@bitblit/ratchet-maze 6.0.146-alpha → 6.0.148-alpha

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@bitblit/ratchet-maze",
-  "version": "6.0.146-alpha",
+  "version": "6.0.148-alpha",
   "description": "My silly tools for mazes",
   "type": "module",
   "files": [
+    "src/**",
     "lib/**",
     "bin/**"
   ],
@@ -43,6 +44,6 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "@bitblit/ratchet-common": "6.0.146-alpha"
+    "@bitblit/ratchet-common": "6.0.148-alpha"
   }
 }

package/src/build/ratchet-maze-info.ts

@@ -0,0 +1,20 @@
+import { BuildInformation } from '@bitblit/ratchet-common/build/build-information';
+
+export class RatchetInfo {
+  // Prevent instantiation
+  // eslint-disable-next-line @typescript-eslint/no-empty-function
+  private constructor() {
+  }
+
+  public static buildInformation(): BuildInformation {
+    const val: BuildInformation = {
+      version: 'LOCAL-SNAPSHOT',
+      hash: 'LOCAL-HASH',
+      branch: 'LOCAL-BRANCH',
+      tag: 'LOCAL-TAG',
+      timeBuiltISO: 'LOCAL-TIME-ISO',
+      notes: 'LOCAL-NOTES',
+    };
+    return val;
+  }
+}

package/src/model/binary-generator.ts

@@ -0,0 +1,30 @@
+import { RectangularMaze } from "./rectangular-maze.js";
+
+// 0,1,2,3...width-1
+// width,
+
+export class BinaryGenerator {
+
+  public static generate(width: number, height: number): RectangularMaze {
+    const rval: RectangularMaze = new RectangularMaze(width, height);
+    for (let y = 0; y < height; y++) {
+      for (let x = 0; x < width; x++) {
+        if (y === 0) {
+          if (x < width - 1) {
+            rval.addPassage({ x, y }, { x: x + 1, y: y });
+          }
+        } else if (x === width - 1) {
+          rval.addPassage({ x, y }, { x: x, y: y - 1 });
+        } else {
+          const flip: number = Math.random();
+          if (flip <= .5) {
+            rval.addPassage({ x, y }, { x: x + 1, y: y });
+          } else {
+            rval.addPassage({ x, y }, { x: x, y: y - 1 });
+          }
+        }
+      }
+    }
+    return rval;
+  }
+}

package/src/model/coordinate.ts

@@ -0,0 +1,4 @@
+export interface Coordinate {
+  x: number;
+  y: number;
+}

package/src/model/direction.ts

@@ -0,0 +1,3 @@
+export enum Direction {
+  North='North',South='South',East='East',West='West'
+}

package/src/model/drawing-util.ts

