Exemplo n.º 1
0
    public void SetGotCards(Card[] cardsToDisplay)
    {
        boosterCards = cardsToDisplay;

        largeBooster.FindChild("BoosterIcon").GetComponent<Image>().color =
            Card.FindColor(cardsToDisplay[0].cardElement);

        largeBooster.GetComponent<Animator>().SetTrigger("Opening");

        int i = 0;

        foreach (Card c in cardsInScene)
        {
            Rarity tempRarity = boosterCards[i].rarity;
            Sprite bg = CardHandler.instance.SelectCardBackground(boosterCards[i].cardElement);
            Sprite rarity = CardHandler.instance.rarityImages[tempRarity];

            c.SetAll(boosterCards[i]);
            c.SetBackground(bg);
            c.SetText();
            c.SetMediumImage();
            c.SetRarity(rarity);
            CardHandler.instance.SetCard(true, boosterCards[i].cardName);
            i++;
        }
    }
 public override void Auto(CardState cs, Card effectOwner)
 {
     if(cs == CardState.EndTurn)
     {
         SetAttackType(AttackType.NONE);
     }
 }
Exemplo n.º 3
0
 /// <summary>
 /// True if all three cards are the same shape,
 /// or all three cards have different shapes from each other.
 /// </summary>
 public static bool IsShapeMatch(Card firstCard, Card secondCard, Card thirdCard)
 {
     return (firstCard.Shape == secondCard.Shape && firstCard.Shape == thirdCard.Shape)
            ||
            (firstCard.Shape != secondCard.Shape && firstCard.Shape != thirdCard.Shape &&
             secondCard.Shape != thirdCard.Shape);
 }
 public override void Auto(CardState cs, Card ownerEffect)
 {
     if(cs == CardState.EndTurn)
     {
         bCanUseAct1 = true;
     }
 }
Exemplo n.º 5
0
        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];
        }
Exemplo n.º 6
0
 /// <summary>
 /// True if all three cards are the same number,
 /// or all three cards have different numbers from each other.
 /// </summary>
 public static bool IsNumberMatch(Card firstCard, Card secondCard, Card thirdCard)
 {
     return (firstCard.Number == secondCard.Number && firstCard.Number == thirdCard.Number)
            ||
            (firstCard.Number != secondCard.Number && firstCard.Number != thirdCard.Number &&
             secondCard.Number != thirdCard.Number);
 }
Exemplo n.º 7
0
 /// <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);
 }
Exemplo n.º 8
0
 public void CloneShouldReturnObjectWithTheSameHashCode()
 {
     var card = new Card(CardSuit.Spade, CardType.Nine);
     var newCard = card.DeepClone();
     Assert.IsNotNull(newCard);
     Assert.AreEqual(card.GetHashCode(), newCard.GetHashCode());
 }
Exemplo n.º 9
0
 /// <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);
 }
Exemplo n.º 10
0
    private void BuildDeck()
    {
        int totalRobots = 4;
        Card card;
        int id = 0;

        for (int i = 0; i < totalRobots; i++)
        {
            List<string> robotParts = new List<string>();
            robotParts.Add("Head");
            robotParts.Add("Arm");
            robotParts.Add("Leg");
            for (int j = 0; j < 2; j++)
            {
                int pos = Random.Range(0, robotParts.Count);
                string theMissingPart = robotParts[pos];

                robotParts.RemoveAt(pos);

                card = new Card("robot" + (i + 1) + "Missing" + theMissingPart, id);
                cards.Add(card);

                card = new Card("robot" + (i + 1) + theMissingPart, id);
                cards.Add(card);
                id++;
            }
        }

        cards.Shuffle();
    }
 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();
         }
     }
 }
Exemplo n.º 12
0
        public void ShouldReturn12ForNumberValueAndCForSuit()
        {
            Card c = new Card("QC");

            Assert.Equal(12, c.NumberValue);
            Assert.Equal("C", c.Suit);
        }
Exemplo n.º 13
0
        public void ShouldReturn6ForNumberValueAndHForSuit()
        {
            Card c = new Card("6H");

            Assert.Equal(6, c.NumberValue);
            Assert.Equal("H", c.Suit);
        }
Exemplo n.º 14
0
 // Overlay hooks
 public void PreOverlayRender(Card card)
 {
     CardType type = allCardTypes[card.typeId];
     if( origNames.ContainsKey(type.id) ) {
         type.name = origNames[type.id];
     }
 }
Exemplo n.º 15
0
        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;
            }
        }
Exemplo n.º 16
0
 protected override int ReadFromByteArray(ByteArrayReader reader)
 {
     base.ReadFromByteArray(reader);
     CardIndex = reader.ReadInt32();
     Card = reader.Read<Card>();
     return reader.Index;
 }
Exemplo n.º 17
0
    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);
        }
    }
Exemplo n.º 18
0
 public MoveCard(Player who, Card card, Group to, int idx, bool faceUp)
 {
     this.who = who; this.card = card;
     this.to = to; this.from = card.Group;
     this.idx = idx;
     this.faceUp = faceUp;
 }
