Implemented all AI behaviour, added final win condition, clearer names

12Acorns · 12Acorns · commit 6215e4a39004 · 2024-08-06T20:47:53.000+01:00
diff --git a/CardDeck/Deck/Card/Colour/ClassicColours.cs b/CardDeck/Deck/Card/Colour/ClassicColours.cs
@@ -4,20 +4,20 @@
 {
 	public ClassicColours() { }
 
-	public readonly RGBColour Red = new("Red", 255, 0, 0);
-	public readonly RGBColour Green = new("Green", 0, 255, 0);
-	public readonly RGBColour Blue = new("Blue", 0, 0, 255);
-	public readonly RGBColour Yellow = new("Yellow", 255, 255, 0);
-	public readonly RGBColour Black = new("Black", 0, 0, 0);
+	public readonly RGBColour Red = RGBColour.Red;
+	public readonly RGBColour Green = RGBColour.Green;
+	public readonly RGBColour Blue = RGBColour.Blue;
+	public readonly RGBColour Yellow = RGBColour.Yellow;
+	public readonly RGBColour None = RGBColour.None;
 
-	public string SetName { get; } = "Default Colours";
+	public string SetName { get; } = "Classic Colours";
 
 	public IEnumerable<RGBColour> GetColours()
 	{
 		yield return Red;
 		yield return Green;
 		yield return Blue;
 		yield return Yellow;
-		yield return Black;
+		yield return None;
 	}
 }
diff --git a/CardDeck/Deck/Card/Colour/IColourSet.cs b/CardDeck/Deck/Card/Colour/IColourSet.cs
@@ -2,7 +2,7 @@
 
 public interface IColourSet
 {
-	public static readonly IColourSet Default = new ClassicColours();
+	public static readonly IColourSet Classic = new ClassicColours();
 
 	public string SetName { get; }
 
diff --git a/CardDeck/Deck/Card/Colour/RGBColour.cs b/CardDeck/Deck/Card/Colour/RGBColour.cs
@@ -4,7 +4,7 @@ namespace Deck.Deck.Card.Colour;
 
 public readonly struct RGBColour
 {
-	public static readonly RGBColour Default = new RGBColour();
+	public static readonly RGBColour None = new();
 
 	public static readonly RGBColour White = new("White", 255, 255, 255);
 	public static readonly RGBColour Black = new("Black", 0, 0, 0);
@@ -24,7 +24,7 @@ public RGBColour(string _name, byte _r, byte _g, byte _b)
 	}
 	public RGBColour()
 	{
-		Name = "";
+		Name = "None";
 		R = default;
 		G = default;
 		B = default;
@@ -47,12 +47,13 @@ public RGBColour()
 		CardColour.Blue => Blue,
 		CardColour.Red => Red,
 		CardColour.Green => Green,
+		CardColour.None => None,
 		_ => throw new ArgumentOutOfRangeException(nameof(_colour))
 	};
 
 	public override string ToString()
 	{
-		return string.Format("R: {0}, G: {1}, B: {2}", R, G, B);
+		return string.Format("Colour: {0}\nR: {1}, G: {2}, B: {3}", Name, R, G, B);
 	}
 
 	public override bool Equals([NotNullWhen(true)] object? _obj)
diff --git a/GameOne/Extensions/CardExtensions.cs b/GameOne/Extensions/CardExtensions.cs
@@ -64,11 +64,11 @@ public static byte MapToScore(this CardSubType _subType)
 		}
 		return _score;
 	}
