Implementing ability to continue playing after a player wins.

Author: 12Acorns

CardDeck/Deck/Card/GameCard.cs

@@ -27,10 +27,16 @@ public GameCard(CardDescription _description, CardData _data)
 	public readonly CardData Data { get; }
 	public bool InUse { get; private set; }
 
+	/// <summary>
+	/// Set card to be in use
+	/// </summary>
 	public void PickUp()
 	{
 		InUse = true;
 	}
+	/// <summary>
+	/// Set card to be no longer in use
+	/// </summary>
 	public void PutDown()
 	{
 		InUse = false;

CardDeck/Deck/CardDeck.cs

@@ -34,21 +34,35 @@ public CardDeck(ReadOnlySpan<GameCard> _cards, IRandomizer _randomizer, int _max
 
 	private int position;
 	private int nextFreePosition;
-	private readonly GameCard[] cards;
 	private readonly IRandomizer randomizer;
 
+	internal readonly GameCard[] cards;
+
+	public void ShufflePutDown(IRandomizer _randomizer)
+	{
+		position = cards.Length - 1;
+		nextFreePosition = position;
+		_randomizer.Randomize(cards);
+        for (int i = 0; i < cards.Length; i++)
+        {
+			cards[i].PutDown();
+		}
+    }
+	public void ShufflePutDown()
+	{
+		ShufflePutDown(randomizer);
+	}
 	public void Shuffle(IRandomizer _randomizer)
 	{
 		position = cards.Length - 1;
 		_randomizer.Randomize(cards);
 	}
 	public void Shuffle()
 	{
-		position = cards.Length - 1;
-		randomizer.Randomize(cards);
+		Shuffle(randomizer);
 	}
 
-	public void SetCurrent(GameCard _card)
+	public void SetCurrentCard(GameCard _card)
 	{
 		cards[position] = _card;
 	}
@@ -106,10 +120,9 @@ public bool Add(GameCard _card)
 
 		_card.PutDown();
 
+		position = nextFreePosition;
 		cards[nextFreePosition--] = _card;
 
-		position = nextFreePosition + 1;
-
 		return true;
 	}
 	/// <returns>
@@ -130,6 +143,9 @@ public bool TryNextFree(out GameCard _card)
 		position--;
 		return position > 0;
 	}
+	/// <summary>
+	/// Destructive operation, will clear internal <see cref="cards"/> array.
+	/// </summary>
 	public void Clear()
 	{
 		position = cards.Length - 1;

GameOne/Game/GameManager.cs

@@ -34,16 +34,20 @@ public GameManager()
 		}
 
 		renderer = new(players, manager.NonAI);
+
+		gameThread = new(Game);
+		gameThread.Start();
 	}
 
 	private bool playing;
 	private readonly Player[] players;
