public void CardValueTest(CardValue value1, CardSuit suit1, CardValue value2, CardSuit suit2, int expected)
{
Card card1 = new Card(value1, suit1);
Card card2 = new Card(value2, suit2);
Assert.AreEqual(expected, card1.CompareTo(card2));
}
public Card(CardSuit suit, CardValue value, Image front, Image back)
{
Suit = suit;
Value = value;
FrontFace = front;
BackFace = back;
}
public static string ConvertToString(CardValue cardValue)
{
switch (cardValue)
{
case CardValue._2:
return "2";
case CardValue._3:
return "3";
case CardValue._4:
return "4";
case CardValue._5:
return "5";
case CardValue._6:
return "6";
case CardValue._7:
return "7";
case CardValue._8:
return "8";
case CardValue._9:
return "9";
case CardValue._10:
return "t";
case CardValue._Jack:
return "j";
case CardValue._Queen:
return "q";
case CardValue._King:
return "k";
case CardValue._Ace:
return "a";
}
throw Utility.GetUnknownEnumValueException(cardValue);
}
public void PlayerCards_HighestCardShouldBeSelectedAsKicker()
{
CardValue firstCard = new CardValue(cardValues[0] + "_of_" + cardTypes[0]);
CardValue secondCard = new CardValue(cardValues[4] + "_of_" + cardTypes[3]);
Result result = new Result(new CardValue[] { firstCard, secondCard }, new CardValue[] { firstCard });
Assert.AreEqual(secondCard, result.PlayerKicker);
}
public void CommunityCards_LowestCardShouldNotBeSelectedAsKicker()
{
CardValue firstCard = new CardValue(cardValues[0] + "_of_" + cardTypes[0]);
CardValue secondCard = new CardValue(cardValues[7] + "_of_" + cardTypes[1]);
CardValue thirdCard = new CardValue(cardValues[2] + "_of_" + cardTypes[3]);
CardValue fourthCard = new CardValue(cardValues[9] + "_of_" + cardTypes[2]);
CardValue fifthCard = new CardValue(cardValues[1] + "_of_" + cardTypes[0]);
Result result = new Result(new CardValue[] { firstCard, secondCard }, new CardValue[] { firstCard, secondCard, thirdCard, fourthCard, fifthCard });
Assert.AreNotEqual(firstCard, result.CommunityKicker);
}
public void CalculateResult_ResultShouldBePair()
{
CardValue firstCard = new CardValue(cardValues[0] + "_of_" + cardTypes[0]);
CardValue secondCard = new CardValue(cardValues[5] + "_of_" + cardTypes[2]);
CardValue thirdCard = new CardValue(cardValues[3] + "_of_" + cardTypes[3]);
CardValue fourthCard = new CardValue(cardValues[8] + "_of_" + cardTypes[1]);
CardValue fifthCard = new CardValue(cardValues[5] + "_of_" + cardTypes[0]);
CardValue sixthCard = new CardValue(cardValues[1] + "_of_" + cardTypes[2]);
CardValue seventhCard = new CardValue(cardValues[9] + "_of_" + cardTypes[3]);
Result result = new Result(new CardValue[]{firstCard, secondCard}, new CardValue[]{thirdCard, fourthCard, fifthCard, sixthCard, seventhCard});
result.CalculateResult();
Assert.AreEqual((int) PlayerResult.Pair, result.ResultIndex);
}
/// <summary>
/// Initializes a new instance of the <see cref="CardsGame"/> class.
/// </summary>
/// <param name="decks">The amount of decks in the game.</param>
/// <param name="jokersInDeck">The amount of jokers in each deck.</param>
/// <param name="suits">The suits which will appear in each deck. Multiple
/// values can be supplied using flags.</param>
/// <param name="cardValues">The card values which will appear in each deck.
/// Multiple values can be supplied using flags.</param>
/// <param name="minimumPlayers">The minimal amount of players
/// for the game.</param>
/// <param name="maximumPlayers">The maximal amount of players
/// for the game.</param>
/// <param name="tableBounds">The table bounds.</param>
/// <param name="dealerPosition">The dealer position.</param>
/// <param name="placeOrder">A function which translates a player's index to
/// his rendering location on the game table.</param>
/// <param name="theme">The name of the theme to use for the
/// game's assets.</param>
/// <param name="game">The associated game object.</param>
public CardsGame(int decks, int jokersInDeck, CardSuit suits, CardValue cardValues,
int minimumPlayers, int maximumPlayers, GameTable gameTable, string theme, Game game)
{
rules = new List<GameRule>();
players = new List<Player>();
dealer = new CardPacket(decks, jokersInDeck, suits, cardValues);
Game = game;
MinimumPlayers = minimumPlayers;
MaximumPlayers = maximumPlayers;
this.Theme = theme;
cardsAssets = new Dictionary<string, Texture2D>();
GameTable = gameTable;
GameTable.DrawOrder = -10000;
game.Components.Add(GameTable);
}
public void TestHandForAStraightFlush(CardValue cardValue1, CardSuit cardSuit1, CardValue cardValue2, CardSuit cardSuit2,
CardValue cardValue3, CardSuit cardSuit3, CardValue cardValue4, CardSuit cardSuit4,
CardValue cardValue5, CardSuit cardSuit5)
{
var card1 = new Card(cardValue1, cardSuit1);
_hand.AddCard(card1);
var card2 = new Card(cardValue2, cardSuit2);
_hand.AddCard(card2);
var card3 = new Card(cardValue3, cardSuit3);
_hand.AddCard(card3);
var card4 = new Card(cardValue4, cardSuit4);
_hand.AddCard(card4);
var card5 = new Card(cardValue5, cardSuit5);
_hand.AddCard(card5);
var play = PokerRules.CheckPlay(_hand);
Assert.AreEqual(PokerRules.PokerPlay.StraightFlush, play);
}
public Result(CardValue[] playerCards, CardValue[] communityCards)
{
playerKicker = playerCards[0].GetIntegerValue() > playerCards[1].GetIntegerValue() ? playerCards[0] : playerCards[1];
communityKicker = communityCards[0];
for (int i = 1; i < communityCards.Length; i++)
{
if (communityCards[i].GetIntegerValue() > communityKicker.GetIntegerValue())
{
communityKicker = communityCards[i];
}
}
cards = new List<CardValue>();
cards.AddRange(playerCards);
cards.AddRange(communityCards);
cards.Sort((p1, p2) => p1.GetIntegerValue().CompareTo(p2.GetIntegerValue()));
}
/// <summary>
/// Initializes a new instance of the <see cref="CardPacket"/> class.
/// </summary>
/// <param name="numberOfDecks">The number of decks to add to
/// the collection.</param>
/// <param name="jokersInDeck">The amount of jokers in each deck.</param>
/// <param name="suits">The suits to add to each decks. Suits are specified
/// as flags and several can be added.</param>
/// <param name="cardValues">The card values which will appear in each deck.
/// values are specified as flags and several can be added.</param>
public CardPacket(int numberOfDecks, int jokersInDeck,
CardSuit suits, CardValue cardValues)
{
cards = new List<TraditionalCard>();
for (int deckIndex = 0; deckIndex < numberOfDecks; deckIndex++)
{
AddSuit(suits, cardValues);
for (int j = 0; j < jokersInDeck / 2; j++)
{
cards.Add(new TraditionalCard(CardSuit.Club,
CardValue.FirstJoker, this));
cards.Add(new TraditionalCard(CardSuit.Club,
CardValue.SecondJoker, this));
}
if (jokersInDeck % 2 == 1)
{
cards.Add(new TraditionalCard(CardSuit.Club,
CardValue.FirstJoker, this));
}
}
}
internal void HandlePutCardCommand(Client sender, byte val, byte type)
{
Client onTurn = Players[this._turn];
if (sender == onTurn)
{ // todo check this check
Card putCard = new Card(type, val);
CardPack playerPack = this.Packs[onTurn];
Card lastCard = PlayedCardsPack.Peek();
if (playerPack.Contains(putCard)) // check if player actually has the card
{
if (lastCard.Umflator)
{
// umflatorii se pun doar ca valoare ambivalenta, nu poti pune 3 INIMA peste 2 Inima
if (putCard.Umflator)
{ // COREEECT
umfla(2);
}
else //if (!playerPack.Any(c => c.Umflator))
{
// jucatorul ALEGE SA NU DEA un umflator sau NU ARE SA DEA
OnCardsOwed();
}
SetNextTurn();
}
else // daca nu e umflator
{
CardValue equivalentValue = lastCard.Value;
if (lastCard.Type == putCard.Type)
{
MoveCard(playerPack, PlayedCardsPack, putCard);
// END TURN HERE
EndTurn();
return;
}
else if (equivalentValue == CardValue.Queen || equivalentValue == CardValue.King)
{
equivalentValue = (CardValue)(equivalentValue - 10);
//goto checkOnValue; // probably redundant
}
//checkOnValue:
if (equivalentValue == putCard.Value)
{
MoveCard(playerPack, PlayedCardsPack, putCard);
// END TURN HERE
EndTurn();
return;
}
// daca am ajuns aici, inseamna ca nu are sa dea carte
// daca este As => sta o tura
// daca nu este As=> primeste una
if (equivalentValue == CardValue.Ace)
{
// sit
}
else
{
Card onTop = this.PackOnTable.Pop();
GiveCardToPlayer(onTop, onTurn);
}
EndTurn();
return;
}
}
}
else
{ // not his turn
sender.Send(Packet.CreatePacket(HeaderTypes.GAME_PLAYER_PUT_CARD_ERROR));
}
}
public void SetPlayerCard(int index, CardValue cardValue)
{
tempPlayerCards[index] = cardValue;
}
public Card(int valueIndex, int suitIndex)
{
this.Value = (CardValue)getCardValue(valueIndex);
this.Suit = (CardSuits)getCardSuit(suitIndex);
}
public PairClassification(CardValue cardValue)
{
_cardValue = cardValue;
}
/// <summary>
/// Initializes a new instance of the <see cref="Card"/> class.
/// </summary>
/// <param name="value">The value of the card.</param>
/// <param name="suit">The suit of the card.</param>
public Card(CardValue value, CardSuit suit)
{
this.Value = value;
this.Suit = suit;
this.Color = suit == CardSuit.Diamonds || suit == CardSuit.Hearts ? CardColor.Red : CardColor.Black;
}
public Card(int type, int val)
{
Type = (CardType)type;
Value = (CardValue)val;
}
//------------------------------------------------
// CCard(SuitValue suit, CardValue number)
//
// Precondition: suit must be a value in the SuitValue enumerator. number must be a value in the CardValue enumerator.
// Postcondition: Sets up the default properties.
//------------------------------------------------
public CCard(SuitValue suit, CardValue number)
{
this.suit = suit;
this.number = number;
}
public PlayCard( CardValue val, CardColour col )
{
Value = val;
Colour = col;
}
public CardModel(CardValue value, CardSuit suit)
{
this.Value = value;
this.Suit = suit;
}
public void SetNumericCardValue(int newValue)
{
this.numericValue = newValue;
this.cardValue = CardHelper.GetCardEnumFromValue(newValue);
}
public Card(CardSuite suite, CardValue value)
{
this.suite = suite;
this.value = value;
}
public void SetCardValue(CardValue newValue)
{
this.cardValue = newValue;
this.numericValue = CardHelper.GetValueFromCardEnum(newValue);
}
public Card(CardValue value, int type)
{
this.cardType = CardHelper.GetCardTypeFromValue(type);
this.SetCardValue(value);
}
public Card(CardValue value, CardType type)
{
this.cardType = type;
this.SetCardValue(value);
}
/// <summary>
/// Adds cards to the collection.
/// </summary>
/// <param name="suit">The suit of the added cards.</param>
/// <param name="cardValues">The card values which will appear in each deck.
/// values are specified as flags and several can be added.</param>
private void AddCards(CardSuit suit,
CardValue cardValues)
{
if ((cardValues & CardValue.Ace) == CardValue.Ace)
{
cards.Add(new TraditionalCard(suit, CardValue.Ace, this));
}
if ((cardValues & CardValue.Two) == CardValue.Two)
{
cards.Add(new TraditionalCard(suit, CardValue.Two, this));
}
if ((cardValues & CardValue.Three) == CardValue.Three)
{
cards.Add(new TraditionalCard(suit, CardValue.Three, this));
}
if ((cardValues & CardValue.Four) == CardValue.Four)
{
cards.Add(new TraditionalCard(suit, CardValue.Four, this));
}
if ((cardValues & CardValue.Five) == CardValue.Five)
{
cards.Add(new TraditionalCard(suit, CardValue.Five, this));
}
if ((cardValues & CardValue.Six) == CardValue.Six)
{
cards.Add(new TraditionalCard(suit, CardValue.Six, this));
}
if ((cardValues & CardValue.Seven) == CardValue.Seven)
{
cards.Add(new TraditionalCard(suit, CardValue.Seven, this));
}
if ((cardValues & CardValue.Eight) == CardValue.Eight)
{
cards.Add(new TraditionalCard(suit, CardValue.Eight, this));
}
if ((cardValues & CardValue.Nine) == CardValue.Nine)
{
cards.Add(new TraditionalCard(suit, CardValue.Nine, this));
}
if ((cardValues & CardValue.Ten) == CardValue.Ten)
{
cards.Add(new TraditionalCard(suit, CardValue.Ten, this));
}
if ((cardValues & CardValue.Jack) == CardValue.Jack)
{
cards.Add(new TraditionalCard(suit, CardValue.Jack, this));
}
if ((cardValues & CardValue.Queen) == CardValue.Queen)
{
cards.Add(new TraditionalCard(suit, CardValue.Queen, this));
}
if ((cardValues & CardValue.King) == CardValue.King)
{
cards.Add(new TraditionalCard(suit, CardValue.King, this));
}
}
public CardModel(AssetService assetService, CardSuit suit, CardValue value)
{
_assetService = assetService;
Suit = suit;
Value = value;
}
public Card(CardValue value, CardSuite suite)
{
v = value;
s = suite;
}
public Card(CardType t, CardValue val)
{
Type = t;
Value = val;
}
public Card(CardSuit suit, CardValue value)
{
Suit = suit;
Value = value;
}
public Card(int iSuit, int iValue)
{
suit = (CardSuit)(iSuit);
value = (CardValue)(iValue);
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="suit">The suit of the card.</param>
/// <param name="value">The value of the card.</param>
public Card(Suit suit, CardValue value)
{
Contract.Requires((int)suit >= (int)Suit.Diamonds && (int)suit <= (int)Suit.Spades);
Contract.Requires((int)value >= (int)CardValue.Two && (int)value <= (int)CardValue.Ace);
this.Suit = suit;
this.Value = value;
}
public CardData(Suit s, CardValue v)
{
suit = s;
value = v;
}
public Card(int value, int suite)
{
v = (CardValue)value;
s = (CardSuite)suite;
}
public Hand(List <Card> cards)
{
if (cards.Count == 0)
{
group = 0;
return;
}
// tell HandType
cards.Sort((x, y) => x.Number.CompareTo(y.Number));
if (cards.Count == 1)
{
handName = "single";
cardValue = new SingleCardValue(cards[0].Number);
return;
}
var flushLastValue = IsFlush(cards);
if (flushLastValue > 0)
{
handName = "flush";
// tell straight Flush
bool isStraightFlush = true;
foreach (var card in cards)
{
if (card.Suit != cards[0].Suit)
{
isStraightFlush = false;
break;
}
}
if (isStraightFlush)
{
cardValue = new FlushCardValue(flushLastValue + 13, cards.Count);
}
else
{
cardValue = new FlushCardValue(flushLastValue, cards.Count);
}
return;
}
var pairLastValue = IsPair(cards);
if (pairLastValue > 0)
{
handName = "pair";
cardValue = new PairCardValue(pairLastValue, cards.Count / 2);
return;
}
// checking for Hong or Bomb
HongOrBomb type;
int returnValue = CheckHongOrBomb(cards, out type);
if (returnValue > 0)
{
handName = type.ToString();
if (type == HongOrBomb.hong)
{
cardValue = new HongCardValue(returnValue, cards.Count() / (int)HongOrBomb.hong);
group = 2;
}
else
{
cardValue = new BombCardValue(returnValue, cards.Count() / (int)HongOrBomb.bomb);
group = 3;
}
return;
}
if (IsCats(cards))
{
handName = "cats";
group = 4;
return;
}
throw new Exception("not a valid hand");
}
public Card(CardSuit suit, CardValue value) // Constructor
{
this.Suit = suit; // Parameter "suit"
this.Value = value;
}
public Card(CardType cardtype, CardValue cardvalue)
{
cardType = cardtype;
cardValue = cardvalue;
}
public Card(CardValue value, CardSuit suit)
{
this.suit = suit;
this.value = value;
}
public Card(CardValue value, CardSuite suite)
{
Value = value;
Suite = suite;
}
public Card(CardValue value, CardSuit suit)
{
Value = value;
Suit = suit;
}
public Card_GetHashCodeThrowsException(CardValue value, CardSuit suit)
{
Value = value;
Suit = suit;
}
public Card(CardValue value)
{
Suit = CardSuit.Spade;
Value = value;
}
public Card(CardSuit suit, CardValue value)
{
Suit = suit;
Value = value;
}
public Card(CardSuit aSuite, CardValue aValue)
{
suit = aSuite;
value = aValue;
}
/// <summary>
/// Initializes a new instance of the <see cref="TraditionalCard"/> class.
/// </summary>
/// <param name="type">The card suit. Supports only a single value.</param>
/// <param name="value">The card's value. Only single values are
/// supported.</param>
/// <param name="holdingCardCollection">The holding card collection.</param>
internal TraditionalCard(CardSuit type, CardValue value,
CardPacket holdingCardCollection)
{
// Check for single type
switch (type)
{
case CardSuit.Club:
case CardSuit.Diamond:
case CardSuit.Heart:
case CardSuit.Spade:
break;
default:
{
throw new ArgumentException(
"type must be single value", "type");
}
}
// Check for single value
switch (value)
{
case CardValue.Ace:
case CardValue.Two:
case CardValue.Three:
case CardValue.Four:
case CardValue.Five:
case CardValue.Six:
case CardValue.Seven:
case CardValue.Eight:
case CardValue.Nine:
case CardValue.Ten:
case CardValue.Jack:
case CardValue.Queen:
case CardValue.King:
case CardValue.FirstJoker:
case CardValue.SecondJoker:
break;
default:
{
throw new ArgumentException(
"value must be single value", "value");
}
}
Type = type;
Value = value;
HoldingCardCollection = holdingCardCollection;
}
public void SetCommunityCard(int index, CardValue cardValue)
{
communityCards[index] = cardValue;
}
private void SetValue(CardValue value)
{
if (m_ValueSet) {
Debug.LogError("Value has been already set!");
return;
}
m_Value = value;
m_ValueSet = true;
SetCardSpritesIfCardFullyPrepared();
}
internal CardPlayedEventArgs(CardValue value, CardColour colour, bool wasPeak)
{
Value = value;
Colour = colour;
WasPeakCard = wasPeak;
}
void InitializeCard(string value, string suit)
{
switch (suit.ToUpper())
{
case "C":
{
this.Suit = CardSuit.Clubs;
break;
}
case "D":
{
this.Suit = CardSuit.Diamonds;
break;
}
case "H":
{
this.Suit = CardSuit.Hearts;
break;
}
case "S":
{
this.Suit = CardSuit.Spades;
break;
}
default:
{
throw new ArgumentException(String.Format("Unrecognized Card Suit: {0}", suit.ToString()));
}
}
switch (value.ToUpper())
{
case "2":
{
this.Value = CardValue.Deuce;
break;
}
case "3":
{
this.Value = CardValue.Trey;
break;
}
case "4":
{
this.Value = CardValue.Four;
break;
}
case "5":
{
this.Value = CardValue.Five;
break;
}
case "6":
{
this.Value = CardValue.Six;
break;
}
case "7":
{
this.Value = CardValue.Seven;
break;
}
case "8":
{
this.Value = CardValue.Eight;
break;
}
case "9":
{
this.Value = CardValue.Nine;
break;
}
case "T":
{
this.Value = CardValue.Ten;
break;
}
case "J":
{
this.Value = CardValue.Jack;
break;
}
case "Q":
{
this.Value = CardValue.Queen;
break;
}
case "K":
{
this.Value = CardValue.King;
break;
}
case "A":
{
this.Value = CardValue.Ace;
break;
}
default:
{
throw new ArgumentException(String.Format("Unrecognized Card Value: {0}", value.ToString()));
}
}
}
public Card(CardSuits suits, CardValue value)
{
Suits = suits;
Value = value;
}
//KONSTRUKTORER (Hur man får skapa ett nytt kort)
public PlayingCard(CardValue value, CardSuit suit, bool faceDown)
{
Value = value;
Suit = suit;
FaceDown = faceDown;
}
/// <summary>
/// Method to check a hand for a specific card
/// </summary>
/// <param name="hand">List of Cards</param>
/// <param name="value">CardValue</param>
/// <returns>true if found</returns>
public bool valuefound(List<Card> hand, CardValue value)
{
if(hand.Count(card => card.Value == value) >= 1){
return true;
}
return false;
}
internal Card(CardValue value, CardSuit suit)
{
this.Value = value;
this.Suit = suit;
}
/// <summary>
/// Adds suits of cards to the collection.
/// </summary>
/// <param name="suits">The suits to add to each decks. Suits are specified
/// as flags and several can be added.</param>
/// <param name="cardValues">The card values which will appear in each deck.
/// values are specified as flags and several can be added.</param>
private void AddSuit(CardSuit suits, CardValue cardValues)
{
if ((suits & CardSuit.Club) == CardSuit.Club)
{
AddCards(CardSuit.Club, cardValues);
}
if ((suits & CardSuit.Diamond) == CardSuit.Diamond)
{
AddCards(CardSuit.Diamond, cardValues);
}
if ((suits & CardSuit.Heart) == CardSuit.Heart)
{
AddCards(CardSuit.Heart, cardValues);
}
if ((suits & CardSuit.Spade) == CardSuit.Spade)
{
AddCards(CardSuit.Spade, cardValues);
}
}
public Card(CardType t, CardValue v)
{
type = t;
value = v;
}
/// <summary>
/// The main constructor.
/// </summary>
/// <param name="type">The type of the card.</param>
/// <param name="value">The value of the card.</param>
/// <param name="isDown">Whether the card is face down or face up.</param>
public Card(CardType type, CardValue value, bool isDown = true)
{
this.Type = type;
this.Value = value;
this.IsDown = isDown;
}
public static PokerHand CreatePairDifferentNonPairCardValue(CardValue thirdCard, CardValue fourthCard, CardValue fifthCard)
{
return(CreateHand(new Tuple <CardSuit, CardValue>(CardSuit.Heart, CardValue.Five),
new Tuple <CardSuit, CardValue>(CardSuit.Club, CardValue.Five),
new Tuple <CardSuit, CardValue>(CardSuit.Spade, thirdCard),
new Tuple <CardSuit, CardValue>(CardSuit.Heart, fourthCard),
new Tuple <CardSuit, CardValue>(CardSuit.Diamond, fifthCard)
));
}
public static PlayingCard Create(CardValue val, CardSuit suit)
{
return new PlayingCard { Suit = suit.ToString(), Value = val.ToString() };
}
public int IndexOfCard(CardValue card)
{
return(Cards.ToList().IndexOf(card));
}
public Card(CardValue cardValue, CardSuit cardSuit)
{
Value = cardValue;
Suit = cardSuit;
}
public Card(CardValue value, CardSuit suit)
{
Value = value;
Suit = suit;
}
