refactor naming

BlazorSolution/MiniGames/Client/ViewModel/IUno.cs

@@ -1,13 +1,14 @@
 using MiniGames.Shared.Models;
+using System.Collections.Generic;
 
 namespace MiniGames.Client.ViewModel
 {
     public interface IUno
     {
-        StapelModel AblageStabel { get; set; }
+        StapelModel ZiehKartenStapel { get; set; }
 
-        void AblagestapelZusammenstellen();
-        bool IstAblageStabelFarbeGleichHand(string ablegeStapelKarte, string neueKarte);
-        HandKartenModel ZiehEineKarte(HandKartenModel handStapel, StapelModel stapelModel);
+        void ZiehKartenStapelZusammenstellen();
+        bool IstAblageStapelFarbeGleichZuLegendeKarte(string neueKarteFarbe);
+        List<KartenModel> ZiehEineKarte(List<KartenModel> zuZiehendeHand);
     }
 }

BlazorSolution/MiniGames/Client/ViewModel/Uno.cs

@@ -1,16 +1,18 @@
 using MiniGames.Shared.Enums;
 using MiniGames.Shared.Models;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace MiniGames.Client.ViewModel
 {
     public class Uno : IUno
     {
-        public StapelModel AblageStabel { get; set; } = new();
+        public StapelModel KartenAblageStapel { get; set; } = new();
+        public StapelModel ZiehKartenStapel { get; set; } = new();
 
-        public bool IstAblageStabelFarbeGleichHand(string ablegeStapelKarte, string neueKarte)
+        public bool IstAblageStapelFarbeGleichZuLegendeKarte(string neueKarteFarbe)
         {
-            if (ablegeStapelKarte.Equals(neueKarte))
+            if (KartenAblageStapel.KartenModels.LastOrDefault().Farbe.Equals(neueKarteFarbe))
             {
                 return true;
             }
@@ -20,16 +22,52 @@ namespace MiniGames.Client.ViewModel
             }
         }
 
-        public HandKartenModel ZiehEineKarte(HandKartenModel handStapel, StapelModel stapelModel)
+        public List<KartenModel> ZiehEineKarte(List<KartenModel> zuZiehendeHand)
         {
-            HandKartenModel _handStapel = handStapel;
-            StapelModel _stapelModel = stapelModel;
+            List<KartenModel> _zuZiehendeHand = zuZiehendeHand;
 
-            _handStapel.KartenModels.Add(_stapelModel.KartenModels.FirstOrDefault());
+            _zuZiehendeHand.Add(ZiehKartenStapel.KartenModels.FirstOrDefault());
+            ZiehKartenStapel.KartenModels.RemoveAt(0);
 
-            return _handStapel;
+            return _zuZiehendeHand;
         }
 
+        public List<KartenModel> KarteAufStapelLegen(List<KartenModel> naechstenHand, KartenModel zuLegendeKarte)
+        {
+            List<KartenModel> _naechstenHand = naechstenHand;
+            StapelModel _stapelModel = new();
+            _stapelModel.KartenModels = new();
+            const string _plusZweiKarte = "PlusZweiKarte";
+            const string _retoureKarte = "RetoureKarte";
+            const string _aussetzenKarte = "AussetzenKarte";
+
+            if (KartenAblageStapel.KartenModels is null)
+            {
+                KartenAblageStapel.KartenModels = new();
+            }
+
+            switch (zuLegendeKarte.Name)
+            {
+                case _plusZweiKarte:
+                    for (int i = 0; i < 2; i++)
+                    {
+                        _naechstenHand = ZiehEineKarte(_naechstenHand);
+                    }
+                    break;
+                case _retoureKarte:
+                    break;
+                case _aussetzenKarte:
+                    break;
+                default:
+                    break;
+
+            }
+
+            return _naechstenHand;
+        }
+
+
+        #region Stapel Erstellen
         public static StapelModel ErstelleStandardKarten()
         {
             StapelModel stapelModel = new();
@@ -106,16 +144,16 @@ namespace MiniGames.Client.ViewModel
             return stapelModel;
         }
 
-        public void AblagestapelZusammenstellen()
+        public void ZiehKartenStapelZusammenstellen()
         {
             var standardKarten = Uno.ErstelleStandardKarten();
             var spezialKarten = Uno.ErstelleFarbigeSpezialKarten();
             var jokerKarten = Uno.ErstelleJokerKarten();
 
-            AblageStabel.KartenModels = new();
-            AblageStabel.KartenModels.AddRange(standardKarten.KartenModels);
-            AblageStabel.KartenModels.AddRange(spezialKarten.KartenModels);
-            AblageStabel.KartenModels.AddRange(jokerKarten.KartenModels);
+            ZiehKartenStapel.KartenModels = new();
+            ZiehKartenStapel.KartenModels.AddRange(standardKarten.KartenModels);
+            ZiehKartenStapel.KartenModels.AddRange(spezialKarten.KartenModels);
+            ZiehKartenStapel.KartenModels.AddRange(jokerKarten.KartenModels);
         }
 
 

BlazorSolution/MiniGamesTests/UnoTest.cs

@@ -1,6 +1,7 @@
 using MiniGames.Client.ViewModel;
 using MiniGames.Shared.Enums;
 using MiniGames.Shared.Models;
+using System.Collections.Generic;
 using System.Linq;
 using Xunit;
 
@@ -73,47 +74,66 @@ namespace MiniGamesTests
         [InlineData(Farbe.Blau, Farbe.Blau, true)]
         [InlineData(Farbe.Gelb, Farbe.Rot, false)]
         [InlineData(Farbe.Gruen, Farbe.Gruen, true)]
-        private void IstAblageStabelFarbeGleichHandTest(Farbe ablegeStapelKarteFarbe, Farbe neueKarteFarbe, bool erwartet)
+        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
-            var erhalten = UnoRegeln.IstAblageStabelFarbeGleichHand(_ablegeStabelKarteFarbe, _neueKarteFarbe);
+            var erhalten = UnoRegeln.IstAblageStapelFarbeGleichZuLegendeKarte(_neueKarteFarbe);
 
             //assert
             Assert.Equal(_erwartet, erhalten);
         }
 
