//Generates an entire tables worth of card graphics
private PictureBox[] UpdateTableau(CardPile table, int inPlay, int tableNum)
{
PictureBox cardImg;
PictureBox[] tableauImg = new PictureBox[table.GetCount()];
Card card;
//loops through each card
for (int i = 0; i < table.GetCount(); i++)
{
cardImg = new PictureBox();
cardImg.SizeMode = PictureBoxSizeMode.AutoSize;
cardImg.Dock = DockStyle.Fill;
card = table.GetCard(i);
//if Face up card
if (i >= (table.GetCount() - inPlay))
{
cardImg.Image = Images.GetCardImage(card);
tableauImg[i] = cardImg;
tableauImg[i].Click += new EventHandler(TableCard_Click);
tableauImg[i].Tag = card;
//else face down card
}
else
{
tableauImg[i] = cardImg;
tableauImg[i].Click += new EventHandler(CardFlip_Click);
tableauImg[i].Tag = tableNum;
cardImg.Image = Images.GetBackOfCardImage();
}
}
return(tableauImg);
}
} // end CheckTurnOver
/// <summary>
/// Finds correct table and adds all the cards in the stack to the table
/// </summary>
/// <param name="played"></param>
/// <param name="destination"></param>
private static void AddToTable(Card[] played, Card destination)
{
//
if ((tableau1.GetCount() != 0) && (tableau1.GetLastCardInPile() == destination))
{
for (int i = 0; i < played.Length; i++)
{
tableau1.Add(played[i]);
tableCardsInPlay[1]++;
}
}
else if ((tableau2.GetCount() != 0) && (tableau2.GetLastCardInPile() == destination))
{
for (int i = 0; i < played.Length; i++)
{
tableau2.Add(played[i]);
tableCardsInPlay[2]++;
}
}
else if ((tableau3.GetCount() != 0) && (tableau3.GetLastCardInPile() == destination))
{
for (int i = 0; i < played.Length; i++)
{
tableau3.Add(played[i]);
tableCardsInPlay[3]++;
}
}
else if ((tableau4.GetCount() != 0) && (tableau4.GetLastCardInPile() == destination))
{
for (int i = 0; i < played.Length; i++)
{
tableau4.Add(played[i]);
tableCardsInPlay[4]++;
}
}
else if ((tableau5.GetCount() != 0) && (tableau5.GetLastCardInPile() == destination))
{
for (int i = 0; i < played.Length; i++)
{
tableau5.Add(played[i]);
tableCardsInPlay[5]++;
}
}
else if ((tableau6.GetCount() != 0) && (tableau6.GetLastCardInPile() == destination))
{
for (int i = 0; i < played.Length; i++)
{
tableau6.Add(played[i]);
tableCardsInPlay[6]++;
}
}
else if ((tableau7.GetCount() != 0) && (tableau7.GetLastCardInPile() == destination))
{
for (int i = 0; i < played.Length; i++)
{
tableau7.Add(played[i]);
tableCardsInPlay[7]++;
}
}
}
/// <summary>
/// Swaps the deck and discard if the deck has run out of cards, then
/// places the last card from the discard pile back onto the discard deck
/// </summary>
public static void DeckDiscardSwap()
{
if (deck.GetCount() == 0)
{
deck = discard;
deck.RemoveLastCard();
Card card = discard.GetLastCardInPile();
discard = new CardPile();
discard.AddCard(card);
}
}
/// <summary>
/// Check if user have won the game base on the number of card in each suit pile
/// </summary>
/// <returns></returns>
public static bool HasWon()
{
if ((suitPileOne.GetCount() == CARDS_IN_SUIT) && (suitPileTwo.GetCount() == CARDS_IN_SUIT) && (suitPileThree.GetCount() == CARDS_IN_SUIT) && (suitPileFour.GetCount() == CARDS_IN_SUIT))
{
return(true);
}
else
{
return(false);
}
} // end HasWon
/// <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);
}
}
private void Displaydiscard()
{
CardPile dis = Solitaire_Game.get_discardPile();
if (dis.GetCount() > 0)
{
Discard_Pile_pictureBox1.Image = Games.Images.GetCardImage(dis.GetLastCardInPile());
}
else if (dis.GetCount() == 0)
{
Discard_Pile_pictureBox1.Image = null;
}
}
/// <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);
}
/// <summary>
/// Checks a given card and determines if it's a legal move
/// </summary>
/// <param name="card">Pre: Must be an instantiated Card</param>
/// <returns>Bool: Returns true if it is a legal move, false otherwise</returns>
public static bool CheckLegalMove(Card card)
{
int cardsAtInitial = 35; //if the face value is eight at the beginning of game, can play anything
int discardAtInitial = 1;
//This checks if it's the first turn of the game and it happens to be an 8 on the play, if so
//any move is possible
if (deck.GetCount() == cardsAtInitial)
{
if (discard.GetCount() == discardAtInitial)
{
if (discard.GetLastCardInPile().GetFaceValue() == FaceValue.Eight)
{
return(true);
}
}
}
if (card.GetFaceValue() == FaceValue.Eight)
{
return(true);
}
else if (card.GetSuit() == legalMove.GetSuit())
{
return(true);
}
else if (card.GetFaceValue() == legalMove.GetFaceValue())
{
return(true);
}
else
{
return(false);
}
}
}//end of ResetTotals
/// <summary>
/// Creates a new pile if there is not enough of needed cards.
/// Shuffles the newly created pile.
/// </summary>
/// <param name="needed">amount of cards needed in deck. </param>
private static void ReplacementCards(int needed)
{
if (cardPile.GetCount() < needed)
{
cardPile = new CardPile(true);
cardPile.Shuffle();
} //end of if statement.
} //end of Replacement Cards.
public static List <Card> FullDeckInOrder()
{
CardPile cardPile = new CardPile(true);
List <Card> allCards = cardPile.DealCards(cardPile.GetCount());
allCards.Reverse();
return(allCards);
}
public void TestGetCountWithEmptyCardPile()
{
CardPile pile = new CardPile();
Assert.AreEqual(0, pile.GetCount());
pile = new CardPile(false);
Assert.AreEqual(0, pile.GetCount());
}
//Check DrawPile for reset requirement
public void CheckDrawPile()
{
if (drawPile.GetCount() == 0)
{
drawPile = Crazy_Eight_Game.ResetDrawPile(discardPile);
discardPile = Crazy_Eight_Game.SetDiscardPile(drawPile);
UpdateTopCardImage();
}
}
public void TestGetCountCorrectAfterAddingCards()
{
CardPile pile = new CardPile();
pile.AddCard(new Card(Suit.Hearts, FaceValue.Seven));
pile.AddCard(new Card(Suit.Hearts, FaceValue.Nine));
pile.AddCard(new Card(Suit.Diamonds, FaceValue.Jack));
Assert.AreEqual(3, pile.GetCount());
}
/// <summary>
/// Failsafe incase cardPile runs out of cards.
/// </summary>
private static void ensurePlayableCardPile()
{
const int MINIMUM_AMOUNT_OF_CARDS_REQUIRED = 2;
int cardPileCount = cardPile.GetCount();
if (cardPileCount < MINIMUM_AMOUNT_OF_CARDS_REQUIRED)
{
cardPile = new CardPile(true);
}
}
//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);
}
}
static void Main()
{
Hand computerHand = new Hand(new List <Card> {
new Card(Suit.Diamonds, FaceValue.Three)
});
Hand userHand = new Hand(new List <Card> {
new Card(Suit.Clubs, FaceValue.Two),
new Card(Suit.Diamonds, FaceValue.Four)
});
List <Card> discardCards = Utility.FullDeckInOrder();
Utility.RemoveHand(discardCards, userHand);
Utility.RemoveHand(discardCards, computerHand);
discardCards.Remove(new Card(Suit.Hearts, FaceValue.Nine));
discardCards.Add(new Card(Suit.Hearts, FaceValue.Nine));
discardCards.Reverse();
discardCards.Remove(new Card(Suit.Clubs, FaceValue.Ace));
discardCards.Add(new Card(Suit.Clubs, FaceValue.Ace));
CardPile discardPile = Utility.CreateCardPile(discardCards);
CardPile drawPile = new CardPile(false);
int originalNumCardsComputer = computerHand.GetCount();
int originalNumCardsDiscardPile = discardPile.GetCount();
CrazyEights.StartGame(
userHand: userHand,
computerHand: computerHand,
discardPile: discardPile,
drawPile: drawPile
);
CrazyEights.UserPlayCard(0);
Console.WriteLine(CrazyEights.ComputerAction());
/*
* Assert.AreEqual(
* CrazyEights.ActionResult.FlippedDeck,
* CrazyEights.ComputerAction()
* );
*
* Assert.IsTrue(CrazyEights.TopDiscard.Equals(new Card(Suit.Hearts, FaceValue.Nine)));
* Assert.AreEqual(originalNumCardsComputer, computerHand.GetCount());
* Assert.AreEqual(originalNumCardsDiscardPile, drawPile.GetCount());
* Assert.AreEqual(1, discardPile.GetCount());
* Assert.IsTrue(CrazyEights.IsPlaying);
* Assert.IsFalse(CrazyEights.IsUserTurn);
*/
ExitProgram();
}
//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 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
// Class methods
/// <summary>
/// Initializes the class variables at start of a new game.
/// </summary>
public static void SetUpGame()
{
totalPoints = new int[] { 0, 0 };
numOfUserAcesWithValueOne = 0;
//Move this to a method of its own
// Create new deck of cards if the pile is empty
if (cardPile.GetCount() < (NUM_OF_PLAYERS * INITIAL_HAND_SIZE))
{
cardPile = new CardPile(true);
cardPile.Shuffle();
}
// Shuffle cards
cardPile.Shuffle();
// Deal intital hand for player and dealer
Hand playerHand = new Hand(cardPile.DealCards(INITIAL_HAND_SIZE));
Hand dealerHand = new Hand(cardPile.DealCards(INITIAL_HAND_SIZE));
// Store dealt cards in hands arrays
hands[PLAYER] = playerHand;
hands[DEALER] = dealerHand;
} // end SetUpGame
}// 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>
/// Not implement yet!
/// Remove a full block of card in the correct order from the table
/// </summary>
/// <param name="stack"></param>
/// <param name="table"></param>
private static void CleanBlock(Card[] stack, int table)
{
//tempoary table variable, inplay variable and while loop control initiziation
CardPile tempTable = GetTable(table);
int tempInPlay = GetTableCardsInPlay(table);
bool allRemoved = false;
while (!allRemoved)
{
//loop each card in the stack and remove it from the table
for (int i = 0; i < stack.Length; i++)
{
for (int j = 0; j < GetTableCount(table); j++)
{
if (tempTable.GetCard(j) == stack[i])
{
tempTable.RemoveCard(j);
tempInPlay--;
break;
}
}
}
//check if all the cards have been removed from the table
int count = 0;
for (int i = 0; i < tempTable.GetCount(); i++)
{
for (int j = 0; j < stack.Length; j++)
{
if (tempTable.GetCard(i) == stack[j])
{
count++;
}
}
}
if (count > 0)
{
//reset the temporary table and repeat process
tempTable = GetTable(table);
tempInPlay = GetTableCardsInPlay(table);
}
else
{
//else kill loop
allRemoved = true;
}
}
SetNewTable(tempTable, table, tempInPlay);
} //end CleanBlock
} // end MoveBlock
/// <summary>
/// Get the card form a tableau
/// </summary>
/// <param name="played">the location of the card need to get</param>
/// <param name="table"> the table where the card located</param>
/// <param name="tableNum">Table number of the card</param>
/// <returns></returns>
private static Card[] GetCards(Card played, CardPile table, int tableNum)
{
//initialize stack to hold the grabed cards and counter varible max
Card[] stack = new Card[1];
int max = 0;
for (int i = 0; i < GetTableCount(tableNum); i++)
{
if (table.GetCard((GetTableCount(tableNum) - 1) - i) == played)
{
max = i;
stack = new Card[max + 1];
break;
}
}
//Grab them from the last card up to the clicked card for redisplaying purposes
for (int j = max; j > -1; j--)
{
stack[max - j] = table.GetCard((table.GetCount() - 1) - j);
}
return(stack);
}
//Method DistoSuit(num).
//This method moves the Ace card from the Discard pile to the Suit Piles.
public static bool DisToSuit(int num)
{
num--;
// if discard not null
if (discardPile.GetCount() == 0)
{
return(false);
}
//if ace
if (checkvalue(discardPile.GetLastCardInPile()) == 1 &&
suitPiles[num].GetCount() == 0
)
{
suitPiles[num].Add(discardPile.DealLastOneCard());
return(true);
}
//if not ace
else
{
// if suit is null
if (suitPiles[num].GetCount() == 0)
{
return(false);
}
//if facevalue is the same and value difference is 1
if (Check_Position(suitPiles[num].GetLastCardInPile(), discardPile.GetLastCardInPile()) &&
suitPiles[num].GetLastCardInPile().GetSuit().Equals(discardPile.GetLastCardInPile().GetSuit())
)
{
suitPiles[num].Add(discardPile.DealLastOneCard());
return(true);
}
return(false);
}
}
/// <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);
}
}
}
public void TestShufflePile()
{
List <Card> cardOrder = new List <Card>()
{
new Card(Suit.Clubs, FaceValue.Ace),
new Card(Suit.Clubs, FaceValue.Two),
new Card(Suit.Clubs, FaceValue.Three),
new Card(Suit.Clubs, FaceValue.Four),
new Card(Suit.Clubs, FaceValue.Five),
new Card(Suit.Clubs, FaceValue.Six),
new Card(Suit.Clubs, FaceValue.Seven),
new Card(Suit.Clubs, FaceValue.Eight),
new Card(Suit.Clubs, FaceValue.Nine),
new Card(Suit.Clubs, FaceValue.Ten),
new Card(Suit.Clubs, FaceValue.Jack),
new Card(Suit.Clubs, FaceValue.Queen),
new Card(Suit.Clubs, FaceValue.King),
new Card(Suit.Diamonds, FaceValue.Ace),
new Card(Suit.Diamonds, FaceValue.Two),
new Card(Suit.Diamonds, FaceValue.Three),
new Card(Suit.Diamonds, FaceValue.Four),
new Card(Suit.Diamonds, FaceValue.Five),
new Card(Suit.Diamonds, FaceValue.Six),
new Card(Suit.Diamonds, FaceValue.Seven),
new Card(Suit.Diamonds, FaceValue.Eight),
new Card(Suit.Diamonds, FaceValue.Nine),
new Card(Suit.Diamonds, FaceValue.Ten),
new Card(Suit.Diamonds, FaceValue.Jack),
new Card(Suit.Diamonds, FaceValue.Queen),
new Card(Suit.Diamonds, FaceValue.King),
new Card(Suit.Hearts, FaceValue.Ace),
new Card(Suit.Hearts, FaceValue.Two),
new Card(Suit.Hearts, FaceValue.Three),
new Card(Suit.Hearts, FaceValue.Four),
new Card(Suit.Hearts, FaceValue.Five),
new Card(Suit.Hearts, FaceValue.Six),
new Card(Suit.Hearts, FaceValue.Seven),
new Card(Suit.Hearts, FaceValue.Eight),
new Card(Suit.Hearts, FaceValue.Nine),
new Card(Suit.Hearts, FaceValue.Ten),
new Card(Suit.Hearts, FaceValue.Jack),
new Card(Suit.Hearts, FaceValue.Queen),
new Card(Suit.Hearts, FaceValue.King),
new Card(Suit.Spades, FaceValue.Ace),
new Card(Suit.Spades, FaceValue.Two),
new Card(Suit.Spades, FaceValue.Three),
new Card(Suit.Spades, FaceValue.Four),
new Card(Suit.Spades, FaceValue.Five),
new Card(Suit.Spades, FaceValue.Six),
new Card(Suit.Spades, FaceValue.Seven),
new Card(Suit.Spades, FaceValue.Eight),
new Card(Suit.Spades, FaceValue.Nine),
new Card(Suit.Spades, FaceValue.Ten),
new Card(Suit.Spades, FaceValue.Jack),
new Card(Suit.Spades, FaceValue.Queen),
new Card(Suit.Spades, FaceValue.King)
};
CardPile pile = new CardPile(true);
pile.ShufflePile();
for (int i = 0; i < pile.GetCount(); i++)
{
if (!pile.DealOneCard().Equals(cardOrder[i]))
{
return;
}
}
// If ShufflePile is correct, there is still a 1/52! (factorial) chance
// that failure will occur.
// The chance of this happening is less than the chance of randomly
// selecting a particular atom on Earth.
Assert.Fail();
}
public void TestGetCountWithFullCardPile()
{
CardPile pile = new CardPile(true);
Assert.AreEqual(52, pile.GetCount());
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static int GetDrawPileCount()
{
return(drawPile.GetCount());
}
/// <summary>
/// Fill the Draw Pile with Cards
/// </summary>
private static void FillCardPile()
{
cardPileCards = cardPile.DealCards(cardPile.GetCount());
drawPile = new Hand(cardPileCards);
}
/// <summary>
/// Returns number of cards in the discardPile
/// </summary>
/// <returns>Returns number of cards in the discardPile</returns>
public static int GetNumDiscardCards()
{
return(discardPile.GetCount());
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static int GetDiscardCount()
{
return(discardPile.GetCount());
}
