public static string Share(this IDeck deck, string name) { try { var tempFile = Path.GetTempFileName(); var game = GameManager.Get().GetById(deck.GameId); deck.Save(game, tempFile); var client = new ApiClient(); if (!Program.LobbyClient.IsConnected) { throw new UserMessageException("You must be logged in to share a deck."); } if (string.IsNullOrWhiteSpace(name)) { throw new UserMessageException("The deck name can't be blank."); } if (name.Length > 32) { throw new UserMessageException("The deck name is too long."); } var result = client.ShareDeck(Program.LobbyClient.Username, Program.LobbyClient.Password, name, tempFile); if (result.Error) { throw new UserMessageException(result.Message); } return(result.DeckPath); } catch (Exception) { throw new UserMessageException("There was an error sharing your deck. 0xFFFF"); } }
public void DeckCanDealACard() { IDeck deck = texasHoldEmBuilder.CreateNewDeck(); ICard card = deck.Deal(); Assert.IsNotNull(card); }
/// <summary> /// The Get. /// </summary> /// <param name="sqlConnectString">The sqlConnectString<see cref="string"/>.</param> /// <param name="sqlQry">The sqlQry<see cref="string"/>.</param> /// <param name="tableName">The tableName<see cref="string"/>.</param> /// <param name="keyNames">The keyNames<see cref="IDeck{string}"/>.</param> /// <returns>The <see cref="IFigures"/>.</returns> public IFigures Get(string sqlConnectString, string sqlQry, string tableName, IDeck <string> keyNames) { try { if (DbHand.Schema == null || DbHand.Schema.DbTables.Count == 0) { Sqlbase sqb = new Sqlbase(sqlConnectString); } SqlAdapter sqa = new SqlAdapter(sqlConnectString); try { return(sqa.ExecuteInject(sqlQry, tableName, keyNames)); } catch (Exception ex) { throw new SqlException(ex.ToString()); } } catch (Exception ex) { throw ex; } }
public IEnumerable <IEnumerable <ICard> > Deal(IDeck deck, DealingOptions options) { if (options.AsEvenPiles) { //make sure we have enough cards if (options.Groups * options.CardsPerGroup > deck.Cards.Count) { throw new InvalidOperationException("There is not enough cards."); } } var dealtCards = new List <List <ICard> >(); for (var i = 0; i < options.Groups; i++) { var cardsForGroup = new List <ICard>(); dealtCards.Add(cardsForGroup); for (var j = 0; j < options.CardsPerGroup; j++) { if (!deck.Cards.Any()) { break; } cardsForGroup.Add(deck.Draw()); } } return(dealtCards); }
protected override void Setup() { _state = GameState.Running; _deck = new Deck(); _playerHand = new PlayerHand(); _dealerHand = new DealerHand(); }
internal PlayerAction InteractWithPlayer(IDeck deck, IPlayer player, Dealer dealer) { PlayerAction action; string actionDisplay; do { action = player.NextAction(dealer.GetHand()); actionDisplay = GetActionMessage(player, action); DisplayMessage(actionDisplay); if (action == PlayerAction.Hit) { ICard card = deck.DealTopCard(true); player.AddCardToHand(card); int score = player.GetHand().Score(true); if (score > MAXSCORE) { action = PlayerAction.Busted; actionDisplay = GetActionMessage(player, action); DisplayMessage(actionDisplay); } string scoreDisplay = GetScoreMessage(player); DisplayMessage(scoreDisplay); string handDisplay = GetHandMessage(player.GetHand(), true); DisplayMessage(handDisplay); } } while (action != PlayerAction.Busted && action != PlayerAction.Stand); return(action); }
public IDeck Transform(IDeck input) { Deck result = new Deck(); ICardEdition minimal = cardDb.Editions.First(); foreach (var c in input.Sections.SelectMany(s => input[s])) { var minEd = cardDb.GetEarliestEditionOfCard(c.Name); if (minEd.CompareTo(minimal) > 0) { minimal = minEd; } } foreach (var s in input.Sections) { var sa = result.EnsureSection(s); foreach (var c in input[s]) { sa.Add(cardDb.CardByName(c.Name, cardDb.GetLatestEditionForCard(c.Name, minimal))); } } return(result); }
public MetaDeck(string path) { IDeck d = null; this.Path = path; this.Name = new FileInfo(Path).Name.Replace(new FileInfo(Path).Extension, ""); CardBack = "pack://application:,,,/Resources/Back.jpg"; try { d = this.Load(path, false); } catch (Exception e) { Log.Warn("New MetaDeck Error", e); IsCorrupt = true; } if (d == null) { return; } this.GameId = d.GameId; this.IsShared = d.IsShared; this.Notes = d.Notes ?? ""; this.Sections = d.Sections.Select(x => new Section() { Name = x.Name, Shared = x.Shared, Cards = x.Cards.Select(y => new MetaMultiCard(y)).ToArray() }).ToArray(); this.NonEmptySections = this.Sections.Where(x => x.Quantity > 0).ToArray(); this.CardBack = GameManager.Get().GetById(this.GameId).CardSize.Back; this.Sleeve = (ISleeve)d.Sleeve?.Clone(); }
public FirstHero(string name) { this.playerOneDeck = new Deck(); this.yuGiOhCardsInHand = new List<ICard>(); this.generalHealthPoints = GENERAL_HEALTH_POINTS; this.Name = name; }
public GameForm() { this.InitializeComponent(); this.timer.Interval = 1000; this.timer.Tick += this.TimerTick; this.updates.Interval = 100; this.updates.Tick += this.UpdateTick; this.textboxBigBlind.Visible = false; this.textboxSmallBlind.Visible = false; this.buttonBigBlind.Visible = false; this.buttonSmallBlind.Visible = false; this.textboxRaise.Text = (AppSettigns.DefaultMinBigBlind * 2).ToString(); IPlayer human = this.GetHumanPlayer(); IAILogicProvider logicProvider = new AILogicProvider(); ICollection <IAIPlayer> enemies = this.GetEnemies(logicProvider); IPot pot = new Pot(this.textboxPot); IDealer dealer = this.GetDealer(); IDeck deck = Deck.Instance; this.messageWriter = new MessageBoxWriter(); IHandTypeHandler handTypeHandler = new HandTypeHandler(); this.engine = new GameEngine(human, enemies, pot, dealer, deck, this.messageWriter, handTypeHandler); this.engine.GameEngineStateEvent += this.ChangeGameEngineStateHandler; this.updates.Start(); this.engine.Run(); }
private void SetupDeckForPlayers(IDeck deck, IEnumerable<ICard> cards) { foreach (var card in cards) { deck.Cards.Push(card); } }
/// <summary> /// Initializes a new instance of a <see cref="GameManager"/> for playing the card game war. /// </summary> /// <param name="baseDeck">The base deck to play with</param> /// <param name="display">An implementation of the <see cref="IDisplay"/> contract</param> /// <param name="statCollector">An implementation of the <see cref="IStatCollector"/> contract</param> /// <param name="gameOptions">The options for the game</param> public GameManager(IDeck baseDeck, IDisplay display, IStatCollector statCollector, WarGameOptions gameOptions) { _display = display; _statCollector = statCollector; _baseDeck = baseDeck; _gameOptions = gameOptions; }
/// <summary> /// When two player's cards tie, we have to do the 'War' action. In this action, you put (up to) /// three cards at stake and then flip another card for battle. Whomever's card is higher gets all the /// cards. /// /// This can repeat multiple times in a row. /// </summary> /// <param name="deckOne">Player one's deck</param> /// <param name="deckTwo">Player two's deck</param> /// <param name="playerOneCard">The card that started the war for player one</param> /// <param name="playerTwoCard">The card that started the war for player two</param> private void War(IDeck deckOne, IDeck deckTwo, Card playerOneCard, Card playerTwoCard) { _display.DisplayMessage($"War between Player 1's {playerOneCard} and Player 2's {playerTwoCard}!"); List <Card> cardsUpForStake = new List <Card> { playerOneCard, playerTwoCard }; while (true) { // If there's only one card left in the deck, we need to make sure to use the card played to start the war playerOneCard = GetCardForWarAndPutCardsUpForStake(deckOne, cardsUpForStake) ?? playerOneCard; playerTwoCard = GetCardForWarAndPutCardsUpForStake(deckTwo, cardsUpForStake) ?? playerTwoCard; if (playerOneCard.Rank > playerTwoCard.Rank) { DoWarOverActions(1, playerOneCard, playerTwoCard, deckOne, deckTwo, cardsUpForStake); return; } else if (playerOneCard.Rank < playerTwoCard.Rank) { DoWarOverActions(2, playerTwoCard, playerOneCard, deckTwo, deckOne, cardsUpForStake); return; } } }
public Game(IDeck deck, IShuffleCards shuffleCards, IPlayCardLogic playCardLogic) { _deck = deck; _cards = deck.Cards.ToList(); _shuffleCards = shuffleCards; _playCardLogic = playCardLogic; }
public DeckHeaderResponse MapToDeckHeader(IDeck deck) { return(new DeckHeaderResponse { DeckName = deck.Name }); }
public void Start() { _deck = _deckFactory.CreateDeck(); _deck.Shuffle(); var briscola = _deck.PeekLast(); if (_subscribers.Count != 2 && _subscribers.Count != 4) { throw new InvalidOperationException("You can start a new game only with 2 or 4 players. Please Join"); } var state = new GameState(_subscribers, briscola); foreach (var pl in state.Players) { for (var i = 0; i < 3; i++) { var card = _deck.Pop(); pl.Take(card); } } state.Briscola = _deck.PeekLast(); Chat.GetUI().Strong(string.Format("BRISCOLA: {0} di {1}", state.Briscola.Value, state.Briscola.Seed)); State = state; }
public static IDeck Load(this IDeck deck, string path, bool cloneCards = true) { var ret = new Deck(); try { Game game = null; using (var fs = File.Open(path, FileMode.Open, FileAccess.ReadWrite, FileShare.None)) { var doc = XDocument.Load(fs); var gameId = Guid.Parse(doc.Descendants("deck").First().Attribute("game").Value); game = Octgn.DataNew.DbContext.Get().Games.FirstOrDefault(x => x.Id == gameId); if (game == null) { throw new UserMessageException("Could not load deck from {0}, you do not have the associated game installed.", path); } } return(deck.Load(game, path, cloneCards)); } catch (UserMessageException) { throw; } catch (Exception e) { Log.Error(String.Format("Problem loading deck from path {0}", path), e); throw new UserMessageException("Could not load deck from {0}, there was an unspecified problem.", path); } return(null); }
public SecondHero(string name) { this.playerTwoDeck = new Deck(); this.yuGiOhCardsInHand = new List <ICard>(); this.generalHealthPoints = GENERAL_HEALTH_POINTS; this.Name = name; }
public static void InitGameObjectss(TestContext testContext) { players = new List<IPlayer>(); IPlayer human = PlayerFactory.CreateHuman("human", 10000, new Label(), new TextBox(), AnchorStyles.Bottom, 100, 100); players.Add(human); IAILogicProvider logicProvider = new AILogicProvider(); IAIPlayer AI1 = PlayerFactory.CreateAI(logicProvider, "AI1", 10000, new Label(), new TextBox(), AnchorStyles.Bottom, 100, 100); players.Add(AI1); IAIPlayer AI2 = PlayerFactory.CreateAI(logicProvider, "AI2", 10000, new Label(), new TextBox(), AnchorStyles.Bottom, 100, 100); players.Add(AI2); IAIPlayer AI3 = PlayerFactory.CreateAI(logicProvider, "AI3", 10000, new Label(), new TextBox(), AnchorStyles.Bottom, 100, 100); players.Add(AI3); IAIPlayer AI4 = PlayerFactory.CreateAI(logicProvider, "AI4", 10000, new Label(), new TextBox(), AnchorStyles.Bottom, 100, 100); players.Add(AI4); IAIPlayer AI5 = PlayerFactory.CreateAI(logicProvider, "AI5", 10000, new Label(), new TextBox(), AnchorStyles.Bottom, 100, 100); players.Add(AI5); dealer = new Dealer(100, 100); deck = new MockDeck(); handHandler = new HandTypeHandler(); }
public bool NewGame(IDeck a_deck, Dealer a_dealer, Player a_player) { //Refactoring. Inherit method from BaseGameStrategy GetCardAndDeal(a_deck, a_player, true); GetCardAndDeal(a_deck, a_dealer, true); GetCardAndDeal(a_deck, a_player, true); GetCardAndDeal(a_deck, a_dealer, false); //Card c; //c = a_deck.GetCard(); //c.Show(true); //a_player.DealCard(c); //c = a_deck.GetCard(); //c.Show(true); //a_dealer.DealCard(c); //c = a_deck.GetCard(); //c.Show(true); //a_player.DealCard(c); //c = a_deck.GetCard(); //c.Show(false); //a_dealer.DealCard(c); return(true); }
public MemorizationPageViewModel(IDeck deck, ITimeTracker timeTracker, ICardAssociationRepository repo) : this() { _timeTracker = timeTracker; _deck = deck; _cardAssociationRepository = repo; }
public void DealInitialHands(IDeck deck, Dealer dealer, IPlayer player) { player.AddCardToHand(deck.DealTopCard(false)); dealer.AddCardToHand(deck.DealTopCard(false)); player.AddCardToHand(deck.DealTopCard(true)); dealer.AddCardToHand(deck.DealTopCard(true)); }
public AbercioStrategyTest() { Strategy = new AbercioStrategy(); Deck = new RandomizedDeck(); Game = new BriscolaGame(new RandomizedDeckFactory(Deck), new PlayerFactory()); Game.Join("Gianni", Strategy); Game.Join("Pinotto", Strategy); FieldInfo deckField = Game.GetType().GetField("_deck", BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance); deckField.SetValue(Game, Deck); FieldInfo subscribersField = Game.GetType().GetField("_subscribers", BindingFlags.NonPublic | BindingFlags.GetField | BindingFlags.Instance); List <IPlayer> players = (List <IPlayer>)subscribersField.GetValue(Game); foreach (Player player in players) { for (var i = 0; i < 3; i++) { var card = Deck.Pop(); player.Take(card); } } Card briscola = Deck.PeekLast(); State = new GameState(players, briscola); PropertyInfo stateProperty = Game.GetType().GetProperty("State"); stateProperty.SetValue(Game, State); Player1 = State.Players.ElementAt(0); Player2 = State.Players.ElementAt(1); }
public OhHellGame(FourPlayers players, IBiddings biddings, IDeck deck) { _Players = players; _Biddings = biddings; _Deck = deck; _Dealer = new Dealer(); }
public Table(IDeck deck, int playerNumber) { this.Deck = deck; this.Players = this.GetPlayersFromNumber(playerNumber); this.GetFirstCards(); this.CurrentPlayer = this.Players.GetCurrentElement(); }
public Game() { deck = new PlayingCardDeck(); deck.ShuffleDeck(); playerOneTurn = true; removalmap = new Dictionary <bool, bool>(); removalmap.Add(true, false); removalmap.Add(false, false); var startingcards = new ICard[5]; for (int i = 0; i < 5; i++) { startingcards[i] = deck.DrawCard(); } board = new GameBoard(startingcards); player1hand = new List <ICard>(); player2hand = new List <ICard>(); for (int i = 0; i < 5; i++) { player1hand.Add(deck.DrawCard()); player2hand.Add(deck.DrawCard()); } }
public GameBoard() { InitializeComponent(); balance = 12000; _deckofcards = new Deck(); _kbd.KeyUp += _kbd_KeyUp; }
public Game(IDeck deck) { Deck = deck; deck.InitialiseDeck(); Players = new List <Player>(); PickUpPile = new List <Card>(); }
private List <string> Deck(IDeck deck) { List <List <string> > forms = new List <List <string> >() { new TileForms().Forms[deck.OpenTiles[0].Form][deck.OpenTiles[0].Rotation], new TileForms().Forms[deck.OpenTiles[1].Form][deck.OpenTiles[1].Rotation], new TileForms().Forms[deck.OpenTiles[2].Form][deck.OpenTiles[2].Rotation], new TileForms().Forms[deck.OpenTiles[3].Form][deck.OpenTiles[3].Rotation], }; List <string> lines = new List <string>() { "+ - - - + - - - + - - - + - - - +", string.Empty, string.Empty, string.Empty, "+ - - - + - - - + - - - + - - - +" }; for (int i = 0; i < 4; i++) { lines[1] += $"| {forms[i][0]} {forms[i][1]} {forms[i][2]} "; lines[2] += $"| {forms[i][3]} {forms[i][4]} {forms[i][5]} "; lines[3] += $"| {forms[i][6]} {forms[i][7]} {forms[i][8]} "; } lines[1] += "|"; lines[2] += "|"; lines[3] += "|"; return(lines); }
public bool NewGame(IDeck a_deck, Dealer a_dealer, Player a_player) { //Refactoring. Inherit method from BaseGameStrategy GetCardAndDeal(a_deck, a_player, true); GetCardAndDeal(a_deck, a_dealer, true); GetCardAndDeal(a_deck, a_player, true); GetCardAndDeal(a_deck, a_dealer, false); //Card c; //c = a_deck.GetCard(); //c.Show(true); //a_player.DealCard(c); //c = a_deck.GetCard(); //c.Show(true); //a_dealer.DealCard(c); //c = a_deck.GetCard(); //c.Show(true); //a_player.DealCard(c); //c = a_deck.GetCard(); //c.Show(false); //a_dealer.DealCard(c); return true; }
public PlayerManager(IPlayer dealer, List <IPlayer> players, IDeck deck) { Dealer = dealer; Players = players; CurrentPlayerIndex = 0; Deck = deck; }
private Game(Game game) { this.deck = game.deck.CopyDeck(); this.board = game.board.CopyBoard(); this.player1hand = new List <ICard>(); this.player2hand = new List <ICard>(); foreach (ICard card in game.player1hand) { player1hand.Add(card.CopyCard()); } foreach (ICard card in game.player2hand) { this.player2hand.Add(card.CopyCard()); } removalmap = new Dictionary <int, bool>(); bool val; game.removalmap.TryGetValue(0, out val); removalmap.Add(0, val); game.removalmap.TryGetValue(1, out val); removalmap.Add(1, val); this.playerturn = game.playerturn; }
public Player(IDeck deck) { this.LifePoints = Player.LIFE_POINTS; this.ManaPoints = Player.MANA_POINTS; this.Hand = new List <ICard>(6); this.Deck = deck; }
public static IDeck Load(this IDeck deck, string path, bool cloneCards = true) { var ret = new Deck(); try { Game game = null; using (var fs = File.Open(path, FileMode.Open, FileAccess.ReadWrite, FileShare.None)) { var doc = XDocument.Load(fs); var gameId = Guid.Parse(doc.Descendants("deck").First().Attribute("game").Value); game = Octgn.Core.DataManagers.GameManager.Get().GetById(gameId); if (game == null) { throw new UserMessageException(L.D.Exception__CanNotLoadDeckGameNotInstalled_Format, path); } } return(deck.Load(game, path, cloneCards)); } catch (UserMessageException) { throw; } catch (Exception e) { Log.Error(String.Format("Problem loading deck from path {0}", path), e); throw new UserMessageException(L.D.Exception__CanNotLoadDeckUnspecified_Format, path); } }
/// <param name='operations'> /// Reference to the AzureCards.WindowsStoreApp.IDeck. /// </param> /// <param name='deckId'> /// Required. /// </param> public static bool Shuffle(this IDeck operations, string deckId) { return(Task.Factory.StartNew((object s) => { return ((IDeck)s).ShuffleAsync(deckId); } , operations, CancellationToken.None, TaskCreationOptions.None, TaskScheduler.Default).Unwrap().GetAwaiter().GetResult()); }
internal Game(IDeck deck, IGameBoard board) { _deck = deck; _board = board; _events = new Queue<GameEvent>(); _users = new List<Guid>(); _hands = new Dictionary<Guid, List<Card>>(); }
protected void GetCardAndDeal(IDeck a_deck, Player a_player, bool showCard) { Card c; c = a_deck.GetCard(); c.Show(showCard); a_player.DealCard(c); }
public UnoGame(IDeck deck) { _tableDeck = new TableDeck(); _deck = deck; _cardRules = _deck.GetCardRules(); _playersInGame = new List<Player>(); _currentPlayersTurn = 0; }
private void InitializeDeck() { this.deck = new Deck(); foreach (var card in this.deck.Cards) { this.Controls.Add(card.PictureBox); } }
public Player(IHand aHand, IDeck aDeck, IDiscard aDiscard) { hand = aHand; deck = aDeck; discard = aDiscard; ExpandHandTo(5); }
public void Init() { ninject = new StandardKernel(new BindingsModule()); deckFactory = ninject.Get<DeckFactory>(); chanceDeck = deckFactory.BuildChanceDeck(); chestDeck = deckFactory.BuildCommunitiyChestDeck(); }
public CardFormatInfo(IDeck deck) { if (deck == null) { throw new ArgumentNullException(nameof(deck)); } Deck = deck; }
public void InitializeDeckPlayersAndCards() { this.deck = new Deck(); this.players = new List<IParticipant>(); this.players.Add(new Player("Meco pug", GlobalVariables.PlayerPlaceOnBoard)); this.players.Add(new Bot("Isuf", GlobalVariables.Bot1PlaceOnBoard)); this.players.Add(new Bot("Georgi-Nikol", GlobalVariables.Bot2PlaceOnBoard)); this.cardsOnBoard = new ICard[5]; }
public static void ChangeFirstCardPosition(IDeck deck, IEnumerable<ICard> cards, ICard card, Priority priority) { var maxPosition = GetMaxPosition(cards); var position = deck.Type == DeckType.Predictable ? GetStaticPosition(priority, maxPosition) : GetRandomPosition(priority, maxPosition); ChangeFirstCardPosition(cards, card, position); }
private static void AddNumberedCards(IDeck deck) { if (deck == null) throw new ArgumentNullException("deck"); AddNumberedCards(deck, CardColour.Blue); AddNumberedCards(deck, CardColour.Green); AddNumberedCards(deck, CardColour.Red); AddNumberedCards(deck, CardColour.Yellow); }
public PlayerObjectContainer(PlayerHandClass player, string playerName, IDeck deck) { PlayerHand = player; PlayerName = playerName; Deck = deck; PlayerNumber = playerName == PLAYER2_USER ? 1 : 0; }
public void TestInit() { _deck = _DECK_BUILDER .ConsistsOfDecks(_NUMBER_OF_DECKS) .Build(); _module = _MODULE_FACTORY .NumberOfDecksIs(_NUMBER_OF_DECKS) .GetChanceModule(); }
public void Setup() { string inputText = "a"; GetPlayerCount(ref numberOfPlayer, ref inputText); CreateDealer(); CreatePlayers(); deck = new Deck(); }
private static void AddSkipCards(IDeck deck) { var deckCount = deck.NumberOfCardsInDeck; foreach (var cardColour in CardColours) { deck.Push(new Skip(cardColour)); deck.Push(new Skip(cardColour)); } Debug.WriteLine(deck.NumberOfCardsInDeck - deckCount, "Skip"); }
private static void FormatAllCards(CardMask cardMask, CardFormatInfo cardFormatInfo, bool isOnePatternAlreadyProcessed, StringBuilder sb, IDeck deck, char patternChar, int num1) { var cardIndexes = cardFormatInfo.Deck.ToCardIndexes(cardMask); var i = 0; foreach (var cardIndex in cardIndexes) { if (i == 0 && isOnePatternAlreadyProcessed) { sb.Append(cardFormatInfo.PatternSeparator); } var rankIndex = deck.ToRankIndex(cardIndex); var suitIndex = deck.ToSuitIndex(cardIndex); switch (patternChar) { case 'i': if (i != 0) { sb.Append(cardFormatInfo.CardIndexesSeparator); } sb.Append(cardIndex.ToString(CultureInfo.CurrentCulture)); break; case 'a': FormatAbbreviatedName(cardFormatInfo, i, sb, rankIndex, suitIndex); break; case 'c': FormatName(cardFormatInfo, i, sb, rankIndex, suitIndex); break; case 'r': case 's': FormatAbbreviatedName2(cardFormatInfo, i, sb, patternChar, rankIndex, suitIndex, num1); break; case 'R': case 'S': FormatName2(cardFormatInfo, i, sb, patternChar, rankIndex, suitIndex, num1); break; default: throw new ArgumentException(patternChar.ToString()); } ++i; } }
public bool NewGame(Player a_player) { if (m_deck == null || IsGameOver()) { //Get a 'normal' deck of cards or get a 'fake' deck, that can be manipulated m_deck = m_deckFactory.GetDeck(); ClearHand(); a_player.ClearHand(); return m_newGameRule.NewGame(m_deck, this, a_player); } return false; }
public Trick( RoundPlayerInfo firstToPlay, RoundPlayerInfo secondToPlay, IStateManager stateManager, IDeck deck, IGameRules gameRules) { this.firstToPlay = firstToPlay; this.secondToPlay = secondToPlay; this.stateManager = stateManager; this.deck = deck; this.gameRules = gameRules; }
public void ChangeEncounterDeck(IDeck<IEncounterCard> encounterDeck) { if (encounterDeck == null) throw new ArgumentNullException("encounterDeck"); if (this.EncounterDeck != null) { EncounterDeck.ShuffleIn(cardsInStagingArea.Select(x => x.Card)); cardsInStagingArea.Clear(); this.EncounterDeck.ShuffleDiscardPileIntoDeck(); } this.EncounterDeck = encounterDeck; }
public SimRound( ISimPlayer firstPlayer, ISimPlayer secondPlayer, IGameRules gameRules, PlayerPosition firstToPlay = PlayerPosition.FirstPlayer) { this.gameRules = gameRules; this.deck = new SimDeck(); this.stateManager = new SimStateManager(); this.firstPlayer = new SimRoundPlayerInfo(firstPlayer); this.secondPlayer = new SimRoundPlayerInfo(secondPlayer); this.firstToPlay = firstToPlay; }
public Game() { _consoleLogger = CardGameFactory.CreateConsoleLogger(); _consoleLogger.WriteMessage("How many decks would you like to play with"); int decksToPlay; while (!Int32.TryParse(Console.ReadLine(), out decksToPlay)) { _consoleLogger.WriteMessage("Value entered is not a number"); _consoleLogger.WriteMessage("How many decks would you like to play with"); } _deck = CardGameFactory.GenerateDeck(decksToPlay); _randomizer = CardGameFactory.GenerateRNGWrapper(); _deck.InitiliazeDeck(); }
public GameEngine(IPlayer human, ICollection<IAIPlayer> enemies, IPot pot, IDealer dealer, IDeck deck, IMessageWriter messageWriter, IHandTypeHandler handTypeHandler) { this.human = human; this.enemies = new List<IAIPlayer>(enemies); this.Pot = pot; this.dealer = dealer; this.deck = deck; this.MessageWriter = messageWriter; this.handTypeHandler = handTypeHandler; this.BigBlind = AppSettigns.DefaultMinBigBlind; this.SmallBlind = AppSettigns.DefaultMinSmallBlind; this.SetDefaultCall(); this.Raise = 0; this.IsAnyPlayerRaise = false; }
public QuestArea(IGame game, IDeck<IQuestCard> questDeck, IEnumerable<IDeck<IEncounterCard>> encounterDecks) : base(game) { if (questDeck == null) throw new ArgumentNullException("questDeck"); if (questDeck.Cards.Count() == 0) throw new ArgumentException("questDeck does not contain any cards"); if (encounterDecks == null) throw new ArgumentNullException("encounterDecks"); if (encounterDecks.Count() == 0) throw new ArgumentException("encounterDecks is an empty list"); this.QuestDeck = questDeck; this.EncounterDecks = encounterDecks; }
public static void AttackAndTrySkills(IAgentInfo target, IAgent engineer, IDeck deck, IAgentUpdateInfo update) { if (target == null) { deck.Trace("Target is null",TraceType.Information); return; } deck.Trace(string.Format("Attack: Owner {0} Level {1} Stack {2} at {3}:{4}:{5}", target.Owner, target.Level, target.Stack, update.Node.Row, update.Node.Column, update.Node.Layer), TraceType.Information); engineer.Attack(target); Skills(target, update, engineer); }
private static void AddNumberedCards(IDeck deck, CardColour cardColour) { var deckCount = deck.NumberOfCardsInDeck; // Add Numbers 1 to 9 (twice) for (var i = 1; i <= 9; i++) { deck.Push(new Number(i, cardColour)); deck.Push(new Number(i, cardColour)); } // Add One Zero card for this colour deck.Push(new Number(0, cardColour)); //Debug.WriteLine(deck.NumberOfCardsInDeck - deckCount, string.Format("{0} Cards", cardColour)); }
public void Launch() { if (DeckPath == null) return; try { Deck = new MetaDeck(DeckPath); var win = new DeckBuilderWindow(Deck,true); Application.Current.MainWindow = win; win.Show(); } catch (UserMessageException e) { TopMostMessageBox.Show(e.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Asterisk); this.Shutdown = true; } }