Changed building static declarations

2025-06-13 13:04:03 +00:00 · 2021-03-02 14:33:22 +01:00 · 2021-03-02 14:33:22 +01:00 · c86c635a82
commit c86c635a82
parent db215dc5b3
25 changed files with 3070 additions and 3024 deletions
--- a/src/js/game/buildings/analyzer.js
+++ b/src/js/game/buildings/analyzer.js
@ -106,9 +106,8 @@ export class MetaAnalyzerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaAnalyzerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaAnalyzerBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new WiredPinsComponent({
@ -140,45 +139,45 @@ MetaAnalyzerBuilding.setupEntityComponents = [
            ),
    ];
-MetaAnalyzerBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#555759",
    };
-MetaAnalyzerBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing),
    };
-MetaAnalyzerBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) =>
            generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 0]),
    };
-MetaAnalyzerBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaAnalyzerBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => false,
    };
-MetaAnalyzerBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "wires",
    };
-MetaAnalyzerBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaAnalyzerBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaAnalyzerBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaAnalyzerBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.WiredPins.setSlots([
                {
@ -201,3 +200,4 @@ MetaAnalyzerBuilding.componentVariations = {
            entity.components.LogicGate.type = enumLogicGateType.analyzer;
        },
    };
 }
--- a/src/js/game/buildings/balancer.js
+++ b/src/js/game/buildings/balancer.js
@ -119,9 +119,8 @@ export class MetaBalancerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaBalancerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaBalancerBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new ItemAcceptorComponent({
@ -148,14 +147,14 @@ MetaBalancerBuilding.setupEntityComponents = [
        entity => entity.addComponent(new BeltUnderlaysComponent({ underlays: [] })),
    ];
-MetaBalancerBuilding.variants = {
+    static variants = {
        merger: "merger",
        mergerInverse: "merger-inverse",
        splitter: "splitter",
        splitterInverse: "splitter-inverse",
    };
-MetaBalancerBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
        [MetaBalancerBuilding.variants.merger]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
@ -167,7 +166,7 @@ MetaBalancerBuilding.overlayMatrices = {
            generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
    };
-MetaBalancerBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_balancer),
        [MetaBalancerBuilding.variants.merger]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_merger),
@ -179,7 +178,7 @@ MetaBalancerBuilding.avaibleVariants = {
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_splitter),
    };
-MetaBalancerBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(2, 1),
        [MetaBalancerBuilding.variants.merger]: () => new Vector(1, 1),
        [MetaBalancerBuilding.variants.mergerInverse]: () => new Vector(1, 1),
@ -187,7 +186,7 @@ MetaBalancerBuilding.dimensions = {
        [MetaBalancerBuilding.variants.splitterInverse]: () => new Vector(1, 1),
    };
-MetaBalancerBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaBalancerBuilding.variants.merger]: () => true,
        [MetaBalancerBuilding.variants.mergerInverse]: () => true,
@ -195,7 +194,7 @@ MetaBalancerBuilding.isRemovable = {
        [MetaBalancerBuilding.variants.splitterInverse]: () => true,
    };
-MetaBalancerBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaBalancerBuilding.variants.merger]: () => true,
        [MetaBalancerBuilding.variants.mergerInverse]: () => true,
@ -203,7 +202,7 @@ MetaBalancerBuilding.isRotateable = {
        [MetaBalancerBuilding.variants.splitterInverse]: () => true,
    };
-MetaBalancerBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => null,
        [MetaBalancerBuilding.variants.merger]: () => null,
        [MetaBalancerBuilding.variants.mergerInverse]: () => null,
@ -211,7 +210,7 @@ MetaBalancerBuilding.renderPins = {
        [MetaBalancerBuilding.variants.splitterInverse]: () => null,
    };
-MetaBalancerBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => null,
        [MetaBalancerBuilding.variants.merger]: () => null,
        [MetaBalancerBuilding.variants.mergerInverse]: () => null,
@ -219,7 +218,7 @@ MetaBalancerBuilding.layerPreview = {
        [MetaBalancerBuilding.variants.splitterInverse]: () => null,
    };
-MetaBalancerBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
        [MetaBalancerBuilding.variants.merger]: root => "regular",
        [MetaBalancerBuilding.variants.mergerInverse]: root => "regular",
@ -227,7 +226,7 @@ MetaBalancerBuilding.layerByVariant = {
        [MetaBalancerBuilding.variants.splitterInverse]: root => "regular",
    };
