Revert "Changed building static declarations"

This reverts commit c86c635a82.
2025-06-13 13:04:03 +00:00 · 2021-03-14 17:24:09 +01:00 · 2021-03-14 17:24:09 +01:00 · 2f872af3e4
commit 2f872af3e4
parent fe1e526b8d
25 changed files with 3014 additions and 3059 deletions
--- a/src/js/game/buildings/analyzer.js
+++ b/src/js/game/buildings/analyzer.js
@ -106,8 +106,9 @@ export class MetaAnalyzerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaAnalyzerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaAnalyzerBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new WiredPinsComponent({
@ -137,47 +138,47 @@ export class MetaAnalyzerBuilding extends MetaBuilding {
                type: enumLogicGateType.analyzer,
            })
        ),
-    ];
+];
-    static silhouetteColors = {
+MetaAnalyzerBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#555759",
-    };
+};
-    static avaibleVariants = {
+MetaAnalyzerBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing),
-    };
+};
-    static overlayMatrices = {
+MetaAnalyzerBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) =>
        generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 0]),
-    };
+};
-    static dimensions = {
+MetaAnalyzerBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static renderPins = {
+MetaAnalyzerBuilding.renderPins = {
    [defaultBuildingVariant]: () => false,
-    };
+};
-    static layerByVariant = {
+MetaAnalyzerBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "wires",
-    };
+};
-    static isRemovable = {
+MetaAnalyzerBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaAnalyzerBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static layerPreview = {
+MetaAnalyzerBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static componentVariations = {
+MetaAnalyzerBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.WiredPins.setSlots([
            {
@ -199,5 +200,4 @@ export class MetaAnalyzerBuilding extends MetaBuilding {
        entity.components.LogicGate.type = enumLogicGateType.analyzer;
    },
-    };
+};
 }
--- a/src/js/game/buildings/balancer.js
+++ b/src/js/game/buildings/balancer.js
@ -119,8 +119,9 @@ export class MetaBalancerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaBalancerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaBalancerBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new ItemAcceptorComponent({
@ -145,16 +146,16 @@ export class MetaBalancerBuilding extends MetaBuilding {
        ),
    entity => entity.addComponent(new BeltUnderlaysComponent({ underlays: [] })),
-    ];
+];
-    static variants = {
+MetaBalancerBuilding.variants = {
    merger: "merger",
    mergerInverse: "merger-inverse",
    splitter: "splitter",
    splitterInverse: "splitter-inverse",
-    };
+};
-    static overlayMatrices = {
+MetaBalancerBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
    [MetaBalancerBuilding.variants.merger]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
@ -164,9 +165,9 @@ export class MetaBalancerBuilding extends MetaBuilding {
        generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
    [MetaBalancerBuilding.variants.splitterInverse]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
-    };
+};
-    static avaibleVariants = {
+MetaBalancerBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_balancer),
    [MetaBalancerBuilding.variants.merger]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_merger),
@ -176,57 +177,57 @@ export class MetaBalancerBuilding extends MetaBuilding {
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_splitter),
    [MetaBalancerBuilding.variants.splitterInverse]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_splitter),
-    };
+};
-    static dimensions = {
+MetaBalancerBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(2, 1),
    [MetaBalancerBuilding.variants.merger]: () => new Vector(1, 1),
    [MetaBalancerBuilding.variants.mergerInverse]: () => new Vector(1, 1),
    [MetaBalancerBuilding.variants.splitter]: () => new Vector(1, 1),
    [MetaBalancerBuilding.variants.splitterInverse]: () => new Vector(1, 1),
-    };
+};
-    static isRemovable = {
+MetaBalancerBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaBalancerBuilding.variants.merger]: () => true,
    [MetaBalancerBuilding.variants.mergerInverse]: () => true,
    [MetaBalancerBuilding.variants.splitter]: () => true,
    [MetaBalancerBuilding.variants.splitterInverse]: () => true,
-    };
+};
-    static isRotateable = {
+MetaBalancerBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaBalancerBuilding.variants.merger]: () => true,
    [MetaBalancerBuilding.variants.mergerInverse]: () => true,
    [MetaBalancerBuilding.variants.splitter]: () => true,
    [MetaBalancerBuilding.variants.splitterInverse]: () => true,
-    };
+};
-    static renderPins = {
+MetaBalancerBuilding.renderPins = {
    [defaultBuildingVariant]: () => null,
    [MetaBalancerBuilding.variants.merger]: () => null,
    [MetaBalancerBuilding.variants.mergerInverse]: () => null,
    [MetaBalancerBuilding.variants.splitter]: () => null,
    [MetaBalancerBuilding.variants.splitterInverse]: () => null,
-    };
+};
-    static layerPreview = {
+MetaBalancerBuilding.layerPreview = {
    [defaultBuildingVariant]: () => null,
    [MetaBalancerBuilding.variants.merger]: () => null,
    [MetaBalancerBuilding.variants.mergerInverse]: () => null,
    [MetaBalancerBuilding.variants.splitter]: () => null,
    [MetaBalancerBuilding.variants.splitterInverse]: () => null,
-    };
+};
-    static layerByVariant = {
+MetaBalancerBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
    [MetaBalancerBuilding.variants.merger]: root => "regular",
    [MetaBalancerBuilding.variants.mergerInverse]: root => "regular",
    [MetaBalancerBuilding.variants.splitter]: root => "regular",
    [MetaBalancerBuilding.variants.splitterInverse]: root => "regular",
-    };
+};
-    static additionalStatistics = {
+MetaBalancerBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
@ -244,9 +245,7 @@ export class MetaBalancerBuilding extends MetaBuilding {
    [MetaBalancerBuilding.variants.merger]: root => [
        [
            T.ingame.buildingPlacement.infoTexts.speed,
-                formatItemsPerSecond(
+            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2),
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2
                ),
        ],
    ],
    /**
@ -256,9 +255,7 @@ export class MetaBalancerBuilding extends MetaBuilding {
    [MetaBalancerBuilding.variants.mergerInverse]: root => [
        [
            T.ingame.buildingPlacement.infoTexts.speed,
-                formatItemsPerSecond(
+            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2),
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2
                ),
        ],
    ],
    /**
@ -268,9 +265,7 @@ export class MetaBalancerBuilding extends MetaBuilding {
    [MetaBalancerBuilding.variants.splitter]: root => [
        [
            T.ingame.buildingPlacement.infoTexts.speed,
-                formatItemsPerSecond(
+            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2),
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2
                ),
        ],
    ],
    /**
@ -280,22 +275,20 @@ export class MetaBalancerBuilding extends MetaBuilding {
    [MetaBalancerBuilding.variants.splitterInverse]: root => [
        [
            T.ingame.buildingPlacement.infoTexts.speed,
-                formatItemsPerSecond(
+            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2),
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2
                ),
        ],
    ],
-    };
+};
-    static silhouetteColors = {
+MetaBalancerBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#555759",
    [MetaBalancerBuilding.variants.merger]: () => "#555759",
    [MetaBalancerBuilding.variants.mergerInverse]: () => "#555759",
    [MetaBalancerBuilding.variants.splitter]: () => "#555759",
    [MetaBalancerBuilding.variants.splitterInverse]: () => "#555759",
-    };
+};
-    static componentVariations = {
+MetaBalancerBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemAcceptor.setSlots([
            {
@ -333,9 +326,7 @@ export class MetaBalancerBuilding extends MetaBuilding {
        entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: enumDirection.top }]);
-            entity.components.BeltUnderlays.underlays = [
+        entity.components.BeltUnderlays.underlays = [{ pos: new Vector(0, 0), direction: enumDirection.top }];
                { pos: new Vector(0, 0), direction: enumDirection.top },
            ];
    },
    [MetaBalancerBuilding.variants.mergerInverse]: (entity, rotationVariant) => {
@ -352,9 +343,7 @@ export class MetaBalancerBuilding extends MetaBuilding {
        entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: enumDirection.top }]);
-            entity.components.BeltUnderlays.underlays = [
+        entity.components.BeltUnderlays.underlays = [{ pos: new Vector(0, 0), direction: enumDirection.top }];
                { pos: new Vector(0, 0), direction: enumDirection.top },
            ];
    },
    [MetaBalancerBuilding.variants.splitter]: (entity, rotationVariant) => {
@ -408,5 +397,4 @@ export class MetaBalancerBuilding extends MetaBuilding {
            ];
        }
    },
-    };
+};
 }
--- a/src/js/game/buildings/belt.js
+++ b/src/js/game/buildings/belt.js
@ -281,84 +281,79 @@ export class MetaBeltBuilding extends MetaBuilding {
            rotationVariant: 0,
        };
    }
 }
-    static setupEntityComponents = [
+MetaBeltBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new BeltComponent({
                direction: enumDirection.top, // updated later
            })
        ),
-    ];
+];
-    static silhouetteColors = {
+
 MetaBeltBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => THEME.map.chunkOverview.beltColor,
-    };
+};
-    static variantToRotation = [enumDirection.top, enumDirection.left, enumDirection.right];
+MetaBeltBuilding.variantToRotation = [enumDirection.top, enumDirection.left, enumDirection.right];
-    static overlayMatrices = {
+MetaBeltBuilding.overlayMatrices = {
-        [enumDirection.top]: (entity, rotationVariant) =>
+    [enumDirection.top]: (entity, rotationVariant) => generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
-            generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
+    [enumDirection.left]: (entity, rotationVariant) => generateMatrixRotations([0, 0, 0, 1, 1, 0, 0, 1, 0]),
-        [enumDirection.left]: (entity, rotationVariant) =>
+    [enumDirection.right]: (entity, rotationVariant) => generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
-            generateMatrixRotations([0, 0, 0, 1, 1, 0, 0, 1, 0]),
+};
        [enumDirection.right]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
    };
-    static placementSounds = {
+MetaBeltBuilding.placementSounds = {
    [defaultBuildingVariant]: () => SOUNDS.placeBelt,
-    };
+};
-    static rotationVariants = [0, 1, 2];
+MetaBeltBuilding.rotationVariants = [0, 1, 2];
-    static avaibleVariants = {
+MetaBeltBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => true,
-    };
+};
-    static dimensions = {
+MetaBeltBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static isRemovable = {
+MetaBeltBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isReplaceable = {
+MetaBeltBuilding.isReplaceable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaBeltBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static renderPins = {
+MetaBeltBuilding.renderPins = {
    [defaultBuildingVariant]: () => null,
-    };
+};
-    static layerPreview = {
+MetaBeltBuilding.layerPreview = {
    [defaultBuildingVariant]: () => null,
-    };
+};
-    static layerByVariant = {
+MetaBeltBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static componentVariations = {
+MetaBeltBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.Belt.direction = MetaBeltBuilding.variantToRotation[rotationVariant];
    },
-    };
+};
-    static additionalStatistics = {
+MetaBeltBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
     */
    [defaultBuildingVariant]: root => [
-            [
+        [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed())],
                T.ingame.buildingPlacement.infoTexts.speed,
                formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed()),
    ],