Exemplo n.º 19
0
    public GameObject CreateGameCharacterCard(GameManager.GameSide side, Card cardData)
    {
        if (Global.Instance.scene == SceneType.GameScene)
        {
            //实例化卡牌
            GameObject prefeb = Resources.Load<GameObject>("CharacterCard");
            GameObject parent = GameObject.Find("GamePanel/" + side.ToString() + "side/CardGrid");
            GameObject card = NGUITools.AddChild(parent, prefeb);

            CardContainer container = card.GetComponent<CardContainer>();
            container.SetCardData(cardData);//设置卡片属性
            container.UpdateCardUI();//更新贴图
            uiManager.AddCharacterUIListener(card, side);//添加UI事件监听
            container.SetGameSide(side);//设置卡片归属方

            parent.GetComponent<UIGrid>().Reposition();//更新卡片位置

            return card;
        }
        else
        {
            LogsSystem.Instance.Print("不能在非游戏界面生成游戏卡牌", LogLevel.WARN);
            return null;
        }
    }
Exemplo n.º 20
0
 private string handstring(Card[] hand)
 {
     return
         hand.Select(c => Ranks[c.Rank] + "" + Suits[(int) c.Suit])
             .Aggregate("", (h, c) => h + " " + c)
             .Remove(0, 1);
 }
    public override void Auto(CardState cs, Card ownerEffect)
    {
        if(cs == CardState.Attacking)
        {
            if(GetDefensor().IsVanguard())
            {
                SetBool(1);
            }
        }
        else if(cs == CardState.EndBattle)
        {
            if(VC ()
               && LimitBreak(4)
               && CB(2)
               && IsInHand(OwnerCard.cardID)
               && GetBool(1)
               && NumUnitsInSoul(delegate(Card c) { return true; }) > 0)
            {
                DisplayConfirmationWindow();
            }

            UnsetBool(1);
        }
        else if(cs == CardState.IsBoosted)
        {
            if(VC ()
               && OwnerCard.IsBoostedBy.BelongsToClan("Pale Moon"))
            {
                IncreasePowerByBattle(OwnerCard, 3000);
            }
        }
    }
Exemplo n.º 22
0
 public override void Auto(CardState cs, Card effectOwner)
 {
     if(cs == CardState.EndTurn)
     {
         _AuxBool = false;
     }
 }
Exemplo n.º 23
0
 public void ToStringAceSpades()
 {
     Card card = new Card(CardFace.Ace, CardSuit.Spades);
     var excpected = "A♠";
     var actual = card.ToString();
     Assert.AreEqual(excpected, actual);
 }
Exemplo n.º 24
0
 public void ToStringTwoClubs()
 {
     Card card = new Card(CardFace.Two, CardSuit.Clubs);
     var excpected = "2♣";
     var actual = card.ToString();
     Assert.AreEqual(excpected, actual);
 }
Exemplo n.º 25
0
 public void ToStringJackHearts()
 {
     Card card = new Card(CardFace.Jack, CardSuit.Hearts);
     var excpected = "J♥";
     var actual = card.ToString();
     Assert.AreEqual(excpected, actual);
 }
Exemplo n.º 26
0
        public void CreatingTwoDifferentCardsAndInvokingEqualsShouldReturnThatCardsAreNotEqual()
        {
            var card = new Card(CardFace.Ace, CardSuit.Hearts);
            var anotherCard = new Card(CardFace.Ace, CardSuit.Clubs);

            Assert.IsFalse(card.Equals(anotherCard));
        }
Exemplo n.º 27
0
        public void CreatingTwoSameCardsAndInvokingEqualsShouldReturnThatCardsAreEqual()
        {
            var card = new Card(CardFace.Ace, CardSuit.Hearts);
            var anotherCard = new Card(CardFace.Ace, CardSuit.Hearts);

            Assert.IsTrue(card.Equals(anotherCard));
        }
Exemplo n.º 28
0
        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);
        }
Exemplo n.º 29
0
        public void CreatingACardAndInvokingToStringToItShouldReturnCorrectString()
        {
            var card = new Card(CardFace.Ace, CardSuit.Hearts);
            var expectedValue = "Ace of Hearts";

            Assert.AreEqual(expectedValue, card.ToString());
        }
 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;
     }
 }
Exemplo n.º 31
0
 public override bool MayInclude(Card card)
 {
     return card.IsDrawCard();
 }
 public CelestialAuraCardController(Card card, TurnTakerController turnTakerController) : base(card, turnTakerController)
 {
     SpecialStringMaker.ShowListOfCards(new LinqCardCriteria((Card c) => c.IsTarget && c.IsHero && IsNextToConstellation(c), useCardsSuffix: false, singular: "hero target next to a constellation", plural: "hero targets next to a constellation"));
 }
Exemplo n.º 33
0
 public void AddCardToExtra(Card card)
 {
     extraDeck.AddCard(card);
 }
Exemplo n.º 34
0
 public void AddCardToExtra(string id)
 {
     Card card = CardFactroy.GenerateCard(id);
     extraDeck.AddCard(card);
 }
Exemplo n.º 35
0
 public void AddCardToMain(string id)
 {
     Card card = CardFactroy.GenerateCard(id);
     mainDeck.AddCard(card);
 }
Exemplo n.º 36
0
 public void AddCardToMain(Card card)
 {
     mainDeck.AddCard(card);
 }
