/// <summary>
        /// Deals the specified players.
        /// </summary>
        /// <param name="players">The players.</param>
        /// <param name="cardsOnBoard">The cards on board.</param>
        public void Deal(IList<IParticipant> players, ICard[] cardsOnBoard)
        {
            this.Shuffle();

            int toTakeFromDeckIndex = 0;

            // deal cards to players
            foreach (IParticipant player in players.Where(p => p.IsInGame))
            {
                this.DealCardsToPlayers(player, ref toTakeFromDeckIndex);
            }

            // place cards on board
            Point boardCardsPosition = GlobalVariables.BoardCardsPlace;
            int positionCardChangeX = boardCardsPosition.X;
            for (int i = 0; i < 5; i++)
            {
                this.DealCardsOnBoard(
                    cardsOnBoard, 
                    i, 
                    ref toTakeFromDeckIndex, 
                    boardCardsPosition, 
                    ref positionCardChangeX);
            }

            // turn the player cards up
            foreach (var player in players.Where(p => p.IsInGame && p is Player))
            {
                player.Hand.CurrentCards[0].IsFacingUp = true;
                player.Hand.CurrentCards[1].IsFacingUp = true;
            }               
        }
Beispiel #2
0
 protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard)
 {
     IUiProxy ui = Game.CurrentGame.UiProxies[dest];
     HuoGongCardChoiceVerifier v1 = new HuoGongCardChoiceVerifier();
     ISkill s;
     List<Player> p;
     List<Card> cards;
     if (dest.IsDead) return;
     if (!ui.AskForCardUsage(new CardUsagePrompt("HuoGong", source), v1, out s, out cards, out p))
     {
         Trace.TraceInformation("Player {0} Invalid answer", dest);
         cards = new List<Card>();
         if (Game.CurrentGame.Decks[dest, DeckType.Hand].Count == 0)
         {
             Trace.TraceError("HuoGong Cannot Show Card! This should NOT have happened!");
             return;
         }
         cards.Add(Game.CurrentGame.Decks[dest, DeckType.Hand][0]);
     }
     Trace.TraceInformation("Player {0} HuoGong showed {1}, ", dest.Id, cards[0].Suit);
     if (source.IsDead) return;
     ui = Game.CurrentGame.UiProxies[source];
     HuoGongCardMatchVerifier v2 = new HuoGongCardMatchVerifier(cards[0].Suit);
     v2.Owner = source;
     if (ui.AskForCardUsage(new CardUsagePrompt("HuoGong2", dest, cards[0].Suit), v2, out s, out cards, out p))
     {
         Game.CurrentGame.HandleCardDiscard(source, cards);
         Game.CurrentGame.DoDamage(source, dest, 1, DamageElement.Fire, card, readonlyCard);
     }
     else
     {
         Trace.TraceInformation("HuoGong aborted, failed to provide card");
     }
 }
Beispiel #3
0
 protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
 {
     DeckType wuguDeck = new DeckType("WuGu");
     DeckType wuguFakeDeck = new DeckType("WuGuFake");
     List<List<Card>> answer;
     if (!Game.CurrentGame.UiProxies[dest].AskForCardChoice(new CardChoicePrompt("WuGuFengDeng"),
             new List<DeckPlace>() { new DeckPlace(null, wuguFakeDeck) },
             new List<string>() { "WuGu" },
             new List<int>() { 1 },
             new WuGuCardChoiceVerifier(FakeMapping),
             out answer,
             new AdditionalCardChoiceOptions() { IsWuGu = true }))
     {
         Trace.TraceInformation("Invalid answer for WuGu, choosing for you");
         answer = new List<List<Card>>();
         answer.Add(new List<Card>());
         answer[0].Add(Game.CurrentGame.Decks[null, wuguDeck][0]);
     }
     else
     {
         if (!FakeMapping.ContainsKey(answer[0][0]) || FakeMapping[answer[0][0]] == null)
         {
             answer[0] = new List<Card>() { Game.CurrentGame.Decks[null, wuguDeck][0] };
         }
         var theCard = answer[0][0];
         answer[0] = new List<Card>() { FakeMapping[theCard] };
         FakeMapping[theCard] = null;
     }
     Game.CurrentGame.HandleCardTransferToHand(null, dest, answer[0], new MovementHelper() { IsWuGu = true });
 }
