public Game(Type[] firstDeck, Type[] secondDeck) { GameState = State.IN_PROGRESS; currentIdNumber = -1; Duelist firstDuelist = new Duelist(this, firstDeck) { Name = "Duelist 0" }; Duelist secondDuelist = new Duelist(this, secondDeck) { Name = "Duelist 1" }; // Turn event handlers. firstDuelist.TurnStarted += OnDuelistTurnStarted; firstDuelist.AtTurnEnd += OnDuelistAtTurnEnd; firstDuelist.TurnEnded += OnDuelistTurnEnded; secondDuelist.TurnStarted += OnDuelistTurnStarted; secondDuelist.AtTurnEnd += OnDuelistAtTurnEnd; secondDuelist.TurnEnded += OnDuelistTurnEnded; // Battle Zone event handlers. firstDuelist.BattleZone.PutCard += OnBattleZonePut; firstDuelist.BattleZone.RemovedCard += OnBattleZoneRemoved; secondDuelist.BattleZone.PutCard += OnBattleZonePut; secondDuelist.BattleZone.RemovedCard += OnBattleZoneRemoved; allDuelists = new List <Duelist>(new Duelist[2] { firstDuelist, secondDuelist }); TurnIndex = 0; }
public Card(Duelist owner) { Owner = owner; ID = Owner.Game.GetID(); Owner.DuelAction.AddUsable(this); Tapped = false; ShieldTrigger = false; }
public void AttackPlayer(Creature attackingCreature, Duelist defendingDuelist) { if (GameStep != Step.ATTACK || !attackingCreature.CreatureAction.EvalCanAttackPlayer(defendingDuelist) || Waiting()) { return; } Busy = true; Task.Run(() => AttackPlayerAsync(attackingCreature, defendingDuelist)); }
public static void TopCardOfDeckIntoManaZone(Card source, int numberOfCards = 1) { Duelist owner = source.Owner; for (int i = 0; i < numberOfCards; i++) { owner.ManaZone.Put(owner.DrawCard()); } }
public bool OtherDuelistsDoingTask(Duelist duelistToExclude) { foreach (Duelist duelist in allDuelists) { if (duelist != duelistToExclude && duelist.TaskList.DoingTask) { return(true); } } return(false); }
public void Lose(Duelist loser) { if (allDuelists.Remove(loser)) { if (NumberOfDuelists <= 1) { GameState = State.COMPLETED; } OnLost(loser); } }
public static void OppBattleZoneToManaZoneTask <T>(Card source, int numberOfTargets = 1, bool optional = false) where T : Card { Duelist owner = source.Owner; foreach (Duelist duelist in owner.Game.Duelists) { if (duelist != owner) { duelist.TaskList.AddTask(BattleZoneToManaZoneOppTask <T>(source, numberOfTargets, optional)); } } }
public Creature(Duelist owner) : base(owner) { CreatureData = new CreatureData() { Name = OriginalName, ManaNumber = 1, ShieldBreaker = 1 }; CreatureAction = new CreatureAction(this); SummoningSickness = false; Blocker = false; Destroy = () => Owner.Graveyard.Put(this); CanAttack = (creature) => true; CanAttackPlayer = (player) => true; CanAttackUntapped = (creature) => false; Blockable = (blocker) => true; }
private void BlockablePlayer(Game game, Creature atking, Duelist defing) { if (CurrentZone is BattleZone && !Tapped && Owner == defing) { if (!atking.Blockable(this)) { return; } defing.TaskList.AddTask(new DuelTask( $"{Name}: Block player {atking.Name}.", (args) => { game.BattleWithoutWaiting(atking, this); Owner.TaskList.ClearOptionalTasks(); } )); } }
public DuelTaskList(Duelist owner) { Owner = owner; tasks = new List <DuelTask>(); }
protected virtual void OnAttackedPlayer(Creature attackingCreature, Duelist defendingPlayer) { AttackedPlayer?.Invoke(this, attackingCreature, defendingPlayer); }
public Zone(Duelist owner) { Owner = owner; cards = new List <Card>(); }
public bool EvalCanAttackPlayer(Duelist defendingPlayer) { return(EvalCanAttack(null) && Creature.CanAttackPlayer(defendingPlayer)); }
public DuelAction(Duelist owner) { Owner = owner; usableCards = new List <Card>(); }
protected virtual void OnDuelistTurnEnded(Duelist duelist) { DuelistTurnEnded?.Invoke(this, duelist); }
protected virtual void OnLost(Duelist loser) { Lost?.Invoke(this, loser); }
private async Task AttackPlayerAsync(Creature attackingCreature, Duelist defendingPlayer) { OnAttacking(attackingCreature); OnAttackingPlayer(attackingCreature, defendingPlayer); // Wait for On Attack tasks to be completed. await Task.Run(() => { while (DuelistsDoingTask()) { Thread.Sleep(100); } }); // If some effect caused the attacking Creature to be removed from the Battle Zone, cancel the attack. if (!(attackingCreature.CurrentZone is BattleZone)) { Busy = false; return; } OnBlockingPlayer(attackingCreature, defendingPlayer); // Wait for Player to pick a Blocker, or pick not to Block. await Task.Run(() => { while (DuelistsDoingTask()) { Thread.Sleep(100); } }); // If Blocked, cancel the attack. if (Blocked) { Blocked = false; return; } attackingCreature.Tapped = true; // Check if attacking Creature is still in the Battle Zone. if (attackingCreature.CurrentZone is BattleZone) { if (defendingPlayer.ShieldZone.NumberOfCards > 0) { for (int i = 0; i < attackingCreature.ShieldBreaker && defendingPlayer.ShieldZone.NumberOfCards > 0; i++) { defendingPlayer.ShieldZone.BreakShield(0); } /*string description = "Break "; * description += attackingCreature.ShieldBreaker > 1 ? $"{attackingCreature.ShieldBreaker} Shields." : " a Shield"; * attackingCreature.Owner.TaskList.AddTask(new DuelTask( * description, * (args) => { * for (int i = 0; i < attackingCreature.ShieldBreaker && defendingPlayer.ShieldZone.NumberOfCards > 0; i++) * if (i >= args.Length) { * defendingPlayer.ShieldZone.BreakShield(0); * } else { * defendingPlayer.ShieldZone.BreakShield((Card)args[i]); * } * }, * false, * () => defendingPlayer.ShieldZone.GetAll<Card>() * )); * await Task.Run(() => { while (DuelistsDoingTask()) { Thread.Sleep(100); } });*/ } else { // Duelist Lose Lose(defendingPlayer); } OnAttacked(attackingCreature); OnAttackedPlayer(attackingCreature, defendingPlayer); } Busy = false; }
protected virtual void OnDuelistEndAttackStep(Duelist duelist) { DuelistEndAttackStep?.Invoke(this, duelist); }