public GameEvent[] pay(Card card, GameInterface gi, int[][] i)
{
List<GameEvent> r = new List<GameEvent>();
if (i.Length == 0) { return r.ToArray(); }
if (i.Length != costs.Count) { throw new Exception("can't"); }
for (int j = 0; j < i.Length; j++)
{
r.AddRange(costs[j].pay(card, gi, i[j]));
}
return r.ToArray();
}
/*
public bool tryPay(Player p)
{
if (checkAll(p))
{
payAll(p);
return true;
}
return false;
}
*/
public int[][] check(Card card, GameInterface gi)
{
gi.setContext("pay shit coach", Choice.Cancel);
int[][] r = new int[costs.Count][];
for (int i = 0; i < costs.Count; i++)
{
int[] c = costs[i].check(card, gi);
if (c == null)
{
r = null;
break;
}
r[i] = c;
}
gi.clearContext();
return r;
}
public MultiCardEvent(Card c, GameEventType t)
: base(t)
{
cs = new List<Card>(1);
cs.Add(c);
}
public MoveCardEvent(Card card, Location loc)
: base(GameEventType.MOVECARD)
{
this.card = card;
to = loc;
from = card.location;
}
public ExhaustEvent(Card card)
: base(card, GameEventType.EXHAUST)
{
}
public DamageCreatureEvent(Card crt, Card src, int dmg)
: base(GameEventType.DAMAGECREATURE)
{
creature = crt;
source = src;
damage = dmg;
}
public CastEvent(Card c, Ability ability, params Target[] cs)
: base(GameEventType.CAST)
{
xd = new StackWrapper(c, ability , cs);
}
public void setFocusCard(Card b)
{
gamePanel.showCardInfo(b);
}
public GameEvent[] resolveEffect(GameInterface ginterface, GameState game, Card resolvingCard)
{
List<GameEvent> r = new List<GameEvent>();
if (!targetRule.check(targetRule.getTargets()))
{
return r.ToArray();
}
foreach (Target t in targetRule.getTargets())
{
foreach (GameEvent e in resolve(ginterface, t, resolvingCard))
{
r.Add(e);
}
}
return r.ToArray();
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
Choice shuffle = Choice.No;
Player player = t.player;
if (optional)
{
if (player.isHero)
{
shuffle = ginterface.getChoice("Shuffle deck?", Choice.Yes, Choice.No);
ginterface.sendSelection((int)shuffle);
}
else
{
shuffle = (Choice)ginterface.demandSelection();
}
}
if (shuffle == Choice.Yes)
{
return new GameEvent[] { new ShuffleDeckEvent(player), };
}
return new GameEvent[] { };
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
GameEvent g;
Card source = resolvingCard;
if (t.isPlayer)
{
g = new DamagePlayerEvent(t.player, source, damage);
}
else
{
g = new DamageCreatureEvent(t.card, source, damage);
}
return new []{g};
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
Card card = t.card;
var r = new MoveCardEvent(card, pile);
return new[] {r};
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
Card card = t.card;
ModifyCardEvent r = new ModifyCardEvent(card, attribute, filter, value);
return new[] {r};
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
Player p = t.player;
GameEvent[] r = p.deck.cards.Take(cards).Select((c) => new MoveCardEvent(c, LocationPile.GRAVEYARD)).ToArray();;
return r;
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
return new[] {new CounterSpellEvent(t.card) };
}
public IEnumerable<Control> getCardButtons(Card c)
{
List<Control> r = new List<Control>();
foreach (Observer o in c.getObservers())
{
if (o is CardButton)
{
r.Add((Control)o);
}
}
return r;
}
public void sendCard(Card c)
{
sendAction(new SelectAction(c.getId()));
}
public void resolveResolveTargets(GameInterface gi, GameState gstate, Card resolving, Target[] last)
{
targetRule.resolveResolveTargets(gi, gstate, resolving, last);
}
public CardEvent(Card card, GameEventType type)
: base(type)
{
this.card = card;
}
protected abstract GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard);
public CounterSpellEvent(Card c)
: base(c, GameEventType.COUNTERSPELL)
{
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
GameEvent[] r = new GameEvent[cards.Length];
Player p = t.player;
for (int i = 0; i < cards.Length; i++)
{
r[i] = new SummonTokenEvent(p, cards[i]);
}
return r;
}
public DamagePlayerEvent(Player plr, Card src, int dmg)
: base(plr, GameEventType.DAMAGEPLAYER)
{
source = src;
damage = dmg;
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
Player p = t.player;
GameEvent e = new DrawEvent(p, cardCount);
return new[] {e};
}
public ModifyCardEvent(Card card, Modifiable m, Clojurex c, int value)
: base(GameEventType.MODIFYCARD)
{
this.card = card;
modifiable = m;
this.value = value;
clojure = c;
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
Choice shuffle;
Player player = t.player;
if (player.isHero)
{
var p = ginterface.showCards(player.deck.cards.Reverse().Take(cardCount).ToArray());
shuffle = ginterface.getChoice("Shuffle deck?", Choice.Yes, Choice.No);
ginterface.sendSelection((int)shuffle);
p.closeWindow();
}
else
{
shuffle = (Choice)ginterface.demandSelection();
}
if (shuffle == Choice.Yes)
{
return new GameEvent[] {new ShuffleDeckEvent(player),};
}
return new GameEvent[]{};
}
public MoveCardEvent(Card card, LocationPile pile)
: this(card, new Location(pile, card.owner.side))
{
}
public List<GameEvent> resolve(Card c, Target[] ts, GameInterface ginterface, GameState gameState)
{
List<GameEvent> r = new List<GameEvent>();
if (!preResolveCheck()) { return r; }
Target[] pts = null;
for (int i = 0; i < subEffects.Length; i++)
{
subEffects[i].resolveResolveTargets(ginterface, gameState, c, pts);
pts = subEffects[i].targets;
}
foreach (SubEffect e in subEffects)
{
foreach (GameEvent ge in e.resolveEffect(ginterface, gameState, c))
{
r.Add(ge);
}
}
return r;
}
public TopEvent(Card c)
: base(c, GameEventType.TOPCARD)
{
}
public GameElement(Card c)
{
element = c;
type = GameElementType.CARD;
}
