public ActionResult BuildDeck(CardSearchModel CardSearch)
{
Session["model"] = CardSearch;
CardSearchService searchService = CardSearchService.AllowedDeckCardsFilterService(MvcApplication.CardCache, CardSearch.SelectedHero);
CardSearch.AllCards = searchService.Search("");
return(PartialView("DeckCardList", DeckBuilder.getPageItems(CardSearch, 1)));
//return PartialView("_ImageList", CardList.getPageItems(CardSearch, 1));
}
public void Initialize(DeckBuilder parent)
{
_deckBuilder = parent;
RefreshLibrary();
grimoireTemplate.Initialize(parent, null);
}
private void CreateDraftDecks()
{
var draftScreen = Ui.Dialogs.DraftScreen.Create(_players);
Ui.Shell.ChangeScreen(draftScreen);
var runner = new DraftRunner(draftScreen);
var results = runner.Run(_players.Count, _p.BoosterPacks, _cardRatings);
if (draftScreen.PlayerLeftDraft)
{
Stop();
return;
}
var nonHumanPlayers = NonHumanPlayers.ToList();
var nonHumanLibraries = results.Libraries.Skip(1).ToList();
_humanLibrary = results.Libraries[0];
AggregateException exception = null;
Task.Factory.StartNew(() =>
{
for (var count = 0; count < nonHumanPlayers.Count; count++)
{
var player = nonHumanPlayers[count];
var library = nonHumanLibraries[count];
var deck = DeckBuilder.BuildDeck(library, _cardRatings);
player.Deck = deck;
Ui.Publisher.Publish(new DeckGenerationStatus
{
PercentCompleted = (int)Math.Round((100 * (count + 1.0)) / nonHumanPlayers.Count)
});
if (_shouldStop)
{
break;
}
}
})
.ContinueWith(t =>
{
exception = t.Exception;
Ui.Publisher.Publish(new DeckGenerationError());
}, TaskContinuationOptions.OnlyOnFaulted);
CreateHumanDeck();
if (exception != null)
{
throw new AggregateException(exception.InnerExceptions);
}
}
public static IEnumerator InitializeGame()
{
//Making query
PlayerDao playerDao = new PlayerDao();
StoreDeckDao storeDeckDao = new StoreDeckDao();
MatchDao matchDao = new MatchDao();
List <Dao> daoList = new List <Dao>()
{
playerDao, storeDeckDao, matchDao
};
yield return(makeQuerry(daoList));
if (!succsesfull)
{
yield break;
}
//Getting results
Player player = playerDao.getQueryResultPlayer();
Player.setInstance(player);
List <StoreDeck> storeDeckList = storeDeckDao.getQueryResultStoreDeckList();
bool change = false;
DeckBuilder deckBuilder;
Deck deck;
List <string> playerStoreDecks = player.StoreDeckNameList.getList();
foreach (StoreDeck storeDeck in storeDeckList)
{
if (!playerStoreDecks.Contains(storeDeck.DeckName))
{
if (player.IsPremium)
{
deckBuilder = new DeckBuilder(storeDeck);
deck = deckBuilder.getDeck();
player.addDeck(deck);
player.addToStoreDeckNameList(deck.DeckName);
change = true;
}
else
{
Store.addDeck(storeDeck);
}
}
}
if (change)
{
playerDao.savePlayer(player);
}
}
public void Creates52CardDeck()
{
var expectedCount = 52;
var deckBuilder = new DeckBuilder();
var deck = deckBuilder.CreateDeck();
var actualCount = deck.Count();
Assert.AreEqual(expectedCount, actualCount);
}
public void CanPayManaCost()
{
// Arrange
var deck = DeckBuilder.Build("CanPayManaCost");
var player = new Player(deck, new NoPlayerAI());
// Act
// Assert
}
public override void Initialize()
{
/* TODO: (low) Implement proper initializer for all the cards/decks
* Init the background
* Init two decks (Load an XML file with data on each card from folders "Decks\Player1" and "Decks\Player2")
* Init controls (buttons, etc)
* Init Labels (damage counters, energy card symbols, card zones, etc)
* Init starting gameplayStage
*/
interfaceSpriteBatch = new SpriteBatch(currentGame.GraphicsDevice);
finalSpriteBatch = new SpriteBatch(currentGame.GraphicsDevice);
Player1 = new NPlayer(1, currentGame);
Player2 = new NPlayer(2, currentGame);
// Build the players' decks
DeckBuilder builder = new DeckBuilder(GameConstants.PATH_PLAYER1DECK, currentGame);
builder.ImportDeck();
Player1.PlayerDeck = builder.ToDeck();
Player1.PlayerDeck.Position = new Vector2(1489, 607);
Player1.PlayerDeck.Shuffle();
builder.DeckPath = GameConstants.PATH_PLAYER2DECK;
builder.ImportDeck();
Player2.PlayerDeck = builder.ToDeck();
Player2.PlayerDeck.Position = new Vector2(30, 178);
Player2.PlayerDeck.Shuffle();
// Init the players' hands
Player1.PlayerHand.Position = new Vector2(15, 650);
Player2.PlayerHand.Position = new Vector2(850, 30);
// Init buttons
drawCardButtonP1 = new Button("DrawButton", new Vector2(1355, 632), true, currentGame);
chatBox = new TextBoxMulti("Enter chat", new Vector2((int)(GameConstants.SCREEN_WIDTH - (GameConstants.SCREEN_WIDTH * 0.005) - 450),
(int)(GameConstants.SCREEN_HEIGHT / 2) - 61), currentGame);
// Populate the OnScreenElements list
OnScreenElements = new List <IClickable>();
OnScreenElements.Add(drawCardButtonP1);
OnScreenElements.Add(chatBox);
foreach (Card c in Player1.PlayerDeck)
{
OnScreenElements.Add(c);
}
foreach (Card c in Player2.PlayerDeck)
{
OnScreenElements.Add(c);
}
currentInputEvent = InputEvent.None;
keyboardHandler = new KeyboardHandler(currentGame);
}
//[Fact]
public void BuildDeck1()
{
var library = new List <string> {
"Void Snare",
"Void Snare",
"Void Snare",
"Chief Engineer",
"Welkin Tern",
"Mind Sculpt",
"Military Intelligence",
"Coral Barrier",
"Dissipate",
"Frost Lynx",
"Illusory Angel",
"Wall of Frost",
"Frost Lynx",
"Cancel",
"Coral Barrier",
"Encrust",
"Amphin Pathmage",
"Glacial Crasher",
"Chronostutter",
"Dauntless River Marshal",
"Kinsbaile Skirmisher",
"Kinsbaile Skirmisher",
"Kinsbaile Skirmisher",
"Raise the Alarm",
"Raise the Alarm",
"Ephemeral Shields",
"Solemn Offering",
"Geist of the Moors",
"Heliod's Pilgrim",
"Midnight Guard",
"Divine Verdict",
"Marked by Honor",
"Tireless Missionaries",
"Sanctified Charge",
"Boonweaver Giant",
"Boonweaver Giant",
"Foundry Street Denizen",
"Crowd's Favor",
"Crowd's Favor",
"Hammerhand",
"Torch Fiend",
"Soul of Shandalar",
"Reclamation Sage",
"Shaman of Spring",
"Typhoid Rats"
};
var deck = DeckBuilder.BuildDeck(
library.Select(x => new CardInfo(x)),
MediaLibrary.GetSet("M15").Ratings, decks => decks.First());
}
public void Initialize(CardData card, DeckBuilder parent)
{
this.card = card;
deckbuilder = parent;
costText.text = card.cardCost.ToString();
cardName.text = card.cardName;
cardArt.sprite = card.cardImage;
cardQuantity++;
deckbuilder.AddCardCount();
deckbuilder.deckInProgress.savedDecklist.Add((int)this.card.cardID);
}
private void Awake()
{
if (Instance == null)
{
Instance = this;
}
else if (Instance != this)
{
Destroy(gameObject);
}
}
private void Awake()
{
if (!instance)
{
instance = this;
}
else
{
Destroy(gameObject);
}
}
private void Awake( )
{
if (Instance != null && Instance != this)
{
Destroy(this);
}
else
{
Instance = this;
}
}
public void Load()
{
//InputField inputField = GameObject.Find("deckName").GetComponent<InputField>();
string deckName = inputField.text;
//inputField.text.Remove(0,inputField.text.Length);
//inputField.textComponent.text = "";
DeckBuilder.Get().LoadDeck(deckName);
}
private Deck getDefaultDeck()
{
DeckBuilder deckBuilder = new DeckBuilder()
.setDeckName("Default")
.setDeckEditable(false)
.addCard("DefPor1", "DefEng1")
.addCard("DefPor2", "DefEng2")
.addCard("DefPor3", "DefEng3")
.addCard("DefPor4", "DefEng4");
return(deckBuilder.getDeck());
}
public void BuildWithSuit_Should_ReturnAllCardsOfGivenSuit()
{
var suits = (Enum.GetValues(typeof(Suits)) as Suits[]).ToList();
var ranks = (Enum.GetValues(typeof(Ranks)) as Ranks[]).ToList();
suits.ForEach(suit =>
{
var cards = DeckBuilder.CreateDeck().WithSuit(suit).Build();
Assert.Equal(ranks.Count, cards.Count());
ranks.ForEach(rank => Assert.Contains(cards, card => card.Rank == rank && card.Suit == suit));
});
}
private void Awake()
{
gameHander = map.GetComponent <GameHandler>();
deckBuilder = map.GetComponent <DeckBuilder>();
planeMan = map.GetComponentInChildren <PlaneManager>();
cardManager = ui.GetComponent <CardManager>();
settingsMenu = ui.GetComponent <SettingsMenu>();
uiMan = ui.GetComponent <UIManager>();
gameHander.GetSetUpParts(camController, cardManager, settingsMenu, uiMan);
settingsMenu.GetSetUpParts(gameHander, planeMan, camController);
cardManager.GetSetUpParts(gameHander, deckBuilder);
}
public void start_with_decks_for_each_player()
{
var duel = Duel.Start(DuelId, FirstDuelistId, SecondDuelistId);
var expectedDeck = DeckBuilder.CompletedDeck();
var firstDeck = duel.State.FirstDuelist.DeckCards;
firstDeck.Should().BeEquivalentTo(expectedDeck);
var secondDeck = duel.State.SecondDuelist.DeckCards;
secondDeck.Should().BeEquivalentTo(expectedDeck);
}
public void DealHand_DealsCorrect13Cards_Success(int playerNumber)
{
var deck = DeckBuilder.BuildDeck13();
var dealer = new Dealer(deck);
var hand = dealer.DealHand(playerNumber);
Assert.AreEqual(13, hand.Count);
for (int i = 0; i < hand.Count; i++)
{
Assert.AreEqual(deck[i + (playerNumber * 13)], hand[i]);
}
}
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 ImDealt26Cards()
{
var expectedCount = 26;
var deckBuilder = new DeckBuilder();
var deck = deckBuilder.CreateDeck();
var myCards = new List <Card>();
var playerCards = new List <Card>();
deckBuilder.DealDeckRandomly(ref deck, ref myCards, ref playerCards);
var actualCount = myCards.Count();
Assert.AreEqual(expectedCount, actualCount);
}
public void Initialize(DeckBuilder parent, DeckBuilder.DeckData deckData)
{
_deckBuilder = parent;
_deckData = deckData;
if (deckData != null)
{
deckList = _deckData.GetCardData();
general = _deckData.GetGeneral();
faction = general.faction;
deckName = _deckData.deckName;
deckNameText.text = deckName;
}
}
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 static IEnumerator InitializeGame()
{
//Making query
PlayerDao playerDao = new PlayerDao();
StoreDeckDao storeDeckDao = new StoreDeckDao();
MatchDao matchDao = new MatchDao();
List<Dao> daoList = new List<Dao>() { playerDao, storeDeckDao, matchDao };
yield return makeQuerry(daoList);
if (!succsesfull)
yield break;
//Getting results
Player player = playerDao.getQueryResultPlayer();
Player.setInstance(player);
List<StoreDeck> storeDeckList = storeDeckDao.getQueryResultStoreDeckList();
bool change = false;
DeckBuilder deckBuilder;
Deck deck;
List<string> playerStoreDecks = player.StoreDeckNameList.getList();
foreach (StoreDeck storeDeck in storeDeckList)
{
if (!playerStoreDecks.Contains(storeDeck.DeckName))
{
if (player.IsPremium)
{
deckBuilder = new DeckBuilder(storeDeck);
deck = deckBuilder.getDeck();
player.addDeck(deck);
player.addToStoreDeckNameList(deck.DeckName);
change = true;
}
else
{
Store.addDeck(storeDeck);
}
}
}
if (change)
{
playerDao.savePlayer(player);
}
}
public void GoalDeckContainsAllTheCards()
{
var goalDeck = DeckBuilder.CreateGoalDeck();
// 4 colors 9 numbers
Assert.AreEqual(4 * 9, goalDeck.Count);
for (int i = 1; i <= 9; ++i)
{
Assert.Contains(new Card(CardColor.Blue, i), goalDeck);
Assert.Contains(new Card(CardColor.Green, i), goalDeck);
Assert.Contains(new Card(CardColor.Pink, i), goalDeck);
Assert.Contains(new Card(CardColor.Yellow, i), goalDeck);
}
}
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 DistributeCards_Should_AssignProperDecksNumberForCards()
{
var cards = DeckBuilder
.CreateDeck()
.WithColor(Colors.Black)
.WithColor(Colors.Red)
.Shuffled()
.Build()
.Take(28)
.ToList()
.DistributeCards(7);
for (var i = 0; i < 7; ++i)
{
Assert.Equal(i + 1, cards.Where(card => card.DeckNumber == i + 2).Count());
}
}
public void DeckBuilderTestShouldThrowException()
{
// ARRANGE
int temp = 1;
// ACT
try
{
var builder = new DeckBuilder(null, temp);
}
catch (Exception e)
{
_ex = e;
}
//Assert
Assert.IsNotNull(_ex);
}
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());
}
static void Main(string[] args)
{
var action = new Actions();
var PlayerName = action.GetPlayerName();
Message.ExplainTheRules(PlayerName);
var deckBuilder = new DeckBuilder();
var deck = deckBuilder.CreateDeck();
var myCards = new List <Card>();
var playerCards = new List <Card>();
deckBuilder.DealDeckRandomly(ref deck, ref myCards, ref playerCards);
Message.DeckIsShuffled(PlayerName);
var roundResult = new RoundResult();
var roundCounter = 0;
while ((myCards.Count > 0) && (playerCards.Count > 0))
{
roundCounter += 1;
Message.DisplayTopCards(myCards[0].ToString(), playerCards[0].ToString());
roundResult = action.FlipTopCardsOver(PlayerName, ref myCards, ref playerCards, ref deck);
if ((roundResult == RoundResult.RyanWins) || (roundResult == RoundResult.PlayerWins))
{
action.GiveWinnerTheirCards(roundResult, ref myCards, ref playerCards, ref deck);
}
while (roundResult == RoundResult.WarIsDeclard)
{
var warResult = action.GetWarResult(PlayerName, myCards, playerCards);
if ((warResult == WarResult.RyanWins) || (warResult == WarResult.PlayerWins) || (warResult == WarResult.WarIsDeclaredAgain))
{
action.FalloutFromWar(ref myCards, ref playerCards, ref deck, warResult, ref roundResult);
}
else
{
action.SomeoneLacksFourCards(ref myCards, ref playerCards, ref deck, warResult, ref roundResult);
}
}
Message.CardCount(myCards.Count, playerCards.Count, roundCounter);
}
action.GameIsOver(PlayerName, roundCounter, myCards, playerCards);
Console.ReadLine();
}
public void DraftLibraries()
{
var sets = new[] { "Urza's Saga", "Urza's Saga", "Urza's Saga" };
var ratings = MediaLibrary.GetSet(sets[0]).Ratings;
var runner = new DraftRunner();
var results = runner.Run(
playerCount: 8,
sets: sets,
ratings: ratings);
Equal(8, results.Libraries.Count);
True(results.Libraries.All(x => x.Count == 45));
for (var i = 0; i < 8; i++)
{
Console.WriteLine("Player {0}", i + 1);
Console.WriteLine("-------------------");
var library = results.Libraries[i];
Console.WriteLine("White cards: {0}", library.Count(x => Grove.Cards.All[x.Name].HasColor(CardColor.White)));
Console.WriteLine("Blue cards: {0}", library.Count(x => Grove.Cards.All[x.Name].HasColor(CardColor.Blue)));
Console.WriteLine("Black cards: {0}", library.Count(x => Grove.Cards.All[x.Name].HasColor(CardColor.Black)));
Console.WriteLine("Red cards: {0}", library.Count(x => Grove.Cards.All[x.Name].HasColor(CardColor.Red)));
Console.WriteLine("Green cards: {0}", library.Count(x => Grove.Cards.All[x.Name].HasColor(CardColor.Green)));
Console.WriteLine("Colorless cards: {0}",
library.Count(x => Grove.Cards.All[x.Name].HasColor(CardColor.Colorless)));
var deck = DeckBuilder.BuildDeck(library, ratings);
Console.WriteLine();
Console.WriteLine("Creatures: {0}, Spells {1}",
deck.Count(x => Grove.Cards.All[x.Name].Is().Creature),
deck.Count(x => !Grove.Cards.All[x.Name].Is().Creature&& !Grove.Cards.All[x.Name].Is().Land));
Console.WriteLine("-------------------");
Console.WriteLine(deck);
Console.WriteLine();
}
}
private Deck getDefaultDeck()
{
DeckBuilder deckBuilder = new DeckBuilder()
.setDeckName("Default")
.setDeckEditable(false)
.addCard("DefPor1", "DefEng1")
.addCard("DefPor2", "DefEng2")
.addCard("DefPor3", "DefEng3")
.addCard("DefPor4", "DefEng4");
return deckBuilder.getDeck();
}
private IEnumerator saveDeck(StoreDeck storeDeck)
{
painel.GetComponent<LoadingPanelCreator>().CreateLoadingPanel();
DeckBuilder deckBuilder = new DeckBuilder(storeDeck);
Deck deck = deckBuilder.getDeck();
Player player = Player.getInstance();
player.addToStoreDeckNameList(deck.DeckName);
player.Currency -= storeDeck.Price;
currency.text = player.Currency.ToString();
player.addDeck(deck);
PlayerDao playerDao = new PlayerDao();
yield return playerDao.savePlayer(player);
if (!playerDao.isSaveSuccessfull())
error.text = "Erro ao salvar compra, porfavor verifique sua conexão";
selectedDeckUI.transform.parent = null;
Store.deletDeck(storeDeck);
painel.GetComponent<LoadingPanelCreator>().DestroyLoadingPanel();
}
void Start()
{
//Don't know what the f**k I'm doing here, but works. #coding101
deckManager = GameObject.Find("DeckBuilder").GetComponent<DeckBuilder>();
}
public void Awake()
{
Singleton = this;
}
