Move Game config into separate object

The 4 constructor arguments already were a bit confusing with two `number` types, also the game config will likely be the output of the matrix generator, so it makes sense to have a separate interface for that anyway.
2026-01-18 03:50:24 +00:00 · 2020-12-17 16:13:21 +01:00
parent d7bf259964
commit 76a1dd8774
3 changed files with 111 additions and 52 deletions
--- a/src/game/Game.test.ts
+++ b/src/game/Game.test.ts
@@ -1,5 +1,5 @@
 import "jest"
-import {EndState, Game, SelectionMode} from "./Game"
+import { EndState, Game, SelectionMode } from "./Game"

 describe("GameState", () => {
    const threeByThreeMatrix = [
@@ -12,42 +12,67 @@ describe("GameState", () => {
    const unlimitedTime = 999 * 1000

    test("getting size works", () => {
-        expect((new Game(["00"], [["AA"]], unrestrictedBuffer, unlimitedTime)).size).toEqual(1)
-        expect((new Game([
+        expect((new Game({ matrix: ["00"], sequences: [["AA"]], maxBufferLength: unrestrictedBuffer, timeout: unlimitedTime })).size).toEqual(1)
+        expect((new Game({
+            matrix: [
                "00", "01",
                "10", "11",
-                         ], [], unrestrictedBuffer, unlimitedTime)).size).toEqual(2)
+            ],
+            sequences: [],
+            maxBufferLength: unrestrictedBuffer,
+            timeout: unlimitedTime,
+        })).size).toEqual(2)
    });

    test("getting cell works", () => {
-        const game = new Game(threeByThreeMatrix, [["AA"]], unrestrictedBuffer, unlimitedTime);
+        const game = new Game({
+            matrix: threeByThreeMatrix,
+            sequences: [["AA"]],
+            maxBufferLength: unrestrictedBuffer,
+            timeout: unlimitedTime,
+        });
        expect(game.getCell(0, 2)).toEqual({ value: "02", isUsed: false })
    });

    describe("picking", () => {
        test("starts with free pick", () => {
-            const game = new Game([], [["AA"]], 1, unlimitedTime);
-            expect(game.state).toEqual({selectionMode: SelectionMode.FreePick})
+            const game = new Game({ matrix: [], sequences: [["AA"]], maxBufferLength: 1, timeout: unlimitedTime });
+            expect(game.state).toEqual({ selectionMode: SelectionMode.FreePick })
        });

        test("picking cells works", () => {
-            const game = new Game(threeByThreeMatrix, [["AA"]], unrestrictedBuffer, unlimitedTime);
+            const game = new Game({
+                matrix: threeByThreeMatrix,
+                sequences: [["AA"]],
+                maxBufferLength: unrestrictedBuffer,
+                timeout: unlimitedTime,
+            });
            game.pick(0, 0);
-            expect(game.state).toEqual({selectionMode: SelectionMode.RowPick, column: 0});
+            expect(game.state).toEqual({ selectionMode: SelectionMode.RowPick, column: 0 });
            expect(game.getCell(0, 0).isUsed).toEqual(true);
            expect(() => game.pick(0, 2)).toThrow();
            game.pick(2, 0);
-            expect(game.state).toEqual({selectionMode: SelectionMode.ColumnPick, row: 2});
+            expect(game.state).toEqual({ selectionMode: SelectionMode.ColumnPick, row: 2 });
        });

        test("cannot pick cell twice", () => {
-            const game = new Game(threeByThreeMatrix, [["AA"]], unrestrictedBuffer, unlimitedTime);
+            const game = new Game({
+                matrix: threeByThreeMatrix,
+                sequences: [["AA"]],
+                maxBufferLength: unrestrictedBuffer,
+                timeout: unlimitedTime,
+            });
            game.pick(0, 0);
            expect(() => game.pick(0, 0)).toThrow();
        });

        test("picking outside of range fails", () => {
-            const game = new Game(threeByThreeMatrix, [], unrestrictedBuffer, unlimitedTime);
+            const game = new Game({
+                matrix: threeByThreeMatrix,
+                sequences: [],
+                maxBufferLength: unrestrictedBuffer,
+                timeout: unlimitedTime,
+            });
            expect(() => game.pick(-1, 0)).toThrow();
            expect(() => game.pick(0, -1)).toThrow();
            expect(() => game.pick(3, 0)).toThrow();
@@ -56,45 +81,60 @@ describe("GameState", () => {

        test("picking fills buffer, fulfills sequence", () => {
            const simpleSequence = ["00", "10", "20"]
-            const game = new Game(threeByThreeMatrix, [simpleSequence], unrestrictedBuffer, unlimitedTime);
-            expect(game.getSequences()).toEqual([{sequence: simpleSequence, numberOfFulfilled: 0}])
+            const game = new Game({
+                matrix: threeByThreeMatrix,
+                sequences: [simpleSequence],
+                maxBufferLength: unrestrictedBuffer,
+                timeout: unlimitedTime,
+            });
+            expect(game.getSequences()).toEqual([{ sequence: simpleSequence, numberOfFulfilled: 0 }])
            game.pick(0, 0);
            expect(game.buffer).toEqual([{
                positionInMatrixRow: 0,
                positionInMatrixColumn: 0,
                value: "00"
            }]);
-            expect(game.getSequences()).toEqual([{sequence: simpleSequence, numberOfFulfilled: 1}])
+            expect(game.getSequences()).toEqual([{ sequence: simpleSequence, numberOfFulfilled: 1 }])
        });

        test("picking fulfills second sequence occurence", () => {
            const sequence = ["AA", "BB", "CC"]
-            const game = new Game([
+            const game = new Game({
+                matrix: [
                    "AA", "AA", "BB",
                    "BB", "CC", "AA",
                    "CC", "CC", "CC",
-                ], [sequence], unrestrictedBuffer, unlimitedTime);
-            expect(game.getSequences()).toEqual([{sequence: sequence, numberOfFulfilled: 0}])
+                ],
+                sequences: [sequence],
+                maxBufferLength: unrestrictedBuffer,
+                timeout: unlimitedTime,
+            });
+            expect(game.getSequences()).toEqual([{ sequence: sequence, numberOfFulfilled: 0 }])
            game.pick(0, 0);
-            expect(game.getSequences()).toEqual([{sequence: sequence, numberOfFulfilled: 1}])
+            expect(game.getSequences()).toEqual([{ sequence: sequence, numberOfFulfilled: 1 }])
            game.pick(2, 0);
-            expect(game.getSequences()).toEqual([{sequence: sequence, numberOfFulfilled: 2}])
+            expect(game.getSequences()).toEqual([{ sequence: sequence, numberOfFulfilled: 2 }])
            game.pick(2, 1);
-            expect(game.getSequences()).toEqual([{sequence: sequence, numberOfFulfilled: 1}])
+            expect(game.getSequences()).toEqual([{ sequence: sequence, numberOfFulfilled: 1 }])
            game.pick(0, 1);
-            expect(game.getSequences()).toEqual([{sequence: sequence, numberOfFulfilled: 2}])
+            expect(game.getSequences()).toEqual([{ sequence: sequence, numberOfFulfilled: 2 }])
            game.pick(0, 2);
-            expect(game.getSequences()).toEqual([{sequence: sequence, numberOfFulfilled: 3}])
+            expect(game.getSequences()).toEqual([{ sequence: sequence, numberOfFulfilled: 3 }])
        });
    });

    describe("game end conditions", () => {
        test("game won", () => {
-            const game = new Game([
+            const game = new Game({
+                matrix: [
                    "AA", "AA", "BB",
                    "BB", "CC", "AA",
                    "CC", "CC", "CC",
-                ], [["AA", "BB", "CC"]], 3, unlimitedTime)
+                ],
+                sequences: [["AA", "BB", "CC"]],
+                maxBufferLength: 3,
+                timeout: unlimitedTime,
+            })
            game.pick(0, 0)
            game.pick(2, 0)
            game.pick(2, 2)
@@ -103,11 +143,16 @@ describe("GameState", () => {
        })

        test("game loose", () => {
-            const game = new Game([
+            const game = new Game({
+                matrix: [
                    "AA", "AA", "BB",
                    "BB", "CC", "AA",
                    "CC", "CC", "CC",
-                ], [["AA", "BB", "CC"]], 3, unlimitedTime)
+                ],
+                sequences: [["AA", "BB", "CC"]],
+                maxBufferLength: 3,
+                timeout: unlimitedTime,
+            })
            game.pick(0, 0)
            game.pick(1, 0)
            game.pick(1, 2)
@@ -133,11 +178,16 @@ describe("GameState", () => {
        }

        test("loosing through timeout works", () => {
-            const game = new Game([
+            const game = new Game({
+                matrix: [
                    "AA", "AA", "BB",
                    "BB", "CC", "AA",
                    "CC", "CC", "CC",
-            ], [["AA"]], 3, 10_000)
+                ],
+                sequences: [["AA"]],
+                maxBufferLength: 3,
+                timeout: 10_000,
+            })
            fakeTimeProgress(1_000)
            expect(game.remainingMilliseconds).toEqual(9_000)
            fakeTimeProgress(1_000)
@@ -150,11 +200,17 @@ describe("GameState", () => {
        })

        test("clock stops when game is won", () => {
-            const game = new Game([
+            const game = new Game({
+                matrix: [
                    "AA", "AA", "BB",
                    "BB", "CC", "AA",
                    "CC", "CC", "CC",
-            ], [["AA"]], 3, 10_000)
+                ],
+                sequences: [["AA"]],
+                maxBufferLength: unrestrictedBuffer,
+                timeout: 10_000,
+            }
+            )
            fakeTimeProgress(1_000)
            game.pick(0, 0)
            expect(game.remainingMilliseconds).toEqual(9_000)
--- a/src/game/Game.ts
+++ b/src/game/Game.ts
@@ -1,3 +1,5 @@
+import GameConfiguration from "./GameConfiguration";
+
 export enum EndState {
    Won,
    Lost,
@@ -95,31 +97,26 @@ export class Game {
    private readonly startTimeTimeStamp: number
    private endTimestamp: number | null = null

-    constructor(
-        public readonly matrix: string[],
-        private readonly sequences: string[][],
-        public readonly maxBufferLength: number,
-        public readonly timeout: number,
-    ) {
-        this.size = Math.sqrt(matrix.length)
+    constructor(private readonly config: GameConfiguration) {
+        this.size = Math.sqrt(config.matrix.length)
        this.timeoutInterval = setTimeout(() => {
                this.state = EndState.Lost
                this.stopClock()
            },
-            this.timeout)
+            this.config.timeout)
        this.startTimeTimeStamp = Date.now()
    }

    get remainingMilliseconds(): number {
        if (this.endTimestamp) {
-            return this.timeout - (this.endTimestamp - this.startTimeTimeStamp)
+            return this.config.timeout - (this.endTimestamp - this.startTimeTimeStamp)
        }
-        return this.timeout - (Date.now() - this.startTimeTimeStamp)
+        return this.config.timeout - (Date.now() - this.startTimeTimeStamp)
    }

    getCell(row: number, column: number): Cell {
        return {
-            value: this.matrix[row + column * this.size],
+            value: this.config.matrix[row + column * this.size],
            isUsed: this.buffer.some(x =>
                x.positionInMatrixRow == row &&
                x.positionInMatrixColumn == column
@@ -128,7 +125,7 @@ export class Game {
    }

    getSequences(): Sequence[] {
-        return this.sequences.map(sequence => {
+        return this.config.sequences.map(sequence => {
            let longestPrefixLength = 0
            for (let i = 0; i < this.buffer.length; ++i) {
                let prefixLength = 0;
@@ -162,7 +159,7 @@ export class Game {
            this.state = EndState.Won
        } else {
            this.stopClock()
-            if (this.buffer.length >= this.maxBufferLength) {
+            if (this.buffer.length >= this.config.maxBufferLength) {
                this.state = EndState.Lost
            }
        }
--- a/src/game/GameConfiguration.ts
+++ b/src/game/GameConfiguration.ts
@@ -0,0 +1,6 @@
+export default interface GameConfiguration {
+    matrix: string[]
+    sequences: string[][]
+    maxBufferLength: number
+    timeout: number
+}