Beispiel #4
0
 protected override VerifierResult Verify(Player source, ICard card, List<Player> targets)
 {
     if (targets == null || targets.Count == 0)
     {
         return VerifierResult.Partial;
     }
     if (targets.Count > 1)
     {
         return VerifierResult.Fail;
     }
     Player player = targets[0];
     if (player == source)
     {
         return VerifierResult.Fail;
     }
     if (!ShunChaiAdditionalCheck(source, player, card))
     {
         return VerifierResult.Fail;
     }
     if (Game.CurrentGame.Decks[player, DeckType.Hand].Count == 0 &&
         Game.CurrentGame.Decks[player, DeckType.DelayedTools].Count == 0 &&
         Game.CurrentGame.Decks[player, DeckType.Equipment].Count == 0)
     {
         return VerifierResult.Fail;
     }
     return VerifierResult.Success;
 }
Beispiel #5
0
            public override void Resolve(TurnContext context, ICard source)
            {
                base.Resolve(context, source);

                if(context.ActivePlayer.Deck.TopCard != null)
                    _activities.Add(Activities.ChooseWhetherToMillTopCard(context, context.ActivePlayer, context.ActivePlayer, source));
            }
    /// <summary>
    /// The entry point of the program.
    /// </summary>
    private static void Main()
    {
        try
        {
            IHandEvaluator handEvaluator = new HandEvaluator();

            ICard[] cards = new ICard[]
                {
                    new Card(CardRank.Queen, CardSuit.Hearts),
                    new Card(CardRank.Queen, CardSuit.Spades),
                    new Card(CardRank.Ten, CardSuit.Hearts),
                    new Card(CardRank.Queen, CardSuit.Diamonds),
                    new Card(CardRank.Queen, CardSuit.Clubs)
                };

            IHand hand = new Hand(cards);

            Console.WriteLine(handEvaluator.GetCategory(hand) == HandCategory.FourOfAKind);

            IHand handFromString = new Hand("7♠ 5♣ 4♦ 3♦ 2♣");
            Console.WriteLine(handFromString);
        }
        catch (ArgumentException aex)
        {
            Console.WriteLine(aex.Message);
        }
    }
Beispiel #7
0
 public void CardValuesTest()
 {
     Assert.AreEqual(Face.Ace, _card.Face);
     Assert.AreEqual(1, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Two).Build();
     Assert.AreEqual(2, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Three).Build();
     Assert.AreEqual(3, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Four).Build();
     Assert.AreEqual(4, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Five).Build();
     Assert.AreEqual(5, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Six).Build();
     Assert.AreEqual(6, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Seven).Build();
     Assert.AreEqual(7, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Eight).Build();
     Assert.AreEqual(8, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Nine).Build();
     Assert.AreEqual(9, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Ten).Build();
     Assert.AreEqual(10, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Jack).Build();
     Assert.AreEqual(10, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.King).Build();
     Assert.AreEqual(10, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.Queen).Build();
     Assert.AreEqual(10, _card.Value);
     _card = _CARD_BUILDER.HasFace(Face.undefined).Build();
     Assert.AreEqual(0, _card.Value);
 }
Beispiel #8
0
        public void TestHandToString1()
        {
            ICard[] cards = new ICard[0];
            IHand hand = new Hand(cards);

            Assert.AreEqual(string.Empty, hand.ToString(), "Hand constructor does not work correctly.");
        }
Beispiel #9
0
 protected override VerifierResult Verify(Player source, ICard card, List<Player> targets)
 {
     if (Game.CurrentGame.IsDying.Count == 0 && targets != null && targets.Count >= 1)
     {
         return VerifierResult.Fail;
     }
     if (Game.CurrentGame.IsDying.Count > 0 && (targets == null || targets.Count != 1))
     {
         return VerifierResult.Fail;
     }
     Player p;
     if (Game.CurrentGame.IsDying.Count == 0)
     {
         p = source;
     }
     else
     {
         p = targets[0];
     }
     if (p.Health >= p.MaxHealth)
     {
         return VerifierResult.Fail;
     }
     return VerifierResult.Success;
 }
