/// <summary>
/// Hit
/// </summary>
/// <param name="HandNum">Player Hand num</param>
public static void Hit(int HandNum)
{
BlackjackHand playerHandNum = PlayerHands[HandNum];
/*
* // if the score is atlest 21
* if (playerHandNum.Score > 21 || playerHandNum.Score == 21) {
* // Is standing automaticaly True
* playerHandNum.IsStanding = true;
* } else {
* playerHandNum.IsStanding = false;
* }
*/
// draw one Card
playerHandNum.AddCard(_deck.DealOneCard());
if (playerHandNum.Score > 21 || playerHandNum.Score == 21)
{
// Is standing automaticaly True
playerHandNum.IsStanding = true;
}
else
{
playerHandNum.IsStanding = false;
}
}
/// <summary>
/// Instantiates all the games variables, used in the setup function. Sets hands, deck and discard
/// </summary>
private static void DealInitial()
{
List <Card> hand1 = deck.DealCards(8);
List <Card> hand2 = deck.DealCards(8);
discard.AddCard(deck.DealOneCard());
playerHand = new Hand(hand1);
compHand = new Hand(hand2);
SetLegalMove(discard.GetLastCardInPile());
}
/// <summary>
/// Initialise Tableau
/// </summary>
/// <param name="amountOfCards"></param>
/// <returns></returns>
//Sets a single table at the start of the game
private static CardPile TableauInitialise(int amountOfCards)
{
CardPile tableau = new CardPile();
for (int i = 0; i < amountOfCards; i++)
{
tableau.Add(drawPile.DealOneCard());
}
return(tableau);
}
//Deal Cards
public void DealCards()
{
const int CARDS_DEALT = 8;
for (int i = 0; i < CARDS_DEALT; i++)
{
playerHand.AddCard(drawPile.DealOneCard());
computerHand.AddCard(drawPile.DealOneCard());
}
}
/// <summary>
/// Attempts to draw a Card into the given Hand.
/// </summary>
/// <param name="hand">Hand</param>
/// <param name="opponentHand">Opponent's hand</param>
/// <returns>Returns an ActionResult based on the normal rules of the game.</returns>
private static ActionResult DrawCard(Hand hand, Hand opponentHand)
{
if (IsHandPlayable(hand) || hand.GetCount() >= FULL_HAND)
{
return(ActionResult.CannotDraw);
}
else if (!IsDrawPileEmpty)
{
hand.AddCard(_drawPile.DealOneCard());
if (IsCardPlayable(hand.GetCard(hand.GetCount() - 1)))
{
return(ActionResult.DrewPlayableCard);
}
else
{
if (hand.GetCount() >= FULL_HAND)
{
IsUserTurn = !IsUserTurn;
if (opponentHand.GetCount() >= FULL_HAND && !IsHandPlayable(opponentHand))
{
while (!IsHandPlayable(opponentHand))
{
while (_discardPile.GetCount() != 0)
{
_drawPile.AddCard(_discardPile.DealOneCard());
}
_drawPile.ShufflePile();
_discardPile.AddCard(_drawPile.DealOneCard());
}
return(ActionResult.DrewAndResetPiles);
}
else
{
return(ActionResult.DrewAndNoMovePossible);
}
}
else
{
return(ActionResult.DrewUnplayableCard);
}
}
}
else
{
while (_discardPile.GetCount() != 0)
{
_drawPile.AddCard(_discardPile.DealOneCard());
}
_discardPile.AddCard(_drawPile.DealOneCard());
return(ActionResult.FlippedDeck);
}
}
/// <summary>
/// Attempts to draw a Card into the given Hand.
/// </summary>
/// <param name="hand"></param>
/// <returns></returns>
private static ActionResult DrawCard(Hand hand)
{
Hand otherHand;
if (IsUserTurn)
{
otherHand = ComputerHand;
}
else
{
otherHand = UserHand;
}
if (IsHandPlayable(hand) == true)
{
return(ActionResult.CannotDraw);
}
else if ((IsDrawPileEmpty == true) && (IsHandPlayable(hand) == false))
{
foreach (Card card in _discardPile.DealCards(_discardPile.GetCount()))
{
_drawPile.AddCard(card);
}
_discardPile.AddCard(_drawPile.DealOneCard());
return(ActionResult.FlippedDeck);
}
hand.AddCard(_drawPile.DealOneCard());
if (hand.GetCount() == 13 && (IsHandPlayable(hand) == false))
{
if ((IsHandPlayable(hand) == false) && (hand.GetCount() == 13) && (IsHandPlayable(otherHand) == false) && otherHand.GetCount() == 13)
{
IsPlaying = true;
IsUserTurn = !IsUserTurn;
return(ActionResult.DrewAndResetPiles);
}
else
{
IsUserTurn = !IsUserTurn;
IsPlaying = true;
return(ActionResult.DrewAndNoMovePossible);
}
}
else if (IsHandPlayable(hand) == false)
{
return(ActionResult.DrewUnplayableCard);
}
return(ActionResult.DrewPlayableCard);
}
} // end PlayerHasMove
/// <summary>
/// Deals one card to specific hand
/// </summary>
/// <param name="who"></param>
/// <returns></returns>
public static Card DealOneCardTo(int who)
{
// check for empty draw pile
if (drawPile.GetCount() <= 0)
{
drawPile = discardPile;
DealOneCard();
}
drawPile.Shuffle();
Card card = drawPile.DealOneCard();
hands[who].Add(card);
return(card);
}//end DealOneCard
private static int[] tableCardsInPlay = new int[8]; //the amount if playable cards per table. index at 1 to allow index to match table number
//Game Setup
public static void SetUpGame()
{
drawPile = new CardPile(true);
discardPile = new CardPile();
suitPileOne = new CardPile();
suitPileTwo = new CardPile();
suitPileThree = new CardPile();
suitPileFour = new CardPile();
drawPile.Shuffle();
discardPile.Add(drawPile.DealOneCard());
tableau1 = TableauInitialise(1);
tableau2 = TableauInitialise(2);
tableau3 = TableauInitialise(3);
tableau4 = TableauInitialise(4);
tableau5 = TableauInitialise(5);
tableau6 = TableauInitialise(6);
tableau7 = TableauInitialise(7);
//sets up the cards in play array, with the index at 1
tableCardsInPlay[0] = 0;
for (int i = 1; i < tableCardsInPlay.Length; i++)
{
tableCardsInPlay[i] = 1;
}
}
}//end of SetUpGame
/// <summary>
/// Deals a card to a specific hand(dealer/player)
/// </summary>
/// <param name="who"></param>
/// <returns>Added card</returns>
public static Card DealOneCardTo(int who)
{
ReplacementCards(1);
Card deal = cardPile.DealOneCard();
hands[who].Add(deal);
return(deal);
}//end of DealOneCardTo
public static Card DealOneCardTo(int who)
{
Card a = cardpile.DealOneCard();
hand[who].Add(a);
CalculateHandTotal(who);
return(a);
}
/// <summary>
///
/// </summary>
/// <param name="who"></param>
/// <returns></returns>
public static Card DealOneCardTo(int who)
{
cardPile.Shuffle();
Card card = cardPile.DealOneCard();
hands[who].Add(card);
return(card);
}//end DealOneCard
// A randomiser for the cards, thus, knowing cards will be different (when dealing)
public static void PlayForDeal()
{
totalPoints[1] = 0;
CardPile cardPile = new CardPile(true);
cardPile.Shuffle();
hands[1].Add(cardPile.DealOneCard());
}
/// <summary>
/// Deals a card and adds it to the hand
/// </summary>
/// <param name="who">Which player</param>
/// <returns>The dealt card</returns>
public static Card DealOneCardTo(int who)
{
Card card = cardPile.DealOneCard();
hands[who].Add(card);
return(card);
}
/// <summary>
/// Draws a new card from the drawPile and adds it to the discardPile
/// </summary>
public static void DrawCard()
{
if (drawPile.GetCount() == 0)
{
ResetDrawPile();
}
discardPile.Add(drawPile.DealOneCard());
}
public static Card DealOneCardTo(int who)
{
Card card1 = new Card();
Card card2 = new Card();
if (who == 0)
{
card1 = cardPile.DealOneCard();
hands[0].Add(card1);
return(card1);
}
else
{
card2 = cardPile.DealOneCard();
hands[1].Add(card2);
return(card2);
}
}
/// <summary>
/// Deal a card to int who
/// </summary>
/// <param name="who"></param>
/// <returns></returns>
public static Card DealOneCardTo(int who)
{
Card dealtCard = cardPile.DealOneCard();
hands[who].Add(dealtCard);
totalPoints[who] = CalculateHandTotal(who);
return(dealtCard);
// Returns card
}
/// <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());
}
/// <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);
}
/// <summary>
/// a
/// </summary>
public static void StartGame()
{
_canplay = true;
IsUserTurn = true;
_drawPile = new CardPile(true);
_drawPile.ShufflePile();
_discardPile = new CardPile();
UserHand = new Hand(_drawPile.DealCards(8));
ComputerHand = new Hand(_drawPile.DealCards(8));
_discardPile.AddCard(_drawPile.DealOneCard());
}
//Method Draw_Card()
//Draws the cards from the cardPile.
public static bool Draw_Card()
{
if (drawPile.GetCount() == 0)
{
return(false);
}
else
{
discardPile.Add(drawPile.DealOneCard());
return(true);
}
}
public void TestDealOneCardAfterAddingCards()
{
CardPile pile = new CardPile();
pile.AddCard(new Card(Suit.Spades, FaceValue.Ace));
pile.AddCard(new Card(Suit.Clubs, FaceValue.Queen));
pile.AddCard(new Card(Suit.Clubs, FaceValue.Four));
Assert.IsTrue(
pile.DealOneCard().Equals(new Card(Suit.Spades, FaceValue.Ace))
);
}
/// <summary>
/// Sets up the solitare game from beginning
/// </summary>
public static void SetupGame()
{
deck = new CardPile(true);
deck.ShufflePile();
for (int i = 0; i < numOfHands; i++)
{
playRevealed[i] = i;
Hand temp = new Hand(deck.DealCards(i + 1));
playHands.Add(temp);
}
current.AddCard(deck.DealOneCard());
}
static int maxHandSize = 13; //maximum hand size
/// <summary>
/// Sets up the game from the starting point, 8 cards per player,
/// and a card added to the discard deck
/// </summary>
public static void SetupGame()
{
deck = new CardPile(true);
deck.ShufflePile();
discard = new CardPile();
discard.AddCard(deck.DealOneCard());
int startHand = 8;
playerHand = new Hand(deck.DealCards(startHand));
compHand = new Hand(deck.DealCards(startHand));
legalMove = discard.GetLastCardInPile();
}
//Reset the Draw Pile on Empty
public static CardPile ResetDrawPile(CardPile discardPile)
{
//declare new cardpile
CardPile drawPile = new CardPile();
//go through discardpile in reverse order adding the cards to drawPile
for (int i = 0; i < discardPile.GetCount(); i++)
{
drawPile.AddCard(discardPile.DealOneCard());
}
//return reversed pile for Draw Pile
return(drawPile);
}
}// End PlayForDealer
/// <summary>
/// Deals one card from the deck to the hand of "who" and returns that card
/// </summary>
/// <param name="who">int: index of dealer or player</param>
/// <returns>Card: c - the dealt card</returns>
public static Card DealOneCardTo(int who)
{
// Create a new deck and shuffle if it is empty
if (cardPile.GetCount() == 0)
{
cardPile = new CardPile(true);
cardPile.Shuffle();
}
// Deal one card and add it to the player's hand
Card c = cardPile.DealOneCard();
hands[who].Add(c);
return(c);
}// End DealOneCardTo
/// <summary>
/// make a new round
/// </summary>
/// <param name="initialBet"> The bet </param>
public static void NewRound(int initialBet)
{
// make a full deck and shuffle it
_deck = new CardPile(true);
_deck.ShufflePile();
// reduce the player fund
PlayerFunds -= initialBet;
DealerHand = new BlackjackHand();
// make a new player hand
PlayerHands = new List <BlackjackHand>();
PlayerHands.Add(new BlackjackHand(initialBet));
// deals 2 card to the player and the dealer
for (int i = 0; i < 2; i++)
{
PlayerHands[0].AddCard(_deck.DealOneCard());
DealerHand.AddCard(_deck.DealOneCard());
}
}
} // end SetUpGame
/// <summary>
/// Deals one card from cardPile to the hand of who and returns that card.
/// </summary>
/// <param name="who">The index of the person in the hands array to be dealt to</param>
/// <returns>Returns the card dealt</returns>
public static Card DealOneCardTo(int who)
{
Card card;
// Move this to method of its own
// Create new deck of cards if the pile is empty
if (cardPile.GetCount() == 0)
{
cardPile = new CardPile(true);
cardPile.Shuffle();
}
// Deal card to person
card = cardPile.DealOneCard();
hands[who].Add(card);
return(card);
} // end DealOneCardTo
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);
}
}
}
//Method SetUpGame()
//This method sets up the Solitaire game everytime initially.
public static void SetUpGame()
{
drawPile = new CardPile(true);
discardPile = new CardPile();
tableauPiles[0] = new Hand();
tableauPiles[1] = new Hand();
tableauPiles[2] = new Hand();
tableauPiles[3] = new Hand();
tableauPiles[4] = new Hand();
tableauPiles[5] = new Hand();
tableauPiles[6] = new Hand();
suitPiles[0] = new CardPile();
suitPiles[1] = new CardPile();
suitPiles[2] = new CardPile();
suitPiles[3] = new CardPile();
drawPile.Shuffle();
for (int i = 0; i < 7; i++)
{
for (int j = 0; j < i + 1; j++)
{
tableauPiles[i].Add(drawPile.DealOneCard());
}
}
}
/// <summary>
/// a
/// </summary>
/// <returns></returns>
public static ActionResult UserDrawCard()
{
if (IsPlaying == false)
{
throw new System.ArgumentException("This game is not start!");
}
if (IsUserTurn == false)
{
throw new System.ArgumentException("This is not your turn!");
}
if (TopDiscard.GetFaceValue() == FaceValue.Eight)
{
return(ActionResult.CannotDraw);
}
foreach (Card c in UserHand)
{
if (c.GetFaceValue() == TopDiscard.GetFaceValue() || c.GetSuit() == TopDiscard.GetSuit())
{
return(ActionResult.CannotDraw);
}
}
if (_drawPile.GetCount() == 0)
{
_discardPile.Reverse();
while (_discardPile.GetCount() > 1)
{
_drawPile.AddCard(_discardPile.DealOneCard());
}
return(ActionResult.FlippedDeck);
}
Card drawCard = _drawPile.DealOneCard();
UserHand.AddCard(drawCard);
if (drawCard.GetFaceValue() == TopDiscard.GetFaceValue() || drawCard.GetSuit() == TopDiscard.GetSuit())
{
return(ActionResult.DrewPlayableCard);
}
else
{
if (UserHand.GetCount() == 13)
{
IsUserTurn = false;
if (ComputerHand.GetCount() == 13)
{
return(ActionResult.DrewAndResetPiles);
}
else
{
return(ActionResult.DrewAndNoMovePossible);
}
}
else
{
return(ActionResult.DrewUnplayableCard);
}
}
}
