public void ResolveStack_StackIsEmptiedAndBothPlayersPass_PhaseIsChanged()
{
bool mustResolve = false;
bool mustResolveAswell = false;
Player[] players = generatePlayersAndStartGame(2);
Phases currentPhase = this.TurnManager.CurrentPhase;
MockCard card1 = new MockCard();
card1.AddSpellAction(_ => mustResolveAswell = true);
MockCard card2 = new MockCard();
card2.AddSpellAction(_ => mustResolve = true);
this.ActionManager.Queue(new CastCardCommand(players[0], card1, mana));
this.ActionManager.Queue(new CastCardCommand(players[0], card2, mana));
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[0]));
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[1]));
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[0]));
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[1]));
this.Engine.Update();
Phases actualPhase = this.TurnManager.CurrentPhase;
Assert.AreNotEqual(currentPhase, actualPhase);
}
public void TestTarget_NoTargetCondition_TargetAccepted()
{
int firstTarget = 0;
MockCard card = new MockCard();
MockUnit someUnit = new MockUnit();
bool result = card.TestTarget(firstTarget, someUnit);
Assert.IsTrue(result);
}
public void TestTarget_NoTargetCondition_TargetAccepted()
{
int firstTarget = 0;
MockCard card = new MockCard();
MockUnit someUnit = new MockUnit();
bool result = card.TestTarget(firstTarget, someUnit);
Assert.IsTrue(result);
}
public void TestTarget_ValidTarget_TargetAccepted()
{
int firstTarget = 0;
MockCard card = new MockCard();
MockUnit someUnit = new MockUnit();
card.SetTargetCondition(firstTarget,unit => unit is UnitEntity);
bool result = card.TestTarget(firstTarget, someUnit);
Assert.IsTrue(result);
}
public void TestTarget_ValidTarget_TargetAccepted()
{
int firstTarget = 0;
MockCard card = new MockCard();
MockUnit someUnit = new MockUnit();
card.SetTargetCondition(firstTarget, unit => unit is UnitEntity);
bool result = card.TestTarget(firstTarget, someUnit);
Assert.IsTrue(result);
}
public void CastCard_PlayerChoosesValidCrystals_CrystalsDischargedAndSpellIsCast()
{
this.FailTestOnEngineCrash();
bool spellResolved = false;
AbilityManager am = new AbilityManager();
this.Engine.AddActor(am);
TurnManager tm = new TurnManager();
this.Engine.AddActor(tm);
ManaStorage m = new ManaStorage();
Player[] players = generatePlayersAndStartGame(new Player[] { new Player(null, null, m, null), new Player() });
this.Engine.Update();
m.AddCrystal(Mana.Divine);
m.AddCrystal(Mana.Divine);
m.AddCrystal(Mana.Arcane);
m.chargeAll();
List <Mana> manaCost = new List <Mana>();
manaCost.Add(Mana.Divine);
manaCost.Add(Mana.Arcane);
MockCard card = new MockCard();
card.ManaCost = manaCost;
card.AddSpellAction(_ => spellResolved = true);
Player owner = players[0];
List <Mana> selectedMana = new List <Mana>();
selectedMana.Add(Mana.Divine);
selectedMana.Add(Mana.Arcane);
this.ActionManager.Queue(new CastCardCommand(owner, card, selectedMana));
this.Engine.Update();
EventManager.Raise(new PlayerPassedPriorityEvent(players[0]));
EventManager.Raise(new PlayerPassedPriorityEvent(players[1]));
this.Engine.Update();
Assert.IsTrue(m.IsCharged(Mana.Divine, 0));
Assert.IsFalse(m.IsCharged(Mana.Divine, 1));
Assert.IsFalse(m.IsCharged(Mana.Arcane, 0));
Assert.IsTrue(spellResolved);
}
public void QueueSpell_PlayerCastCard_SpellFromCardQueuedToStack()
{
MockCard card = new MockCard();
Player castingPlayer = new Player();
this.ActionManager.Queue(new CastCardCommand(castingPlayer, card, mana));
this.Engine.Update();
IEnumerable <Ability> unresolved = AbilityManager.Unresolved;
int expectedCount = 1;
int actualCount = unresolved.Count();
Assert.AreEqual(expectedCount, actualCount);
}
public void ConstructSpell_SimpleSpell_CorrectlyConstructed()
{
bool spellResolved = false;
MockCard card = new MockCard();
card.SetTargetCondition(0, _ => true);
card.AddSpellAction(_ => spellResolved = true);
Spell spell = card.ConstructSpell();
spell.SetTarget(0, new object[]{null});
this.ActionManager.Queue(spell);
this.ActionManager.ExecuteActions();
Assert.IsTrue(spellResolved);
}
public void CastCard_PlayerChoosesValidCrystals_CrystalsDischargedAndSpellIsCast()
{
this.FailTestOnEngineCrash();
bool spellResolved = false;
AbilityManager am = new AbilityManager();
this.Engine.AddActor(am);
TurnManager tm = new TurnManager();
this.Engine.AddActor(tm);
ManaStorage m = new ManaStorage();
Player[] players = generatePlayersAndStartGame(new Player[]{new Player(null,null,m,null),new Player()});
this.Engine.Update();
m.AddCrystal(Mana.Divine);
m.AddCrystal(Mana.Divine);
m.AddCrystal(Mana.Arcane);
m.chargeAll();
List<Mana> manaCost = new List<Mana>();
manaCost.Add(Mana.Divine);
manaCost.Add(Mana.Arcane);
MockCard card = new MockCard();
card.ManaCost = manaCost;
card.AddSpellAction(_ => spellResolved = true);
Player owner = players[0];
List<Mana> selectedMana = new List<Mana>();
selectedMana.Add(Mana.Divine);
selectedMana.Add(Mana.Arcane);
this.ActionManager.Queue(new CastCardCommand(owner, card, selectedMana));
this.Engine.Update();
EventManager.Raise(new PlayerPassedPriorityEvent(players[0]));
EventManager.Raise(new PlayerPassedPriorityEvent(players[1]));
this.Engine.Update();
Assert.IsTrue(m.IsCharged(Mana.Divine, 0));
Assert.IsFalse(m.IsCharged(Mana.Divine, 1));
Assert.IsFalse(m.IsCharged(Mana.Arcane, 0));
Assert.IsTrue(spellResolved);
}
public void ShuffleIntegrityTest()
{
var cardType = new MockCardType();
var collection = new MockCardCollection();
var card1 = new MockCard(cardType, collection);
var card2 = new MockCard(cardType, collection);
var card3 = new MockCard(cardType, collection);
collection.Shuffle();
var cards = new List <MockCard>(new[] { card1, card2, card3 });
foreach (MockCard card in collection.Cards)
{
Assert.Contains(card, cards);
cards.Remove(card);
}
Assert.Empty(cards);
}
public void QueueSpell_FirstPlayersTurnOtherPlayerCastSpell_FirstPlayerGetsPriorityFirst()
{
Player[] players = generatePlayersAndStartGame(2);
Phases currentPhase = this.TurnManager.CurrentPhase;
MockCard card = new MockCard();
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[0]));
this.Engine.Update();
bool firstPlayerGainPrioOnCast = false;
bool secondPlayerGainPrioOnCast = false;
this.EventManager.Register(new Trigger <PlayerGainedPriorityEvent>(evt => firstPlayerGainPrioOnCast = players[0] == evt.Player));
this.EventManager.Register(new Trigger <PlayerGainedPriorityEvent>(evt => secondPlayerGainPrioOnCast = players[1] == evt.Player));
this.ActionManager.Queue(new CastCardCommand(players[1], card, mana));
this.Engine.Update();
Assert.IsTrue(firstPlayerGainPrioOnCast);
Assert.IsFalse(secondPlayerGainPrioOnCast);
}
public void ConstructSpell_SimpleSpell_CorrectlyConstructed()
{
bool spellResolved = false;
MockCard card = new MockCard();
card.SetTargetCondition(0, _ => true);
card.AddSpellAction(_ => spellResolved = true);
Spell spell = card.ConstructSpell();
spell.SetTarget(0, new object[] { null });
this.ActionManager.Queue(spell);
this.ActionManager.ExecuteActions();
Assert.IsTrue(spellResolved);
}
public void ShuffleTest()
{
var cardType = new MockCardType();
var collection = new MockCardCollection();
var card1 = new MockCard(cardType, collection);
var card2 = new MockCard(cardType, collection);
var card3 = new MockCard(cardType, collection);
var card4 = new MockCard(cardType, collection);
var card5 = new MockCard(cardType, collection);
var cards = new List <MockCard>(new[] { card1, card2, card3, card4, card5 });
var cardsTest = new List <MockCard>();
int differents = 0; // Anzahl Unterschiede zu Original Liste
double mischGrad = 0.5; // Bestimmen wie viel Karten unterschiedlich sein sollen
int minDiff = Convert.ToInt32(Math.Round(cards.Count * mischGrad));
collection.AddCard(card1);
collection.AddCard(card2);
collection.AddCard(card3);
collection.AddCard(card4);
collection.AddCard(card5);
collection.Shuffle();
// Karten Liste der gemischten Collection
foreach (MockCard card in collection.Cards)
{
cardsTest.Add(card);
}
// Gemischte Karten Liste und Original Liste vergleichen
for (int i = 0; i < cards.Count; i++)
{
if (cards[i] != cardsTest[i])
{
differents += 1;
}
}
Assert.True(differents >= minDiff);
}
public void QueueSpell_FirstPlayersTurnOtherPlayerCastSpell_FirstPlayerGetsPriorityFirst()
{
Player[] players = generatePlayersAndStartGame(2);
Phases currentPhase = this.TurnManager.CurrentPhase;
MockCard card = new MockCard();
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[0]));
this.Engine.Update();
bool firstPlayerGainPrioOnCast = false;
bool secondPlayerGainPrioOnCast = false;
this.EventManager.Register(new Trigger<PlayerGainedPriorityEvent>(evt => firstPlayerGainPrioOnCast = players[0] == evt.Player));
this.EventManager.Register(new Trigger<PlayerGainedPriorityEvent>(evt => secondPlayerGainPrioOnCast = players[1] == evt.Player));
this.ActionManager.Queue(new CastCardCommand(players[1], card, mana));
this.Engine.Update();
Assert.IsTrue(firstPlayerGainPrioOnCast);
Assert.IsFalse(secondPlayerGainPrioOnCast);
}
public void ResolveStack_StackIsEmptiedAndBothPlayersPass_PhaseIsChanged()
{
bool mustResolve = false;
bool mustResolveAswell = false;
Player[] players = generatePlayersAndStartGame(2);
Phases currentPhase = this.TurnManager.CurrentPhase;
MockCard card1 = new MockCard();
card1.AddSpellAction(_ => mustResolveAswell = true);
MockCard card2 = new MockCard();
card2.AddSpellAction(_ => mustResolve = true);
this.ActionManager.Queue(new CastCardCommand(players[0], card1, mana));
this.ActionManager.Queue(new CastCardCommand(players[0], card2, mana));
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[0]));
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[1]));
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[0]));
this.ActionManager.Queue(new PlayerPassPriorityCommand(players[1]));
this.Engine.Update();
Phases actualPhase = this.TurnManager.CurrentPhase;
Assert.AreNotEqual(currentPhase, actualPhase);
}
public void QueueSpell_PlayerCastCard_SpellFromCardQueuedToStack()
{
MockCard card = new MockCard();
Player castingPlayer = new Player();
this.ActionManager.Queue(new CastCardCommand(castingPlayer, card, mana));
this.Engine.Update();
IEnumerable<Ability> unresolved = AbilityManager.Unresolved;
int expectedCount = 1;
int actualCount = unresolved.Count();
Assert.AreEqual(expectedCount, actualCount);
}
