public void TestGameRule_PlayCardSuccessDrawCard()
{
var player = new Mock <IHanabiPlayer>();
CardIdType id = new CardIdType(0);
CardIndexType index = new CardIndexType(0);
Card card = new Card(id, index, CardColorType.Blue, CardValueType.Value1);
HandCard handCard = new HandCard(card);
player.Setup(x => x.GetHandCard(index)).Returns(handCard);
player.Setup(x => x.PlayCard(index));
var board = new Mock <IGameBoard>();
CardIdType newId = new CardIdType(1);
CardIndexType newIndex = new CardIndexType(1);
Card newCard = new Card(newId, newIndex, CardColorType.Blue, CardValueType.Value1);
board.Setup(x => x.Draw()).Returns(newCard);
board.Setup(x => x.Play(card)).Returns(true);
GameRule rule = new GameRule();
Debug.Assert(rule.PlayCard(index, player.Object, board.Object) == PlayCardResult.Success);
player.VerifyAll();
board.VerifyAll();
}
public void TestGameRule_PlayCardFailedNoSlot()
{
var player = new Mock <IHanabiPlayer>();
CardIdType id = new CardIdType(0);
CardIndexType index = new CardIndexType(0);
Card card = new Card(id, index, CardColorType.Blue, CardValueType.Value1);
HandCard handCard = new HandCard(card);
player.Setup(x => x.GetHandCard(index)).Returns(handCard);
player.Setup(x => x.PlayCard(index));
var board = new Mock <IGameBoard>();
board.Setup(x => x.Draw()).Returns <Card>(null);
board.Setup(x => x.Play(card)).Returns(false);
board.Setup(x => x.Discard(card));
board.Setup(x => x.Punish());
GameRule rule = new GameRule();
Debug.Assert(rule.PlayCard(index, player.Object, board.Object) == PlayCardResult.FailNoSlot);
player.VerifyAll();
board.VerifyAll();
}
public void clickBattlecryTarget(GameObject g)
{
if (g.GetComponent <BoardCharacter>())
{
BoardCharacter c = g.GetComponent <BoardCharacter>();
if (p.currentObj.GetComponent <HandCard>().representative != null)
{
if (p.currentObj.GetComponent <HandCard>().representative.effect.setBattlecryTarget(c))
{
p.currentObj.GetComponent <HandCard>().aimingBattlecry = false;
Debug.Log("Aimed a battlecry");
}
}
else if (p.currentObj.GetComponent <HandCard>().spellRepresentative != null)
{
if (p.currentObj.GetComponent <HandCard>().spellRepresentative.effect.setSpellTarget(c))
{
Debug.Log("Aimed a spell");
p.currentObj.GetComponent <HandCard>().aimingBattlecry = false;
}
}
}
else
{
HandCard cardCancelled = p.currentObj.GetComponent <HandCard>();
cancelBattlecry(cardCancelled);
}
}
//actually draw a card
IEnumerator drawCards(int num)
{
for (int i = 0; i < num; i++)
{
//if I have cards left, draw, else fatigue
if (deck.Count > 0)
{
HandCard cardToDraw = deck[0];
deck.RemoveAt(0);
//if I have space, add, otherwise, discard
if (hand.Count < 10)
{
hand.Add(cardToDraw);
Vector3 temp = playerInput.controller.getNextHandPos(this, cardToDraw);
temp.x -= 3;
cardToDraw.posToMoveTo = temp;
}
else
{
Debug.Log("Too many cards in hand");
Destroy(cardToDraw.gameObject);
}
}
else
{
EffectsController.dealDamage(hero, fatigue);
fatigue += 1;
Debug.Log("No cards in deck");
}
yield return(new WaitForSeconds(1));
}
}
void exeBegin(RaycastHit hit)
{
if (hit.transform.tag == "HandCard" && hit.transform.GetComponent <HandCard>().getOwner() == this &&
hit.transform.GetComponent <HandCard>().getCard() != null)
{
if (chosenCards == 0)
{
// ETHAN: added animation that flips the selected FIRST card
hc1 = hit.transform.GetComponent <HandCard>();
hc1.getCard().toggleCard();
chosenCards++;
}
else if (chosenCards == 1 && hit.transform.GetComponent <HandCard>() != hc1)
{
// ETHAN: added animation that flips the selected SECOND card
hc2 = hit.transform.GetComponent <HandCard>();
hc2.getCard().toggleCard();
// ETHAN: added animation that flips back the selected two cards (after flipBack() delay)
StartCoroutine(flipBack(hc1, hc2));
chosenCards = 0;
this.unhighlightHand();
CmdUpdateMode(Modes.WAITING);
//Debug.Log("waiting");
}
}
}
// Checks if player has enough mana and card is not on cooldown
public bool ValidateCardPlay (HandCard card, Player currentPlayer) {
if (currentPlayer.CheckMana(card.GetCurrentManaCost()) && card.GetCurrentCooldown() == 0){
return true;
} else {
return false;
}
}
private void CreateInactiveCard()
{
HandCard newInactiveCard = GameObject.Instantiate <GameObject>(handCardObj, inactiveCardHolder.transform).GetComponent <HandCard>();
inactiveCards.Add(newInactiveCard);
newInactiveCard.gameObject.SetActive(false);
}
public void AddHandCardsPool(HandCard handCard)
{
//handCard.gameObject.SetActive(false);
handCard.transform.position = new Vector3(100, 100, 100);
handCardsPool.Add(handCard);
handCard.transform.SetParent(GameData.hcPoolTrans);
}
//for when I dont want to animate it
public void addCardsToHand(int num)
{
for (int i = 0; i < num; i++)
{
if (deck.Count > 0)
{
HandCard cardToDraw = deck[0];
deck.RemoveAt(0);
if (hand.Count < 10)
{
hand.Add(cardToDraw);
}
else
{
Debug.Log("Too many cards in hand");
}
}
else
{
EffectsController.dealDamage(hero, fatigue);
fatigue += 1;
Debug.Log("No cards in deck");
}
}
}
public async Task <ResponseGetDeallerCardGameView> GetDeallerCard(RequestGetDeallerCardGameView requestGetDeallerCardGameView)
{
Game game = await _gameRepository.GetGameWithPlayerGames(requestGetDeallerCardGameView.GameId);
Hand hand = await _handRepository.GetHandWithCardsByRoundAndPlayerId(requestGetDeallerCardGameView.RoundId, requestGetDeallerCardGameView.PlayerId);
if (game == null || hand == null)
{
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine(string.Format("RoundId: {0}", requestGetDeallerCardGameView.RoundId));
stringBuilder.AppendLine(string.Format("PlayerId: {0}", requestGetDeallerCardGameView.PlayerId));
stringBuilder.AppendLine(string.Format("GameId: {0}", requestGetDeallerCardGameView.GameId));
stringBuilder.AppendLine(string.Format("Message: {0}", SolutionConstants.BUSINESS_LOGIC_GET_ITEM_EXCEPTION_MESSAGE));
string message = stringBuilder.ToString();
throw new BusinessLogicGetItemException(message);
}
Deck infinityDeck = await _deckProvider.GetAllDeckFromCache(game.Id);
List <Card> handCards = hand.HandCards.Select(item => item.Card).ToList();
Card card = DeckExtension.GetCard(infinityDeck);
handCards.Add(card);
hand.Summary += _gameUtility.GetCardValue(card.Face);
if (handCards.Count == GameConstants.TWO_CARDS)
{
hand.VictoryType = _gameUtility.CheckTypeOfVictory(handCards);
if (hand.VictoryType == VictoryType.GoldenPoint)
{
hand.Summary = GameConstants.BLACKJACK;
}
}
await _handRepository.Update(hand);
var handCard = new HandCard();
handCard.CardId = card.Id;
handCard.HandId = hand.Id;
await _handCardRepository.Create(handCard);
_deckProvider.SetDeckInMemoryCashe(game.Id, infinityDeck);
var responseView = new ResponseGetDeallerCardGameView();
responseView.HandId = hand.Id;
responseView.Card = _mapper.Map <Card, CardGetDeallerCardGameViewItemItem>(card);
responseView.Summary = hand.Summary;
return(responseView);
}
public void ActivateExamined(HandCard cardToExamine)
{
Card c = cardToExamine.getCard();
className.text = c.GetDisplayName();
description.text = c.GetDescription();
gameObject.SetActive(true);
}
private void FlipOneCard(Image imgCard, HandCard card, List <Sprite> textures, float delay, float time)
{
LeanTween.rotateLocal(imgCard.gameObject, new Vector3(0, 90, 0), time).setDelay(delay).setOnComplete(() =>
{
imgCard.sprite = textures[CardToIndex(card)];
LeanTween.rotateLocal(imgCard.gameObject, Vector3.zero, time);
});
}
private void DeactivateCard(HandCard card)
{
inactiveCards.Add(card);
activeCards.Remove(card);
card.gameObject.SetActive(false);
card.transform.SetParent(inactiveCardHolder.transform);
UpdateCardPositions();
}
public bool RemoveCardFromUserHand(GameTable table, User actualUser, Card removeCard)
{
List <HandCard> handCards =
table.Participations.Find(participation => participation.Participant.Nickname == actualUser.Nickname)
.ActualPlayRound.Cards;
HandCard handCard = handCards.Find(card => card.Id == removeCard.Id);
return(handCards.Remove(handCard));
}
public void RemoveAllCardsFromUser(GameTable actualGameTable, User actualUser)
{
HandCard[] cardArray = new HandCard[6];
actualGameTable.CardServiceData.GetActualHandCards(actualUser, actualGameTable).CopyTo(cardArray);
foreach (var card in cardArray)
{
actualGameTable.CardServiceData.RemoveCardFromUserHand(actualGameTable, actualUser, card);
}
}
public void GivenHandCardsThenCompareStraightFlush(string handCardA, string handCardB, string expectedResult, CardTypes cardType)
{
var blackGroup = new HandCard(GroupTypes.Black, Common.ConvertCardStringToList(handCardA), cardType);
var whiteGroup = new HandCard(GroupTypes.White, Common.ConvertCardStringToList(handCardB), cardType);
var compareResult = CardTypeBase.CompareMultipleCardNumber(blackGroup, whiteGroup);
Assert.Equal(expectedResult, compareResult);
}
public static void discardFirst(Player p, int num)
{
for (int i = 0; i < num; i++)
{
HandCard c = p.hand[0];
p.hand.RemoveAt(0);
GameObject.Destroy(c.gameObject);
}
}
void Start()
{
players[0] = player1;
players[1] = player2;
//initialize the two players
int indx;
foreach (Player player in players)
{
player.processDecklist(getCorrectPath("player" + player.playernum + "decklist.txt"));
player.deckPosX = 12.0f;
player.deckPosY = 7.0f * (player.playernum * 2 - 3);
indx = 0;
player.startHandWidth = -19.0F;
player.handWidthDifference = 3.0f;
player.handHeight = 7.0f * (player.playernum * 2 - 3);
player.startBoardPos = -1.5f;
player.boardWidthDifference = 3.0f;
player.boardHeight = 2.5f * (player.playernum * 2 - 3);
foreach (Card card in player.decklist)
{
if (card == null)
{
break;
}
HandCard newCard = Instantiate(baseCard) as HandCard;
newCard.Player = player;
newCard.SetCard(card);
newCard.transform.position = new Vector3(player.deckPosX, player.deckPosY, -3);
newCard.cardBack.enabled = true;
indx++;
player.deck.Add(newCard);
}
Shuffle <HandCard>(player.deck);
player.mulligan.getCards();
player.hero.transform.position = new Vector3(12, 2.5f * (player.playernum * 2 - 3) - .2f, 0);
player.hero.posToMoveTo = player.hero.transform.position;
}
activePlayer = player1;
player1.activeplayer = true;
player2.activeplayer = false;
player1.startTurn();
}
public HandCard createHandCard(Card card, Player p)
{
HandCard newCard = Instantiate(baseCard) as HandCard;
newCard.Player = p;
newCard.SetCard(card);
newCard.cardBack.enabled = true;
return(newCard);
}
public void Deselect(HandCard card)
{
if (selectedCard == card)
{
selectedCard = null;
UpdateCardPositions();
}
examineCard.Deativate();
examineClass.Deativate();
}
private async Task GiveOutTwoCards(int gameId, RequestGetPlayersTwoCardsGameView requestView)
{
Deck infinityDeck = await _deckProvider.GetAllDeckFromCache(gameId);
var hands = new List <Hand>();
var handCards = new List <HandCard>();
for (int i = 0; i < requestView.Players.Count; i++)
{
Hand hand = await _handRepository.GetHandByRoundAndPlayerId(requestView.RoundId, requestView.Players[i]);
if (hand == null)
{
continue;
}
int summary = 0;
var cards = new List <Card>();
for (int y = 0; y < GameConstants.TWO_CARDS; y++)
{
Card card = DeckExtension.GetCard(infinityDeck);
cards.Add(card);
var handCard = new HandCard();
handCard.CardId = card.Id;
handCard.HandId = hand.Id;
handCards.Add(handCard);
summary += _gameUtility.GetCardValue(card.Face);
}
hand.Summary = summary;
hand.VictoryType = _gameUtility.CheckTypeOfVictory(cards);
if (hand.VictoryType == VictoryType.GoldenPoint)
{
hand.Summary = GameConstants.BLACKJACK;
}
hands.Add(hand);
}
await _handRepository.UpdateMultiple(hands);
await _handCardRepository.CreateMultiple(handCards);
_deckProvider.SetDeckInMemoryCashe(gameId, infinityDeck);
}
public int findHandCard(HandCard hc)
{
for (int i = 0; i < hand.Length; i++)
{
if (hand[i] == hc)
{
return(i);
}
}
return(-1);
}
public void startGame()
{
foreach (PlayerScript player in players)
{
for (int i = 0; i < STARTING_HAND_SIZE; i++)
{
HandCard moveDest = player.addCard(deck.drawCard());
}
player.begin();
}
}
// Checks if player has enough mana and card is not on cooldown
public bool ValidateCardPlay(HandCard card, Player currentPlayer)
{
if (currentPlayer.CheckMana(card.GetCurrentManaCost()) && card.GetCurrentCooldown() == 0)
{
return(true);
}
else
{
return(false);
}
}
void exeDoubling(RaycastHit hit)
{
if (hit.transform.tag == "HandCard" && hit.transform.GetComponent <HandCard>().getCard() != null &&
!hit.transform.GetComponent <HandCard>().getOwner().isCambrio())
{
control.unhighlightPlayerCardsExcept(null);
doubleSpot = hit.transform.GetComponent <HandCard>(); //need to remember the spot across calls
Card doubleCard = doubleSpot.getCard();
if (doubleCard.getNum() == discard.peekTop().getNum())
{
this.CmdDiscardCard(doubleCard.gameObject);
int handInd = doubleSpot.getOwner().findHandCard(doubleSpot);
doubleSpot.getOwner().CmdSetCard(handInd, null); //remove card from handcard
if (doubleSpot.getOwner() != this)
{
CmdUpdateMode(Modes.REPLACING);
this.highlightHand();
//Debug.Log("replacing");
}
else
{
CmdUpdateMode(oldMode);
revertBoardState();
}
}
else //double incorrect, add top of discard to player's empty spot
{
this.CmdRevealOtherPlayerHandCard(doubleSpot.getOwner().gameObject, doubleSpot.getOwner().findHandCard(doubleSpot));
int moveDestInd = FindEmptyHandCard();
if (moveDestInd == -1) //no more empty spots, so you lose
{
this.CmdUpdateMode(Modes.OUT);
this.CmdRevealHand();
this.CmdNextPlayer();
}
else
{
this.CmdSetCard(moveDestInd, discard.peekTop().gameObject);
this.CmdPopDiscard();
CmdUpdateMode(oldMode);
revertBoardState();
}
}
}
else if (hit.transform.tag == "Discard")
{
CmdUpdateMode(oldMode);
control.unhighlightPlayerCardsExcept(null);
revertBoardState();
//Debug.Log(oldMode);
}
}
public static void discardRandom(Player p, int num)
{
for (int i = 0; i < num; i++)
{
if (p.hand.Count > 0)
{
int choice = Random.Range(0, p.hand.Count);
HandCard c = p.hand[choice];
p.hand.Remove(c);
GameObject.Destroy(c.gameObject);
}
}
}
// this method is not used yet, as initial card excchange has not been implemented
public void ChooseCardExchange(HandCard selectedCard, int tableId)
{
GameTable actualGameTable = GameTableService.GetTable(Games, tableId);
User actualUser = actualGameTable.Participations.Find(participation => participation.Participant.Identifier == Context.User.Identity.Name).Participant;
actualGameTable.CardServiceData.CardExchange(actualUser, ref actualGameTable, selectedCard);
User partnerUser = ParticipationService.GetPartner(actualUser, actualGameTable.Participations);
partnerUser.ConnectionIds.ForEach(id =>
{
Clients.Client(id).exchangeCard(selectedCard);
});
}
// ETHAN: function that helps flip back the selected two cards with a delay
IEnumerator flipBack(HandCard hand1, HandCard hand2)
{
yield return(new WaitForSeconds(FLIP_TIME));
if (hand1 != null && hand1.getCard() != null)
{
hand1.getCard().flipDown(); //guarantees it always flip down and not up
}
if (hand2 != null && hand2.getCard() != null)
{
hand2.getCard().flipDown();
}
}
public string CompareHandCards(string handCardA, string handCardB)
{
var serviceProvider = SetDI();
var cardListA = Common.ConvertCardStringToList(handCardA);
var cardListB = Common.ConvertCardStringToList(handCardB);
var bridge = serviceProvider.GetService <Compare>();
var blackGroup = new HandCard(GroupTypes.Black, cardListA, bridge.DistinguishCardTypes(cardListA));
var whiteGroup = new HandCard(GroupTypes.White, cardListB, bridge.DistinguishCardTypes(cardListB));
return(bridge.CompareWith(blackGroup, whiteGroup));
}
public async Task <ResponseGetExtraCardGameView> GetExtraCard(RequestGetExtraCardGameView requestGetExtraCardGameView)
{
Game game = await _gameRepository.GetGameWithPlayerGames(requestGetExtraCardGameView.GameId);
Hand hand = await _handRepository.GetWithCards(requestGetExtraCardGameView.HandId);
if (game == null || hand == null)
{
var stringBuilder = new StringBuilder();
stringBuilder.AppendLine(string.Format("GameId: {0}", requestGetExtraCardGameView.GameId));
stringBuilder.AppendLine(string.Format("HandId: {0}", requestGetExtraCardGameView.HandId));
stringBuilder.AppendLine(string.Format("Message: {0}", SolutionConstants.BUSINESS_LOGIC_GET_ITEM_EXCEPTION_MESSAGE));
string message = stringBuilder.ToString();
throw new BusinessLogicGetItemException(message);
}
Deck infinityDeck = await _deckProvider.GetAllDeckFromCache(game.Id);
List <Card> handCards = hand.HandCards.Select(item => item.Card).ToList();
Card card = DeckExtension.GetCard(infinityDeck);
_deckProvider.SetDeckInMemoryCashe(game.Id, infinityDeck);
handCards.Add(card);
hand.Summary = _gameUtility.CalculateCardsSumm(handCards);
hand.VictoryType = _gameUtility.CheckTypeOfVictory(handCards);
var handCard = new HandCard();
handCard.CardId = card.Id;
handCard.HandId = hand.Id;
await _handCardRepository.Create(handCard);
await _handRepository.Update(hand);
ResponseGetExtraCardGameViewItem responseViewItem = _mapper.Map <Card, ResponseGetExtraCardGameViewItem>(card);
var responseView = new ResponseGetExtraCardGameView();
responseView.Card = responseViewItem;
responseView.Summary = hand.Summary;
return(responseView);
}
public bool FlipNextCard(Hand hand, List <Sprite> textures)
{
for (int i = 0; i < 3; i++)
{
Image image = cards[i];
if (image.sprite == textures[52])
{
HandCard card = hand.HandCards[i];
FlipOneCard(image, card, textures, 0, 0.25f);
return(i == 2);
}
}
return(true);
}
public void GetFullRank(
Hand h,
IEnumerable<Card> wildCards,
out FullRank fRank,
out HandCard[] hcsRank,
out HandCard[] hcsFill)
{
Contract.Requires(h.Cards.Count() >= NumCardsInFinalHand, "Error: Not enough cards in hand for ranking");
foreach (HandCard hc in h.Cards)
{
hc.TamedValue = TValue.NoValue;
hc.TamedSuit = TSuit.NoSuit;
}
HandInfo hi = new HandInfo(h, wildCards);
foreach (Ranker.RankPredicate rankPredicate in rankPredicates)
{
if (rankPredicate(hi, out fRank, out hcsRank, out hcsFill))
{
return;
}
}
// If HighCard is one of the RankPredicates, we should never arrive here.
fRank = new FullRank();
hcsRank = null;
hcsFill = null;
}
public void RemoveCardFromHand (HandCard card) {
hand.Remove(card);
}
public void AddCardToHand (HandCard card) {
hand.Add(card);
}
private bool isStraightN(HandInfo hi, out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill, int n)
{
return isStraightOrStraightFlushN(hi, out fRank, out hcsRank, out hcsFill, false, n);
}
private bool isStraightOrStraightFlushN(HandInfo hi, out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill, bool isFlushRequired, int n)
{
bool isStraight = false;
bool isStraightFlush = false;
TValue minVal = TValue.NoValue; // Suppress compiler warning
TValue maxVal;
IEnumerable<IGrouping<TValue, HandCard>> valueGroups = null;
TSuit flushSuit = TSuit.NoSuit;
// Note: The loop could be started at Max(hcsPlain.Value) + hi.UnboundCount()
for (maxVal = TValue.Ace;
maxVal >= (TValue)n; // TValue.Five
maxVal = maxVal.Prev())
{
minVal = maxVal.Prev(n - 1);
valueGroups = hi.CardsPlain
.Where(hc => (hc.Value >= minVal && hc.Value <= maxVal) || (minVal == TValue.LowAce && hc.Value == TValue.Ace))
.GroupBy(hc => hc.Value);
isStraight = valueGroups.Count() >= n - hi.UnboundCount();
if (isStraight && isFlushRequired)
{
foreach (TSuit s in Card.Suits)
{
if (valueGroups.All(grp => grp.Any(hc => hc.Suit == s)))
{
flushSuit = s;
isStraightFlush = true;
break;
}
}
}
if (isStraight && (isStraightFlush || !isFlushRequired)) { break; }
}
if (!isStraight || (isFlushRequired && !isStraightFlush))
{
setToNull(out fRank, out hcsRank, out hcsFill);
return false;
}
Func<HandCard, bool> pred = null;
if (isFlushRequired)
{
pred = hc => hc.Suit == flushSuit;
}
IEnumerable<HandCard> hcsAvail = valueGroups.EnumerableChoice(pred);
hcsRank = new HandCard[n];
hcsFill = new HandCard[NumCardsInFinalHand - n];
int index = 0;
List<HandCard> hcsUnbound = new List<HandCard>(hi.CardsUnbound); // Need random access
for (TValue val = minVal; val <= maxVal; val = val.Next())
{
HandCard nextCard = hcsAvail.Where(hc => hc.Value == val).FirstOrDefault();
if (nextCard != null)
{
hcsRank[index] = nextCard;
}
else
{
Debug.Assert(hcsUnbound.Count > 0, "Error: Not enough cards to form straight");
IEnumerable<HandCard> hcDesired = hcsUnbound.Where(hc => hc.Value == val).Take(1);
if (hcDesired.Count() > 0)
{
hcsRank[index] = hcDesired.ElementAt(0);
hcsUnbound.Remove(hcsRank[index]);
}
else
{
hcsRank[index] = hcsUnbound[0];
hcsUnbound.RemoveAt(0);
}
hcsRank[index].TamedValue = val;
if (isFlushRequired) { hcsRank[index].TamedSuit = flushSuit; }
}
index++;
}
fRank = new FullRank(
isFlushRequired
? SimpleRank.StraightFlush5
: SimpleRank.Straight5,
Enumerable.Range((int)minVal, ((int)maxVal - (int)minVal) + 1)
.OrderByDescending(x => x)
.Select(x => (TValue) x)
.ToArray()
);
return true;
}
private bool isStraightFlush5(HandInfo hi, out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill)
{
return isStraightOrStraightFlushN(hi, out fRank, out hcsRank, out hcsFill, true, 5);
}
private static void setToNull(out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill)
{
fRank = null;
hcsRank = null;
hcsFill = null;
}
private bool isFlush4(HandInfo hi, out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill)
{
return isFlushN(hi, out fRank, out hcsRank, out hcsFill, 4);
}
private bool isKindN(
HandInfo hi,
out FullRank fRank,
out HandCard[] hcsRank,
out HandCard[] hcsFill,
int n,
int maxFillCount = int.MaxValue)
{
Contract.Requires(n >= 2 && n <= 5, String.Format("Error: Unrecognized n-of-a-kind: {0:d}", n));
bool hasKindN = (!hi.HasPlainCards() && hi.UnboundCount() >= n)
|| (hi.ValueGram.Values.Max() >= n - hi.UnboundCount());
if (!hasKindN)
{
setToNull(out fRank, out hcsRank, out hcsFill);
return false;
}
TValue kindVal;
int numChosen;
HandCard[] hcsChosen;
var plainValues = hi.ValueGram.Keys;
if (plainValues.Count() == 0)
{
kindVal = TValue.Ace;
numChosen = 0;
hcsChosen = new HandCard[0];
}
else
{
kindVal = plainValues.Where(val => hi.ValueGram[val] >= n - hi.UnboundCount()).Max();
HandCard[] hcsAvail = hi.CardsPlain.Where(hc => hc.Value == kindVal).ToArray();
numChosen = Math.Min(n, hcsAvail.Count());
hcsChosen = hcsAvail.Take(numChosen).ToArray();
}
int numTamed = Math.Min(n - numChosen, hi.UnboundCount());
HandCard[] hcsTamed = hi.CardsUnbound.Take(numTamed).ToArray();
foreach (HandCard hc in hcsTamed) { hc.TamedValue = kindVal; }
List<HandCard> fillTamed;
List<HandCard> fillPlain;
Util.TakeFill(Math.Min(NumCardsInFinalHand - n, maxFillCount),
hi.CardsUnbound.Except(hcsTamed).OrderByDescending(hc => hc.Value),
out fillTamed,
hi.CardsPlain.Except(hcsChosen).OrderByDescending(hc => hc.Value),
out fillPlain);
foreach (HandCard hc in fillTamed) { hc.TamedValue = TValue.Ace; }
SimpleRank sRank;
switch (n)
{
case 5: sRank = SimpleRank.Kind5; break;
case 4: sRank = SimpleRank.Kind4; break;
case 3: sRank = SimpleRank.Kind3; break;
case 2: sRank = SimpleRank.Kind2; break;
default: throw new ArgumentException("n");
}
fRank = new FullRank(sRank,
Util.SingletonEnumerable(kindVal)
.Concat(fillTamed.Select(hc => hc.TamedValue))
.Concat(fillPlain.Select(hc => hc.Value))
);
hcsRank = hcsChosen.Concat(hcsTamed).ToArray();
hcsFill = fillTamed.Concat(fillPlain).ToArray();
return true;
}
private bool isKind5(HandInfo hi, out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill)
{
return isKindN(hi, out fRank, out hcsRank, out hcsFill, 5);
}
private bool isFlushN(HandInfo hi, out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill, int n)
{
Contract.Requires(n >= 4 && n <= 5, String.Format("Error: Unrecognized flush size: {0:d}", n));
bool hasFlushN = (!hi.HasPlainCards() && hi.UnboundCount() >= n)
|| (hi.SuitGram.Values.Max() >= n - hi.UnboundCount());
if (!hasFlushN)
{
setToNull(out fRank, out hcsRank, out hcsFill);
return false;
}
TSuit flushSuit;
int numChosen = 0;
IEnumerable<HandCard> hcsChosen;
if (!hi.HasPlainCards())
{
flushSuit = Card.Suits.First(); // Any suit will do
numChosen = 0;
hcsChosen = new HandCard[0];
}
else
{
var sg = hi.SuitGram;
// Note: suits can only have Length > 1 if the hand has >= 2 * numCardsInFullHand cards.
TSuit[] candidateSuits = sg.Keys.Where(s => sg[s] >= n - hi.UnboundCount()).ToArray();
if (candidateSuits.Length == 1)
{
flushSuit = candidateSuits[0];
}
else
{ // Determine which suit is best
var cardSeqEnum = candidateSuits
.Select(s => hi.CardsPlain
.Where(hc => hc.Suit == s)
.OrderByDescending(hc => hc.Value));
var cardSeqOrd = cardSeqEnum
.OrderByDescending(hcs => (IEnumerable<HandCard>) hcs,
new EnumerableComparer<HandCard>());
var cardSeq = cardSeqOrd.First();
flushSuit = cardSeq.First().Suit;
}
HandCard[] hcsAvail = hi.CardsPlain.Where(hc => hc.Suit == flushSuit).ToArray();
numChosen = Math.Min(n, hcsAvail.Count());
hcsChosen = hcsAvail.OrderByDescending(hc => hc.Value).Take(numChosen);
}
HandCard[] hcsTamed = hi.CardsUnbound.Take(n - numChosen).ToArray();
foreach (HandCard hcs in hcsTamed)
{
hcs.TamedValue = TValue.Ace;
hcs.TamedSuit = flushSuit;
}
List<HandCard> fillTamed;
List<HandCard> fillPlain;
Util.TakeFill(NumCardsInFinalHand - n,
hi.CardsUnbound.Except(hcsTamed), out fillTamed,
hi.CardsPlain.Except(hcsChosen), out fillPlain);
foreach (HandCard hcs in fillTamed) { hcs.TamedValue = TValue.Ace; }
; SimpleRank sRank;
switch (n)
{
case 4: sRank = SimpleRank.Flush4; break;
case 5: sRank = SimpleRank.Flush5; break;
default: throw new ApplicationException(String.Format(
String.Format("Error: Unrecognized flush size: {0:d}", n)));
};
fRank = new FullRank(sRank,
hcsTamed.Select(hc => hc.TamedValue)
.Concat(hcsChosen.Select(hc => hc.Value).OrderByDescending(v => v))
.Concat(fillTamed.Select(hc => hc.TamedValue))
.Concat(fillPlain.Select(hc => hc.Value).OrderByDescending(v => v)));
hcsRank = hcsChosen.Concat(hcsTamed).ToArray();
hcsFill = fillTamed.Concat(fillPlain).ToArray();
return true;
}
private bool isTwoPair(HandInfo hi, out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill)
{
// Note: In the presence of wild cards, any hand with two pair
// would also have a higher rank (e.g., 3 of a kind).
FullRank fRank1;
HandCard[] hcsRank1;
HandCard[] hcsFill1;
if (!isKindN(hi, out fRank1, out hcsRank1, out hcsFill1, 2, 0))
{
setToNull(out fRank, out hcsRank, out hcsFill);
return false;
}
TValue value1 = fRank1.Values[0];
FullRank fRank2;
HandCard[] hcsRank2;
HandInfo hi2 = new HandInfo(new Hand(hi.CardsAll.Except(hcsRank1)), hi.WildCards());
if (!isKindN(hi2, out fRank2, out hcsRank2, out hcsFill, 2, NumCardsInFinalHand - 4))
{
setToNull(out fRank, out hcsRank, out hcsFill);
return false;
}
TValue value2 = fRank2.Values[0];
TValue[] fillValues = hcsFill
.Select(hc => hc.TamedValue == TValue.NoValue ? hc.Value : hc.TamedValue)
.ToArray();
IEnumerable<TValue> vals = Util.PairEnumerable(value1, value2).Concat(fillValues);
fRank = new FullRank(SimpleRank.TwoPair, vals);
hcsRank = hcsRank1.Concat(hcsRank2).ToArray();
return true;
}
private bool isFullHouse(HandInfo hi, out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill)
{
FullRank fRankTrio;
HandCard[] hcsRankTrio;
HandCard[] hcsFillTrio;
if (!isKindN(hi, out fRankTrio, out hcsRankTrio, out hcsFillTrio, 3, 0))
{
setToNull(out fRank, out hcsRank, out hcsFill);
return false;
}
TValue trioValue = fRankTrio.Values[0];
FullRank fRankPair;
HandCard[] hcsRankPair;
HandInfo hi2 = new HandInfo(new Hand(hi.CardsAll.Except(hcsRankTrio)), hi.WildCards());
if (!isKindN(hi2, out fRankPair, out hcsRankPair, out hcsFill, 2, NumCardsInFinalHand - 3 - 2))
{
setToNull(out fRank, out hcsRank, out hcsFill);
return false;
}
TValue pairValue = fRankPair.Values[0];
fRank = new FullRank(SimpleRank.FullHouse,
Util.PairEnumerable(trioValue, pairValue).Concat(hcsFill.Select(hc => TValue.Ace)));
hcsRank = hcsRankTrio.Concat(hcsRankPair).ToArray();
return true;
}
private bool isHighCard(HandInfo hi, out FullRank fRank, out HandCard[] hcsRank, out HandCard[] hcsFill)
{
// Note: Any hand with 2+ cards and at least one wild card contains a pair.
hcsRank = new HandCard[0];
List<HandCard> fillTamed;
List<HandCard> fillPlain;
Util.TakeFill(NumCardsInFinalHand, hi.CardsUnbound, out fillTamed,
hi.CardsPlain.OrderByDescending(hc => hc.Value), out fillPlain);
foreach (HandCard hc in fillTamed) { hc.TamedValue = TValue.Ace; }
hcsFill = fillPlain.Reverse<HandCard>().Concat(fillTamed).ToArray();
TValue[] vals = fillTamed
.Select(hc => hc.TamedValue)
.Concat(fillPlain.Select(hc => hc.Value))
.ToArray();
fRank = new FullRank(SimpleRank.HighCard, vals);
return true;
}
