Initial implementation

Author: cscleison

.github/workflows/main.yml

@@ -0,0 +1,19 @@
+on: push
+
+jobs:
+  test:
+    runs-on: ubuntu-16.04
+    steps:
+      - name: checkout actions
+        uses: actions/checkout@master
+
+      - name: set Node to 12.x
+        uses: actions/setup-node@v1
+        with:
+          node-version: "12.x"
+
+      - name: install dependencies
+        run: npm ci
+
+      - name: run tests
+        run: npm t

.gitignore

@@ -0,0 +1 @@
+node_modules

.prettierignore

@@ -0,0 +1 @@
+settings

README.md

@@ -1 +1,16 @@
-# ts-challenge
+# ts-challenge
+
+How to run:
+
+- click here https://cscleison.github.io/ts-challenge/
+
+OR
+
+- `npm i`
+- `npm start`
+- open `index.html`
+
+Design decisions:
+
+- validates all the settings before the game starts
+- all functions are immutable

__tests__/board.test.ts

@@ -0,0 +1,65 @@
+import { Board, checkTile, runAction, TileStatus, Turtle } from "../src/board";
+import { Tile } from "../src/navigation";
+
+const zeroTile: Tile = { x: 0, y: 0 };
+
+describe("run action", () => {
+  it("should move the turtle north", () => {
+    const moved: Turtle = {
+      direction: 0,
+      tile: { x: 0, y: -1 }
+    };
+    expect(runAction("m", { direction: 0, tile: zeroTile })).toEqual(moved);
+  });
+
+  it("should rotate the turtle", () => {
+    const rotated: Turtle = {
+      direction: 1,
+      tile: zeroTile
+    };
+    expect(runAction("r", { direction: 0, tile: zeroTile })).toEqual(rotated);
+  });
+});
+
+describe("check tile", () => {
+  const mine: Tile = { x: 1, y: 1 };
+  const exit: Tile = { x: 2, y: 2 };
+
+  const board: Board = {
+    xLength: 3,
+    yLength: 3,
+    mines: [mine],
+    exit
+  };
+  const checkStatus = checkTile(board);
+
+  it("should be on the exit", () => {
+    const onExit: TileStatus = "onExit";
+    expect(checkStatus({ ...exit })).toBe(onExit);
+  });
+
+  it("should be on a mine", () => {
+    const onMine: TileStatus = "onMine";
+    expect(checkStatus({ ...mine })).toBe(onMine);
+  });
+
+  it("should be out of bounds", () => {
+    const outOfBounds: TileStatus = "outOfBounds";
+    const outsiders: Tile[] = [
+      { x: -1, y: 0 },
+      { x: -100, y: 0 },
+      { x: 0, y: -1 },
+      { x: 0, y: -100 },
+      { x: 0, y: 3 },
+      { x: 0, y: 300 },
+      { x: 3, y: 0 },
+      { x: 300, y: 0 }
+    ];
+    outsiders.forEach(t => expect(checkStatus(t)).toBe(outOfBounds));
+  });
+
+  it("should be in danger", () => {
+    const inDanger: TileStatus = "inDanger";
+    expect(checkStatus(zeroTile)).toBe(inDanger);
+  });
+});

__tests__/game.test.ts

@@ -0,0 +1,50 @@
+import { Action, Board, TileStatus, Turtle } from "../src/board";
+import { runSequence } from "../src/game";
+
+describe("run sequence", () => {
+  const zeroTurtle: Turtle = { direction: 0, tile: { x: 0, y: 0 } };
+  const board: Board = {
+    xLength: 3,
+    yLength: 3,
+    mines: [{ x: 2, y: 0 }],
+    exit: { x: 0, y: 1 }
+  };
+
+  it("should return outOfBounds", () => {
+    const outOfBounds: TileStatus = "outOfBounds";
+    expect(runSequence(["m"], zeroTurtle, board)).toBe(outOfBounds);
+  });
+
+  it("should return onMine", () => {
+    const onMine: TileStatus = "onMine";
+    const explosives: Action[][] = [
+      ["r", "m", "m"],
+      ["r", "m", "m", "m"] // extra move to see if it stops
+    ];
+
+    explosives.forEach(sequence =>
+      expect(runSequence(sequence, zeroTurtle, board)).toBe(onMine)
+    );
+  });
+
+  it("should return onExit", () => {
+    const onExit: TileStatus = "onExit";
+    const successful: Action[][] = [
+      ["r", "r", "m"],
+      ["r", "r", "m", "m"] // extra move to see if it stops
+    ];
+
+    successful.forEach(sequence =>
+      expect(runSequence(sequence, zeroTurtle, board)).toBe(onExit)
+    );
+  });
+
+  it("should return inDanger", () => {
+    const inDanger: TileStatus = "inDanger";
+    const dangerous: Action[][] = [["r", "m"], ["r", "r", "r", "r"]];
+
+    dangerous.forEach(sequence =>
+      expect(runSequence(sequence, zeroTurtle, board)).toBe(inDanger)
+    );
+  });
+});

__tests__/navigation.test.ts

@@ -0,0 +1,64 @@
+import {
+  DIRECTIONS,
+  isOnTiles,
+  isSameTile,
+  move,
+  rotate,
+  Tile
+} from "../src/navigation";
+
+const zeroTile: Tile = { x: 0, y: 0 };
+
+describe("move", () => {
+  it("should move a tile north", () => {
+    const moved: Tile = { x: 0, y: -1 };
+    expect(move(zeroTile, DIRECTIONS.North)).toEqual(moved);
+  });
+
+  it("should move a tile east", () => {
+    const moved: Tile = { x: 1, y: 0 };
+    expect(move(zeroTile, DIRECTIONS.East)).toEqual(moved);
+  });
+
+  it("should move a tile south", () => {
+    const moved: Tile = { x: 0, y: 1 };
+    expect(move(zeroTile, DIRECTIONS.South)).toEqual(moved);
+  });
+
+  it("should move a tile west", () => {
+    const moved: Tile = { x: -1, y: 0 };
+    expect(move(zeroTile, DIRECTIONS.West)).toEqual(moved);
+  });
+});
+
+describe("rotate", () => {
+  it("should rotate from north to east", () => {
+    expect(rotate(DIRECTIONS.North)).toBe(DIRECTIONS.East);
+  });
+
+  it("should rotate from west to north", () => {
+    expect(rotate(DIRECTIONS.West)).toBe(DIRECTIONS.North);
+  });
+});
+
+describe("is the same tile", () => {
+  it("should be the same tile", () => {
+    expect(isSameTile(zeroTile, zeroTile)).toBeTruthy();
+    expect(isSameTile(zeroTile, { ...zeroTile })).toBeTruthy();
+  });
+
+  it("should NOT be the same tile", () => {
+    expect(isSameTile(zeroTile, { x: 1, y: 0 })).toBeFalsy();
+    expect(isSameTile(zeroTile, { x: 0, y: 1 })).toBeFalsy();
+  });
+});
+
+describe("is on tiles", () => {
+  it("should be on tiles", () => {
+    expect(isOnTiles(zeroTile, [{ ...zeroTile }, { x: 1, y: 1 }])).toBeTruthy();
+  });
+
+  it("should NOT be on tiles", () => {
+    expect(isOnTiles(zeroTile, [{ x: 1, y: 1 }, { x: 2, y: 2 }])).toBeFalsy();
+  });
+});