-MetaBalancerBuilding.additionalStatistics = {
+    static additionalStatistics = {
        /**
         * @param {*} root
         * @returns {Array<[string, string]>}
@ -245,7 +244,9 @@ MetaBalancerBuilding.additionalStatistics = {
        [MetaBalancerBuilding.variants.merger]: root => [
            [
                T.ingame.buildingPlacement.infoTexts.speed,
-            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2),
+                formatItemsPerSecond(
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2
                ),
            ],
        ],
        /**
@ -255,7 +256,9 @@ MetaBalancerBuilding.additionalStatistics = {
        [MetaBalancerBuilding.variants.mergerInverse]: root => [
            [
                T.ingame.buildingPlacement.infoTexts.speed,
-            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2),
+                formatItemsPerSecond(
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2
                ),
            ],
        ],
        /**
@ -265,7 +268,9 @@ MetaBalancerBuilding.additionalStatistics = {
        [MetaBalancerBuilding.variants.splitter]: root => [
            [
                T.ingame.buildingPlacement.infoTexts.speed,
-            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2),
+                formatItemsPerSecond(
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2
                ),
            ],
        ],
        /**
@ -275,12 +280,14 @@ MetaBalancerBuilding.additionalStatistics = {
        [MetaBalancerBuilding.variants.splitterInverse]: root => [
            [
                T.ingame.buildingPlacement.infoTexts.speed,
-            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2),
+                formatItemsPerSecond(
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2
                ),
            ],
        ],
    };
-MetaBalancerBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#555759",
        [MetaBalancerBuilding.variants.merger]: () => "#555759",
        [MetaBalancerBuilding.variants.mergerInverse]: () => "#555759",
@ -288,7 +295,7 @@ MetaBalancerBuilding.silhouetteColors = {
        [MetaBalancerBuilding.variants.splitterInverse]: () => "#555759",
    };
-MetaBalancerBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemAcceptor.setSlots([
                {
@ -326,7 +333,9 @@ MetaBalancerBuilding.componentVariations = {
            entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: enumDirection.top }]);
-        entity.components.BeltUnderlays.underlays = [{ pos: new Vector(0, 0), direction: enumDirection.top }];
+            entity.components.BeltUnderlays.underlays = [
                { pos: new Vector(0, 0), direction: enumDirection.top },
            ];
        },
        [MetaBalancerBuilding.variants.mergerInverse]: (entity, rotationVariant) => {
@ -343,7 +352,9 @@ MetaBalancerBuilding.componentVariations = {
            entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: enumDirection.top }]);
-        entity.components.BeltUnderlays.underlays = [{ pos: new Vector(0, 0), direction: enumDirection.top }];
+            entity.components.BeltUnderlays.underlays = [
                { pos: new Vector(0, 0), direction: enumDirection.top },
            ];
        },
        [MetaBalancerBuilding.variants.splitter]: (entity, rotationVariant) => {
@ -398,3 +409,4 @@ MetaBalancerBuilding.componentVariations = {
            }
        },
    };
 }
--- a/src/js/game/buildings/belt.js
+++ b/src/js/game/buildings/belt.js
@ -281,9 +281,8 @@ export class MetaBeltBuilding extends MetaBuilding {
            rotationVariant: 0,
        };
    }
 }
-MetaBeltBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new BeltComponent({
@ -291,69 +290,75 @@ MetaBeltBuilding.setupEntityComponents = [
                })
            ),
    ];
-
+    static silhouetteColors = {
 MetaBeltBuilding.silhouetteColors = {
        [defaultBuildingVariant]: () => THEME.map.chunkOverview.beltColor,
    };
-MetaBeltBuilding.variantToRotation = [enumDirection.top, enumDirection.left, enumDirection.right];
+    static variantToRotation = [enumDirection.top, enumDirection.left, enumDirection.right];
-MetaBeltBuilding.overlayMatrices = {
+    static overlayMatrices = {
-    [enumDirection.top]: (entity, rotationVariant) => generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
+        [enumDirection.top]: (entity, rotationVariant) =>
-    [enumDirection.left]: (entity, rotationVariant) => generateMatrixRotations([0, 0, 0, 1, 1, 0, 0, 1, 0]),
+            generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
-    [enumDirection.right]: (entity, rotationVariant) => generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
+        [enumDirection.left]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 0, 0, 1, 1, 0, 0, 1, 0]),
        [enumDirection.right]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
    };
-MetaBeltBuilding.placementSounds = {
+    static placementSounds = {
        [defaultBuildingVariant]: () => SOUNDS.placeBelt,
    };
-MetaBeltBuilding.rotationVariants = [0, 1, 2];
+    static rotationVariants = [0, 1, 2];
-MetaBeltBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => true,
    };
-MetaBeltBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaBeltBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaBeltBuilding.isReplaceable = {
+    static isReplaceable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaBeltBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaBeltBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => null,
    };
-MetaBeltBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => null,
    };
-MetaBeltBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaBeltBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.Belt.direction = MetaBeltBuilding.variantToRotation[rotationVariant];
        },
    };
-MetaBeltBuilding.additionalStatistics = {
+    static 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,9 +107,8 @@ export class MetaComparatorBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaComparatorBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaComparatorBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        (entity, rotationVariant) =>
            entity.addComponent(
                new WiredPinsComponent({
@ -140,44 +139,44 @@ MetaComparatorBuilding.setupEntityComponents = [
            ),
    ];
-MetaComparatorBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: () => null,
    };
-MetaComparatorBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaComparatorBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#823cab",
    };
-MetaComparatorBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaComparatorBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaComparatorBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => false,
    };
-MetaComparatorBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaComparatorBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing),
    };
-MetaComparatorBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaComparatorBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.WiredPins.setSlots([
                {
@ -200,3 +199,4 @@ MetaComparatorBuilding.componentVariations = {
            entity.components.LogicGate.type = enumLogicGateType.compare;
        },
    };
 }
--- a/src/js/game/buildings/constant_signal.js
+++ b/src/js/game/buildings/constant_signal.js
@ -107,9 +107,8 @@ export class MetaConstantSignalBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaConstantSignalBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaConstantSignalBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new WiredPinsComponent({
@ -125,45 +124,45 @@ MetaConstantSignalBuilding.setupEntityComponents = [
        entity => entity.addComponent(new ConstantSignalComponent({})),
    ];
-MetaConstantSignalBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 1, 0, 1, 1, 1, 1, 1, 1]),
    };
-MetaConstantSignalBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaConstantSignalBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#2b84fd",
    };
-MetaConstantSignalBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaConstantSignalBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaConstantSignalBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => false,
    };
-MetaConstantSignalBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_constant_signal),
    };
-MetaConstantSignalBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "wires",
    };
-MetaConstantSignalBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaConstantSignalBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.WiredPins.setSlots([
                {
@ -174,3 +173,4 @@ MetaConstantSignalBuilding.componentVariations = {
            ]);
        },
    };
 }
--- 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);
    }
-}
+
-MetaCutterBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new ItemProcessorComponent({
@ -103,53 +103,53 @@ MetaCutterBuilding.setupEntityComponents = [
            ),
    ];
-MetaCutterBuilding.variants = {
+    static variants = {
        quad: "quad",
    };
-MetaCutterBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
        [MetaCutterBuilding.variants.quad]: (entity, rotationVariant) => null,
    };
-MetaCutterBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(2, 1),
        [MetaCutterBuilding.variants.quad]: () => new Vector(4, 1),
    };
-MetaCutterBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#7dcda2",
        [MetaCutterBuilding.variants.quad]: () => "#7dcda2",
    };
-MetaCutterBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_and_trash),
        [MetaCutterBuilding.variants.quad]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_quad),
    };
-MetaCutterBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
        [MetaCutterBuilding.variants.quad]: root => "regular",
    };
-MetaCutterBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => null,
        [MetaCutterBuilding.variants.quad]: () => null,
    };
-MetaCutterBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaCutterBuilding.variants.quad]: () => true,
    };
-MetaCutterBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaCutterBuilding.variants.quad]: () => true,
    };
-MetaCutterBuilding.additionalStatistics = {
+    static additionalStatistics = {
        /**
         * @param {*} root
         * @returns {Array<[string, string]>}
@ -168,12 +168,14 @@ MetaCutterBuilding.additionalStatistics = {
        [MetaCutterBuilding.variants.quad]: root => [
            [
                T.ingame.buildingPlacement.infoTexts.speed,
-            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.cutterQuad) / 2),
+                formatItemsPerSecond(
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.cutterQuad) / 2
                ),
            ],
        ],
    };
-MetaCutterBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemEjector.setSlots([
                { pos: new Vector(0, 0), direction: enumDirection.top },
@ -193,3 +195,4 @@ MetaCutterBuilding.componentVariations = {
            entity.components.ItemProcessor.type = enumItemProcessorTypes.cutterQuad;
        },
    };
 }
--- a/src/js/game/buildings/display.js
+++ b/src/js/game/buildings/display.js
@ -94,9 +94,8 @@ export class MetaDisplayBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaDisplayBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaDisplayBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new WiredPinsComponent({
@ -112,43 +111,43 @@ MetaDisplayBuilding.setupEntityComponents = [
        entity => entity.addComponent(new DisplayComponent()),
    ];
-MetaDisplayBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
    };
-MetaDisplayBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaDisplayBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#aaaaaa",
    };
-MetaDisplayBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaDisplayBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaDisplayBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_display),
    };
-MetaDisplayBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaDisplayBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaDisplayBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => true,
    };
-MetaDisplayBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.WiredPins.setSlots([
                {
@ -159,3 +158,4 @@ MetaDisplayBuilding.componentVariations = {
            ]);
        },
    };
 }
--- a/src/js/game/buildings/filter.js
+++ b/src/js/game/buildings/filter.js
@ -119,9 +119,8 @@ export class MetaFilterBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaFilterBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaFilterBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new WiredPinsComponent({
@ -166,49 +165,52 @@ MetaFilterBuilding.setupEntityComponents = [
        entity => entity.addComponent(new FilterComponent()),
    ];
-MetaFilterBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: () => null,
    };
-MetaFilterBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(2, 1),
    };
-MetaFilterBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#c45c2e",
    };
-MetaFilterBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaFilterBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaFilterBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_filter),
    };
-MetaFilterBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaFilterBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaFilterBuilding.additionalStatistics = {
+    static additionalStatistics = {
        [defaultBuildingVariant]: root => [
-        [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed())],
+            [
                T.ingame.buildingPlacement.infoTexts.speed,
                formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed()),
            ],
        ],
    };
-MetaFilterBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => true,
    };
-MetaFilterBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.WiredPins.setSlots([
                {
@ -237,3 +239,4 @@ MetaFilterBuilding.componentVariations = {
            ]);
        },
    };
 }
--- a/src/js/game/buildings/hub.js
+++ b/src/js/game/buildings/hub.js
@ -108,11 +108,10 @@ export class MetaHubBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaHubBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaHubBuilding.canPipet = () => false;
+    static canPipet = () => false;
-MetaHubBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity => entity.addComponent(new HubComponent()),
        entity =>
            entity.addComponent(
@ -214,39 +213,39 @@ MetaHubBuilding.setupEntityComponents = [
            ),
    ];
-MetaHubBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#eb5555",
    };
-MetaHubBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(4, 4),
    };
-MetaHubBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => false,
    };
-MetaHubBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => false,
    };
-MetaHubBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
    };
-MetaHubBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => false,
    };
-MetaHubBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaHubBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => false,
    };
-MetaHubBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemProcessor.inputsPerCharge = 1;
@ -334,3 +333,4 @@ MetaHubBuilding.componentVariations = {
            ]);
        },
    };
 }
--- a/src/js/game/buildings/item_producer.js
+++ b/src/js/game/buildings/item_producer.js
@ -87,9 +87,8 @@ export class MetaItemProducerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaItemProducerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaItemProducerBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new ItemEjectorComponent({
@ -112,39 +111,39 @@ MetaItemProducerBuilding.setupEntityComponents = [
        entity => entity.addComponent(new ItemProducerComponent()),
    ];
-MetaItemProducerBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
    };
-MetaItemProducerBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaItemProducerBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#b37dcd",
    };
-MetaItemProducerBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaItemProducerBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaItemProducerBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => true,
    };
-MetaItemProducerBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaItemProducerBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaItemProducerBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemEjector.setSlots([{ pos: new Vector(0, 0), direction: enumDirection.top }]);
@ -157,3 +156,4 @@ MetaItemProducerBuilding.componentVariations = {
            ]);
        },
    };
 }
--- a/src/js/game/buildings/lever.js
+++ b/src/js/game/buildings/lever.js
@ -110,9 +110,8 @@ export class MetaLeverBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaLeverBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaLeverBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new WiredPinsComponent({
@ -128,44 +127,44 @@ MetaLeverBuilding.setupEntityComponents = [
        entity => entity.addComponent(new LeverComponent({})),
    ];
-MetaLeverBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
    };
-MetaLeverBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaLeverBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#1a678b",
    };
-MetaLeverBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaLeverBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaLeverBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers),
    };
-MetaLeverBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaLeverBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaLeverBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => true,
    };
-MetaLeverBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.WiredPins.setSlots([
                {
@ -176,3 +175,4 @@ MetaLeverBuilding.componentVariations = {
            ]);
        },
    };
 }
--- 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);
    }
-}
+
-MetaLogicGateBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new WiredPinsComponent({
@ -118,13 +118,13 @@ MetaLogicGateBuilding.setupEntityComponents = [
        entity => entity.addComponent(new LogicGateComponent({})),
    ];
-MetaLogicGateBuilding.variants = {
+    static variants = {
        not: "not",
        xor: "xor",
        or: "or",
    };
-MetaLogicGateBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 1]),
        [MetaLogicGateBuilding.variants.xor]: (entity, rotationVariant) =>
@ -134,36 +134,37 @@ MetaLogicGateBuilding.overlayMatrices = {
        [MetaLogicGateBuilding.variants.not]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
    };
-MetaLogicGateBuilding.dimensions = {
+    static 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),
    };
-MetaLogicGateBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#f48d41",
        [MetaLogicGateBuilding.variants.xor]: () => "#f4a241",
        [MetaLogicGateBuilding.variants.or]: () => "#f4d041",
        [MetaLogicGateBuilding.variants.not]: () => "#f44184",
    };
-MetaLogicGateBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaLogicGateBuilding.variants.xor]: () => true,
        [MetaLogicGateBuilding.variants.or]: () => true,
        [MetaLogicGateBuilding.variants.not]: () => true,
    };
-MetaLogicGateBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaLogicGateBuilding.variants.xor]: () => true,
        [MetaLogicGateBuilding.variants.or]: () => true,
        [MetaLogicGateBuilding.variants.not]: () => true,
    };
-MetaLogicGateBuilding.avaibleVariants = {
+    static avaibleVariants = {
-    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
+        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
        [MetaLogicGateBuilding.variants.xor]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
        [MetaLogicGateBuilding.variants.or]: root =>
@ -172,28 +173,28 @@ MetaLogicGateBuilding.avaibleVariants = {
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
    };
-MetaLogicGateBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "wires",
        [MetaLogicGateBuilding.variants.xor]: root => "wires",
        [MetaLogicGateBuilding.variants.or]: root => "wires",
        [MetaLogicGateBuilding.variants.not]: root => "wires",
    };
-MetaLogicGateBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => false,
        [MetaLogicGateBuilding.variants.xor]: () => false,
        [MetaLogicGateBuilding.variants.or]: () => false,
        [MetaLogicGateBuilding.variants.not]: () => false,
    };
-MetaLogicGateBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
        [MetaLogicGateBuilding.variants.xor]: () => "wires",
        [MetaLogicGateBuilding.variants.or]: () => "wires",
        [MetaLogicGateBuilding.variants.not]: () => "wires",
    };
-MetaLogicGateBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.WiredPins.setSlots([
                {
@ -276,3 +277,4 @@ MetaLogicGateBuilding.componentVariations = {
            entity.components.LogicGate.type = enumLogicGateType.not;
        },
    };
 }
--- a/src/js/game/buildings/miner.js
+++ b/src/js/game/buildings/miner.js
@ -103,9 +103,8 @@ export class MetaMinerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaMinerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaMinerBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity => entity.addComponent(new MinerComponent({})),
        entity =>
            entity.addComponent(
@ -114,67 +113,74 @@ MetaMinerBuilding.setupEntityComponents = [
                })
            ),
    ];
-MetaMinerBuilding.variants = {
+
    static variants = {
        chainable: "chainable",
    };
-MetaMinerBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#b37dcd",
        [MetaMinerBuilding.variants.chainable]: () => "#b37dcd",
    };
-MetaMinerBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
        [MetaMinerBuilding.variants.chainable]: () => new Vector(1, 1),
    };
-MetaMinerBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaMinerBuilding.variants.chainable]: () => true,
    };
-MetaMinerBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaMinerBuilding.variants.chainable]: () => true,
    };
-MetaMinerBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
        [MetaMinerBuilding.variants.chainable]: root => "regular",
    };
-MetaMinerBuilding.overlayMatrices = {
+    static 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]),
    };
-MetaMinerBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root =>
            !root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_miner_chainable),
        [MetaMinerBuilding.variants.chainable]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_miner_chainable),
    };
-MetaMinerBuilding.additionalStatistics = {
+    static 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()),
            ],
        ],
    };
-MetaMinerBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.Miner.chainable = false;
        },
@ -183,3 +189,4 @@ MetaMinerBuilding.componentVariations = {
            entity.components.Miner.chainable = true;
        },
    };
 }
--- a/src/js/game/buildings/mixer.js
+++ b/src/js/game/buildings/mixer.js
@ -104,9 +104,8 @@ export class MetaMixerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaMixerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaMixerBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new ItemProcessorComponent({
@ -140,35 +139,35 @@ MetaMixerBuilding.setupEntityComponents = [
            ),
    ];
-MetaMixerBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#cdbb7d",
    };
-MetaMixerBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(2, 1),
    };
-MetaMixerBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaMixerBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaMixerBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaMixerBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
    };
-MetaMixerBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_mixer),
    };
-MetaMixerBuilding.additionalStatistics = {
+    static additionalStatistics = {
        /**
         * @param {*} root
         * @returns {Array<[string, string]>}
@ -181,7 +180,7 @@ MetaMixerBuilding.additionalStatistics = {
        ],
    };
-MetaMixerBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemProcessor.inputsPerCharge = 2;
@ -203,3 +202,4 @@ MetaMixerBuilding.componentVariations = {
            ]);
        },
    };
 }
--- a/src/js/game/buildings/painter.js
+++ b/src/js/game/buildings/painter.js
@ -109,9 +109,8 @@ export class MetaPainterBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaPainterBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaPainterBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity => entity.addComponent(new ItemProcessorComponent({})),
        entity =>
            entity.addComponent(
@ -138,55 +137,55 @@ MetaPainterBuilding.setupEntityComponents = [
            ),
    ];
-MetaPainterBuilding.variants = {
+    static variants = {
        mirrored: "mirrored",
        double: "double",
        quad: "quad",
    };
-MetaPainterBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#cd9b7d",
        [MetaPainterBuilding.variants.mirrored]: () => "#cd9b7d",
        [MetaPainterBuilding.variants.double]: () => "#cd9b7d",
        [MetaPainterBuilding.variants.quad]: () => "#cd9b7d",
    };
-MetaPainterBuilding.dimensions = {
+    static 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),
    };
-MetaPainterBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaPainterBuilding.variants.mirrored]: () => true,
        [MetaPainterBuilding.variants.double]: () => true,
        [MetaPainterBuilding.variants.quad]: () => true,
    };
-MetaPainterBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaPainterBuilding.variants.mirrored]: () => true,
        [MetaPainterBuilding.variants.double]: () => true,
        [MetaPainterBuilding.variants.quad]: () => true,
    };
-MetaPainterBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
        [MetaPainterBuilding.variants.mirrored]: root => "regular",
        [MetaPainterBuilding.variants.double]: root => "regular",
        [MetaPainterBuilding.variants.quad]: root => "regular",
    };
-MetaPainterBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
        [MetaPainterBuilding.variants.mirrored]: (entity, rotationVariant) => null,
        [MetaPainterBuilding.variants.double]: (entity, rotationVariant) => null,
        [MetaPainterBuilding.variants.quad]: (entity, rotationVariant) => null,
    };
-MetaPainterBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_painter),
        [MetaPainterBuilding.variants.mirrored]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_painter),
@ -196,7 +195,7 @@ MetaPainterBuilding.avaibleVariants = {
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers),
    };
-MetaPainterBuilding.additionalStatistics = {
+    static additionalStatistics = {
        /**
         * @param {*} root
         * @returns {Array<[string, string]>}
@ -224,7 +223,9 @@ MetaPainterBuilding.additionalStatistics = {
        [MetaPainterBuilding.variants.double]: root => [
            [
                T.ingame.buildingPlacement.infoTexts.speed,
-            formatItemsPerSecond(root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.painterDouble)),
+                formatItemsPerSecond(
                    root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.painterDouble)
                ),
            ],
        ],
        /**
@ -239,7 +240,7 @@ MetaPainterBuilding.additionalStatistics = {
        ],
    };
-MetaPainterBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            if (entity.components.WiredPins) {
                entity.removeComponent(WiredPinsComponent);
@ -258,7 +259,9 @@ MetaPainterBuilding.componentVariations = {
                },
            ]);
-        entity.components.ItemEjector.setSlots([{ pos: new Vector(1, 0), direction: enumDirection.right }]);
+            entity.components.ItemEjector.setSlots([
                { pos: new Vector(1, 0), direction: enumDirection.right },
            ]);
            entity.components.ItemProcessor.type = enumItemProcessorTypes.painter;
            entity.components.ItemProcessor.processingRequirement = null;
@ -283,7 +286,9 @@ MetaPainterBuilding.componentVariations = {
                },
            ]);
-        entity.components.ItemEjector.setSlots([{ pos: new Vector(1, 0), direction: enumDirection.right }]);
+            entity.components.ItemEjector.setSlots([
                { pos: new Vector(1, 0), direction: enumDirection.right },
            ]);
            entity.components.ItemProcessor.type = enumItemProcessorTypes.painter;
            entity.components.ItemProcessor.processingRequirement = null;
@ -313,7 +318,9 @@ MetaPainterBuilding.componentVariations = {
                },
            ]);
-        entity.components.ItemEjector.setSlots([{ pos: new Vector(1, 0), direction: enumDirection.right }]);
+            entity.components.ItemEjector.setSlots([
                { pos: new Vector(1, 0), direction: enumDirection.right },
            ]);
            entity.components.ItemProcessor.type = enumItemProcessorTypes.painterDouble;
            entity.components.ItemProcessor.processingRequirement = null;
@ -383,3 +390,4 @@ MetaPainterBuilding.componentVariations = {
            entity.components.ItemProcessor.inputsPerCharge = 5;
        },
    };
 }
--- a/src/js/game/buildings/reader.js
+++ b/src/js/game/buildings/reader.js
@ -121,9 +121,8 @@ export class MetaReaderBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaReaderBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaReaderBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new WiredPinsComponent({
@ -184,50 +183,54 @@ MetaReaderBuilding.setupEntityComponents = [
        entity => entity.addComponent(new BeltReaderComponent()),
    ];
-MetaReaderBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaReaderBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#25fff2",
    };
-MetaReaderBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaReaderBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaReaderBuilding.additionalStatistics = {
+    static additionalStatistics = {
        [defaultBuildingVariant]: root => [
-        [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed())],
+            [
                T.ingame.buildingPlacement.infoTexts.speed,
                formatItemsPerSecond(root.hubGoals.getBeltBaseSpeed()),
            ],
        ],
    };
-MetaReaderBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
    };
-MetaReaderBuilding.avaibleVariants = {
+    static avaibleVariants = {
-    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_belt_reader),
+        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_belt_reader),
    };
-MetaReaderBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaReaderBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaReaderBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => true,
    };
-MetaReaderBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemAcceptor.setSlots([
                {
@ -255,3 +258,4 @@ MetaReaderBuilding.componentVariations = {
            ];
        },
    };
 }
--- a/src/js/game/buildings/rotater.js
+++ b/src/js/game/buildings/rotater.js
@ -118,9 +118,8 @@ export class MetaRotaterBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaRotaterBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaRotaterBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new ItemProcessorComponent({
@ -148,24 +147,24 @@ MetaRotaterBuilding.setupEntityComponents = [
            ),
    ];
-MetaRotaterBuilding.variants = {
+    static variants = {
        ccw: "ccw",
        rotate180: "rotate180",
    };
-MetaRotaterBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
        [MetaRotaterBuilding.variants.ccw]: () => new Vector(1, 1),
        [MetaRotaterBuilding.variants.rotate180]: () => new Vector(1, 1),
    };
-MetaRotaterBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#7dc6cd",
        [MetaRotaterBuilding.variants.ccw]: () => "#7dc6cd",
        [MetaRotaterBuilding.variants.rotate180]: () => "#7dc6cd",
    };
-MetaRotaterBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 1, 1, 1, 1, 0, 0, 1, 1]),
        [MetaRotaterBuilding.variants.ccw]: (entity, rotationVariant) =>
@ -174,7 +173,7 @@ MetaRotaterBuilding.overlayMatrices = {
            generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 1]),
    };
-MetaRotaterBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotater),
        [MetaRotaterBuilding.variants.ccw]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotater_ccw),
@ -182,37 +181,37 @@ MetaRotaterBuilding.avaibleVariants = {
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_rotater_180),
    };
-MetaRotaterBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaRotaterBuilding.variants.ccw]: () => true,
        [MetaRotaterBuilding.variants.rotate180]: () => true,
    };
-MetaRotaterBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaRotaterBuilding.variants.ccw]: () => true,
        [MetaRotaterBuilding.variants.rotate180]: () => true,
    };
-MetaRotaterBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
        [MetaRotaterBuilding.variants.ccw]: root => "regular",
        [MetaRotaterBuilding.variants.rotate180]: root => "regular",
    };
-MetaRotaterBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => null,
        [MetaRotaterBuilding.variants.ccw]: () => null,
        [MetaRotaterBuilding.variants.rotate180]: () => null,
    };
-MetaRotaterBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => null,
        [MetaRotaterBuilding.variants.ccw]: () => null,
        [MetaRotaterBuilding.variants.rotate180]: () => null,
    };
-MetaRotaterBuilding.additionalStatistics = {
+    static additionalStatistics = {
        /**
         * @param {*} root
         * @returns {Array<[string, string]>}
@ -245,7 +244,7 @@ MetaRotaterBuilding.additionalStatistics = {
        ],
    };
-MetaRotaterBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemProcessor.type = enumItemProcessorTypes.rotater;
        },
@ -258,3 +257,4 @@ MetaRotaterBuilding.componentVariations = {
            entity.components.ItemProcessor.type = enumItemProcessorTypes.rotater180;
        },
    };
 }
--- a/src/js/game/buildings/stacker.js
+++ b/src/js/game/buildings/stacker.js
@ -118,9 +118,8 @@ export class MetaStackerBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaStackerBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaStackerBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new ItemProcessorComponent({
@ -153,43 +152,43 @@ MetaStackerBuilding.setupEntityComponents = [
            ),
    ];
-MetaStackerBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(2, 1),
    };
-MetaStackerBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#9fcd7d",
    };
-MetaStackerBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
    };
-MetaStackerBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_stacker),
    };
-MetaStackerBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaStackerBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaStackerBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaStackerBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => null,
    };
-MetaStackerBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => null,
    };
-MetaStackerBuilding.additionalStatistics = {
+    static additionalStatistics = {
        /**
         * @param {*} root
         * @returns {Array<[string, string]>}
@ -202,7 +201,7 @@ MetaStackerBuilding.additionalStatistics = {
        ],
    };
-MetaStackerBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemProcessor.inputsPerCharge = 2;
@ -224,3 +223,4 @@ MetaStackerBuilding.componentVariations = {
            ]);
        },
    };
 }
--- a/src/js/game/buildings/storage.js
+++ b/src/js/game/buildings/storage.js
@ -121,9 +121,8 @@ export class MetaStorageBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaStorageBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaStorageBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            // Required, since the item processor needs this.
            entity.addComponent(
@ -180,23 +179,23 @@ MetaStorageBuilding.setupEntityComponents = [
            ),
    ];
-MetaStorageBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(2, 2),
    };
-MetaStorageBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#bbdf6d",
    };
-MetaStorageBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaStorageBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaStorageBuilding.additionalStatistics = {
+    static additionalStatistics = {
        /**
         * @param {*} root
         * @returns {Array<[string, string]>}
@ -206,27 +205,27 @@ MetaStorageBuilding.additionalStatistics = {
        ],
    };
-MetaStorageBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
    };
-MetaStorageBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_storage),
    };
-MetaStorageBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaStorageBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaStorageBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => true,
    };
-MetaStorageBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemEjector.setSlots([
                {
@ -263,3 +262,4 @@ MetaStorageBuilding.componentVariations = {
            ]);
        },
    };
 }
--- a/src/js/game/buildings/transistor.js
+++ b/src/js/game/buildings/transistor.js
@ -107,9 +107,8 @@ export class MetaTransistorBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaTransistorBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaTransistorBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new WiredPinsComponent({
@ -140,59 +139,60 @@ MetaTransistorBuilding.setupEntityComponents = [
            ),
    ];
-MetaTransistorBuilding.variants = {
+    static variants = {
        mirrored: "mirrored",
    };
-MetaTransistorBuilding.overlayMatrices = {
+    static 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]),
    };
-MetaTransistorBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
        [MetaTransistorBuilding.variants.mirrored]: () => new Vector(1, 1),
    };
-MetaTransistorBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#823cab",
        [MetaTransistorBuilding.variants.mirrored]: () => "#823cab",
    };
-MetaTransistorBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaTransistorBuilding.variants.mirrored]: () => true,
    };
-MetaTransistorBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaTransistorBuilding.variants.mirrored]: () => true,
    };
-MetaTransistorBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => false,
        [MetaTransistorBuilding.variants.mirrored]: () => false,
    };
-MetaTransistorBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
        [MetaTransistorBuilding.variants.mirrored]: () => "wires",
    };
-MetaTransistorBuilding.avaibleVariants = {
+    static avaibleVariants = {
-    [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
+        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
        [MetaTransistorBuilding.variants.mirrored]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_logic_gates),
    };
-MetaTransistorBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "wires",
        [MetaTransistorBuilding.variants.mirrored]: root => "wires",
    };
-MetaTransistorBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.WiredPins.slots[1].direction = enumDirection.left;
        },
@ -201,3 +201,4 @@ MetaTransistorBuilding.componentVariations = {
            entity.components.WiredPins.slots[1].direction = enumDirection.right;
        },
    };
 }
--- a/src/js/game/buildings/trash.js
+++ b/src/js/game/buildings/trash.js
@ -109,9 +109,8 @@ export class MetaTrashBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaTrashBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaTrashBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new ItemAcceptorComponent({
@ -137,45 +136,45 @@ MetaTrashBuilding.setupEntityComponents = [
            ),
    ];
-MetaTrashBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) =>
            generateMatrixRotations([1, 1, 0, 1, 1, 1, 0, 1, 1]),
    };
-MetaTrashBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaTrashBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#ed1d5d",
    };
-MetaTrashBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaTrashBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaTrashBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => false,
    };
-MetaTrashBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
    };
-MetaTrashBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => null,
    };
-MetaTrashBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_cutter_and_trash),
    };
-MetaTrashBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.ItemAcceptor.setSlots([
                {
@ -194,3 +193,4 @@ MetaTrashBuilding.componentVariations = {
            entity.components.ItemProcessor.type = enumItemProcessorTypes.trash;
        },
    };
 }
--- a/src/js/game/buildings/underground_belt.js
+++ b/src/js/game/buildings/underground_belt.js
@ -234,9 +234,8 @@ export class MetaUndergroundBeltBuilding extends MetaBuilding {
        entity.components.UndergroundBelt.tier = MetaUndergroundBeltBuilding.variantToTier[variant];
        MetaUndergroundBeltBuilding.componentVariationsByRotation[mode](entity, rotationVariant);
    }
 }
-MetaUndergroundBeltBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        // Required, since the item processor needs this.
        entity =>
            entity.addComponent(
@ -253,68 +252,65 @@ MetaUndergroundBeltBuilding.setupEntityComponents = [
            ),
    ];
-MetaUndergroundBeltBuilding.rotationVariants = [0, 1];
+    static rotationVariants = [0, 1];
-MetaUndergroundBeltBuilding.variants = {
+    static variants = {
        tier2: "tier2",
    };
-MetaUndergroundBeltBuilding.overlayMatricesByRotation = [
+    static 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]),
    ];
-MetaUndergroundBeltBuilding.rotationVariantToMode = [
+    static rotationVariantToMode = [enumUndergroundBeltMode.sender, enumUndergroundBeltMode.receiver];
    enumUndergroundBeltMode.sender,
    enumUndergroundBeltMode.receiver,
 ];
-MetaUndergroundBeltBuilding.variantToTier = {
+    static variantToTier = {
        [defaultBuildingVariant]: 0,
        [MetaUndergroundBeltBuilding.variants.tier2]: 1,
    };
-MetaUndergroundBeltBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
        [MetaUndergroundBeltBuilding.variants.tier2]: () => new Vector(1, 1),
    };
-MetaUndergroundBeltBuilding.silhouetteColorsByRotation = [() => "#6d9dff", () => "#71ff9c"];
+    static silhouetteColorsByRotation = [() => "#6d9dff", () => "#71ff9c"];
-MetaUndergroundBeltBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaUndergroundBeltBuilding.variants.tier2]: () => true,
    };
-MetaUndergroundBeltBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaUndergroundBeltBuilding.variants.tier2]: () => true,
    };
-MetaUndergroundBeltBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => null,
        [MetaUndergroundBeltBuilding.variants.tier2]: () => null,
    };
-MetaUndergroundBeltBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => null,
        [MetaUndergroundBeltBuilding.variants.tier2]: () => null,
    };
-MetaUndergroundBeltBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root => root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_tunnel),
        [MetaUndergroundBeltBuilding.variants.tier2]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_underground_belt_tier_2),
    };
-MetaUndergroundBeltBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "regular",
        [MetaUndergroundBeltBuilding.variants.tier2]: root => "regular",
    };
-MetaUndergroundBeltBuilding.additionalStatistics = {
+    static additionalStatistics = {
        /**
         * @param {*} root
         * @returns {Array<[string, string]>}
@ -350,7 +346,7 @@ MetaUndergroundBeltBuilding.additionalStatistics = {
        },
    };
-MetaUndergroundBeltBuilding.componentVariationsByRotation = {
+    static componentVariationsByRotation = {
        [enumUndergroundBeltMode.sender]: (entity, rotationVariant) => {
            entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.sender;
            entity.components.ItemEjector.setSlots([]);
@ -373,3 +369,4 @@ MetaUndergroundBeltBuilding.componentVariationsByRotation = {
            ]);
        },
    };
 }
--- a/src/js/game/buildings/virtual_processor.js
+++ b/src/js/game/buildings/virtual_processor.js
@ -110,9 +110,8 @@ export class MetaVirtualProcessorBuilding extends MetaBuilding {
    updateVariants(entity, rotationVariant, variant) {
        MetaVirtualProcessorBuilding.componentVariations[variant](entity, rotationVariant);
    }
 }
-MetaVirtualProcessorBuilding.setupEntityComponents = [
+    static setupEntityComponents = [
        entity =>
            entity.addComponent(
                new WiredPinsComponent({
@ -122,14 +121,14 @@ MetaVirtualProcessorBuilding.setupEntityComponents = [
        entity => entity.addComponent(new LogicGateComponent({})),
    ];
-MetaVirtualProcessorBuilding.variants = {
+    static variants = {
        rotater: "rotater",
        unstacker: "unstacker",
        stacker: "stacker",
        painter: "painter",
    };
-MetaVirtualProcessorBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) => null,
        [MetaVirtualProcessorBuilding.variants.rotater]: (entity, rotationVariant) => null,
        [MetaVirtualProcessorBuilding.variants.unstacker]: (entity, rotationVariant) => null,
@ -137,7 +136,7 @@ MetaVirtualProcessorBuilding.overlayMatrices = {
        [MetaVirtualProcessorBuilding.variants.painter]: (entity, rotationVariant) => null,
    };
-MetaVirtualProcessorBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing),
        [MetaVirtualProcessorBuilding.variants.rotater]: root =>
@ -150,7 +149,7 @@ MetaVirtualProcessorBuilding.avaibleVariants = {
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_virtual_processing),
    };
-MetaVirtualProcessorBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
        [MetaVirtualProcessorBuilding.variants.rotater]: () => new Vector(1, 1),
        [MetaVirtualProcessorBuilding.variants.unstacker]: () => new Vector(1, 1),
@ -158,7 +157,7 @@ MetaVirtualProcessorBuilding.dimensions = {
        [MetaVirtualProcessorBuilding.variants.painter]: () => new Vector(1, 1),
    };
-MetaVirtualProcessorBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaVirtualProcessorBuilding.variants.rotater]: () => true,
        [MetaVirtualProcessorBuilding.variants.unstacker]: () => true,
@ -166,7 +165,7 @@ MetaVirtualProcessorBuilding.isRemovable = {
        [MetaVirtualProcessorBuilding.variants.painter]: () => true,
    };
-MetaVirtualProcessorBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaVirtualProcessorBuilding.variants.rotater]: () => true,
        [MetaVirtualProcessorBuilding.variants.unstacker]: () => true,
@ -174,7 +173,7 @@ MetaVirtualProcessorBuilding.isRotateable = {
        [MetaVirtualProcessorBuilding.variants.painter]: () => true,
    };
-MetaVirtualProcessorBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => false,
        [MetaVirtualProcessorBuilding.variants.rotater]: () => false,
        [MetaVirtualProcessorBuilding.variants.unstacker]: () => false,
@ -182,7 +181,7 @@ MetaVirtualProcessorBuilding.renderPins = {
        [MetaVirtualProcessorBuilding.variants.painter]: () => false,
    };
-MetaVirtualProcessorBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
        [MetaVirtualProcessorBuilding.variants.rotater]: () => "wires",
        [MetaVirtualProcessorBuilding.variants.unstacker]: () => "wires",
@ -190,7 +189,7 @@ MetaVirtualProcessorBuilding.layerPreview = {
        [MetaVirtualProcessorBuilding.variants.painter]: () => "wires",
    };
-MetaVirtualProcessorBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "wires",
        [MetaVirtualProcessorBuilding.variants.rotater]: root => "wires",
        [MetaVirtualProcessorBuilding.variants.unstacker]: root => "wires",
@ -198,7 +197,7 @@ MetaVirtualProcessorBuilding.layerByVariant = {
        [MetaVirtualProcessorBuilding.variants.painter]: root => "wires",
    };
-MetaVirtualProcessorBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => MetaCutterBuilding.silhouetteColors[defaultBuildingVariant],
        [MetaVirtualProcessorBuilding.variants.rotater]: () =>
            MetaRotaterBuilding.silhouetteColors[defaultBuildingVariant],
@ -210,7 +209,7 @@ MetaVirtualProcessorBuilding.silhouetteColors = {
            MetaPainterBuilding.silhouetteColors[defaultBuildingVariant],
    };
-MetaVirtualProcessorBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.WiredPins.setSlots([
                {
@ -316,3 +315,4 @@ MetaVirtualProcessorBuilding.componentVariations = {
            entity.components.LogicGate.type = enumLogicGateType.painter;
        },
    };
 }
--- a/src/js/game/buildings/wire.js
+++ b/src/js/game/buildings/wire.js
@ -298,92 +298,95 @@ export class MetaWireBuilding extends MetaBuilding {
            rotationVariant: MetaWireBuilding.rotationVariantToType.indexOf(targetType),
        };
    }
 }
-MetaWireBuilding.setupEntityComponents = [entity => entity.addComponent(new WireComponent({}))];
+    static setupEntityComponents = [entity => entity.addComponent(new WireComponent({}))];
-MetaWireBuilding.variants = {
+    static variants = {
        second: "second",
    };
-MetaWireBuilding.wireVariants = {
+    static wireVariants = {
        first: "first",
        [MetaWireBuilding.variants.second]: "second",
    };
-MetaWireBuilding.rotationVariants = [0, 1, 2, 3];
+    static rotationVariants = [0, 1, 2, 3];
-MetaWireBuilding.placementSounds = {
+    static placementSounds = {
        [defaultBuildingVariant]: SOUNDS.placeBelt,
        [MetaWireBuilding.variants.second]: SOUNDS.placeBelt,
    };
-MetaWireBuilding.wireVariantToVariant = {
+    static wireVariantToVariant = {
        [defaultBuildingVariant]: "first",
        [MetaWireBuilding.variants.second]: "second",
    };
-MetaWireBuilding.rotationVariantToType = [
+    static rotationVariantToType = [
        enumWireType.forward,
        enumWireType.turn,
        enumWireType.split,
        enumWireType.cross,
    ];
-MetaWireBuilding.overlayMatrices = {
+    static overlayMatrices = {
-    [enumWireType.forward]: (entity, rotationVariant) => generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
+        [enumWireType.forward]: (entity, rotationVariant) =>
-    [enumWireType.split]: (entity, rotationVariant) => generateMatrixRotations([0, 0, 0, 1, 1, 1, 0, 1, 0]),
+            generateMatrixRotations([0, 1, 0, 0, 1, 0, 0, 1, 0]),
-    [enumWireType.turn]: (entity, rotationVariant) => generateMatrixRotations([0, 0, 0, 0, 1, 1, 0, 1, 0]),
+        [enumWireType.split]: (entity, rotationVariant) =>
-    [enumWireType.cross]: (entity, rotationVariant) => generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 0]),
+            generateMatrixRotations([0, 0, 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]),
    };
-MetaWireBuilding.avaibleVariants = {
+    static 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),
    };
-MetaWireBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
        [MetaWireBuilding.variants.second]: () => new Vector(1, 1),
    };
-MetaWireBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
        [MetaWireBuilding.variants.second]: () => true,
    };
-MetaWireBuilding.isReplaceable = {
+    static isReplaceable = {
        [defaultBuildingVariant]: () => true,
        [MetaWireBuilding.variants.second]: () => true,
    };
-MetaWireBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => true,
        [MetaWireBuilding.variants.second]: () => true,
    };
-MetaWireBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => null,
        [MetaWireBuilding.variants.second]: () => null,
    };
-MetaWireBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
        [MetaWireBuilding.variants.second]: () => "wires",
    };
-MetaWireBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "wires",
        [MetaWireBuilding.variants.second]: root => "wires",
    };
-MetaWireBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#61ef6f",
        [MetaWireBuilding.variants.second]: () => "#61ef6f",
    };
-MetaWireBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {
            entity.components.Wire.type = MetaWireBuilding.rotationVariantToType[rotationVariant];
            entity.components.Wire.variant = "first";
@ -394,3 +397,4 @@ MetaWireBuilding.componentVariations = {
            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);
    }
 }
-MetaWireTunnelBuilding.setupEntityComponents = [entity => entity.addComponent(new WireTunnelComponent())];
+    static setupEntityComponents = [entity => entity.addComponent(new WireTunnelComponent())];
-MetaWireTunnelBuilding.overlayMatrices = {
+    static overlayMatrices = {
        [defaultBuildingVariant]: (entity, rotationVariant) =>
            generateMatrixRotations([0, 1, 0, 1, 1, 1, 0, 1, 0]),
    };
-MetaWireTunnelBuilding.dimensions = {
+    static dimensions = {
        [defaultBuildingVariant]: () => new Vector(1, 1),
    };
-MetaWireTunnelBuilding.silhouetteColors = {
+    static silhouetteColors = {
        [defaultBuildingVariant]: () => "#777a86",
    };
-MetaWireTunnelBuilding.isRemovable = {
+    static isRemovable = {
        [defaultBuildingVariant]: () => true,
    };
-MetaWireTunnelBuilding.isRotateable = {
+    static isRotateable = {
        [defaultBuildingVariant]: () => false,
    };
-MetaWireTunnelBuilding.renderPins = {
+    static renderPins = {
        [defaultBuildingVariant]: () => false,
    };
-MetaWireTunnelBuilding.layerPreview = {
+    static layerPreview = {
        [defaultBuildingVariant]: () => "wires",
    };
-MetaWireTunnelBuilding.avaibleVariants = {
+    static avaibleVariants = {
        [defaultBuildingVariant]: root =>
            root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_wires_painter_and_levers),
    };
-MetaWireTunnelBuilding.layerByVariant = {
+    static layerByVariant = {
        [defaultBuildingVariant]: root => "wires",
    };
-MetaWireTunnelBuilding.componentVariations = {
+    static componentVariations = {
        [defaultBuildingVariant]: (entity, rotationVariant) => {},
    };
 }