Exemplo n.º 37
0
        private async void SendExecute()
        {
            var save = _isSave ?? false;

            if (_paymentForm.HasSavedCredentials && !save && _paymentForm.IsCanSaveCredentials)
            {
                _paymentForm.HasSavedCredentials = false;
                _paymentForm.SavedCredentials    = null;

                ApplicationSettings.Current.TmpPassword = null;
                ProtoService.ClearSavedInfoAsync(false, true, null, null);
            }

            var month = 0;
            var year  = 0;

            if (_date != null)
            {
                var args = _date.Split('/');
                if (args.Length == 2)
                {
                    month = int.Parse(args[0]);
                    year  = int.Parse(args[1]);
                }
            }

            var card = new Card(
                _card,
                month,
                year,
                _cvc,
                _cardName,
                null, null, null, null,
                _postcode,
                _selectedCountry?.Code?.ToUpper(),
                null);

            if (!card.ValidateNumber())
            {
                RaisePropertyChanged("CARD_NUMBER_INVALID");
                return;
            }
            if (!card.ValidateExpireDate())
            {
                RaisePropertyChanged("CARD_EXPIRE_DATE_INVALID");
                return;
            }
            if (NeedCardholderName && string.IsNullOrWhiteSpace(_cardName))
            {
                RaisePropertyChanged("CARD_HOLDER_NAME_INVALID");
                return;
            }
            if (!card.ValidateCVC())
            {
                RaisePropertyChanged("CARD_CVC_INVALID");
                return;
            }
            if (NeedCountry && _selectedCountry == null)
            {
                RaisePropertyChanged("CARD_COUNTRY_INVALID");
                return;
            }
            if (NeedZip && string.IsNullOrWhiteSpace(_postcode))
            {
                RaisePropertyChanged("CARD_ZIP_INVALID");
                return;
            }

            IsLoading = true;

            using (var stripe = new StripeClient(_publishableKey))
            {
                var token = await stripe.CreateTokenAsync(card);

                if (token != null)
                {
                    var title       = card.GetBrand() + " *" + card.GetLast4();
                    var credentials = string.Format("{{\"type\":\"{0}\", \"id\":\"{1}\"}}", token.Type, token.Id);

                    NavigateToNextStep(title, credentials, _isSave ?? false);
                }
                else
                {
                    IsLoading = false;
                }
            }

            //var save = _isSave ?? false;
            //var info = new TLPaymentRequestedInfo();
            //if (_paymentForm.Invoice.IsNameRequested)
            //{
            //    info.Name = _info.Name;
            //}
            //if (_paymentForm.Invoice.IsEmailRequested)
            //{
            //    info.Email = _info.Email;
            //}
            //if (_paymentForm.Invoice.IsPhoneRequested)
            //{
            //    info.Phone = _info.Phone;
            //}
            //if (_paymentForm.Invoice.IsShippingAddressRequested)
            //{
            //    info.ShippingAddress = _info.ShippingAddress;
            //    info.ShippingAddress.CountryIso2 = _selectedCountry?.Code;
            //}

            //var response = await ProtoService.ValidateRequestedInfoAsync(save, _message.Id, info);
            //if (response.IsSucceeded)
            //{
            //    IsLoading = false;

            //    if (_paymentForm.HasSavedInfo && !save)
            //    {
            //        ProtoService.ClearSavedInfoAsync(true, false, null, null);
            //    }

            //    if (_paymentForm.Invoice.IsFlexible)
            //    {
            //        NavigationService.Navigate(typeof(PaymentFormStep2Page), TLTuple.Create(_message, _paymentForm, response.Result));
            //    }
            //    else if (_paymentForm.HasSavedCredentials)
            //    {
            //        // TODO: Is password expired?
            //        var expired = true;
            //        if (expired)
            //        {
            //            NavigationService.Navigate(typeof(PaymentFormStep4Page));
            //        }
            //        else
            //        {
            //            NavigationService.Navigate(typeof(PaymentFormStep5Page));
            //        }
            //    }
            //    else
            //    {
            //        NavigationService.Navigate(typeof(PaymentFormStep3Page));
            //    }
            //}
        }
Exemplo n.º 38
0
 public MoveCardCommand(Card moveCard, Deck deckTo)
 {
     _deckFrom = moveCard.DeckOn;
     _moveCard = moveCard;
     _deckTo   = deckTo;
 }
 public HauntingEchoCardController(Card card, TurnTakerController turnTakerController)
     : base(card, turnTakerController)
 {
 }
 public NecroZombieCardController(Card card, TurnTakerController turnTakerController) : base(card, turnTakerController)
 {
 }
Exemplo n.º 41
0
 public static IPlayable DrawCard(Controller c, Card card)
 {
     return(DrawCardBlock.Invoke(c, card));
 }
