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