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