Beispiel #10
0
        protected override void Process(Player source, Player dest, ICard card, ReadOnlyCard readonlyCard, GameEventArgs inResponseTo)
        {
            IUiProxy ui = Game.CurrentGame.UiProxies[source];
            if (source.IsDead) return;
            List<DeckPlace> places = new List<DeckPlace>();
            places.Add(new DeckPlace(dest, DeckType.Hand));
            places.Add(new DeckPlace(dest, DeckType.Equipment));
            places.Add(new DeckPlace(dest, DeckType.DelayedTools));
            List<string> resultDeckPlace = new List<string>();
            resultDeckPlace.Add(ResultDeckName);
            List<int> resultDeckMax = new List<int>();
            resultDeckMax.Add(1);
            List<List<Card>> answer;
            if (!ui.AskForCardChoice(new CardChoicePrompt(ChoicePrompt), places, resultDeckPlace, resultDeckMax, new RequireOneCardChoiceVerifier(true), out answer))
            {
                Trace.TraceInformation("Player {0} Invalid answer", source.Id);
                answer = new List<List<Card>>();
                answer.Add(Game.CurrentGame.PickDefaultCardsFrom(places));
            }
            Card theCard = answer[0][0];

            if (ShunChaiDest(source, dest).DeckType == DeckType.Discard)
            {
                Game.CurrentGame.HandleCardDiscard(dest, new List<Card>() { theCard });
            }
            else
            {
                Game.CurrentGame.HandleCardTransferToHand(dest, source, new List<Card>() { theCard });
            }
        }
Beispiel #11
0
            public override void Resolve(TurnContext context, ICard source)
            {
                var estate = context.ActivePlayer.Hand.OfType<Estate>().FirstOrDefault();

                Action discardAction = () =>
                {
                    context.AvailableSpend += 4;
                    context.DiscardCard(context.ActivePlayer, estate);
                };

                Action gainAction = () => new GainUtility(context, context.ActivePlayer).Gain<Estate>();

                if (estate != null)
                {
                    var activity = Activities.ChooseYesOrNo
                        (context.Game.Log, context.ActivePlayer, "Discard an Estate?",
                         source,
                         discardAction, gainAction);

                    _activities.Add(activity);
                }
                else
                {
                    gainAction();
                }
            }
Beispiel #12
0
 public override void Process(Player source, List<Player> dests, ICard card, ReadOnlyCard cardr)
 {
     Trace.Assert(dests == null || dests.Count == 0);
     Trace.Assert(card is Card);
     Card c = (Card)card;
     Install(source, c);
 }
        public void Setup()
        {
            player = new Player("name");
            banker = new Banker(new[] { player });

            collectCard = new FlatCollectCard("collect", 10, banker);
        }
Beispiel #14
0
 protected override VerifierResult Verify(Player source, ICard card, List<Player> targets)
 {
     if (Game.CurrentGame.IsDying.Count == 0 && targets != null && targets.Count >= 1)
     {
         return VerifierResult.Fail;
     }
     if (Game.CurrentGame.IsDying.Count > 0 && (targets == null || targets.Count != 1))
     {
         return VerifierResult.Fail;
     }
     if (Game.CurrentGame.IsDying.Count == 0)
     {
         if (source[JiuUsed] == 1)
         {
             return VerifierResult.Fail;
         }
     }
     else
     {
         if (targets[0] != source)
         {
             return VerifierResult.Fail;
         }
     }
     return VerifierResult.Success;
 }
Beispiel #15
0
            public override void Resolve(TurnContext context, ICard source)
            {
                var upgradeActivity = new SelectCardsActivity(context, "Select a card to Upgrade",
                    SelectionSpecifications.SelectExactlyXCards(1), source);

                upgradeActivity.AfterCardsSelected = cardList =>
                {
                    var player = context.ActivePlayer;
                    var cardToUpgrade = cardList.Single();
                    var upgradeCost = cardToUpgrade.Cost + 1;
                    context.Trash(player, cardToUpgrade);

                    if (context.Game.Bank.Piles.Any(p => !p.IsEmpty && p.TopCard.Cost == upgradeCost))
                    {
                        var gainActivity = Activities.GainACardCostingExactlyX(context.Game.Log, player,
                            upgradeCost, player.Discards, source);
                        _activities.Add(gainActivity);
                    }
                    else
                    {
                        context.Game.Log.LogMessage("{0} could gain no card of appropriate cost", player);
                    }
                };

                _activities.Add(upgradeActivity);
            }
