public ChoicePanel(GameInterface g)
{
gameInterface = g;
BackColor = Color.CornflowerBlue;
//Size = new Size(300, 140);
textLabel = new Label();
textLabel.Size = new Size(280, 40);
textLabel.Location = new Point(10, 10);
textLabel.Font = new Font(new FontFamily("Comic Sans MS"), 14);
for (int i = 0; i < buttons.Length; i++)
{
ChoiceButton b = new ChoiceButton();
b.BackColor = Color.GhostWhite;
b.Visible = false;
b.Font = new Font(new FontFamily("Comic Sans MS"), 12);
b.Location = new Point(5 + (i % 3) * 80, 100 + 50*(i/3));
b.Click += (sender, args) =>
{
buttonPressed(b);
};
buttons[i] = b;
Controls.Add(b);
}
Controls.Add(textLabel);
}
public GameController(GameConnection cn, GameInterface g)
{
gameInterface = g;
cn.setGame(this);
game = new GameState();
gameInterface.setObservers(game.hero, game.villain, game.stack);
setupEventHandlers();
stackxd = new Stack<StackWrapper>();
}
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();
}
private static void newGameT(object o)
{
GameConnection c = (GameConnection)o;
GameInterface gi = new GameInterface();
GUI.addGameWindow(gi);
gi.connection = c;
GameController g = new GameController(c, gi);
gi.setGame(g);
GUI.transitionToGame(gi);
g.start(c.asHomePlayer());
}
/*
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 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;
}
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[]{};
}
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 void resolveResolveTargets(GameInterface gi, GameState gstate, Card resolving, Target[] last)
{
targetRule.resolveResolveTargets(gi, gstate, resolving, last);
}
public Target[] resolveCastTargets(GameInterface ginterface, GameState gstate, bool cancellable)
{
return targetRule.resolveCastTargets(ginterface, gstate, cancellable);
}
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};
}
public static void transitionToGame(GameInterface g)
{
frame.transitionTo(g.gamePanel);
}
public abstract GameEvent[] pay(Card c, GameInterface gi, int[] i);
public abstract int[] check(Card c, GameInterface gi);
public override GameEvent[] pay(Card c, GameInterface gi, int[] i)
{
return new[] {new GainLifeEvent(c.owner, -i[0])};
}
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)
{
Card card = t.card;
var r = new MoveCardEvent(card, pile);
return new[] {r};
}
public static void addGameWindow(GameInterface g)
{
frame.createGamePanel(g);
}
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[] { };
}
/// <summary>
/// Creates and binds a new GamePanel to the given GameInterface
/// </summary>
/// <param name="g"></param>
public void createGamePanel(GameInterface g)
{
GamePanel r = new GamePanel(g);
r.Size = Size;
g.setPanel(r);
Invoke(new Action(() => { Controls.Add(r); }));
}
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)
{
Card c = t.card;
return new[] {new ExhaustEvent(c)};
}
protected abstract GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard);
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
GameEvent[] r = new GameEvent[colours.Length];
for (int i = 0; i < r.Length; i++)
{
r[i] = new GainBonusManaEvent(t.player, colours[i]);
}
return r;
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
Player p = t.player;
GameEvent e = new DrawEvent(p, cardCount);
return new[] {e};
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
Player p = t.player;
return new[]{new GainLifeEvent(p, life)};
}
public Target[] aquireTargets(GameInterface ginterface, GameState gstate, bool cancellable)
{
List<Target> l = new List<Target>();
foreach (SubEffect e in subEffects)
{
Target[] ts = e.resolveCastTargets(ginterface, gstate, cancellable);
if (ts == null) return null;
l.AddRange(ts);
}
return l.ToArray();
}
protected override GameEvent[] resolve(GameInterface ginterface, Target t, Card resolvingCard)
{
return new[] {new CounterSpellEvent(t.card) };
}
public PlayerPanel(GameInterface g)
{
game = g;
for (int i = 0; i < 5; i++)
{
manaButtons[i] = new ManaButton[6];
}
normalButtons = new Button[NORMALBUTTONS];
for (int i = 1; i < NORMALBUTTONS; i++)
{
normalButtons[i] = new Button();
}
yard.Click += clickGraveyard;
Controls.Add(health);
Controls.Add(deck);
Controls.Add(hand);
Controls.Add(yard);
BackColor = Color.Aquamarine;
for (int i = 0; i < 5; i++)
{
Colour colour = (Colour)i;
for (int j = 0; j < 6; j++)
{
Color c = Color.Chartreuse;
switch (colour)
{
case Colour.WHITE:
{
c = Color.White;
} break;
case Colour.BLUE:
{
c = Color.Blue;
} break;
case Colour.BLACK:
{
c = Color.Black;
} break;
case Colour.RED:
{
c = Color.Red;
} break;
case Colour.GREEN:
{
c = Color.Green;
} break;
}
ManaButton b = new ManaButton(colour);
b.setState(ManaButton.HIDDEN);
manaButtons[i][j] = b;
var j1 = j;
var i1 = i;
b.Click += (sender, args) =>
{
manaButtonPressed(b);
};
Controls.Add(b);
}
}
playerPortrait = new PlayerButton();
normalButtons[0] = playerPortrait;
playerPortrait.Click += (_, __) =>
{
game.gameElementPressed(playerPortrait.getElement());
};
Controls.Add(playerPortrait);
}
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;
}
