public Solitaire(ISolitaireDealer dealer, ISolitaireBoard board, ICardDeck cardDeck)
{
Dealer = dealer;
Board = board;
CardDeck = cardDeck;
player = new Player();
}
public void InitializeDecks(int seed)
{
StuffManager stuffManager = StuffManager.Instance;
DxMCardDeck = new CardDeck<IDxMCard>(stuffManager.DxMCards, seed);
TreasureCardDeck = new CardDeck<ITreasureCard>(stuffManager.TreasureCards, seed);
MonsterCardDeck = new CardDeck<IMonsterCard>(stuffManager.MonsterCards, seed);
}
public async Task Play(IEnumerable <IPlayer> players, ICardDealer dealer, ICardDeck deck, ICardTransport transport, ICentralPile centralPile)
{
deck.Shuffle();
DumpState("Deck", players, centralPile.GetAll());
dealer.Deal(deck, players);
while (!HasWinner && players.Any(p => !p.Hand.IsEmpty))
{
foreach (var player in players)
{
player.TakeTurn(centralPile, transport);
}
DumpState("Play", players, centralPile.GetAll());
await ProcessPlayerSnaps(players, centralPile, transport);
if (players.Where(o => o.Hand.IsEmpty).Count() == (players.Count() - 1))
{
var winner = (from p in players
orderby p.Hand.Count descending
select p)
.First();
Winner = winner;
}
}
}
public void InsertBaseGameCards(ICardDeck currentDeck)
{
foreach(var card in this.zombicideCards)
{
currentDeck.InsertCard(card);
}
}
public void OnCardDeckEvents(ICardDeck deck)
{
throw new NotImplementedException();
string message = "";
Output(message);
}
private void Construct(ICardDeck cardDeck, CombinationsData combinationsData)
{
_cardDeck = cardDeck;
InitCombinations(combinationsData);
InitCardsVisual();
InitTable();
}
public Squad(ISquadConfiguration config, CardDeckConfig deckConfig)
{
Config = config;
Deck = new CardDeck(this, deckConfig.GetCards());
var bus = ServiceLocator.Instance.GetService <IMessageBus>();
_token = bus.Subscribe <EntityKilledMessage>(OnEntityKilled);
}
public Game(string name, ICardDeck cardDeck)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException(@"Name cannot be null or empty.", nameof(name));
}
Id = Guid.NewGuid().ToString("N");
Name = name;
_cardDeck = cardDeck;
}
public GameService(IConsoleWrapper consoleWrapper, ICardDeck cardDeck)
{
_consoleWrapper = consoleWrapper;
var numberOfPlayers = getNumberOfPlayers();
cardDeck.ShuffleDeck();
initializePlayers(numberOfPlayers);
setUpPlayers(cardDeck, numberOfPlayers);
}
public void Deal(ICardDeck cardDeck, IEnumerable <IPlayer> players)
{
var playerCount = players.Count();
while (cardDeck.Count >= playerCount)
{
foreach (var player in players)
{
cardTransport.Transfer(cardDeck, player.Hand);
}
}
}
private List <ECardSuitTypes> GetCardSuitTypesFromDeck(ICardDeck deck)
{
List <ECardSuitTypes> suitTypes = new List <ECardSuitTypes>();
foreach (ICard card in deck.Cards)
{
if (!suitTypes.Contains(card.CardSuit))
{
suitTypes.Add(card.CardSuit);
}
}
return(suitTypes);
}
/// <summary>
/// Sample program for test (for now)
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
// Create a deck of cards (52)
DeckCards myDeck = new DeckCards(1);
// create a discard deck :)
DeckCards discardDeck = new DeckCards();
// shuffle the initial deck
myDeck.Shuffle();
Card nextCard = null;
int counter = 1;
do
{
// get the topmost card and add to the discard deck
nextCard = myDeck.GetNext();
if (nextCard != null)
{
discardDeck.AddCard(nextCard);
// display
Console.WriteLine("{0}, Card: Value: {1}, Suite: {2}", counter++, nextCard.Value, nextCard.Suit);
}
} while (nextCard != null);
Console.WriteLine("done");
// shuffle the discard deck
discardDeck.Shuffle();
do
{
nextCard = discardDeck.GetNext();
if (nextCard != null)
{
// display
Console.WriteLine("{0}, Card: Value: {1}, Suite: {2}", counter++, nextCard.Value, nextCard.Suit);
}
} while (nextCard != null);
Console.WriteLine("done");
// test the Interface and enumerator
ICardDeck foo = discardDeck;
Console.WriteLine("done");
foreach (Card card in foo)
{
Console.WriteLine(" Card: Value: {0}, Suite: {1}", card.Value, card.Suit);
}
}
/// <summary>
/// Increase the election tracker count. Clears term limits and resets the
/// election tracker if needed, as well as enacts a policy. The consumer
/// must check if a win condition needs to be enforced as a result of the
/// policy being enacted.
/// </summary>
/// <param name="policyDeck">
/// Policy deck implementation. The default is used if null.
/// </param>
/// <returns>True if election tracker max value exceeded.</returns>
public virtual bool UpdateElectionTracker(ICardDeck <PolicyType> policyDeck = null)
{
Game.ElectionTracker++;
if (Game.ElectionTracker >= Constants.FailedElectionThreshold)
{
Game.ElectionTracker = 0;
Game.IneligibleChancellors.Clear();
var drawnPolicy = (policyDeck ?? new PolicyDeck(Game.DrawPile, Game.DiscardPile, false)).Draw();
EnactPolicy(drawnPolicy.Single());
return(true);
}
return(false);
}
private void setUpPlayers(ICardDeck deckOfCards, int numberOfPlayers)
{
var playerNumber = 0;
var drawnCard = deckOfCards.DrawCard();
while (drawnCard != null)
{
players[playerNumber].AddCard(drawnCard);
drawnCard = deckOfCards.DrawCard();
playerNumber++;
if (playerNumber >= numberOfPlayers)
{
playerNumber = 0;
}
}
}
protected override void OnCreate(Bundle bundle)
{
base.OnCreate(bundle);
try
{
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
this.currentDeck = this.cardManager.CreateGenericDeck();
string content;
using (StreamReader sr = new StreamReader(Assets.Open("ZombicideCards.xml")))
{
content = sr.ReadToEnd();
}
var deckFactory = new ZombicideDeckFactory(content);
deckFactory.InsertBaseGameCards(currentDeck);
this.NewSession();
var drawButton = FindViewById<Button>(Resource.Id.DrawCardButton);
drawButton.Click += DrawButtonClicked;
var shuffleButton = FindViewById<Button>(Resource.Id.ShuffleButton);
shuffleButton.Click += ShuffleButtonClicked;
var redButton = FindViewById<Button>(Resource.Id.RedLevel);
redButton.Click += RedButtonClicked;
var orangeButton = FindViewById<Button>(Resource.Id.OrangeLevel);
orangeButton.Click += OrangeButtonClicked;
var yellowButton = FindViewById<Button>(Resource.Id.YellowLevel);
yellowButton.Click += YellowButtonClicked;
var blueButton = FindViewById<Button>(Resource.Id.BlueLevel);
blueButton.Click += BlueButtonClicked;
this.UpdateCardDisplay();
this.UpdateDeckStatus();
}
catch(Exception e)
{
Console.WriteLine(" exeption " + e);
}
}
/// <summary>
/// Static method to validate if the subdeck passed is
/// a third (3 of the same value)
/// </summary>
/// <param name="subdeck"></param>
/// <returns>true if is a third, false if not</returns>
public static bool IsThird(ICardDeck subdeck)
{
if (subdeck == null)
{
throw new InvalidProgramException("Null subdeck");
}
// minimum number of cards is 3
if (subdeck.Count < 3)
{
return(false);
}
var first = subdeck.First();
// iterate over all the cards and if all of them contain the same
// value then return true, else false
return(subdeck.All(x => x.Value == first.Value) ? true : false);
}
public SolitaireGameModel(
ICardDeck cardDeck,
ICardPileFactory cardPileFactory,
IObserversCollection <GameStarted> gameStartedObservers,
IObserversCollection <StepDone> stepDoneObservers,
IObserversCollection <GameEnded> gameEndedObservers)
{
if (cardDeck == null)
{
throw new ArgumentNullException(nameof(cardDeck));
}
if (cardPileFactory == null)
{
throw new ArgumentNullException(nameof(cardPileFactory));
}
if (gameStartedObservers == null)
{
throw new ArgumentNullException(nameof(gameStartedObservers));
}
if (stepDoneObservers == null)
{
throw new ArgumentNullException(nameof(stepDoneObservers));
}
if (gameEndedObservers == null)
{
throw new ArgumentNullException(nameof(gameEndedObservers));
}
_cardDeck = cardDeck;
_cardPileFactory = cardPileFactory;
_gameStartedObservers = gameStartedObservers;
_stepDoneObservers = stepDoneObservers;
_gameEndedObservers = gameEndedObservers;
GameState = new InternalGameState(this);
}
public Game(ICardDeck cardDeck)
{
_cardDeck = cardDeck;
}
public PlayNumberPoke(NumberPoke numberPoke, ICardDeck cardDeck)
{
_numberPoke = numberPoke;
_cardDeck = cardDeck;
}
public void Transfer(ICardDeck cardDeck, IHand hand)
{
var buffer = cardDeck.Take();
hand.Add(buffer);
}
public SolitaireDealer(ICardDeck cardDeck)
: base(cardDeck)
{
}
public static bool IsRun(ICardDeck subdeck)
{
if (subdeck == null)
{
throw new InvalidProgramException("Null subdeck");
}
int deckSize = subdeck.Count;
// minimum number of cards is 4
if (deckSize < 4)
{
return(false);
}
// ensure all the cards are from the same suit
var first = subdeck.First();
// iterate over all the cards and if all of them contain the same
// suit, if different return false
if (!subdeck.All(x => x.Suit == first.Suit))
{
return(false);
}
// need to sort per value
subdeck.Sort();
// treat as deck of cards so we can access de indexer
var asDeckCard = subdeck as DeckCards;
// crate a link list so we can verify the values
// need to find a better way, that we don't generate
// the l.l every time we evaluate a run
LinkedList <Card.CardValue> linkedListValues = new LinkedList <Card.CardValue>();
foreach (Card.CardValue value in Enum.GetValues(typeof(Card.CardValue)))
{
if (value != Card.CardValue.Jocker)
{
linkedListValues.AddLast(value);
}
}
// if Ace is a low card, then we need to change the logic,
// after sorting we need to verify that the last 2 cards
// if a[n-1] = Ace and a[n-2] != King, then we can assume Ace == 1
if ((asDeckCard[deckSize - 1].Value == Card.CardValue.Ace) &&
(asDeckCard[deckSize - 2].Value != Card.CardValue.King))
{
// ace == 1
// skip the compare of the last card, since we assume is the ACE
// which should be taken as lowest value
deckSize--;
}
else
{
// ace == 14
}
first = asDeckCard.First();
// ensure the values are consecutive
// get the next index
var indexInList = linkedListValues.Find(first.Value).Next;
for (var index = 1; index < deckSize; index++)
{
if (asDeckCard[index].Value != indexInList.Value)
{
return(false);
}
indexInList = indexInList.Next;
}
return(true);
}
public Dealer(ICardDeck cardDeck) : base(cardDeck)
{
HiddenCard = _cardDeck.TakeCard();
}
public void addDeck(ICardDeck <TCard> referenceDeck)
{
var uniqueDeck = referenceDeck.clone();
_availableCards.AddRange(uniqueDeck.cards);
}
public void addDeck(ICardDeck <TCard> referenceDeck)
{
_subComponent.addDeck(referenceDeck);
_hasCards = _subComponent.numCardsRemaining > 0;
}
public Participant(ICardDeck cardDeck)
{
_cardDeck = cardDeck;
}
public NumberPoke(INumberPokeMessages messages, ICardDeck cardDeck)
{
_messages = messages;
_cardDeck = cardDeck;
}
private bool DoCard(ICardDeck deck)
{
return(homeSquadCards ? (deck.Owner == _gameManager.HomeSquad) : (deck.Owner != _gameManager.HomeSquad));
}
public BlackJack(IBlackJackMessages messages, ICardDeck cardDeck)
{
_messages = messages;
_cardDeck = cardDeck;
}
public PickupCardAction(ICardDeck cardDeck)
{
this.cardDeck = cardDeck;
}
public Dealer(ICardDeck cardDeck)
{
CardDeck = cardDeck;
Shuffle();
}
public PlayNumberGuess(NumberGuess numberGuess, ICardDeck cardDeck)
{
_numberGuess = numberGuess;
_cardDeck = cardDeck;
}
public Player(ICardDeck cardDeck) : base(cardDeck)
{
}