@@ -0,0 +1,106 @@
+import { RectangularMaze } from "./rectangular-maze.js";
+import { RequireRatchet } from "@bitblit/ratchet-common/lang/require-ratchet";
+
+import fs from "fs";
+import { Direction } from "./direction.js";
+import { StringRatchet } from "@bitblit/ratchet-common/lang/string-ratchet";
+import { BinaryGenerator } from "./binary-generator";
+
+// 0,1,2,3...width-1
+// width,
+
+export class DrawingUtil {
+
+  public static formatBitmapToString(bmap: string[][], lineEnd: string = '\n'): string {
+    const rval: string = bmap.map(s=>s.join(' ')).join(lineEnd);
+    return rval;
+  }
+
+  public static rectangularMazeToBitmap(maze: RectangularMaze): string[][] {
+    RequireRatchet.notNullOrUndefined(maze);
+    RequireRatchet.true(maze.width>0);
+    RequireRatchet.true(maze.height>0);
+
+    const rval: string[][]=[];
+
+    for (let y=0;y<maze.height;y++) {
+      const curRow: string[] = [];
+      for (let x=0;x<maze.width;x++) {
+        if (maze.isDisabled({x:x, y:y})) {
+          curRow.push('X');
+        } else {
+          let num: number = 0;
+          num += maze.hasWall({x,y}, Direction.North) ? 1 : 0;
+          num += maze.hasWall({x,y}, Direction.East) ? 2 : 0;
+          num += maze.hasWall({x,y}, Direction.South) ? 4 : 0;
+          num += maze.hasWall({x,y}, Direction.West) ? 8 : 0;
+          curRow.push(StringRatchet.HEXITS[num]);
+        }
+      }
+      rval.push(curRow);
+    }
+
+    return rval;
+  }
+
+
+  public static rectangularMazeToSvg(maze: RectangularMaze, opts?: RectangularMazeDrawOptions): string {
+    RequireRatchet.notNullOrUndefined(maze);
+    RequireRatchet.true(maze.width>0);
+    RequireRatchet.true(maze.height>0);
+
+    const widthPx: number = maze.width * opts.cellSize;
+    const heightPx: number = maze.height * opts.cellSize;
+
+    let rval: string =
+      `<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0  ${widthPx} ${heightPx}"><g> \n`
+     // `<text x="10" y="10" font-family="Style_Script, cursive" font-size="2">Test</text>`;
+
+    for (let y=0;y<maze.height;y++) {
+      for (let x=0;x<maze.width;x++) {
+        // Upper left corner
+        const uX: number = x * opts.cellSize;
+        const uY: number = y * opts.cellSize;
+        if (maze.isDisabled({x:x, y:y})) {
+
+          //curRow.push('X');
+        } else {
+          if (maze.hasWall({x,y}, Direction.North)) {
+            rval+=`<polyline stroke="#000080" stroke-width="1" fill="none" points="${uX},${uY} ${uX+opts.cellSize} ${uY}" />\n`;
+          }
+          if (maze.hasWall({x,y}, Direction.East)) {
+            rval+=`<polyline stroke="#000080" stroke-width="1" fill="none" points="${uX+opts.cellSize},${uY} ${uX+opts.cellSize} ${uY+opts.cellSize}" />\n`;
+          }
+          if (maze.hasWall({x,y}, Direction.South)) {
+            rval+=`<polyline stroke="#000080" stroke-width="1" fill="none" points="${uX},${uY+opts.cellSize} ${uX+opts.cellSize} ${uY+opts.cellSize}" />\n`;
+          }
+          if (maze.hasWall({x,y}, Direction.West)) {
+            rval+=`<polyline stroke="#000080" stroke-width="1" fill="none" points="${uX},${uY+opts.cellSize} ${uX} ${uY}" />\n`;
+          }
+        }
+      }
+    }
+
+    rval+='</g></svg>';
+
+    return rval;
+  }
+
+}
+
+export interface RectangularMazeDrawOptions {
+  backgroundColor: string;
+  wallColor: string;
+  disabledColor: string;
+  cellSize: number;
+}
+
+// DELETE ME
+//x.addPassage(0,1);
+//x.addPassage(1,3);
+//const bmap: string[][]=DrawingUtil.rectangularMazeToBitmap(x);
+//console.log(DrawingUtil.formatBitmapToString(bmap));
+//const x: RectangularMaze = new RectangularMaze(10,10);
+//const x: RectangularMaze = BinaryGenerator.generate(20,20);// new RectangularMaze(2,2);
+//const out: string = DrawingUtil.rectangularMazeToSvg(x, {backgroundColor: '#FFF', wallColor: '#000', disabledColor: '#333', cellSize: 10});
+//fs.writeFileSync('test.svg', out);

package/src/model/rectangular-maze.ts