-        ],
+};
    };
 }
--- a/src/js/game/buildings/comparator.js
+++ b/src/js/game/buildings/comparator.js
@ -107,8 +107,9 @@ export class MetaComparatorBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaComparatorBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaComparatorBuilding.setupEntityComponents = [
    (entity, rotationVariant) =>
        entity.addComponent(
            new WiredPinsComponent({
@ -137,46 +138,46 @@ export class MetaComparatorBuilding extends MetaBuilding {
                type: enumLogicGateType.compare,
            })
        ),
-    ];
+];
-    static overlayMatrices = {
+MetaComparatorBuilding.overlayMatrices = {
    [defaultBuildingVariant]: () => null,
-    };
+};
-    static dimensions = {
+MetaComparatorBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaComparatorBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#823cab",
-    };
+};
-    static isRemovable = {
+MetaComparatorBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaComparatorBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static renderPins = {
+MetaComparatorBuilding.renderPins = {
    [defaultBuildingVariant]: () => false,
-    };
+};
-    static layerPreview = {
+MetaComparatorBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static avaibleVariants = {
+MetaComparatorBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing),
-    };
+};
-    static layerByVariant = {
+MetaComparatorBuilding.layerByVariant = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static componentVariations = {
+MetaComparatorBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.WiredPins.setSlots([
            {
@ -198,5 +199,4 @@ export class MetaComparatorBuilding extends MetaBuilding {
        entity.components.LogicGate.type = enumLogicGateType.compare;
    },
-    };
+};
 }
--- a/src/js/game/buildings/constant_signal.js
+++ b/src/js/game/buildings/constant_signal.js
@ -107,8 +107,9 @@ export class MetaConstantSignalBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaConstantSignalBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaConstantSignalBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new WiredPinsComponent({
@ -122,47 +123,47 @@ export class MetaConstantSignalBuilding extends MetaBuilding {
            })
        ),
    entity => entity.addComponent(new ConstantSignalComponent({})),
-    ];
+];
-    static overlayMatrices = {
+MetaConstantSignalBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 1, 1, 1, 1, 1, 1]),
-    };
+};
-    static dimensions = {
+MetaConstantSignalBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaConstantSignalBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#2b84fd",
-    };
+};
-    static isRemovable = {
+MetaConstantSignalBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaConstantSignalBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static renderPins = {
+MetaConstantSignalBuilding.renderPins = {
    [defaultBuildingVariant]: () => false,
-    };
+};
-    static avaibleVariants = {
+MetaConstantSignalBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_constant_signal),
-    };
+};
-    static layerByVariant = {
+MetaConstantSignalBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "wires",
-    };
+};
-    static layerPreview = {
+MetaConstantSignalBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static componentVariations = {
+MetaConstantSignalBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.WiredPins.setSlots([
            {
@ -172,5 +173,4 @@ export class MetaConstantSignalBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/cutter.js
+++ b/src/js/game/buildings/cutter.js
@ -79,8 +79,8 @@ export class MetaCutterBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaCutterBuilding.componentVariations[variant](entity, rotationVariant);
    }
-
+}
-    static setupEntityComponents = [
+MetaCutterBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new ItemProcessorComponent({
@ -101,55 +101,55 @@ export class MetaCutterBuilding extends MetaBuilding {
                ],
            })
        ),
-    ];
+];
-    static variants = {
+MetaCutterBuilding.variants = {
    quad: "quad",
-    };
+};
-    static overlayMatrices = {
+MetaCutterBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
    [MetaCutterBuilding.variants.quad]: (entity, rotationVariant) => null,
-    };
+};
-    static dimensions = {
+MetaCutterBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(2, 1),
    [MetaCutterBuilding.variants.quad]: () => new Vector(4, 1),
-    };
+};
-    static silhouetteColors = {
+MetaCutterBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#7dcda2",
    [MetaCutterBuilding.variants.quad]: () => "#7dcda2",
-    };
+};
-    static avaibleVariants = {
+MetaCutterBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_and_trash),
    [MetaCutterBuilding.variants.quad]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_quad),
