private static Card CreateCard(string cardCode)
{
FaceValue face = GetFaceValue(cardCode[0]);
Suit suit = GetSuit(cardCode[1]);
return(new Card(suit, face));
}
private Tuple <FaceValue, int, int> GetFaceValue(FaceValue faceValue)
{
int standardVal;
int altVal;
switch (faceValue)
{
case FaceValue.Ace:
{
standardVal = 1;
altVal = 11;
break;
}
case FaceValue.Jack:
case FaceValue.Queen:
case FaceValue.King:
{
standardVal = altVal = 10;
break;
}
default:
standardVal = altVal = (int)faceValue + 1;
break;
}
return(Tuple.Create(faceValue, standardVal, altVal));
}
public void CheckHandType()
{
bool HasStraight = IsStraight();
if (HasStraight)
{
HandType = HandType.Straight;
}
else if (HasPair)
{
FindPairs();
}
// Hand is a flush
if (Suits.Count == 1)
{
// Check for royal straight flush
if (HasStraight)
{
if (Cards[0].FaceValue == FaceValue.Ten && Cards[4].FaceValue == FaceValue.Ace)
{
HandType = HandType.RoyalFlush;
}
HandType = HandType.StraightFlush;
}
}
if (HandType == HandType.HighCard)
{
HighValue = Cards[4].FaceValue;
}
}
public void Value_AddCardToHand_GivesCorrectValue(FaceValue face1, FaceValue face2, int expected)
{
_aHand.AddCard(new BlackJackCard(Suit.Clubs, face1));
_aHand.AddCard(new BlackJackCard(Suit.Clubs, face2));
_aHand.TurnAllCardsFaceUp();
Assert.Equal(expected, _aHand.Value);
}
public Task <FaceValueDto> Update(FaceValueDto faceValueDto)
{
FaceValue faceValue = ObjectMapper.Map <FaceValue>(faceValueDto);
faceValue = _faceValueRepository.Update(faceValue);
return(Task.FromResult <FaceValueDto>(faceValueDto));
}
public Card(FaceColor faceColor, FaceValue faceValue)
{
FaceColor = faceColor;
FaceValue = faceValue;
SetImage();
SetValues();
}
/// <summary>
/// Used by the constructor in this class only. Do NOT use elsewhere.
/// </summary>
private static string GetCardImageName(Card card)
{
Suit suit = card.GetSuit();
FaceValue faceValue = card.GetFaceValue();
return(string.Format("{0}{1}", suit.ToString().TrimEnd('s'), faceValue));
}
/// <summary>
/// Constructor - Loads images from disk files.
/// </summary>
static Images()
{
// Load coin images.
heads = LoadImage("Coins", "Heads150");
tails = LoadImage("Coins", "Tails150");
// Load card images.
backOfCardImage = Images.LoadImage("Cards", "CardBack_Red");
cardImages = new Bitmap[CardPile.NUM_SUITS, CardPile.NUM_CARDS_PER_SUIT];
for (Suit suit = Suit.Clubs; suit <= Suit.Spades; suit++)
{
for (FaceValue faceValue = FaceValue.Two; faceValue <= FaceValue.Ace; faceValue++)
{
Card card = new Card(suit, faceValue);
string cardImageName = GetCardImageName(card);
cardImages[(int)card.GetSuit(), (int)card.GetFaceValue()] = LoadImage("Cards", cardImageName);
}
} //end for ( Suit suit ...
//Load die images
dieImages = new Bitmap[7];
for (int i = 1; i < dieImages.Length; i++)
{
string dieImageName = "Face_";
dieImageName = dieImageName + i;
dieImages[i] = LoadImage("Dice", dieImageName);
}
}//end Images
public PlayingCard(Suit suit, FaceValue faceValue)
{
CheckArgument(suit, "suit", "suit");
CheckArgument(faceValue, "faceValue", "face value");
Suit = suit;
Value = faceValue;
}
public void Value_HandWithAce_TakesCorrectValueForAce(FaceValue value1, FaceValue value2, FaceValue value3, int value)
{
_aHand.AddCard(new BlackJackCard(Suit.Clubs, value1));
_aHand.AddCard(new BlackJackCard(Suit.Clubs, value2));
_aHand.AddCard(new BlackJackCard(Suit.Clubs, value3));
_aHand.TurnAllCardsFaceUp();
Assert.Equal(value, _aHand.Value);
}
public void CanConvertToString(FaceValue faceValue, string expected)
{
// act
string actual = converter.ToString(faceValue);
// assert
Assert.Equal(expected, actual);
}
public async Task <FaceValueDto> GetById(int id)
{
FaceValue result = await _faceValueRepository.GetAsync(id);
FaceValueDto dto = ObjectMapper.Map <FaceValueDto>(result);
return(dto);
}
public void ShouldHaveCorrectValForRoyalCards(FaceValue faceValue)
{
var deck = new Deck();
var card = deck.Cards.FirstOrDefault(x => x.FaceValue.Item1 == faceValue);
Assert.AreEqual(10, card.FaceValue.Item2);
Assert.AreEqual(10, card.FaceValue.Item3);
}
public void CanConvertFromString(string str, FaceValue expected)
{
// act
FaceValue actual = converter.FromString(str);
// assert
Assert.Equal(expected, actual);
}
/// <summary>
/// Returns the image for a given Card.
/// </summary>
/// <param name="card"></param>
/// <returns>the image for the Card specified by the parameter.</returns>
public static Bitmap GetCardImage(Card card)
{
Suit suit = card.GetSuit();
FaceValue faceValue = card.GetFaceValue();
string name = string.Format("{0}{1}", suit.ToString().TrimEnd('s'), faceValue);
return((Bitmap)Properties.Resources.ResourceManager.GetObject(name));
}
public Task <FaceValueDto> Create(FaceValueDto faceValueDto)
{
faceValueDto.CreatorUserId = AbpSession.UserId.Value;
faceValueDto.CreationTime = DateTime.Now;
FaceValue faceValue = ObjectMapper.Map <FaceValue>(faceValueDto);
faceValueDto.Id = _faceValueRepository.InsertAndGetId(faceValue);
return(Task.FromResult <FaceValueDto>(faceValueDto));
}
private void btnPickCard_Click(object sender, RoutedEventArgs e)
{
int cardValue = random.Next(52);
Suit suit = (Suit)(cardValue / 13);
FaceValue facevalue = (FaceValue)(cardValue / 13);
lblOutput.Content = cardValue + Environment.NewLine +
facevalue.ToString() + " of " + suit.ToString();
}
//Automatically populate the full deck on creation
public Deck()
{
for (Suit s = Suit.Clubs; s <= Suit.Spades; s++)
{
for (FaceValue f = FaceValue.Two; f <= FaceValue.Ace; f++)
{
this.sourceCards.Add(new Card(s, f));
}
}
}
private void MakeDeck(Suit[] suits, FaceValue[] values)
{
for (int aSuit = 0; aSuit < suits.Length; aSuit++)
{
for (int avalue = 0; avalue < values.Length; avalue++)
{
m_cards.Add(new Card(suits[aSuit], values[avalue]));
}
}
}
private Card GenerateCard()
{
Random myRandom = new Random();
//The random min value is INCLUSIVE, and the max value is EXCLUSIVE
Suit suit = (Suit)myRandom.Next(0, 4);
FaceValue face = (FaceValue)myRandom.Next(0, 13);
return(new Card(suit, face));
}
private void DetermineFaceValue()
{
// the way the deck is arranged, the face value of the card
// can be determined by taking the remainder of the
// integer division of the card number by the number of
// cards in each suit (13)
int fv = _cardNumber % 13;
_faceValue = (FaceValue)fv;
}
public Card GenerateCard()
{
Random myRandom = new Random();
//The random min value is inclusive. The max is exclusive
Suit mySuit = (Suit)myRandom.Next(0, 4);
FaceValue myFace = (FaceValue)myRandom.Next(0, 13);
return(new Card(mySuit, myFace));
}
public bool Contains(Suit suit, FaceValue faceValue)
{
for (int i = 0; i < cards.Count; i++)
{
if (cards[i].CardSuit == suit && cards[i].CardValue == faceValue)
{
return(true);
}
}
return(false);
}
public void RemoveCard(Suit theSuit, FaceValue theFaceValue)
{
foreach (Card card in this._cardsInHand)
{
if (card.Suit == theSuit && card.FaceValue == theFaceValue)
{
this._cardsInHand.Remove(card);
return;
}
}
}
public void Value_AddCardToHand_GivesCorrectValue(Suit suit1, FaceValue faceValue1, Suit suit2, FaceValue faceValue2, int value)
{
BlackJackCard card = new BlackJackCard(suit1, faceValue1);
card.TurnCard();
_aHand.AddCard(card);
card = new BlackJackCard(suit2, faceValue2);
card.TurnCard();
_aHand.AddCard(card);
Assert.Equal(value, _aHand.Value);
}
public void RemoveCard(Suit theSuit, FaceValue theFaceValue)
{
Card card = cards.Where(c => c.FaceValue == theFaceValue && c.Suit == theSuit).FirstOrDefault();
if (card == null)
{
throw new ConstraintException(theFaceValue.ToString() + "of" +
theSuit.ToString() + "does not exist in the hand.");
}
cards.Remove(card);
}
public void Randomize()
{
Random rnd = new Random(Guid.NewGuid().GetHashCode());
for (int i = 0; i < FaceValues.Count; i++)
{
FaceValues[i] = new FaceValue((ushort)rnd.Next(0, 65535), (ushort)rnd.Next(0, 65535), (ushort)rnd.Next(0, 65535));
}
isOriginal = false;
UpdateItemText();
}
public bool ContainsFaceValue(FaceValue faceValue)
{
foreach (Card card in GetCardEnumerator())
{
if (card.faceValue == faceValue)
{
return(true);
}
}
return(false);
}
/// <summary>
/// Deal a single card to who.
/// </summary>
/// <param name="who"></param>
/// <returns>The Card that has been delt to who.</returns>
public static Card DealOneCardTo(int who)
{
ensurePlayableCardPile();
Card deltCard = cardPile.DealOneCard();
sessionFaceValue = deltCard.GetFaceValue();
addPlayerPoints(who, sessionFaceValue);
hands[who].Add(deltCard);
return(deltCard);
}
/// Checks to see if the hand contains a card of a certain face value
public bool ContainsCard(FaceValue item)
{
foreach (Card c in cards)
{
if (c.FaceVal == item)
{
return(true);
}
}
return(false);
}
public void CanConvertFromString(
Suit suit, FaceValue faceValue, string str)
{
// arrange
var expectedCard = new PlayingCard(suit, faceValue);
// act
var actualCard = converter.FromString(str);
// assert
Assert.Equal(expectedCard, actualCard);
}
public void CanConvertToString(
Suit suit, FaceValue faceValue, string expected)
{
// arrange
var card = new PlayingCard(suit, faceValue);
// act
string cardAsString = converter.ToString(card);
// assert
Assert.Equal(expected, cardAsString);
}
public void RemoveCard(Suit theSuit, FaceValue theFaceValue)
{
for (int i = 0; i <= _Cards.Count - 1; i++)
{
if ((_Cards[i].Suit == theSuit) && (_Cards[i].FaceValue == theFaceValue))
{
_Cards.Remove(_Cards[i]);
return;
}
}
throw new ArgumentException(theFaceValue.ToString() + " of " + theSuit.ToString() + " is not in hand.");
}
public void RemoverCard(Suit theSuit, FaceValue theFaceValue)
{
foreach (Card card in cards)
{
if (card.Suit == theSuit && card.FaceValue == theFaceValue)
{
cards.Remove(card);
return;
}
}
throw new DataException(theFaceValue.ToString() + " of " + theSuit.ToString());
}
public void Remove(Suit suitToFind, FaceValue valueToFind)
{
Card aCard;
for (int i = 0; i < m_cards.Count; i++)
{
aCard = (Card)m_cards[i];
if ((aCard.Suit == suitToFind) && (aCard.FaceValue == valueToFind))
{
m_cards.Remove(aCard);
break;
}
}
}
public DeckOfCards GetCardsWithSameFaceValue(FaceValue faceValue)
{
DeckOfCards deckToReturn = new DeckOfCards();
foreach (Card card in GetCardEnumerator())
{
if (card.faceValue == faceValue)
{
deckToReturn.CardDeck.Add(card);
}
}
return(deckToReturn);
}
public int IndexOf(Suit suit, FaceValue faceValue)
{
int ret = -1;
for (int i = 0; i < cards.Count; i++)
{
if (cards[i].CardSuit == suit && cards[i].CardValue == faceValue)
{
ret = i;
}
}
return(ret);
}
public bool Contains(Suit suitToFind, FaceValue valueToFind)
{
bool found = false;
Card aCard;
for (int i = 0; i < m_cards.Count; i++)
{
aCard = (Card)m_cards[i];
if ((aCard.Suit == suitToFind) && (aCard.FaceValue == valueToFind))
{
found = true;
}
}
return found;
}
public void CanRestrictPlayingCardCreationToExistingSuitsOnly(
int intSuit, FaceValue faceValue)
{
// arrange
var suit = (Suit)intSuit;
string expectedMessage =
"The value '" + suit + "' does not represent a valid suit." + NewLine
+ "Parameter name: suit" + NewLine
+ "Actual value was " + suit + ".";
// act
var exception = Record.Exception(
() => new PlayingCard(suit, faceValue));
// assert
var argOutOfRangeExc =
Assert.IsType<ArgumentOutOfRangeException>(exception);
Assert.Equal(suit, argOutOfRangeExc.ActualValue);
Assert.Equal("suit", argOutOfRangeExc.ParamName);
Assert.Equal(expectedMessage, argOutOfRangeExc.Message);
}
/// <summary>
/// Checks to see if the hand contains a card of a certain face value
/// </summary>
/// <param name="item"></param>
/// <returns></returns>
public bool ContainsCard(FaceValue item)
{
foreach (Card c in cards)
{
if (c.FaceVal == item)
{
return true;
}
}
return false;
}
public PokerCard(Suit suit, FaceValue faceValue)
{
Suit = suit;
FaceValue = faceValue;
FaceUp = false;
}
public Card(Suit newSuit, FaceValue newValue)
{
m_suit = newSuit;
m_faceValue = newValue;
}
public Card(Suit s, FaceValue f)
{
Suit = s;
FaceValue = f;
}
/// <summary>
/// Constructor for a new card. Assign the card a suit, face value, and if the card is facing up or down
/// </summary>
/// <param name="suit"></param>
/// <param name="faceVal"></param>
/// <param name="isCardUp"></param>
public Card(Suit suit, FaceValue faceVal, bool isCardUp)
{
this.suit = suit;
this.faceVal = faceVal;
this.isCardUp = isCardUp;
}
public Deck(Suit[] suits, FaceValue[] values)
{
this.MakeDeck(suits, values);
}
