public void UseYearOfPlentyCard_UseCardPurchasedInSameTurn_MeaningfulErrorIsReceived()
{
// Arrange
var yearOfPlentyCard = new YearOfPlentyDevelopmentCard();
var testInstances = this.TestSetupWithExplictDevelopmentCards(yearOfPlentyCard);
var localGameController = testInstances.LocalGameController;
testInstances.MainPlayer.AddResources(ResourceClutch.DevelopmentCard);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
DevelopmentCard purchasedDevelopmentCard = null;
localGameController.DevelopmentCardPurchasedEvent = (DevelopmentCard d) => { purchasedDevelopmentCard = d; };
localGameController.StartGamePlay();
localGameController.BuyDevelopmentCard(turnToken);
ErrorDetails errorDetails = null;
localGameController.ErrorRaisedEvent = (ErrorDetails e) => { errorDetails = e; };
// Act
localGameController.UseYearOfPlentyCard(turnToken, (YearOfPlentyDevelopmentCard)purchasedDevelopmentCard, ResourceTypes.Brick, ResourceTypes.Brick);
// Assert
errorDetails.ShouldNotBeNull();
errorDetails.Message.ShouldBe("Cannot use development card that has been purchased this turn.");
}
public void UseYearOfPlentyCard_UseDevelopmentCardMoreThanOnce_MeaningfulErrorIsReceived()
{
// Arrange
var yearOfPlentyCard = new YearOfPlentyDevelopmentCard();
var testInstances = this.TestSetupWithExplictDevelopmentCards(yearOfPlentyCard);
var localGameController = testInstances.LocalGameController;
testInstances.Dice.AddSequenceWithRepeatingRoll(null, 6);
testInstances.MainPlayer.AddResources(ResourceClutch.DevelopmentCard);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
localGameController.StartGamePlay();
// Buy the year of plenty card
localGameController.BuyDevelopmentCard(turnToken);
localGameController.EndTurn(turnToken);
// Play the same year of plenty card each turn for the next two turns
localGameController.UseYearOfPlentyCard(turnToken, yearOfPlentyCard, ResourceTypes.Brick, ResourceTypes.Brick);
localGameController.EndTurn(turnToken);
ErrorDetails errorDetails = null;
localGameController.ErrorRaisedEvent = (ErrorDetails e) => { errorDetails = e; };
// Act
localGameController.UseYearOfPlentyCard(turnToken, yearOfPlentyCard, ResourceTypes.Brick, ResourceTypes.Brick);
// Assert
errorDetails.ShouldNotBeNull();
errorDetails.Message.ShouldBe("Cannot play the same development card more than once.");
}
public void Scenario_OpponentUsesYearOfPlentyCardAndGetsResourcesofDifferentTypes()
{
// Arrange
var bankId = Guid.NewGuid();
var yearOfPlentyCard = new YearOfPlentyDevelopmentCard();
var testInstances = this.TestSetupWithExplictGameBoard(bankId, yearOfPlentyCard, new MockGameBoardWithNoResourcesCollected());
var localGameController = testInstances.LocalGameController;
testInstances.Dice.AddSequence(new uint[] { 8, 8, 8, 8, 8, 8, 8, 8 });
var player = testInstances.MainPlayer;
var firstOpponent = testInstances.FirstOpponent;
var secondOpponent = testInstances.SecondOpponent;
var thirdOpponent = testInstances.ThirdOpponent;
firstOpponent.AddResources(ResourceClutch.DevelopmentCard);
firstOpponent.AddBuyDevelopmentCardChoice(1).EndTurn()
.AddPlayYearOfPlentyCardInstruction(new PlayYearOfPlentyCardInstruction {
FirstResourceChoice = ResourceTypes.Brick, SecondResourceChoice = ResourceTypes.Grain
}).EndTurn();
var turn = 0;
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; turn++; };
var gameEvents = new List <List <GameEvent> >();
localGameController.GameEvents = (List <GameEvent> e) => { gameEvents.Add(e); };
localGameController.StartGamePlay();
localGameController.EndTurn(turnToken); // Opponent buys development card
localGameController.EndTurn(turnToken); // Opponent plays year of plenty card
// Assert
var expectedBuyDevelopmentCardEvent = new BuyDevelopmentCardEvent(firstOpponent.Id);
var expectedResourceTransactionList = new ResourceTransactionList();
expectedResourceTransactionList.Add(new ResourceTransaction(firstOpponent.Id, bankId, new ResourceClutch(1, 1, 0, 0, 0)));
var expectedPlayYearOfPlentyCardEvent = new YearOfPlentyCardPlayedEvent(firstOpponent.Id, ResourceTypes.Brick, ResourceTypes.Brick);
gameEvents.Count.ShouldBe(15);
gameEvents[2].Count.ShouldBe(2);
gameEvents[2][1].ShouldBe(expectedBuyDevelopmentCardEvent);
gameEvents[9].Count.ShouldBe(2);
gameEvents[9][1].ShouldBe(expectedPlayYearOfPlentyCardEvent);
player.Resources.Count.ShouldBe(0);
firstOpponent.Resources.Count.ShouldBe(2);
firstOpponent.Resources.BrickCount.ShouldBe(1);
firstOpponent.Resources.GrainCount.ShouldBe(1);
secondOpponent.Resources.Count.ShouldBe(0);
secondOpponent.Resources.BrickCount.ShouldBe(0);
thirdOpponent.Resources.Count.ShouldBe(0);
}
public void UseYearOfPlentyCard_GameIsOver_MeaningfulErrorIsReceived()
{
// Arrange
var testInstances = this.TestSetupWithExplictGameBoard(Guid.Empty, new YearOfPlentyDevelopmentCard(), new MockGameBoardWithNoResourcesCollected());
var localGameController = testInstances.LocalGameController;
testInstances.Dice.AddSequenceWithRepeatingRoll(null, 6);
var player = testInstances.MainPlayer;
player.AddResources(ResourceClutch.RoadSegment * 5);
player.AddResources(ResourceClutch.Settlement * 3);
player.AddResources(ResourceClutch.City * 4);
player.AddResources(ResourceClutch.DevelopmentCard);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
ErrorDetails errorDetails = null;
localGameController.ErrorRaisedEvent = (ErrorDetails e) => { errorDetails = e; };
YearOfPlentyDevelopmentCard yearOfPlentyCard = null;
localGameController.DevelopmentCardPurchasedEvent = (DevelopmentCard d) => { yearOfPlentyCard = (YearOfPlentyDevelopmentCard)d; };
localGameController.StartGamePlay();
localGameController.BuyDevelopmentCard(turnToken);
localGameController.EndTurn(turnToken);
localGameController.BuildRoadSegment(turnToken, 4u, 3u);
localGameController.BuildRoadSegment(turnToken, 3u, 2u);
localGameController.BuildRoadSegment(turnToken, 2u, 1u);
localGameController.BuildRoadSegment(turnToken, 1u, 0u); // Got 2VP for longest road (4VP)
localGameController.BuildRoadSegment(turnToken, 2u, 10u);
localGameController.BuildSettlement(turnToken, 3);
localGameController.BuildSettlement(turnToken, 10);
localGameController.BuildCity(turnToken, 3);
localGameController.BuildCity(turnToken, 10);
localGameController.BuildCity(turnToken, 12);
localGameController.BuildCity(turnToken, 40); // Got 10VP, Game over event raised
// Act
localGameController.UseYearOfPlentyCard(turnToken, yearOfPlentyCard, ResourceTypes.Brick, ResourceTypes.Grain);
// Assert
errorDetails.ShouldNotBeNull();
errorDetails.Message.ShouldBe("Cannot use year of plenty card. Game is over.");
}
public void AddDevelopmentCard(DevelopmentCardTypes developmentCardType)
{
DevelopmentCard developmentCard = null;
switch (developmentCardType)
{
case DevelopmentCardTypes.Knight: developmentCard = new KnightDevelopmentCard(); break;
case DevelopmentCardTypes.Monopoly: developmentCard = new MonopolyDevelopmentCard(); break;
case DevelopmentCardTypes.RoadBuilding: developmentCard = new RoadBuildingDevelopmentCard(); break;
case DevelopmentCardTypes.YearOfPlenty: developmentCard = new YearOfPlentyDevelopmentCard(); break;
default: throw new NotImplementedException($"Development card type {developmentCardType} not recognised");
}
this.developmentCards.Enqueue(developmentCard);
}
public void UseYearOfPlentyCard_UseDevelopmentCard_DifferentResourcesAreCollected()
{
// Arrange
var bankId = Guid.NewGuid();
var yearOfPlentyCard = new YearOfPlentyDevelopmentCard();
var testInstances = this.TestSetupWithExplictGameBoard(bankId, yearOfPlentyCard, new MockGameBoardWithNoResourcesCollected());
var localGameController = testInstances.LocalGameController;
var player = testInstances.MainPlayer;
testInstances.Dice.AddSequenceWithRepeatingRoll(null, 8);
testInstances.MainPlayer.AddResources(ResourceClutch.DevelopmentCard);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
ResourceTransactionList resources = null;
localGameController.ResourcesTransferredEvent = (ResourceTransactionList r) => { resources = r; };
localGameController.StartGamePlay();
// Buy the year of plenty card
localGameController.BuyDevelopmentCard(turnToken);
localGameController.EndTurn(turnToken);
// Act
localGameController.UseYearOfPlentyCard(turnToken, yearOfPlentyCard, ResourceTypes.Brick, ResourceTypes.Grain);
// Assert
var expected = new ResourceTransactionList();
expected.Add(new ResourceTransaction(player.Id, bankId, new ResourceClutch(1, 1, 0, 0, 0)));
resources.ShouldBe(expected);
player.Resources.Count.ShouldBe(2);
player.Resources.BrickCount.ShouldBe(1);
player.Resources.GrainCount.ShouldBe(1);
}
private void Initialise(IIndexSequence random)
{
this.cards = new Queue <DevelopmentCard>();
var victoryPointCardTitles = new Queue <string>(new[] { "Chapel", "Great Hall", "Library", "Market", "University" });
var index = -1;
while (random.TryGetNextIndex(out index))
{
if (index < KnightCardCount)
{
var card = new KnightDevelopmentCard();
this.cards.Enqueue(card);
}
else if (index < (KnightCardCount + MonopolyCardCount))
{
var card = new MonopolyDevelopmentCard();
this.cards.Enqueue(card);
}
else if (index < (KnightCardCount + MonopolyCardCount + RoadBuildingCardCount))
{
var card = new RoadBuildingDevelopmentCard();
this.cards.Enqueue(card);
}
else if (index < (KnightCardCount + MonopolyCardCount + RoadBuildingCardCount + YearOfPlentyCardCount))
{
var card = new YearOfPlentyDevelopmentCard();
this.cards.Enqueue(card);
}
else if (index < (KnightCardCount + MonopolyCardCount + RoadBuildingCardCount + YearOfPlentyCardCount + VictoryPointCardCount))
{
var title = victoryPointCardTitles.Dequeue();
var card = new VictoryPointDevelopmentCard(title);
this.cards.Enqueue(card);
}
}
}