-    };
+};
-    static layerByVariant = {
+MetaCutterBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
    [MetaCutterBuilding.variants.quad]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaCutterBuilding.layerPreview = {
    [defaultBuildingVariant]: () => null,
    [MetaCutterBuilding.variants.quad]: () => null,
-    };
+};
-    static isRemovable = {
+MetaCutterBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaCutterBuilding.variants.quad]: () => true,
-    };
+};
-    static isRotateable = {
+MetaCutterBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaCutterBuilding.variants.quad]: () => true,
-    };
+};
-    static additionalStatistics = {
+MetaCutterBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
@ -168,14 +168,12 @@ export class MetaCutterBuilding extends MetaBuilding {
    [MetaCutterBuilding.variants.quad]: root => [
        [
            T.ingame.buildingPlacement.infoTexts.speed,
-                formatItemsPerSecond(
+            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.cutterQuad) / 2),
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.cutterQuad) / 2
                ),
        ],
    ],
-    };
+};
-    static componentVariations = {
+MetaCutterBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemEjector.setSlots([
            { pos: new Vector(0, 0), direction: enumDirection.top },
@ -194,5 +192,4 @@ export class MetaCutterBuilding extends MetaBuilding {
        ]);
        entity.components.ItemProcessor.type = enumItemProcessorTypes.cutterQuad;
    },
-    };
+};
 }
--- a/src/js/game/buildings/display.js
+++ b/src/js/game/buildings/display.js
@ -94,8 +94,9 @@ export class MetaDisplayBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaDisplayBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaDisplayBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new WiredPinsComponent({
@ -109,45 +110,45 @@ export class MetaDisplayBuilding extends MetaBuilding {
            })
        ),
    entity => entity.addComponent(new DisplayComponent()),
-    ];
+];
-    static overlayMatrices = {
+MetaDisplayBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
-    };
+};
-    static dimensions = {
+MetaDisplayBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaDisplayBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#aaaaaa",
-    };
+};
-    static isRemovable = {
+MetaDisplayBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaDisplayBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static avaibleVariants = {
+MetaDisplayBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_display),
-    };
+};
-    static layerByVariant = {
+MetaDisplayBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaDisplayBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static renderPins = {
+MetaDisplayBuilding.renderPins = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static componentVariations = {
+MetaDisplayBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.WiredPins.setSlots([
            {
@ -157,5 +158,4 @@ export class MetaDisplayBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/filter.js
+++ b/src/js/game/buildings/filter.js
@ -119,8 +119,9 @@ export class MetaFilterBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaFilterBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaFilterBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new WiredPinsComponent({
@ -163,54 +164,51 @@ export class MetaFilterBuilding extends MetaBuilding {
        ),
    entity => entity.addComponent(new FilterComponent()),
-    ];
+];
-    static overlayMatrices = {
+MetaFilterBuilding.overlayMatrices = {
    [defaultBuildingVariant]: () => null,
-    };
+};
-    static dimensions = {
+MetaFilterBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(2, 1),
-    };
+};
-    static silhouetteColors = {
+MetaFilterBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#c45c2e",
-    };
+};
-    static isRemovable = {
+MetaFilterBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaFilterBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static avaibleVariants = {
+MetaFilterBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_filter),
-    };
+};
-    static layerByVariant = {
+MetaFilterBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaFilterBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static additionalStatistics = {
+MetaFilterBuilding.additionalStatistics = {
    [defaultBuildingVariant]: root => [
-            [
+        [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed())],
                T.ingame.buildingPlacement.infoTexts.speed,
                formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed()),
    ],
-        ],
+};
    };
-    static renderPins = {
+MetaFilterBuilding.renderPins = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static componentVariations = {
+MetaFilterBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.WiredPins.setSlots([
            {
@ -238,5 +236,4 @@ export class MetaFilterBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/hub.js
+++ b/src/js/game/buildings/hub.js
@ -108,10 +108,11 @@ export class MetaHubBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaHubBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static canPipet = () => false;
+MetaHubBuilding.canPipet = () => false;
-    static setupEntityComponents = [
+MetaHubBuilding.setupEntityComponents = [
    entity => entity.addComponent(new HubComponent()),
    entity =>
        entity.addComponent(
@ -211,41 +212,41 @@ export class MetaHubBuilding extends MetaBuilding {
                ],
            })
        ),
-    ];
+];
-    static silhouetteColors = {
+MetaHubBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#eb5555",
-    };
+};
-    static dimensions = {
+MetaHubBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(4, 4),
-    };
+};
-    static isRemovable = {
+MetaHubBuilding.isRemovable = {
    [defaultBuildingVariant]: () => false,
-    };
+};
-    static isRotateable = {
+MetaHubBuilding.isRotateable = {
    [defaultBuildingVariant]: () => false,
-    };
+};
-    static overlayMatrices = {
+MetaHubBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
-    };
+};
-    static avaibleVariants = {
+MetaHubBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => false,
-    };
+};
-    static layerByVariant = {
+MetaHubBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaHubBuilding.layerPreview = {
    [defaultBuildingVariant]: () => false,
-    };
+};
-    static componentVariations = {
+MetaHubBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemProcessor.inputsPerCharge = 1;
@ -332,5 +333,4 @@ export class MetaHubBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/item_producer.js
+++ b/src/js/game/buildings/item_producer.js
@ -87,8 +87,9 @@ export class MetaItemProducerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaItemProducerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaItemProducerBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new ItemEjectorComponent({
@ -109,41 +110,41 @@ export class MetaItemProducerBuilding extends MetaBuilding {
        ),
    entity => entity.addComponent(new ItemProducerComponent()),
-    ];
+];
-    static overlayMatrices = {
+MetaItemProducerBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
-    };
+};
-    static dimensions = {
+MetaItemProducerBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaItemProducerBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#b37dcd",
-    };
+};
-    static isRemovable = {
+MetaItemProducerBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaItemProducerBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static avaibleVariants = {
+MetaItemProducerBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => true,
-    };
+};
-    static layerByVariant = {
+MetaItemProducerBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaItemProducerBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static componentVariations = {
+MetaItemProducerBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: enumDirection.top }]);
@ -155,5 +156,4 @@ export class MetaItemProducerBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/lever.js
+++ b/src/js/game/buildings/lever.js
@ -110,8 +110,9 @@ export class MetaLeverBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaLeverBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaLeverBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new WiredPinsComponent({
@ -125,46 +126,46 @@ export class MetaLeverBuilding extends MetaBuilding {
            })
        ),
    entity => entity.addComponent(new LeverComponent({})),
-    ];
+];
-    static overlayMatrices = {
+MetaLeverBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
-    };
+};
-    static dimensions = {
+MetaLeverBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaLeverBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#1a678b",
-    };
+};
-    static isRemovable = {
+MetaLeverBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaLeverBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static avaibleVariants = {
+MetaLeverBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers),
-    };
+};
-    static layerByVariant = {
+MetaLeverBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaLeverBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static renderPins = {
+MetaLeverBuilding.renderPins = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static componentVariations = {
+MetaLeverBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.WiredPins.setSlots([
            {
@ -174,5 +175,4 @@ export class MetaLeverBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/logic_gate.js
+++ b/src/js/game/buildings/logic_gate.js
@ -107,8 +107,8 @@ export class MetaLogicGateBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaLogicGateBuilding.componentVariations[variant](entity, rotationVariant);
    }
-
+}
-    static setupEntityComponents = [
+MetaLogicGateBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new WiredPinsComponent({
@ -116,15 +116,15 @@ export class MetaLogicGateBuilding extends MetaBuilding {
            })
        ),
    entity => entity.addComponent(new LogicGateComponent({})),
-    ];
+];
-    static variants = {
+MetaLogicGateBuilding.variants = {
    not: "not",
    xor: "xor",
    or: "or",
-    };
+};
-    static overlayMatrices = {
+MetaLogicGateBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 1]),
    [MetaLogicGateBuilding.variants.xor]: (entity, rotationVariant) =>
@ -133,68 +133,67 @@ export class MetaLogicGateBuilding extends MetaBuilding {
        generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 1]),
    [MetaLogicGateBuilding.variants.not]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
-    };
+};
-    static dimensions = {
+MetaLogicGateBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
    [MetaLogicGateBuilding.variants.xor]: () => new Vector(1, 1),
    [MetaLogicGateBuilding.variants.or]: () => new Vector(1, 1),
    [MetaLogicGateBuilding.variants.not]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaLogicGateBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#f48d41",
    [MetaLogicGateBuilding.variants.xor]: () => "#f4a241",
    [MetaLogicGateBuilding.variants.or]: () => "#f4d041",
    [MetaLogicGateBuilding.variants.not]: () => "#f44184",
-    };
+};
-    static isRemovable = {
+MetaLogicGateBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaLogicGateBuilding.variants.xor]: () => true,
    [MetaLogicGateBuilding.variants.or]: () => true,
    [MetaLogicGateBuilding.variants.not]: () => true,
