Add quad cutter and painter

src/js/game/buildings/cutter.js

@@ -4,10 +4,13 @@ import { enumItemAcceptorItemFilter, ItemAcceptorComponent } from "../components
 import { ItemEjectorComponent } from "../components/item_ejector";
 import { enumItemProcessorTypes, ItemProcessorComponent } from "../components/item_processor";
 import { Entity } from "../entity";
-import { MetaBuilding } from "../meta_building";
+import { MetaBuilding, defaultBuildingVariant } from "../meta_building";
 import { GameRoot } from "../root";
 import { enumHubGoalRewards } from "../tutorial_goals";
 
+/** @enum {string} */
+export const enumCutterVariants = { quad: "quad" };
+
 export class MetaCutterBuilding extends MetaBuilding {
     constructor() {
         super("cutter");
@@ -16,9 +19,15 @@ export class MetaCutterBuilding extends MetaBuilding {
     getSilhouetteColor() {
         return "#7dcda2";
     }
-
-    getDimensions() {
-        return new Vector(2, 1);
+    getDimensions(variant) {
+        switch (variant) {
+            case defaultBuildingVariant:
+                return new Vector(2, 1);
+            case enumCutterVariants.quad:
+                return new Vector(4, 1);
+            default:
+                assertAlways(false, "Unknown splitter variant: " + variant);
+        }
     }
 
     getName() {
@@ -29,6 +38,10 @@ export class MetaCutterBuilding extends MetaBuilding {
         return "Cuts shapes from top to bottom and outputs both halfs. <strong>If you use only one part, be sure to destroy the other part or it will stall!</strong>";
     }
 
+    getAvailableVariants(root) {
+        return [defaultBuildingVariant, enumCutterVariants.quad];
+    }
+
     /**
      * @param {GameRoot} root
      */
@@ -47,15 +60,7 @@ export class MetaCutterBuilding extends MetaBuilding {
                 processorType: enumItemProcessorTypes.cutter,
             })
         );
-
-        entity.addComponent(
-            new ItemEjectorComponent({
-                slots: [
-                    { pos: new Vector(0, 0), direction: enumDirection.top },
-                    { pos: new Vector(1, 0), direction: enumDirection.top },
-                ],
-            })
-        );
+        entity.addComponent(new ItemEjectorComponent({}));
         entity.addComponent(
             new ItemAcceptorComponent({
                 slots: [
@@ -68,4 +73,36 @@ export class MetaCutterBuilding extends MetaBuilding {
             })
         );
     }
+
+    /**
+     *
+     * @param {Entity} entity
+     * @param {number} rotationVariant
+     * @param {string} variant
+     */
+    updateVariants(entity, rotationVariant, variant) {
+        switch (variant) {
+            case defaultBuildingVariant: {
+                entity.components.ItemEjector.setSlots([
+                    { pos: new Vector(0, 0), direction: enumDirection.top },
+                    { pos: new Vector(1, 0), direction: enumDirection.top },
+                ]);
+                entity.components.ItemProcessor.type = enumItemProcessorTypes.cutter;
+                break;
+            }
+            case enumCutterVariants.quad: {
+                entity.components.ItemEjector.setSlots([
+                    { pos: new Vector(0, 0), direction: enumDirection.top },
+                    { pos: new Vector(1, 0), direction: enumDirection.top },
+                    { pos: new Vector(2, 0), direction: enumDirection.top },
+                    { pos: new Vector(3, 0), direction: enumDirection.top },
+                ]);
+                entity.components.ItemProcessor.type = enumItemProcessorTypes.cutterQuad;
+                break;
+            }
+
+            default:
+                assertAlways(false, "Unknown painter variant: " + variant);
+        }
+    }
 }

src/js/game/buildings/painter.js

@@ -9,7 +9,7 @@ import { enumHubGoalRewards } from "../tutorial_goals";
 import { GameRoot } from "../root";
 
 /** @enum {string} */
-export const enumPainterVariants = { double: "double" };
+export const enumPainterVariants = { double: "double", quad: "quad" };
 
 export class MetaPainterBuilding extends MetaBuilding {
     constructor() {
@@ -22,6 +22,8 @@ export class MetaPainterBuilding extends MetaBuilding {
                 return new Vector(2, 1);
             case enumPainterVariants.double:
                 return new Vector(2, 2);
+            case enumPainterVariants.quad:
+                return new Vector(4, 1);
             default:
                 assertAlways(false, "Unknown painter variant: " + variant);
         }
@@ -40,7 +42,7 @@ export class MetaPainterBuilding extends MetaBuilding {
     }
 
     getAvailableVariants(root) {
-        return [defaultBuildingVariant, enumPainterVariants.double];
+        return [defaultBuildingVariant, enumPainterVariants.double, enumPainterVariants.quad];
     }
 
     /**
@@ -104,6 +106,9 @@ export class MetaPainterBuilding extends MetaBuilding {
 
                 entity.components.ItemProcessor.type = enumItemProcessorTypes.painter;
                 entity.components.ItemProcessor.inputsPerCharge = 2;
+                entity.components.ItemEjector.setSlots([
+                    { pos: new Vector(1, 0), direction: enumDirection.right },
+                ]);
                 break;
             }
             case enumPainterVariants.double: {
@@ -127,6 +132,47 @@ export class MetaPainterBuilding extends MetaBuilding {
 
                 entity.components.ItemProcessor.type = enumItemProcessorTypes.painterDouble;
                 entity.components.ItemProcessor.inputsPerCharge = 3;
+
+                entity.components.ItemEjector.setSlots([
+                    { pos: new Vector(1, 0), direction: enumDirection.right },
+                ]);
+                break;
+            }
+            case enumPainterVariants.quad: {
+                entity.components.ItemAcceptor.setSlots([
+                    {
+                        pos: new Vector(0, 0),
+                        directions: [enumDirection.left],
+                        filter: enumItemAcceptorItemFilter.shape,
+                    },
+                    {
+                        pos: new Vector(0, 0),
+                        directions: [enumDirection.bottom],
+                        filter: enumItemAcceptorItemFilter.color,
+                    },
+                    {
+                        pos: new Vector(1, 0),
+                        directions: [enumDirection.bottom],
+                        filter: enumItemAcceptorItemFilter.color,
+                    },
+                    {
+                        pos: new Vector(2, 0),
+                        directions: [enumDirection.bottom],
+                        filter: enumItemAcceptorItemFilter.color,
+                    },
+                    {
+                        pos: new Vector(3, 0),
+                        directions: [enumDirection.bottom],
+                        filter: enumItemAcceptorItemFilter.color,
+                    },
+                ]);
+
+                entity.components.ItemProcessor.type = enumItemProcessorTypes.painterQuad;
+                entity.components.ItemProcessor.inputsPerCharge = 5;
+
+                entity.components.ItemEjector.setSlots([
+                    { pos: new Vector(0, 0), direction: enumDirection.top },
+                ]);
                 break;
             }
             default: