public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Sorcery }, null, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{X}{U}{U}");
// This must be a new delegate every time. Otherwise we mess up the card reference.
(card.Cost as ManaCost).ValueforXChosen += (x => card.SetVar("X", x));
card.OnCast = (g, c) =>
{
var target = c.Controller.ChoosePlayer("Choose Target Player", g.Players().Where(p => true));// p.CanBeTargetedBy(c)))
c.SetVar("Target", target);
};
card.OnResolve = (g, c) =>
{
var target = c.GetVar <Player>("Target");
var X = c.GetVar <int>("X");
target.Draw(X);
};
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Instant }, null, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.CanCast = (g, c) =>
{
// Cast this spell only during combat before blockers are declared
return(g.CurrentStep == Phases.DeclareAttackers);
};
card.OnCast = (g, c) =>
{
var creaturesControlledByDefendingPlayers = new List <ITarget>();
var attackingCreatures = g.Battlefield.Creatures.Where(_c => _c.IsAttacking).ToList();
var defendingPlayers = attackingCreatures.Select(_c => _c.DefendingPlayer).Distinct().ToList();
foreach (var player in defendingPlayers)
{
// Add all creatures that player controls that can block any attacking creature that is attacking that player
creaturesControlledByDefendingPlayers.AddRange(player.Battlefield.Creatures.Where(_d => attackingCreatures.Any(_c => _c.DefendingPlayer == player && _d.CanBlock(_c))));
}
var target = c.Controller.ChooseTarget(c, creaturesControlledByDefendingPlayers) as Card;
c.SetVar("Target", target);
};
// Target creature defending player controls can block any number of creatures this turn. It blocks each attacking creature this turn if able.
return(card);
}
public override Card GetCard(Player owner)
{
Func <Game, Card, int> basePowerFunc = (g, c) =>
{
var cardTypes = new List <CardType>();
foreach (var graveyard in g.Players().Select(p => p.Graveyard))
{
foreach (var c2 in graveyard)
{
foreach (var cardType in c2.Types)
{
if (!cardTypes.Contains(cardType))
{
cardTypes.Add(cardType);
}
}
}
}
return(cardTypes.Count);
};
Func <Game, Card, int> baseToughnessFunc = (g, c) =>
{
return(1 + c.BasePowerFunc(g, c));
};
var card = new Card(owner, new[] { CardType.Creature }, new[] { "Lhurgoyf" }, false, basePowerFunc, baseToughnessFunc, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{1}{G}");
return(card);
}
public override Card GetCard(Player owner)
{
var card = base.GetCard(owner);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new CardType[] { CardType.Creature }, new string[] { "Elemental" }, false, 8, 8, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{W}{U}{B}{R}{G}");
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Creature }, new[] { "Dinosaur" }, false, 10, 10, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{G}{G}{G}{G}{G}");
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Enchantment }, null, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
// TODO: {W}: Target creature gets +1/+1 until end of turn
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Enchantment }, null, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{3}{W}");
card.AddEffect(new CastleEffect(card));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Creature }, new[] { "Spider" }, false, 2, 4, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{3}{G}");
card.AddStaticAbility(StaticAbility.Reach);
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Artifact, CardType.Creature }, new[] { "Myr" }, false, 0, 1, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{3}");
card.AddStaticAbility(StaticAbility.Indestructible);
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Land }, null, false, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.Colorless), "{T}: Add {C}"));
card.AddAbility(new CopyAbility(card));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Artifact }, null, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{3}");
card.AddAbility(new ManaAbility(card, new SacrificeCreatureCost(card), new Common.Mana.ManaAmount(2, ManaColor.Colorless), "Sacrifice a Creature: Add {C}{C}."));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Creature }, new[] { "Beast" }, false, 3, 1, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{1}{G}");
card.AddStaticAbility(StaticAbility.Vigilance);
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Creature }, new[] { "Bird" }, false, 1, 2, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{W}");
card.AddStaticAbility(StaticAbility.Flying);
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Creature }, new[] { "Wurm" }, false, 7, 7, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{5}{G}{G}");
card.AddAbility(new EngulfingSlagwurmAbility(card));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Creature }, new[] { "Human", "Soldier" }, false, 1, 1, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{1}{W}");
card.AddStaticAbility(StaticAbility.DoubleStrike);
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Land }, new[] { "Island", "Mountain" }, false, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.Blue), "{T}: Add {U}"));
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.Red), "{T}: Add {R}"));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Land }, new[] { "Plains", "Swamp" }, false, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.White), "{T}: Add {W}"));
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.Black), "{T}: Add {B}"));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Creature }, new[] { "Wraith" }, false, 3, 3, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{3}{B}");
card.AddStaticAbility(StaticAbility.Swampwalk);
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Artifact }, null, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.AddAbility(new ManaAbility(card, new AggregateCost(card, new TapCost(card), new SacrificeSourceCost(card)), new ManaAmount(3, ManaColor.White), "{T}, Sacrifice Black Lotus: Add {W}{W}{W}"));
card.AddAbility(new ManaAbility(card, new AggregateCost(card, new TapCost(card), new SacrificeSourceCost(card)), new ManaAmount(3, ManaColor.Blue), "{T}, Sacrifice Black Lotus: Add {U}{U}{U}"));
card.AddAbility(new ManaAbility(card, new AggregateCost(card, new TapCost(card), new SacrificeSourceCost(card)), new ManaAmount(3, ManaColor.Black), "{T}, Sacrifice Black Lotus: Add {B}{B}{B}"));
card.AddAbility(new ManaAbility(card, new AggregateCost(card, new TapCost(card), new SacrificeSourceCost(card)), new ManaAmount(3, ManaColor.Red), "{T}, Sacrifice Black Lotus: Add {R}{R}{R}"));
card.AddAbility(new ManaAbility(card, new AggregateCost(card, new TapCost(card), new SacrificeSourceCost(card)), new ManaAmount(3, ManaColor.Green), "{T}, Sacrifice Black Lotus: Add {G}{G}{G}"));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Artifact, CardType.Creature }, new[] { "Myr" }, false, 1, 1, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{2}");
card.AddStaticAbility(StaticAbility.Infect);
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.Colorless), "{T}: Add {C}."));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Creature, CardType.Token }, new[] { "Avatar" }, false, 20, 20, true, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.AddStaticAbility(StaticAbility.Flying);
card.AddStaticAbility(StaticAbility.Indestructible);
// Override Color Identity to Black
card.Modifiers.Add(new ColorModifier(card, nameof(Card.ColorIdentity), ModifierMode.Override, ManaColor.Black));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Enchantment }, new[] { "Aura" }, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{R}");
card.OnCast = (g, c) =>
{
var target = c.Controller.ChooseTarget(c, new List <ITarget>(g.Battlefield.Where(_c => _c.IsAnArtifact && _c.CanBeTargetedBy(c)))) as Card;
c.AddEffect(new BurrowingEffect(c, target));
};
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Enchantment }, new[] { "Aura" }, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{2}{U}");
card.OnCast = (g, c) =>
{
var target = c.Controller.ChooseTarget(c, new List <ITarget>(g.Battlefield.Where(_c => (_c.IsACreature || _c.IsALand || _c.IsAPlaneswalker) && _c.CanBeTargetedBy(c)))) as Card;
c.AddEffect(new ImprisonedInTheMoonEffect(c, target));
};
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Artifact, CardType.Creature }, new[] { "Myr" }, false, 2, 2, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{3}");
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.White), "{T}: Add {W}."));
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.Blue), "{T}: Add {U}."));
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.Black), "{T}: Add {B}."));
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.Red), "{T}: Add {R}."));
card.AddAbility(new ManaAbility(card, new TapCost(card), new Common.Mana.ManaAmount(1, ManaColor.Green), "{T}: Add {G}."));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Land }, null, false, true, true);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
// Dark Depths enters the battlefield with 10 ice counters on it
card.AddCounters(card, 10, CounterType.Ice);
// {3}: Remove an ice counter from Dark Depths
card.AddAbility(new DarkDepthsAbility(card));
// When Dark Depths has no ice counters on it, sacrifice it. If you do, create Marit Lage, a legendary 20/20 black Avatar creature token with flying and indestructible
card.AddAbility(new MaritLageAbility(card));
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Instant }, null, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{U}");
card.OnCast = (g, c) =>
{
var options = new List <string>(modes);
var choice = c.Controller.MakeChoice("Choose One", 1, options);
c.SetVar("Mode", choice[0]);
if (choice[0] == options[0])
{
// Select target red spell
var target = c.Controller.ChooseTarget(c, new List <ITarget>(g.CardsOnStack().Where(c2 => c2.IsRed && c2.CanBeTargetedBy(c))), "Choose target red spell") as Card;
c.SetVar("Target", target);
}
else
{
// Select target red permanent
var target = c.Controller.SelectTarget("Select target red permanent", c2 => c2.IsRed && c2.CanBeTargetedBy(c)) as Card;
c.SetVar("Target", target);
}
};
card.OnResolve = (g, c) =>
{
var mode = c.GetVar <string>("Mode");
var target = c.GetVar <Card>("Target");
if (mode == modes[0])
{
// Counter target spell
g.Counter(target);
}
else
{
// Destroy target permanent
g.DestroyPermanent(target);
}
};
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Artifact }, null, false, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{X}{X}{X}");
// This must be a new delegate every time. Otherwise we lose the card reference
(card.Cost as ManaCost).ValueforXChosen += (x => card.SetVar("X", x));
card.AddAbility(new AstralCornucopiaManaAbility(card));
card.OnResolve = (g, c) =>
{
c.AddCounters(c, c.GetVar <int>("X"), CounterType.Charge);
};
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Instant }, null, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{G}");
card.CanCast = (g, c) =>
{
return(g.ActivePlayer == c.Controller && g.CurrentStep == Phases.DeclareAttackers);
};
// TODO: This turn, instead of declaring blockers, each defending player chooses any number of creatures
// they control and divides them into a number of piles equal to the number of attacking creatures for
// whom that player is the defending player. Creatures those players control that can block additional
// creatures may likewise be put into additional piles. Assign each pile to a different one of those
// attacking creatures at random. Each creature in a pile that can block the creature that pile is
// assigned to does so. (Piles can be empty.)
return(card);
}
public override Card GetCard(Player owner)
{
var card = new Card(owner, new[] { CardType.Instant }, null, false);
card._attrs = MtgCardAttribute.GetAttribute(GetType());
card.Cost = ManaCost.Parse(card, "{U}{U}");
card.CanCast = (g, c) =>
{
var possibleTargets = g.CardsOnStack().Where(_c => _c.CanBeCountered).ToList();
if (possibleTargets.Count == 0)
{
return(false);
}
return(true);
};
card.OnCast = (g, c) =>
{
var possibleTargets = g.CardsOnStack();
if (possibleTargets.Count == 0)
{
throw new InvalidOperationException("Counterspell can't be cast if there are no spells on the stack");
}
var target = c.Controller.ChooseTarget(c, new List <ITarget>(possibleTargets)) as Card;
c.SetVar("Target", target);
};
card.OnResolve = (g, c) =>
{
var target = c.GetVar <Card>("Target");
g.Counter(target);
};
return(card);
}