Exemplo n.º 42
0
		public DefaultBarImageBuilder(Card card, string dir) : base(card, dir)
		{
		}
        public IEnumerator DowsingCrystalDamage(CardEntersPlayAction cep)
        {
            //base.SetCardPropertyToTrueIfRealAction("InUse");
            //Log.Debug("DowsingCrystalDamage triggers");
            var dcTriggers = GameController.StatusEffectManager
                             .GetStatusEffectControllersInList(CardControllerListType.ActivatesEffects)
                             .Where((StatusEffectController sec) => (sec.StatusEffect as ActivateEffectStatusEffect).EffectName == "Dowsing Crystal trigger")
                             .ToList();

            //for each of the various Dowsing Crystal uses that have happened...
            foreach (StatusEffectController seController in dcTriggers)
            {
                var        currentTriggerEffect = seController.StatusEffect as ActivateEffectStatusEffect;
                Card       triggeringCrystal    = currentTriggerEffect.CardSource;
                CardSource crystalSource        = new CardSource(FindCardController(triggeringCrystal));

                if (!IsSpecificTriggerAvailable(seController))
                {
                    continue;
                }
                _inUseTriggers.Add(seController);

                if (!crystalSource.Card.IsInPlay)
                {
                    GameController.RemoveInhibitor(crystalSource.CardController);
                }

                //"(one hero target) may..."
                var storedYesNo       = new List <YesNoCardDecision> {
                };
                IEnumerator coroutine = GameController.MakeYesNoCardDecision(DecisionMaker, SelectionType.DealDamage, triggeringCrystal, storedResults: storedYesNo, cardSource: crystalSource);
                if (base.UseUnityCoroutines)
                {
                    yield return(base.GameController.StartCoroutine(coroutine));
                }
                else
                {
                    base.GameController.ExhaustCoroutine(coroutine);
                }

                if (DidPlayerAnswerYes(storedYesNo))
                {
                    //"one hero target (may deal damage...)"
                    var storedDamageSource = new List <SelectTargetDecision> {
                    };
                    var heroTargets        = GameController.FindCardsWhere(new LinqCardCriteria((Card c) => c != null && c.IsTarget && c.IsHero && c.IsInPlayAndHasGameText), visibleToCard: crystalSource);
                    coroutine = GameController.SelectTargetAndStoreResults(DecisionMaker, heroTargets, storedDamageSource, damageAmount: (Card c) => 2, selectionType: SelectionType.HeroToDealDamage, cardSource: crystalSource);
                    if (base.UseUnityCoroutines)
                    {
                        yield return(base.GameController.StartCoroutine(coroutine));
                    }
                    else
                    {
                        base.GameController.ExhaustCoroutine(coroutine);
                    }

                    var selectedDecision = storedDamageSource.FirstOrDefault();
                    if (selectedDecision != null && selectedDecision.SelectedCard != null)
                    {
                        var damageSource = selectedDecision.SelectedCard;

                        //"...of a type of their choosing."
                        var damageTypeDecision = new List <SelectDamageTypeDecision> {
                        };
                        coroutine = GameController.SelectDamageType(FindHeroTurnTakerController(damageSource.Owner.ToHero()), damageTypeDecision, cardSource: crystalSource);
                        if (base.UseUnityCoroutines)
                        {
                            yield return(base.GameController.StartCoroutine(coroutine));
                        }
                        else
                        {
                            base.GameController.ExhaustCoroutine(coroutine);
                        }

                        var selectedDamage = DamageType.Melee;
                        if (damageTypeDecision.FirstOrDefault() != null && damageTypeDecision.FirstOrDefault().SelectedDamageType != null)
                        {
                            selectedDamage = (DamageType)damageTypeDecision.FirstOrDefault().SelectedDamageType;
                        }


                        //Log.Debug("Dowsing Crystal's trigger-on-Mara approach works so far.");

                        //attempts to give the damage a destroy-dowsing-crystal-for-boost effect

                        //does not seem to be needed yet, causes warnings in multiple-play-reactions
                        //may be required in some future scenario
                        //var damageSourceTempVar = (Card)AddTemporaryVariable("DowsingCrystalDamageSource", damageSource);

                        var boostDamageTrigger = new IncreaseDamageTrigger(GameController, (DealDamageAction dd) => LogAndReturnTrue(dd) && dd.DamageSource.Card == damageSource && dd.CardSource == crystalSource && triggeringCrystal.IsInPlay, DestroyCrystalToBoostDamageResponse, null, TriggerPriority.Low, false, crystalSource);

                        AddTrigger(boostDamageTrigger);

                        //"deal a non-hero target 2 damage"

                        coroutine = GameController.SelectTargetsAndDealDamage(DecisionMaker, new DamageSource(GameController, damageSource), 2, selectedDamage, 1, false, 1, additionalCriteria: ((Card c) => !c.IsHero), cardSource: crystalSource);
                        if (UseUnityCoroutines)
                        {
                            yield return(GameController.StartCoroutine(coroutine));
                        }
                        else
                        {
                            GameController.ExhaustCoroutine(coroutine);
                        }

                        RemoveTrigger(boostDamageTrigger);
                        //RemoveTemporaryVariables();
                    }

                    //"Once before your next turn..."
                    coroutine = GameController.ExpireStatusEffect(currentTriggerEffect, crystalSource);
                    if (UseUnityCoroutines)
                    {
                        yield return(GameController.StartCoroutine(coroutine));
                    }
                    else
                    {
                        GameController.ExhaustCoroutine(coroutine);
                    }
                    _hasBeenUsedTriggers.Add(seController);
                }
                _inUseTriggers.Remove(seController);
            }

            yield break;
        }
