Load css resources async, improve building descriptions

src/js/game/buildings/balancer.js

@@ -7,7 +7,7 @@ import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
 import { GameRoot } from "../root";
 import { enumHubGoalRewards } from "../tutorial_goals";
 import { T } from "../../translations";
-import { formatItemsPerSecond } from "../../core/utils";
+import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
 import { BeltUnderlaysComponent } from "../components/belt_underlays";
 
 /** @enum {string} */
@@ -18,6 +18,14 @@ export const enumBalancerVariants = {
     splitterInverse: "splitter-inverse",
 };
 
+const overlayMatrices = {
+    [defaultBuildingVariant]: null,
+    [enumBalancerVariants.merger]: generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
+    [enumBalancerVariants.mergerInverse]: generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
+    [enumBalancerVariants.splitter]: generateMatrixRotations([0, 1, 0, 0, 1, 1, 0, 1, 0]),
+    [enumBalancerVariants.splitterInverse]: generateMatrixRotations([0, 1, 0, 1, 1, 0, 0, 1, 0]),
+};
+
 export class MetaBalancerBuilding extends MetaBuilding {
     constructor() {
         super("balancer");
@@ -37,18 +45,43 @@ export class MetaBalancerBuilding extends MetaBuilding {
         }
     }
 
+    /**
+     * @param {number} rotation
+     * @param {number} rotationVariant
+     * @param {string} variant
+     * @param {Entity} entity
+     * @returns {Array<number>|null}
+     */
+    getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+        const matrix = overlayMatrices[variant];
+        if (matrix) {
+            return matrix[rotation];
+        }
+        return null;
+    }
+
     /**
      * @param {GameRoot} root
      * @param {string} variant
      * @returns {Array<[string, string]>}
      */
     getAdditionalStatistics(root, variant) {
-        const speed = root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer);
+        let speedMultiplier = 2;
+        switch (variant) {
+            case enumBalancerVariants.merger:
+            case enumBalancerVariants.mergerInverse:
+            case enumBalancerVariants.splitter:
+            case enumBalancerVariants.splitterInverse:
+                speedMultiplier = 1;
+        }
+
+        const speed =
+            (root.hubGoals.getProcessorBaseSpeed(enumItemProcessorTypes.balancer) / 2) * speedMultiplier;
         return [[T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(speed)]];
     }
 
     getSilhouetteColor() {
-        return "#444";
+        return "#555759";
     }
 
     /**

src/js/game/buildings/miner.js

@@ -6,12 +6,15 @@ import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
 import { GameRoot } from "../root";
 import { enumHubGoalRewards } from "../tutorial_goals";
 import { T } from "../../translations";
-import { formatItemsPerSecond } from "../../core/utils";
+import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
 
 /** @enum {string} */
 export const enumMinerVariants = { chainable: "chainable" };
 
