internal void player_RevealHorseTraders(Player player, ref AttackedEventArgs e) { player.AddCardInto(DeckLocation.Revealed, player.RetrieveCardFrom(DeckLocation.Hand, this.PhysicalCard)); player.AddCardInto(DeckLocation.SetAside, player.RetrieveCardFrom(DeckLocation.Revealed, this.PhysicalCard)); // Attack isn't cancelled... it's just mitigated e.HandledBy.Add(TypeClass.HorseTraders); }
internal void player_RevealMoat(Player player, ref AttackedEventArgs e) { player.AddCardInto(DeckLocation.Revealed, player.RetrieveCardFrom(DeckLocation.Hand, this.PhysicalCard)); e.Cancelled = true; player.AddCardInto(DeckLocation.Hand, player.RetrieveCardFrom(DeckLocation.Revealed, this.PhysicalCard)); e.HandledBy.Add(TypeClass.Moat); }
/// <summary> /// Helper function used to fire Attacked events. /// </summary> /// <param name="e">The attacked event arguments.</param> /// <param name="clearOnly">Only clear the action, don't fire the event.</param> private void OnAttacked(AttackedEventArgs e, bool clearOnly) { if (!clearOnly && Attacked != null) { Attacked(this, e); } }
protected virtual void OnAttacked(AttackedEventArgs e) { if (Attacked != null) { Attacked(this, e); } }
private AttackedEventArgs OnAttackedForOut() { AttackedEventArgs args = new AttackedEventArgs(); OnAttacked(args); return(args); }
private AttackedEventArgs OnAttacked(Unit attackedUnit) { AttackedEventArgs args = new AttackedEventArgs(attackedUnit); OnAttacked(args); return(args); }
/// <summary> /// Adds a new AttackEventArgs to the collection for a creature. /// When the creature executes the next tick, each of these will /// create an Attacked event that can be used to determine which /// of the one or more creatures attack in the previous tick. /// </summary> /// <param name="attackedEventArgs">Represents the creature doing the attacking</param> public void Add(AttackedEventArgs attackedEventArgs) { if (IsImmutable) { throw new ApplicationException("Object is immutable."); } InnerList.Add(attackedEventArgs); }
protected void Attack(Actor defender, uint strenght) { if (defender is null) { throw new ArgumentNullException(nameof(defender)); } var ea = new AttackedEventArgs(this, defender, strenght); Attacked?.Invoke(this, ea); defender.ReceiveDamage(strenght, this); }
// Fired if we're being attacked private void MyAnimal_Attacked(object sender, AttackedEventArgs e) { if (e.Attacker.IsAlive) { AnimalState TheAttacker = e.Attacker; BeginDefending(TheAttacker); //defend against the attacker WriteTrace("Run away to some random point"); int X = OrganismRandom.Next(0, WorldWidth - 1); int Y = OrganismRandom.Next(0, WorldHeight - 1); BeginMoving(new MovementVector(new Point(X, Y), 10)); } }
internal override void player_Attacked(object sender, AttackedEventArgs e) { Player player = sender as Player; // Secret Chamber only protects against other attackers if (player == e.Attacker) { return; } // Only allow a single handling by a given card type if (player.Hand.Contains(this.PhysicalCard) && !e.HandledBy.Contains(TypeClass.SecretChamber) && !e.Revealable.ContainsKey(TypeClass.SecretChamber)) { e.Revealable[TypeClass.SecretChamber] = new AttackReaction(this, String.Format("Reveal {0}", this.PhysicalCard), player_RevealSecretChamber); } }
internal override void player_Attacked(object sender, AttackedEventArgs e) { Player player = sender as Player; // Horse Traders only protects against other attackers if (player == e.Attacker) { return; } // Make sure it exists already if (player.Hand.Contains(this.PhysicalCard) && !e.Revealable.ContainsKey(TypeClass.HorseTraders)) { e.Revealable[TypeClass.HorseTraders] = new AttackReaction(this, String.Format("Reveal {0}", this.PhysicalCard), player_RevealHorseTraders); } }
internal override void player_Attacked(object sender, AttackedEventArgs e) { Player player = sender as Player; // Moat only protects against other attackers if (player == e.Attacker) { return; } // Already been cancelled -- don't need to process this one if (player.Hand.Contains(this.PhysicalCard) && !e.Cancelled && !e.Revealable.ContainsKey(TypeClass.Moat)) { e.Revealable[TypeClass.Moat] = new AttackReaction(this, String.Format("Reveal {0}", this.PhysicalCard), player_RevealMoat); } }
internal void player_RevealSecretChamber(Player player, ref AttackedEventArgs e) { player.AddCardInto(DeckLocation.Revealed, player.RetrieveCardFrom(DeckLocation.Hand, this.PhysicalCard)); player.AddCardToHand(player.RetrieveCardFrom(DeckLocation.Revealed, this.PhysicalCard)); player.Draw(2, DeckLocation.Hand); Choice replaceChoice = new Choice("Choose order of cards to put back on your deck", this, new CardCollection() { e.AttackCard }, player.Hand, player, true, 2, 2); ChoiceResult replaceResult = player.MakeChoice(replaceChoice); player.RetrieveCardsFrom(DeckLocation.Hand, replaceResult.Cards); player.AddCardsToDeck(replaceResult.Cards, DeckPosition.Top); e.HandledBy.Add(TypeClass.SecretChamber); // Attack isn't cancelled... it's just mitigated }
public void OnAttacked(AttackedEventArgs args) { throw new System.NotImplementedException(); }
protected override ChoiceResult Decide_Attacked(Choice choice, AttackedEventArgs aea, IEnumerable<Type> cardsToReveal) { // Always reveal my Moat if the attack hasn't been cancelled yet if (!aea.Cancelled && cardsToReveal.Contains(Cards.Base.TypeClass.Moat)) return new ChoiceResult(new CardCollection() { aea.Revealable[Cards.Base.TypeClass.Moat].Card }); // Always reveal my Secret Chamber if it hasn't been revealed yet if ((_LastReactedCard == null || _LastReactedCard != choice.CardTriggers[0]) && cardsToReveal.Contains(Cards.Intrigue.TypeClass.SecretChamber) && !aea.HandledBy.Contains(Cards.Intrigue.TypeClass.SecretChamber)) return new ChoiceResult(new CardCollection() { aea.Revealable[Cards.Intrigue.TypeClass.SecretChamber].Card }); // Always reveal my Horse Traders if I can if (cardsToReveal.Contains(Cards.Cornucopia.TypeClass.HorseTraders)) return new ChoiceResult(new CardCollection() { aea.Revealable[Cards.Cornucopia.TypeClass.HorseTraders].Card }); // Always reveal my Horse Traders if I can if (cardsToReveal.Contains(Cards.DarkAges.TypeClass.Beggar)) { // Don't reveal Beggar for these Attacks -- Also, keep Beggar around if Young Witch is played and Beggar is the Bane card if (aea.AttackCard.CardType != Cards.Base.TypeClass.Thief && aea.AttackCard.CardType != Cards.Seaside.TypeClass.PirateShip && aea.AttackCard.CardType != Cards.Hinterlands.TypeClass.NobleBrigand && (aea.AttackCard.CardType != Cards.Cornucopia.TypeClass.YoungWitch || !this.RealThis._Game.Table.Supplies[Cards.DarkAges.TypeClass.Beggar].Tokens.Any(t => t.GetType() != Cards.Cornucopia.TypeClass.BaneToken))) { return new ChoiceResult(new CardCollection() { aea.Revealable[Cards.DarkAges.TypeClass.Beggar].Card }); } } return new ChoiceResult(new CardCollection()); }
// Stub for Attacks, so they can get called during an existing attack internal virtual void player_Attacked(object sender, AttackedEventArgs e) { }
//- Property controll methods public virtual bool Attacked(object sender, AttackedEventArgs e) { OnRaiseUpdateHP(new UpdateHPEventArgs(0 - e.RawDammage)); return(true); }
protected override ChoiceResult Decide_Attacked(Choice choice, AttackedEventArgs aea, IEnumerable<Type> cardsToReveal) { if (cardsToReveal.Contains(Cards.Base.TypeClass.Moat) && !aea.Cancelled) return new ChoiceResult(new CardCollection() { aea.Revealable[Cards.Base.TypeClass.Moat].Card }); // Always reveal Horse Traders (any reason *not* to?) if (cardsToReveal.Contains(Cards.Cornucopia.TypeClass.HorseTraders)) return new ChoiceResult(new CardCollection() { aea.Revealable[Cards.Cornucopia.TypeClass.HorseTraders].Card }); if (cardsToReveal.Contains(Cards.Intrigue.TypeClass.SecretChamber) && !aea.HandledBy.Contains(Cards.Intrigue.TypeClass.SecretChamber) && (_LastReactedCard == null || _LastReactedCard != choice.CardTriggers[0])) return new ChoiceResult(new CardCollection() { aea.Revealable[Cards.Intrigue.TypeClass.SecretChamber].Card }); return new ChoiceResult(new CardCollection()); }
public virtual void OnAttacked(AttackedEventArgs args) { }