Beispiel #16
0
        public override VerifierResult Verify(Player source, ICard card, List<Player> targets, bool isLooseVerify)
        {
            if (targets == null || targets.Count == 0)
            {
                return VerifierResult.Partial;
            }
            if (!isLooseVerify && targets.Count > 1)
            {
                return VerifierResult.Fail;
            }

            foreach (var player in targets)
            {
                if (player == source)
                {
                    return VerifierResult.Fail;
                }
                if (!ShunChaiAdditionalCheck(source, player, card))
                {
                    return VerifierResult.Fail;
                }
                if (Game.CurrentGame.Decks[player, DeckType.Hand].Count == 0 &&
                    Game.CurrentGame.Decks[player, DeckType.DelayedTools].Count == 0 &&
                    Game.CurrentGame.Decks[player, DeckType.Equipment].Count == 0)
                {
                    return VerifierResult.Fail;
                }
            }
            return VerifierResult.Success;
        }
Beispiel #17
0
 public void Count(ICard card)
 {
     if (card.Value == 1 || card.Value == 10)
         _count--;
     else if (card.Value > 1 && card.Value < 7)
         _count++;
 }
        public void Setup()
        {
            player = new Player("name");
            banker = new Banker(new[] { player });

            payCard = new FlatPayCard("pay", 10, banker);
        }
        public ICard SaveCard(IUserSession session, ICard newCard)
        {
            CardEffect effect = new CardEffect
            {
                Affected = (int)newCard.Effect.Affected,
                CardAttackChange = newCard.Effect.CardAttackChange,
                CardAttackMultiplier = newCard.Effect.CardAttackMultiplier,
                Description = newCard.Effect.Description,
                DisableOpponentEffect = newCard.Effect.DisableOpponentEffect,
                EffectTiming = (int)newCard.Effect.EffectTiming,
                LifePointsChange = newCard.Effect.LifePointsChange,
                Name = newCard.Effect.Name,
                ProbabilityOfEffect = newCard.Effect.ProbabilityOfEffect
            };

            Card created = new Card
            {
                Name = newCard.Name,
                ImageUrl = newCard.ImageUrl,
                Effect = effect,
                AttackPoints = newCard.AttackPoints,
                DefensePoints = newCard.DefensePoints
            };

            RequestContext.Model<Entities>().AddToCards(created);
            RequestContext.Model<Entities>().SaveChanges();

            return created;
        }
Beispiel #20
0
            public override void Resolve(TurnContext context, ICard source)
            {
                var player = context.ActivePlayer;
                var log = context.Game.Log;

                if (player.Hand.OfType<IActionCard>().Any())
                {
                    var activity = new SelectCardsActivity(
                        log, player,
                        "Select an action to play twice",
                        SelectionSpecifications.SelectExactlyXCards(1), source);

                    activity.Hint = ActivityHint.PlayCards;
                    activity.Specification.CardTypeRestriction = typeof (IActionCard);
                    activity.AfterCardsSelected = cards =>
                    {
                        var actionCard = cards.OfType<IActionCard>().Single();
                        log.LogMessage("{0} selected {1} to be played twice.", player.Name, actionCard.Name);

                        actionCard.MoveTo(context.ActivePlayer.PlayArea);
                        context.AddEffect(source, new PlayCardEffect(actionCard));
                        context.AddEffect(source, new PlayCardEffect(actionCard));                        
                    };

                    _activities.Add(activity);
                }
                    
            }
 public DamageDealt(IGame game, ICard source, ICardInPlay target, byte damage)
     : base(game)
 {
     this.Source = source;
     this.Target = target;
     this.damage = damage;
 }
Beispiel #22
0
 public void AddCard(ICard card)
 {
     if (card == null)
         throw new ArgumentNullException("Card must not be null!");
     else
         _hand.AddCard(card);
 }