-const overlayMatrix = [1, 1, 1, 1, 0, 1, 1, 1, 1];
+const overlayMatrix = {
+    [defaultBuildingVariant]: generateMatrixRotations([1, 1, 1, 1, 0, 1, 1, 1, 1]),
+    [enumMinerVariants.chainable]: generateMatrixRotations([0, 1, 0, 1, 1, 1, 1, 1, 1]),
+};
 
 export class MetaMinerBuilding extends MetaBuilding {
     constructor() {
@@ -50,7 +53,7 @@ export class MetaMinerBuilding extends MetaBuilding {
      * @param {Entity} entity
      */
     getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
-        return overlayMatrix;
+        return overlayMatrix[variant][rotation];
     }
 
     /**

src/js/game/buildings/rotater.js

@@ -1,4 +1,4 @@
-import { formatItemsPerSecond } from "../../core/utils";
+import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
 import { enumDirection, Vector } from "../../core/vector";
 import { T } from "../../translations";
 import { ItemAcceptorComponent } from "../components/item_acceptor";
@@ -12,6 +12,11 @@ import { enumHubGoalRewards } from "../tutorial_goals";
 /** @enum {string} */
 export const enumRotaterVariants = { ccw: "ccw", rotate180: "rotate180" };
 
+const overlayMatrices = {
+    [defaultBuildingVariant]: generateMatrixRotations([0, 1, 1, 1, 1, 0, 0, 1, 1]),
+    [enumRotaterVariants.ccw]: generateMatrixRotations([1, 1, 0, 0, 1, 1, 1, 1, 0]),
+};
+
 export class MetaRotaterBuilding extends MetaBuilding {
     constructor() {
         super("rotater");
@@ -21,6 +26,21 @@ export class MetaRotaterBuilding extends MetaBuilding {
         return "#7dc6cd";
     }
 
+    /**
+     * @param {number} rotation
+     * @param {number} rotationVariant
+     * @param {string} variant
+     * @param {Entity} entity
+     * @returns {Array<number>|null}
+     */
+    getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+        const matrix = overlayMatrices[variant];
+        if (matrix) {
+            return matrix[rotation];
+        }
+        return null;
+    }
+
     /**
      * @param {GameRoot} root
      * @param {string} variant

src/js/game/buildings/underground_belt.js

@@ -1,266 +1,268 @@
-import { Loader } from "../../core/loader";
-import { enumDirection, Vector, enumAngleToDirection, enumDirectionToVector } from "../../core/vector";
-import { ItemAcceptorComponent } from "../components/item_acceptor";
-import { ItemEjectorComponent } from "../components/item_ejector";
-import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt";
-import { Entity } from "../entity";
-import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
-import { GameRoot } from "../root";
-import { globalConfig } from "../../core/config";
-import { enumHubGoalRewards } from "../tutorial_goals";
-import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
-import { T } from "../../translations";
-
-/** @enum {string} */
-export const arrayUndergroundRotationVariantToMode = [
-    enumUndergroundBeltMode.sender,
-    enumUndergroundBeltMode.receiver,
-];
-
-/** @enum {string} */
-export const enumUndergroundBeltVariants = { tier2: "tier2" };
-
-export const enumUndergroundBeltVariantToTier = {
-    [defaultBuildingVariant]: 0,
-    [enumUndergroundBeltVariants.tier2]: 1,
-};
-
-const overlayMatrices = [
-    // Sender
-    generateMatrixRotations([1, 1, 1, 0, 1, 0, 0, 1, 0]),
-
-    // Receiver
-    generateMatrixRotations([0, 1, 0, 0, 1, 0, 1, 1, 1]),
-];
-
-export class MetaUndergroundBeltBuilding extends MetaBuilding {
-    constructor() {
-        super("underground_belt");
-    }
-
-    getSilhouetteColor() {
-        return "#222";
-    }
-
-    getFlipOrientationAfterPlacement() {
-        return true;
-    }
-
-    getStayInPlacementMode() {
-        return true;
-    }
-
-    /**
-     * @param {number} rotation
-     * @param {number} rotationVariant
-     * @param {string} variant
-     * @param {Entity} entity
-     */
-    getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
-        return overlayMatrices[rotationVariant][rotation];
-    }
-
-    /**
-     * @param {GameRoot} root
-     * @param {string} variant
-     * @returns {Array<[string, string]>}
-     */
-    getAdditionalStatistics(root, variant) {
-        const rangeTiles =
-            globalConfig.undergroundBeltMaxTilesByTier[enumUndergroundBeltVariantToTier[variant]];
-
-        const beltSpeed = root.hubGoals.getUndergroundBeltBaseSpeed();
-        return [
-            [
-                T.ingame.buildingPlacement.infoTexts.range,
-                T.ingame.buildingPlacement.infoTexts.tiles.replace("<x>", "" + rangeTiles),
-            ],
-            [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)],
-        ];
-    }
-
-    /**
-     * @param {GameRoot} root
-     */
-    getAvailableVariants(root) {
-        if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_underground_belt_tier_2)) {
-            return [defaultBuildingVariant, enumUndergroundBeltVariants.tier2];
-        }
-        return super.getAvailableVariants(root);
-    }
-
-    /**
-     * @param {number} rotationVariant
-     * @param {string} variant
-     */
-    getPreviewSprite(rotationVariant, variant) {
-        let suffix = "";
-        if (variant !== defaultBuildingVariant) {
-            suffix = "-" + variant;
-        }
-
-        switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
-            case enumUndergroundBeltMode.sender:
-                return Loader.getSprite("sprites/buildings/underground_belt_entry" + suffix + ".png");
-            case enumUndergroundBeltMode.receiver:
-                return Loader.getSprite("sprites/buildings/underground_belt_exit" + suffix + ".png");
-            default:
-                assertAlways(false, "Invalid rotation variant");
-        }
-    }
-
-    /**
-     * @param {number} rotationVariant
-     * @param {string} variant
-     */
-    getBlueprintSprite(rotationVariant, variant) {
-        let suffix = "";
-        if (variant !== defaultBuildingVariant) {
-            suffix = "-" + variant;
-        }
-
-        switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
-            case enumUndergroundBeltMode.sender:
-                return Loader.getSprite("sprites/blueprints/underground_belt_entry" + suffix + ".png");
-            case enumUndergroundBeltMode.receiver:
-                return Loader.getSprite("sprites/blueprints/underground_belt_exit" + suffix + ".png");
-            default:
-                assertAlways(false, "Invalid rotation variant");
-        }
-    }
-
-    /**
-     * @param {number} rotationVariant
-     * @param {string} variant
-     */
-    getSprite(rotationVariant, variant) {
-        return this.getPreviewSprite(rotationVariant, variant);
-    }
-
-    /**
-     * @param {GameRoot} root
-     */
-    getIsUnlocked(root) {
-        return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_tunnel);
-    }
-
-    /**
-     * Creates the entity at the given location
-     * @param {Entity} entity
-     */
-    setupEntityComponents(entity) {
-        // Required, since the item processor needs this.
-        entity.addComponent(
-            new ItemEjectorComponent({
-                slots: [],
-            })
-        );
-
-        entity.addComponent(new UndergroundBeltComponent({}));
-        entity.addComponent(
-            new ItemAcceptorComponent({
-                slots: [],
-            })
-        );
-    }
-
-    /**
-     * Should compute the optimal rotation variant on the given tile
-     * @param {object} param0
-     * @param {GameRoot} param0.root
-     * @param {Vector} param0.tile
-     * @param {number} param0.rotation
-     * @param {string} param0.variant
-     * @param {Layer} param0.layer
-     * @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array<Entity> }}
-     */
-    computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
-        const searchDirection = enumAngleToDirection[rotation];
-        const searchVector = enumDirectionToVector[searchDirection];
-        const tier = enumUndergroundBeltVariantToTier[variant];
-
-        const targetRotation = (rotation + 180) % 360;
-        const targetSenderRotation = rotation;
-
-        for (
-            let searchOffset = 1;
-            searchOffset <= globalConfig.undergroundBeltMaxTilesByTier[tier];
-            ++searchOffset
-        ) {
-            tile = tile.addScalars(searchVector.x, searchVector.y);
-
-            /* WIRES: FIXME */
-            const contents = root.map.getTileContent(tile, "regular");
-            if (contents) {
-                const undergroundComp = contents.components.UndergroundBelt;
-                if (undergroundComp && undergroundComp.tier === tier) {
-                    const staticComp = contents.components.StaticMapEntity;
-                    if (staticComp.rotation === targetRotation) {
-                        if (undergroundComp.mode !== enumUndergroundBeltMode.sender) {
-                            // If we encounter an underground receiver on our way which is also faced in our direction, we don't accept that
-                            break;
-                        }
-                        return {
-                            rotation: targetRotation,
-                            rotationVariant: 1,
-                            connectedEntities: [contents],
-                        };
-                    } else if (staticComp.rotation === targetSenderRotation) {
-                        // Draw connections to receivers
-                        if (undergroundComp.mode === enumUndergroundBeltMode.receiver) {
-                            return {
-                                rotation: rotation,
-                                rotationVariant: 0,
-                                connectedEntities: [contents],
-                            };
-                        } else {
-                            break;
-                        }
-                    }
-                }
-            }
-        }
-
-        return {
-            rotation,
-            rotationVariant: 0,
-        };
-    }
-
-    /**
-     *
-     * @param {Entity} entity
-     * @param {number} rotationVariant
-     * @param {string} variant
-     */
-    updateVariants(entity, rotationVariant, variant) {
-        entity.components.UndergroundBelt.tier = enumUndergroundBeltVariantToTier[variant];
-
-        switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
-            case enumUndergroundBeltMode.sender: {
-                entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.sender;
-                entity.components.ItemEjector.setSlots([]);
-                entity.components.ItemAcceptor.setSlots([
-                    {
-                        pos: new Vector(0, 0),
-                        directions: [enumDirection.bottom],
-                    },
-                ]);
-                return;
-            }
-            case enumUndergroundBeltMode.receiver: {
-                entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.receiver;
-                entity.components.ItemAcceptor.setSlots([]);
-                entity.components.ItemEjector.setSlots([
-                    {
-                        pos: new Vector(0, 0),
-                        direction: enumDirection.top,
-                    },
-                ]);
-                return;
-            }
-            default:
-                assertAlways(false, "Invalid rotation variant");
-        }
-    }
-}
+import { Loader } from "../../core/loader";
+import { enumDirection, Vector, enumAngleToDirection, enumDirectionToVector } from "../../core/vector";
+import { ItemAcceptorComponent } from "../components/item_acceptor";
+import { ItemEjectorComponent } from "../components/item_ejector";
+import { enumUndergroundBeltMode, UndergroundBeltComponent } from "../components/underground_belt";
+import { Entity } from "../entity";
+import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
+import { GameRoot } from "../root";
+import { globalConfig } from "../../core/config";
+import { enumHubGoalRewards } from "../tutorial_goals";
+import { formatItemsPerSecond, generateMatrixRotations } from "../../core/utils";
+import { T } from "../../translations";
+
+/** @enum {string} */
+export const arrayUndergroundRotationVariantToMode = [
+    enumUndergroundBeltMode.sender,
+    enumUndergroundBeltMode.receiver,
+];
+
+/** @enum {string} */
+export const enumUndergroundBeltVariants = { tier2: "tier2" };
+
+export const enumUndergroundBeltVariantToTier = {
+    [defaultBuildingVariant]: 0,
+    [enumUndergroundBeltVariants.tier2]: 1,
+};
+
+const colorsByRotationVariant = ["#6d9dff", "#51d723"];
+
+const overlayMatrices = [
+    // Sender
+    generateMatrixRotations([1, 1, 1, 0, 1, 0, 0, 1, 0]),
+
+    // Receiver
+    generateMatrixRotations([0, 1, 0, 0, 1, 0, 1, 1, 1]),
+];
+
+export class MetaUndergroundBeltBuilding extends MetaBuilding {
+    constructor() {
+        super("underground_belt");
+    }
+
+    getSilhouetteColor(variant, rotationVariant) {
+        return colorsByRotationVariant[rotationVariant];
+    }
+
+    getFlipOrientationAfterPlacement() {
+        return true;
+    }
+
+    getStayInPlacementMode() {
+        return true;
+    }
+
+    /**
+     * @param {number} rotation
+     * @param {number} rotationVariant
+     * @param {string} variant
+     * @param {Entity} entity
+     */
+    getSpecialOverlayRenderMatrix(rotation, rotationVariant, variant, entity) {
+        return overlayMatrices[rotationVariant][rotation];
+    }
+
+    /**
+     * @param {GameRoot} root
+     * @param {string} variant
+     * @returns {Array<[string, string]>}
+     */
+    getAdditionalStatistics(root, variant) {
+        const rangeTiles =
+            globalConfig.undergroundBeltMaxTilesByTier[enumUndergroundBeltVariantToTier[variant]];
+
+        const beltSpeed = root.hubGoals.getUndergroundBeltBaseSpeed();
+        return [
+            [
+                T.ingame.buildingPlacement.infoTexts.range,
+                T.ingame.buildingPlacement.infoTexts.tiles.replace("<x>", "" + rangeTiles),
+            ],
+            [T.ingame.buildingPlacement.infoTexts.speed, formatItemsPerSecond(beltSpeed)],
+        ];
+    }
+
+    /**
+     * @param {GameRoot} root
+     */
+    getAvailableVariants(root) {
+        if (root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_underground_belt_tier_2)) {
+            return [defaultBuildingVariant, enumUndergroundBeltVariants.tier2];
+        }
+        return super.getAvailableVariants(root);
+    }
+
+    /**
+     * @param {number} rotationVariant
+     * @param {string} variant
+     */
+    getPreviewSprite(rotationVariant, variant) {
+        let suffix = "";
+        if (variant !== defaultBuildingVariant) {
+            suffix = "-" + variant;
+        }
+
+        switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
+            case enumUndergroundBeltMode.sender:
+                return Loader.getSprite("sprites/buildings/underground_belt_entry" + suffix + ".png");
+            case enumUndergroundBeltMode.receiver:
+                return Loader.getSprite("sprites/buildings/underground_belt_exit" + suffix + ".png");
+            default:
+                assertAlways(false, "Invalid rotation variant");
+        }
+    }
+
+    /**
+     * @param {number} rotationVariant
+     * @param {string} variant
+     */
+    getBlueprintSprite(rotationVariant, variant) {
+        let suffix = "";
+        if (variant !== defaultBuildingVariant) {
+            suffix = "-" + variant;
+        }
+
+        switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
+            case enumUndergroundBeltMode.sender:
+                return Loader.getSprite("sprites/blueprints/underground_belt_entry" + suffix + ".png");
+            case enumUndergroundBeltMode.receiver:
+                return Loader.getSprite("sprites/blueprints/underground_belt_exit" + suffix + ".png");
+            default:
+                assertAlways(false, "Invalid rotation variant");
+        }
+    }
+
+    /**
+     * @param {number} rotationVariant
+     * @param {string} variant
+     */
+    getSprite(rotationVariant, variant) {
+        return this.getPreviewSprite(rotationVariant, variant);
+    }
+
+    /**
+     * @param {GameRoot} root
+     */
+    getIsUnlocked(root) {
+        return root.hubGoals.isRewardUnlocked(enumHubGoalRewards.reward_tunnel);
+    }
+
+    /**
+     * Creates the entity at the given location
+     * @param {Entity} entity
+     */
+    setupEntityComponents(entity) {
+        // Required, since the item processor needs this.
+        entity.addComponent(
+            new ItemEjectorComponent({
+                slots: [],
+            })
+        );
+
+        entity.addComponent(new UndergroundBeltComponent({}));
+        entity.addComponent(
+            new ItemAcceptorComponent({
+                slots: [],
+            })
+        );
+    }
+
+    /**
+     * Should compute the optimal rotation variant on the given tile
+     * @param {object} param0
+     * @param {GameRoot} param0.root
+     * @param {Vector} param0.tile
+     * @param {number} param0.rotation
+     * @param {string} param0.variant
+     * @param {Layer} param0.layer
+     * @return {{ rotation: number, rotationVariant: number, connectedEntities?: Array<Entity> }}
+     */
+    computeOptimalDirectionAndRotationVariantAtTile({ root, tile, rotation, variant, layer }) {
+        const searchDirection = enumAngleToDirection[rotation];
+        const searchVector = enumDirectionToVector[searchDirection];
+        const tier = enumUndergroundBeltVariantToTier[variant];
+
+        const targetRotation = (rotation + 180) % 360;
+        const targetSenderRotation = rotation;
+
+        for (
+            let searchOffset = 1;
+            searchOffset <= globalConfig.undergroundBeltMaxTilesByTier[tier];
+            ++searchOffset
+        ) {
+            tile = tile.addScalars(searchVector.x, searchVector.y);
+
+            /* WIRES: FIXME */
+            const contents = root.map.getTileContent(tile, "regular");
+            if (contents) {
+                const undergroundComp = contents.components.UndergroundBelt;
+                if (undergroundComp && undergroundComp.tier === tier) {
+                    const staticComp = contents.components.StaticMapEntity;
+                    if (staticComp.rotation === targetRotation) {
+                        if (undergroundComp.mode !== enumUndergroundBeltMode.sender) {
+                            // If we encounter an underground receiver on our way which is also faced in our direction, we don't accept that
+                            break;
+                        }
+                        return {
+                            rotation: targetRotation,
+                            rotationVariant: 1,
+                            connectedEntities: [contents],
+                        };
+                    } else if (staticComp.rotation === targetSenderRotation) {
+                        // Draw connections to receivers
+                        if (undergroundComp.mode === enumUndergroundBeltMode.receiver) {
+                            return {
+                                rotation: rotation,
+                                rotationVariant: 0,
+                                connectedEntities: [contents],
+                            };
+                        } else {
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        return {
+            rotation,
+            rotationVariant: 0,
+        };
+    }
+
+    /**
+     *
+     * @param {Entity} entity
+     * @param {number} rotationVariant
+     * @param {string} variant
+     */
+    updateVariants(entity, rotationVariant, variant) {
+        entity.components.UndergroundBelt.tier = enumUndergroundBeltVariantToTier[variant];
+
+        switch (arrayUndergroundRotationVariantToMode[rotationVariant]) {
+            case enumUndergroundBeltMode.sender: {
+                entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.sender;
+                entity.components.ItemEjector.setSlots([]);
+                entity.components.ItemAcceptor.setSlots([
+                    {
+                        pos: new Vector(0, 0),
+                        directions: [enumDirection.bottom],
+                    },
+                ]);
+                return;
+            }
+            case enumUndergroundBeltMode.receiver: {
+                entity.components.UndergroundBelt.mode = enumUndergroundBeltMode.receiver;
+                entity.components.ItemAcceptor.setSlots([]);
+                entity.components.ItemEjector.setSlots([
+                    {
+                        pos: new Vector(0, 0),
+                        direction: enumDirection.top,
+                    },
+                ]);
+                return;
+            }
+            default:
+                assertAlways(false, "Invalid rotation variant");
+        }
+    }
+}