alexis.drai
/
dice_app
0
0
Fork 0
Code Issues 60 Pull Requests Packages Projects 1 Releases Wiki Activity
Labels Milestones
New Pull Request

🐛 fix-#87 #88

Merged
alexis.drai merged 4 commits from fix-#87 into main 3 years ago
Conversation 0 Commits 4 Files Changed 6
6 changed files with 389 additions and 234 deletions
Show Stats Download Patch File Download Diff File

428
Sources/Model/Games/Game.cs
Unescape View File

@ -1,209 +1,219 @@
using Model.Dice;
using Model.Dice.Faces;
using Model.Players;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using System.Text;
namespace Model.Games
{
public class Game
{
/// <summary>
/// the name of the game 😎
/// </summary>
public string Name
{
get
{
return name;
}
set // GameRunner will need to take care of forbidding
// (or allowing) having two Games with the same name etc.
{
if (string.IsNullOrWhiteSpace(value))
{
throw new ArgumentException("param should not be null or blank", nameof(value));
}
name = value;
}
}
private string name;
/// <summary>
/// references the position in list of the current player, for a given game.
/// </summary>
private int nextIndex;
/// <summary>
/// the turns that have been done so far
/// </summary>
private readonly List<Turn> turns;
/// </summary>
/// get a READ ONLY enumerable of all turns belonging to this game
/// </summary>
/// <returns>a readonly enumerable of all this game's turns</returns>
public IEnumerable<Turn> GetHistory() => turns.AsEnumerable();
/// <summary>
/// the game's player manager, doing CRUD on players and switching whose turn it is
/// </summary>
private readonly IManager<Player> playerManager;
/// <summary>
/// the group of dice used for this game
/// </summary>
public IEnumerable<AbstractDie<AbstractDieFace>> Dice => dice;
private readonly IEnumerable<AbstractDie<AbstractDieFace>> dice;
/// <summary>
/// constructs a Game with its own history of Turns.
/// If <paramref name="turns"/> is null, starts a new history
/// </summary>
/// <param name="name">the name of the game 😎</param>
/// <param name="turns">the turns that have been done so far</param>
/// <param name="playerManager">the game's player manager, doing CRUD on players and switching whose turn it is</param>
/// <param name="favGroup">the group of dice used for this game</param>
public Game(string name, IManager<Player> playerManager, IEnumerable<AbstractDie<AbstractDieFace>> dice, IEnumerable<Turn> turns)
{
Name = name;
this.turns = turns is null ? new List<Turn>() : turns.ToList();
this.playerManager = playerManager;
this.dice = dice;
this.nextIndex = 0;
}
/// <summary>
/// constructs a Game with no history of turns.
/// </summary>
/// <param name="name">the name of the game 😎</param>
/// <param name="playerManager">the game's player manager, doing CRUD on players and switching whose turn it is</param>
/// <param name="favGroup">the group of dice used for this game</param>
public Game(string name, IManager<Player> playerManager, IEnumerable<AbstractDie<AbstractDieFace>> dice)
: this(name, playerManager, dice, null)
{ }
/// <summary>
/// performs a Turn, marks this Game as "started", and logs that Turn
/// </summary>
/// <param name="player">the player whose turn it is</param>
public void PerformTurn(Player player)
{
Turn turn = Turn.CreateWithDefaultTime(
player,
ThrowAll()
);
turns.Add(turn);
}
/// <summary>
/// finds and returns the player whose turn it is
/// </summary>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public Player GetWhoPlaysNow()
{
if (!playerManager.GetAll().Any())
{
throw new MemberAccessException("you are exploring an empty collection\nthis should not have happened");
}
return playerManager.GetAll().ElementAt(nextIndex);
}
/// <summary>
/// this feels very dirty
/// </summary>
/// <param name="current">the current player</param>
/// <exception cref="MemberAccessException"></exception>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public void PrepareNextPlayer(Player current)
{
if (!playerManager.GetAll().Any())
{
throw new MemberAccessException("you are exploring an empty collection\nthis should not have happened");
}
if (current == null)
{
throw new ArgumentNullException(nameof(current), "param should not be null");
}
if (!playerManager.GetAll().Contains(current))
{
throw new ArgumentException("param could not be found in this collection\n did you forget to add it?", nameof(current));
}
if (playerManager.GetAll().Last() == current)
{
// if we've reached the last player, we need the index to loop back around
nextIndex = 0;
}
else
{
// else we can just move up by one from the current index
nextIndex++;
}
}
/// <summary>
/// throws all the Dice in FavGroup and returns a list of their Faces
/// </summary>
/// <returns>list of AbstractDieFaces after a throw</returns>
private Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> ThrowAll()
{
Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> faces = new();
foreach (AbstractDie<AbstractDieFace> die in dice)
{
faces.Add(die, die.GetRandomFace());
}
return faces;
}
public Player AddPlayerToGame(Player player)
{
return playerManager.Add(player);
}
public IEnumerable<Player> GetPlayersFromGame()
{
return playerManager.GetAll();
}
public Player UpdatePlayerInGame(Player oldPlayer, Player newPlayer)
{
return playerManager.Update(oldPlayer, newPlayer);
}
public void RemovePlayerFromGame(Player player)
{
playerManager.Remove(player);
}
/// <summary>
/// represents a Game in string format
/// </summary>
/// <returns>a Game in string format</returns>
public override string ToString()
{
StringBuilder sb = new();
sb.Append($"Game: {Name}");
sb.Append("\nPlayers:");
foreach (Player player in GetPlayersFromGame())
{
sb.Append($" {player.ToString()}");
}
sb.Append($"\nNext: {GetWhoPlaysNow()}");
sb.Append("\nLog:\n");
foreach (Turn turn in this.turns)
{
sb.Append($"\t{turn.ToString()}\n");
}
return sb.ToString();
}
}
}
using Model.Dice;
using Model.Dice.Faces;
using Model.Players;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Numerics;
using System.Text;
namespace Model.Games
{
public class Game
{
/// <summary>
/// the name of the game 😎
/// </summary>
public string Name
{
get
{
return name;
}
set // GameRunner will need to take care of forbidding
// (or allowing) having two Games with the same name etc.
{
if (string.IsNullOrWhiteSpace(value))
{
throw new ArgumentException("param should not be null or blank", nameof(value));
}
name = value;
}
}
private string name;
/// <summary>
/// references the position in list of the current player, for a given game.
/// </summary>
private int nextIndex;
/// <summary>
/// the turns that have been done so far
/// </summary>
private readonly List<Turn> turns;
/// </summary>
/// get a READ ONLY enumerable of all turns belonging to this game
/// </summary>
/// <returns>a readonly enumerable of all this game's turns</returns>
public IEnumerable<Turn> GetHistory() => turns.AsEnumerable();
/// <summary>
/// the game's player manager, doing CRUD on players and switching whose turn it is
/// </summary>
private readonly IManager<Player> playerManager;
/// <summary>
/// the group of dice used for this game
/// </summary>
public IEnumerable<AbstractDie<AbstractDieFace>> Dice => dice;
private readonly IEnumerable<AbstractDie<AbstractDieFace>> dice;
/// <summary>
/// constructs a Game with its own history of Turns.
/// If <paramref name="turns"/> is null, starts a new history
/// </summary>
/// <param name="name">the name of the game 😎</param>
/// <param name="turns">the turns that have been done so far</param>
/// <param name="playerManager">the game's player manager, doing CRUD on players and switching whose turn it is</param>
/// <param name="favGroup">the group of dice used for this game</param>
public Game(string name, IManager<Player> playerManager, IEnumerable<AbstractDie<AbstractDieFace>> dice, IEnumerable<Turn> turns)
{
Name = name;
this.turns = turns is null ? new List<Turn>() : turns.ToList();
this.playerManager = playerManager;
this.dice = dice;
this.nextIndex = 0;
}
/// <summary>
/// constructs a Game with no history of turns.
/// </summary>
/// <param name="name">the name of the game 😎</param>
/// <param name="playerManager">the game's player manager, doing CRUD on players and switching whose turn it is</param>
/// <param name="favGroup">the group of dice used for this game</param>
public Game(string name, IManager<Player> playerManager, IEnumerable<AbstractDie<AbstractDieFace>> dice)
: this(name, playerManager, dice, null)
{ }
/// <summary>
/// performs a Turn, marks this Game as "started", and logs that Turn
/// </summary>
/// <param name="player">the player whose turn it is</param>
public void PerformTurn(Player player)
{
Turn turn = Turn.CreateWithDefaultTime(
player,
ThrowAll()
);
AddTurn(turn);
}
private void AddTurn(Turn turn)
{
if (!(turns.Contains(turn)))
{
turns.Add(turn);
}
}
/// <summary>
/// finds and returns the player whose turn it is
/// </summary>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public Player GetWhoPlaysNow()
{
if (!playerManager.GetAll().Any())
{
throw new MemberAccessException("you are exploring an empty collection\nthis should not have happened");
}
return playerManager.GetAll().ElementAt(nextIndex);
}
/// <summary>
/// this feels very dirty
/// </summary>
/// <param name="current">the current player</param>
/// <exception cref="MemberAccessException"></exception>
/// <exception cref="ArgumentNullException"></exception>
/// <exception cref="ArgumentException"></exception>
public void PrepareNextPlayer(Player current)
{
if (!playerManager.GetAll().Any())
{
throw new MemberAccessException("you are exploring an empty collection\nthis should not have happened");
}
if (current == null)
{
throw new ArgumentNullException(nameof(current), "param should not be null");
}
if (!playerManager.GetAll().Contains(current))
{
throw new ArgumentException("param could not be found in this collection\n did you forget to add it?", nameof(current));
}
if (playerManager.GetAll().Last() == current)
{
// if we've reached the last player, we need the index to loop back around
nextIndex = 0;
}
else
{
// else we can just move up by one from the current index
nextIndex++;
}
}
/// <summary>
/// throws all the Dice in FavGroup and returns a list of their Faces
/// </summary>
/// <returns>list of AbstractDieFaces after a throw</returns>
private Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> ThrowAll()
{
Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> faces = new();
foreach (AbstractDie<AbstractDieFace> die in dice)
{
faces.Add(die, die.GetRandomFace());
}
return faces;
}
public Player AddPlayerToGame(Player player)
{
return playerManager.Add(player);
}
public IEnumerable<Player> GetPlayersFromGame()
{
return playerManager.GetAll();
}
public Player UpdatePlayerInGame(Player oldPlayer, Player newPlayer)
{
return playerManager.Update(oldPlayer, newPlayer);
}
public void RemovePlayerFromGame(Player player)
{
playerManager.Remove(player);
}
/// <summary>
/// represents a Game in string format
/// </summary>
/// <returns>a Game in string format</returns>
public override string ToString()
{
StringBuilder sb = new();
sb.Append($"Game: {Name}");
sb.Append("\nPlayers:");
foreach (Player player in GetPlayersFromGame())
{
sb.Append($" {player.ToString()}");
}
sb.Append($"\nNext: {GetWhoPlaysNow()}");
sb.Append("\nLog:\n");
foreach (Turn turn in this.turns)
{
sb.Append($"\t{turn.ToString()}\n");
}
return sb.ToString();
}
}
}

