From eebca998cb8709b4d4f6c928114604f38e2ab1cf Mon Sep 17 00:00:00 2001
From: Marvin Blum <marvin.blum@emvi.com>
Date: Mon, 21 Dec 2020 17:27:16 +0100
Subject: [PATCH] Manage game state through object injection everywhere, fixed
 filling buffer and stopping clock in Game.

---
 src/App.vue                  | 24 ++++--------------------
 src/components/Buffer.vue    | 10 ++++++----
 src/components/Matrix.vue    | 23 +++++++++++++++++------
 src/components/Sequences.vue |  6 ++++--
 src/components/Timer.vue     | 22 +++++++++++++++++++---
 src/components/timer.ts      | 28 ----------------------------
 src/game/Game.test.ts        |  4 ++++
 src/game/Game.ts             | 23 +++++++++++------------
 src/sass/main.scss           |  5 +++++
 9 files changed, 70 insertions(+), 75 deletions(-)
 delete mode 100644 src/components/timer.ts

diff --git a/src/App.vue b/src/App.vue
index 6bb5d41..e7c3b6a 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -8,13 +8,12 @@
 </template>
 
 <script lang="ts">
-    import {defineComponent, provide, ref, readonly} from "vue";
+    import {defineComponent, provide, ref} from "vue";
     import Level from "./components/Level.vue";
     import Timer from "./components/Timer.vue";
     import Buffer from "./components/Buffer.vue";
     import Matrix from "./components/Matrix.vue";
     import { Game } from "./game/Game";