Beispiel #23
0
 public override void Process(Player source, List<Player> dests, ICard card, ReadOnlyCard readonlyCard)
 {
     DeckType wuguDeck = new DeckType("WuGu");
     DeckType wuguFakeDeck = new DeckType("WuGuFake");
     CardsMovement move = new CardsMovement();
     move.Cards = new List<Card>();
     for (int i = 0; i < dests.Count; i++)
     {
         Game.CurrentGame.SyncImmutableCardAll(Game.CurrentGame.PeekCard(0));
         Card c = Game.CurrentGame.DrawCard();
         move.Cards.Add(c);
     }
     move.To = new DeckPlace(null, wuguDeck);
     Game.CurrentGame.MoveCards(move);
     fakeMapping = new Dictionary<Card, Card>();
     Game.CurrentGame.Decks[null, wuguFakeDeck].Clear();
     foreach (var c in Game.CurrentGame.Decks[null, wuguDeck])
     {
         var faked = new Card(c);
         faked.Place = new DeckPlace(null, wuguFakeDeck);
         Game.CurrentGame.Decks[null, wuguFakeDeck].Add(faked);
         fakeMapping.Add(faked, c);
     }
     Game.CurrentGame.NotificationProxy.NotifyWuGuStart(new DeckPlace(null, wuguFakeDeck));
     base.Process(source, dests, card, readonlyCard);
     Game.CurrentGame.NotificationProxy.NotifyWuGuEnd();
     Game.CurrentGame.Decks[null, wuguFakeDeck].Clear();
     if (Game.CurrentGame.Decks[null, wuguDeck].Count > 0)
     {
         move = new CardsMovement();
         move.Cards = new List<Card>(Game.CurrentGame.Decks[null, wuguDeck]);
         move.To = new DeckPlace(null, DeckType.Discard);
         Game.CurrentGame.MoveCards(move);
     }
 }
        public override void TagAndNotify(Player source, List<Player> dests, ICard card, GameAction action = GameAction.Use)
        {
            if (this.IsReforging(source, null, null, dests))
            {
                if (card is CompositeCard)
                {
                    foreach (Card c in (card as CompositeCard).Subcards)
                    {
                        c.Log.Source = source;
                        c.Log.GameAction = GameAction.Reforge;
                    }

                }
                else
                {
                    var c = card as Card;
                    Trace.Assert(card != null);
                    c.Log.Source = source;
                    c.Log.GameAction = GameAction.Reforge;
                }
                Game.CurrentGame.NotificationProxy.NotifyReforge(source, card);
                return;
            }
            base.TagAndNotify(source, dests, card, action);
        }
        public void TestCompareHands_HighCard()
        {
            ICard[] cards1 = new ICard[5]
            {
                new Card(CardFace.Ace, CardSuit.Clubs),
                new Card(CardFace.Ten, CardSuit.Diamonds),
                new Card(CardFace.Nine, CardSuit.Clubs),
                new Card(CardFace.Five, CardSuit.Clubs),
                new Card(CardFace.Four, CardSuit.Clubs)
            };
            IHand hand1 = new Hand(cards1);

            ICard[] cards2 = new ICard[5]
            {
                new Card(CardFace.King, CardSuit.Clubs),
                new Card(CardFace.Queen, CardSuit.Clubs),
                new Card(CardFace.Jack, CardSuit.Clubs),
                new Card(CardFace.Eight, CardSuit.Spades),
                new Card(CardFace.Six, CardSuit.Diamonds)
            };
            IHand hand2 = new Hand(cards2);

            int compareResult = handChecker.CompareHands(hand1, hand2);

            Assert.IsTrue(compareResult > 0);
        }
 public GetJudgeCardTrigger(Player p, ISkill skill, ICard card, bool permenant = false)
 {
     Owner = p;
     jSkill = skill;
     jCard = card;
     doNotUnregister = permenant;
 }
Beispiel #27
0
            public override void Attack(Player victim, TurnContext context, ICard source)
            {
                var swindledCard = victim.Deck.TopCard;
                if(swindledCard == null)
                {
                    context.Game.Log.LogMessage("{0} did not have any cards to be swindled.", victim.Name);
                    return;
                }
                
                context.Trash(victim, swindledCard);
                var candidates = context.Game.Bank.Piles.Where(p => p.IsEmpty == false && p.TopCard.Cost == swindledCard.Cost);                

                if(candidates.Count() == 0)
                {
                    context.Game.Log.LogMessage("There are no cards of cost {0}.", swindledCard.Cost);
                }
                else if (candidates.Count() == 1)
                {
                    var pile = candidates.Single();
                    var card = pile.TopCard;
                    card.MoveTo(victim.Discards);
                    context.Game.Log.LogGain(victim, card);
                }
                else
                {
                    var activity = Activities.SelectACardForOpponentToGain(context, context.ActivePlayer, victim, swindledCard.Cost, source);
                    _activities.Add(activity);    
                }
            }
Beispiel #28
0
 public void CmdDestroyCard(ICard card)
 {
     if(card.cardtype == ECardType.MONSTER_CARD)
     {
         for(int i = 0; i < monsterCards.Length; i++)
         {
             if(card == monsterCards[i])
             {
                 DestroyMonsterCard(i);
                 return;
             }
         }
     }
     else if(card.cardtype != ECardType.UNKNOWN)
     {
         for(int i = 0; i < effectCards.Length; i++)
         {
             if(card == effectCards[i])
             {
                 DestroyEffectCard(i);
                 return;
             }
         }
     }
 }