Exemplo n.º 44
0
        public override PlayerAction ChooseCard(PlayerTurnContext context, ICollection <Card> possibleCardsToPlay)
        {
            // If bigger card is available => play it
            var biggerCard =
                possibleCardsToPlay.Where(
                    x => x.Suit == context.FirstPlayedCard.Suit && x.GetValue() > context.FirstPlayedCard.GetValue())
                .OrderByDescending(x => x.GetValue())
                .FirstOrDefault();

            if (biggerCard != null)
            {
                // If other player wins with this trick => take it
                if (context.FirstPlayedCard.GetValue() + biggerCard.GetValue() + context.FirstPlayerRoundPoints > 65)
                {
                    return(PlayerAction.PlayCard(biggerCard));
                }

                // If current player wins with this trick => take it
                if (context.FirstPlayedCard.GetValue() + biggerCard.GetValue() + context.SecondPlayerRoundPoints > 65)
                {
                    return(PlayerAction.PlayCard(biggerCard));
                }

                // Don't have Queen and King of the same suit => play it
                if (biggerCard.Type != CardType.Queen || !this.Cards.Contains(Card.GetCard(biggerCard.Suit, CardType.King)))
                {
                    if (biggerCard.Type != CardType.King || !this.Cards.Contains(Card.GetCard(biggerCard.Suit, CardType.Queen)))
                    {
                        return(PlayerAction.PlayCard(biggerCard));
                    }
                }
            }

            // Smallest card
            var smallestCard = possibleCardsToPlay.OrderBy(x => x.GetValue()).ThenByDescending(x => this.Tracker.UnknownCards.Count(uc => uc.Suit == x.Suit)).FirstOrDefault();

            if (context.FirstPlayedCard.Suit != context.TrumpCard.Suit)
            {
                var biggestTrump =
                    possibleCardsToPlay.Where(x => x.Suit == context.TrumpCard.Suit)
                    .OrderByDescending(x => x.GetValue()).FirstOrDefault();

                if (biggestTrump != null)
                {
                    var currentPlayerPotentialPoints = context.FirstPlayedCard.GetValue() + biggestTrump.GetValue()
                                                       + context.SecondPlayerRoundPoints;

                    var cardFor20Or40 = this.TryToAnnounce20Or40(context, this.Cards);
                    if (cardFor20Or40?.Type == CardType.Queen && cardFor20Or40.Suit != context.TrumpCard.Suit)
                    {
                        currentPlayerPotentialPoints += 20;
                    }

                    // If the current player wins the round by playing trump => play it
                    if (currentPlayerPotentialPoints > 65)
                    {
                        return(PlayerAction.PlayCard(biggestTrump));
                    }

                    // If the other player wins the round by taking this hand => trump it
                    if (context.FirstPlayedCard.GetValue() + smallestCard.GetValue() + context.FirstPlayerRoundPoints > 65)
                    {
                        return(PlayerAction.PlayCard(biggestTrump));
                    }
                }
            }

            // When opponent plays Ace or Ten => play trump card
            if (context.FirstPlayedCard.Suit != context.TrumpCard.Suit &&
                (context.FirstPlayedCard.Type == CardType.Ace || context.FirstPlayedCard.Type == CardType.Ten))
            {
                if (possibleCardsToPlay.Contains(Card.GetCard(context.TrumpCard.Suit, CardType.Nine)) &&
                    context.TrumpCard.Type == CardType.Jack)
                {
                    return(PlayerAction.PlayCard(Card.GetCard(context.TrumpCard.Suit, CardType.Nine)));
                }

                if (possibleCardsToPlay.Contains(Card.GetCard(context.TrumpCard.Suit, CardType.Jack)))
                {
                    return(PlayerAction.PlayCard(Card.GetCard(context.TrumpCard.Suit, CardType.Jack)));
                }

                if (possibleCardsToPlay.Contains(Card.GetCard(context.TrumpCard.Suit, CardType.Queen)) &&
                    this.Tracker.PlayedCards.Contains(Card.GetCard(context.TrumpCard.Suit, CardType.King)))
                {
                    return(PlayerAction.PlayCard(Card.GetCard(context.TrumpCard.Suit, CardType.Queen)));
                }

                if (possibleCardsToPlay.Contains(Card.GetCard(context.TrumpCard.Suit, CardType.King)) &&
                    this.Tracker.PlayedCards.Contains(Card.GetCard(context.TrumpCard.Suit, CardType.Queen)))
                {
                    return(PlayerAction.PlayCard(Card.GetCard(context.TrumpCard.Suit, CardType.King)));
                }

                if (possibleCardsToPlay.Contains(Card.GetCard(context.TrumpCard.Suit, CardType.Ten)))
                {
                    return(PlayerAction.PlayCard(Card.GetCard(context.TrumpCard.Suit, CardType.Ten)));
                }

                if (possibleCardsToPlay.Contains(Card.GetCard(context.TrumpCard.Suit, CardType.Ace)))
                {
                    return(PlayerAction.PlayCard(Card.GetCard(context.TrumpCard.Suit, CardType.Ace)));
                }
            }

            return(PlayerAction.PlayCard(smallestCard));
        }
Exemplo n.º 45
0
 public override void PayPartial(PayCostParameters p)
 {
     Card.PutToHand();
 }
