//------------------------------------------------------------------------------------
/// <summary>
/// Do some preprossessing of the cards before evaluation
/// </summary>
//------------------------------------------------------------------------------------
public Card[] PrepCards()
{
var cards = DealtCards.ToArray();
// Use a custom insertion sort for fastest sorting on this
// small array.
for (int i = 1; i < cards.Length; i++)
{
for (int j = i - 1, k = i; j >= 0 && cards[j].Rank < cards[k].Rank; j--, k--)
{
(cards[j], cards[k]) = (cards[k], cards[j]);
}
}
foreach (var card in cards)
{
_suitBits[(int)card.Suit] |= (int)card.Rank;
_rankBits |= (int)card.Rank;
// ace is special because it can be the "1" in a strait
if (card.Rank == Rank.Ace)
{
_suitBits[(int)card.Suit] |= 1;
_rankBits |= 1;
}
_suitCounts[(int)card.Suit]++;
}
return(cards);
}
public CardModel ReplaceCard(CardModel cardToReplace)
{
cardToReplace.IsSelected = false;
Cards.Add(cardToReplace);
DealtCards.Remove(cardToReplace);
return(GetCard());
}
public CardModel GetCard()
{
int index = Random.Next(Cards.Count);
DealtCards.Add(Cards[index]);
Cards.RemoveAt(index);
return(DealtCards.Last());
}
//------------------------------------------------------------------------------------
/// <summary>
/// Add a card to this hand
/// </summary>
//------------------------------------------------------------------------------------
public void AddCard(Card card)
{
if ((CardBits & card.Bit) > 0)
{
throw new ApplicationException("Duplicate Card: " + card);
}
CardBits |= card.Bit;
DealtCards.Add(card);
_evaluated = false;
}
private bool CheckIfFlush()
{
int suitToCheck = DealtCards[0].CardSuit;
foreach (Card card in DealtCards.Skip(1))
{
if (card.CardSuit != suitToCheck)
{
return(false);
}
}
return(true);
}
//------------------------------------------------------------------------------------
/// <summary>
/// Remove cards from the hand, except for the number of cards you specify. The
/// cards will be removed last in, first out order
/// </summary>
//------------------------------------------------------------------------------------
internal void ClearAllBut(int keep)
{
var pocketCards = DealtCards.Take(keep);
DealtCards.Clear();
_suitBits = new int[4];
_suitCounts = new int[4];
_rankBits = 0;
_evaluated = false;
CardBits = 0;
foreach (var card in pocketCards)
{
AddCard(card);
}
}
private void SendCardToFoundationResult(CardTransferResponseEventArgs response)
{
_eventAggregator.GetEvent <CardTransferResponseEvent>().Unsubscribe(
SendCardToFoundationResult);
if (response.Accepted)
{
//accepted.
Debug.WriteLine("accepted");
DealtCards.Remove(response.Card);
}
else
{
// rejected
Debug.WriteLine("rejected");
}
}
private bool CheckIfThreeOfAKind()
{
var groupedCards = DealtCards.GroupBy(n => n.CardRank);
List <int> numOfElements = new List <int>();
foreach (var cardGroup in groupedCards)
{
numOfElements.Add(cardGroup.Count());
}
if (numOfElements.Contains(3) && numOfElements.Contains(1))
{
return(true);
}
return(false);
}
private bool CheckIfStraight()
{
var sortedCards = DealtCards.OrderBy(o => o.CardRank).ToList();
int rankToCheck = sortedCards[0].CardRank;
foreach (Card card in sortedCards)
{
if (card.CardRank != rankToCheck)
{
return(false);
}
rankToCheck++;
}
return(true);
}
private bool CheckIfJacksOrBetter()
{
var queryAce = DealtCards.Select(n => n)
.Where(n => n.CardRank == 1)
.ToList();
if (queryAce.Count == 2)
{
return(true);
}
var queryKings = DealtCards.Select(n => n)
.Where(n => n.CardRank == 13)
.ToList();
if (queryKings.Count == 2)
{
return(true);
}
var queryQueens = DealtCards.Select(n => n)
.Where(n => n.CardRank == 12)
.ToList();
if (queryQueens.Count == 2)
{
return(true);
}
var queryJacks = DealtCards.Select(n => n)
.Where(n => n.CardRank == 11)
.ToList();
if (queryJacks.Count == 2)
{
return(true);
}
return(false);
}
//Deals out the cards
private void DealStack()
{
//overflow goes to separeate pile
DealtCards.ToList().ForEach(c => c.FaceUp = false);
_wasteStack.AddRange(DealtCards);
DealtCards.Clear();
if (_cards.Count == 0)
{
CardsEmpty = true;
// Resets
_wasteStack.Reverse();
_cards.AddRange(_wasteStack);
_wasteStack.Clear();
// Top card changes
TopCard = _cards.Count > 0 ? _cards[_cards.Count - 1] : null;
return;
}
if (CardsEmpty)
{
CardsEmpty = false;
}
int numToDeal = Math.Min(_cards.Count, NumCardsPerDeal);
int index = _cards.Count - numToDeal;
// cycles through cards
var deal = _cards.GetRange(index, numToDeal);
deal.Reverse();
DealtCards.AddRange(deal);
_cards.RemoveRange(index, numToDeal);
DealtCards.ToList().ForEach(c => c.FaceUp = true);
// Top card changes
TopCard = _cards.Count > 0 ? _cards[_cards.Count - 1] : null;
}
private bool CheckIfRoyalFlush()
{
var sortedCards = DealtCards.OrderBy(o => o.CardRank).ToList();
int suitToCheck = sortedCards[0].CardSuit;
int rankToCheck = 10;
if (sortedCards[0].CardRank != 1)
{
return(false);
}
foreach (Card card in sortedCards.Skip(1))
{
if (card.CardSuit != suitToCheck || card.CardRank != rankToCheck)
{
return(false);
}
rankToCheck++;
}
return(true);
}
public void RemoveCard(int index)
{
DealtCards.RemoveAt(index);
}
public void AddCard(Card card)
{
DealtCards.Add(card);
EvaluateHand();
}
