/// <summary>
/// Testing function used to generate card data for testing
/// </summary>
public void GenerateTestCards()
{
//generate 30 cards for the draw pile
for (int i = 0; i < 30; ++i)
{
Card newCard = new Card();
newCard.Title = "drawpile card " + i.ToString();
newCard.Description = "drawpile description " + i.ToString();
DrawPile.AddCard(newCard);
AllCards.AddCard(newCard);
}
//generate 10 cards for the discard pile
for (int i = 0; i < 10; ++i)
{
PlayerCard newCard = new PlayerCard();
newCard.Title = "discarded card " + i.ToString();
newCard.Description = "discarded description " + i.ToString();
newCard.FirstName = "FirstName" + i.ToString();
newCard.LastName = "LastName" + i.ToString();
newCard.Attributes = new PlayerAttributes(i, i);
DiscardPile.AddCard(newCard);
AllCards.AddCard(newCard);
}
//generate 5 cards for the exile pile
for (int i = 0; i < 5; ++i)
{
Card newCard = new Card();
newCard.Title = "exiled card " + i.ToString();
newCard.Description = "exiled description " + i.ToString();
ExilePile.AddCard(newCard);
AllCards.AddCard(newCard);
}
}
public void TestAddCardRunsWithoutErrors()
{
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));
}
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.Count);
}
/// <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());
}
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>
/// 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);
}
}
public void AddCard(CardData card, CardPile pile)
{
cardList.Add(card);
card.indexInDeck = cardList.Count - 1;
pile.AddCard(cardList.Count - 1);
SetTotalCardsInDeck();
}
/// <summary>
/// 进行一次选牌
/// </summary>
private IEnumerator ESelectCardForCardPile(int i)
{
var tuple = SelectCard.GetCards(i);
List <Card> firstPile = tuple.Item1.Shuffle().Take(3).ToList();
List <Card> secondPile = tuple.Item2.Shuffle().Take(3).ToList();
List <Card>[] piles = new List <Card>[2] {
firstPile, secondPile
};
gameAnimationSetting.SelectCardForCardPile(firstPile, secondPile, cardPile, tuple.Item3, tuple.Item4);
gameAnimationSetting.selectPileAction = n =>
{
Debug.Log("选择了 " + piles[n].Select(card => card.name).StringJoin(","));
isGotResponse = true;
piles[n].ForEach(card =>
{
cardPile.AddCard(card, Const.numOfMinionsInCardPile[card.star - 1]);
SelectCard.Remove(card);
});
};
if (isTest)
{
gameAnimationSetting.selectPileAction.Invoke(0);
yield break;
}
yield return(StartCoroutine(WaitForGotResponse()));
//Debug.Log("选择完毕");
}
public void TestGetLastCardInPileAfterAddCard()
{
CardPile pile = new CardPile();
pile.AddCard(new Card(Suit.Clubs, FaceValue.Ace));
Assert.IsTrue(
pile.TopCard.Equals(new Card(Suit.Clubs, FaceValue.Ace))
);
pile.AddCard(new Card(Suit.Hearts, FaceValue.Seven));
Assert.IsTrue(
pile.TopCard.Equals(new Card(Suit.Hearts, FaceValue.Seven))
);
}
public static CardPile CreateCardPile(List <Card> cards)
{
CardPile cardPile = new CardPile();
foreach (Card card in cards)
{
cardPile.AddCard(card);
}
return(cardPile);
}
public void FillCardPileWith1StarMinion(CardPile cardPile)
{
CardBuilder.AllCards
.FilterValue(card => card.cardType == CardType.Minion && !card.isToken && card.star == 1)
.Shuffle()
.Take(5)
.Map(card => {
cardPile.AddCard(card, 18);
});
}
public void Test_CardPile_AddCard(int numberOfCards)
{
CardPile cardPile = new CardPile();
for (int i = 0; i < numberOfCards; i++)
{
cardPile.AddCard(new Card(CardSuit.DIAMOND, CardRank.RANK_2));
}
Assert.True(numberOfCards == cardPile.NumberOfCards);
}
/// <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());
}
/// <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);
}
}
public void ReturnCards(CardPile cp, List <Card> cards)
{
if (isPutBack)
{
cp.AddCard(cards);
}
if (isShuffle)
{
cp.Shuffle();
}
}
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();
}
private void AddPlayedCards(Player player, params Card[] cards)
{
foreach (Card card in cards)
{
CardPile.AddCard(card);
if (player != null)
{
player.RemoveCard(card);
}
}
PlayedCards(cards);
}
/// <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());
}
//Create Discard Pile from Draw Pile Last Card
public static CardPile SetDiscardPile(CardPile drawPile)
{
//Declare new card pile
CardPile discardPile = new CardPile();
//Retrieve last card from draw pile and add it to the discard pile
Card lastCard = drawPile.GetLastCardInPile();
discardPile.AddCard(lastCard);
//Remove the last card from the draw pile
drawPile.RemoveLastCard();
//return the discard pile
return(discardPile);
}
//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);
}
/// <summary>
/// Plays the chosen Card (given by cardNum) from the given Hand (given
/// by hand), with a particular Suit(given by newSuit).
/// </summary>
/// <param name="hand">Hand</param>
/// <param name="cardNum">Card's index</param>
/// <param name="newSuit">Give suit if the card is eight</param>
/// <param name="opponentHand">The opponent's hand</param>
/// <returns></returns>
private static ActionResult PlayCard(Hand hand, int cardNum, Suit newSuit, Hand opponentHand)
{
// Get the card
Card cardPlayed = hand.GetCard(cardNum);
if (!IsCardPlayable(cardPlayed))
{
if (IsHandPlayable(hand))
{
return(ActionResult.InvalidPlay);
}
else
{
return(ActionResult.InvalidPlayAndMustDraw);
}
}
else
{
_discardPile.AddCard(new Card(newSuit, cardPlayed.GetFaceValue()));
hand.RemoveCardAt(cardNum);
if (hand.GetCount() == 0)
{
IsPlaying = false;
return(ActionResult.WinningPlay);
}
else
{
if (!IsHandPlayable(opponentHand) && opponentHand.GetCount() == FULL_HAND)
{
return(ActionResult.ValidPlayAndExtraTurn);
}
else
{
IsUserTurn = !IsUserTurn;
return(ActionResult.ValidPlay);
}
}
}
}
/// <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);
}
// 卡牌相关
public void AddNewCardTo(CardPile.PileType _type, Card _card)
{
switch (_type)
{
case CardPile.PileType.deck: deckPile.AddCard(_card); break;
case CardPile.PileType.focus: focusPile.AddCard(_card); break;
case CardPile.PileType.hand: handPile.AddCard(_card);
UIManager.instance.UpdateHandUI(handPile.cards_list); break;
case CardPile.PileType.discard: discardPile.AddCard(_card); break;
default: break;
}
}
private void ActualMove(CardPile newPile, Card source)
{
if (CardPile != null)
{
if (newPile == CardPile) // if we're already in the new pile then do nothing
{
return;
}
CardPile.RemoveCard(this);
}
CardPile previousPile = CardPile;
CardPile = newPile;
newPile.AddCard(this);
TriggerAddedToCardPileEffects(this, new AddedToCardPileArgs(previousPile, newPile, source));
}
/// <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());
}
public CardPile GetDeckByInfo(DeckInfo info)
{
List <string> cards = info.cardWithNum;
CardPile pile = new CardPile("deckPile");
for (int i = 0; i < cards.Count; i++)
{
char[] words = cards[i].ToCharArray();
// 名称
List <char> name = new List <char>();
// 数量
List <char> value = new List <char>();
for (int j = 0; j < words.Length; j++)
{
if ((int)words[j] > '0' && (int)words[j] < '9')
{
value.Add(words[j]);
}
else
{
name.Add(words[j]);
}
}
char[] _name = name.ToArray();
string mname = new string(_name);
char[] _value = value.ToArray();
for (int j = 0; j < _value[0] - 48; j++)
{
pile.AddCard(GetCardByName(mname));
}
}
return(pile);
}
public void TestDealCardsAfterAddingCards()
{
CardPile pile = new CardPile();
List <Card> cardsToAdd = new List <Card> {
new Card(Suit.Spades, FaceValue.Ace),
new Card(Suit.Clubs, FaceValue.Queen),
new Card(Suit.Clubs, FaceValue.Four),
new Card(Suit.Hearts, FaceValue.Seven),
new Card(Suit.Diamonds, FaceValue.Seven)
};
foreach (Card card in cardsToAdd)
{
pile.AddCard(card);
}
List <Card> dealtCards = pile.DealCards(4);
for (int i = 0; i < 4; i++)
{
Assert.IsTrue(dealtCards[i].Equals(cardsToAdd[i]));
}
}
/// <summary>
/// Plays chosen Card, from the given Hand, with a particular Suit.
/// </summary>
/// <param name="cardnum">the chosen card</param>
/// <param name="choosen"></param>
/// <returns></returns>
private static ActionResult PlayCard(Hand thisHand, int cardnum, Suit?newSuit)
{
Hand otherHand;
if (IsUserTurn)
{
otherHand = ComputerHand;
}
else
{
otherHand = UserHand;
}
//Eights
if (thisHand.GetCard(cardnum).GetFaceValue() == FaceValue.Eight)
{
if (newSuit == null)
{
return(ActionResult.SuitRequired);
}
else
{
if ((IsHandPlayable(otherHand) == false) && (otherHand.GetCount() == 13))
{
_discardPile.AddCard(thisHand.GetCard(cardnum));
thisHand.RemoveCardAt(cardnum);
return(ActionResult.ValidPlayAndExtraTurn);
}
IsUserTurn = !IsUserTurn;
thisHand.RemoveCardAt(cardnum);
_discardPile.AddCard(new Card((Suit)newSuit, FaceValue.Eight));
return(ActionResult.ValidPlay);
}
}
if ((IsCardPlayable(thisHand.GetCard(cardnum)) == true) && (thisHand.GetCount() == 1))
{
_discardPile.AddCard(thisHand.GetCard(cardnum));
thisHand.RemoveCardAt(cardnum);
IsPlaying = false;
return(ActionResult.WinningPlay);
}
if (IsCardPlayable(thisHand.GetCard(cardnum)) == true)
{
_discardPile.AddCard(thisHand.GetCard(cardnum));
thisHand.RemoveCardAt(cardnum);
if ((IsHandPlayable(otherHand) == false) && (otherHand.GetCount() == 13))
{
return(ActionResult.ValidPlayAndExtraTurn);
}
IsUserTurn = !IsUserTurn;
return(ActionResult.ValidPlay);
}
if (IsHandPlayable(thisHand) == false)
{
return(ActionResult.InvalidPlayAndMustDraw);
}
else
{
//
return(ActionResult.InvalidPlay);
}
}
/// <summary>
/// a
/// </summary>
/// <param name="cardNum"></param>
/// <param name="chosenSuit"></param>
/// <returns></returns>
public static ActionResult UserPlayCard(int cardNum, Suit?chosenSuit = null)
{
if (IsPlaying == false)
{
throw new System.ArgumentException("This game is not start!");
}
if (IsUserTurn == false)
{
throw new System.ArgumentException("This is not your turn!");
}
Card card = _userhand.GetCard(cardNum);
if (_discardPile.GetCount() == 1 && TopDiscard.GetFaceValue() == FaceValue.Eight)
{
IsUserTurn = false;
_userhand.RemoveCardAt(cardNum);
_discardPile.AddCard(card);
return(ActionResult.ValidPlay);
}
if (card.GetFaceValue() == FaceValue.Eight)
{
if (!chosenSuit.HasValue)
{
return(ActionResult.SuitRequired);
}
IsUserTurn = false;
_userhand.RemoveCardAt(cardNum);
_discardPile.AddCard(new Card(chosenSuit, FaceValue.Eight));
return(ActionResult.ValidPlay);
}
if (card.GetFaceValue() == TopDiscard.GetFaceValue() || card.GetSuit() == TopDiscard.GetSuit())
{
_userhand.RemoveCardAt(cardNum);
_discardPile.AddCard(card);
if (UserHand.GetCount() == 0)
{
IsPlaying = false;
return(ActionResult.WinningPlay);
}
if (ComputerHand.GetCount() == 13)
{
foreach (Card c in ComputerHand)
{
if (c.GetFaceValue() == TopDiscard.GetFaceValue() || c.GetSuit() == TopDiscard.GetSuit())
{
IsUserTurn = false;
return(ActionResult.ValidPlay);
}
}
return(ActionResult.ValidPlayAndExtraTurn);
}
IsUserTurn = false;
return(ActionResult.ValidPlay);
}
// Invalid Play
foreach (Card c in UserHand)
{
if (c.GetFaceValue() == TopDiscard.GetFaceValue() || c.GetSuit() == TopDiscard.GetSuit() || c.GetFaceValue() == FaceValue.Eight)
{
return(ActionResult.InvalidPlay);
}
}
return(ActionResult.InvalidPlayAndMustDraw);
}
/// <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);
}
}
}