-    };
+};
-    static isRotateable = {
+MetaLogicGateBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaLogicGateBuilding.variants.xor]: () => true,
    [MetaLogicGateBuilding.variants.or]: () => true,
    [MetaLogicGateBuilding.variants.not]: () => true,
-    };
+};
-    static avaibleVariants = {
+MetaLogicGateBuilding.avaibleVariants = {
-        [defaultBuildingVariant]: root =>
+    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
    [MetaLogicGateBuilding.variants.xor]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
    [MetaLogicGateBuilding.variants.or]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
    [MetaLogicGateBuilding.variants.not]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
-    };
+};
-    static layerByVariant = {
+MetaLogicGateBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "wires",
    [MetaLogicGateBuilding.variants.xor]: root => "wires",
    [MetaLogicGateBuilding.variants.or]: root => "wires",
    [MetaLogicGateBuilding.variants.not]: root => "wires",
-    };
+};
-    static renderPins = {
+MetaLogicGateBuilding.renderPins = {
    [defaultBuildingVariant]: () => false,
    [MetaLogicGateBuilding.variants.xor]: () => false,
    [MetaLogicGateBuilding.variants.or]: () => false,
    [MetaLogicGateBuilding.variants.not]: () => false,
-    };
+};
-    static layerPreview = {
+MetaLogicGateBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
    [MetaLogicGateBuilding.variants.xor]: () => "wires",
    [MetaLogicGateBuilding.variants.or]: () => "wires",
    [MetaLogicGateBuilding.variants.not]: () => "wires",
-    };
+};
-    static componentVariations = {
+MetaLogicGateBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.WiredPins.setSlots([
            {
@ -276,5 +275,4 @@ export class MetaLogicGateBuilding extends MetaBuilding {
        entity.components.LogicGate.type = enumLogicGateType.not;
    },
-    };
+};
 }
--- a/src/js/game/buildings/miner.js
+++ b/src/js/game/buildings/miner.js
@ -103,8 +103,9 @@ export class MetaMinerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaMinerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaMinerBuilding.setupEntityComponents = [
    entity => entity.addComponent(new MinerComponent({})),
    entity =>
        entity.addComponent(
@ -112,75 +113,68 @@ export class MetaMinerBuilding extends MetaBuilding {
                slots: [{ pos: new Vector(0, 0), direction: enumDirection.top }],
            })
        ),
-    ];
+];
-
+MetaMinerBuilding.variants = {
    static variants = {
    chainable: "chainable",
-    };
+};
-    static silhouetteColors = {
+MetaMinerBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#b37dcd",
    [MetaMinerBuilding.variants.chainable]: () => "#b37dcd",
-    };
+};
-    static dimensions = {
+MetaMinerBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
    [MetaMinerBuilding.variants.chainable]: () => new Vector(1, 1),
-    };
+};
-    static isRemovable = {
+MetaMinerBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaMinerBuilding.variants.chainable]: () => true,
-    };
+};
-    static isRotateable = {
+MetaMinerBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaMinerBuilding.variants.chainable]: () => true,
-    };
+};
-    static layerByVariant = {
+MetaMinerBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
    [MetaMinerBuilding.variants.chainable]: root => "regular",
-    };
+};
-    static overlayMatrices = {
+MetaMinerBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) =>
        generateMatrixRotations([1, 1, 1, 1, 0, 1, 1, 1, 1]),
    [MetaMinerBuilding.variants.chainable]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 1, 1, 1, 1, 1, 1]),
-    };
+};
-    static avaibleVariants = {
+MetaMinerBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        !root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_miner_chainable),
    [MetaMinerBuilding.variants.chainable]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_miner_chainable),
-    };
+};
-    static additionalStatistics = {
+MetaMinerBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
     */
    [defaultBuildingVariant]: root => [
-            [
+        [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(root.hubGoals.getMinerBaseSpeed())],
                T.ingame.buildingPlacement.infoTexts.speed,
                formatItemsPerSecond(root.hubGoals.getMinerBaseSpeed()),
            ],
    ],
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
     */
    [MetaMinerBuilding.variants.chainable]: root => [
-            [
+        [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(root.hubGoals.getMinerBaseSpeed())],
                T.ingame.buildingPlacement.infoTexts.speed,
                formatItemsPerSecond(root.hubGoals.getMinerBaseSpeed()),
    ],
-        ],
+};
    };
-    static componentVariations = {
+MetaMinerBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.Miner.chainable = false;
    },
@ -188,5 +182,4 @@ export class MetaMinerBuilding extends MetaBuilding {
    [MetaMinerBuilding.variants.chainable]: (entity, rotationVariant) => {
        entity.components.Miner.chainable = true;
    },
-    };
+};
 }
--- a/src/js/game/buildings/mixer.js
+++ b/src/js/game/buildings/mixer.js
@ -104,8 +104,9 @@ export class MetaMixerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaMixerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaMixerBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new ItemProcessorComponent({
@ -137,37 +138,37 @@ export class MetaMixerBuilding extends MetaBuilding {
                ],
            })
        ),
-    ];
+];
-    static silhouetteColors = {
+MetaMixerBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#cdbb7d",
-    };
+};
-    static dimensions = {
+MetaMixerBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(2, 1),
-    };
+};
-    static isRemovable = {
+MetaMixerBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaMixerBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static layerByVariant = {
+MetaMixerBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static overlayMatrices = {
+MetaMixerBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
-    };
+};
-    static avaibleVariants = {
+MetaMixerBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_mixer),
-    };
+};
-    static additionalStatistics = {
+MetaMixerBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
@ -178,9 +179,9 @@ export class MetaMixerBuilding extends MetaBuilding {
            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.mixer)),
        ],
    ],
-    };
+};
-    static componentVariations = {
+MetaMixerBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemProcessor.inputsPerCharge = 2;
@ -201,5 +202,4 @@ export class MetaMixerBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/painter.js
+++ b/src/js/game/buildings/painter.js
@ -109,8 +109,9 @@ export class MetaPainterBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaPainterBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaPainterBuilding.setupEntityComponents = [
    entity => entity.addComponent(new ItemProcessorComponent({})),
    entity =>
        entity.addComponent(
@ -135,57 +136,57 @@ export class MetaPainterBuilding extends MetaBuilding {
                ],
            })
        ),
-    ];
+];
-    static variants = {
+MetaPainterBuilding.variants = {
    mirrored: "mirrored",
    double: "double",
    quad: "quad",
-    };
+};
-    static silhouetteColors = {
+MetaPainterBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#cd9b7d",
    [MetaPainterBuilding.variants.mirrored]: () => "#cd9b7d",
    [MetaPainterBuilding.variants.double]: () => "#cd9b7d",
    [MetaPainterBuilding.variants.quad]: () => "#cd9b7d",
-    };
+};
-    static dimensions = {
+MetaPainterBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(2, 1),
    [MetaPainterBuilding.variants.mirrored]: () => new Vector(2, 1),
    [MetaPainterBuilding.variants.double]: () => new Vector(2, 2),
    [MetaPainterBuilding.variants.quad]: () => new Vector(4, 1),
-    };
+};
-    static isRemovable = {
+MetaPainterBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaPainterBuilding.variants.mirrored]: () => true,
    [MetaPainterBuilding.variants.double]: () => true,
    [MetaPainterBuilding.variants.quad]: () => true,