+	private readonly Thread gameThread;
 	private readonly RoundManager manager;
 	private readonly GameRenderer renderer;
 
 	public void Run()
 	{
-		var _winner = manager.AllPlayers().FirstOrDefault(x => x.Score > 500);
+		var _winner = players.FirstOrDefault(x => x.Score > 500);
 		if(_winner != null)
 		{
 			Console.WriteLine($"{manager.CurrentPlayer} has won the game");
@@ -56,9 +60,6 @@ public void Run()
 		}
 		playing = true;
 
-		var _gameThread = new Thread(Game);
-		_gameThread.Start();
-
 		while(!manager.GameOver) 
 		{
 			threadEvent.Set();
@@ -71,6 +72,9 @@ public void Run()
 		Console.WriteLine(_winningPlayer.Name + $" Won\nPoints: {_winningPlayer.Score}");
 
 		playing = false;
+
+
+
 		Run();
 	}
 	public void Render(Player _player)
@@ -83,6 +87,8 @@ public void Render(Player _player)
 
 	private void Game()
 	{
+		threadEvent.WaitOne();
+
 		var _nonAI = manager.NonAI;
 		lock(lockObject)
 		{

GameOne/Game/RoundManager.cs

@@ -55,6 +55,41 @@ public RoundManager(CardDeck _deck, int _playerCount, int _startingCards)
 	private int skipPlayerCount;
 	private bool reverseOrder;
 
+	public void NewGame(int _startingCards)
+	{
+		playerIndex = 0;
+
+		for(int i = PickupDeck.Cards.Length; i > 0; i++)
+		{
+			PickupDeck.TryNextFree(out var _pickupCard);
+			if(_pickupCard.Data.SubType == Globals.)
+		}
+
+		PickupDeck.ShufflePutDown();
+		DiscardPile.Clear();
+		for(int i = 0; i < players.Length; i++)
+		{
+			players[i].Clear();
+
+
+		}
+
+		PickupDeck.TryNextFree(out var _card);
+
+		DiscardPile.Add(_card);
+
+		// Make sure first playing card is NUMERICTYPE
+		while(_card.Description.Type == Globals.SpecialType)
+		{
+			if(!PickupDeck.TryNextFree(out _card))
+			{
+				throw new Exception("Failed to init, try adding more cards");
+			}
+
+			DiscardPile.Add(_card);
+		}
+	}
+
 	public void EvaluatePostPlay()
 	{
 		OnWin(CurrentPlayer);
@@ -96,14 +131,20 @@ public GameCard GetTopCard()
 	}
 	public void SetWildColour(RGBColour _colour)
 	{
+		if(_colour == RGBColour.None)
+		{
+			_colour = RGBColour.GetClassicColour((CardColour)Random.Shared.Next(4));
+			Console.WriteLine($"Invalid Colour, Got: {RGBColour.None.Name}, Now: {_colour.Name}");
+		}
+
 		var _card = DiscardPile.Peek();
 		if(_card.Data.SubType != Globals.WildSubType && _card.Data.SubType != Globals.WildPlusFourSubType)
 		{
 			return;
 		}
 
 		_card.Description = _card.Description with { Colour = _colour };
-		DiscardPile.SetCurrent(_card);
+		DiscardPile.SetCurrentCard(_card);
 	}
 	[MethodImpl(MethodImplOptions.AggressiveInlining)]
 	public GameCard PeekDiscardPileTopCard() => 
@@ -225,10 +266,7 @@ public bool ExecuteCardBehaviour(GameCard _card)
 	}
 	public IEnumerable<Player> AllPlayers()
 	{
-		for(int i = 0; i < playersLength; i++)
-		{
-			yield return PeekPlayer(i);
-		}
+		return players;
 	}
 	private void IncrementSkipCount()
 	{
@@ -276,7 +314,7 @@ private Player[] CreateAndGivePlayersCards(int _playerCount, int _cardsPerPlayer
 			_players[i] = i switch
 			{
 				0 => new GamePlayer("Player", _cards, this),
-				> 0 => new GameAI("AI " + i, _cards, this),
+				> 0 => new GameAI($"AI {i}", _cards, this),
 				_ => throw new IndexOutOfRangeException(nameof(i))
 			};
 		}

GameOne/_Player/GameAI.cs

@@ -53,10 +53,12 @@ protected override void PlayImpl(Action<Player> _render)
 		if(!playerCardMap.TryGetValue(_nextPlayer, out var _cardHistory))
 		{
 			defaultCardAction(x => x.CanPlay(_discardCard, false), out bool _colourChange);
-			if(_colourChange)
+			if(!_colourChange)
 			{
-				manager.SetWildColour(_selfOrdered.First().Key);
+				return;
 			}
+			var _first = _selfOrdered.FirstOrDefault().Key;
+			manager.SetWildColour(_first);
 			return;
 		}
 

GameOne/_Player/Player.cs

@@ -23,9 +23,21 @@ public Player(IEnumerable<GameCard> _startingCards, RoundManager _manager)
 
 	protected int currentCardHandle
 	{
-		get => currentCardHandleVal %= cards.Count;
+		get
+		{
+			if(cards.Count == 0)
+			{
+				return 0;
+			}
+			return currentCardHandleVal %= cards.Count;
+		}
 		set
 		{
+			if(cards.Count == 0)
+			{
+				currentCardHandleVal = 0;
+				return;
+			}
 			currentCardHandleVal = value;
 			if(currentCardHandle < 0)
 			{
@@ -38,7 +50,6 @@ protected int currentCardHandle
 	protected readonly List<GameCard> cards;
 	protected readonly RoundManager manager;
 
-
 	public GameCard CurrentCard => cards[currentCardHandle];
 	public bool IsTurn => manager.CurrentPlayer == this;
 	public List<GameCard> Cards => cards;
@@ -62,6 +73,10 @@ public int SumOfCardsScores
 		}
 	}
 
+	public void Clear()
+	{
+		cards.Clear();
+	}
 	public void Play(Action<Player> _render)
 	{
 		if(!IsTurn)
@@ -83,7 +98,6 @@ public void Play(Action<Player> _render)
 
 		PlayImpl(_render);
 	}
-
 	public void GiveCards(ReadOnlySpan<GameCard> _cards) => cards.AddRange(_cards);
 	public void GiveCard(GameCard _card) => cards.Add(_card);
 	public bool PlayCards(ReadOnlySpan<GameCard> _desiredCards)