public void Hand_AddCard_Test()
{
// Arrange
var hand = new Hand();
// Act & Assert
hand.AddCard(new Card(Rank.Ace, Suite.Club));
Assert.AreEqual(10, hand.SoftValue);
Assert.AreEqual(10, hand.TotalValue);
hand.AddCard(new Card(Rank.Two, Suite.Club));
Assert.AreEqual(12, hand.SoftValue);
Assert.AreEqual(12, hand.TotalValue);
hand.AddCard(new Card(Rank.Ace, Suite.Club));
Assert.AreEqual(22, hand.SoftValue);
Assert.AreEqual(13, hand.TotalValue);
hand.AddCard(new Card(Rank.Eight, Suite.Club));
Assert.AreEqual(30, hand.SoftValue);
Assert.AreEqual(21, hand.TotalValue);
hand.Clear();
Assert.AreEqual(0, hand.Cards.Count);
Assert.AreEqual(0, hand.SoftValue);
Assert.AreEqual(0, hand.TotalValue);
}
public void GetValue_ShouldReturnCorrectResult_ForTwoCards(Ranks rank1, Ranks rank2, int expectedValue, Hand hand, Suits suit)
{
hand.AddCard(rank1.Of(suit));
hand.AddCard(rank2.Of(suit));
Assert.Equal(expectedValue, hand.GetValue());
}
public void setup()
{
_validHand = new Hand();
_validHand.AddCard(new Card(Suit.Hearts, 10));
_validHand.AddCard(new Card(Suit.Hearts, 6));
_validHand.AddCard(new Card(Suit.Diamonds, 3));
_validHand.AddCard(new Card(Suit.Spades, 14));
_validHand.AddCard(new Card(Suit.Clubs, 2));
}
bool Check(Card[] cards)
{
Hand player1 = new Hand();
Hand player2 = new Hand();
for (int i = 0; i < 10; i++)
if (i < 5)
player1.AddCard(cards[i]);
else
player2.AddCard(cards[i]);
if (player1.Type != player2.Type)
return (int)player1.Type > (int)player2.Type;
if (player1.Type == HandType.RoyalFlush)
return true;
if (player1.Type == HandType.StraightFlush || player1.Type == HandType.Flush || player1.Type == HandType.Straight || player1.Type == HandType.Nothing)
{
if (player1.HighCard > player2.HighCard)
return true;
if (player1.HighCard == player2.HighCard)
return true;
return false;
}
if (player1.Type == HandType.ThreeOfAKind || player1.Type == HandType.OnePair)
{
if (player1.MaxCard > player2.MaxCard)
return true;
if (player1.MaxCard == player2.MaxCard)
{
if (player1.HighCard > player2.HighCard)
return true;
if (player1.HighCard == player2.HighCard)
return true;
return false;
}
return false;
}
if (player1.Type == HandType.FourOfAKind || player1.Type == HandType.FullHouse || player1.Type == HandType.TwoPair)
{
if (player1.MaxCard > player2.MaxCard)
return true;
if (player1.MaxCard == player2.MaxCard)
{
if (player1.SecondCard > player2.SecondCard)
return true;
if (player1.SecondCard == player2.SecondCard)
{
if (player1.HighCard > player2.HighCard)
return true;
if (player1.HighCard == player2.HighCard)
return true;
return false;
}
}
return false;
}
return false;
}
public void Cards_ShouldReturnCorrectResult(Hand hand, Card[] cards)
{
foreach (var card in cards)
{
hand.AddCard(card);
}
Assert.Equal(cards, hand.Cards);
}
public void InstantiateHand()
{
var h = new Hand(new Card("Ad"));
Assert.IsTrue(h.Contains(new Card('A', Suit.Diamond)));
Assert.IsFalse(h.Contains(new Card('K', Suit.Diamond)));
h.AddCard("Kd");
Assert.IsTrue(h.Contains(new Card('K', Suit.Diamond)));
Assert.Throws(typeof (ArgumentException), delegate { h.AddCard("Kd"); });
Assert.Throws(typeof(ArgumentException), delegate { h.AddCard(new Card("Ad")); });
List<Card> l = new List<Card>();
l.Add(new Card("Ad"));
h = new Hand(l);
l.Add(new Card("Ad"));
Assert.Throws(typeof(ArgumentException), delegate { h = new Hand(l); });
}
public void WhenCardsAreAddedToAHand_TheCalculateScoreMethodReturnsTheCorrectValue()
{
IHand hand = new Hand();
hand
.AddCard(new Number(3, CardColour.Blue))
.AddCard(new Reverse(CardColour.Green))
.AddCard(new Skip(CardColour.Red));
Assert.AreEqual(43, hand.Score);
}
public void GetValue_ShouldReturnCorrectResult_ForOneCard(Hand hand, Card card)
{
var expectedValue = BlackJack.CardValues[card.Rank];
if (card.Rank == Ace)
{
expectedValue += BlackJack.AceIncrement;
}
hand.AddCard(card);
Assert.Equal(expectedValue, hand.GetValue());
}
public void Hand_Should_Fire_OnChanged_Event()
{
// Arrange
var hand = new Hand();
var onChangedCalled = false;
// Act
hand.Changed += (object sender, EventArgs args) => onChangedCalled = true;
hand.AddCard(new Card(Rank.Ace, Suite.Club));
// Assert
Assert.IsTrue(onChangedCalled);
}
public void PlayCardTest()
{
var hand = new Hand(new Player("yes"));
var card = new Card(Rank.Ace, Suit.Clubs);
hand.AddCard(card);
var card2 = hand.PlayCard("3c");
Assert.Null(card2);
Assert.Equal(1, hand.CardCount);
var card3 = hand.PlayCard(card.ShortName);
Assert.NotNull(card3);
Assert.Equal(0, hand.CardCount);
}
public void Init()
{
Hand hand = new Hand();
Deck deck = new Deck();
cardIndexAceDiamond = Card.ToCardIndex(CardSuit.Diamonds, CardRank.Ace);
carIndexAceClubs = Card.ToCardIndex(CardSuit.Clubs, CardRank.Ace);
for (int i = 0; i < 13; i++)
{
hand.AddCard((int)deck.CardPile[i]);
}
pTest = new player(1, false);
pTest.Hand = hand;
}
public void Hand_FlushTest()
{
Hand hand = new Hand();
hand.AddCard(new Card(Engine.Infrastructure.Suit.Heart, Engine.Infrastructure.Face.Two));
hand.AddCard(new Card(Engine.Infrastructure.Suit.Heart, Engine.Infrastructure.Face.Four));
hand.AddCard(new Card(Engine.Infrastructure.Suit.Diamond, Engine.Infrastructure.Face.Six));
hand.AddCard(new Card(Engine.Infrastructure.Suit.Heart, Engine.Infrastructure.Face.Jack));
hand.AddCard(new Card(Engine.Infrastructure.Suit.Spade, Engine.Infrastructure.Face.Ace));
hand.AddCard(new Card(Engine.Infrastructure.Suit.Heart, Engine.Infrastructure.Face.Nine));
hand.AddCard(new Card(Engine.Infrastructure.Suit.Heart, Engine.Infrastructure.Face.King));
hand.EvaluateHand();
Assert.IsTrue(hand.PokerHandName == Engine.Infrastructure.PokerHands.Flush);
}
public static void NewRound()
{
_deck = new CardPile(fullDeck: true);
_deck.ShufflePile();
_playerHand = new Hand();
_dealerHand = new Hand();
foreach (Card card in _deck.DealCards(STARTING_HAND_SIZE))
{
_playerHand.AddCard(card);
}
foreach (Card card in _deck.DealCards(STARTING_HAND_SIZE))
{
_dealerHand.AddCard(card);
}
}
//draw the card on top of the player deck and remove it from the deck
public BasicCard DrawCard()
{
// Check if We Can!
//if (hand.Count() >= settings.MaxHandCapability /*+ player.HandOverflow*/)//important pour le player
// throw new HandIsFullException();
if (playerDeck.Count() == 0)
{
throw new DeckIsEmptyException();
}
else
{
// Take from the deck
BasicCard myNewCard = playerDeck.DrawCard();
hand.AddCard(myNewCard);
return(myNewCard);
}
}
private void btnAction_Click(object sender, EventArgs e)
{
if (btnAction.Text == "End Attack")
{
// Replenish hands
ReplenishHands(true);
// Clear the board
ClearBoard();
}
if (btnAction.Text == "Take Cards")
{
for (int i = 0; i < pnlPlayArea.Controls.Count; i++)
{
CardBox aCardBox = new CardBox(playerHand[i]);
playerHand.AddCard(theBoard[i]);
pnlPlayerHand.Controls.Add(aCardBox);
theBoard.Remove(aCardBox.Card);
playerHand.Remove(aCardBox.Card);
// Resize the CardBox
aCardBox.Size = cardSize;
// Add the control to the play panel
pnlPlayArea.Controls.Remove(aCardBox);
}
// Clear the board
ClearBoard();
}
// Add the removed event handlers back
foreach (CardBox cardBox in pnlPlayerHand.Controls)
{
cardBox.Click += CardBox_Click;
}
// Pass the turn
playerTurn = false;
AIAttacking = true;
AITurn();
}
/// <summary>
/// Sets up a game of Crazy Eights according to the normal rules.
/// </summary>
public static void StartGame()
{
// Sets up the initial state
_drawPile = new CardPile(true);
_drawPile.ShufflePile();
UserHand = new Hand();
ComputerHand = new Hand();
IsPlaying = true;
IsUserTurn = true;
// Deal each hand eight cards
for (int count = 1; count <= 8; count++)
{
UserHand.AddCard(_drawPile.DealOneCard());
ComputerHand.AddCard(_drawPile.DealOneCard());
}
// Get one card to discard pile
_discardPile = new CardPile();
_discardPile.AddCard(_drawPile.DealOneCard());
}
private static void HandTest_AddCard(IReadOnlyCollection <Card> cards, bool expectedIsBust, int expectedScore)
{
var hand = new Hand(0);
foreach (var card in cards)
{
hand.AddCard(card);
}
Assert.AreEqual(cards.Count, hand.Cards.Count);
foreach (var card in cards)
{
Assert.IsTrue(hand.Cards.Any(c => c.Id == card.Id));
}
Assert.AreEqual(expectedIsBust, hand.IsBust);
Assert.AreEqual(expectedScore, hand.Score);
}
public void next_action_busted_because_total_is_greater_than_21()
{
IPlayer dealer = new Dealer();
IHand playerHand = new Hand();
Card card0 = new Card(Suit.Spades, Rank.King);
playerHand.AddCard(card0);
Card card1 = new Card(Suit.Clubs, Rank.King);
Card card2 = new Card(Suit.Clubs, Rank.Seven);
Card card3 = new Card(Suit.Clubs, Rank.Five);
dealer.AddCardToHand(card1);
dealer.AddCardToHand(card2);
dealer.AddCardToHand(card3);
PlayerAction action = dealer.NextAction(playerHand);
Assert.AreEqual(PlayerAction.Busted, action);
}
public Hand DealHand(int number)
{
if (deck.Count == 0)
{
throw new ConstraintException("There are no cards left in the deck. Redeal.");
}
Hand hand = new Hand();
int countTo = deck.Count >= number ? number : deck.Count;
for (int handIndex = 0; handIndex < countTo; handIndex++)
{
hand.AddCard(deck[0]);
deck.RemoveAt(0);
}
return(hand);
}
public static void Hit(Player player)
{
if (_status == Status.In_Progress)
{
Card newCard = _deck.DealOneCard();
if (player == Player.Player)
{
_playerHand.AddCard(newCard);
if (GetScore(Player.Player) > 21)
{
return Status.
}
}
else if (player == Player.Dealer)
{
_dealerHand.AddCard(newCard);
}
}
}
public void TurnAllCardsFaceUp_TurnsAllCardsFaceUp()
{
BlackJackCard card = new BlackJackCard(Suit.Hearts, FaceValue.Ace);
card.TurnCard();
_aHand.AddCard(card);
_aHand.AddCard(new BlackJackCard(Suit.Clubs, FaceValue.Two));
_aHand.AddCard(new BlackJackCard(Suit.Clubs, FaceValue.Two));
_aHand.TurnAllCardsFaceUp();
foreach (BlackJackCard c in _aHand.Cards)
{
Assert.True(c.FaceUp);
}
}
public void CannotCompareHandIncompleteHand(
[Values(HighCard, Pair, TwoPairs, ThreeOfAKind, Straight, Flush, FullHouse, FourOfAKind, StraightFlush)] HandType handType)
{
Hand hand = new Hand();
Hand hand2 = new Hand();
foreach (Card card in exampleHands[handType])
{
hand.AddCard(card);
}
foreach (Card card in exampleHands[handType].Take(4))
{
hand2.AddCard(card);
}
Assert.AreEqual(handType, hand.HandType);
Assert.AreEqual(Incomplete, hand2.HandType);
Assert.Throws <HandException>(() => hand.CompareTo(hand2));
Assert.Throws <HandException>(() => hand2.CompareTo(hand));
}
void Reload()
{
if (m_reloadTimer <= 0)
{
m_discard.AddCards(m_hand.GetAllCards());
m_audioHandler.PlaySound("Draw");
m_reloadTimer = m_reloadTime;
m_reloadText.SetActive(true);
for (int i = 0; i < m_handSize; i++)
{
if (!m_deck.HasCards())
{
m_audioHandler.PlaySound("Shuffle");
m_deck.AddCards(m_discard.PopAllCards());
}
m_hand.AddCard(m_deck.PopRandomCard());
}
m_hand.selectedIndex = 0;
}
}
public void TestGetCountWithHandFilledViaAddCard()
{
List <Card> cards = new List <Card> {
new Card(Suit.Clubs, FaceValue.Ace),
new Card(Suit.Hearts, FaceValue.Six),
new Card(Suit.Diamonds, FaceValue.King),
new Card(Suit.Clubs, FaceValue.Four),
new Card(Suit.Spades, FaceValue.Four),
new Card(Suit.Hearts, FaceValue.Ten)
};
Hand hand = new Hand();
foreach (Card card in cards)
{
hand.AddCard(card);
}
Assert.AreEqual(6, hand.GetCount());
}
void Update()
{
switch (m_ePhase)
{
case phase.Start:
//Check the baord
m_ManaPool.NewTurn();
List <Minion> m = Board.Get().GetActivePlayersMinions();
for (int i = 0; i < m.Count; ++i)
{
if (m[i].GetAbility() == Minion.ability.Start)
{
m[i].ActivateAbility();
}
}
// need a sec Sleep right here
break;
case phase.Draw:
m_Hand.AddCard(m_Deck.Draw());
break;
case phase.Main:
//Check
break;
case phase.Cleanup:
//Check
break;
case phase.End:
break;
case phase.Waiting:
break;
}
}
private static void TestAddGetNumCard(Deck d, Hand h, int num)
{
Console.WriteLine("Check number of Cards in Hand");
Console.WriteLine("Expect: " + num.ToString());
Console.WriteLine("Result: " + h.NumCards.ToString());
Console.WriteLine();
Console.WriteLine("Add a card to the Hand from the Deck");
Card c = d.Deal();
h.AddCard(c);
Console.WriteLine("Check number of Cards in Hand");
Console.WriteLine("Expect: " + (num + 1).ToString());
Console.WriteLine("Result: " + h.NumCards.ToString());
Console.WriteLine();
Console.WriteLine("Get card just added to Hand");
Console.WriteLine("Expected: " + c.ToString());
Console.WriteLine("Result: " + h.GetCard(num).ToString());
Console.WriteLine();
}
public override void ReplaceCard(CardDeck deck)
{
List <int> cardsReplaced = new List <int>();
bool replacing = true;
int maxReplacable = Hand.MaxReplacable;
Console.WriteLine($"You are allowed to replace {maxReplacable} cards.");
while (replacing)
{
Console.Write("Enter the number (1-5) of a card to replace, or (D)one/(E)nter: ");
string toReplace = Console.ReadLine();
int index;
if (toReplace == "" || toReplace.ToUpper()[0] == 'D' || toReplace.ToUpper()[0] == 'E')
{
Console.WriteLine();
break;
}
else if (!int.TryParse(toReplace, out index) || !(index >= 1 && index <= 5))
{
Console.WriteLine("That is not a valid selection.");
continue;
}
else if (cardsReplaced.Contains(index))
{
Console.WriteLine("You have already replaced that card.");
continue;
}
cardsReplaced.Add(index);
index--;
Hand.RemoveCard(index);
Hand.AddCard(deck.Draw, index);
if (cardsReplaced.Count == maxReplacable)
{
replacing = false;
Console.WriteLine("Maximum cards reached!");
Console.WriteLine();
}
}
}
public Hand DealHand(DebugHands pDebugHand = 0, string pHand = null)
{
Hand tHand = new Hand();
switch (pDebugHand)
{
case DebugHands.NormalHandDeal:
for (int i = 0; i < 5; i++)
{
tHand.AddCard(DealCard());
}
break;
case DebugHands.CommaDelimitedHand:
tHand = GetHandFromHandString(pHand);
break;
default:
break;
}
return(tHand);
}
//------------------------------------------------------------------------------------
/// <summary>
/// Add a new card to the hand
/// </summary>
//------------------------------------------------------------------------------------
internal void AddCard(Card card)
{
_playerHand.AddCard(card);
var newCard = new CardModel(card);
Cards.Add(newCard);
switch (_playerHand.DealtCards.Count)
{
case 1: NotifyPropertyChanged(nameof(PocketCard1)); break;
case 2: NotifyPropertyChanged(nameof(PocketCard2)); break;
case 3: NotifyPropertyChanged(nameof(FlopCard1)); break;
case 4: NotifyPropertyChanged(nameof(FlopCard2)); break;
case 5: NotifyPropertyChanged(nameof(FlopCard3)); break;
case 6: NotifyPropertyChanged(nameof(TurnCard)); break;
case 7: NotifyPropertyChanged(nameof(RiverCard)); break;
}
}
private void btnHit_Click(object sender, EventArgs e)
{
try
{
Player.AddCard(aDeck.DrawOneCard());
ShowHand(Player);
lblPlayer.Text = Player.GetHandValue().ToString();
int PlayerHand = Convert.ToInt32(lblPlayer.Text);
//If player hand value is greater then 21 they bust.
if (Player.BustCheck(PlayerHand))
{
MessageBox.Show("You busted. House Wins!");
GameOver();
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, ex.GetType().ToString());
}
}
/// <summary>
/// Adds a card to the hand and increases the current score
/// </summary>
/// <param name="card">The card to be added</param>
public void AddCard(Card card)
{
hand.AddCard(card);
score += card.Value;
}
private void DealToHand(Hand hand)
{
var card = _deck.DealCard();
hand.AddCard(card);
}
public void NewHand_AddCardRangeAddNull_ThrowsArgumentNullException()
{
var hand = new Hand("9632-YUITR");
Assert.Throws <ArgumentNullException>(() => hand.AddCard(null));
}
public void AddCard_ShouldThrowException_IfCardIsNull(Hand hand)
{
Assert.Throws<ArgumentNullException>(() => hand.AddCard(null));
}
public void should_provide_a_card_when_adding_to_hand()
{
var hand = new Hand();
hand.AddCard(null);
}
public void ReceivedCards(Card fromLeft, Card fromRight)
{
_currentHand.AddCard(fromLeft);
_currentHand.AddCard(fromRight);
}
public void should_add_card_to_hand()
{
var hand = new Hand();
hand.AddCard(new Card(Suit.Spades, 14));
hand.Cards.Count.ShouldEqual(1);
}
/// <summary>
/// Deals a card to a hand with a specified visibilty
/// </summary>
/// <param name="hand"> The hand to deal to. </param>
/// <param name="visibility"> The visibilty of the card. </param>
/// <returns> Returns true if deal was successful, false if unsuccessful (no cards left in deck). </returns>
private bool dealCardToHand(Hand hand, Visibility visibility)
{
if (_deck.Cards.Count == 0)
{
return false;
}
Card card = _deck.Cards[0];
_deck.Cards.RemoveAt(0);
card.Visibility = visibility;
hand.AddCard(card);
return true;
}
bool Check(Card[] cards)
{
Hand player1 = new Hand();
Hand player2 = new Hand();
for (int i = 0; i < 10; i++)
{
if (i < 5)
{
player1.AddCard(cards[i]);
}
else
{
player2.AddCard(cards[i]);
}
}
if (player1.Type != player2.Type)
{
return((int)player1.Type > (int)player2.Type);
}
if (player1.Type == HandType.RoyalFlush)
{
return(true);
}
if (player1.Type == HandType.StraightFlush || player1.Type == HandType.Flush || player1.Type == HandType.Straight || player1.Type == HandType.Nothing)
{
if (player1.HighCard > player2.HighCard)
{
return(true);
}
if (player1.HighCard == player2.HighCard)
{
return(true);
}
return(false);
}
if (player1.Type == HandType.ThreeOfAKind || player1.Type == HandType.OnePair)
{
if (player1.MaxCard > player2.MaxCard)
{
return(true);
}
if (player1.MaxCard == player2.MaxCard)
{
if (player1.HighCard > player2.HighCard)
{
return(true);
}
if (player1.HighCard == player2.HighCard)
{
return(true);
}
return(false);
}
return(false);
}
if (player1.Type == HandType.FourOfAKind || player1.Type == HandType.FullHouse || player1.Type == HandType.TwoPair)
{
if (player1.MaxCard > player2.MaxCard)
{
return(true);
}
if (player1.MaxCard == player2.MaxCard)
{
if (player1.SecondCard > player2.SecondCard)
{
return(true);
}
if (player1.SecondCard == player2.SecondCard)
{
if (player1.HighCard > player2.HighCard)
{
return(true);
}
if (player1.HighCard == player2.HighCard)
{
return(true);
}
return(false);
}
}
return(false);
}
return(false);
}
public void AddCardToHand(CardData card, Hand hand)
{
cardList.Add(card);
hand.AddCard(cardList.Count - 1);
SetTotalCardsInDeck();
}
private Hand GenerateHandFromDescription(string handDescription)
{
var hand = new Hand();
var values = handDescription.Substring(0, 5);
var suits = handDescription.Substring(5, 5);
var valueMap = new Dictionary<string, string>()
{
{"A", "14"},
{"K", "13"},
{"Q", "12"},
{"J", "11"},
{"T", "10"}
};
for(var i = 0;i < 5;i++)
{
var suit = Enum.GetNames(typeof (Suit)).Single(n => n[0] == suits[i]);
var value = values[i].ToString();
if(valueMap.ContainsKey(value))
value = valueMap[value];
var card = new Card((Suit) Enum.Parse(typeof (Suit), suit), int.Parse(value));
hand.AddCard(card);
}
return hand;
}
private void DealToHand(Hand hand, Visibility visibility)
{
var card = _deck.DealCard();
card.Visibility = visibility;
hand.AddCard(card);
}
private void setupGame(bool newGame)
{
int nbrOfDecks = noOfDecks;
int nbrOfPlayers = noOfPlayers;
dealer = new Dealer("Dealer", 0);
dealer.DealerIsDone += dealer_DealerIsDone;
CardDeck = new Deck(nbrOfDecks);
DonePlayers = new bool[nbrOfPlayers];
Hand dealerHand = new Hand();
for (int i = 0; i < 5; i++)
{
dealerHand.AddCard(CardDeck);
}
dealer.hand = dealerHand;
for (int i = 0; i < nbrOfPlayers; i++)
{
Hand hand = new Hand();
for (int j = 0; j < 5; j++)
{
hand.AddCard(CardDeck);
}
String playerName = "";
if (newGame)
{
while (playerName.Equals(""))
{
playerName = Interaction.InputBox("Please submit a name for player " + (i + 1).ToString() + ".", "Player" + (i + 1).ToString() + " name", "Player " + (i + 1).ToString());
}
Players.Add(new Player(playerName, i + 1));
}
Players.ElementAt(i).hand = hand;
DonePlayers[i] = false;
}
playerNbrTextBlock.Text = nbrOfPlayers.ToString();
deckTextBlock.Text = nbrOfDecks.ToString();
playerCardImages = new Image[5];
dealerCardImages = new Image[5];
playerCardImages[0] = CardR1;
playerCardImages[1] = CardR2;
playerCardImages[2] = CardR3;
playerCardImages[3] = CardR4;
playerCardImages[4] = CardR5;
dealerCardImages[0] = CardL1;
dealerCardImages[1] = CardL2;
dealerCardImages[2] = CardL3;
dealerCardImages[3] = CardL4;
dealerCardImages[4] = CardL5;
gameState = GameState.PLAY;
DealerIsDone = false;
enableButtons();
firstRound();
}
public void should_not_fail_if_card_is_added_when_cards_a_null()
{
var hand = new Hand();
hand.Cards = null;
hand.AddCard(new Card(Suit.Spades, 14));
hand.Cards.Count.ShouldEqual(1);
}
private void Given_Cards(List <Card> cards)
{
cards.ForEach(n => _hand.AddCard(n));
}
static void Main(string[] args)
{
//playing flag
bool amPlaying = true;
//player list accessors
const int USER_PLAYER = 0;
const int COMP_PLAYER = 1;
//player cards
Card userCard = new Card();
Card compCard = new Card();
//String for information output
String outputInfo = "";
while (amPlaying)
{
Console.WriteLine("WAR Declared...Your opponent will be the computer...");
//Initialize Deck
Deck deck = new Deck();
//Create Hands
List <Hand> hands = new List <Hand>
{
new Hand(),
new Hand()
};
//Deal Hands
deck.Deal(hands);
Console.WriteLine("Hands dealt...");
while (hands[USER_PLAYER].HandCount() > 0 && hands[COMP_PLAYER].HandCount() > 0)
{
//Await user input to flip
Console.WriteLine("Hit any key to flip your card...");
//Await user flips their card
Console.ReadKey();
userCard = hands[USER_PLAYER].FlipCard();
//generate output
outputInfo = MapValueString(userCard);
if (outputInfo.CompareTo("Joker") != 0)
{
outputInfo += " of " + MapSuitString(userCard);
}
Console.WriteLine("");
Console.WriteLine("You have flipped a " + outputInfo);
//Computer flips
Console.WriteLine("Computer flipping...");
compCard = hands[COMP_PLAYER].FlipCard();
//generate output
outputInfo = MapValueString(compCard);
if (outputInfo.CompareTo("Joker") != 0)
{
outputInfo += " of " + MapSuitString(compCard);
}
Console.WriteLine("Computer has flipped a " + outputInfo);
//for storing war cards
Hand userWarCards = new Hand();
Hand compWarCards = new Hand();
userWarCards.AddCard(hands[USER_PLAYER].TakeCard());
compWarCards.AddCard(hands[COMP_PLAYER].TakeCard());
//Compare cards
int comp = userCard.CompareCards(compCard);
//if cards are equal
while (comp == 0)
{
Console.WriteLine("Uh oh - WAR");
int cardsToTransfer = 0;
//three cards from each
//////////////////////////////DO THIS
Console.WriteLine("Hit any key to go to war");
Console.ReadKey();
while (cardsToTransfer < 3 && hands[USER_PLAYER].HandCount() > cardsToTransfer + 1 && hands[COMP_PLAYER].HandCount() > cardsToTransfer + 1)
{
userWarCards.AddCard(hands[USER_PLAYER].TakeCard());
compWarCards.AddCard(hands[COMP_PLAYER].TakeCard());
cardsToTransfer++;
}
//flip fourth
userCard = hands[USER_PLAYER].FlipCard();
Console.WriteLine("");
//generate output
outputInfo = MapValueString(userCard);
if (outputInfo.CompareTo("Joker") != 0)
{
outputInfo += " of " + MapSuitString(userCard);
}
Console.WriteLine("");
Console.WriteLine("You have flipped a " + outputInfo);
//Computer flips
Console.WriteLine("Computer flipping...");
compCard = hands[COMP_PLAYER].FlipCard();
userWarCards.AddCard(hands[USER_PLAYER].TakeCard());
compWarCards.AddCard(hands[COMP_PLAYER].TakeCard());
//generate output
outputInfo = MapValueString(compCard);
if (outputInfo.CompareTo("Joker") != 0)
{
outputInfo += " of " + MapSuitString(compCard);
}
Console.WriteLine("Computer has flipped a " + outputInfo);
//back to compare cards
comp = userCard.CompareCards(compCard);
}
//if cards aren't equal
int handToCharge = 0;
int handToGive = 0;
if (comp > 0)
{
handToCharge = COMP_PLAYER;
handToGive = USER_PLAYER;
Console.WriteLine("You have won this hand");
}
else
{
handToCharge = USER_PLAYER;
handToGive = COMP_PLAYER;
Console.WriteLine("Computer has won this hand");
}
//Remove played cards from both hands
//Add cards to winning hand (bottom)
hands[handToGive].AddCards(userWarCards);
hands[handToGive].AddCards(compWarCards);
//DEBUG
Console.WriteLine("Your cards: " + hands[USER_PLAYER].HandCount());
Console.WriteLine("Computer's cards: " + hands[COMP_PLAYER].HandCount());
}
if (hands[USER_PLAYER].HandCount() > hands[COMP_PLAYER].HandCount())
{
Console.WriteLine("CONGRATULATIONS! You won the war; the spoils are yours");
}
else
{
Console.WriteLine("You did not win the war; the spoils are not yours");
}
Console.WriteLine("Continue playing (Hit Y or y for YES)?");
//Take input
String s = Console.ReadLine();
//Check input and update amPlaying
if (s != "y" || s != "Y")
{
amPlaying = false;
}
}
}
public void AddCard_EmptyHand_ResultsInHandWithOneCard()
{
_aHand.AddCard(new BlackJackCard(Suit.Hearts, FaceValue.Ace));
Assert.Equal(1, _aHand.NrOfCards);
}
private void Hit_Click(object sender, EventArgs e)
{
thisGame.SetInsuranceAvailaible(false);
InsuranceButton.Visible = false;
SplitButton.Visible = false;
if (thisGame.GetBet(currentPlayer) <= 0)
{
Output.Text = "Must bet to play!";
return;
}
Output.Text = "Player " + currentPlayer.ToString() + " choose to hit.";
Card hitCard = thisGame.GetDeck().GetCard();
Hand hand = thisGame.GetPlayerHand(currentPlayer);
Hand splitHand = thisGame.GetSplitHand(currentPlayer);
if (!thisGame.HasSplit(currentPlayer))
{
hand.AddCard(hitCard);
DisplayCards(true);
PlayerCount.Text = hand.GetTotal().ToString();
if (hand.HasBusted())
{
Output.Text = "Player " + currentPlayer.ToString() + " busted!";
this.Hit.Visible = false;
this.Stay.Visible = false;
Who_Won();
}
}
else if (!splitHandDone)
{
hand.AddCard(hitCard);
DisplayCards(true);
PlayerCount.Text = hand.GetTotal().ToString();
if (hand.HasBusted())
{
Output.Text = "Hand 1 busted!";
splitHandDone = true;
}
}
else
{
splitHand.AddCard(hitCard);
SplitCount.Text = splitHand.GetTotal().ToString();
DisplayCards(true);
if (splitHand.HasBusted())
{
Output.Text = "Hand 2 busted!";
this.Hit.Visible = false;
this.Stay.Visible = false;
if (hand.HasBusted())
{
Who_Won();
}
else
{
Computer_Turn();
}
}
}
}
public void Hit()
{
var card = Deal();
_hand.AddCard(card);
}
public void should_have_a_description_in_value_order()
{
var hand = new Hand();
hand.AddCard(new Card(Suit.Clubs, 3));
hand.AddCard(new Card(Suit.Spades, 5));
hand.AddCard(new Card(Suit.Diamonds, 14));
hand.AddCard(new Card(Suit.Clubs, 10));
hand.Description.ShouldEqual("3C 5S AD TC");
hand.ValuesThenSuitsDescription.ShouldEqual("35TACSCD");
}