private void OnPiecePlaced(GameToken token)
{
GameObject holder;
if (token.type == PieceType.ROUND)
{
holder = (GameObject)Instantiate (RoundToken);
}
else if (token.type == PieceType.SQUARE)
{
holder = (GameObject)Instantiate (SquareToken);
}
else
{
throw new InvalidOperationException ();
}
Transform mesh = holder.transform.FindChild ("Mesh");
if (token.owner == Player.P1)
{
mesh.renderer.material = whiteMat;
}
else if (token.owner == Player.P2)
{
mesh.renderer.material = blackMat;
}
else
{
throw new InvalidOperationException ();
}
holder.transform.parent = GameObject.Find ("GameBoard").transform;
holder.transform.position = new Vector3 (token.location.x, 0, token.location.y);
mesh.GetComponent<PieceHandler> ().ID = token.id;
mesh.GetComponent<PieceHandler> ().OnSpawned ();
}
/// <summary>
/// Serialises all header properties. The output will be a dictionary containing
/// the extra header key-value pairs in addition the standard headers sent with
/// all server requests. Will return an empty dictionary if there are no headers.
/// </summary>
///
/// <returns>The header key-value pairs.</returns>
public IDictionary <string, string> SerialiseHeaders()
{
var dictionary = new Dictionary <string, string>();
// Game Token
dictionary.Add("Game-Token", GameToken.ToString());
return(dictionary);
}
private void DisplaceEvent(GameToken origin, Coords toLoc)
{
if (origin.id != ID)
{
return;
}
animationQueue.Enqueue (toLoc);
}
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);
}
void IEndDragHandler.OnEndDrag(PointerEventData eventData)
{
if (draggingToken != null)
{
// find nearest open pin and snap token to it
SnapTokenToPin(draggingToken);
// done
eventData.Use();
draggingToken = null;
}
}
private void StartPlayerTurnEventHandler(GameToken turnToken)
{
this.currentTurnToken = turnToken;
this.currentTurnNumber++;
foreach (var kv in this.playerViewModelsById)
{
kv.Value.UpdateHistory($"TURN {this.currentTurnNumber}");
}
this.StartPhase();
}
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.");
}
private void CreateGrid()
{
// calculate pin spacing based on size of board and number of pins
var space = new Vector2(pinsContainer.rect.width / gridSize.x, pinsContainer.rect.height / gridSize.y);
// everything is centered around middle of game board so need an offset from that to start placing pins
var offs = (pinsContainer.rect.size * -0.5f) + (space * 0.5f);
// define the game board's grid (pins) and place initial tokens
grid = new GameBoardPin[gridSize.x * gridSize.y];
var idx = 0;
for (int x = 0; x < gridSize.x; x++)
{
for (int y = 0; y < gridSize.y; y++)
{
var gridPos = new Vector2Int(x, y);
// create and place the pin object
var pinRt = Instantiate(pinFab, this.pinsContainer).GetComponent <RectTransform>();
pinRt.anchoredPosition = offs + (space * gridPos);
// create a token if there is a token in this position at start
GameTokenDef def = startTokens.FirstOrDefault(t => t.startPos == gridPos);
GameToken token = null;
if (def != null)
{
if (def.tokenColor >= 0 && def.tokenColor < tokenColours.Length)
{
token = Instantiate(tokenFab, tokensContainer).GetComponent <GameToken>();
token.TokenColor = def.tokenColor;
token.image.color = tokenColours[def.tokenColor];
token.Rt.anchoredPosition = pinRt.anchoredPosition;
token.PrevAnchorPos = token.Rt.anchoredPosition;
}
else
{
Debug.LogError($"Invalid token colour: {def.tokenColor}. It must be in range 0..{tokenColours.Length-1}");
}
}
// initialize the grid position
grid[idx] = new GameBoardPin
{
pinRt = pinRt,
token = token,
};
idx++;
}
}
}
public static string GenerateGameToken(string playerToken)
{
//Structure of a game token
//G....-....-....-....
//[0]: Timestamp since equinox
//[1]: State => Number of games currently going
//[2]: Player token last bit
//[3]: Nonce
GameToken gameToken = new GameToken(playerToken);
return(gameToken.ToString());
}
public void UseMonopolyCard_UseDevelopmentCard_ReceiveAllResourcesOfRequestedTypeFromOpponents()
{
// Arrange
var monopolyCard = new MonopolyDevelopmentCard();
var testInstances = this.TestSetup(new MockGameBoardWithNoResourcesCollected(), monopolyCard);
var localGameController = testInstances.LocalGameController;
testInstances.Dice.AddSequenceWithRepeatingRoll(null, 8);
var player = testInstances.MainPlayer;
var firstOpponent = testInstances.FirstOpponent;
var secondOpponent = testInstances.SecondOpponent;
var thirdOpponent = testInstances.ThirdOpponent;
player.AddResources(ResourceClutch.DevelopmentCard);
firstOpponent.AddResources(ResourceClutch.OneOfEach);
secondOpponent.AddResources(ResourceClutch.OneBrick * 2);
thirdOpponent.AddResources(new ResourceClutch(0, 1, 1, 1, 1));
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
ResourceTransactionList gainedResources = null;
localGameController.ResourcesTransferredEvent = (ResourceTransactionList r) => { gainedResources = r; };
localGameController.StartGamePlay();
// Buy the monopoly card
localGameController.BuyDevelopmentCard(turnToken);
localGameController.EndTurn(turnToken);
// Act
localGameController.UseMonopolyCard(turnToken, monopolyCard, ResourceTypes.Brick);
// Assert
var expectedResources = new ResourceTransactionList();
expectedResources.Add(new ResourceTransaction(player.Id, firstOpponent.Id, ResourceClutch.OneBrick));
expectedResources.Add(new ResourceTransaction(player.Id, secondOpponent.Id, ResourceClutch.OneBrick * 2));
gainedResources.ShouldBe(expectedResources);
player.Resources.Count.ShouldBe(3);
player.Resources.BrickCount.ShouldBe(3);
firstOpponent.Resources.Count.ShouldBe(4);
firstOpponent.Resources.BrickCount.ShouldBe(0);
secondOpponent.Resources.Count.ShouldBe(0);
thirdOpponent.Resources.Count.ShouldBe(4);
thirdOpponent.Resources.BrickCount.ShouldBe(0);
}
public MoveResult SetToken(GameToken token, BoardPosition position)
{
if (outsideBoard(position))
{
return(MoveResult.OutsideBoardBoundary);
}
if (TokenAt(position) == GameToken.None)
{
_board[position.Column, position.Row] = token;
return(MoveResult.ValidMove);
}
return(MoveResult.PositionTaken);
}
public void BuildCity_AllCitiesAreBuilt_MeaningfulErrorIsReceived()
{
// Arrange
MockDice mockDice = null;
MockPlayer player;
MockComputerPlayer firstOpponent, secondOpponent, thirdOpponent;
var localGameController = this.CreateLocalGameControllerAndCompleteGameSetup(out mockDice, out player, out firstOpponent, out secondOpponent, out thirdOpponent);
mockDice.AddSequence(new[] { 8u });
player.AddResources(ResourceClutch.RoadSegment * 4);
player.AddResources(ResourceClutch.Settlement * 3);
player.AddResources(ResourceClutch.City * 5);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
ErrorDetails errorDetails = null;
localGameController.ErrorRaisedEvent = (ErrorDetails e) =>
{
if (errorDetails != null)
{
throw new Exception("Error already raised: " + errorDetails.Message);
}
errorDetails = e;
};
localGameController.StartGamePlay();
localGameController.BuildCity(turnToken, MainSettlementOneLocation);
localGameController.BuildCity(turnToken, MainSettlementTwoLocation);
localGameController.BuildRoadSegment(turnToken, 4, 3);
localGameController.BuildRoadSegment(turnToken, 4, 5);
localGameController.BuildSettlement(turnToken, 3);
localGameController.BuildCity(turnToken, 3);
localGameController.BuildSettlement(turnToken, 5);
localGameController.BuildCity(turnToken, 5);
localGameController.BuildRoadSegment(turnToken, 3, 2);
localGameController.BuildRoadSegment(turnToken, 2, 1);
localGameController.BuildSettlement(turnToken, 1);
// Act
localGameController.BuildCity(turnToken, 1);
// Assert
errorDetails.ShouldNotBeNull();
errorDetails.Message.ShouldBe("Cannot build city. All cities already built.");
}
private void SnapTokenToPin(GameToken token)
{
// calculated from (token_size * minSnapFactor) to determine how close a token must be to pin before it will snap
float minDistToSnap = minSnapFactor * token.Rt.rect.height;
// find nearest open pin to the token
float dist = 0f;
GameBoardPin pin = null;
for (int i = 0; i < gridSize.x * gridSize.y; i++)
{
var p = grid[i];
if (p.token == null || p.token == token) // open pin or the pin this token came from
{
var d = Vector2.Distance(p.pinRt.localPosition, token.Rt.localPosition);
if (d <= minDistToSnap && (pin == null || d < dist))
{
pin = p;
dist = d;
}
}
}
// update token with new position in grid
if (pin != null)
{
// remove token from old position in grid
var p = grid.FirstOrDefault(g => g.token == token);
if (p != null)
{
p.token = null;
}
else
{
Debug.LogError("This should not happen. There is a bug somewhere with tokens not being linked to pins/grid positions.");
}
// place it in new position
pin.token = token;
token.Rt.anchoredPosition = pin.pinRt.anchoredPosition;
token.PrevAnchorPos = token.Rt.anchoredPosition;
}
else
{
// snap back to previous position
token.Rt.anchoredPosition = token.PrevAnchorPos;
}
}
public void BuildRoadSegment_GameIsOver_MeaningfulErrorIsReceived()
{
// Arrange
var testInstances = LocalGameControllerTestCreator.CreateTestInstances(new MockGameBoardWithNoResourcesCollected());
var localGameController = testInstances.LocalGameController;
LocalGameControllerTestSetup.LaunchGameAndCompleteSetup(localGameController);
testInstances.Dice.AddSequence(new[] { 8u });
var player = testInstances.MainPlayer;
player.AddResources(ResourceClutch.RoadSegment * 6);
player.AddResources(ResourceClutch.Settlement * 3);
player.AddResources(ResourceClutch.City * 4);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
ErrorDetails errorDetails = null;
localGameController.ErrorRaisedEvent = (ErrorDetails e) => { errorDetails = e; };
localGameController.StartGamePlay();
localGameController.BuildRoadSegment(turnToken, 4u, 3u);
localGameController.BuildRoadSegment(turnToken, 3u, 2u);
localGameController.BuildRoadSegment(turnToken, 2u, 1u);
localGameController.BuildRoadSegment(turnToken, 2u, 10u);
localGameController.BuildSettlement(turnToken, 1);
localGameController.BuildSettlement(turnToken, 3);
localGameController.BuildSettlement(turnToken, 10);
localGameController.BuildCity(turnToken, 1);
localGameController.BuildCity(turnToken, 3);
localGameController.BuildCity(turnToken, 10);
localGameController.BuildCity(turnToken, 12);
localGameController.BuildRoadSegment(turnToken, 1, 0); // Got 10VP, Game is over
// Act
localGameController.BuildRoadSegment(turnToken, LocalGameControllerTestCreator.MainRoadTwoEnd, 47);
// Assert
errorDetails.ShouldNotBeNull();
errorDetails.Message.ShouldBe("Cannot build road segment. Game is over.");
}
public void BuildSettlement_AllSettlementsAreBuilt_MeaningfulErrorIsReceived()
{
// Arrange
MockDice mockDice = null;
MockPlayer player;
MockComputerPlayer firstOpponent, secondOpponent, thirdOpponent;
var localGameController = this.CreateLocalGameControllerAndCompleteGameSetup(out mockDice, out player, out firstOpponent, out secondOpponent, out thirdOpponent);
mockDice.AddSequence(new[] { 8u });
player.AddResources(ResourceClutch.Settlement * 3);
player.AddResources(ResourceClutch.RoadSegment * 7);
ErrorDetails errorDetails = null;
localGameController.ErrorRaisedEvent = (ErrorDetails e) =>
{
if (errorDetails != null)
{
// Ensure that the error details are only received once.
throw new Exception("Already received error details");
}
errorDetails = e;
};
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
localGameController.StartGamePlay();
var roadSegmentDetails = new UInt32[] { 4, 3, 3, 2, 2, 1, 1, 0, 0, 8, 8, 7, 7, 17 };
for (var index = 0; index < roadSegmentDetails.Length; index += 2)
{
localGameController.BuildRoadSegment(turnToken, roadSegmentDetails[index], roadSegmentDetails[index + 1]);
}
localGameController.BuildSettlement(turnToken, 3);
localGameController.BuildSettlement(turnToken, 1);
localGameController.BuildSettlement(turnToken, 8);
// Act
localGameController.BuildSettlement(turnToken, 17);
// Assert
errorDetails.ShouldNotBeNull();
errorDetails.Message.ShouldBe("Cannot build settlement. All settlements already built.");
}
public SetGameTokenResult SetGameToken(GameToken gameToken)
{
if (GameToken != null)
{
return(SetGameTokenResult.Occupied);
}
if (!_supportedGameTokens.Contains(gameToken.GetType()))
{
return(SetGameTokenResult.Unsupported);
}
GameToken = gameToken;
return(SetGameTokenResult.Success);
}
// ----------------------------------------------------------------------------------------------------------------
#region input interfaces
void IBeginDragHandler.OnBeginDrag(PointerEventData eventData)
{
if (eventData.pointerCurrentRaycast.gameObject == null)
{
return;
}
// check if drag starts over a token
var token = eventData.pointerCurrentRaycast.gameObject.GetComponent <GameToken>();
if (token != null)
{
eventData.Use();
draggingToken = token;
}
}
public void Scenario_OpponentBuildsLongerRoadThanPlayer_LongestRoadEventReturned()
{
// Arrange
var testInstances = LocalGameControllerTestCreator.CreateTestInstances();
var localGameController = testInstances.LocalGameController;
LocalGameControllerTestSetup.LaunchGameAndCompleteSetup(localGameController);
var player = testInstances.MainPlayer;
var firstOpponent = testInstances.FirstOpponent;
testInstances.Dice.AddSequence(new uint[] { 8, 8, 8, 8, 8 });
player.AddResources(ResourceClutch.RoadSegment * 5);
firstOpponent.AddResources(ResourceClutch.RoadSegment * 6);
firstOpponent.AddBuildRoadSegmentInstruction(new BuildRoadSegmentInstruction {
Locations = new UInt32[] { 17, 16, 16, 27, 27, 28, 28, 29, 29, 18 }
});
var actualEvents = new List <List <GameEvent> >();
localGameController.GameEvents = (List <GameEvent> e) => { actualEvents.Add(e); };
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
localGameController.StartGamePlay();
localGameController.BuildRoadSegment(turnToken, 4, 3);
localGameController.BuildRoadSegment(turnToken, 3, 2);
localGameController.BuildRoadSegment(turnToken, 2, 10);
localGameController.BuildRoadSegment(turnToken, 10, 9);
// Act - Opponent builds longer road.
localGameController.EndTurn(turnToken);
// Assert
var expectedEvents = new GameEvent[] {
new RoadSegmentPlacedEvent(firstOpponent.Id, 17, 16),
new RoadSegmentPlacedEvent(firstOpponent.Id, 16, 27),
new RoadSegmentPlacedEvent(firstOpponent.Id, 27, 28),
new RoadSegmentPlacedEvent(firstOpponent.Id, 28, 29),
new RoadSegmentPlacedEvent(firstOpponent.Id, 29, 18),
new LongestRoadBuiltEvent(firstOpponent.Id, null, player.Id)
};
//actualEvents.ShouldContainExact(expectedEvents);
}
public void TradeWithBank_GameIsOver_MeaningfulErrorIsReceived()
{
// Arrange
var testInstances = LocalGameControllerTestCreator.CreateTestInstances(new MockGameBoardWithNoResourcesCollected());
var localGameController = testInstances.LocalGameController;
LocalGameControllerTestSetup.LaunchGameAndCompleteSetup(localGameController);
testInstances.Dice.AddSequence(new[] { 8u });
var player = testInstances.MainPlayer;
player.AddResources(ResourceClutch.RoadSegment * 5);
player.AddResources(ResourceClutch.Settlement * 3);
player.AddResources(ResourceClutch.City * 4);
player.AddResources(ResourceClutch.OneBrick * 4);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
ErrorDetails errorDetails = null;
localGameController.ErrorRaisedEvent = (ErrorDetails e) => { errorDetails = e; };
localGameController.StartGamePlay();
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.TradeWithBank(turnToken, ResourceTypes.Grain, 1, ResourceTypes.Brick);
// Assert
errorDetails.ShouldNotBeNull();
errorDetails.Message.ShouldBe("Cannot trade with bank. Game is over.");
}
public void BuildSettlement_GotNineVictoryPoints_EndOfGameEventRaisedWithPlayerAsWinner()
{
// Arrange
var testInstances = LocalGameControllerTestCreator.CreateTestInstances(new MockGameBoardWithNoResourcesCollected());
var localGameController = testInstances.LocalGameController;
LocalGameControllerTestSetup.LaunchGameAndCompleteSetup(localGameController);
testInstances.Dice.AddSequence(new[] { 8u });
var player = testInstances.MainPlayer;
player.AddResources(ResourceClutch.RoadSegment * 5);
player.AddResources(ResourceClutch.Settlement * 4);
player.AddResources(ResourceClutch.City * 4);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
Guid winningPlayer = Guid.Empty;
localGameController.GameOverEvent = (Guid g) => { winningPlayer = g; };
localGameController.StartGamePlay();
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, 40);
// Act
localGameController.BuildSettlement(turnToken, 1);
// Assert
winningPlayer.ShouldBe(player.Id);
player.VictoryPoints.ShouldBe(10u);
}
public void BuildRoadSegment_MainPlayerBuildsLongerRoadThanOpponent_LongestRoadEventRaised()
{
// Arrange
var testInstances = LocalGameControllerTestCreator.CreateTestInstances();
var localGameController = testInstances.LocalGameController;
LocalGameControllerTestSetup.LaunchGameAndCompleteSetup(localGameController);
testInstances.Dice.AddSequence(new[] { 8u, 8u, 8u, 8u, 8u });
var player = testInstances.MainPlayer;
player.AddResources(ResourceClutch.RoadSegment * 7);
var firstOpponent = testInstances.FirstOpponent;
firstOpponent.AddResources(ResourceClutch.RoadSegment * 6);
firstOpponent.AddBuildRoadSegmentInstruction(new BuildRoadSegmentInstruction {
Locations = new UInt32[] { 17, 16, 16, 27, 27, 28, 28, 29, 29, 18 }
});
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
Guid previousLongestRoadPlayerId = Guid.Empty;
Guid newLongestRoadPlayerId = Guid.Empty;
localGameController.LongestRoadBuiltEvent = (Guid p, Guid n) => { previousLongestRoadPlayerId = p; newLongestRoadPlayerId = n; };
localGameController.StartGamePlay();
localGameController.BuildRoadSegment(turnToken, 4, 3);
localGameController.BuildRoadSegment(turnToken, 3, 2);
localGameController.BuildRoadSegment(turnToken, 2, 10);
localGameController.BuildRoadSegment(turnToken, 10, 9);
localGameController.EndTurn(turnToken); // First opponent builds 6 road segments to take the longest road title
// Build two more road segments for a new longest road of 7
localGameController.BuildRoadSegment(turnToken, 9, 8);
localGameController.BuildRoadSegment(turnToken, 8, 0);
// Assert
previousLongestRoadPlayerId.ShouldBe(firstOpponent.Id);
newLongestRoadPlayerId.ShouldBe(player.Id);
}
public void UseMonopolyCard_UseDevelopmentCardWhenOpponentsHaveNoResourcesOfType_ReceivedNullReference()
{
// Arrange
var monopolyCard = new MonopolyDevelopmentCard();
var testInstances = this.TestSetup(new MockGameBoardWithNoResourcesCollected(), monopolyCard);
var localGameController = testInstances.LocalGameController;
testInstances.Dice.AddSequence(new uint[] { 8, 8, 8, 3, 8 });
var player = testInstances.MainPlayer;
var firstOpponent = testInstances.FirstOpponent;
var secondOpponent = testInstances.SecondOpponent;
var thirdOpponent = testInstances.ThirdOpponent;
player.AddResources(ResourceClutch.DevelopmentCard);
firstOpponent.AddResources(ResourceClutch.OneGrain);
secondOpponent.AddResources(ResourceClutch.OneLumber);
thirdOpponent.AddResources(ResourceClutch.OneOre);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
var gainedResources = new ResourceTransactionList(); // Ensure that state change can be recognised
localGameController.ResourcesTransferredEvent = (ResourceTransactionList r) => { gainedResources = r; };
localGameController.StartGamePlay();
// Buy the monopoly card
localGameController.BuyDevelopmentCard(turnToken);
localGameController.EndTurn(turnToken);
// Act
localGameController.UseMonopolyCard(turnToken, monopolyCard, ResourceTypes.Brick);
// Assert
gainedResources.ShouldBeNull();
player.Resources.Count.ShouldBe(0);
firstOpponent.Resources.Count.ShouldBe(1);
firstOpponent.Resources.GrainCount.ShouldBe(1);
secondOpponent.Resources.Count.ShouldBe(1);
secondOpponent.Resources.LumberCount.ShouldBe(1);
thirdOpponent.Resources.Count.ShouldBe(1);
thirdOpponent.Resources.OreCount.ShouldBe(1);
}
public void Read(GamePacketReader reader)
{
Build = reader.ReadUInt();
Unknown8 = reader.ReadULong(); // 0x1588
Email = reader.ReadWideStringFixed();
Unknown208.Read(reader);
GameToken.Read(reader);
Unknown228 = reader.ReadUInt();
Unknown22C = reader.ReadUInt();
Unknown230 = reader.ReadUInt();
Unknown234 = reader.ReadUInt();
Hardware.Read(reader);
Unknown284 = reader.ReadUInt();
}
public void Read(GamePacketReader reader)
{
Build = reader.ReadUInt();
Unknown8 = reader.ReadULong(); // 0x1588
Email = reader.ReadWideStringFixed();
Unknown208.Read(reader);
GameToken.Read(reader);
Unknown228 = reader.ReadUInt();
Language = reader.ReadEnum <Language>(32u);
Unknown230 = reader.ReadUInt();
Unknown234 = reader.ReadUInt();
Hardware.Read(reader);
RealmDataCenterId = reader.ReadUInt();
}
public void Scenario_OpponentTradesWithBank()
{
// Arrange
var bankId = Guid.NewGuid();
var testInstances = this.TestSetupWithExplictGameBoard(bankId, new MockGameBoardWithNoResourcesCollected());
var localGameController = testInstances.LocalGameController;
testInstances.Dice.AddSequence(new uint[] { 8, 8, 8, 8 });
var givingResources = ResourceClutch.OneGrain * 4;
var firstOpponent = testInstances.FirstOpponent;
firstOpponent.AddResources(givingResources);
var tradeWithBankAction = new TradeWithBankInstruction {
GivingType = ResourceTypes.Grain, ReceivingCount = 1, ReceivingType = ResourceTypes.Wool
};
firstOpponent.AddTradeWithBankInstruction(tradeWithBankAction).EndTurn();
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
var gameEvents = new List <List <GameEvent> >();
localGameController.GameEvents = (List <GameEvent> e) => { gameEvents.Add(e); };
localGameController.StartGamePlay();
// Act
localGameController.EndTurn(turnToken);
// Assert
var expectedTradeWithBankEvent = new TradeWithBankEvent(firstOpponent.Id, bankId, givingResources, ResourceClutch.OneWool);
gameEvents.Count.ShouldBe(8);
gameEvents[2].Count.ShouldBe(2);
gameEvents[2][1].ShouldBe(expectedTradeWithBankEvent);
firstOpponent.Resources.Count.ShouldBe(1);
firstOpponent.Resources.WoolCount.ShouldBe(1);
}
public void TradeWithBank_LegitmateResourcesForTransaction_ResourceTransactionCompleted(Int32 brickCount, Int32 receivingCount, Int32 otherCount, Int32 leftOverBrickCount)
{
// Arrange
var bankId = Guid.NewGuid();
var testInstances = this.TestSetupWithExplictGameBoard(bankId, new MockGameBoardWithNoResourcesCollected());
var localGameController = testInstances.LocalGameController;
var paymentResources = ResourceClutch.OneBrick * (receivingCount * 4);
var requestedResources = ResourceClutch.OneGrain * receivingCount;
var player = testInstances.MainPlayer;
player.AddResources(ResourceClutch.OneBrick * brickCount);
player.AddResources(ResourceClutch.OneWool * otherCount);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
ResourceTransactionList resources = null;
localGameController.ResourcesTransferredEvent = (ResourceTransactionList r) => { resources = r; };
localGameController.StartGamePlay();
// Act
localGameController.TradeWithBank(turnToken, ResourceTypes.Grain, receivingCount, ResourceTypes.Brick);
// Assert
resources.ShouldNotBeNull();
var expected = new ResourceTransactionList();
expected.Add(new ResourceTransaction(bankId, player.Id, paymentResources));
expected.Add(new ResourceTransaction(player.Id, bankId, requestedResources));
resources.ShouldBe(expected);
player.Resources.Count.ShouldBe(receivingCount + otherCount + leftOverBrickCount);
player.Resources.BrickCount.ShouldBe(leftOverBrickCount);
player.Resources.GrainCount.ShouldBe(receivingCount);
player.Resources.WoolCount.ShouldBe(otherCount);
}
public void BuildRoadSegment_MainPlayerBuildsLongerRoadThanOpponent_VictoryPointsChangesFromOpponentToPlayer()
{
// Arrange
var testInstances = LocalGameControllerTestCreator.CreateTestInstances();
var localGameController = testInstances.LocalGameController;
LocalGameControllerTestSetup.LaunchGameAndCompleteSetup(localGameController);
testInstances.Dice.AddSequence(new[] { 8u, 8u, 8u, 8u, 8u });
var player = testInstances.MainPlayer;
player.AddResources(ResourceClutch.RoadSegment * 7);
var firstOpponent = testInstances.FirstOpponent;
firstOpponent.AddResources(ResourceClutch.RoadSegment * 6);
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
Guid previousLongestRoadPlayerId = Guid.Empty;
Guid newLongestRoadPlayerId = Guid.Empty;
localGameController.LongestRoadBuiltEvent = (Guid p, Guid n) => { previousLongestRoadPlayerId = p; newLongestRoadPlayerId = n; };
localGameController.StartGamePlay();
localGameController.BuildRoadSegment(turnToken, 4, 3);
localGameController.BuildRoadSegment(turnToken, 3, 2);
localGameController.BuildRoadSegment(turnToken, 2, 10);
localGameController.BuildRoadSegment(turnToken, 10, 9);
localGameController.EndTurn(turnToken);
localGameController.BuildRoadSegment(turnToken, 9, 8);
localGameController.BuildRoadSegment(turnToken, 8, 0);
// Assert
player.VictoryPoints.ShouldBe(4u);
firstOpponent.VictoryPoints.ShouldBe(2u);
}
public void StartOfMainPlayerTurn_TurnTokenReceived()
{
// Arrange
MockDice mockDice = null;
Guid id = Guid.Empty;
MockPlayer player;
MockComputerPlayer firstComputerPlayer, secondComputerPlayer, thirdComputerPlayer;
var localGameController = this.CreateLocalGameControllerAndCompleteGameSetup(out mockDice, out player, out firstComputerPlayer, out secondComputerPlayer, out thirdComputerPlayer);
mockDice.AddSequence(new[] { 8u });
// Act
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
localGameController.StartGamePlay();
// Assert
turnToken.ShouldNotBeNull();
}
public IPlayerBoard For(GameToken player)
{
var playerTokenFor = new Dictionary <GameToken, PlayerToken> {
{ GameToken.Player1, player == GameToken.Player1 ? PlayerToken.Me : PlayerToken.Opponent },
{ GameToken.Player2, player == GameToken.Player2 ? PlayerToken.Me : PlayerToken.Opponent },
{ GameToken.None, PlayerToken.None }
};
PlayerBoard boardForPlayer = new PlayerBoard();
for (int columns = 0; columns < BOARD_SIZE; columns++)
{
for (int rows = 0; rows < BOARD_SIZE; rows++)
{
var gameToken = _board[columns, rows];
boardForPlayer.SetToken(playerTokenFor[gameToken], BoardPosition.At(columns, rows));
}
}
return(boardForPlayer);
}
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);
}
public void Scenario_OpponentBuildsLongerRoadThanPlayer_VictoryPointsChangesFromPlayerToOpponent()
{
// Arrange
var testInstances = LocalGameControllerTestCreator.CreateTestInstances();
var localGameController = testInstances.LocalGameController;
LocalGameControllerTestSetup.LaunchGameAndCompleteSetup(localGameController);
var player = testInstances.MainPlayer;
var firstOpponent = testInstances.FirstOpponent;
testInstances.Dice.AddSequence(new uint[] { 8, 8, 8, 8, 8 });
player.AddResources(ResourceClutch.RoadSegment * 5);
firstOpponent.AddResources(ResourceClutch.RoadSegment * 6);
firstOpponent.AddBuildRoadSegmentInstruction(new BuildRoadSegmentInstruction {
Locations = new UInt32[] { 17, 16, 16, 27, 27, 28, 28, 29, 29, 18 }
});
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
localGameController.StartGamePlay();
localGameController.BuildRoadSegment(turnToken, 4, 3);
localGameController.BuildRoadSegment(turnToken, 3, 2);
localGameController.BuildRoadSegment(turnToken, 2, 10);
localGameController.BuildRoadSegment(turnToken, 10, 9);
player.VictoryPoints.ShouldBe(4u);
firstOpponent.VictoryPoints.ShouldBe(2u);
// Act - Opponent builds longer road.
localGameController.EndTurn(turnToken);
// Assert
player.VictoryPoints.ShouldBe(2u);
firstOpponent.VictoryPoints.ShouldBe(4u);
}
public void BuildSettlement_InsufficientResourcesAfterBuildingSettlement_MeaningfulErrorIsReceived()
{
// Arrange
var testInstances = LocalGameControllerTestCreator.CreateTestInstances(new MockGameBoardWithNoResourcesCollected());
var localGameController = testInstances.LocalGameController;
var player = testInstances.MainPlayer;
LocalGameControllerTestSetup.LaunchGameAndCompleteSetup(localGameController);
testInstances.Dice.AddSequence(new[] { 8u });
player.AddResources(ResourceClutch.RoadSegment * 3);
player.AddResources(ResourceClutch.Settlement);
Int32 settlementBuilt = 0;
localGameController.SettlementBuiltEvent = s => { settlementBuilt++; };
ErrorDetails errorDetails = null;
localGameController.ErrorRaisedEvent = (ErrorDetails e) => { errorDetails = e; };
GameToken turnToken = null;
localGameController.StartPlayerTurnEvent = (GameToken t) => { turnToken = t; };
localGameController.StartGamePlay();
localGameController.BuildRoadSegment(turnToken, MainRoadOneEnd, 3);
localGameController.BuildRoadSegment(turnToken, 3, 2);
localGameController.BuildRoadSegment(turnToken, 2, 1);
localGameController.BuildSettlement(turnToken, 3);
// Act
localGameController.BuildSettlement(turnToken, 1);
// Assert
settlementBuilt.ShouldBe(1);
errorDetails.ShouldNotBeNull();
errorDetails.Message.ShouldBe("Cannot build settlement. Missing 1 brick and 1 grain and 1 lumber and 1 wool.");
}
