🚧 WIP

Sources/Data/Stub.cs

@@ -21,9 +21,9 @@ namespace Data
             Player player1 = new("Alice"), player2 = new("Bob"), player3 = new("Clyde");
 
             IManager<(string, IEnumerable<AbstractDie<AbstractDieFace>>)> globalDieManager = new DieManager();
-
-            // create at least one fav group in there
+            // create at least one group in there
             // ... 
+
             IEnumerable<AbstractDie<AbstractDieFace>> dice1;
             (_, dice1) = globalDieManager.GetAll().First();
             IEnumerable<AbstractDie<AbstractDieFace>> dice2;

Sources/Model/Games/Game.cs

@@ -91,8 +91,8 @@ namespace Model.Games
         public void PerformTurn(Player player)
         {
             Turn turn = Turn.CreateWithDefaultTime(
-                new Player(player),
-                ThrowAll() //using a copy so that next lines can't "change history"
+                new Player(player), //using a copy so that next lines can't "change history"
+                ThrowAll()
                 );
             turns.Add(turn);
             nextIndex++;
@@ -151,12 +151,12 @@ namespace Model.Games
         /// throws all the Dice in FavGroup and returns a list of their Faces
         /// </summary>
         /// <returns>list of AbstractDieFaces after a throw</returns>
-        private List<AbstractDieFace> ThrowAll()
+        private Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> ThrowAll()
         {
-            List<AbstractDieFace> faces = new();
+            Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> faces = new();
             foreach (AbstractDie<AbstractDieFace> die in dice)
             {
-                faces.Add(die.GetRandomFace());
+                faces.Add(die, die.GetRandomFace());
             }
             return faces;
         }
@@ -165,12 +165,12 @@ namespace Model.Games
         {
             return playerManager.Add(player);
         }
-        
+
         public IEnumerable<Player> GetPlayersFromGame()
         {
             return playerManager.GetAll();
         }
-        
+
         public Player UpdatePlayerInGame(Player oldPlayer, Player newPlayer)
         {
             return playerManager.Update(oldPlayer, newPlayer);
@@ -180,7 +180,7 @@ namespace Model.Games
         {
             playerManager.Remove(player);
         }
-        
+
         /// <summary>
         /// represents a Game in string format
         /// </summary>

Sources/Model/Games/Turn.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using System.Linq;
 using System.Text;
+using Model.Dice;
 using Model.Dice.Faces;
 using Model.Players;
 
@@ -22,17 +23,17 @@ namespace Model.Games
         /// <summary>
         /// the date and time, adjusted to UTC
         /// </summary>
-        public readonly DateTime when;
+        public DateTime When { get; private set; }
 
         /// <summary>
         /// the Player who rolled the dice
         /// </summary>
-        public readonly Player player;
+        public Player Player { get; private set; }
 
         /// <summary>
         /// the collection of Face that were rolled
         /// </summary>
-        private readonly IEnumerable<AbstractDieFace> faces;
+        public Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DiceNFaces { get; }
 
         /// <summary>
         /// this private constructor is to be used only by factories
@@ -40,11 +41,11 @@ namespace Model.Games
         /// <param name="when">date and time of the turn</param>
         /// <param name="player">player who played the turn</param>
         /// <param name="faces">faces that were rolled</param>
-        private Turn(DateTime when, Player player, IEnumerable<AbstractDieFace> faces)
+        private Turn(DateTime when, Player player, Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> diceNFaces)
         {
-            this.when = when;
-            this.player = player;
-            this.faces = faces;
+            When = when;
+            Player = player;
+            DiceNFaces = diceNFaces;
         }
 
         /// <summary>
@@ -57,23 +58,22 @@ namespace Model.Games
         /// <param name="player">player who played the turn</param>
         /// <param name="faces">faces that were rolled</param>
         /// <returns>a new Turn object</returns>
-        public static Turn CreateWithSpecifiedTime(DateTime when, Player player, IEnumerable<AbstractDieFace> faces)
+        public static Turn CreateWithSpecifiedTime(DateTime when, Player player, Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> diceNFaces)
         {
-
-            if (faces is null || !faces.Any())
-            {
-                throw new ArgumentException("param should not be null or empty", nameof(faces));
-            }
             if (player is null)
             {
                 throw new ArgumentNullException(nameof(player), "param should not be null");
             }
+            if (diceNFaces is null)
+            {
+                throw new ArgumentNullException(nameof(diceNFaces), "param should not be null");
+            }
             if (when.Kind != DateTimeKind.Utc)
             {
                 when = when.ToUniversalTime();
             }
 
-            return new Turn(when, player, faces);
+            return new Turn(when, player, diceNFaces);
         }
 
         /// <summary>
@@ -82,9 +82,9 @@ namespace Model.Games
         /// <param name="player">player who played the turn</param>
         /// <param name="faces">faces that were rolled</param>
         /// <returns>a new Turn object</returns>
-        public static Turn CreateWithDefaultTime(Player player, IEnumerable<AbstractDieFace> faces)
+        public static Turn CreateWithDefaultTime(Player player, Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> diceNFaces)
         {
-            return CreateWithSpecifiedTime(DateTime.UtcNow, player, faces);
+            return CreateWithSpecifiedTime(DateTime.UtcNow, player, diceNFaces);
         }
 
         /// <summary>
@@ -93,7 +93,7 @@ namespace Model.Games
         /// <returns>a turn in string format</returns>
         public override string ToString()
         {
-            string[] datetime = when.ToString("s", System.Globalization.CultureInfo.InvariantCulture).Split("T");
+            string[] datetime = When.ToString("s", System.Globalization.CultureInfo.InvariantCulture).Split("T");
             string date = datetime[0];
             string time = datetime[1];
 
@@ -102,9 +102,8 @@ namespace Model.Games
             sb.AppendFormat("{0} {1} -- {2} rolled:",
                 date,
                 time,
-                player.ToString());
-
-            foreach (AbstractDieFace face in faces)
+                Player.ToString());
+            foreach ((_, AbstractDieFace face) in DiceNFaces)
             {
                 sb.Append(" " + face.ToString());
             }

Sources/Tests/Model_UTs/TurnTest.cs

@@ -0,0 +1,196 @@
+using Model.Dice;
+using Model.Dice.Faces;
+using Model.Games;
+using Model.Players;
+using Newtonsoft.Json.Linq;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Xunit;
+
+namespace Tests.Model_UTs
+{
+    public class TurnTest
+
+    {
+        private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES;
+        private static readonly AbstractDieFace FACE_ONE = new NumberDieFace(1);
+        private static readonly AbstractDieFace FACE_TWO = new NumberDieFace(12);
+        private static readonly AbstractDieFace FACE_THREE = new ImageDieFace(54);
+        private static readonly AbstractDieFace FACE_FOUR = new ColorDieFace(16548);
+
+        private readonly static NumberDieFace[] FACES1 = new NumberDieFace[]
+        {
+            FACE_ONE as NumberDieFace,
+            new NumberDieFace(2),
+            new NumberDieFace(3),
+            new NumberDieFace(4)
+        };
+
+        private readonly static NumberDieFace[] FACES2 = new NumberDieFace[] {
+                  new NumberDieFace(9),
+                  new NumberDieFace(10),
+                  new NumberDieFace(11),
+                  FACE_TWO as NumberDieFace,
+                  new NumberDieFace(13),
+                  new NumberDieFace(14)
+            };
+
+        private readonly static ImageDieFace[] FACES3 = new ImageDieFace[] {
+                  new ImageDieFace(13),
+                  new ImageDieFace(27),
+                  new ImageDieFace(38),
+                  FACE_THREE as ImageDieFace
+            };
+
+        private readonly static ColorDieFace[] FACES4 = new ColorDieFace[] {
+                  new(11651),
+                  new(24651),
+                  FACE_FOUR as ColorDieFace,
+                  new(412)
+            };
+
+        /*
+        private readonly AbstractDie<AbstractDieFace> NUM1 = new NumberDie(FACES1);
+        private readonly AbstractDie<AbstractDieFace> NUM2 = new NumberDie(FACES2);
+        private readonly AbstractDie<AbstractDieFace> IMG1 = new ImageDie(FACES3);
+        private readonly AbstractDie<AbstractDieFace> CLR1 = new ColorDie(FACES4);
+        */
+
+        /*
+        public TurnTest()
+        {
+            DICE_N_FACES = new()
+            {
+                { NUM1, FACE_ONE },
+                { NUM2, FACE_TWO },
+                { IMG1, FACE_THREE },
+                { CLR1, FACE_FOUR }
+            };
+        }
+        */
+
+        /*
+        [Fact]
+        public void TestCreateWithSpecifiedTimeNotUTCThenValid()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Local);
+            Player player = new("Alice");
+            Assert.NotEqual(DateTimeKind.Utc, dateTime.Kind);
+
+            // Act
+            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
+
+            // Assert
+            Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
+            Assert.Equal(dateTime.ToUniversalTime(), turn.When);
+        }
+        */
+
+        /*
+        [Fact]
+        public void TestCreateWithSpecifiedTimeUTCThenValid()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
+            Player player = new("Bobby");
+            Assert.Equal(DateTimeKind.Utc, dateTime.Kind);
+
+            // Act
+            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
+
+            // Assert
+            Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
+            Assert.Equal(dateTime.ToUniversalTime(), turn.When);
+        }
+        */
+
+        [Fact]
+        public void TestCreateWithSpecifiedTimeNullPlayerThenException()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
+
+            // Act
+            void action() => Turn.CreateWithSpecifiedTime(dateTime, null, DICE_N_FACES);
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        [Fact]
+        public void TestCreateWithSpecifiedTimeNullFacesThenException()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
+            Player player = new("Chucky");
+
+            // Act
+            void action() => Turn.CreateWithSpecifiedTime(dateTime, player, null);
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(action);
+        }
+
+        /*
+        [Fact]
+        public void TestCreateWithSpecifiedTimeEmptyFacesThenException()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
+            Player player = new("Chucky");
+            DICE_N_FACES.Clear();
+
+            // Act
+            void action() => Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
+
+            // Assert
+            Assert.Throws<ArgumentException>(action);
+        }
+        */
+
+        /*
+        [Fact]
+        public void TestCreateWithDefaultTimeThenValid()
+        {
+            // Arrange
+            Player player = new("Chloe");
+
+            // Act
+            Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES);
+
+            // Assert
+            Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
+            Assert.Equal(DateTime.Now.ToUniversalTime().Date, turn.When.Date);
+            // N.B.: might fail between 11:59:59PM and 00:00:00AM
+        }
+        */
+
+        /*
+        [Fact]
+        public void TestToStringValidIfAllNormal()
+        {
+            // Arrange
+            DateTime dateTime = new(year: 2018, month: 06, day: 15, hour: 16, minute: 30, second: 0, kind: DateTimeKind.Utc);
+            string name = "Bobby";
+            Player player = new(name);
+            string expected = $"2018-06-15 16:30:00 -- {name} rolled: "
+                + FACE_ONE.ToString() + " "
+                + FACE_TWO.ToString()
+                + " Assets/images/" + FACE_THREE.ToString() + " "
+                + FACE_FOUR.ToString();
+
+            Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
+
+            // Act
+            string actual = turn.ToString();
+            Debug.WriteLine(actual);
+
+            // Assert
+            Assert.Equal(expected, actual);
+        }
+        */
+    }
+}