Beispiel #29
0
            public override void Attack(Player victim, TurnContext context, ICard source)
            {
                var victoryTypes = victim.Hand.OfType<IVictoryCard>()
                    .WithDistinctTypes()
                    .ToList();

                if(victoryTypes.Count() > 1)
                {
                    var activity = Activities.PutCardOfTypeFromHandOnTopOfDeck(context.Game.Log, victim,
                                                                               "Select a victory card to put on top",
                                                                               typeof (IVictoryCard),
                                                                               source);
                   _activities.Add(activity);
                }
                else if(victoryTypes.Any())
                {
                    var card = victoryTypes.Single();
                    victim.Deck.MoveToTop(card);
                    context.Game.Log.LogMessage("{0} put a {1} on top of the deck.", victim.Name, card.Name);
                }
                else
                {
                    context.Game.Log.LogRevealHand(victim);
                }
            }
Beispiel #30
0
        private void SaveChangesToCard(IUserSet currentUserSet, ICard currentCard)
        {       
            Card existingCard = FindCard(currentUserSet, currentCard);
            Card modifiedCard = (Card)currentCard;

            Type typeOfExistingCard = existingCard.GetType();
            Type typeOfModifiedCard = modifiedCard.GetType();

            List<PropertyInfo> propertiesExistingCard = new List<PropertyInfo>(typeOfExistingCard.GetRuntimeProperties());
            List<PropertyInfo> propertiesModifiedCard = new List<PropertyInfo>(typeOfModifiedCard.GetRuntimeProperties());

            // check if the properties are changed in the meantime. Should not be.
            for (int i = 0; i < propertiesExistingCard.Count; i++)
            {
                if(propertiesExistingCard[i].Name == propertiesModifiedCard[i].Name)
                {
                    propertiesExistingCard[i].SetValue(existingCard, propertiesModifiedCard[i].GetValue(modifiedCard));
                }
                else
                {
                    throw new ArrayTypeMismatchException("Cannot save the modified Card information",
                                                            new Exception(
                                                                "The type of the card is changed, because the properties ofthe existing and modified cards are not the same "));
                }
            }
        }
Beispiel #31
0
 public override void Resolve(TurnContext context, ICard source)
 {
     _card.Play(context);
 }
Beispiel #32
0
 public Card(ICard card)
     : this(card.Id, card.SetId, card.Name.Clone() as string, card.ImageUri.Clone() as string, card.Alternate.Clone() as string, card.Size, card.CloneProperties())
 {
 }
        private static SkillResponse BuildResponse(IOutputSpeech outputSpeech, bool shouldEndSession, Session sessionAttributes, Reprompt reprompt, ICard card)
        {
            SkillResponse response = new SkillResponse {
                Version = "1.0"
            };

            if (sessionAttributes != null)
            {
                response.SessionAttributes = sessionAttributes.Attributes;
            }

            ResponseBody body = new ResponseBody
            {
                ShouldEndSession = shouldEndSession,
                OutputSpeech     = outputSpeech
            };

            if (reprompt != null)
            {
                body.Reprompt = reprompt;
            }
            if (card != null)
            {
                body.Card = card;
            }

            response.Response = body;

            return(response);
        }
 public void AddCards(ICard card)
 {
     dealerCards.Add(card);
 }
Beispiel #35
0
        public override async Task <MessageView> BuildView(ICard item)
        {
            Embed embed = await BuildEmbed(item);

            return(new MessageView(embed));
        }
Beispiel #36
0
 public static bool CheckMatch(this ICard lCard, ICard rCard)
 {
     return(lCard.Value == rCard.Value);
 }
Beispiel #37
0
 public void AddCardToHand(ICard card)
 {
     _hand.AddCard(card);
 }
Beispiel #38
0
 public void ShowCard(ICard card)
 {
     _view.Cards.FirstOrDefault(x => ((ICard)(x.Tag))?.Number == card.Number).Left = 0;
 }
Beispiel #39
0
 public void TrashCard(ICard card)
 {
     Cards.Add(card);
 }
 public void AddCardToDeck(ICard card)
 {
     Cards.Add(card);
 }