@@ -0,0 +1,135 @@
+import { Coordinate } from "./coordinate.js";
+import { RequireRatchet } from "@bitblit/ratchet-common/lang/require-ratchet";
+import { Direction } from "./direction.js";
+
+// 0,1,2,3...width-1
+// width,
+
+export class RectangularMaze {
+
+  private disabledIdx: Set<number> = new Set<number>();
+  private passages: Map<number, Set<number>> = new Map<number, Set<number>>();
+
+  constructor(private _width: number, private _height: number) {
+  }
+
+  public isDisabled(idx: number | Coordinate): boolean {
+    if (typeof idx === 'number') {
+      return this.disabledIdx.has(idx);
+    } else {
+      return this.disabledIdx.has(this.coordinateToIndex(idx));
+    }
+  }
+
+  public neighborCoordinate(idx:number | Coordinate, direction: Direction): Coordinate {
+    let rval: Coordinate = structuredClone((typeof idx==='number') ? this.indexToCoordinate(idx) : idx);
+
+    switch (direction) {
+      case Direction.North : rval.y--;break;
+      case Direction.South : rval.y++;break;
+      case Direction.East : rval.x++;break;
+      case Direction.West : rval.x--;break;
+      default: throw new Error('Cannot happen - invalid direction');
+    }
+
+    if (rval.x<0 || rval.y<0 || rval.x >=this.width || rval.y>=this.height) {
+      rval = null;
+    }
+
+    return rval;
+  }
+
+
+  public neighborIdx(idx:number, direction: Direction): number {
+    const n = this.neighborCoordinate(idx, direction);
+    return n===null ? null : this.coordinateToIndex(n);
+  }
+
+  public hasWall(idx: number | Coordinate, direction: Direction): boolean {
+    const idx1: number = (typeof(idx)==='number') ? idx : this.coordinateToIndex(idx);
+    const idx2: number = this.neighborIdx(idx1, direction);
+    return !this.hasPassage(idx1, idx2);
+  }
+
+  public get width(): number {
+    return this._width;
+  }
+
+  public get height(): number {
+    return this._height;
+  }
+
+  public coordinateToIndex(coord: Coordinate): number {
+    RequireRatchet.true(coord.x < this.width);
+    RequireRatchet.true(coord.y < this.height);
+    return (coord.y * this.width) + coord.x;
+  }
+
+  public indexToCoordinate(idx: number): Coordinate {
+    const row: number = Math.floor(idx/this.width);
+    const rval: Coordinate = {
+      x: idx - (row*this.width),
+      y: row
+    };
+    return rval;
+  }
+
+  public get maxIdx(): number {
+    return this.coordinateToIndex({x: this.width-1, y: this.height-1});
+  }
+
+  public validIdx(idx: number): boolean {
+    const crd: Coordinate = this.indexToCoordinate(idx);
+    return crd.x < this.width && crd.y < this.height;
+  }
+
+  public get allIdxWithPassages(): Set<number> {
+    const rval: Set<number> = new Set<number>();
+    Array.from(this.passages.values()).forEach(vals=>{
+      Array.from(vals).forEach(s=>rval.add(s));
+    })
+    return rval;
+  }
+
+  public disable(idx: number): void {
+    RequireRatchet.true(this.validIdx(idx));
+    RequireRatchet.true(!this.passages.has(idx));
+    RequireRatchet.true(!this.allIdxWithPassages.has(idx));
+    this.disabledIdx.add(idx);
+  }
+
+  public hasPassage(idx1: number, idx2: number): boolean {
+    let rval: boolean = false;
+    if (idx1!==null && idx2!==null) {
+      const vals: Set<number> = this.passages.get(Math.min(idx1, idx2));
+      rval = vals && vals.has(Math.max(idx1, idx2));
+    }
+    return rval;
+  }
+
+
+  public addPassage(idxC1: number | Coordinate, idxC2: number | Coordinate) : void {
+    RequireRatchet.notNullOrUndefined(idxC1);
+    RequireRatchet.notNullOrUndefined(idxC2);
+    const idx1: number = (typeof idxC1 ==='number') ? idxC1 : this.coordinateToIndex(idxC1);
+    const idx2: number = (typeof idxC2 ==='number') ? idxC2 : this.coordinateToIndex(idxC2);
+
+    RequireRatchet.true(this.validIdx(idx1));
+    RequireRatchet.true(this.validIdx(idx2));
+    RequireRatchet.true(!this.disabledIdx.has(idx1));
+    RequireRatchet.true(!this.disabledIdx.has(idx2));
+
+    const cur: Set<number> = this.passages.get(Math.min(idx1, idx2)) ?? new Set<number>;
+    cur.add(Math.max(idx1,idx2));
+    this.passages.set(Math.min(idx1,idx2), cur);
+  }
+
+  public removePassage(idx1: number, idx2: number) : void {
+    RequireRatchet.true(this.validIdx(idx1));
+    RequireRatchet.true(this.validIdx(idx2));
+
+    const cur: Set<number> = this.passages.get(Math.min(idx1, idx2)) ?? new Set<number>;
+    cur.delete(Math.max(idx1, idx2));
+  }
+
+}