public DealingService(bool startsFromLeft, List <Player> players)
{
_ps = new PlayerService();
_deck = new TarotDeck(true);
_rules = new DealingRules();
_aside = new List <Card>();
_round = new RoundService(startsFromLeft, players);
}
static IEnumerable <Tuple <int, int> > TestPlayersNbAndPosition()
{
DealingRules dr = new DealingRules();
foreach (int nbPlayer in dr.PossibleNbPlayers)
{
for (int i = 0; i < nbPlayer; i++)
{
yield return(new Tuple <int, int>(nbPlayer, i));
}
}
}
public void AfterDealingRoundNumberIsZero()
{
List <Player> players = Musketeers(5);
DealingService dealingService = new DealingService(true, players);
PlayerService playerService = new PlayerService();
DealingRules rules = new DealingRules();
playerService.MakeDealer(players.First());
dealingService.DealsAllCardsFromDeck();
Assert.That(dealingService.GetRoundNumber() == 0);
}
public void PlayOneGame(int nbPlayers)
{
DealingRules dealingRules = new DealingRules();
BettingService bettingService = new BettingService();
PlayerService playerService = new PlayerService();
List <Player> players = playerService.CreatePlayers(Musketeers().Take(nbPlayers)).ToList();
DealingService dealingService = new DealingService(false, players);
RoundService roundService = new RoundService(false, players);
Player dealer = players.First();
dealer.Dealer = true;
dealingService.DealsAllCardsFromDeck();
Assert.That(dealingService.NbPlayers(), Is.EqualTo(nbPlayers));
Assert.That(dealingService.CountAside(), Is.EqualTo(dealingRules.AsideMaxCards(nbPlayers)));
Assert.NotNull(dealingService.GetDealer());
Assert.Zero(dealingService.GetRoundNumber());
Assert.That(dealingService.DealtAsideIsCorrect(), Is.True);
foreach (Player player in players)
{
Assert.That(player.Hand.Count == players.First().Hand.Count);
Assert.That(player.Contract.ToString(), Is.EqualTo("pass"));
}
bettingService.GatherBets(players);
bettingService.AuctionIsWon(dealingService);
Player attacker = bettingService.GetWinningBet().Key;
playerService.MakeAside(attacker, dealingService.NbCardsInAside());
// Put this in dealing service ?
// Game is ready to start when:
Assert.That(attacker.Hand.Count, Is.EqualTo(players.First(x => x.Attacker is false).Hand.Count));
Assert.That(attacker.WonHands.Count, Is.EqualTo(dealingRules.AsideMaxCards(nbPlayers)));
Assert.Zero(dealingService.GetRoundNumber());
while (dealer.Hand.Count > 0)
{
var round = roundService.PlayRound();
}
Assert.Zero(players.Select(x => x.Hand.Count).Sum());
Assert.That(players.Select(x => x.WonHands.Count).Sum(), Is.EqualTo(DealingRules.MaxCardsInDeck));
Assert.That(players.Select(x => x.WonHands.Cast <Card>().Score()).Sum(), Is.EqualTo(CardCountingRules.MaxScore));
}
public void MakeAside(Player player, int nbCards)
{
DealingRules dr = new DealingRules();
IEnumerable <Card> cardsInHand = player.Hand.Cast <Card>();
var possibleAsideCards = cardsInHand.Where(x => dr.CardAllowedInPlayerAside(x.IsTrumper(), x.IsOudler(), x.Points())).ToList();
if (possibleAsideCards.Count() == 0)
{
throw new NotSupportedException("Cannot make aside without possible cards");
}
var playerChoice = AskPlayerCards(player, possibleAsideCards, nbCards);
player.WonHands.AddRange(playerChoice);
playerChoice.ForEach(x => player.Hand.Remove(x));
}
public void FivePlayersCalledKingInAsideOneAttacker()
{
List <Player> players = Musketeers(5);
PlayerService playerService = new PlayerService();
DealingService dealingService = new DealingService(true, players);
DealingRules rules = new DealingRules();
//var dealingServiceMock = new Mock<IDealingService>().Setup(x => x.SendCardsToAside(Kings()));
players.First().Dealer = true;
players.First().Attacker = true;
Player calledPlayer = dealingService.AttackerCallsKing(players.First());
Assert.That(players.Count(x => x.Attacker is false), Is.EqualTo(4));
Assert.That(players.First(), Is.SameAs(calledPlayer));
}
public void FivePlayersCallsKingMostCommonCase()
{
List <Player> players = Musketeers(5);
PlayerService playerService = new PlayerService();
DealingService dealingService = new DealingService(true, players);
DealingRules rules = new DealingRules();
Player attacker = players.First();
Player defender = players.Last();
attacker.Attacker = true;
attacker.Dealer = true;
defender.Hand.AddRange(Kings());
Player calledPlayer = dealingService.AttackerCallsKing(attacker);
Assert.That(players.Count(x => x.Attacker is false), Is.EqualTo(3));
Assert.That(defender, Is.SameAs(calledPlayer));
}
public void CheckNbCardsInPlayersHandsAndAsideIsCorrect(int nbPlayers)
{
List <Player> players = Musketeers(nbPlayers);
DealingService dealingService = new DealingService(true, players);
PlayerService playerService = new PlayerService();
DealingRules rules = new DealingRules();
int totalCardsInHand = 0;
playerService.MakeDealer(players.First());
dealingService.DealsAllCardsFromDeck();
foreach (Player player in players)
{
totalCardsInHand += playerService.CountCardsInHand(player);
Assert.AreEqual(players[0].Hand.Count(), player.Hand.Count()); //all players have same nb cards
Assert.IsEmpty(player.WonHands); //no player has an aside
}
Assert.AreEqual(DealingRules.MaxCardsInDeck, totalCardsInHand + dealingService.CountAside()); //all cards are dealt
Assert.AreEqual(rules.AsideMaxCards(nbPlayers), dealingService.CountAside()); //aside has expected number of cards
}