Beispiel #41
0
 public void DecreaseTemplateDominance(ICard copy)
 {
     DominanceDegree[copy] = DominanceDegree[copy] + 1;
 }
Beispiel #42
0
 public void RegisterCopy(ICard copy)
 {
     DominanceDegree.Add(copy, 0);
 }
Beispiel #43
0
 public void Discard(ICard card)
 {
     this.DiscardPile.Push(card);
 }
Beispiel #44
0
        public override ICard PlayCard(Prompt prompt, List <IRound> rounds, IPlayer picker, IBlind blind, ICard partnerCard)
        {
            var trick = rounds.Last().Trick;
            var cards = Hand.GetPlayableCards(trick.LeadingCard());

            cards.Sort();
            cards.Reverse();
            ICard playThis;

            if (!_isPartner && picker != this)
            {
                _isPartner = Hand.Contains(partnerCard);
            }
            if (!trick.Any())
            {
                if (picker == this)
                {
                    playThis = cards[0];
                }
                else if (_isPartner)
                {
                    playThis = cards[0];
                }
                else
                {
                    playThis = cards.Aggregate((acc, next) => acc.IsTrump() && !next.IsTrump() ? next : acc);
                }
            }
            else
            {
                var winCard         = trick.TheWinnerCard();
                var isPickerWinning = trick.TheWinnerPlayer() == picker;
                if (isPickerWinning && _isPartner)
                {
                    playThis = cards.Aggregate((acc, next) => acc.Value >= next.Value ? acc : next);
                }
                else if (!isPickerWinning && _isPartner)
                {
                    playThis = cards[0];
                }
                else if (isPickerWinning && !_isPartner)
                {
                    if (cards[0].Power > winCard.Power)
                    {
                        playThis = cards[0];
                    }
                    else
                    {
                        cards.Sort();
                        playThis = cards.Aggregate((acc, next) => acc.Value <= next.Value ? acc : next);
                    }
                }
                else
                {
                    playThis = cards[0].Power > winCard.Power ? cards[0] : cards.Last();
                }
            }
            Hand.RemoveCard(playThis);
            prompt(PromptType.BotPlayCard, new Dictionary <PromptData, object> {
                { PromptData.Player, this },
                { PromptData.Card, playThis },
                { PromptData.Trick, rounds.Last().Trick }
            });
            return(playThis);
        }
Beispiel #45
0
 public void Add(ICard card)
 {
     _hand.Add(card);
 }
Beispiel #46
0
 public void Remove(ICard card)
 {
     _hand.Remove(card);
 }
Beispiel #47
0
 public void PickCardResponse(ICard cardSelected)
 {
     _selectedCard = cardSelected;
 }
 /// <summary>
 /// The NewCard.
 /// </summary>
 /// <param name="card">The card<see cref="ICard{V}"/>.</param>
 /// <returns>The <see cref="ICard{V}"/>.</returns>
 public override ICard <V> NewCard(ICard <V> card)
 {
     return(new Card64 <V>(card));
 }
Beispiel #49
0
        public static IActivity GainOpponentsCardChoice(TurnContext context, Card card, Player cardOwner, ICard source)
        {
            var activity = new ChoiceActivity(context, context.ActivePlayer,
                                              string.Format("Gain {0}'s {1}?", cardOwner.Name, card), source, Choice.Yes, Choice.No);

            activity.ActOnChoice = choice =>
            {
                if (choice == Choice.Yes)
                {
                    card.MoveTo(context.ActivePlayer.Discards);
                    context.Game.Log.LogGain(context.ActivePlayer, card);
                }
            };

            activity.Hint = ActivityHint.GainCards;

            return(activity);
        }
Beispiel #50
0
 public void RevealCard(ICard card)
 {
     RevealCardHandler(Id, card);
 }
Beispiel #51
0
 public static GainACardActivity GainACardCostingUpToX(IGameLog log, Player player, CardCost cost, CardZone destination, ICard source)
 {
     return(new GainACardActivity(log, player, string.Format("Select a card to gain of cost {0} or less.", cost),
                                  SelectionSpecifications.SelectPileCostingUpToX(cost), destination, source));
 }
Beispiel #52
0
 public static ISelectCardsActivity DiscardCards(TurnContext context, Player player, int numberToDiscard, ICard source)
 {
     return(new SelectCardsActivity(
                context.Game.Log, player, string.Format("Select {0} card(s) to discard.", numberToDiscard),
                SelectionSpecifications.SelectExactlyXCards(numberToDiscard), source)
     {
         AfterCardsSelected = cards => context.DiscardCards(player, cards),
         Hint = ActivityHint.DiscardCards
     });
 }
