Merge commit '2e56a1e0cba7b14252016ac4be857b8f35bc20ea' into HEAD

2 years ago · 3eb5acfc88
6 changed files with 220 additions and 66 deletions
--- a/BlazorSolution/MiniGames/Client/ViewModel/ITicTacToe.cs
+++ b/BlazorSolution/MiniGames/Client/ViewModel/ITicTacToe.cs
@ -2,6 +2,6 @@
 {
    public interface ITicTacToe
    {
-        bool SpielerInput(int spielerIndex, int posIndex);
+        void SpielerInput(int posIndex);
    }
 }
--- a/BlazorSolution/MiniGames/Client/ViewModel/TicTacToe.cs
+++ b/BlazorSolution/MiniGames/Client/ViewModel/TicTacToe.cs
@ -17,9 +17,36 @@ namespace MiniGames.Client.ViewModel
            set { Model.Brett = value; }
        }

-        public bool SpielerInput(int spielerIndex, int posIndex)
+        public int AktiverSpielerIndex
        {
-            return true;
+            get { return Model.AktiverSpielerIndex; }
+            set { Model.AktiverSpielerIndex = value; }
+        }
+
+        public int GewinnerIndex
+        {
+            get { return Model.GewinnerIndex; }
+            set {
+                if (Model.GewinnerIndex < 0)
+                {
+                    Model.GewinnerIndex = value;
+                }
+            }
+        }
+
+        public void SpielerInput(int posIndex)
+        {
+            if (Brett.Set(posIndex, AktiverSpielerIndex))
+            {
+                SpielerWechsel();
+            }
+
+            GewinnerIndex = Brett.Gewinner();
+        }
+
+        public void SpielerWechsel()
+        {
+            AktiverSpielerIndex = 1 - AktiverSpielerIndex;
        }
    }
 }
