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)
{
}
