nachsterSpielerTest erstellt

BlazorSolution/MiniGames/Client/ViewModel/IUno.cs

@@ -9,6 +9,6 @@ namespace MiniGames.Client.ViewModel
 
         void ZiehKartenStapelZusammenstellen();
         bool IstAblageStapelFarbeGleichZuLegendeKarte(string neueKarteFarbe);
-        List<KartenModel> ZiehEineKarte(List<KartenModel> zuZiehendeHand);
+        void ZiehEineKarte(int id);
     }
 }

BlazorSolution/MiniGames/Client/ViewModel/Uno.cs

@@ -1,5 +1,6 @@
 using MiniGames.Shared.Enums;
 using MiniGames.Shared.Models;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 
@@ -9,32 +10,39 @@ namespace MiniGames.Client.ViewModel
     {
         public StapelModel KartenAblageStapel { get; set; } = new();
         public StapelModel ZiehKartenStapel { get; set; } = new();
+        public List<HandKartenModel> Spieler { get; set; } = new();
+        public int NaechsterSpielerId { get; set; }
 
         public bool IstAblageStapelFarbeGleichZuLegendeKarte(string neueKarteFarbe)
         {
-            if (KartenAblageStapel.KartenModels.LastOrDefault().Farbe.Equals(neueKarteFarbe))
-            {
-                return true;
+            bool ergebnis;
+
+            _ = KartenAblageStapel.KartenModels.LastOrDefault().Farbe.Equals(neueKarteFarbe) ? ergebnis = true : ergebnis = false;
+
+            return ergebnis;
         }
-            else
+
+        public bool IstAblageStapelZahlGleichZuLegendeKarte(string handStapelKarteBezeichnung)
         {
-                return false;
-            }
+            bool ergebnis;
+
+            _ = KartenAblageStapel.KartenModels.LastOrDefault().Name.Equals(handStapelKarteBezeichnung) ? ergebnis = true : ergebnis = false;
+
+            return ergebnis;
         }
 
-        public List<KartenModel> ZiehEineKarte(List<KartenModel> zuZiehendeHand)
+        public void ZiehEineKarte(int id)
         {
-            List<KartenModel> _zuZiehendeHand = zuZiehendeHand;
+            int _id = id;
+            int index = Spieler.FindIndex(x => x.SpielerModel.Id == _id);
 
-            _zuZiehendeHand.Add(ZiehKartenStapel.KartenModels.FirstOrDefault());
+            Spieler[index].KartenModels.Add(ZiehKartenStapel.KartenModels.FirstOrDefault());
             ZiehKartenStapel.KartenModels.RemoveAt(0);
-
-            return _zuZiehendeHand;
         }
 
-        public List<KartenModel> KarteAufStapelLegen(List<KartenModel> naechstenHand, KartenModel zuLegendeKarte)
+        public void KarteAufStapelLegen(int id, KartenModel zuLegendeKarte)
         {
-            List<KartenModel> _naechstenHand = naechstenHand;
+            int _id = id;
             StapelModel _stapelModel = new();
             _stapelModel.KartenModels = new();
             const string _plusZweiKarte = "PlusZweiKarte";
@@ -51,7 +59,7 @@ namespace MiniGames.Client.ViewModel
                 case _plusZweiKarte:
                     for (int i = 0; i < 2; i++)
                     {
-                        _naechstenHand = ZiehEineKarte(_naechstenHand);
+                        ZiehEineKarte(_id);
                     }
                     break;
                 case _retoureKarte:
@@ -63,9 +71,49 @@ namespace MiniGames.Client.ViewModel
 
             }
 
-            return _naechstenHand;
         }
 
+        public void SpielerErstellen(string spielerName)
+        {
+            string _spielerName = spielerName;
+            Spieler.Add(
+                new HandKartenModel
+                {
+                    SpielerModel = new()
+                    {
+                        Id = Spieler.Count() + 1,
+                        SpielerName = _spielerName,
+                    },
+                    KartenModels = new()
+                });
+        }
+
+        public void SpielerWahl(int aktuellerSpielerId, bool uhrZeigerSinn)
+        {
+            var aktuellerSpielerIndex = Spieler.FindIndex(x => x.SpielerModel.Id == aktuellerSpielerId);
+            if (uhrZeigerSinn)
+            {
+                if (aktuellerSpielerIndex == Spieler.Count() - 1)
+                {
+                    NaechsterSpielerId = 1;
+                }
+                else
+                {
+                    NaechsterSpielerId = Spieler[aktuellerSpielerIndex + 1].SpielerModel.Id;
+                }
+            }
+            else
+            {
+                if (aktuellerSpielerIndex != 0)
+                {
+                    NaechsterSpielerId = Spieler[aktuellerSpielerIndex - 1].SpielerModel.Id;
+                }
+                else
+                {
+                    NaechsterSpielerId = Spieler.LastOrDefault().SpielerModel.Id;
+                }
+            }
+        }
 
         #region Stapel Erstellen
         public static StapelModel ErstelleStandardKarten()

