private void HealOneDamageOnCharacter(IGame game, IEffectHandle handle, IPlayer player, ICharacterInPlay glorfindel, ICharacterInPlay character)
            {
                glorfindel.Resources -= 1;
                character.Damage -= 1;

                handle.Resolve(string.Format("{0} chose to heal 1 damage on '{1}'", player.Name, character.Title));
            }
        protected void PayResourcesFromCharacter(IGame game, IEffectHandle handle, ICharacterInPlay character, IPlayer player, byte numberOfResources)
        {
            var charactersAndPayments = new List <Tuple <ICharacterInPlay, byte> >();

            charactersAndPayments.Add(new Tuple <ICharacterInPlay, byte>(character, numberOfResources));
            PayResourcesFromCharacters(game, handle, charactersAndPayments, player);
        }
Beispiel #3
0
            private void HealCreatureInPlay(IGame game, IEffectHandle handle, IPlayer controller, ICharacterInPlay radagast, ICharacterInPlay creature, byte numberOfResources)
            {
                radagast.Resources -= numberOfResources;
                creature.Damage -= numberOfResources;

                handle.Resolve(string.Format("{0} chose to have '{1}' heal {2} damage from '{3}'", controller.Name, CardSource.Title, numberOfResources, creature.Title));
            }
        public void AddPayment(ICharacterInPlay character, byte numberOfResources)
        {
            if (character == null)
                throw new ArgumentNullException("character");

            if (payments.ContainsKey(character.Card.Id))
                throw new ArgumentException("character is already included in this payment");

            if (character.Resources < numberOfResources)
                throw new ArgumentException("character does not have enough resources to make a payment of: " + numberOfResources);

            characters.Add(character);
            payments.Add(character.Card.Id, numberOfResources);
        }
        public void AddPayment(ICharacterInPlay character, byte numberOfResources)
        {
            if (character == null)
            {
                throw new ArgumentNullException("character");
            }

            if (payments.ContainsKey(character.Card.Id))
            {
                throw new ArgumentException("character is already included in this payment");
            }

            if (character.Resources < numberOfResources)
            {
                throw new ArgumentException("character does not have enough resources to make a payment of: " + numberOfResources);
            }

            characters.Add(character);
            payments.Add(character.Card.Id, numberOfResources);
        }
            private void PayResourcesToReadyAttachedCharacter(IGame game, IEffectHandle handle, IPlayer player, ICharacterInPlay character)
            {
                var refreshPhase = game.CurrentPhase as IRefreshPhase;
                if (refreshPhase == null)
                    throw new InvalidOperationException("This effect can only be triggered during the refresh phase");

                var readyingCard = refreshPhase.GetReadyingCards().Where(x => x.Exhaustable.BaseCard.Id == source.Id).FirstOrDefault();
                if (readyingCard == null)
                {
                    handle.Cancel(string.Format("Could not determine the readying state of '{0}'", character.Title));
                    return;
                }

                character.Resources -= 2;
                readyingCard.IsReadying = true;

                handle.Resolve(string.Format("{0} chose to pay 2 resources from {1}'s resource pool to allow them to ready ({2})", player.Name, character.Title, CardSource.Title));
            }
Beispiel #7
0
            private void PayResourcesToReadyAttachedCharacter(IGame game, IEffectHandle handle, IPlayer player, ICharacterInPlay character)
            {
                var refreshPhase = game.CurrentPhase as IRefreshPhase;

                if (refreshPhase == null)
                {
                    throw new InvalidOperationException("This effect can only be triggered during the refresh phase");
                }

                var readyingCard = refreshPhase.GetReadyingCards().Where(x => x.Exhaustable.BaseCard.Id == source.Id).FirstOrDefault();

                if (readyingCard == null)
                {
                    handle.Cancel(string.Format("Could not determine the readying state of '{0}'", character.Title));
                    return;
                }

                character.Resources    -= 2;
                readyingCard.IsReadying = true;

                handle.Resolve(string.Format("{0} chose to pay 2 resources from {1}'s resource pool to allow them to ready ({2})", player.Name, character.Title, CardSource.Title));
            }
Beispiel #8
0
 public CheckForResourceIcon(IGame game, ICharacterInPlay target, Sphere resourceIcon)
     : base(game)
 {
     this.Target       = target;
     this.ResourceIcon = resourceIcon;
 }
 public CollectingResources(IGame game, ICharacterInPlay character, byte resourcesToCollect)
     : base(game)
 {
     this.Character          = character;
     this.resourcesToCollect = resourcesToCollect;
 }
 public CollectingResources(IGame game, ICharacterInPlay character, byte resourcesToCollect)
     : base(game)
 {
     this.Character = character;
     this.resourcesToCollect = resourcesToCollect;
 }
            private void HealOneDamageOnCharacter(IGame game, IEffectHandle handle, IPlayer player, ICharacterInPlay glorfindel, ICharacterInPlay character)
            {
                glorfindel.Resources -= 1;
                character.Damage     -= 1;

                handle.Resolve(string.Format("{0} chose to heal 1 damage on '{1}'", player.Name, character.Title));
            }
 private void DealTwoDamageToChosenCharacter(IGame game, IEffectHandle handle, ICharacterInPlay character)
 {
     character.Damage += 2;
     handle.Resolve(string.Format("'{0}' dealt 2 damage to '{1}'", CardSource.Title, character.Title));
 }
 private void DealTwoDamageToChosenCharacter(IGame game, IEffectHandle handle, ICharacterInPlay character)
 {
     character.Damage += 2;
     handle.Resolve(string.Format("'{0}' dealt 2 damage to '{1}'", CardSource.Title, character.Title));
 }
            private void ExhaustAndAddTwoResources(IGame game, IEffectHandle handle, IPlayer player, IExhaustableInPlay exhaustable, ICharacterInPlay resourceful)
            {
                exhaustable.Exhaust();
                resourceful.Resources += 2;

                handle.Resolve(string.Format("{0} chose to exhaust '{1}' to add 2 resources to {2}'s resource pool", player.Name, CardSource.Title, resourceful.Title));
            }
 public CheckForResourceIcon(IGame game, ICharacterInPlay target, Sphere resourceIcon)
     : base(game)
 {
     this.Target = target;
     this.ResourceIcon = resourceIcon;
 }
 protected void PayResourcesFromCharacter(IGame game, IEffectHandle handle, ICharacterInPlay character, IPlayer player, byte numberOfResources)
 {
     var charactersAndPayments = new List<Tuple<ICharacterInPlay, byte>>();
     charactersAndPayments.Add(new Tuple<ICharacterInPlay, byte>(character, numberOfResources));
     PayResourcesFromCharacters(game, handle, charactersAndPayments, player);
 }
Beispiel #17
0
            private void HealCreatureInPlay(IGame game, IEffectHandle handle, IPlayer controller, ICharacterInPlay radagast, ICharacterInPlay creature, byte numberOfResources)
            {
                radagast.Resources -= numberOfResources;
                creature.Damage    -= numberOfResources;

                handle.Resolve(string.Format("{0} chose to have '{1}' heal {2} damage from '{3}'", controller.Name, CardSource.Title, numberOfResources, creature.Title));
            }