-	public static bool CanPlay(this GameCard _card, GameCard _other, bool _strictPlay = true)
+	public static bool CanPlay(this GameCard _card, GameCard _comparison, bool _strictPlay = true)
 	{
-		var _discardDescription = _other.Description;
+		var _discardDescription = _comparison.Description;
 		var _desiredDescription = _card.Description;
-		var _discardData = _other.Data;
+		var _discardData = _comparison.Data;
 		var _desiredData = _card.Data;
 
 		if(_card.InUse && _strictPlay)
diff --git a/GameOne/Extensions/IEnumerableExtensions.cs b/GameOne/Extensions/IEnumerableExtensions.cs
@@ -2,9 +2,27 @@
 
 internal static class IEnumerableExtensions
 {
+	public static IEnumerable<(T _self, int _index)> WithIndex<T>(this IEnumerable<T> _self)
+	{
+		if(_self == null)
+		{
+			throw new NullReferenceException($"{nameof(_self)} is null");
+		}
+
+		return _self.Select((T _element, int _index) => (_element, _index));
+	}
 	public static IEnumerable<(T1 _first, T2 _second)> EnumerateMany<T1, T2>
 		(this IEnumerable<T1> _first, IEnumerable<T2> _second)
 	{
+		if(_first == null)
+		{
+			throw new NullReferenceException($"{nameof(_first)} is null");
+		}
+		if(_second == null)
+		{
+			throw new NullReferenceException($"{nameof(_second)} is null");
+		}
+
 		using var _firstIE = _first.GetEnumerator();
 		using var _secondIE = _second.GetEnumerator();
 
diff --git a/GameOne/Game/DeckFactory.cs b/GameOne/Game/DeckFactory.cs
@@ -10,19 +10,19 @@ public static CardGroupDescription GetDefaultSpecialDescription()
 	{
 		var _descriptions = new CardDescription[5];
 
-		ReadOnlySpan<RGBColour> _colours = IColourSet.Default.GetColours().ToArray();
+		ReadOnlySpan<RGBColour> _colours = IColourSet.Classic.GetColours().ToArray();
 
 		for(int i = 0; i < _colours.Length - 1; i++)
 		{
 			var _cardDescriptionBuilder =
-				new CardDescriptionBuilder(Globals.SpecialType, IColourSet.Default, _colours[i]);
+				new CardDescriptionBuilder(Globals.SpecialType, IColourSet.Classic, _colours[i]);
 			_descriptions[i] = _cardDescriptionBuilder
 				.WithType(Globals.PlusTwoSubType, 2).WithType(Globals.ReverseSubType, 2)
 				.WithType(Globals.SkipSubType, 2).Build();
 		}
 
 		var _wildCardsBuilder =
-			new CardDescriptionBuilder(Globals.SpecialType, IColourSet.Default, _colours[^1]);
+			new CardDescriptionBuilder(Globals.SpecialType, IColourSet.Classic, _colours[^1]);
 		_descriptions[4] = _wildCardsBuilder
 			.WithType(Globals.WildSubType, 4).WithType(Globals.WildPlusFourSubType, 4)
 			.Build();
@@ -31,14 +31,14 @@ public static CardGroupDescription GetDefaultSpecialDescription()
 	}
 	public static CardGroupDescription GetDefaultNumericDescription()
 	{
-		ReadOnlySpan<RGBColour> _colours = IColourSet.Default.GetColours().ToArray();
+		ReadOnlySpan<RGBColour> _colours = IColourSet.Classic.GetColours().ToArray();
 
 		var _descriptions = new CardDescription[_colours.Length - 1];
 
 		for(int i = 0; i < _descriptions.Length; i++)
 		{
 			var _cardDescriptionBuilder =
-				new CardDescriptionBuilder(Globals.NumericType, IColourSet.Default, _colours[i]);
+				new CardDescriptionBuilder(Globals.NumericType, IColourSet.Classic, _colours[i]);
 			_cardDescriptionBuilder
 				.WithType(Globals.ZeroSubType, 1);
 
diff --git a/GameOne/Game/GameManager.cs b/GameOne/Game/GameManager.cs
@@ -43,6 +43,13 @@ public GameManager()
 
 	public void Run()
 	{
+		var _winner = manager.AllPlayers().FirstOrDefault(x => x.Score > 500);
+		if(_winner != null)
+		{
+			Console.WriteLine($"{manager.CurrentPlayer} has won the game");
+			return;
+		}
+
 		if(playing)
 		{
 			return;
@@ -59,7 +66,12 @@ public void Run()
 
 		threadEvent.Reset();
 
-		Console.WriteLine(manager.CurrentPlayer.Name + $" Won\nPoints: {manager.CurrentPlayer.SumOfCardsScores}");
+		var _winningPlayer = manager.CurrentPlayer;
+
+		Console.WriteLine(_winningPlayer.Name + $" Won\nPoints: {_winningPlayer.Score}");
+
+		playing = false;
+		Run();
 	}
 	public void Render(Player _player)
 	{
@@ -74,16 +86,25 @@ private void Game()
 		var _nonAI = manager.NonAI;
 		lock(lockObject)
 		{
-			while(!manager.GameOver)
+			while(true)
 			{
 				threadEvent.WaitOne();
 
 				Render(_nonAI);
 				manager.CurrentPlayer.Play(Render);
 
+				if(manager.GameOver)
+				{
+					break;
+				}
 
 				manager.NextPlayer();
 			}
 		}
+		if(manager.AllPlayers().Any(x => x.Score > 500))
+		{
+			return;
+		}
+		Game();
 	}
 }
diff --git a/GameOne/Game/RoundManager.cs b/GameOne/Game/RoundManager.cs
@@ -55,19 +55,18 @@ public RoundManager(CardDeck _deck, int _playerCount, int _startingCards)
 	private int skipPlayerCount;
 	private bool reverseOrder;
 
-
 	public void EvaluatePostPlay()
 	{
 		OnWin(CurrentPlayer);
 	}
 	private void OnWin(Player _player)
 	{
-		if(_player.Cards.Length != 0)
+		if(_player.TotalCards != 0)
 		{
 			return;
 		}
+		_player.Score += AllPlayers().Where(x => x != _player).Sum(x => x.SumOfCardsScores);
 		GameOver = true;
-		_player.Score += AllPlayers().Sum(x => x.SumOfCardsScores);
 	}
 	public ReadOnlySpan<GameCard> GetMultipleCards(int _amount)
 	{
@@ -95,18 +94,6 @@ public GameCard GetTopCard()
 
 		return _card;
 	}
-	public void SkipPlayer()
-	{
-		var _discardCard = PeekDiscardPileTopCard();
-		if(_discardCard.Data.SubType != Globals.WildPlusFourSubType
-		|| _discardCard.Data.SubType != Globals.PlusTwoSubType
-		|| _discardCard.Data.SubType != Globals.SkipSubType)
-		{
-			return;
-		}
-
-		skipPlayerCount++;
-	}
 	public void SetWildColour(RGBColour _colour)
 	{
 		var _card = DiscardPile.Peek();
@@ -148,7 +135,6 @@ public bool AddToDiscard(GameCard _card)
 	/// <summary>
 	/// Returns current player and increments player handle
 	/// </summary>
-	/// <returns></returns>
 	public Player NextPlayer()
 	{
 		var _player = CurrentPlayer;
@@ -165,21 +151,24 @@ public Player NextPlayer()
 		{
 			playerIndex = (byte)((playerIndex + 1) % playersLength);
 		}
-		CurrentPlayer = players[playerIndex];
 
 		if(skipPlayerCount > 0)
 		{
 			skipPlayerCount--;
 			_player = NextPlayer();
 		}
 
+		CurrentPlayer = players[playerIndex];
 		return _player;
 	}
 	public Player PeekPlayer(int _offset)
 	{
 		int _index;
 		int _modValue;
-		if(reverseOrder || _offset < 0)
+
+		var _checkReverse = reverseOrder ^ (_offset < 0);
+
+		if(_checkReverse)
 		{
 			_offset = Math.Abs(_offset);
 			_modValue = playerIndex - _offset;
@@ -207,14 +196,13 @@ public bool ExecuteCardBehaviour(GameCard _card)
 		if(_subType == Globals.PlusTwoSubType)
 		{
 			var _nextPlayer = PeekPlayer(1);
-			_nextPlayer.GiveCard(GetTopCard());
-			_nextPlayer.GiveCard(GetTopCard());
-			SkipPlayer();
+			_nextPlayer.GiveCards(GetMultipleCards(2));
+			IncrementSkipCount();
 			return false;
 		}
 		if(_subType == Globals.SkipSubType)
 		{
-			SkipPlayer();
+			IncrementSkipCount();
 			return false;
 		}
 		if(_subType == Globals.ReverseSubType)
@@ -229,22 +217,23 @@ public bool ExecuteCardBehaviour(GameCard _card)
 		if(_subType == Globals.WildPlusFourSubType)
 		{
 			var _nextPlayer = PeekPlayer(1);
-			_nextPlayer.GiveCard(GetTopCard());
-			_nextPlayer.GiveCard(GetTopCard());
-			_nextPlayer.GiveCard(GetTopCard());
-			_nextPlayer.GiveCard(GetTopCard());
-			SkipPlayer();
+			_nextPlayer.GiveCards(GetMultipleCards(4));
+			IncrementSkipCount();
 			return true;
 		}
 		throw new NotSupportedException(nameof(_subType) + " is not a supported type");
 	}
-	private IEnumerable<Player> AllPlayers()
+	public IEnumerable<Player> AllPlayers()
 	{
 		for(int i = 0; i < playersLength; i++)
 		{
 			yield return PeekPlayer(i);
 		}
 	}
+	private void IncrementSkipCount()
+	{
+		skipPlayerCount++;
+	}
 	private void Shuffle()
 	{
 		PickupDeck.Shuffle();
diff --git a/GameOne/_Player/GameAI.cs b/GameOne/_Player/GameAI.cs
diff --git a/GameOne/_Player/GamePlayer.cs b/GameOne/_Player/GamePlayer.cs
diff --git a/GameOne/_Player/Player.cs b/GameOne/_Player/Player.cs

Original file line number	Diff line number	Diff line change
`@@ -2,7 +2,7 @@`
`2`	`2`
`3`	`3`	`public interface IColourSet`
`4`	`4`	`{`
`5`		`- public static readonly IColourSet Default = new ClassicColours();`
	`5`	`+ public static readonly IColourSet Classic = new ClassicColours();`
`6`	`6`
`7`	`7`	`public string SetName { get; }`
`8`	`8`
Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ namespace Deck.Deck.Card.Colour;`
`4`	`4`
`5`	`5`	`public readonly struct RGBColour`
`6`	`6`	`{`
`7`		`- public static readonly RGBColour Default = new RGBColour();`
	`7`	`+ public static readonly RGBColour None = new();`
`8`	`8`
`9`	`9`	`public static readonly RGBColour White = new("White", 255, 255, 255);`
`10`	`10`	`public static readonly RGBColour Black = new("Black", 0, 0, 0);`
`@@ -24,7 +24,7 @@ public RGBColour(string _name, byte _r, byte _g, byte _b)`
`24`	`24`	`}`
`25`	`25`	`public RGBColour()`
`26`	`26`	`{`
`27`		`- Name = "";`
	`27`	`+ Name = "None";`
`28`	`28`	`R = default;`
`29`	`29`	`G = default;`
`30`	`30`	`B = default;`
`@@ -47,12 +47,13 @@ public RGBColour()`
`47`	`47`	`CardColour.Blue => Blue,`
`48`	`48`	`CardColour.Red => Red,`
`49`	`49`	`CardColour.Green => Green,`
	`50`	`+ CardColour.None => None,`
`50`	`51`	`_ => throw new ArgumentOutOfRangeException(nameof(_colour))`
`51`	`52`	`};`
`52`	`53`
`53`	`54`	`public override string ToString()`
`54`	`55`	`{`
`55`		`- return string.Format("R: {0}, G: {1}, B: {2}", R, G, B);`
	`56`	`+ return string.Format("Colour: {0}\nR: {1}, G: {2}, B: {3}", Name, R, G, B);`
`56`	`57`	`}`
`57`	`58`
`58`	`59`	`public override bool Equals([NotNullWhen(true)] object? _obj)`
Original file line number	Diff line number	Diff line change
`@@ -64,11 +64,11 @@ public static byte MapToScore(this CardSubType _subType)`
`64`	`64`	`}`
`65`	`65`	`return _score;`
`66`	`66`	`}`
`67`		`- public static bool CanPlay(this GameCard _card, GameCard _other, bool _strictPlay = true)`
	`67`	`+ public static bool CanPlay(this GameCard _card, GameCard _comparison, bool _strictPlay = true)`
`68`	`68`	`{`
`69`		`- var _discardDescription = _other.Description;`
	`69`	`+ var _discardDescription = _comparison.Description;`
`70`	`70`	`var _desiredDescription = _card.Description;`
`71`		`- var _discardData = _other.Data;`
	`71`	`+ var _discardData = _comparison.Data;`
`72`	`72`	`var _desiredData = _card.Data;`
`73`	`73`
`74`	`74`	`if(_card.InUse && _strictPlay)`
Original file line number	Diff line number	Diff line change
`@@ -10,19 +10,19 @@ public static CardGroupDescription GetDefaultSpecialDescription()`
`10`	`10`	`{`
`11`	`11`	`var _descriptions = new CardDescription[5];`
`12`	`12`
`13`		`- ReadOnlySpan<RGBColour> _colours = IColourSet.Default.GetColours().ToArray();`
	`13`	`+ ReadOnlySpan<RGBColour> _colours = IColourSet.Classic.GetColours().ToArray();`
`14`	`14`
`15`	`15`	`for(int i = 0; i < _colours.Length - 1; i++)`
`16`	`16`	`{`
`17`	`17`	`var _cardDescriptionBuilder =`
`18`		`- new CardDescriptionBuilder(Globals.SpecialType, IColourSet.Default, _colours[i]);`
	`18`	`+ new CardDescriptionBuilder(Globals.SpecialType, IColourSet.Classic, _colours[i]);`
`19`	`19`	`_descriptions[i] = _cardDescriptionBuilder`
`20`	`20`	`.WithType(Globals.PlusTwoSubType, 2).WithType(Globals.ReverseSubType, 2)`
`21`	`21`	`.WithType(Globals.SkipSubType, 2).Build();`
`22`	`22`	`}`
`23`	`23`
`24`	`24`	`var _wildCardsBuilder =`
`25`		`- new CardDescriptionBuilder(Globals.SpecialType, IColourSet.Default, _colours[^1]);`
	`25`	`+ new CardDescriptionBuilder(Globals.SpecialType, IColourSet.Classic, _colours[^1]);`
`26`	`26`	`_descriptions[4] = _wildCardsBuilder`
`27`	`27`	`.WithType(Globals.WildSubType, 4).WithType(Globals.WildPlusFourSubType, 4)`
`28`	`28`	`.Build();`
`@@ -31,14 +31,14 @@ public static CardGroupDescription GetDefaultSpecialDescription()`
`31`	`31`	`}`
`32`	`32`	`public static CardGroupDescription GetDefaultNumericDescription()`
`33`	`33`	`{`
`34`		`- ReadOnlySpan<RGBColour> _colours = IColourSet.Default.GetColours().ToArray();`
	`34`	`+ ReadOnlySpan<RGBColour> _colours = IColourSet.Classic.GetColours().ToArray();`
`35`	`35`
`36`	`36`	`var _descriptions = new CardDescription[_colours.Length - 1];`
`37`	`37`
`38`	`38`	`for(int i = 0; i < _descriptions.Length; i++)`
`39`	`39`	`{`
`40`	`40`	`var _cardDescriptionBuilder =`
`41`		`- new CardDescriptionBuilder(Globals.NumericType, IColourSet.Default, _colours[i]);`
	`41`	`+ new CardDescriptionBuilder(Globals.NumericType, IColourSet.Classic, _colours[i]);`
`42`	`42`	`_cardDescriptionBuilder`
`43`	`43`	`.WithType(Globals.ZeroSubType, 1);`
`44`	`44`
Original file line number	Diff line number	Diff line change
`@@ -43,6 +43,13 @@ public GameManager()`
`43`	`43`
`44`	`44`	`public void Run()`
`45`	`45`	`{`
	`46`	`+ var _winner = manager.AllPlayers().FirstOrDefault(x => x.Score > 500);`
	`47`	`+ if(_winner != null)`
	`48`	`+ {`
	`49`	`+ Console.WriteLine($"{manager.CurrentPlayer} has won the game");`
	`50`	`+ return;`
	`51`	`+ }`
	`52`	`+`
`46`	`53`	`if(playing)`
`47`	`54`	`{`
`48`	`55`	`return;`
`@@ -59,7 +66,12 @@ public void Run()`
`59`	`66`
`60`	`67`	`threadEvent.Reset();`
`61`	`68`
`62`		`- Console.WriteLine(manager.CurrentPlayer.Name + $" Won\nPoints: {manager.CurrentPlayer.SumOfCardsScores}");`
	`69`	`+ var _winningPlayer = manager.CurrentPlayer;`
	`70`	`+`
	`71`	`+ Console.WriteLine(_winningPlayer.Name + $" Won\nPoints: {_winningPlayer.Score}");`
	`72`	`+`
	`73`	`+ playing = false;`
	`74`	`+ Run();`
`63`	`75`	`}`
`64`	`76`	`public void Render(Player _player)`
`65`	`77`	`{`
`@@ -74,16 +86,25 @@ private void Game()`
`74`	`86`	`var _nonAI = manager.NonAI;`
`75`	`87`	`lock(lockObject)`
`76`	`88`	`{`
`77`		`- while(!manager.GameOver)`
	`89`	`+ while(true)`
`78`	`90`	`{`
`79`	`91`	`threadEvent.WaitOne();`
`80`	`92`
`81`	`93`	`Render(_nonAI);`
`82`	`94`	`manager.CurrentPlayer.Play(Render);`
`83`	`95`
	`96`	`+ if(manager.GameOver)`
	`97`	`+ {`
	`98`	`+ break;`
	`99`	`+ }`
`84`	`100`
`85`	`101`	`manager.NextPlayer();`
`86`	`102`	`}`
`87`	`103`	`}`
	`104`	`+ if(manager.AllPlayers().Any(x => x.Score > 500))`
	`105`	`+ {`
	`106`	`+ return;`
	`107`	`+ }`
	`108`	`+ Game();`
`88`	`109`	`}`
`89`	`110`	`}`
Original file line number	Diff line number	Diff line change
`@@ -55,19 +55,18 @@ public RoundManager(CardDeck _deck, int _playerCount, int _startingCards)`
`55`	`55`	`private int skipPlayerCount;`
`56`	`56`	`private bool reverseOrder;`
`57`	`57`
`58`		`-`
`59`	`58`	`public void EvaluatePostPlay()`
`60`	`59`	`{`
`61`	`60`	`OnWin(CurrentPlayer);`
`62`	`61`	`}`
`63`	`62`	`private void OnWin(Player _player)`
`64`	`63`	`{`
`65`		`- if(_player.Cards.Length != 0)`
	`64`	`+ if(_player.TotalCards != 0)`
`66`	`65`	`{`
`67`	`66`	`return;`
`68`	`67`	`}`
	`68`	`+ _player.Score += AllPlayers().Where(x => x != _player).Sum(x => x.SumOfCardsScores);`
`69`	`69`	`GameOver = true;`
`70`		`- _player.Score += AllPlayers().Sum(x => x.SumOfCardsScores);`
`71`	`70`	`}`
`72`	`71`	`public ReadOnlySpan<GameCard> GetMultipleCards(int _amount)`
`73`	`72`	`{`
`@@ -95,18 +94,6 @@ public GameCard GetTopCard()`
`95`	`94`
`96`	`95`	`return _card;`
`97`	`96`	`}`
`98`		`- public void SkipPlayer()`
`99`		`- {`
`100`		`- var _discardCard = PeekDiscardPileTopCard();`
`101`		`- if(_discardCard.Data.SubType != Globals.WildPlusFourSubType`
`102`		`- \|\| _discardCard.Data.SubType != Globals.PlusTwoSubType`
`103`		`- \|\| _discardCard.Data.SubType != Globals.SkipSubType)`
`104`		`- {`
`105`		`- return;`
`106`		`- }`
`107`		`-`
`108`		`- skipPlayerCount++;`
`109`		`- }`
`110`	`97`	`public void SetWildColour(RGBColour _colour)`
`111`	`98`	`{`
`112`	`99`	`var _card = DiscardPile.Peek();`
`@@ -148,7 +135,6 @@ public bool AddToDiscard(GameCard _card)`
`148`	`135`	`/// <summary>`
`149`	`136`	`/// Returns current player and increments player handle`
`150`	`137`	`/// </summary>`
`151`		`- /// <returns></returns>`
`152`	`138`	`public Player NextPlayer()`
`153`	`139`	`{`
`154`	`140`	`var _player = CurrentPlayer;`
`@@ -165,21 +151,24 @@ public Player NextPlayer()`
`165`	`151`	`{`
`166`	`152`	`playerIndex = (byte)((playerIndex + 1) % playersLength);`
`167`	`153`	`}`
`168`		`- CurrentPlayer = players[playerIndex];`
`169`	`154`
`170`	`155`	`if(skipPlayerCount > 0)`
`171`	`156`	`{`
`172`	`157`	`skipPlayerCount--;`
`173`	`158`	`_player = NextPlayer();`
`174`	`159`	`}`
`175`	`160`
	`161`	`+ CurrentPlayer = players[playerIndex];`
`176`	`162`	`return _player;`
`177`	`163`	`}`
`178`	`164`	`public Player PeekPlayer(int _offset)`
`179`	`165`	`{`
`180`	`166`	`int _index;`
`181`	`167`	`int _modValue;`
`182`		`- if(reverseOrder \|\| _offset < 0)`
	`168`	`+`
	`169`	`+ var _checkReverse = reverseOrder ^ (_offset < 0);`
	`170`	`+`
	`171`	`+ if(_checkReverse)`
`183`	`172`	`{`
`184`	`173`	`_offset = Math.Abs(_offset);`
`185`	`174`	`_modValue = playerIndex - _offset;`
`@@ -207,14 +196,13 @@ public bool ExecuteCardBehaviour(GameCard _card)`
`207`	`196`	`if(_subType == Globals.PlusTwoSubType)`
`208`	`197`	`{`
`209`	`198`	`var _nextPlayer = PeekPlayer(1);`
`210`		`- _nextPlayer.GiveCard(GetTopCard());`
`211`		`- _nextPlayer.GiveCard(GetTopCard());`
`212`		`- SkipPlayer();`
	`199`	`+ _nextPlayer.GiveCards(GetMultipleCards(2));`
	`200`	`+ IncrementSkipCount();`
`213`	`201`	`return false;`
`214`	`202`	`}`
`215`	`203`	`if(_subType == Globals.SkipSubType)`
`216`	`204`	`{`
`217`		`- SkipPlayer();`
	`205`	`+ IncrementSkipCount();`
`218`	`206`	`return false;`
`219`	`207`	`}`
`220`	`208`	`if(_subType == Globals.ReverseSubType)`
`@@ -229,22 +217,23 @@ public bool ExecuteCardBehaviour(GameCard _card)`
`229`	`217`	`if(_subType == Globals.WildPlusFourSubType)`
`230`	`218`	`{`
`231`	`219`	`var _nextPlayer = PeekPlayer(1);`
`232`		`- _nextPlayer.GiveCard(GetTopCard());`
`233`		`- _nextPlayer.GiveCard(GetTopCard());`
`234`		`- _nextPlayer.GiveCard(GetTopCard());`
`235`		`- _nextPlayer.GiveCard(GetTopCard());`
`236`		`- SkipPlayer();`
	`220`	`+ _nextPlayer.GiveCards(GetMultipleCards(4));`
	`221`	`+ IncrementSkipCount();`
`237`	`222`	`return true;`
`238`	`223`	`}`
`239`	`224`	`throw new NotSupportedException(nameof(_subType) + " is not a supported type");`
`240`	`225`	`}`
`241`		`- private IEnumerable<Player> AllPlayers()`
	`226`	`+ public IEnumerable<Player> AllPlayers()`
`242`	`227`	`{`
`243`	`228`	`for(int i = 0; i < playersLength; i++)`
`244`	`229`	`{`
`245`	`230`	`yield return PeekPlayer(i);`
`246`	`231`	`}`
`247`	`232`	`}`
	`233`	`+ private void IncrementSkipCount()`
	`234`	`+ {`
	`235`	`+ skipPlayerCount++;`
	`236`	`+ }`
`248`	`237`	`private void Shuffle()`
`249`	`238`	`{`
`250`	`239`	`PickupDeck.Shuffle();`