BlazorSolution/MiniGames/Shared/Models/HandKartenModel.cs

@@ -8,8 +8,7 @@ namespace MiniGames.Shared.Models
 {
     public class HandKartenModel
     {
-        public int Id { get; set; }
-        public string Name { get; set; }
+        public SpielerModel SpielerModel { get; set; }
 
         public List<KartenModel> KartenModels { get; set; }
     }

BlazorSolution/MiniGames/Shared/Models/SpielerModel.cs

@@ -8,6 +8,7 @@ namespace MiniGames.Shared.Models
 {
     public class SpielerModel
     {
+        public int Id { get; set; }
         public string SpielerName { get; set; }
         public int Punkte { get; set; }
     }

BlazorSolution/MiniGamesTests/UnoTest.cs

@@ -30,9 +30,13 @@ namespace MiniGamesTests
         private HandKartenModel BeispielHand()
         {
             HandKartenModel HandStapel = new()
+            {
+                SpielerModel = new()
                 {
                     Id = 1,
-                Name = "Andrej",
+                    SpielerName = "Andrej",
+                },
+
                 KartenModels = new()
                 {
                     new KartenModel
@@ -66,6 +70,89 @@ namespace MiniGamesTests
             return TestStapel;
         }
 
+        #region UserManagement
+        [Theory]
+        [InlineData("Andrej", 1)]
+        private void SpielerErstellenTest(string spielerName, int id)
+        {
+            //arrange
+            var _spielerName = spielerName;
+            var _id = id;
+
+            //act
+            UnoRegeln.SpielerErstellen(_spielerName);
+            var ergebnis = UnoRegeln.Spieler;
+
+            //assert
+            Assert.Equal(_spielerName, ergebnis[0].SpielerModel.SpielerName);
+            Assert.Equal(_id, ergebnis[0].SpielerModel.Id);
+        }
+
+        [Theory]
+        [InlineData("Andrej", 1, "Paul", 2, "Erhard", 3)]
+        [InlineData("Sabine", 1, "Erich", 2, "Anna", 3)]
+        [InlineData("Thomas", 1, "Mike", 2, "Robin", 3)]
+        private void MehrereSpielerErstellenTest(string spielerEinsName, int spielerEinsId, string spielerZweiName, int spielerZweiId, string spielerDreiName, int spielerDreiId)
+        {
+            //arrange
+            var _spielerEinsName = spielerEinsName;
+            var _spielerEinsId = spielerEinsId;
+            var _spielerZweiName = spielerZweiName;
+            var _spielerZweiId = spielerZweiId;
+            var _spielerDreiName = spielerDreiName;
+            var _spielerDreiId = spielerDreiId;
+
+            //act
+            UnoRegeln.SpielerErstellen(_spielerEinsName);
+            UnoRegeln.SpielerErstellen(_spielerZweiName);
+            UnoRegeln.SpielerErstellen(_spielerDreiName);
+            var ergebnis = UnoRegeln.Spieler;
+
+            //assert
+            Assert.Equal(_spielerEinsName, ergebnis[0].SpielerModel.SpielerName);
+            Assert.Equal(_spielerEinsId, ergebnis[0].SpielerModel.Id);
+            Assert.NotNull(ergebnis[0].KartenModels);
+
+            Assert.Equal(_spielerZweiName, ergebnis[1].SpielerModel.SpielerName);
+            Assert.Equal(_spielerZweiId, ergebnis[1].SpielerModel.Id);
+            Assert.NotNull(ergebnis[1].KartenModels);
+
+            Assert.Equal(_spielerDreiName, ergebnis[2].SpielerModel.SpielerName);
+            Assert.Equal(_spielerDreiId, ergebnis[2].SpielerModel.Id);
+            Assert.NotNull(ergebnis[2].KartenModels);
+        }
+
+        [Theory]
+        [InlineData("Andrej", 1, "Paul", 2, "Erhard", 3, true, 2, 3)]
+        [InlineData("Sabine", 1, "Erich", 2, "Anna", 3, false, 3, 2)]
+        [InlineData("Thomas", 1, "Mike", 2, "Robin", 3, true, 2, 3)]
+        [InlineData("Andrej", 1, "Paul", 2, "Erhard", 3, true, 3, 1)]
+        [InlineData("Sabine", 1, "Erich", 2, "Anna", 3, false, 1, 3)]
+        private void NaechsterSpielerTest(string spielerEinsName, int spielerEinsId, string spielerZweiName, int spielerZweiId, string spielerDreiName, int spielerDreiId, bool uhrZeigerSinn, int aktuellerSpieler, int naechsterErwartung)
+        {
+            //arrange
+            var _spielerEinsName = spielerEinsName;
+            var _spielerEinsId = spielerEinsId;
+            var _spielerZweiName = spielerZweiName;
+            var _spielerZweiId = spielerZweiId;
+            var _spielerDreiName = spielerDreiName;
+            var _spielerDreiId = spielerDreiId;
+            var _uhrZeigerSinn = uhrZeigerSinn;
+            var _aktuellerSpieler = aktuellerSpieler;
+            var _naechsterErwartung = naechsterErwartung;
+
+            //act
+            UnoRegeln.SpielerErstellen(_spielerEinsName);
+            UnoRegeln.SpielerErstellen(_spielerZweiName);
+            UnoRegeln.SpielerErstellen(_spielerDreiName);
+            UnoRegeln.SpielerWahl(_aktuellerSpieler, _uhrZeigerSinn);
+
+            //assert
+            Assert.Equal(_naechsterErwartung, UnoRegeln.NaechsterSpielerId);
+
+        }
+
+        #endregion
 
         [Theory]
         [InlineData(Farbe.Rot, Farbe.Rot, true)]
@@ -77,35 +164,61 @@ namespace MiniGamesTests
         private void IstAblageStapelFarbeGleichZuLegendeKarteTest(Farbe ablegeStapelKarteFarbe, Farbe neueKarteFarbe, bool erwartet)
         {
             //arrange
-            UnoRegeln.ZiehKartenStapelZusammenstellen();
             var _ablegeStabelKarteFarbe = ablegeStapelKarteFarbe.ToString();
             var _neueKarteFarbe = neueKarteFarbe.ToString();
             var _erwartet = erwartet;
 
-            UnoRegeln.KartenAblageStapel.KartenModels = new();
-            UnoRegeln.KartenAblageStapel.KartenModels.Add(BeispielKarte("Testkarten Name", _ablegeStabelKarteFarbe, false));
 
             //act
+            UnoRegeln.KartenAblageStapel.KartenModels = new();
+            UnoRegeln.KartenAblageStapel.KartenModels.Add(
+                BeispielKarte("Testkarten Name", _ablegeStabelKarteFarbe, false)
+                );
             var erhalten = UnoRegeln.IstAblageStapelFarbeGleichZuLegendeKarte(_neueKarteFarbe);
 
             //assert
             Assert.Equal(_erwartet, erhalten);
         }
 
+        [Theory]
+        [InlineData(Kartenbezeichnung.Acht, Kartenbezeichnung.Acht, true)]
+        [InlineData(Kartenbezeichnung.Eins, Kartenbezeichnung.Acht, false)]
+        [InlineData(Kartenbezeichnung.Fuenf, Kartenbezeichnung.Vier, false)]
+        [InlineData(Kartenbezeichnung.Sechs, Kartenbezeichnung.Sechs, true)]
+        [InlineData(Kartenbezeichnung.Zwei, Kartenbezeichnung.Drei, false)]
+        [InlineData(Kartenbezeichnung.Neun, Kartenbezeichnung.Acht, false)]
+        private void IstAblageStapelZahlGleichZuLegendeKarteTest(Kartenbezeichnung ablegeStapelKarteBezeichnung, Kartenbezeichnung handStapelKarteBezeichnung, bool erwartet)
+        {
+            //arrange
+            var _ablegeStapelKarteBezeichnung = ablegeStapelKarteBezeichnung.ToString();
+            var _handStapelKarteBezeichnung = handStapelKarteBezeichnung.ToString();
+            var _erwartet = erwartet;
+
+            //act
+            UnoRegeln.KartenAblageStapel.KartenModels = new();
+            UnoRegeln.KartenAblageStapel.KartenModels.Add(
+                BeispielKarte(_ablegeStapelKarteBezeichnung, Farbe.Blau.ToString(), false)
+                );
+            var erhalten = UnoRegeln.IstAblageStapelZahlGleichZuLegendeKarte(_handStapelKarteBezeichnung);
+
+            //assert
+            Assert.Equal(_erwartet, erhalten);
+
+        }
+
         [Fact]
         private void ZiehEineKarteTest()
         {
             //arrange
             UnoRegeln.ZiehKartenStapelZusammenstellen();
-            List<KartenModel> KartenListe = new();
+            UnoRegeln.SpielerErstellen("Andrej");
 
-            var beispielHand = BeispielHand();
             var erwartet = UnoRegeln.ZiehKartenStapel.KartenModels.FirstOrDefault();
 
             //act
-            KartenListe = UnoRegeln.ZiehEineKarte(beispielHand.KartenModels);
+            UnoRegeln.ZiehEineKarte(1);
 
-            var erhalten = KartenListe.LastOrDefault();
+            var erhalten = UnoRegeln.Spieler[0].KartenModels.LastOrDefault();
 
             //assert
             Assert.Equal(erwartet, erhalten);
@@ -128,7 +241,7 @@ namespace MiniGamesTests
 
 
             //act
-            naechstenHand.KartenModels = UnoRegeln.KarteAufStapelLegen(naechstenHand.KartenModels, beispielZuLegendeKarte);
+            //naechstenHand.KartenModels = UnoRegeln.KarteAufStapelLegen(naechstenHand.KartenModels, beispielZuLegendeKarte);
 
             //assert
         }