TicTacToe verhindert überschreiben des ersten Gewinners

BlazorSolution/MiniGames/Client/ViewModel/ITicTacToe.cs

@@ -2,6 +2,6 @@
 {
     public interface ITicTacToe
     {
-        bool SpielerInput(int spielerIndex, int posIndex);
+        void SpielerInput(int posIndex);
     }
 }

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;
         }
     }
 }

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
             {

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; }
     }
 }

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();

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);
+        }
     }
 }