Introduce Move tool

Author: Hartrik

src/core/ResourceTool.js

@@ -49,11 +49,11 @@ export class ResourceTool {
 
         if (type === 'image-template') {
             const scenes = await this.parseImageTemplate(json, zip);
-            return Tools.insertElementAreaTool(info, scenes, undefined);
+            return Tools.insertScenesTool(info, scenes, undefined);
 
         } else if (type === 'random-template') {
             const scenes = await this.parseRandomTemplate(json, zip);
-            return Tools.insertElementAreaTool(info, scenes, undefined);
+            return Tools.insertScenesTool(info, scenes, undefined);
 
         } else {
             throw 'Tool action not supported: ' + type;

src/core/SandGame.js

@@ -146,7 +146,8 @@ export class SandGame {
     }
 
     graphics() {
-        return new SandGameGraphics(this.#elementArea, this.#random, (x, y) => {
+        const defaults = this.#processor.getDefaults();
+        return new SandGameGraphics(this.#elementArea, this.#random, defaults, (x, y) => {
             this.#processor.trigger(x, y);
             this.#renderer.trigger(x, y);
         });

src/core/SandGameGraphics.js

@@ -7,7 +7,7 @@ import {CircleIterator} from "./CircleIterator.js";
 /**
  *
  * @author Patrik Harag
- * @version 2023-12-10
+ * @version 2023-12-28
  */
 export class SandGameGraphics {
 
@@ -17,45 +17,34 @@ export class SandGameGraphics {
     /** @type DeterministicRandom */
     #random;
 
-    /** @type function(number, number) */
+    /** @type ProcessorDefaults */
+    #defaults;
+
+    /** @type {function(number,number)} */
     #triggerFunction;
 
-    constructor(elementArea, random, triggerFunction) {
+    constructor(elementArea, random, defaults, triggerFunction) {
         this.#elementArea = elementArea;
         this.#random = random;
+        this.#defaults = defaults;
         this.#triggerFunction = triggerFunction;
     }
 
-    /**
-     *
-     * @param aX {number}
-     * @param aY {number}
-     * @param bX {number}
-     * @param bY {number}
-     */
-    swap(aX, aY, bX, bY) {
-        aX = Math.trunc(aX);
-        aY = Math.trunc(aY);
-        bX = Math.trunc(bX);
-        bY = Math.trunc(bY);
-
-        if (this.#elementArea.isValidPosition(aX, aY) && this.#elementArea.isValidPosition(bX, bY)) {
-            this.#elementArea.swap(aX, aY, bX, bY);
-        }
-    }
-
     /**
      *
      * @param x {number}
      * @param y {number}
-     * @param brushOrElement {Brush|Element}
+     * @param brushOrElement {Brush|Element|null}
      */
     draw(x, y, brushOrElement) {
         x = Math.trunc(x);
         y = Math.trunc(y);
 
         if (this.#elementArea.isValidPosition(x, y)) {
-            if (brushOrElement instanceof Element) {
+            if (brushOrElement === null) {
+                this.#elementArea.setElement(x, y, this.#defaults.getDefaultElement());
+                this.#triggerFunction(x, y);
+            } else if (brushOrElement instanceof Element) {
                 this.#elementArea.setElement(x, y, brushOrElement);
                 this.#triggerFunction(x, y);
             } else if (brushOrElement instanceof Brush) {
@@ -108,16 +97,28 @@ export class SandGameGraphics {
         x2 = Math.trunc(x2);
         y2 = Math.trunc(y2);
 
-        const d = Math.ceil(size / 2);
-
         let consumer;
         if (round) {
+            let maxLevel = Math.trunc(size / 2);
+
+            let blueprint;
+            if (maxLevel <= 3) {
+                blueprint = CircleIterator.BLUEPRINT_3;
+            } else if (maxLevel === 4) {
+                blueprint = CircleIterator.BLUEPRINT_4;
+            } else {
+                blueprint = CircleIterator.BLUEPRINT_9;
+            }
+
             consumer = (x, y) => {
-                CircleIterator.iterate(CircleIterator.BLUEPRINT_3, (dx, dy, level) => {
-                    this.draw(x + dx, y + dy, brush);
+                CircleIterator.iterate(blueprint, (dx, dy, level) => {
+                    if (level <= maxLevel) {
+                        this.draw(x + dx, y + dy, brush);
+                    }
                 });
             };
         } else {
+            const d = Math.ceil(size / 2);
             consumer = (x, y) => {
                 this.drawRectangle(x - d, y - d, x + d, y + d, brush);
             };
@@ -185,4 +186,8 @@ export class SandGameGraphics {
     getHeight() {
         return this.#elementArea.getHeight();
     }
+
+    getDefaults() {
+        return this.#defaults;
+    }
 }

src/core/Tool.js

@@ -4,7 +4,7 @@ import {CursorDefinition} from "./CursorDefinition.js";
  * @interface
  *
  * @author Patrik Harag
- * @version 2023-12-23
+ * @version 2023-12-28
  */
 export class Tool {
 
@@ -23,15 +23,7 @@ export class Tool {
         return this.#info;
     }
 
-    isStrokeEnabled() {
-        return false;
-    }
-
-    isSelectionEnabled() {
-        return false;
-    }
-
-    isRepeatingEnabled() {
+    hasCursor() {
         return false;
     }
 
@@ -43,6 +35,10 @@ export class Tool {
         return null;
     }
 
+    isRepeatingEnabled() {
+        return false;
+    }
+
     /**
      *
      * @param x {number}
@@ -52,7 +48,19 @@ export class Tool {
      * @return {void}
      */
     applyPoint(x, y, graphics, altModifier) {
-        throw 'Not implemented';
+        // no action by default
+    }
+
+    isLineModeEnabled() {
+        return false;
+    }
+
+    onDragStart(x, y, graphics, altModifier) {
+        // no action by default
+    }
+
+    onDragEnd(x, y, graphics, altModifier) {
+        // no action by default
     }
 
     /**
@@ -69,6 +77,10 @@ export class Tool {
         // no action by default
     }
 
+    isAreaModeEnabled() {
+        return false;
+    }
+
     /**
      *
      * @param x1 {number}
@@ -94,4 +106,20 @@ export class Tool {
     applySpecial(x, y, graphics, altModifier) {
         // no action by default
     }
+
+    isSecondaryActionEnabled() {
+        return false;
+    }
+
+    /**
+     *
+     * @param x {number}
+     * @param y {number}
+     * @param graphics {SandGameGraphics}
+     * @param altModifier {boolean}
+     * @return {void}
+     */
+    applySecondaryAction(x, y, graphics, altModifier) {
+        // no action by default
+    }
 }

src/core/Tools.js

@@ -2,14 +2,15 @@ import {RoundBrushTool} from "./tool/RoundBrushTool";
 import {PointBrushTool} from "./tool/PointBrushTool";
 import {Point2BrushTool} from "./tool/Point2BrushTool";
 import {MeteorTool} from "./tool/MeteorTool";
-import {InsertSceneTool} from "./tool/InsertSceneTool";
+import {InsertElementAreaTool} from "./tool/InsertElementAreaTool";
 import {InsertRandomSceneTool} from "./tool/InsertRandomSceneTool";
 import {ActionTool} from "./tool/ActionTool";
+import {MoveTool} from "./tool/MoveTool";
 
 /**
  *
  * @author Patrik Harag
- * @version 2023-12-25
+ * @version 2023-12-28
  */
 export class Tools {
 
@@ -29,9 +30,10 @@ export class Tools {
         return new MeteorTool(info);
     }
 
-    static insertElementAreaTool(info, scenes, handler) {
+    static insertScenesTool(info, scenes, handler) {
         if (scenes.length === 1) {
-            return new InsertSceneTool(info, scenes[0], handler);
+            const elementArea = InsertElementAreaTool.asElementArea(scenes[0]);
+            return new InsertElementAreaTool(info, elementArea, handler);
         } else {
             return new InsertRandomSceneTool(info, scenes, handler);
         }
@@ -40,4 +42,8 @@ export class Tools {
     static actionTool(info, handler) {
         return new ActionTool(info, handler);
     }
+
+    static moveTool(info, size) {
+        return new MoveTool(info, size);
+    }
 }

src/core/tool/InsertSceneTool.js renamed to src/core/tool/InsertElementAreaTool.js

@@ -6,9 +6,15 @@ import {Tool} from "../Tool";
 /**
  *
  * @author Patrik Harag
- * @version 2023-12-25
+ * @version 2023-12-28
  */
-export class InsertSceneTool extends Tool {
+export class InsertElementAreaTool extends Tool {
+
+    static asElementArea(scene) {
+        return scene.createElementArea(InsertElementAreaTool.DEFAULT_W, InsertElementAreaTool.DEFAULT_H,
+                ElementArea.TRANSPARENT_ELEMENT);
+    }
+
 
     static DEFAULT_W = 30;
     static DEFAULT_H = 30;
@@ -18,12 +24,9 @@ export class InsertSceneTool extends Tool {
     /** @type function */
     #onInsertHandler;
 
-    constructor(info, scene, onInsertHandler) {
+    constructor(info, elementArea, onInsertHandler) {
         super(info);
-
-        this.#elementArea = scene.createElementArea(
-            InsertSceneTool.DEFAULT_W, InsertSceneTool.DEFAULT_H, ElementArea.TRANSPARENT_ELEMENT);
-
+        this.#elementArea = elementArea;
         this.#onInsertHandler = onInsertHandler;
     }
 
@@ -66,6 +69,10 @@ export class InsertSceneTool extends Tool {
         }
     }
 
+    hasCursor() {
+        return true;
+    }
+
     createCursor() {
         return new CursorDefinitionElementArea(this.#elementArea);
     }

src/core/tool/InsertRandomSceneTool.js

@@ -1,11 +1,11 @@
 import {DeterministicRandom} from "../DeterministicRandom";
-import {InsertSceneTool} from "./InsertSceneTool";
+import {InsertElementAreaTool} from "./InsertElementAreaTool";
 import {Tool} from "../Tool";
 
 /**
  *
  * @author Patrik Harag
- * @version 2023-12-25
+ * @version 2023-12-29
  */
 export class InsertRandomSceneTool extends Tool {
 
@@ -31,14 +31,19 @@ export class InsertRandomSceneTool extends Tool {
 
         const i = DeterministicRandom.DEFAULT.nextInt(this.#scenes.length);
         const scene = this.#scenes[i];
-        this.#currentTool = new InsertSceneTool(this.getInfo(), scene, this.#onInsertHandler);
+        const elementArea = InsertElementAreaTool.asElementArea(scene);
+        this.#currentTool = new InsertElementAreaTool(this.getInfo(), elementArea, this.#onInsertHandler);
     }
 
     applyPoint(x, y, graphics, aldModifier) {
         this.#currentTool.applyPoint(x, y, graphics, aldModifier);
         this.#initRandomTool();
     }
 
+    hasCursor() {
+        return true;
+    }
+
     createCursor() {
         return this.#currentTool.createCursor();
     }