+        [Fact]
+        private void ZiehEineKarteTest()
+        {
+            //arrange
+            UnoRegeln.ZiehKartenStapelZusammenstellen();
+            List<KartenModel> KartenListe = new();
+
+            var beispielHand = BeispielHand();
+            var erwartet = UnoRegeln.ZiehKartenStapel.KartenModels.FirstOrDefault();
+
+            //act
+            KartenListe = UnoRegeln.ZiehEineKarte(beispielHand.KartenModels);
+
+            var erhalten = KartenListe.LastOrDefault();
+
+            //assert
+            Assert.Equal(erwartet, erhalten);
+        }
+
         [Theory]
-        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Blau, true)]
-        [InlineData((Kartenbezeichnung)1, Farbe.Gelb, false)]
-        [InlineData((Kartenbezeichnung)3, Farbe.Blau, false)]
-        [InlineData((Kartenbezeichnung)7, Farbe.Gruen, false)]
-        [InlineData(Kartenbezeichnung.FarbwahlKarte, Farbe.Keine, false)]
-        private void ZiehEineKarteTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial)
+        [InlineData(Kartenbezeichnung.PlusZweiKarte, Farbe.Gelb, true)]
+        private void PlusZweiKarteAufStapelLegenTest(Kartenbezeichnung kartenbezeichnung, Farbe farbe, bool spezial)
         {
             //arrange
+            UnoRegeln.ZiehKartenStapelZusammenstellen();
+            var kartenAblageStapel = UnoRegeln.KartenAblageStapel;
+            var ziehKartenStapel = UnoRegeln.ZiehKartenStapel;
+
             var _kartenbezeichnung = kartenbezeichnung.ToString();
             var _farbe = farbe.ToString();
             var _spezial = spezial;
-            StapelModel zuFüllend = new();
+            var naechstenHand = BeispielHand();
+            var beispielZuLegendeKarte = BeispielKarte(_kartenbezeichnung, _farbe, _spezial);
 
-            var beispielStapel = BeispielStapelModelKarten(_kartenbezeichnung, _farbe, _spezial);
-            var beispielHand = BeispielHand();
 
             //act
-            zuFüllend.KartenModels = UnoRegeln.ZiehEineKarte(beispielHand, beispielStapel).KartenModels;
-
-            var erwartet = beispielStapel.KartenModels.FirstOrDefault();
-            var erhalten = beispielHand.KartenModels.LastOrDefault();
+            naechstenHand.KartenModels = UnoRegeln.KarteAufStapelLegen(naechstenHand.KartenModels, beispielZuLegendeKarte);
 
             //assert
-            Assert.Equal(erwartet, erhalten);
         }
 
+        #region Stapel erstellen
         [Theory]
         [InlineData((Kartenbezeichnung)2, Farbe.Gelb, false, 19)]
         [InlineData((Kartenbezeichnung)7, Farbe.Blau, false, 19)]
@@ -219,9 +239,9 @@ namespace MiniGamesTests
         private void AblagestapelZusammenstellenTest()
         {
 
-            UnoRegeln.AblagestapelZusammenstellen();
+            UnoRegeln.ZiehKartenStapelZusammenstellen();
 
-            var ergebnis = UnoRegeln.AblageStabel;
+            var ergebnis = UnoRegeln.ZiehKartenStapel;
 
             Assert.Equal(108, ergebnis.KartenModels.Count());
         }