--- a/BlazorSolution/MiniGames/Shared/Models/TicTacToeBrett.cs
+++ b/BlazorSolution/MiniGames/Shared/Models/TicTacToeBrett.cs
@ -65,8 +65,8 @@ namespace MiniGames.Shared.Models

        public bool Set(int pos, int wert)
        {
-            int x = pos / 3;
-            int y = pos % 3;
+            int x = pos % 3;
+            int y = pos / 3;

            try
            {
--- a/BlazorSolution/MiniGames/Shared/Models/TicTacToeModel.cs
+++ b/BlazorSolution/MiniGames/Shared/Models/TicTacToeModel.cs
@ -9,6 +9,8 @@ namespace MiniGames.Shared.Models
    public class TicTacToeModel
    {
        public SpielerModel[] Spieler { get; set; }
+        public int AktiverSpielerIndex { get; set; } = 0;
+        public int GewinnerIndex { get; set; } = -1;
        public TicTacToeBrett Brett { get; set; }
    }
 }
--- a/BlazorSolution/MiniGamesTests/TicTacToeBrettTest.cs
+++ b/BlazorSolution/MiniGamesTests/TicTacToeBrettTest.cs
@ -5,36 +5,56 @@ namespace MiniGamesTests
 {
    public class TicTacToeBrettTest
    {
+        const int LEER = TicTacToeBrett.LEER;
+
        public TicTacToeBrett TestBrett(
-            int a = TicTacToeBrett.LEER, int b = TicTacToeBrett.LEER, int c = TicTacToeBrett.LEER,
-            int d = TicTacToeBrett.LEER, int e = TicTacToeBrett.LEER, int f = TicTacToeBrett.LEER,
-            int g = TicTacToeBrett.LEER, int h = TicTacToeBrett.LEER, int i = TicTacToeBrett.LEER
+            int f00 = LEER, int f10 = LEER, int f20 = LEER,
+            int f01 = LEER, int f11 = LEER, int f21 = LEER,
+            int f02 = LEER, int f12 = LEER, int f22 = LEER
        )
        {
            return new(
                new int[,]
                {
-                    { a, b, c, },
-                    { d, e, f, },
-                    { g, h, i, },
+                    { f00, f01, f02, },
+                    { f10, f11, f12, },
+                    { f20, f21, f22, },
                }
            );
        }

-        [Fact]
-        public void Set_FreiesFeldBelegenTest()
+        [Theory]
+        [InlineData(4, 0,
+                LEER, LEER, LEER,
+                LEER, 0
+        )]
+        [InlineData(0, 1,
+                1
+        )]
+        [InlineData(8, 2,
+                LEER, LEER, LEER,
+                LEER, LEER, LEER,
+                LEER, LEER, 2
+        )]
+        [InlineData(6, 3,
+                LEER, LEER, LEER,
+                LEER, LEER, LEER,
+                3, LEER, LEER
+        )]
+        [InlineData(3, 4,
+                LEER, LEER, LEER,
+                4, LEER, LEER,
+                LEER, LEER, LEER
+        )]
+        public void Set_FreiesFeldBelegenTest(int pos, int wert,
+            int a = LEER, int b = LEER, int c = LEER,
+            int d = LEER, int e = LEER, int f = LEER,
+            int g = LEER, int h = LEER, int i = LEER
+        )
        {
            // arrange
            TicTacToeBrett brett = new();
-            TicTacToeBrett erwartetesBrett = TestBrett(
-                TicTacToeBrett.LEER,
-                TicTacToeBrett.LEER,
-                TicTacToeBrett.LEER,
-                TicTacToeBrett.LEER,
-                0
-            );
-            int pos = 4;
-            int wert = 0;
+            TicTacToeBrett erwartetesBrett = TestBrett(a, b, c, d, e, f, g, h, i);
            bool erwartetGesetzt = true;

            // act
@ -189,7 +209,7 @@ namespace MiniGamesTests
        {
            // arrange
            TicTacToeBrett brett = TestBrett();
-            int erwarteterGewinner = TicTacToeBrett.LEER;
+            int erwarteterGewinner = LEER;

            // act
            int erhaltenerGewinner = brett.Gewinner();
@ -201,56 +221,56 @@ namespace MiniGamesTests
        [Theory]
        // Vertikale Reihe 1
        [InlineData(0,
-            0, 0, 0,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER
+            0, LEER, LEER,
+            0, LEER, LEER,
+            0, LEER, LEER
        )]
        // Vertikale Reihe 2
        [InlineData(1,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
-            1, 1, 1,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER
+            LEER, 1, LEER,
+            LEER, 1, LEER,
+            LEER, 1, LEER
        )]
        // Vertikale Reihe 3
        [InlineData(2,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
-            2, 2, 2
+            LEER, LEER, 2,
+            LEER, LEER, 2,
+            LEER, LEER, 2
        )]
        // Horizontale Reihe 1
        [InlineData(3,
-            3, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
-            3, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
-            3, TicTacToeBrett.LEER, TicTacToeBrett.LEER
+            3, 3, 3,
+            LEER, LEER, LEER,
+            LEER, LEER, LEER
        )]
        // Horizontale Reihe 2
        [InlineData(4,
-            TicTacToeBrett.LEER, 4, TicTacToeBrett.LEER,
-            TicTacToeBrett.LEER, 4, TicTacToeBrett.LEER,
-            TicTacToeBrett.LEER, 4, TicTacToeBrett.LEER
+            LEER, LEER, LEER,
+            4, 4, 4,
+            LEER, LEER, LEER
        )]
        // Horizontale Reihe 3
        [InlineData(5,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, 5,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, 5,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, 5
+            LEER, LEER, LEER,
+            LEER, LEER, LEER,
+            5, 5, 5
        )]
        // Diagonale Reihe links oben nach rechts unten
        [InlineData(6,
-            6, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
-            TicTacToeBrett.LEER, 6, TicTacToeBrett.LEER,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, 6
+            6, LEER, LEER,
+            LEER, 6, LEER,
+            LEER, LEER, 6
        )]
        // Diagonale Reihe rechts oben nach links unten
        [InlineData(7,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, 7,
-            TicTacToeBrett.LEER, 7, TicTacToeBrett.LEER,
-            7, TicTacToeBrett.LEER, TicTacToeBrett.LEER
+            LEER, LEER, 7,
+            LEER, 7, LEER,
+            7, LEER, LEER
        )]
        public void Gewinner_VolleReihenTest(int gewinner,
-            int a = TicTacToeBrett.LEER, int b = TicTacToeBrett.LEER, int c = TicTacToeBrett.LEER,
-            int d = TicTacToeBrett.LEER, int e = TicTacToeBrett.LEER, int f = TicTacToeBrett.LEER,
-            int g = TicTacToeBrett.LEER, int h = TicTacToeBrett.LEER, int i = TicTacToeBrett.LEER
+            int a = LEER, int b = LEER, int c = LEER,
+            int d = LEER, int e = LEER, int f = LEER,
+            int g = LEER, int h = LEER, int i = LEER
        )
        {
            // arrange
@ -266,34 +286,34 @@ namespace MiniGamesTests

        [Theory]
        [InlineData(
-            0, TicTacToeBrett.LEER, 0,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
-            0, TicTacToeBrett.LEER, 0
+            0, LEER, 0,
+            LEER, LEER, LEER,
+            0, LEER, 0
        )]
        [InlineData(
-            1, 1, TicTacToeBrett.LEER,
-            1, 1, TicTacToeBrett.LEER,
-            TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER
+            1, 1, LEER,
+            1, 1, LEER,
+            LEER, LEER, LEER
        )]
        [InlineData(
-            2, TicTacToeBrett.LEER, TicTacToeBrett.LEER,
-            2, TicTacToeBrett.LEER, 2,
-            TicTacToeBrett.LEER, 2, 2
+            2, 2, LEER,
+            LEER, LEER, 2,
+            LEER, 2, 2
        )]
        [InlineData(
            1, 1, 2,
-            1, 3, 2,
-            2, 3, 3
+            1, 3, 3,
+            2, 2, 3
        )]
        public void Gewinner_NichtVolleReihenTest(
-            int a = TicTacToeBrett.LEER, int b = TicTacToeBrett.LEER, int c = TicTacToeBrett.LEER,
-            int d = TicTacToeBrett.LEER, int e = TicTacToeBrett.LEER, int f = TicTacToeBrett.LEER,
-            int g = TicTacToeBrett.LEER, int h = TicTacToeBrett.LEER, int i = TicTacToeBrett.LEER
+            int a = LEER, int b = LEER, int c = LEER,
+            int d = LEER, int e = LEER, int f = LEER,
+            int g = LEER, int h = LEER, int i = LEER
        )
        {
            // arrange
            TicTacToeBrett brett = TestBrett(a, b, c, d, e, f, g, h, i);
-            int erwarteterGewinner = TicTacToeBrett.LEER;
+            int erwarteterGewinner = LEER;

            // act
            int erhaltenerGewinner = brett.Gewinner();
--- a/BlazorSolution/MiniGamesTests/TicTacToeTest.cs
+++ b/BlazorSolution/MiniGamesTests/TicTacToeTest.cs
@ -1,4 +1,5 @@
-using MiniGames.Shared.Models;
+using MiniGames.Client.ViewModel;
+using MiniGames.Shared.Models;
 using Xunit;

 namespace MiniGamesTests
@ -35,5 +36,109 @@ namespace MiniGamesTests
                Brett = StandardBrett(),
            };
        }
+
+        TicTacToe StandardSpiel()
+        {
+            return new(StandardModel());
+        }
+
+        [Theory]
+        [InlineData(0, 1)]
+        [InlineData(1, 0)]
+        public void SpielerWechselTest(int vorher, int nachher)
+        {
+            // arrange
+            TicTacToe spiel = StandardSpiel();
+            spiel.AktiverSpielerIndex = vorher;
+            int erwarteterIndex = nachher;
+
+            // act
+            spiel.SpielerWechsel();
+
+            // assert
+            Assert.Equal(erwarteterIndex, spiel.AktiverSpielerIndex);
+        }
+
+        [Fact]
+        public void SpielerInput_ValidesInputTest()
+        {
+            // arrange
+            TicTacToe spiel = StandardSpiel();
+            spiel.AktiverSpielerIndex = 0;
+            int erwarteterSpielerIndex = 1;
+
+            int pos = 2;
+            TicTacToeBrett erwartetesBrett = new(new int[,]
+            {
+                { TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
+                { TicTacToeBrett.LEER, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
+                { spiel.AktiverSpielerIndex, TicTacToeBrett.LEER, TicTacToeBrett.LEER, },
+            });
+
+            // act
+            spiel.SpielerInput(pos);
+
+            // assert
+            Assert.True(spiel.Brett.Gleich(erwartetesBrett));
+            Assert.Equal(erwarteterSpielerIndex, spiel.AktiverSpielerIndex);
+        }
+
+        [Fact]
+        public void SpielerInput_InvalidesInputTest()
+        {
+            // arrange
+            TicTacToe spiel = StandardSpiel();
+            spiel.AktiverSpielerIndex = 0;
+            int erwarteterSpielerIndex = 0;
+
+            int pos = -1;
+            TicTacToeBrett erwartetesBrett = StandardBrett();
+
+            // act
+            spiel.SpielerInput(pos);
+
+            // assert
+            Assert.True(spiel.Brett.Gleich(erwartetesBrett));
+            Assert.Equal(erwarteterSpielerIndex, spiel.AktiverSpielerIndex);
+        }
+
+        [Theory]
+        [InlineData(0, 0, 3, 1, 4, 2)]
+        [InlineData(0, 3, 0, 4, 1, 5, 2)]
+        public void SpielerInput_GewinnerTest(int gewinnerIndex, params int[] inputs)
+        {
+            // arrange
+            TicTacToe spiel = StandardSpiel();
+            int erwarteterGewinnerIndex = gewinnerIndex;
+
+            // act
+            foreach (int input in inputs)
+            {
+                spiel.SpielerInput(input);
+            }
+
+            // assert
+            Assert.Equal(spiel.GewinnerIndex, erwarteterGewinnerIndex);
+        }
+
+        [Fact]
+        public void SpielerInput_KeinGewinnerTest()
+        {
+            // arrange
+            TicTacToe spiel = StandardSpiel();
+            spiel.AktiverSpielerIndex = 0;
+            int erwarteterGewinnerIndex = -1;
+
+            // act
+            spiel.SpielerInput(0);
+            spiel.SpielerInput(3);
+            spiel.SpielerInput(1);
+            spiel.SpielerInput(4);
+            spiel.SpielerInput(5);
+            spiel.SpielerInput(2);
+
+            // assert
+            Assert.Equal(spiel.GewinnerIndex, erwarteterGewinnerIndex);
+        }
    }
 }