-    };
+};
-    static isRotateable = {
+MetaPainterBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaPainterBuilding.variants.mirrored]: () => true,
    [MetaPainterBuilding.variants.double]: () => true,
    [MetaPainterBuilding.variants.quad]: () => true,
-    };
+};
-    static layerByVariant = {
+MetaPainterBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
    [MetaPainterBuilding.variants.mirrored]: root => "regular",
    [MetaPainterBuilding.variants.double]: root => "regular",
    [MetaPainterBuilding.variants.quad]: root => "regular",
-    };
+};
-    static overlayMatrices = {
+MetaPainterBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
    [MetaPainterBuilding.variants.mirrored]: (entity, rotationVariant) => null,
    [MetaPainterBuilding.variants.double]: (entity, rotationVariant) => null,
    [MetaPainterBuilding.variants.quad]: (entity, rotationVariant) => null,
-    };
+};
-    static avaibleVariants = {
+MetaPainterBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_painter),
    [MetaPainterBuilding.variants.mirrored]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_painter),
@ -193,9 +194,9 @@ export class MetaPainterBuilding extends MetaBuilding {
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_painter_double),
    [MetaPainterBuilding.variants.quad]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers),
-    };
+};
-    static additionalStatistics = {
+MetaPainterBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
@ -223,9 +224,7 @@ export class MetaPainterBuilding extends MetaBuilding {
    [MetaPainterBuilding.variants.double]: root => [
        [
            T.ingame.buildingPlacement.infoTexts.speed,
-                formatItemsPerSecond(
+            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.painterDouble)),
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.painterDouble)
                ),
        ],
    ],
    /**
@ -238,9 +237,9 @@ export class MetaPainterBuilding extends MetaBuilding {
            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.painterQuad)),
        ],
    ],
-    };
+};
-    static componentVariations = {
+MetaPainterBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        if (entity.components.WiredPins) {
            entity.removeComponent(WiredPinsComponent);
@ -259,9 +258,7 @@ export class MetaPainterBuilding extends MetaBuilding {
            },
        ]);
-            entity.components.ItemEjector.setSlots([
+        entity.components.ItemEjector.setSlots([{ pos: new Vector(1, 0), direction: enumDirection.right }]);
                { pos: new Vector(1, 0), direction: enumDirection.right },
            ]);
        entity.components.ItemProcessor.type = enumItemProcessorTypes.painter;
        entity.components.ItemProcessor.processingRequirement = null;
@ -286,9 +283,7 @@ export class MetaPainterBuilding extends MetaBuilding {
            },
        ]);
-            entity.components.ItemEjector.setSlots([
+        entity.components.ItemEjector.setSlots([{ pos: new Vector(1, 0), direction: enumDirection.right }]);
                { pos: new Vector(1, 0), direction: enumDirection.right },
            ]);
        entity.components.ItemProcessor.type = enumItemProcessorTypes.painter;
        entity.components.ItemProcessor.processingRequirement = null;
@ -318,9 +313,7 @@ export class MetaPainterBuilding extends MetaBuilding {
            },
        ]);
-            entity.components.ItemEjector.setSlots([
+        entity.components.ItemEjector.setSlots([{ pos: new Vector(1, 0), direction: enumDirection.right }]);
                { pos: new Vector(1, 0), direction: enumDirection.right },
            ]);
        entity.components.ItemProcessor.type = enumItemProcessorTypes.painterDouble;
        entity.components.ItemProcessor.processingRequirement = null;
@ -389,5 +382,4 @@ export class MetaPainterBuilding extends MetaBuilding {
        entity.components.ItemProcessor.processingRequirement = enumItemProcessorRequirements.painterQuad;
        entity.components.ItemProcessor.inputsPerCharge = 5;
    },
-    };
+};
 }
--- a/src/js/game/buildings/reader.js
+++ b/src/js/game/buildings/reader.js
@ -121,8 +121,9 @@ export class MetaReaderBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaReaderBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaReaderBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new WiredPinsComponent({
@ -181,56 +182,52 @@ export class MetaReaderBuilding extends MetaBuilding {
            })
        ),
    entity => entity.addComponent(new BeltReaderComponent()),
-    ];
+];
-    static dimensions = {
+MetaReaderBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaReaderBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#25fff2",
-    };
+};
-    static isRemovable = {
+MetaReaderBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaReaderBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static additionalStatistics = {
+MetaReaderBuilding.additionalStatistics = {
    [defaultBuildingVariant]: root => [
-            [
+        [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed())],
                T.ingame.buildingPlacement.infoTexts.speed,
                formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed()),
    ],
-        ],
+};
    };
-    static overlayMatrices = {
+MetaReaderBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
-    };
+};
-    static avaibleVariants = {
+MetaReaderBuilding.avaibleVariants = {
-        [defaultBuildingVariant]: root =>
+    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_belt_reader),
-            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_belt_reader),
+};
    };
-    static layerByVariant = {
+MetaReaderBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaReaderBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static renderPins = {
+MetaReaderBuilding.renderPins = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static componentVariations = {
+MetaReaderBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemAcceptor.setSlots([
            {
@ -257,5 +254,4 @@ export class MetaReaderBuilding extends MetaBuilding {
            },
        ];
    },
-    };
+};
 }
--- a/src/js/game/buildings/rotater.js
+++ b/src/js/game/buildings/rotater.js
@ -118,8 +118,9 @@ export class MetaRotaterBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaRotaterBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaRotaterBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new ItemProcessorComponent({
@ -145,73 +146,73 @@ export class MetaRotaterBuilding extends MetaBuilding {
                ],
            })
        ),
-    ];
+];
-    static variants = {
+MetaRotaterBuilding.variants = {
    ccw: "ccw",
    rotate180: "rotate180",
-    };
+};
-    static dimensions = {
+MetaRotaterBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
    [MetaRotaterBuilding.variants.ccw]: () => new Vector(1, 1),
    [MetaRotaterBuilding.variants.rotate180]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaRotaterBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#7dc6cd",
    [MetaRotaterBuilding.variants.ccw]: () => "#7dc6cd",
    [MetaRotaterBuilding.variants.rotate180]: () => "#7dc6cd",
-    };
+};
-    static overlayMatrices = {
+MetaRotaterBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 1, 1, 1, 0, 0, 1, 1]),
    [MetaRotaterBuilding.variants.ccw]: (entity, rotationVariant) =>
        generateMatrixRotations([1, 1, 0, 0, 1, 1, 1, 1, 0]),
    [MetaRotaterBuilding.variants.rotate180]: (entity, rotationVariant) =>
        generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 1]),
-    };
+};
-    static avaibleVariants = {
+MetaRotaterBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotater),
    [MetaRotaterBuilding.variants.ccw]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotater_ccw),
    [MetaRotaterBuilding.variants.rotate180]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotater_180),
-    };
+};
-    static isRemovable = {
+MetaRotaterBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaRotaterBuilding.variants.ccw]: () => true,
    [MetaRotaterBuilding.variants.rotate180]: () => true,
-    };
+};
-    static isRotateable = {
+MetaRotaterBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaRotaterBuilding.variants.ccw]: () => true,
    [MetaRotaterBuilding.variants.rotate180]: () => true,
-    };
+};
-    static layerByVariant = {
+MetaRotaterBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
    [MetaRotaterBuilding.variants.ccw]: root => "regular",
    [MetaRotaterBuilding.variants.rotate180]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaRotaterBuilding.layerPreview = {
    [defaultBuildingVariant]: () => null,
    [MetaRotaterBuilding.variants.ccw]: () => null,
    [MetaRotaterBuilding.variants.rotate180]: () => null,
-    };
+};
-    static renderPins = {
+MetaRotaterBuilding.renderPins = {
    [defaultBuildingVariant]: () => null,
    [MetaRotaterBuilding.variants.ccw]: () => null,
    [MetaRotaterBuilding.variants.rotate180]: () => null,
-    };
+};
-    static additionalStatistics = {
+MetaRotaterBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
@ -242,9 +243,9 @@ export class MetaRotaterBuilding extends MetaBuilding {
            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.rotater180)),
        ],
    ],
-    };
+};
-    static componentVariations = {
+MetaRotaterBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemProcessor.type = enumItemProcessorTypes.rotater;
    },
@ -256,5 +257,4 @@ export class MetaRotaterBuilding extends MetaBuilding {
    [MetaRotaterBuilding.variants.rotate180]: (entity, rotationVariant) => {
        entity.components.ItemProcessor.type = enumItemProcessorTypes.rotater180;
    },
-    };
+};
 }
--- a/src/js/game/buildings/stacker.js
+++ b/src/js/game/buildings/stacker.js
@ -118,8 +118,9 @@ export class MetaStackerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaStackerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaStackerBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new ItemProcessorComponent({
@ -150,45 +151,45 @@ export class MetaStackerBuilding extends MetaBuilding {
                ],
            })
        ),
-    ];
+];
-    static dimensions = {
+MetaStackerBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(2, 1),
-    };
+};
-    static silhouetteColors = {
+MetaStackerBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#9fcd7d",
-    };
+};
-    static overlayMatrices = {
+MetaStackerBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
-    };
+};
-    static avaibleVariants = {
+MetaStackerBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_stacker),
-    };
+};
-    static isRemovable = {
+MetaStackerBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaStackerBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static layerByVariant = {
+MetaStackerBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaStackerBuilding.layerPreview = {
    [defaultBuildingVariant]: () => null,
-    };
+};
-    static renderPins = {
+MetaStackerBuilding.renderPins = {
    [defaultBuildingVariant]: () => null,
-    };
+};
-    static additionalStatistics = {
+MetaStackerBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
@ -199,9 +200,9 @@ export class MetaStackerBuilding extends MetaBuilding {
            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.stacker)),
        ],
    ],
-    };
+};
-    static componentVariations = {
+MetaStackerBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemProcessor.inputsPerCharge = 2;
@ -222,5 +223,4 @@ export class MetaStackerBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/storage.js
+++ b/src/js/game/buildings/storage.js
@ -121,8 +121,9 @@ export class MetaStorageBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaStorageBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaStorageBuilding.setupEntityComponents = [
    entity =>
        // Required, since the item processor needs this.
        entity.addComponent(
@ -177,25 +178,25 @@ export class MetaStorageBuilding extends MetaBuilding {
                ],
            })
        ),
-    ];
+];
-    static dimensions = {
+MetaStorageBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(2, 2),
-    };
+};
-    static silhouetteColors = {
+MetaStorageBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#bbdf6d",
-    };
+};
-    static isRemovable = {
+MetaStorageBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaStorageBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static additionalStatistics = {
+MetaStorageBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
@ -203,29 +204,29 @@ export class MetaStorageBuilding extends MetaBuilding {
    [defaultBuildingVariant]: root => [
        [T.ingame.buildingPlacement.infoTexts.storage, formatBigNumber(storageSize)],
    ],
-    };
+};
-    static overlayMatrices = {
+MetaStorageBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
-    };
+};
-    static avaibleVariants = {
+MetaStorageBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_storage),
-    };
+};
-    static layerByVariant = {
+MetaStorageBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaStorageBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static renderPins = {
+MetaStorageBuilding.renderPins = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static componentVariations = {
+MetaStorageBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemEjector.setSlots([
            {
@ -261,5 +262,4 @@ export class MetaStorageBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/transistor.js
+++ b/src/js/game/buildings/transistor.js
@ -107,8 +107,9 @@ export class MetaTransistorBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaTransistorBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaTransistorBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new WiredPinsComponent({
@ -137,62 +138,61 @@ export class MetaTransistorBuilding extends MetaBuilding {
                type: enumLogicGateType.transistor,
            })
        ),
-    ];
+];
-    static variants = {
+MetaTransistorBuilding.variants = {
    mirrored: "mirrored",
-    };
+};
-    static overlayMatrices = {
+MetaTransistorBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
    [MetaTransistorBuilding.variants.mirrored]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
-    };
+};
-    static dimensions = {
+MetaTransistorBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
    [MetaTransistorBuilding.variants.mirrored]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaTransistorBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#823cab",
    [MetaTransistorBuilding.variants.mirrored]: () => "#823cab",
-    };
+};
-    static isRemovable = {
+MetaTransistorBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaTransistorBuilding.variants.mirrored]: () => true,
-    };
+};
-    static isRotateable = {
+MetaTransistorBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaTransistorBuilding.variants.mirrored]: () => true,
-    };
+};
-    static renderPins = {
+MetaTransistorBuilding.renderPins = {
    [defaultBuildingVariant]: () => false,
    [MetaTransistorBuilding.variants.mirrored]: () => false,
-    };
+};
-    static layerPreview = {
+MetaTransistorBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
    [MetaTransistorBuilding.variants.mirrored]: () => "wires",
-    };
+};
-    static avaibleVariants = {
+MetaTransistorBuilding.avaibleVariants = {
-        [defaultBuildingVariant]: root =>
+    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
    [MetaTransistorBuilding.variants.mirrored]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
-    };
+};
-    static layerByVariant = {
+MetaTransistorBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "wires",
    [MetaTransistorBuilding.variants.mirrored]: root => "wires",
-    };
+};
-    static componentVariations = {
+MetaTransistorBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.WiredPins.slots[1].direction = enumDirection.left;
    },
@ -200,5 +200,4 @@ export class MetaTransistorBuilding extends MetaBuilding {
    [MetaTransistorBuilding.variants.mirrored]: (entity, rotationVariant) => {
        entity.components.WiredPins.slots[1].direction = enumDirection.right;
    },
-    };
+};
 }
--- a/src/js/game/buildings/trash.js
+++ b/src/js/game/buildings/trash.js
@ -118,7 +118,7 @@ export class MetaTrashBuilding extends MetaBuilding {
     * @param {Entity} entity
     */
    setupEntityComponents(entity) {
-        MetaTrashBuilding.setupEntityComponents.forEach(func => func(entity));
+        MetaTrashBuilding.setupEntityComponents.forEach(func => func.bind(this)(entity));
    }
    /**
@ -129,8 +129,9 @@ export class MetaTrashBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaTrashBuilding.componentVariations[variant].bind(this)(entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaTrashBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new ItemAcceptorComponent({
@ -154,51 +155,52 @@ export class MetaTrashBuilding extends MetaBuilding {
                processorType: enumItemProcessorTypes.trash,
            })
        ),
    function (entity) {
        // @ts-ignore
        this.addAchievementReceiver(entity);
    },
-    ];
+];
-    static overlayMatrices = {
+MetaTrashBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) =>
        generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 1]),
-    };
+};
-    static dimensions = {
+MetaTrashBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaTrashBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#ed1d5d",
-    };
+};
-    static isRemovable = {
+MetaTrashBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaTrashBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static renderPins = {
+MetaTrashBuilding.renderPins = {
    [defaultBuildingVariant]: () => false,
-    };
+};
-    static layerByVariant = {
+MetaTrashBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
-    };
+};
-    static layerPreview = {
+MetaTrashBuilding.layerPreview = {
    [defaultBuildingVariant]: () => null,
-    };
+};
-    static avaibleVariants = {
+MetaTrashBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_and_trash),
-    };
+};
-    static componentVariations = {
+MetaTrashBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.ItemAcceptor.setSlots([
            {
@ -216,5 +218,4 @@ export class MetaTrashBuilding extends MetaBuilding {
        entity.components.ItemProcessor.type = enumItemProcessorTypes.trash;
    },
-    };
+};
 }
--- a/src/js/game/buildings/underground_belt.js
+++ b/src/js/game/buildings/underground_belt.js
@ -234,8 +234,9 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
        entity.components.UndergroundBelt.tier = MetaUndergroundBeltBuilding.variantToTier[variant];
        MetaUndergroundBeltBuilding.componentVariationsByRotation[mode](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaUndergroundBeltBuilding.setupEntityComponents = [
    // Required, since the item processor needs this.
    entity =>
        entity.addComponent(
@ -250,67 +251,70 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
                slots: [],
            })
        ),
-    ];
+];
-    static rotationVariants = [0, 1];
+MetaUndergroundBeltBuilding.rotationVariants = [0, 1];
-    static variants = {
+MetaUndergroundBeltBuilding.variants = {
    tier2: "tier2",
-    };
+};
-    static overlayMatricesByRotation = [
+MetaUndergroundBeltBuilding.overlayMatricesByRotation = [
    // Sender
    (entity, rotationVariant) => generateMatrixRotations([1, 1, 1, 0, 1, 0, 0, 1, 0]),
    // Receiver
    (entity, rotationVariant) => generateMatrixRotations([0, 1, 0, 0, 1, 0, 1, 1, 1]),
-    ];
+];
-    static rotationVariantToMode = [enumUndergroundBeltMode.sender, enumUndergroundBeltMode.receiver];
+MetaUndergroundBeltBuilding.rotationVariantToMode = [
    enumUndergroundBeltMode.sender,
    enumUndergroundBeltMode.receiver,
 ];
-    static variantToTier = {
+MetaUndergroundBeltBuilding.variantToTier = {
    [defaultBuildingVariant]: 0,
    [MetaUndergroundBeltBuilding.variants.tier2]: 1,
-    };
+};
-    static dimensions = {
+MetaUndergroundBeltBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
    [MetaUndergroundBeltBuilding.variants.tier2]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColorsByRotation = [() => "#6d9dff", () => "#71ff9c"];
+MetaUndergroundBeltBuilding.silhouetteColorsByRotation = [() => "#6d9dff", () => "#71ff9c"];
-    static isRemovable = {
+MetaUndergroundBeltBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaUndergroundBeltBuilding.variants.tier2]: () => true,
-    };
+};
-    static isRotateable = {
+MetaUndergroundBeltBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaUndergroundBeltBuilding.variants.tier2]: () => true,
-    };
+};
-    static renderPins = {
+MetaUndergroundBeltBuilding.renderPins = {
    [defaultBuildingVariant]: () => null,
    [MetaUndergroundBeltBuilding.variants.tier2]: () => null,
-    };
+};
-    static layerPreview = {
+MetaUndergroundBeltBuilding.layerPreview = {
    [defaultBuildingVariant]: () => null,
    [MetaUndergroundBeltBuilding.variants.tier2]: () => null,
-    };
+};
-    static avaibleVariants = {
+MetaUndergroundBeltBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_tunnel),
    [MetaUndergroundBeltBuilding.variants.tier2]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_underground_belt_tier_2),
-    };
+};
-    static layerByVariant = {
+MetaUndergroundBeltBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "regular",
    [MetaUndergroundBeltBuilding.variants.tier2]: root => "regular",
-    };
+};
-    static additionalStatistics = {
+MetaUndergroundBeltBuilding.additionalStatistics = {
    /**
     * @param {*} root
     * @returns {Array<[string, string]>}
@ -344,9 +348,9 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
            [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)],
        ];
    },
-    };
+};
-    static componentVariationsByRotation = {
+MetaUndergroundBeltBuilding.componentVariationsByRotation = {
    [enumUndergroundBeltMode.sender]: (entity, rotationVariant) => {
        entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.sender;
        entity.components.ItemEjector.setSlots([]);
@ -368,5 +372,4 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
            },
        ]);
    },
-    };
+};
 }
--- a/src/js/game/buildings/virtual_processor.js
+++ b/src/js/game/buildings/virtual_processor.js
@ -110,8 +110,9 @@ export class MetaVirtualProcessorBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaVirtualProcessorBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [
+MetaVirtualProcessorBuilding.setupEntityComponents = [
    entity =>
        entity.addComponent(
            new WiredPinsComponent({
@ -119,24 +120,24 @@ export class MetaVirtualProcessorBuilding extends MetaBuilding {
            })
        ),
    entity => entity.addComponent(new LogicGateComponent({})),
-    ];
+];
-    static variants = {
+MetaVirtualProcessorBuilding.variants = {
    rotater: "rotater",
    unstacker: "unstacker",
    stacker: "stacker",
    painter: "painter",
-    };
+};
-    static overlayMatrices = {
+MetaVirtualProcessorBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) => null,
    [MetaVirtualProcessorBuilding.variants.rotater]: (entity, rotationVariant) => null,
    [MetaVirtualProcessorBuilding.variants.unstacker]: (entity, rotationVariant) => null,
    [MetaVirtualProcessorBuilding.variants.stacker]: (entity, rotationVariant) => null,
    [MetaVirtualProcessorBuilding.variants.painter]: (entity, rotationVariant) => null,
-    };
+};
-    static avaibleVariants = {
+MetaVirtualProcessorBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing),
    [MetaVirtualProcessorBuilding.variants.rotater]: root =>
@ -147,57 +148,57 @@ export class MetaVirtualProcessorBuilding extends MetaBuilding {
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing),
    [MetaVirtualProcessorBuilding.variants.painter]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing),
-    };
+};
-    static dimensions = {
+MetaVirtualProcessorBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
    [MetaVirtualProcessorBuilding.variants.rotater]: () => new Vector(1, 1),
    [MetaVirtualProcessorBuilding.variants.unstacker]: () => new Vector(1, 1),
    [MetaVirtualProcessorBuilding.variants.stacker]: () => new Vector(1, 1),
    [MetaVirtualProcessorBuilding.variants.painter]: () => new Vector(1, 1),
-    };
+};
-    static isRemovable = {
+MetaVirtualProcessorBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaVirtualProcessorBuilding.variants.rotater]: () => true,
    [MetaVirtualProcessorBuilding.variants.unstacker]: () => true,
    [MetaVirtualProcessorBuilding.variants.stacker]: () => true,
    [MetaVirtualProcessorBuilding.variants.painter]: () => true,
-    };
+};
-    static isRotateable = {
+MetaVirtualProcessorBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaVirtualProcessorBuilding.variants.rotater]: () => true,
    [MetaVirtualProcessorBuilding.variants.unstacker]: () => true,
    [MetaVirtualProcessorBuilding.variants.stacker]: () => true,
    [MetaVirtualProcessorBuilding.variants.painter]: () => true,
-    };
+};
-    static renderPins = {
+MetaVirtualProcessorBuilding.renderPins = {
    [defaultBuildingVariant]: () => false,
    [MetaVirtualProcessorBuilding.variants.rotater]: () => false,
    [MetaVirtualProcessorBuilding.variants.unstacker]: () => false,
    [MetaVirtualProcessorBuilding.variants.stacker]: () => false,
    [MetaVirtualProcessorBuilding.variants.painter]: () => false,
-    };
+};
-    static layerPreview = {
+MetaVirtualProcessorBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
    [MetaVirtualProcessorBuilding.variants.rotater]: () => "wires",
    [MetaVirtualProcessorBuilding.variants.unstacker]: () => "wires",
    [MetaVirtualProcessorBuilding.variants.stacker]: () => "wires",
    [MetaVirtualProcessorBuilding.variants.painter]: () => "wires",
-    };
+};
-    static layerByVariant = {
+MetaVirtualProcessorBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "wires",
    [MetaVirtualProcessorBuilding.variants.rotater]: root => "wires",
    [MetaVirtualProcessorBuilding.variants.unstacker]: root => "wires",
    [MetaVirtualProcessorBuilding.variants.stacker]: root => "wires",
    [MetaVirtualProcessorBuilding.variants.painter]: root => "wires",
-    };
+};
-    static silhouetteColors = {
+MetaVirtualProcessorBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => MetaCutterBuilding.silhouetteColors[defaultBuildingVariant],
    [MetaVirtualProcessorBuilding.variants.rotater]: () =>
        MetaRotaterBuilding.silhouetteColors[defaultBuildingVariant],
@ -207,9 +208,9 @@ export class MetaVirtualProcessorBuilding extends MetaBuilding {
        MetaStackerBuilding.silhouetteColors[defaultBuildingVariant],
    [MetaVirtualProcessorBuilding.variants.painter]: () =>
        MetaPainterBuilding.silhouetteColors[defaultBuildingVariant],
-    };
+};
-    static componentVariations = {
+MetaVirtualProcessorBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.WiredPins.setSlots([
            {
@ -314,5 +315,4 @@ export class MetaVirtualProcessorBuilding extends MetaBuilding {
        entity.components.LogicGate.type = enumLogicGateType.painter;
    },
-    };
+};
 }
--- a/src/js/game/buildings/wire.js
+++ b/src/js/game/buildings/wire.js
@ -298,95 +298,92 @@ export class MetaWireBuilding extends MetaBuilding {
            rotationVariant: MetaWireBuilding.rotationVariantToType.indexOf(targetType),
        };
    }
 }
-    static setupEntityComponents = [entity => entity.addComponent(new WireComponent({}))];
+MetaWireBuilding.setupEntityComponents = [entity => entity.addComponent(new WireComponent({}))];
-    static variants = {
+MetaWireBuilding.variants = {
    second: "second",
-    };
+};
-    static wireVariants = {
+MetaWireBuilding.wireVariants = {
    first: "first",
    [MetaWireBuilding.variants.second]: "second",
-    };
+};
-    static rotationVariants = [0, 1, 2, 3];
+MetaWireBuilding.rotationVariants = [0, 1, 2, 3];
-    static placementSounds = {
+MetaWireBuilding.placementSounds = {
    [defaultBuildingVariant]: SOUNDS.placeBelt,
    [MetaWireBuilding.variants.second]: SOUNDS.placeBelt,
-    };
+};
-    static wireVariantToVariant = {
+MetaWireBuilding.wireVariantToVariant = {
    [defaultBuildingVariant]: "first",
    [MetaWireBuilding.variants.second]: "second",
-    };
+};
-    static rotationVariantToType = [
+MetaWireBuilding.rotationVariantToType = [
    enumWireType.forward,
    enumWireType.turn,
    enumWireType.split,
    enumWireType.cross,
-    ];
+];
-    static overlayMatrices = {
+MetaWireBuilding.overlayMatrices = {
-        [enumWireType.forward]: (entity, rotationVariant) =>
+    [enumWireType.forward]: (entity, rotationVariant) => generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
-            generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
+    [enumWireType.split]: (entity, rotationVariant) => generateMatrixRotations([0, 0, 0, 1, 1, 1, 0, 1, 0]),
-        [enumWireType.split]: (entity, rotationVariant) =>
+    [enumWireType.turn]: (entity, rotationVariant) => generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
-            generateMatrixRotations([0, 0, 0, 1, 1, 1, 0, 1, 0]),
+    [enumWireType.cross]: (entity, rotationVariant) => generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 0]),
-        [enumWireType.turn]: (entity, rotationVariant) =>
+};
            generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
        [enumWireType.cross]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 0]),
    };
-    static avaibleVariants = {
+MetaWireBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers),
    [MetaWireBuilding.variants.second]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers),
-    };
+};
-    static dimensions = {
+MetaWireBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
    [MetaWireBuilding.variants.second]: () => new Vector(1, 1),
-    };
+};
-    static isRemovable = {
+MetaWireBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
    [MetaWireBuilding.variants.second]: () => true,
-    };
+};
-    static isReplaceable = {
+MetaWireBuilding.isReplaceable = {
    [defaultBuildingVariant]: () => true,
    [MetaWireBuilding.variants.second]: () => true,
-    };
+};
-    static isRotateable = {
+MetaWireBuilding.isRotateable = {
    [defaultBuildingVariant]: () => true,
    [MetaWireBuilding.variants.second]: () => true,
-    };
+};
-    static renderPins = {
+MetaWireBuilding.renderPins = {
    [defaultBuildingVariant]: () => null,
    [MetaWireBuilding.variants.second]: () => null,
-    };
+};
-    static layerPreview = {
+MetaWireBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
    [MetaWireBuilding.variants.second]: () => "wires",
-    };
+};
-    static layerByVariant = {
+MetaWireBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "wires",
    [MetaWireBuilding.variants.second]: root => "wires",
-    };
+};
-    static silhouetteColors = {
+MetaWireBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#61ef6f",
    [MetaWireBuilding.variants.second]: () => "#61ef6f",
-    };
+};
-    static componentVariations = {
+MetaWireBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {
        entity.components.Wire.type = MetaWireBuilding.rotationVariantToType[rotationVariant];
        entity.components.Wire.variant = "first";
@ -396,5 +393,4 @@ export class MetaWireBuilding extends MetaBuilding {
        entity.components.Wire.type = MetaWireBuilding.rotationVariantToType[rotationVariant];
        entity.components.Wire.variant = "second";
    },
-    };
+};
 }
--- a/src/js/game/buildings/wire_tunnel.js
+++ b/src/js/game/buildings/wire_tunnel.js
@ -106,48 +106,48 @@ export class MetaWireTunnelBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaWireTunnelBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-    static setupEntityComponents = [entity => entity.addComponent(new WireTunnelComponent())];
+MetaWireTunnelBuilding.setupEntityComponents = [entity => entity.addComponent(new WireTunnelComponent())];
-    static overlayMatrices = {
+MetaWireTunnelBuilding.overlayMatrices = {
    [defaultBuildingVariant]: (entity, rotationVariant) =>
        generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 0]),
-    };
+};
-    static dimensions = {
+MetaWireTunnelBuilding.dimensions = {
    [defaultBuildingVariant]: () => new Vector(1, 1),
-    };
+};
-    static silhouetteColors = {
+MetaWireTunnelBuilding.silhouetteColors = {
    [defaultBuildingVariant]: () => "#777a86",
-    };
+};
-    static isRemovable = {
+MetaWireTunnelBuilding.isRemovable = {
    [defaultBuildingVariant]: () => true,
-    };
+};
-    static isRotateable = {
+MetaWireTunnelBuilding.isRotateable = {
    [defaultBuildingVariant]: () => false,
-    };
+};
-    static renderPins = {
+MetaWireTunnelBuilding.renderPins = {
    [defaultBuildingVariant]: () => false,
-    };
+};
-    static layerPreview = {
+MetaWireTunnelBuilding.layerPreview = {
    [defaultBuildingVariant]: () => "wires",
-    };
+};
-    static avaibleVariants = {
+MetaWireTunnelBuilding.avaibleVariants = {
    [defaultBuildingVariant]: root =>
        root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers),
-    };
+};
-    static layerByVariant = {
+MetaWireTunnelBuilding.layerByVariant = {
    [defaultBuildingVariant]: root => "wires",
-    };
+};
-    static componentVariations = {
+MetaWireTunnelBuilding.componentVariations = {
    [defaultBuildingVariant]: (entity, rotationVariant) => {},
-    };
+};
 }