Exemplo n.º 46
0
    // 牌型選擇ui監聽事件實作
    private void SenderFunction(string senderName)
    {
        List <List <Card> > decks = new List <List <Card> >();
        Player      player        = GameView.transform.GetComponent <GameView>().m_player[0];
        List <Card> cards         = player.GetCardList();

        // 將牌先全部放下
        for (int i = 0; i < player.deck.transform.childCount; i++)
        {
            player.deck.transform.GetChild(i).transform.GetComponent <Card>().SetCardCancel();
        }

        // 如果是同顆按鈕則尋找下一個位置
        if (tempButton == senderName)
        {
            tempButtonindex++;
        }
        else
        {
            tempButton      = senderName;
            tempButtonindex = 0;
        }

        switch (senderName)
        {
        case "btn_findpair":
            decks = CardTypeCheckMgr.FindPair(cards);
            break;

        case "btn_findthree":
            decks = CardTypeCheckMgr.FindThreeOfKinds(cards);
            break;

        case "btn_findStraight":
            decks = CardTypeCheckMgr.FindStraight(cards);
            break;

        case "btn_findFullHouse":
            decks = CardTypeCheckMgr.FindFullHouse(cards);
            break;

        case "btn_findFour":
            decks = CardTypeCheckMgr.FindFourOfKinds(cards);
            break;

        case "btn_findStraightFlush":
            decks = CardTypeCheckMgr.FindStraightFlush(cards);
            break;
        }

        // 找牌,並選起
        for (int i = 0; i < player.deck.transform.childCount; i++)
        {
            Card card      = player.deck.transform.GetChild(i).transform.GetComponent <Card>();
            var  tempdecks = decks[tempButtonindex % decks.Count];
            for (int j = 0; j < tempdecks.Count; j++)
            {
                if (card.value == tempdecks[j].value &&
                    card.symbol == tempdecks[j].symbol)
                {
                    card.SetCardSelect();
                }
            }
        }

        // 去檢查是否可以出牌
        if (Judgment.CheckCanPassCard(player.deck))
        {
            btn_PassCards.interactable = true;
        }
        else
        {
            btn_PassCards.interactable = false;
        }
    }
Exemplo n.º 47
0
    }     //GetCardDefinitionByRank

    public void MakeCards()
    {
        // stub Add the code from page 577 here
        cardNames = new List <string>();
        string[] letters = new string[] { "C", "D", "H", "S" };
        foreach (string s in letters)
        {
            for (int i = 0; i < 13; i++)
            {
                cardNames.Add(s + (i + 1));
            }
        }

        // list of all Cards
        cards = new List <Card>();

        // temp variables
        Sprite         tS  = null;
        GameObject     tGO = null;
        SpriteRenderer tSR = null;          // so tempted to make a D&D ref here...

        for (int i = 0; i < cardNames.Count; i++)
        {
            GameObject cgo = Instantiate(prefabCard) as GameObject;
            cgo.transform.parent = deckAnchor;
            Card card = cgo.GetComponent <Card>();

            cgo.transform.localPosition = new Vector3(i % 13 * 3, i / 13 * 4, 0);

            card.name = cardNames[i];
            card.suit = card.name[0].ToString();
            card.rank = int.Parse(card.name.Substring(1));

            if (card.suit == "D" || card.suit == "H")
            {
                card.colS  = "Red";
                card.color = Color.red;
            }

            card.def = GetCardDefinitionByRank(card.rank);

            // Add Decorators
            foreach (Decorator deco in decorators)
            {
                tGO = Instantiate(prefabSprite) as GameObject;
                tSR = tGO.GetComponent <SpriteRenderer>();

                if (deco.type == "suit")
                {
                    tSR.sprite = dictSuits[card.suit];
                }
                else                     // it is a rank
                {
                    tS         = rankSprites[card.rank];
                    tSR.sprite = tS;
                    tSR.color  = card.color;
                }

                tSR.sortingOrder            = 1;                          // make it render above card
                tGO.transform.parent        = cgo.transform;              // make deco a child of card GO
                tGO.transform.localPosition = deco.loc;                   // set the deco's local position

                if (deco.flip)
                {
                    tGO.transform.rotation = Quaternion.Euler(0, 0, 180);
                }

                if (deco.scale != 1)
                {
                    tGO.transform.localScale = Vector3.one * deco.scale;
                }

                tGO.name = deco.type;

                card.decoGOs.Add(tGO);
            }             // foreach Deco


            //Add the pips
            foreach (Decorator pip in card.def.pips)
            {
                tGO = Instantiate(prefabSprite) as GameObject;
                tGO.transform.parent        = cgo.transform;
                tGO.transform.localPosition = pip.loc;

                if (pip.flip)
                {
                    tGO.transform.rotation = Quaternion.Euler(0, 0, 180);
                }

                if (pip.scale != 1)
                {
                    tGO.transform.localScale = Vector3.one * pip.scale;
                }

                tGO.name         = "pip";
                tSR              = tGO.GetComponent <SpriteRenderer>();
                tSR.sprite       = dictSuits[card.suit];
                tSR.sortingOrder = 1;
                card.pipGOs.Add(tGO);
            }

            //Handle face cards
            if (card.def.face != "")
            {
                tGO = Instantiate(prefabSprite) as GameObject;
                tSR = tGO.GetComponent <SpriteRenderer>();

                tS                          = GetFace(card.def.face + card.suit);
                tSR.sprite                  = tS;
                tSR.sortingOrder            = 1;
                tGO.transform.parent        = card.transform;
                tGO.transform.localPosition = Vector3.zero;                  // slap it smack dab in the middle
                tGO.name                    = "face";
            }

            // Add Card Back
            // Back isn't actually behind the card. It sits in front of the card
            // and can be turned on and off to hide the face
            tGO                         = Instantiate(prefabSprite) as GameObject;
            tSR                         = tGO.GetComponent <SpriteRenderer>();
            tSR.sprite                  = cardBack;
            tGO.transform.parent        = card.transform;
            tGO.transform.localPosition = Vector3.zero;
            tSR.sortingOrder            = 2;
            tGO.name                    = "back";

            card.back   = tGO;
            card.faceUP = true;

            cards.Add(card);
        } // for all the Cardnames
    }     // makeCards
