public override void Auto(CardState cs, Card ownerEffect)
 {
     if(cs == CardState.EndTurn)
     {
         bCanUseAct1 = true;
     }
 }

 /// <summary>
 /// True if all three cards are the same shading,
 /// or all three cards have different shadings from each other.
 /// </summary>
 public static bool IsShadingMatch(Card firstCard, Card secondCard, Card thirdCard)
 {
     return (firstCard.Shading == secondCard.Shading && firstCard.Shading == thirdCard.Shading)
            ||
            (firstCard.Shading != secondCard.Shading && firstCard.Shading != thirdCard.Shading &&
             secondCard.Shading != thirdCard.Shading);
 }

        public static double PreFlop(Card firstCard, Card secondCard)
        {
            int row = 13 - ((int)firstCard.Type - 1);
            int col = 13 - ((int)secondCard.Type - 1);

            return StartingHandRecommendationPercentage[row, col];
        }

 public override void Auto(CardState cs, Card ownerEffect)
 {
     if(cs == CardState.Attacking)
     {
         if(GetDefensor().IsVanguard()
            && NumUnits(delegate(Card c) { return true; }) > NumEnemyUnits(delegate(Card c) { return true; })
            && LimitBreak(4)
            && CB(1, delegate(Card c) { return c.name.Contains("Revenger"); })
            && VC())
         {
             bUseAuto1 = true;
             DisplayConfirmationWindow();
         }
     }
     else if(cs == CardState.BeginMain)
     {
         if(VC ()
            && NumUnits (delegate(Card c) { return c.BelongsToClan("Shadow Paladin"); }) > 0
            && NumEnemyUnits(delegate(Card c) { return true; }) > 0)
         {
             bUseAuto2 = true;
             DisplayConfirmationWindow();
         }
     }
 }

 /// <summary>
 /// True if all three cards are the same color,
 /// or all three cards have different colors from each other.
 /// </summary>
 public static bool IsColorMatch(Card firstCard, Card secondCard, Card thirdCard)
 {
     return (firstCard.Color == secondCard.Color && firstCard.Color == thirdCard.Color)
            ||
            (firstCard.Color != secondCard.Color && firstCard.Color != thirdCard.Color &&
             secondCard.Color != thirdCard.Color);
 }

        public static CardValuationType CalculateRisk(Card leftCard, Card rightCard, IReadOnlyCollection<Card> communityCard)
        {
            List<Card> cards = new List<Card>(communityCard);
            cards.Add(leftCard);
            cards.Add(rightCard);

            var handRankType = Helpers.GetHandRank(cards);

            switch (handRankType)
            {
                case HandRankType.Pair:
                    return CardValuationType.Risky;
                case HandRankType.TwoPairs:
                    return CardValuationType.Recommended;
                case HandRankType.ThreeOfAKind:
                case HandRankType.Straight:
                    return CardValuationType.VeryRecommended;
                case HandRankType.Flush:
                case HandRankType.FullHouse:
                case HandRankType.FourOfAKind:
                    return CardValuationType.VeryPowerful;
                case HandRankType.StraightFlush:
                    return CardValuationType.AllIn;
                default:
                    return CardValuationType.Unplayable;
            }
        }

        public void ShouldReturn6ForNumberValueAndHForSuit()
        {
            Card c = new Card("6H");

            Assert.Equal(6, c.NumberValue);
            Assert.Equal("H", c.Suit);
        }

 public void ToStringAceSpades()
 {
     Card card = new Card(CardFace.Ace, CardSuit.Spades);
     var excpected = "A♠";
     var actual = card.ToString();
     Assert.AreEqual(excpected, actual);
 }

        public async Task<IHttpActionResult> PutCard(int id, Card card)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != card.Id)
            {
                return BadRequest();
            }

            db.Entry(card).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!CardExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

 public void ToStringTwoClubs()
 {
     Card card = new Card(CardFace.Two, CardSuit.Clubs);
     var excpected = "2♣";
     var actual = card.ToString();
     Assert.AreEqual(excpected, actual);
 }

 public void ToStringJackHearts()
 {
     Card card = new Card(CardFace.Jack, CardSuit.Hearts);
     var excpected = "J♥";
     var actual = card.ToString();
     Assert.AreEqual(excpected, actual);
 }

        public void CreatingTwoSameCardsAndInvokingEqualsShouldReturnThatCardsAreEqual()
        {
            var card = new Card(CardFace.Ace, CardSuit.Hearts);
            var anotherCard = new Card(CardFace.Ace, CardSuit.Hearts);

            Assert.IsTrue(card.Equals(anotherCard));
        }

        public void CreatingTwoDifferentCardsAndInvokingEqualsShouldReturnThatCardsAreNotEqual()
        {
            var card = new Card(CardFace.Ace, CardSuit.Hearts);
            var anotherCard = new Card(CardFace.Ace, CardSuit.Clubs);

            Assert.IsFalse(card.Equals(anotherCard));
        }

        public void CreatingACardAndInvokingToStringToItShouldReturnCorrectString()
        {
            var card = new Card(CardFace.Ace, CardSuit.Hearts);
            var expectedValue = "Ace of Hearts";

            Assert.AreEqual(expectedValue, card.ToString());
        }

    public override void Update()
    {
        DelayUpdate(delegate {
            if(GetBool(1))
            {
                if(currentCard.BelongsToClan(OwnerCard.clan))
                {
                    FromDeckToGuardianCircle(currentCard);
                }
                else
                {
                    SendCardFromDeckToDrop();
                    ResolveQuintetWallNextCard();
                }
            }
            else
            {
                CounterBlast(1,
                             delegate {
                    numCardsToCall = 5;
                });
            }
        });

        FromDeckToGuardianCircleUpdate(delegate {
            ResolveQuintetWallNextCard();
        });

        if(numCardsToCall > 0 && !GetBool(1))
        {
            SetBool(1);
            currentCard = RevealTopCard();
            Delay(0.8f);
        }
    }

 public override void Auto(CardState cs, Card effectOwner)
 {
     if(cs == CardState.EndTurn)
     {
         _AuxBool = false;
     }
 }

 // Overlay hooks
 public void PreOverlayRender(Card card)
 {
     CardType type = allCardTypes[card.typeId];
     if( origNames.ContainsKey(type.id) ) {
         type.name = origNames[type.id];
     }
 }

 public override Unit PlayCardOnHex(Card card, Hex hex, string id)
 {
     CardHistory.Add(card);
     GuiControl.AddCardToHistory(card);
     // TODO Clean up this method to better handle multiple card types.
     if(typeof(EntityCard).IsAssignableFrom(card.GetType())) {
         EntityCard eCard = (EntityCard) card;
         GameObject go = (GameObject) Instantiate(UnitPrefab, Vector3.zero, Quaternion.identity);
         Unit unit = go.GetComponent<Unit>();
         unit.Id = id;
         unit.FromCard(eCard);
         unit.Hex = hex;
         unit.transform.position = hex.transform.position;
         hex.Unit = unit;
         Units.Add(unit);
         unit.Team = MyTurn() ? Team.ME : Team.ENEMY;
         if(MyTurn() && ThisPlayer.Hand.Count != 0) {
             // TODO Find a better way to sort this
             ThisPlayer.PlayCard();
         }
         card.OnPlay(new StateObject(Units, hex, null, MyTurn() ? ThisPlayer : EnemyPlayer, MyTurn() ? EnemyPlayer : ThisPlayer));
         return unit;
     } else {
         if(MyTurn() && ThisPlayer.Hand.Count != 0) {
             // TODO Find a better way to sort this
             ThisPlayer.PlayCard();
         }
         card.OnPlay(new StateObject(Units, hex, null, MyTurn() ? ThisPlayer : EnemyPlayer, MyTurn() ? EnemyPlayer : ThisPlayer));
         return null;
     }
 }

        public void ShouldReturn12ForNumberValueAndCForSuit()
        {
            Card c = new Card("QC");

            Assert.Equal(12, c.NumberValue);
            Assert.Equal("C", c.Suit);
        }

 private string handstring(Card[] hand)
 {
     return
         hand.Select(c => Ranks[c.Rank] + "" + Suits[(int) c.Suit])
             .Aggregate("", (h, c) => h + " " + c)
             .Remove(0, 1);
 }