Beispiel #53
0
 public static IEnumerable <ISelectCardsActivity> PutMultipleCardsFromHandOnTopOfDeck(IGameLog log, Player player, int count, ICard source)
 {
     return(count.Items(i => PutCardFromHandOnTopOfDeck(log, player,
                                                        string.Format("Select the {0} (of {1}) card to put on top of the deck.", i.ToOrderString(), count), source)));
 }
Beispiel #54
0
 public static GainACardActivity GainACardCostingExactlyX(IGameLog log, Player player, CardCost cost, CardZone destination, ICard source)
 {
     return(new GainACardActivity(log, player,
                                  string.Format("Select a card to gain with a cost of exactly {0}.", cost),
                                  SelectionSpecifications.SelectPileCostingExactlyX(cost), destination, source));
 }
Beispiel #55
0
        public static IActivity ChooseWhetherToMillTopCard(TurnContext context, Player choosingPlayer, Player targetPlayer, ICard source)
        {
            var revealZone = new RevealZone(targetPlayer);

            targetPlayer.Deck.TopCard.MoveTo(revealZone);
            revealZone.LogReveal(context.Game.Log);

            var otherPlayerMessage = string.Format("Put {0}'s card in the discard pile?", targetPlayer.Name);
            var selfMessage        = "Put your own card in the discard pile?";

            var activity = new ChooseBasedOnRevealedCardsActivity(
                context.Game.Log,
                choosingPlayer,
                revealZone,
                choosingPlayer == targetPlayer ? selfMessage : otherPlayerMessage,
                source,
                Choice.Yes,
                Choice.No
                );

            activity.ActOnChoice = choice =>
            {
                var    card = revealZone.Single();
                string actionDescription;
                if (choice == Choice.Yes)
                {
                    actionDescription = "into the discard pile";
                    card.MoveTo(targetPlayer.Discards);
                }
                else
                {
                    actionDescription = "back on top";
                    targetPlayer.Deck.MoveToTop(card);
                }

                var message = string.Format("{0} put {1}'s {2} {3}.", context.ActivePlayer, targetPlayer, card.Name, actionDescription);
                context.Game.Log.LogMessage(message);
            };

            return(activity);
        }
Beispiel #56
0
 public static GainACardActivity GainACardCostingUpToX(IGameLog log, Player player, CardCost cost, ICard source)
 {
     return(GainACardCostingUpToX(log, player, cost, player.Discards, source));
 }
Beispiel #57
0
 public bool Apply(ICard card) => card is ITreasure;
Beispiel #58
0
        public static ISelectCardsActivity PutCardOfTypeFromHandOnTopOfDeck(IGameLog log, Player player, string message, Type cardType, ICard source)
        {
            var spec = SelectionSpecifications.SelectExactlyXCards(1);

            spec.CardTypeRestriction = cardType;

            return(new SelectCardsActivity
                       (log, player, message, spec, source)
            {
                AfterCardsSelected = cards =>
                {
                    var card = cards.Single();
                    player.Deck.MoveToTop(card);
                    log.LogMessage("{0} put a {1} on top of the deck.", player.Name, card.Name);
                },
                Hint = ActivityHint.RedrawCards
            });
        }
 public static void RemoveCard(ICard removeCard)
 {
     fiftyTwo.Remove(removeCard);
 }
Beispiel #60
0
        public static ISelectCardsActivity SelectActionToPlayMultipleTimes(TurnContext context, Player player, IGameLog log, ICard source, int count)
        {
            var activity = new SelectCardsActivity(
                log, player,
                string.Format("Select an action to play {0} times", count),
                SelectionSpecifications.SelectExactlyXCards(1), source);

            activity.Hint = ActivityHint.PlayCards;
            activity.Specification.CardTypeRestriction = typeof(IActionCard);
            activity.AfterCardsSelected = cards =>
            {
                var actionCard = cards.OfType <IActionCard>().Single();
                log.LogMessage("{0} selected {1} to be played {2} times.", player.Name, actionCard.Name, count);

                actionCard.MoveTo(context.ActivePlayer.PlayArea);

                count.Times(() => context.AddEffect(source, new PlayCardEffect(actionCard)));
            };

            return(activity);
        }