Exemplo n.º 48
0
    IEnumerator DoSummon()
    {
        UIManager.instance.SettingText(true, "- 소환 단계 진행중 -");
        foreach (var obj in summonEnableEnemyCards)
        {
            obj.GetComponent <Card>().CardTextSet(true);
        }
        yield return(new WaitForSeconds(0.5f));

        if (RandomSelecter.m_isMyTurn)
        {
            RandomSelecter.RandomActive();
            bool[] ran = { RandomSelecter.GetRandomValue(0), RandomSelecter.GetRandomValue(1), RandomSelecter.GetRandomValue(2),
                           RandomSelecter.GetRandomValue(3), RandomSelecter.GetRandomValue(4) };
            GameClient.instance.SendRandInfo(ran);
        }

        for (int i = 0; i < summonCount; i++)
        {
            int playerFieldNum = 6;
            int enemyFieldNum  = 6;

            summonEnablePlayerCards.Sort(new CardTurnSort());
            summonEnableEnemyCards.Sort(new CardTurnSort());
            if (summonEnablePlayerCards.Count != 0)
            {
                playerFieldNum = summonEnablePlayerCards[0].GetComponent <Card>().FieldNumber;
            }
            if (summonEnableEnemyCards.Count != 0)
            {
                enemyFieldNum = summonEnableEnemyCards[0].GetComponent <Card>().FieldNumber;
            }
            if (playerFieldNum < enemyFieldNum)
            {
                summonEnablePlayerCards[0].gameObject.GetComponentInChildren <SpriteRenderer>().color = Color.white;
                summonEnablePlayerCards.RemoveAt(0);
            }
            else if (playerFieldNum > enemyFieldNum)
            {
                summonEnableEnemyCards[0].gameObject.GetComponentInChildren <SpriteRenderer>().color = Color.white;
                Card card = summonEnableEnemyCards[0].GetComponent <Card>();
                card.Init();
                card.ChangeState(new Summon());
                card.ChangePosition(new InField());
                LogicManager.instance.Enemy.AddCard(card.gameObject);
                enemy.RemoveCardHand(null);
                summonEnableEnemyCards.RemoveAt(0);
            }
            else
            {
                if (RandomSelecter.GetRandomValue_n())
                {
                    summonEnablePlayerCards[0].gameObject.GetComponentInChildren <SpriteRenderer>().color = Color.white;
                    summonEnablePlayerCards.RemoveAt(0);
                }
                else
                {
                    summonEnableEnemyCards[0].gameObject.GetComponentInChildren <SpriteRenderer>().color = Color.white;
                    Card card = summonEnableEnemyCards[0].GetComponent <Card>();
                    card.Init();
                    card.ChangeState(new Summon());
                    card.ChangePosition(new InField());
                    LogicManager.instance.Enemy.AddCard(card.gameObject);
                    enemy.RemoveCardHand(null);
                    summonEnableEnemyCards.RemoveAt(0);
                }
            }
            yield return(new WaitForSeconds(turnDelay));
        }
        Debug.Log("Summon End");
        summonCount = 0;
        yield return(new WaitForSeconds(0.5f));

        presentlevel = Level.Battle;
        summonCards.Clear();

        ObjectPool objpool = GameObject.Find("CardPool").GetComponent <ObjectPool>();

        foreach (CardInfo_send soul in player.GetTrashCards())
        {
            GameObject    card = objpool.GetObject();
            CardInfo_send newInfo;
            newInfo = soul;
            newInfo.FieldLocation = 0;
            newInfo.isEnemyCard   = false;
            newInfo.isReturn      = false;
            card.GetComponent <Card>().SetInfo(newInfo);
            card.GetComponent <Card>().Init();
            card.GetComponent <Card>().ChangePosition(new InHand());
            player.cards.Add(card);
        }
        player.GetTrashCards().Clear();
        foreach (CardInfo_send soul in enemy.GetTrashCards())
        {
            GameObject    card = objpool.GetObject();
            CardInfo_send newInfo;
            newInfo = soul;
            newInfo.FieldLocation = 0;
            newInfo.isEnemyCard   = true;
            newInfo.isReturn      = false;
            card.GetComponent <Card>().SetInfo(newInfo);
            card.GetComponent <Card>().Init();
            card.GetComponent <Card>().ChangePosition(new InHand());
            enemy.cards.Add(card);
        }
        enemy.GetTrashCards().Clear();
        ChangeState(new BattleLogic());
    }
Exemplo n.º 49
0
 public virtual bool ContainsCard(Card c)
 {
     return(Cards.Contains(c));
 }
Exemplo n.º 50
0
 public OutOfBoundsCardController(Card card, TurnTakerController turnTakerController)
     : base(card, turnTakerController)
 {
     SpecialStringMaker.ShowListOfCardsInPlay(GoalpostsCards);
 }
