public void CanComputePlayabilityStatistics()
{
var deck = DeckBuilder.Build("CanComputePlayabilityStatistics")
.With(1, CardJson.NissaStewardOfElements)
.With(1, CardJson.BaneOfBalaGed)
.With(1, CardJson.DeceiverOfForm)
.With(1, CardJson.ConduitOfRuin)
.With(3, CardJson.Endbringer)
.With(1, CardJson.DeepfathomSkulker)
.With(1, CardJson.ThoughtKnotSeer)
.With(4, CardJson.ElvishSpiritGuide)
.With(3, CardJson.VoidGrafter)
.With(4, CardJson.MagusOfTheLibrary)
.With(1, CardJson.DesolationTwin)
.With(4, CardJson.LlanowarElves)
.With(4, CardJson.ProphetOfDistortion)
.With(1, CardJson.HedronArchive)
.With(4, CardJson.PulseOfMurasa)
.With(3, CardJson.SpatialContortion)
.With(3, CardJson.WorldlyTutor)
.With(2, CardJson.LotusPetal)
.With(5, CardJson.Island)
.With(9, CardJson.Forest)
.With(3, CardJson.GhostQuarter)
.With(3, CardJson.MishrasFactory)
.With(1, CardJson.SpawningBed)
.With(1, CardJson.UnclaimedTerritory);
var statsSvc = new MtgStatisticsService();
var playerAI = new DesolationPlayerAI();
var player = new Player(deck, playerAI);
statsSvc.ComputePlayabilityStatistics(deck, player, 8);
}
public static void Fill(Deck deck, string deckName)
{
var deckBuilder = new DeckBuilder();
var cards = deckBuilder.Build(deckName);
deck.DrawPile = new Queue <Actor>(cards);
}
public void loadDeck(string deckFile)
{
Deck.Clear();
var cardReader = new CsvReader(File.OpenText(deckFile));
Deck = DeckBuilder.Build(cardReader);
cardReader.Dispose();
}
public void CanPayManaCost()
{
// Arrange
var deck = DeckBuilder.Build("CanPayManaCost");
var player = new Player(deck, new NoPlayerAI());
// Act
// Assert
}
public void MakesTheCorrectDeckUsingTheDeckScaffold()
{
var deckBuilder = new DeckBuilder();
var deck = deckBuilder.Build(BaseDeck);
Dictionary <string, int> tracker = new Dictionary <string, int>
{
{ "Warden", 0 },
{ "Brute", 0 },
{ "Enchanter", 0 },
{ "Sorcerer", 0 },
{ "Trapper", 0 },
{ "Stalker", 0 },
{ "Undead", 0 },
{ "Glacial", 0 },
{ "Infernal", 0 },
{ "Bestial", 0 },
{ "Aberrant", 0 },
{ "Aquatic", 0 },
{ "Common", 0 },
{ "Uncommon", 0 },
{ "Rare", 0 }
};
foreach (var card in deck)
{
tracker[card.Class]++;
tracker[card.Origin]++;
tracker[card.Rarity]++;
}
Assert.NotNull(deck);
Assert.Equal(108, deck.Length);
Assert.Equal(18, tracker["Warden"]);
Assert.Equal(27, tracker["Brute"]);
Assert.Equal(12, tracker["Enchanter"]);
Assert.Equal(18, tracker["Sorcerer"]);
Assert.Equal(15, tracker["Trapper"]);
Assert.Equal(18, tracker["Stalker"]);
Assert.Equal(18, tracker["Undead"]);
Assert.Equal(18, tracker["Glacial"]);
Assert.Equal(18, tracker["Infernal"]);
Assert.Equal(18, tracker["Bestial"]);
Assert.Equal(18, tracker["Aberrant"]);
Assert.Equal(18, tracker["Aquatic"]);
Assert.Equal(54, tracker["Common"]);
Assert.Equal(36, tracker["Uncommon"]);
Assert.Equal(18, tracker["Rare"]);
}
public void CanTakeMulligan()
{
// Arrange
var deck = DeckBuilder.Build("CanTakeMulligan", 16);
var firstMulligan = 4;
var player = new Player(deck, new NoPlayerAI(), 20, firstMulligan);
// Act
player.TakeMulligan();
// Assert
Assert.AreEqual(4, player.Hand.Cards.Count);
Assert.AreEqual(deck.Cards.Count - 4, player.Library.Cards.Count);
// Act
player.TakeMulligan();
// Assert
Assert.AreEqual(3, player.Hand.Cards.Count);
Assert.AreEqual(deck.Cards.Count - 3, player.Library.Cards.Count);
// Act
player.TakeMulligan();
// Assert
Assert.AreEqual(2, player.Hand.Cards.Count);
Assert.AreEqual(deck.Cards.Count - 2, player.Library.Cards.Count);
// Act
player.TakeMulligan();
// Assert
Assert.AreEqual(1, player.Hand.Cards.Count);
Assert.AreEqual(deck.Cards.Count - 1, player.Library.Cards.Count);
// Act
player.TakeMulligan();
// Assert
Assert.AreEqual(0, player.Hand.Cards.Count);
Assert.AreEqual(deck.Cards.Count, player.Library.Cards.Count);
// Act
player.TakeMulligan();
// Assert
Assert.AreEqual(0, player.Hand.Cards.Count);
Assert.AreEqual(deck.Cards.Count, player.Library.Cards.Count);
}
public MemorizationPageViewModel()
{
CardsSeen = new ObservableCollection <PlayingCard>();
DeckBuilder deckBuilder = new DeckBuilder();
deckBuilder.IncludeSpades();
deckBuilder.IncludeDiamonds();
deckBuilder.IncludeClubs();
deckBuilder.IncludeHearts();
deckBuilder.Shuffle();
_deck = new Deck(deckBuilder.Build());
TurnCardCommand = new DelegateCommand(ExecuteTurnCard, CanExecuteTurnCard);
StopCommand = new DelegateCommand(ExecuteStop, CanExecuteStop);
_timeTracker = new TimeTracker();
}
public void CanStartGame()
{
// Arrange
var deck = DeckBuilder.Build("CanStartGame", 16);
var player = new Player(deck, new NoPlayerAI());
var expectedStartingHand = 7;
var expectedStartingLibrary = deck.Cards.Count - expectedStartingHand;
// Act
player.Draw(expectedStartingHand);
// Assert
Assert.AreEqual(expectedStartingHand, player.Hand.Cards.Count);
Assert.AreEqual(expectedStartingLibrary, player.Library.Cards.Count);
}
public void CanTellIsTrue()
{
// Arrange
var deck = DeckBuilder.Build("CanTellIsTrue")
.With(CardJson.ElvishSpiritGuide);
var player = new Player(deck, new NoPlayerAI());
var esg = player.Deck.Cards.First();
// Act - Assert
player.Draw(1);
Assert.IsTrue(esg.GetAbility <ManaActivatedAbility>().Condition.IsTrue());
// Act - Assert
player.Hand.Pop(esg);
player.Battlefield.Enter(esg);
Assert.IsFalse(esg.GetAbility <ManaActivatedAbility>().Condition.IsTrue());
}
public void InitDeck(bool includeSpades, bool includeDiamonds, bool includeClubs, bool includeHearts)
{
DeckBuilder deckBuilder = new DeckBuilder();
if (includeSpades)
{
deckBuilder.IncludeSpades();
}
if (includeDiamonds)
{
deckBuilder.IncludeDiamonds();
}
if (includeClubs)
{
deckBuilder.IncludeClubs();
}
if (includeHearts)
{
deckBuilder.IncludeHearts();
}
deckBuilder.Shuffle();
_deck = new Deck(deckBuilder.Build());
}
private static void Main(string[] args)
{
string deckFile = "decklist.csv";
string rulesFile = "rulelist.csv";
var cardReader = new CsvReader(File.OpenText(deckFile));
var deck = DeckBuilder.Build(cardReader);
foreach (Card c in deck)
{
Console.WriteLine($"{c.Name}, {c.Amount}, {c.DeckName}");
}
var rulesReader = new CsvReader(File.OpenText(rulesFile));
var rulesList = RuleBuilder.Build(rulesReader);
foreach (Rule r in rulesList)
{
Console.WriteLine(r.Validate(deck).Item2);
}
;
Console.ReadKey(true);
}
/// <summary> /// Construct a valid 52 card deck, with 4 suits and 13 cards (Ace through King) of each suit. /// </summary> private static Deck BuildDeck() => DeckBuilder.Build(new RandomCardFactory());
public void CanGetAvailableMana()
{
// Arrange
var deck = DeckBuilder.Build("CanGetAvailableMana")
.With(CardJson.BaneOfBalaGed)
.With(CardJson.ThoughtKnotSeer)
.With(CardJson.ElvishSpiritGuide)
.With(CardJson.MagusOfTheLibrary)
.With(CardJson.Forest)
.With(CardJson.SpawningBed)
.With(CardJson.GhostQuarter);
var player = new Player(deck, new NoPlayerAI());
player.ShuffleLibrary();
player.Draw(7);
var expectedAvailableMana = new AvailableMana();
// Act
var actualAvailableMana = player.GetAvailableMana();
// Assert
Assert.AreEqual("AT:0-AC:0-C:0-W:0-U:0-B:0-R:0-G:1", actualAvailableMana.ToString());
// Arrange
var forest = player.Hand.Get("Forest");
player.Play(forest);
// Act
actualAvailableMana = player.GetAvailableMana();
// Assert
Assert.AreEqual("AT:0-AC:0-C:0-W:0-U:0-B:0-R:0-G:2", actualAvailableMana.ToString());
// Arrange
var magus = player.Hand.Cards.First(c => c.Name == "Magus of the Library");
player.Play(magus); // Use Forest & Elvish Spirit Guide
// Act
actualAvailableMana = player.GetAvailableMana();
// Assert
Assert.AreEqual("AT:0-AC:0-C:0-W:0-U:0-B:0-R:0-G:0", actualAvailableMana.ToString());
// Arrange
player.PassTheTurn();
player.StartTheTurn();
// Act
actualAvailableMana = player.GetAvailableMana();
// Assert
Assert.AreEqual("AT:0-AC:0-C:1-W:0-U:0-B:0-R:0-G:1", actualAvailableMana.ToString());
// Arrange
var ghostQuarter = player.Hand.Cards.First(c => c.Name == "Ghost Quarter");
player.Play(ghostQuarter);
// Act
actualAvailableMana = player.GetAvailableMana();
// Assert
Assert.AreEqual("AT:0-AC:0-C:2-W:0-U:0-B:0-R:0-G:1", actualAvailableMana.ToString());
}