/// <summary>
/// Returns card at current position of the pile and removes it from the pile.
/// </summary>
public Card Pop(Pile pile)
{
var card = Peek(pile);
pile.CardsInPile.Remove(card);
return(card);
}
public override List <Card> Pop(Pile pile, int count)
{
// group of cards from middle
var seed = Peek(pile);
var index = pile.CardsInPile.IndexOf(seed);
var start = 0;
if (index >= count - 1)
{
// take from beginning to seed
start = index - count + 1;
}
else if (pile.Size - index >= count)
{
// take from seed to ending
start = index;
}
else
{
// take around seed
start = Math.Max(0, pile.Size - count);
}
var result = pile.CardsInPile.Skip(start).Take(count).ToList();
pile.CardsInPile.RemoveRange(start, result.Count);
return(result);
}
public override List <Card> Pop(Pile pile, int count)
{
var result = pile.CardsInPile.Take(count).ToList();
pile.CardsInPile.RemoveRange(0, result.Count);
return(result);
}
public void Ctor_UsesGivenCardsInGivenOrder()
{
var source = new[] { RndCard(3), RndCard(1), RndCard(3), RndCard(4) };
var result = new Pile(source);
Assert.That(result, Is.EqualTo(source).Using(CardByRefEqualityComparer.Instance));
}
/// <summary>
/// Trump defined by stock.
/// </summary>
public static Trump LastCard(Pile pile)
{
if (pile.IsEmpty)
{
throw new ArgumentException("Can not peek card from empty pile");
}
return(new Trump(pile.Peek(PilePosition.Bottom).Suit));
}
public void Push_Bottom_AddedCardsAreLast()
{
var pile = new Pile(new[] { RndCard(), RndCard(), RndCard() });
var cards = new[] { RndCard(), RndCard() };
pile.Push(cards, PilePosition.Bottom);
CollectionAssert.AreEqual(cards, pile.TakeLast(2));
}
/// <summary>
/// Sets pile on zone explicitly.
/// </summary>
public void PlacePile(Pile pile)
{
if (!Pile.IsEmpty)
{
throw new InvalidOperationException("Current pile of this zone is not empty");
}
Pile = pile;
}
public void Pop_ManyFromEmptyPile_Throws()
{
var position = _f.Create <PilePosition>();
var pile = new Pile();
var ex = Assert.Catch <InvalidOperationException>(() => pile.Pop(position, 2));
Assert.That(ex.Message, Contains.Substring("is empty").IgnoreCase);
}
public void Push_Bottom_AddedCardIsLast()
{
var pile = new Pile(new[] { RndCard(), RndCard(), RndCard() });
var card = RndCard();
pile.Push(card, PilePosition.Bottom);
Assert.AreSame(card, pile.Last());
}
public void Push_Top_AddedCardIsFirst()
{
var pile = new Pile(new[] { RndCard(), RndCard(), RndCard() });
var card = RndCard();
pile.Push(card, PilePosition.Top);
Assert.AreSame(card, pile.First());
}
public void Push_Top_AddedCardsAreFirst()
{
var pile = new Pile(new[] { RndCard(), RndCard(), RndCard() });
var cards = new[] { RndCard(), RndCard() };
pile.Push(cards, PilePosition.Top);
CollectionAssert.AreEqual(cards, pile.Take(2));
}
public void Push_Middle_OneInPile_AddedCardIsLast()
{
var pile = new Pile(new[] { RndCard() });
var card = RndCard();
pile.Push(card, PilePosition.Middle);
Assert.AreSame(card, pile.Last());
}
public void Push_AddsAllCards()
{
var position = _f.Create <PilePosition>();
var pile = new Pile();
pile.Push(new[] { RndCard(), RndCard() }, position);
Assert.AreEqual(2, pile.Size);
}
public void Peek_Top_ReturnsFirstCard()
{
var source = new[] { RndCard(1), RndCard(2), RndCard(3), RndCard(4) };
var pile = new Pile(source);
var result = pile.Peek(PilePosition.Top);
Assert.AreSame(source[0], result);
Assert.AreEqual(source.Count(), pile.Size);
}
public void Push_DuplicateOfCardInstance_Throws()
{
var position = _f.Create <PilePosition>();
var pile = new Pile();
var card = RndCard();
var ex = Assert.Catch <ArgumentException>(() => pile.Push(new[] { card, card }, position));
Assert.That(ex.Message, Contains.Substring("Duplicate instances").IgnoreCase);
}
public void Push_EmptyPile_Ok()
{
var position = _f.Create <PilePosition>();
var pile = new Pile();
var card = RndCard();
pile.Push(card, position);
Assert.AreSame(card, pile.First());
}
public void Pop_CountExactlyAsSizeOfPile_EmptyPile()
{
var position = _f.Create <PilePosition>();
var pile = new Pile(new[] { RndCard(), RndCard() });
pile.Pop(position, 2);
Assert.AreEqual(0, pile.Size);
Assert.IsTrue(pile.IsEmpty);
}
public void Peek_Bottom_ReturnsLasstCard()
{
var source = new[] { RndCard(1), RndCard(2), RndCard(3), RndCard(4) };
var pile = new Pile(source);
var result = pile.Peek(PilePosition.Bottom);
Assert.AreSame(source[3], result);
Assert.AreEqual(source.Count(), pile.Size);
}
public void Pop_Bottom_TakesOrderedGroupFromTail()
{
var source = new[] { RndCard(1), RndCard(2), RndCard(3), RndCard(4) };
var pile = new Pile(source);
var result = pile.Pop(PilePosition.Bottom, 2);
CollectionAssert.AreEqual(new[] { source[2], source[3] }, result);
CollectionAssert.AreEqual(new[] { source[0], source[1] }, pile);
}
public void Pop_Bottom_TakesFromTail()
{
var source = new[] { RndCard(1), RndCard(2), RndCard(3), RndCard(4) };
var pile = new Pile(source);
var result = pile.Pop(PilePosition.Bottom);
Assert.AreEqual(3, pile.Size);
Assert.AreSame(source[3], result);
}
public void Push_AddsCard()
{
var position = _f.Create <PilePosition>();
var pile = new Pile();
var card = RndCard();
pile.Push(card, position);
Assert.AreEqual(1, pile.Size);
}
public void Pop_Top_TakesFromHead()
{
var source = new[] { RndCard(1), RndCard(2), RndCard(3), RndCard(4) };
var pile = new Pile(source);
var result = pile.Pop(PilePosition.Top);
Assert.AreEqual(3, pile.Size);
Assert.AreSame(source[0], result);
}
public void Pop_MoreThanCardsInPile_ReturnsAllCards()
{
var position = _f.Create <PilePosition>();
var pile = new Pile(new[] { RndCard() });
var result = pile.Pop(position, 2);
Assert.AreEqual(0, pile.Size);
Assert.IsTrue(pile.IsEmpty);
Assert.AreEqual(1, result.Count);
}
public void Pop_Middle_OneLessThanCardsInPile_AlsoTakesCardFromHeadOrTail()
{
var source = new[] { RndCard(1), RndCard(2), RndCard(3), RndCard(4) };
var pile = new Pile(source);
var result = pile.Pop(PilePosition.Middle, 3);
Assert.AreEqual(3, result.Count, "result size");
Assert.AreEqual(1, pile.Size);
Assert.IsTrue(pile.First().Rank.Value == 1 || pile.First().Rank.Value == 4);
}
public void Push_Middle_TwoInPile_AddedCardAlwaysIsInMiddle()
{
var pile = new Pile(new[] { RndCard(), RndCard() });
var card = RndCard();
pile.Push(card, PilePosition.Middle);
Assert.AreSame(pile.ElementAt(1), card);
Assert.IsFalse(ReferenceEquals(pile.First(), card));
Assert.IsFalse(ReferenceEquals(pile.Last(), card));
}
private void DrawCardsToFillHands(Pile stockPile)
{
_movements
.Select(movement => movement.PlayerName)
.Distinct()
.OrderBy(name => name == _defendingPlayer?.Name ? 1 : 0) // defending is last
.Select(name => _players.First(p => p.Name == name).Hand)
.Select(hand => (hand, lack: _rules.HandSize - hand.Size))
.TakeWhile(_ => stockPile.Size > 0)
.Select(x => (x.hand, drawnCards: stockPile.Pop(PilePosition.Top, x.lack)))
.ForEach(x => x.hand.Push(x.drawnCards, PilePosition.Default));
}
public void Push_CardInstanceAlreadyInPile_Throws()
{
var position = _f.Create <PilePosition>();
var pile = new Pile();
var card = RndCard();
pile.Push(card, position);
var ex = Assert.Catch <ArgumentException>(() => pile.Push(card, position));
Assert.That(ex.Message, Contains.Substring("instance already in pile").IgnoreCase);
}
public override void Push(Pile pile, IReadOnlyCollection <Card> cards)
{
if (pile.IsEmpty)
{
pile.CardsInPile.AddRange(cards);
}
else
{
var i = Random.Next(1, pile.Size);
pile.CardsInPile.InsertRange(i, cards);
}
}
public override void Push(Pile pile, Card card)
{
if (pile.IsEmpty)
{
pile.CardsInPile.Add(card);
}
else
{
var i = Random.Next(1, pile.Size);
pile.CardsInPile.Insert(i, card);
}
}
public void Pop_Middle_TakesOrderedGroup()
{
var source = new[] { RndCard(1), RndCard(2), RndCard(3), RndCard(4) };
var pile = new Pile(source);
using (Random.Returing(new[] { 2 }))
{
var result = pile.Pop(PilePosition.Middle, 2);
CollectionAssert.AreEqual(new[] { source[1], source[2] }, result);
Assert.AreEqual(2, result.Count, "result size");
Assert.AreEqual(2, pile.Size);
Assert.AreSame(source[0], pile.First(), "first");
Assert.AreSame(source[3], pile.Last(), "last");
}
}
