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); }