24
Sources/Model/Games/Turn.cs
Unescape View File

@ -17,7 +17,7 @@ namespace Model.Games
/// Two turns are equal if they are litterally the same instance in RAM
/// (default behaviors Equals() and GetHashCode())
/// </summary>
public class Turn
public sealed class Turn : IEquatable<Turn>
{
/// <summary>
@ -115,5 +115,27 @@ namespace Model.Games
return sb.ToString();
}
public bool Equals(Turn other)
{
return Player.Equals(other.Player)
&& When.Equals(other.When)
&& DiceNFaces.SequenceEqual(other.DiceNFaces);
}
public override bool Equals(object obj)
{
if (obj is not Turn)
{
return false;
}
return Equals(obj as Turn);
}
public override int GetHashCode()
{
return HashCode.Combine(Player, When, DiceNFaces);
}
}
}

3
Sources/Tests/Model_UTs/GameTest.cs
Unescape View File

@ -149,9 +149,6 @@ namespace Tests.Model_UTs
int n = 5;
IEnumerable<Player> players = game.GetPlayersFromGame();
Debug.WriteLine(players);
Player currentPlayer;
for (int i = 0; i < n; i++)
{

10
Sources/Tests/Model_UTs/PlayerTest.cs
Unescape View File

@ -79,16 +79,6 @@ namespace Tests.Model_UTs
Assert.Equal(expected, actual);
}
class Point
{
public int X { get; set; }
public int Y { get; set; }
public Point(int x, int y)
{
X = x; Y = y;
}
}
[Fact]
public void TestEqualsFalseIfNotPlayer()
{

19
Sources/Tests/Model_UTs/Point.cs
Unescape View File

@ -0,0 +1,19 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace Tests.Model_UTs
{
public class Point
{
public int X { get; private set; }
public int Y { get; private set; }
public Point(int x, int y)
{
X = x; Y = y;
}
}
}

139
Sources/Tests/Model_UTs/TurnTest.cs
Unescape View File

@ -13,7 +13,9 @@ namespace Tests.Model_UTs
public class TurnTest
{
private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES;
private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES_1;
private readonly Dictionary<AbstractDie<AbstractDieFace>, AbstractDieFace> DICE_N_FACES_2;
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);
@ -57,13 +59,19 @@ namespace Tests.Model_UTs
public TurnTest()
{
DICE_N_FACES = new()
DICE_N_FACES_1 = new()
{
{ NUM1, FACE_ONE },
{ NUM2, FACE_TWO },
{ IMG1, FACE_THREE },
{ CLR1, FACE_FOUR }
};
DICE_N_FACES_2 = new()
{
{ NUM1, FACE_TWO },
{ IMG1, FACE_THREE },
{ CLR1, FACE_FOUR }
};
}
@ -77,7 +85,7 @@ namespace Tests.Model_UTs
Assert.NotEqual(DateTimeKind.Utc, dateTime.Kind);
// Act
Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
// Assert
Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
@ -95,7 +103,7 @@ namespace Tests.Model_UTs
Assert.Equal(DateTimeKind.Utc, dateTime.Kind);
// Act
Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
// Assert
Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
@ -110,7 +118,7 @@ namespace Tests.Model_UTs
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);
void action() => Turn.CreateWithSpecifiedTime(dateTime, null, DICE_N_FACES_1);
// Assert
Assert.Throws<ArgumentNullException>(action);
@ -137,10 +145,10 @@ namespace Tests.Model_UTs
// 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();
DICE_N_FACES_1.Clear();
// Act
void action() => Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
void action() => Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
// Assert
Assert.Throws<ArgumentException>(action);
@ -155,7 +163,7 @@ namespace Tests.Model_UTs
Player player = new("Chloe");
// Act
Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES);
Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
// Assert
Assert.Equal(DateTimeKind.Utc, turn.When.Kind);
@ -178,7 +186,7 @@ namespace Tests.Model_UTs
+ FACE_THREE.ToString() + " "
+ FACE_FOUR.ToString();
Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES);
Turn turn = Turn.CreateWithSpecifiedTime(dateTime, player, DICE_N_FACES_1);
// Act
string actual = turn.ToString();
@ -195,11 +203,120 @@ namespace Tests.Model_UTs
Player player = new("Erika");
// Act
Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES);
IEnumerable<KeyValuePair<AbstractDie<AbstractDieFace>, AbstractDieFace>> expected = DICE_N_FACES.AsEnumerable();
Turn turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
IEnumerable<KeyValuePair<AbstractDie<AbstractDieFace>, AbstractDieFace>> expected = DICE_N_FACES_1.AsEnumerable();
// Assert
Assert.Equal(expected, turn.DiceNFaces);
}
[Fact]
public void TestEqualsFalseIfNotTurn()
{
// Arrange
Point point;
Turn turn;
Player player = new("Freddie");
// Act
point = new(1, 2);
turn = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
// Assert
Assert.False(point.Equals(turn));
Assert.False(point.GetHashCode().Equals(turn.GetHashCode()));
Assert.False(turn.Equals(point));
Assert.False(turn.GetHashCode().Equals(point.GetHashCode()));
}
[Fact]
public void TestGoesThruToSecondMethodIfObjIsTypeTurn()
{
// Arrange
Object t1;
Turn t2;
Player player1 = new Player("Marvin");
Player player2 = new Player("Noah");
// Act
t1 = Turn.CreateWithDefaultTime(player1, DICE_N_FACES_1);
t2 = Turn.CreateWithDefaultTime(player2, DICE_N_FACES_2);
// Assert
Assert.False(t1.Equals(t2));
Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.False(t2.Equals(t1));
Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
}
[Fact]
public void TestEqualsFalseIfNotSamePlayer()
{
// Arrange
Player player1= new("Panama");
Player player2= new("Clyde");
// Act
Turn t1 = Turn.CreateWithDefaultTime(player1, DICE_N_FACES_2);
Turn t2 = Turn.CreateWithDefaultTime(player2, DICE_N_FACES_2);
// Assert
Assert.False(t1.Equals(t2));
Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.False(t2.Equals(t1));
Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
}
[Fact]
public void TestEqualsFalseIfNotSameTime()
{
// Arrange
Player player = new("Oscar");
// Act
Turn t1 = Turn.CreateWithSpecifiedTime(new DateTime(1994, 07, 10), player, DICE_N_FACES_1);
Turn t2 = Turn.CreateWithSpecifiedTime(new DateTime(1991, 08, 20), player, DICE_N_FACES_1);
// Assert
Assert.False(t1.Equals(t2));
Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.False(t2.Equals(t1));
Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
}
[Fact]
public void TestEqualsFalseIfNotSameDiceNFaces()
{
// Arrange
Player player = new("Django");
// Act
Turn t1 = Turn.CreateWithDefaultTime(player, DICE_N_FACES_1);
Turn t2 = Turn.CreateWithDefaultTime(player, DICE_N_FACES_2);
// Assert
Assert.False(t1.Equals(t2));
Assert.False(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.False(t2.Equals(t1));
Assert.False(t2.GetHashCode().Equals(t1.GetHashCode()));
}
[Fact]
public void TestEqualsTrueIfExactlySameProperties()
{
// Arrange
Player player = new("Elyse");
// Act
Turn t1 = Turn.CreateWithSpecifiedTime(new DateTime(1990, 04, 29), player, DICE_N_FACES_1);
Turn t2 = Turn.CreateWithSpecifiedTime(new DateTime(1990, 04, 29), player, DICE_N_FACES_1);
// Assert
Assert.True(t1.Equals(t2));
Assert.True(t1.GetHashCode().Equals(t2.GetHashCode()));
Assert.True(t2.Equals(t1));
Assert.True(t2.GetHashCode().Equals(t1.GetHashCode()));
}
}
}

Write Preview
Loading…
Cancel
Save