-    import {useTimer} from "./components/timer";
 
     export default defineComponent({
         components: {
@@ -24,8 +23,7 @@
             Matrix
         },
         setup() {
-            const {updateCountdown} = useTimer();
-            const game = new Game({
+            const game = ref(new Game({
                 matrix: [
                     "AA", "BB", "CC",
                     "DD", "AA", "BB",
@@ -36,23 +34,9 @@
                 ],
                 maxBufferLength: 3,
                 timeoutMilliseconds: 60_000,
-            });
+            }));
+            provide("game", game);
             const level = ref(1);
-            const remainingMilliseconds = ref(game.remainingMilliseconds);
-            const timeoutMilliseconds = ref(game.timeoutMilliseconds);
-            const maxBufferLength = ref(game.maxBufferLength);
-            const buffer = ref(game.buffer);
-            const sequences = ref(game.sequences);
-            const size = ref(game.size);
-            const matrix = ref(game.matrix);
-            provide("remainingMilliseconds", readonly(remainingMilliseconds));
-            provide("timeoutMilliseconds", readonly(timeoutMilliseconds));
-            provide("maxBufferLength", readonly(maxBufferLength));
-            provide("buffer", readonly(buffer));
-            provide("sequences", readonly(sequences));
-            provide("size", readonly(size));
-            provide("matrix", readonly(matrix));
-            updateCountdown(game, remainingMilliseconds);
 
             return {
                 level
diff --git a/src/components/Buffer.vue b/src/components/Buffer.vue
index 9ddc235..a9a6ea3 100644
--- a/src/components/Buffer.vue
+++ b/src/components/Buffer.vue
@@ -3,7 +3,7 @@
         <h2>Buffer</h2>
         <div class="buffer-slots">
             <div class="buffer-slots-slot buffer-slots-border" v-for="(slot, i) in maxBufferLength" :key="i">
-                <span v-if="buffer.length > i">{{buffer[i]}}</span>
+                <span v-if="buffer.length > i">{{buffer[i].value}}</span>
             </div>
         </div>
         <Sequences />
@@ -11,7 +11,8 @@
 </template>
 
 <script lang="ts">
-    import {defineComponent, inject} from "vue";
+    import { Game } from "@/game/Game";
+    import {defineComponent, inject, Ref, computed} from "vue";
     import Sequences from "./Sequences.vue";
     
     export default defineComponent({
@@ -19,8 +20,9 @@
             Sequences
         },
         setup() {
-            const maxBufferLength = inject("maxBufferLength");
-            const buffer = inject("buffer");
+            const game = inject("game") as Ref<Game>;
+            const maxBufferLength = computed(() => game.value.maxBufferLength);
+            const buffer = computed(() => game.value.buffer);
 
             return {
                 maxBufferLength,
diff --git a/src/components/Matrix.vue b/src/components/Matrix.vue
index 1f23f57..823243c 100644
--- a/src/components/Matrix.vue
+++ b/src/components/Matrix.vue
@@ -2,24 +2,35 @@
     <div class="matrix">
         <h2>Code-Matrix</h2>
         <div class="matrix-row" v-for="i in size" :key="i">
-            <div class="matrix-column" v-for="j in size" :key="j">
-                {{matrix[(i - 1)*size + (j - 1)]}}
+            <div class="matrix-column" v-for="j in size" :key="j" v-on:click="select(i, j)">
+                {{matrix[(j - 1)*size + (i - 1)]}}
             </div>
         </div>
     </div>
 </template>
 
 <script lang="ts">
-    import {defineComponent, inject} from "vue";
+    import { Game } from "@/game/Game";
+    import {defineComponent, inject, computed, Ref} from "vue";
     
     export default defineComponent({
         setup() {
-            const size = inject("size");
-            const matrix = inject("matrix");
+            const game = inject("game") as Ref<Game>;
+            const size = computed(() => game.value.size);
+            const matrix = computed(() => game.value.matrix);
+
+            function select(row: number, column: number) {
+                try {
+                    game.value.pick(row-1, column-1);
+                } catch (e) {
+                    console.log("nö!");
+                }
+            }
 
             return {
                 size,
-                matrix
+                matrix,
+                select
             }
         }
     });
diff --git a/src/components/Sequences.vue b/src/components/Sequences.vue
index ed05921..60e6464 100644
--- a/src/components/Sequences.vue
+++ b/src/components/Sequences.vue
@@ -10,11 +10,13 @@
 </template>
 
 <script lang="ts">
-    import {defineComponent, inject} from "vue";
+    import { Game } from "@/game/Game";
+    import {computed, defineComponent, inject, Ref} from "vue";
     
     export default defineComponent({
         setup() {
-            const sequences = inject("sequences");
+            const game = inject("game") as Ref<Game>;
+            const sequences = computed(() => game.value.sequences);
 
             return {
                 sequences
diff --git a/src/components/Timer.vue b/src/components/Timer.vue
index cfe41d8..eea8155 100644
--- a/src/components/Timer.vue
+++ b/src/components/Timer.vue
@@ -6,15 +6,31 @@
 </template>
 
 <script lang="ts">
-    import {defineComponent, computed, inject, Ref} from "vue";
+    import { Game } from "@/game/Game";
+    import {defineComponent, computed, inject, Ref, ref} from "vue";
     
     export default defineComponent({
         setup() {
-            const remainingMilliseconds = inject("remainingMilliseconds") as Ref<number>;
-            const timeoutMilliseconds = inject("timeoutMilliseconds") as Ref<number>;
+            const game = inject("game") as Ref<Game>;
+            const remainingMilliseconds = ref(game.value.remainingMilliseconds);
+            const timeoutMilliseconds = computed(() => game.value.timeoutMilliseconds);
             const progress = computed(() => remainingMilliseconds.value/timeoutMilliseconds.value*100);
             const countdown = computed(() => (remainingMilliseconds.value/1000).toFixed(2));
 
+            const updateTime = () => {
+                remainingMilliseconds.value = game.value.remainingMilliseconds;
+                
+                if (remainingMilliseconds.value > 0) {
+                    requestAnimationFrame(() => {
+                        updateTime();
+                    });
+                }
+            }
+
+            requestAnimationFrame(() => {
+                updateTime();
+            });
+
             return {
                 countdown,
                 progress
diff --git a/src/components/timer.ts b/src/components/timer.ts
deleted file mode 100644
index c01fb0d..0000000
--- a/src/components/timer.ts
+++ /dev/null
@@ -1,28 +0,0 @@
-import { Game } from '@/game/Game';
-import { Ref } from 'vue';
-
-interface Timer {
-    updateCountdown(game: Game, remainingMilliseconds: Ref<number>): void
-}
-
-export function useTimer(): Timer {
-    function updateCountdown(game: Game, remainingMilliseconds: Ref<number>) {
-        const updateTime = () => {
-            remainingMilliseconds.value = game.remainingMilliseconds;
-            
-            if (remainingMilliseconds.value > 0) {
-                requestAnimationFrame(() => {
-                    updateTime();
-                });
-            }
-        }
-
-        requestAnimationFrame(() => {
-            updateTime();
-        });
-    }
-
-    return {
-        updateCountdown
-    }
-}
diff --git a/src/game/Game.test.ts b/src/game/Game.test.ts
index 84ac15d..57c3240 100644
--- a/src/game/Game.test.ts
+++ b/src/game/Game.test.ts
@@ -53,6 +53,7 @@ describe("GameState", () => {
             expect(() => game.pick(0, 2)).toThrow();
             game.pick(2, 0);
             expect(game.state).toEqual({ selectionMode: SelectionMode.ColumnPick, row: 2 });
+            expect(game.buffer.length).toEqual(2);
         });
 
         test("cannot pick cell twice", () => {
@@ -64,6 +65,7 @@ describe("GameState", () => {
             });
             game.pick(0, 0);
             expect(() => game.pick(0, 0)).toThrow();
+            expect(game.buffer.length).toEqual(1);
         });
 
         test("picking outside of range fails", () => {
@@ -95,6 +97,7 @@ describe("GameState", () => {
                 value: "00"
             }]);
             expect(game.getSequences()).toEqual([{ sequence: simpleSequence, numberOfFulfilled: 1 }])
+            expect(game.buffer.length).toEqual(1);
         });
 
         test("picking fulfills second sequence occurence", () => {
@@ -120,6 +123,7 @@ describe("GameState", () => {
             expect(game.getSequences()).toEqual([{ sequence: sequence, numberOfFulfilled: 2 }])
             game.pick(0, 2);
             expect(game.getSequences()).toEqual([{ sequence: sequence, numberOfFulfilled: 3 }])
+            expect(game.buffer.length).toEqual(5);
         });
     });
 
diff --git a/src/game/Game.ts b/src/game/Game.ts
index f12f4ab..7819b6d 100644
--- a/src/game/Game.ts
+++ b/src/game/Game.ts
@@ -156,11 +156,9 @@ export class Game {
         if (this.getSequences().every(isSequenceFulfilled)) {
             this.stopClock()
             this.state = EndState.Won
-        } else {
+        } else if (this.buffer.length >= this.config.maxBufferLength) {
             this.stopClock()
-            if (this.buffer.length >= this.config.maxBufferLength) {
-                this.state = EndState.Lost
-            }
+            this.state = EndState.Lost
         }
     }
 
@@ -174,15 +172,10 @@ export class Game {
             Lost: () => {throw new IllegalMoveError()},
             InProgress: (selectionMode) => {
                 const cell = this.getCell(row, column)
-                if (cell.isUsed) {
-                    throw new IllegalMoveError()
-                }
 
-                this.buffer.push({
-                    value: cell.value,
-                    positionInMatrixRow: row,
-                    positionInMatrixColumn: column,
-                })
+                if (cell.isUsed) {
+                    throw new IllegalMoveError();
+                }
 
                 matchSelectionState({
                     Free: () => {
@@ -212,6 +205,12 @@ export class Game {
                         }
                     },
                 })(selectionMode)
+
+                this.buffer.push({
+                    value: cell.value,
+                    positionInMatrixRow: row,
+                    positionInMatrixColumn: column,
+                })
             }
         })(this.state)
 
diff --git a/src/sass/main.scss b/src/sass/main.scss
index f0fc522..c654cd2 100644
--- a/src/sass/main.scss
+++ b/src/sass/main.scss
@@ -107,6 +107,11 @@ main {
         height: 32px;
         margin: 0 5px 5px 0;
         cursor: pointer;
+
+        &:hover {
+            background: $yellow;
+            color: $background;
+        }
     }
 }