Started on the game logic

src/game/Game.ts

@@ -0,0 +1,125 @@
+export enum EndState {
+    Won,
+    Lost,
+}
+
+export enum SelectionMode {
+    FreePick,
+    RowPick,
+    ColumnPick,
+}
+
+type FreeSelection = {
+    selectionMode: SelectionMode.FreePick,
+}
+
+type RowSelection = {
+    selectionMode: SelectionMode.RowPick,
+    column: number;
+}
+
+type ColumnSelection = {
+    selectionMode: SelectionMode.ColumnPick,
+    row: number;
+}
+
+type SelectionState = FreeSelection | RowSelection | ColumnSelection;
+
+type State = SelectionState | EndState.Won | EndState.Lost;
+
+interface StateSpecificHandler<T> {
+    Won(): T
+    Lost(): T
+    InProgress(selectionState: SelectionState): T
+}
+
+function matchState<T>(h: StateSpecificHandler<T>): (a: State) => T {
+    return (a: State) => {
+        switch (a) {
+            case EndState.Won:
+                return h.Won();
+            case EndState.Lost:
+                return h.Lost();
+            default:
+                return h.InProgress(a);
+        }
+    }
+}
+
+interface SelectionStateSpecificHandler<T> {
+    Free(): T;
+    Row(row: number): T;
+    Column(column: number): T;
+}
+
+function matchSelectionState<T>(h: SelectionStateSpecificHandler<T>): (a: SelectionState) => T {
+    return (a: SelectionState) => {
+        switch (a.selectionMode) {
+            case SelectionMode.FreePick:
+                return h.Free();
+            case SelectionMode.RowPick:
+                return h.Row(a.column);
+            case SelectionMode.ColumnPick:
+                return h.Column(a.row);
+        }
+    }
+}
+
+class IllegalMoveError extends Error {
+    constructor() {
+        super("Illegal move!")
+    }
+}
+
+export class Game {
+    state: State = {selectionMode: SelectionMode.FreePick}
+    public readonly size: number
+
+    constructor(public readonly matrix: string[]) {
+        this.size = Math.sqrt(matrix.length)
+    }
+
+    getCell(row: number, column: number) {
+        return this.matrix[row + column * this.size]
+    }
+
+    pick(row: number, column: number): void {
+        if (row < 0 || column < 0 || row >= this.size || column >= this.size) {
+            throw new IllegalMoveError()
+        }
+
+        matchState({
+            Won: () => {throw new IllegalMoveError()},
+            Lost: () => {throw new IllegalMoveError()},
+            InProgress: (selectionMode) =>
+                matchSelectionState({
+                    Free: () => {
+                        this.state = {
+                            selectionMode: SelectionMode.RowPick,
+                            column: column,
+                        };
+                    },
+                    Column: (r) => {
+                        if (r === row) {
+                            this.state = {
+                                selectionMode: SelectionMode.RowPick,
+                                column: column,
+                            }
+                        } else {
+                            throw new IllegalMoveError()
+                        }
+                    },
+                    Row: (c) => {
+                        if (c === column) {
+                            this.state = {
+                                selectionMode: SelectionMode.ColumnPick,
+                                row: row,
+                            }
+                        } else {
+                            throw new IllegalMoveError()
+                        }
+                    },
+                })(selectionMode),
+        })(this.state)
+    }
+}