Exemplo n.º 51
0
 public static bool operator <(Card a, int b)
 {
     Card c = b; return(a.Value < c.Value && a.Suit > c.Suit);
 }
Exemplo n.º 52
0
 private CardInfo CardModel(Card card)
 {
     return(new CardInfo {
         Type = card.Name
     });
 }
Exemplo n.º 53
0
        private void AddCardToDeck(Card card)
        {
            var frm = new FormListDeck();

            frm.Show();
        }
Exemplo n.º 54
0
 public virtual bool RemoveCard(Card c)
 {
     return(Cards.Remove(c));
 }
Exemplo n.º 55
0
 public ActionResult <long> Post([FromBody] Card card)
 {
     return(_CardsBusiness.CreateCard(card));
 }
Exemplo n.º 56
0
 public CeiffCardController(Card card, TurnTakerController turnTakerController)
     : base(card, turnTakerController)
 {
     SpecialStringMaker.ShowNonEnvironmentTargetWithLowestHP(ranking: 1, numberOfTargets: 1);
     SpecialStringMaker.ShowNumberOfCardsInPlay(new LinqCardCriteria((Card c) => c.DoKeywordsContain("livestock"), "livestock", false));
 }
Exemplo n.º 57
0
        ///<summary>
        /// Returns -1 if Hearthstone loses focus
        /// </summary>
        public static async Task <int> AddCardToDeck(Card card, ExportingInfo info)
        {
            if (!User32.IsHearthstoneInForeground())
            {
                Core.MainWindow.ShowMessage("Exporting aborted", "Hearthstone window lost focus.").Forget();
                Log.Info("Exporting aborted, window lost focus");
                return(-1);
            }

            if (Config.Instance.ExportForceClear)
            {
                await ClearSearchBox(info.HsHandle, info.SearchBoxPos);
            }

            await ClickOnPoint(info.HsHandle, info.SearchBoxPos);

            if (Config.Instance.ExportPasteClipboard || !Helper.LatinLanguages.Contains(Config.Instance.SelectedLanguage))
            {
                Clipboard.SetText(GetSearchString(card));
                SendKeys.SendWait("^{v}");
            }
            else
            {
                SendKeys.SendWait(GetSearchString(card));
            }
            SendKeys.SendWait("{ENTER}");

            Log.Info("try to export card: " + card);
            await Task.Delay(Config.Instance.DeckExportDelay * 2);

            //Check if Card exist in collection
            var cardExists = await CardExists(info.HsHandle, (int)info.CardPosX, (int)info.CardPosY, info.HsRect.Width, info.HsRect.Height);

            if (cardExists)
            {
                //Check if a golden exist
                if (Config.Instance.PrioritizeGolden &&
                    await CardExists(info.HsHandle, (int)info.Card2PosX, (int)info.CardPosY, info.HsRect.Width, info.HsRect.Height))
                {
                    await ClickOnPoint(info.HsHandle, new Point((int)info.Card2PosX + 50, (int)info.CardPosY + 50));

                    if (card.Count == 2)
                    {
                        await ClickOnPoint(info.HsHandle, new Point((int)info.Card2PosX + 50, (int)info.CardPosY + 50));
                        await ClickOnPoint(info.HsHandle, new Point((int)info.CardPosX + 50, (int)info.CardPosY + 50));
                    }
                }
                else
                {
                    await ClickOnPoint(info.HsHandle, new Point((int)info.CardPosX + 50, (int)info.CardPosY + 50));

                    if (card.Count == 2)
                    {
                        //Check if two card are not available
                        await Task.Delay(200 - Config.Instance.DeckExportDelay);

                        if (await CardHasLock(info.HsHandle, (int)(info.CardPosX + info.HsRect.Width * 0.048),
                                              (int)(info.CardPosY + info.HsRect.Height * 0.287), info.HsRect.Width, info.HsRect.Height))
                        {
                            var card2Exists = await CardExists(info.HsHandle, (int)info.Card2PosX, (int)info.CardPosY, info.HsRect.Width, info.HsRect.Height);

                            if (card2Exists)
                            {
                                await ClickOnPoint(info.HsHandle, new Point((int)info.Card2PosX + 50, (int)info.CardPosY + 50));

                                return(0);
                            }
                            Log.Info("Only one copy found: " + card.Name);
                            return(1);
                        }

                        await ClickOnPoint(info.HsHandle, new Point((int)info.CardPosX + 50, (int)info.CardPosY + 50));
                    }
                }
            }
            else
            {
                return(card.Count);
            }
            return(0);
        }
Exemplo n.º 58
0
 public void AddCard(Card card)
 {
     db.Insert(card);
 }
Exemplo n.º 59
0
 public void HasDrop(Card idDrag, Card idDrop)
 {
 }
Exemplo n.º 60
0
 public ConstantSurveillanceCardController(Card card, TurnTakerController turnTakerController)
     : base(card, turnTakerController)
 {
     LinqCardCriteria otherImperialTargetInPlay = new LinqCardCriteria((Card c) => c != base.Card && c.IsTarget && c.DoKeywordsContain(AuthorityKeyword) && c.IsInPlayAndHasGameText, "other Imperial targets in play", false, false, "other Imperial target in play", "other Imperial targets in play");
     SpecialStringMaker.ShowListOfCardsInPlay(otherImperialTargetInPlay);
 }