public void Draw_ShouldThrowException_IfDeckIsEmpty()
{
var deck = new Deck<StandartCard>(OpositeOrderShufflerMock().Object, new[] { new StandartCard(Suit.Clubs, Rank.Ace) });
deck.Draw();
var act = new Action(() => deck.Draw());
act.ShouldThrow<InvalidOperationException>();
}
public void Draw_ShouldDrawCardSuccessfully()
{
var cards = RandomStandartCards();
var deck = new Deck<StandartCard>(OpositeOrderShufflerMock().Object, cards);
deck.Draw().Should().Be(cards[0]);
deck.Draw().Should().Be(cards[1]);
deck.Draw().Should().Be(cards[2]);
deck.Draw().Should().Be(cards[3]);
}
public void DrawTwoCards()
{
// destroy sprites of previous hand
DiscardHand();
handText1.text = handText2.text = winnerText.text = "";
if (deck.GetCurrentCardCount() > 0)
{
// animate discard
if (hand.Count > 0)
{
GameObject faceDown1 = Instantiate(cardBack3);
GameObject faceDown2 = Instantiate(cardBack3);
discards.Add(faceDown1);
discards.Add(faceDown2);
StartCoroutine(TranslateCard(faceDown1, new Vector3(-3.0f, -1.5f), new Vector3(-5.0f, 3.2f)));
StartCoroutine(TranslateCard(faceDown2, new Vector3(3.0f, -1.5f), new Vector3(-5.0f, 3.2f)));
}
// draw twice for new hand
hand = new List <Card>();
hand.Add(deck.Draw());
hand.Add(deck.Draw());
PlaySound("Draw");
// animate card draw
GameObject card1 = Instantiate(cardBack3);
GameObject card2 = Instantiate(cardBack3);
StartCoroutine(TranslateCard(card1, card1.transform.position, new Vector3(-3.0f, -1.5f)));
StartCoroutine(TranslateCard(card2, card2.transform.position, new Vector3(3.0f, -1.5f)));
// reveal cards and update deck sprites
StartCoroutine(RevealCardDraw(1.0f, card1, card2));
DownsizeDeck();
}
else
{
// destroy discard pile
ClearDiscards();
// notify refresh
winnerText.text = "Shuffling deck . . .";
// refresh deck
for (int i = 0; i < cardBacks.Length; i++)
{
cardBacks[i].SetActive(true);
}
PlaySound("Shuffle");
Start();
}
}
static void Main(string[] args)
{
//Create a deck of cards
var deck = new Deck(52);
//start a counter as we build the deck
int counter = 0;
//loop through the face values
for (int i = 2; i <= 14; i++)
{
//loop through the suits
for (int j = 0; j <= 4; j++)
{
//set the face values
string faceValue;
if (i < 11) faceValue = i.ToString();
else if (i == 11) faceValue = "Jack";
else if (i == 12) faceValue = "Queen";
else if (i == 13) faceValue = "King";
else faceValue = "Ace";
//set the suit values
string suit;
if (j == 1) suit = "Hearts";
else if (j == 2) suit = "Diamonds";
else if (j == 3) suit = "Spades";
else suit = "Clubs";
deck.Cards[counter] = new Card
{
FaceValue = faceValue,
Suit = suit,
};
counter++;
}
//draw a card
var card = deck.Draw();
//draw rando 2
var card2 = deck.Draw();
//show the value
Console.WriteLine(card.GetFullName());
Console.ReadLine();
}
}
//public Deck deck = new Deck();
//public Deck fold = new Deck();
//private int[] Player1Position = new int[2] { 0, 0 };
//private int[] Player2Position = new int[2] { 0, 0 };
void Start()
{
label = type + order;
m = manager.GetComponent <Stage1_Manager>();
sr = this.transform.GetChild(0).GetComponent <SpriteRenderer>();
aggr = new Card();
pass = new Card();
deck = new Deck(card_id);
deck.Shuffle();
hand[0] = deck.Draw();
hand[1] = deck.Draw();
hand[2] = deck.Draw();
}
public void Decide()
{
if (this.CountPoints(CroupierCards) <= 15)
{
var card = carddeck.Draw();
CroupierCards.Add(card);
Console.WriteLine($"Krupier dobiera {card.Number}");
}
else
{
Console.WriteLine("Krupier nie dobiera");
}
}
// Use this for initialization
void Start()
{
gm = this;
GameDeck = GameObject.Find("Deck").GetComponent <Deck>();
DiscardPile = GameObject.Find("Discard").GetComponent <Discard>();
Log = GameObject.Find("GameLog").GetComponent <GameLog>();
Players = new GameObject[PlayerCount];
Players[0] = GameObject.Find("PlayerObject");
Players[0].GetComponent <Controller>().Order = 0;
Players[0].GetComponent <Controller>().Name = pname;
PlayerIndex = 0;
for (int i = 1; i < PlayerCount; i++)
{
Players[i] = Instantiate(COM);
Players[i].transform.SetParent(gameObject.transform);
Players[i].GetComponent <Controller>().Order = i;
Players[i].GetComponent <Controller>().Name = "COM " + i;
if (ShowAllHands)
{
Players[i].transform.localRotation = Quaternion.Euler(180, 0, 0);
Players[i].transform.FindChild("Name").localRotation = Quaternion.Euler(Vector3.zero);
}
}
foreach (Card c in GameDeck.Cards)
{
c.InstantiateObject();
}
for (int i = 0; i < 7; i++) // distribute cards
{
foreach (GameObject player in Players)
{
Controller pc = player.GetComponent <Controller>();
if (pc.Hand == null)
{
pc.Hand = new List <Card>();
}
Card c = GameDeck.Draw();
player.GetComponent <Controller>().AddCard(c);
}
}
Turn = (int)System.Math.Floor(Random.Range(0, 3.9f));
Log.LogTurn(Players[Turn].GetComponent <Controller>());
Clockwise = false;
DiscardPile.DiscardCard(GameDeck.Draw());
if (ColorInPlay == Card.Colors.Wild)
{
ColorInPlay = Players[Turn].GetComponent <Controller>().ChooseColor();
}
CurrentState = States.Wait;
}
public void DrawShouldGiveACardFromTheDeck()
{
var initialDeck = _deck.Cards.ToList();
var drawnCard = _deck.Draw();
Assert.IsTrue(initialDeck.Contains(drawnCard));
}
public void Deck_DiscardListOfCard_CardsDiscardedCorrectly()
{
// Arrange
Deck unitUnderTest = new Deck();
List <Card> cards = new List <Card> {
unitUnderTest.Draw(), unitUnderTest.Draw(), unitUnderTest.Draw()
};
// Act
unitUnderTest.Discard(cards);
// Assert
cards.ForEach(card => Assert.IsFalse(unitUnderTest.Cards.Contains(card)));
cards.ForEach(card => Assert.IsTrue(unitUnderTest.DiscardedCards.Contains(card)));
}
private void NewGame()
{
// create new deck
deck = new Deck();
discard = new Stack <Card>();
// create players
cpuPics = new List <PictureBox>();
playerPics = new List <PictureBox>();
cpu = new Player(deck, deck.Draw(5), cpuPics);
player = new Player(deck, deck.Draw(5), playerPics);
playerTurn = PlayerType.PLAYER;
Discard(deck.Draw(1)[0]);
}
private static void TestGame()
{
Deck d = new Deck();
Player p = new Player("Robot1", "Robot1");
Player q = new Player("Robot2", "Robot2");
p.SetPocket(d.Draw(), d.Draw());
q.SetPocket(d.Draw(), d.Draw());
Card[] community = { d.Draw(), d.Draw(), d.Draw(), d.Draw(), d.Draw() };
Console.WriteLine(p.FindBestHand(SerializeCommunity(community)).Description);
Console.WriteLine(q.FindBestHand(SerializeCommunity(community)).Description);
}
public static Game InProgress(int numberOfPlayers = 2)
{
var game = new Game
{
Status = GameStatus.InProgress
};
var deck = new Deck(game);
deck.New();
game.Deck = deck;
var players = new List <Player>();
for (var i = 1; i <= numberOfPlayers; i++)
{
players.Add(PlayerFactory.New(i));
}
var hands = players.Select(t => HandFactory.New(deck.DealHand(), t)).ToList();
var discard = new Stack <Card>();
discard.Push(deck.Draw());
game.CurrentColor = discard.Peek().Color;
game.CurrentValue = discard.Peek().Value;
game.Discard = discard;
game.Hands = hands;
game.Players = players;
return(game);
}
public void DrawCard()
{
Card newCard = _drawDeck.Draw(DeckPosition.Top);
if (newCard != null)
{
Debug.Log("Player: Drew card: " + newCard.Name);
_playerHand.Add(newCard, DeckPosition.Top);
_currentCardIndex = _playerHand.Count - 1;
StartCoroutine(DrawCardTween(newCard, 0.25f));
AudioHelper.PlayClip2D(_drawAudio, 1f);
_canDraw = false;
}
else
{
Debug.Log("Player: Shuffling discard into deck...");
_drawDeck.Add(_discardDeck.Cards);
StartCoroutine(ReshuffleTween(_discardDeck.TopItem, 0.25f));
AudioHelper.PlayClip2D(_shuffleAudio, 1f);
_drawDeck.Shuffle();
_discardDeck.Clear();
_canDraw = true;
}
CheckPassPlayState();
UpdateHandSize();
}
public static bool Players1WinsRecursive(Deck player1, Deck player2)
{
var states = new HashSet <string>();
while (player1.HasAny && player2.HasAny)
{
if (!states.Add($"{player1}&{player2}"))
{
return(true);
}
var card1 = player1.Draw();
var card2 = player2.Draw();
var p1Wins = player1.Count >= card1 && player2.Count >= card2
? Players1WinsRecursive(player1.Copy(card1), player2.Copy(card2))
: card1 > card2;
if (p1Wins)
{
player1.Add(card1, card2);
}
else
{
player2.Add(card2, card1);
}
}
return(player2.Count == 0);
}
public void Init()
{
Entity.Create(new Transform2(new Size2(1920, 1080)))
.Add(new Sprite("Images/Table/casino-felt"));
var deckData = DeckData.LoadFromDir("Content/Decks/Poker");
var cards = new Items(deckData.GetAllCards().Select(x => Create(new Card(x))));
var deck = new Deck(cards);
Entity.Create(new Transform2(new Vector2(200, 200), Sizes.Card))
.Add(cards)
.Add(deck.Sprite)
.Add(new ZGravity())
.Add(x => new MouseDropTarget {
OnDrop = o => deck.PutFacedownOnTop(o)
})
.Add(x => new MouseStateActions
{
OnPressed = () => deck.If(deck.Count > 0, () =>
{
var drawnCard = deck.Draw();
drawnCard.Transform.Location = x.Transform.Location;
})
});
}
public void FillHand()
{
for (filledSlots = 0; filledSlots < handSize; filledSlots++)
{
cardHand.Add(deckMang.Draw(isAttacking));
}
redInHand = 0;
blueInHand = 0;
greenInHand = 0;
foreach (Card card in cardHand)
{
if (card.type == Card.eCardType.Bomb || card.type == Card.eCardType.Boost)
{
redInHand++;
}
if (card.type == Card.eCardType.Charge || card.type == Card.eCardType.Uturn)
{
blueInHand++;
}
if (card.type == Card.eCardType.Laser || card.type == Card.eCardType.Spin)
{
greenInHand++;
}
}
slotOne = cardHand[0];
slotTwo = cardHand[1];
slotThree = cardHand[2];
slotOneButton.image.sprite = cardHand[0].cardArt;
slotTwoButton.image.sprite = cardHand[1].cardArt;
slotThreeButton.image.sprite = cardHand[2].cardArt;
}
public void Deck_Draw()
{
var drawnCard = testDeck.Draw();
Assert.AreEqual(testCard, drawnCard);
Assert.AreEqual(2, testDeck.Cards.Count());
}
public bool Draw(CardListFilter filter, int?numToChoose = null)
{
var drawnCard = Deck.Draw(filter, out bool failedFilter, numToChoose);
if (!failedFilter)
{
if (numToChoose == null)
{
if (drawnCard != null)
{
AddToHand(drawnCard);
}
else
{
Debug.Log("Deck is empty");
}
}
return(true);
}
else
{
Debug.Log("Given filter cannot draw any cards from the deck");
return(false);
}
}
private void TestDeck()
{
deck = new Deck(eDeckType.std54Card);
int i = 0;
while (deck.cardsRemains > 0)
{
Card card = deck.Draw();
Debug.Log(++i + " " + card);
}
/*Debug.Log("card remains : " + deck.cardsRemains);
* PrintCard(deck.Draw());
* Debug.Log("card remains : " + deck.cardsRemains);
* PrintCard(deck.Draw());
* Debug.Log("card remains : " + deck.cardsRemains);
* PrintCard(deck.Draw());
* card = deck.Draw();
* PrintCard(card);
* Debug.Log("card remains : " + deck.cardsRemains);
* Debug.Log("card in discard : " + deck.cardsInDiscards);
* deck.Discard(card);
* Debug.Log("card in discard : " + deck.cardsInDiscards);
* deck.Burn();
* Debug.Log("card in discard : " + deck.cardsInDiscards);*/
}
public void StartGame(int playerCount)
{
//Debug.Log("Start game");
deck = new Deck();
deck.Shuffle();
graveyard = new List <Card>();
/*playerHands = new List<List<Card>>();
* for (int i = 0; i < playerCount; i++)
* {
* playerHands.Add(deck.Draw(initialDrawAmount));
* }*/
playerOrder = new List <Player>();
trump = deck.Draw(1)[0];
originalTurn = 0;
defender = 1;
deck.AddToBottom(trump);
if (!isServer)
{
trump = null;
deck = null;
}
durak = -1;
field = new List <FieldPair>();
winners = new List <Player>();
selected = new List <Card>();
defendCards = new List <FieldPair>();
myTurn = 0;
gameEnded = false;
inGame = true;
//defendField = new List<Card>();
}
public void draw()
{
int idx = int.MaxValue;
bool found = false;
for (int i = 0; i < hand.Length; i++)
{
if (hand[i] == null)
{
idx = i;
found = true;
break;
}
}
if (!found)
{
return;
}
var card = deck.Draw();
hand[idx] = card;
card.setupUICard(cardPrototype, uiHand, this);
Log("Player " + Name + " draws " + card.cardName);
}
public void Draw(int numToDraw, CardListFilter filter)
{
var drawnCards = Deck.Draw(numToDraw, filter, out int failedDraws, out bool failedFilter);
if (!failedFilter)
{
if (drawnCards.Count != 0)
{
foreach (var drawnCard in drawnCards)
{
AddToHand(drawnCard);
}
if (failedDraws > 0)
{
Debug.Log($"Failed to draw {failedDraws} from the deck as there were not enough cards remaining");
}
}
else
{
Debug.Log("Deck is empty");
}
}
else
{
Debug.Log("Given filter cannot draw any cards from the deck");
}
}
public void DealPlayerHand(Player p)
{
foreach (var i in Enumerable.Range(1, 10))
{
p.Hand.AddCard(Deck.Draw());
}
}
private void pbDeck_Click(object sender, EventArgs e)
{
if (playerTurn == PlayerType.PLAYER)
{
var newCards = deck.Draw(1);
player.GiveCards(newCards);
playerTurn = PlayerType.CPU;
}
else
{
var newCards = deck.Draw(1);
cpu.GiveCards(newCards);
playerTurn = PlayerType.PLAYER;
}
ShowCards();
}
public void Draw_DrawCardsShouldReturn5Cards()
{
var deck = new Deck();
var cards = deck.Draw();
Assert.Equal(5, cards.Count);
}
public void DrawStartingHand()
{
for (int i = 0; i < Deck.Faction.StartingHandSize; i++)
{
Hand.Add(Deck.Draw());
}
}
public void InitState(GameServer server)
{
// Get the deck
Deck toDrawFrom = new Deck(server.GameState.GetValueCardCollection(Names.DECK));
// Iterate over all players
for (byte index = 0; index < server.Players.Count; index++)
{
// If the player exists
if (server.Players[index] != null)
{
// Add 6 cards to their hand
for (int cIndex = 0; cIndex < 6; cIndex++)
{
if (toDrawFrom.CardsInDeck > 0)
{
server.Players[index].Hand.Add(toDrawFrom.Draw());
}
else if (!server.GameState.GetValueBool(Names.TRUMP_CARD_USED))
{
server.Players[index].Hand.Add(server.GameState.GetValueCard(Names.TRUMP_CARD));
server.GameState.Set(Names.TRUMP_CARD_USED, true);
}
}
}
}
// Update the deck and the count in the state
server.GameState.Set <CardCollection>(Names.DECK, toDrawFrom.Cards);
server.GameState.Set <int>(Names.DECK_COUNT, toDrawFrom.CardsInDeck);
}
private static void DealCards(GameState state, Dictionary <int, Player> players, List <int> winningPlayers, Deck deck)
{
var block = !state.GetValueBool(Names.TRUMP_CARD_USED);
while (block && !players.Values.All(p => p.Hand.Count >= 6))
{
foreach (var player in players.Values)
{
if (deck.Cards.Count > 0 && player.Hand.Count < 6)
{
player.Hand.Add(deck.Draw());
}
else if (block && deck.Cards.Count <= 0 && player.Hand.Count < 6)
{
player.Hand.Add(state.GetValueCard(Names.TRUMP_CARD));
state.Set(Names.TRUMP_CARD_USED, true);
block = false;
break;
}
}
}
foreach (var player in players.Values)
{
if (player.Hand.Count == 0 && !winningPlayers.Contains(player.ID))
{
winningPlayers.Add(player.ID);
}
}
}
// Start is called before the first frame update
void Start()
{
CardGame currentGame = new CardGame();
currentGame.elements = new ICardGameElement[listOfDecks.Length];
for (int i = 0; i < listOfDecks.Length; i++)
{
//listOfDecks[i] = new Deck();
for (int j = 0; j < listOfDecks[i].namesOfCards.Length; j++)
{
Card newCard;
System.Type cardType = System.Type.GetType(listOfDecks[i].namesOfCards[j]);
newCard = (Card)cardType.GetConstructor(System.Type.EmptyTypes).Invoke(null);
listOfDecks[i].Add(newCard);
}
listOfDecks[i].Shuffle();
currentGame.elements[i] = listOfDecks[i];
}
currentGame.participants = new Player[Players.Length];
for (int i = 0; i < Players.Length; i++)
{
currentGame.participants[i] = new Player(Players[i]);
GameObject playerGameObject = new GameObject(currentGame.participants[i].name);
playerGameObject.transform.SetPositionAndRotation(Vector3.zero, Quaternion.identity);
playerGameObject.transform.SetParent(GameObject.Find("Canvas").transform);
playerGameObject.AddComponent <HandManager>().currentGame = currentGame;
playerGameObject.GetComponent <HandManager>().handToDisplay = currentGame.participants[i].playerHand;
Deck deckToDrawFrom = (Deck)currentGame.elements[0];
deckToDrawFrom.Draw(currentGame.participants[i].playerHand);
}
}
private static int DeckTest()
{
Deck d = new Deck();
Card drawn;
bool[,] exist = new bool[4, 13];
int count = 0;
while (!d.IsEmpty)
{
drawn = d.Draw();
exist[drawn.Suit, drawn.Rank] = true;
count++;
}
for (int i = 0; i < 4; i++)
{
for (int j = 0; j < 13; j++)
{
if (!exist[i, j])
{
Console.WriteLine("ERROR MISSING CARD: {0}{1}", i, j);
}
}
}
Console.WriteLine("{0} cards drawn", count);
return(0);
}
/* Displays a new card from the Deck */
public void DisplayNewCard()
{
card = deck.Draw(); // Draws the next card
cardText.text = card; // Displays the card's text
drawnCards.Add(card); // Add the card to the drawnCards list
}
public void Play(Deck gameDeck)
{
if (!this.HasBlackJack() && !this.IsBusted() && Hand.GetTotal() < 17)
{
gameDeck.Draw(this);
}
}
public void AfterPlayAll_Draw_ShouldNotReturnNull()
{
Deck target = new Deck(new TestDeckProvider());
for (int i = 0; i < TestDeckProvider.DefaultTestDeckSize; i++)
{
Card card = target.Draw();
target.Play(card);
}
Card final = target.Draw(); // This will trigger the reshuffle.
Assert.IsNotNull(final);
return;
}
private IEnumerator InitialDraw(Deck deck)
{
for(int i=0; i < drawCount; i ++)
{
deck.Draw();
yield return new WaitForSeconds(drawDelay);
}
}
public void TestDealCard()
{
Deck deck = new Deck();
Player hand = new Player();
Assert.IsTrue(deck.CardsLeft() == 52);
deck.Draw();
Assert.IsTrue(deck.CardsLeft() == 51);
}
public Game(Player Master, List<Player> Learners, Random Random)
{
_Random = Random;
_Deck = new Deck();
_Deck.Shuffle(_Random);
_Return = new Deck(true);
_Master = Master;
_Learners = Learners;
_MasterHand = new Hand(10, _Deck);
foreach(Player L in _Learners) _LearnerHands.Add(new Hand(10, _Deck));
_DownCard = _Deck.Draw();
}
/// <summary>
/// Enumerate through a deck
/// </summary>
/// <param name="deck"></param>
/// <returns></returns>
private static IEnumerable<ColorettoCard> DeckEnumeration(Deck<ColorettoCard> deck)
{
if (deck != null && !deck.IsEmpty)
{
do
{
ColorettoCard card = null;
deck = deck.Draw(out card);
yield return card;
} while (!deck.IsEmpty);
}
}
private Card DrawCardFromDeck(Deck deck)
{
var card = deck.Draw();
Player.Game.SendUpdateDeck(deck);
return card;
}
public void DrawHands_draws_the_top_cards_from_the_stack()
{
// Arrange.
var seed = Environment.TickCount;
var sut = new Deck();
var controlDeck = new Deck();
sut.Shuffle(seed);
controlDeck.Shuffle(seed);
// Act.
var hands = sut.DrawHands(2);
var controlHands = hands.Select(hand => hand.Select(card => controlDeck.Draw())).ToList();
// Assert.
for (int i = 0; i < hands.Count; i++)
{
var hand = hands[i];
var controlHand = controlHands[i];
ActualValueDelegate<bool> test = () => hand.SequenceEqual(controlHand);
Assert.That(test, Is.True);
}
}
public void TestPlayerTotal()
{
Deck deck = new Deck();
Player hand = new Player();
Assert.IsTrue(hand.Cards.Count == 0);
hand.AddCard(deck.Draw());
Assert.IsTrue(hand.Cards.Count == 1);
}
public Card ShowCard(Deck deck)
{
return deck.Draw();
}
static void NewGame(object o, ButtonPressEventArgs args)
{
Bet = 0;
DealButton.Opacity = 0;
BetButton.Opacity = 255;
BetButton.Reactive = true;
BetButton.Show ();
StepButton.HoldState ();
StepButton.Show ();
// Needs to be replaced with "return to deck" animation
for (int i = 0; i < 5; i++) {
PlayerHand.GetCard (i).Hide ();
OpponentHand.GetCard (i).Hide ();
}
Deck = new Deck ();
PlayerHand = new Hand (Deck.Draw (), Deck.Draw (), Deck.Draw (), Deck.Draw (), Deck.Draw ());
OpponentHand = new Hand (Deck.Draw (), Deck.Draw (), Deck.Draw (), Deck.Draw (), Deck.Draw ());
SetupAnimation ();
}
static void Main()
{
Clutter.Application.Init ();
Stage = new Stage ();
Stage.Title = "Deal!";
Stage.Add (new Texture ("Pixmaps/Table.png"));
Stage.SetSize (800, 480);
Stage.KeyPressEvent += HandleKeyPress;
Texture C = new Texture ("Pixmaps/Coin.png");
C.SetSize (50, 50);
C.SetPosition (35, 405);
Stage.Add (C);
Bet = 0;
BetButton = new BetButton ();
BetButton.ButtonPressEvent += IncreaseBet;
Stage.Add (BetButton);
DealButton = new DealButton ();
DealButton.ButtonPressEvent += NewGame;
Stage.Add (DealButton);
StepButton = new StepButton ();
StepButton.ButtonPressEvent += NextStep;
Stage.Add (StepButton);
Stack = new Stack ();
Stack.Decrease (20);
ScoreText = new Text ("Droid Sans Bold 21", "" + Stack.GetAmount());
ScoreText.SetColor (new Clutter.Color (0xff, 0xff, 0xff, 0xff));
ScoreText.SetPosition (100, 413);
Stage.Add (ScoreText);
Coins = new Coin [5];
Coins [0] = new Coin ();
Coins [1] = new Coin ();
Coins [2] = new Coin ();
Coins [3] = new Coin ();
Coins [4] = new Coin ();
for (int i = 0; i < 5; i++) {
Coins [i].SetPosition (35, 405);
Stage.Add (Coins [i]);
}
Deck = new Deck ();
PlayerHand = new Hand (Deck.Draw (), Deck.Draw (), Deck.Draw (), Deck.Draw (), Deck.Draw ());
OpponentHand = new Hand (Deck.Draw (), Deck.Draw (), Deck.Draw (), Deck.Draw (), Deck.Draw ());
SetupAnimation ();
Stage.ShowAll();
Clutter.Application.Run ();
}
/// <summary>
/// Verifies that expectedContent is a subset of deck and each card in expectedContent exists sequentually numberOfDups times.
/// </summary>
/// <param name="expectedContent"></param>
/// <param name="deck"></param>
/// <param name="numberOfDups"></param>
/// <returns></returns>
private static bool IsValid_CollatedDuplication(List<StandardCard> expectedContent, Deck<StandardCard> deck, int numberOfDups)
{
for (int i = 0; i < expectedContent.Count; i++)
{
for (int j = 0; j < numberOfDups; j++)
{
StandardCard card;
deck = deck.Draw(out card);
if (expectedContent[i].Equals(card) == false)
{
return false;
}
}
}
return true;
}
public void NewGame()
{
rowDecks = new List<Deck>();
stackDecks = new List<Deck>();
gameShape.Game = new Game();
//Dealer
dealer = new Deck(1, 13, gameShape.Game);
dealer.Shuffle(5);
dealer.FlipAllCards();
dealer.EnableAllCards(false);
dealer.MakeAllCardsDragable(false);
dealer.Enabled = false;
Dealer.Deck = dealer;
gameShape.DeckShapes.Add(Dealer);
Dealer.DeckMouseLeftButtonDown += new MouseButtonEventHandler(Dealer_DeckMouseLeftButtonDown);
//Ground
ground = new Deck(gameShape.Game);
Ground.Deck = ground;
Ground.UpdateCardShapes();
gameShape.DeckShapes.Add(Ground);
//Row Decks
for (int i = 0; i < 7; i++)
{
Deck deck = new Deck(gameShape.Game);
rowDecks.Add(deck);
DeckShape deckShape = new DeckShape();
gameShape.DeckShapes.Add(deckShape);
deckShape.CardSpacerY = 20;
deckShape.MaxCardsSpace = 10;
deckShape.Deck = deck;
this.LayoutRoot.Children.Add(deckShape);
Canvas.SetLeft(deckShape, 25 + (i * 85));
Canvas.SetTop(deckShape, 150);
dealer.Draw(deck, i + 1);
deck.TopCard.Visible = true;
deck.TopCard.Enabled = true;
deck.TopCard.IsDragable = true;
}
//Stack Decks
for (int i = 0; i < 4; i++)
{
Deck deck = new Deck(gameShape.Game);
stackDecks.Add(deck);
DeckShape deckShape = new DeckShape();
gameShape.DeckShapes.Add(deckShape);
deckShape.CardSpacerY = 1;
deckShape.MaxCardsSpace = 10;
deckShape.Deck = deck;
this.LayoutRoot.Children.Add(deckShape);
Canvas.SetLeft(deckShape, 280 + (i * 85));
Canvas.SetTop(deckShape, 24);
}
dealer.TopCard.Enabled = true;
dealer.TopCard.IsDragable = false;
}
/// <summary>
/// Takes a deck and converts it into a list by drawing cards.
/// </summary>
/// <param name="deck"></param>
/// <returns></returns>
private static List<StandardCard> ConvertDeckToList(Deck<StandardCard> deck)
{
List<StandardCard> list = new List<StandardCard>(deck.OriginalSize);
for (int i = 0; i < deck.OriginalSize; i++)
{
StandardCard card = null;
deck = deck.Draw(out card);
list.Add(card);
}
return list;
}
