private void CheckPieceIsOnBoard(IGamePiece piece)
{
if (!PiecesOnBoard.Contains(piece))
{
throw new ArgumentException("Piece not currently on the board.", "Piece");
}
}
public void OnPieceAddedToChain(IGamePiece i_piece)
{
if (GamePiece == i_piece)
{
SetIsOnProperty(true);
}
}
public void DoesMatchCombo_ReturnsAsExpected(List <int> i_comboAttempt, bool i_expectedMatch)
{
IMonsterData mockMonsterData = Substitute.For <IMonsterData>();
mockMonsterData.GetAttackCombo().Returns(new List <int>()
{
1, 2, 3
});
List <IGamePiece> comboAttempt = new List <IGamePiece>();
if (i_comboAttempt != null)
{
foreach (int pieceType in i_comboAttempt)
{
IGamePiece mockPiece = Substitute.For <IGamePiece>();
mockPiece.PieceType.Returns(pieceType);
comboAttempt.Add(mockPiece);
}
}
GameMonster systemUnderTest = new GameMonster(mockMonsterData);
bool doesMatch = systemUnderTest.DoesMatchCombo(comboAttempt);
Assert.AreEqual(i_expectedMatch, doesMatch);
}
private void CheckPieceIsNotOnBoard(IGamePiece piece)
{
if (PiecesOnBoard.Contains(piece))
{
throw new ArgumentException("Piece is already on the board.", "Piece");
}
}
private IGamePiece CreateMockPieceWithIndex(int i_index)
{
IGamePiece mockPiece = Substitute.For <IGamePiece>();
mockPiece.Index.Returns(i_index);
return(mockPiece);
}
/// <summary>
/// Add piece to a specified location.
/// </summary>
/// <param name="piece">Game piece to add to board.</param>
/// <param name="location">Location to add game piece.</param>
public void PlacePiece(IGamePiece piece, IEnumerable <int> location)
{
CheckPieceIsNotOnBoard(piece);
var validLocation = IsLocationValid(location.ToArray());
AddPiece(piece, validLocation);
}
private void DeletePiece(IGamePiece piece)
{
var location = FindPiece(piece);
board[location[0], location[1]].Remove(piece);
PiecesOnBoard.Remove(piece);
}
public bool IsValidPieceInChain(IGamePiece i_piece, List <IGamePiece> i_chain)
{
return(DuplicatePieceValidator.IsValidPieceInChain(i_piece, i_chain) &&
DiagonalPieceValidator.IsValidPieceInChain(i_piece, i_chain) &&
StraightLinesOnlyValidator.IsValidPieceInChain(i_piece, i_chain) &&
MaxLengthValidator.IsValidPieceInChain(i_piece, i_chain) &&
SelectablePieceValidator.IsValidPieceInChain(i_piece, i_chain));
}
public void StartChain(IGamePiece i_piece)
{
if (IsNoChain())
{
CreateChain();
AddPieceToChain(i_piece);
SendPieceAddedEvent(i_piece);
}
}
/// <summary>
/// Move a specified piece from a source location to a destination location.
/// </summary>
/// <param name="piece">Piece to move</param>
/// <param name="location">Location to move the piece from</param>
/// <param name="destLocation">Location to move the piece to</param>
public void MovePiece(IGamePiece piece, IEnumerable <int> destLocation)
{
CheckPieceIsOnBoard(piece);
var destinationLocation = IsLocationValid(destLocation.ToArray());
DeletePiece(piece);
AddPiece(piece, destinationLocation);
}
/// <summary>
/// Adds a specified game piece to a tile.
/// </summary>
/// <param name="element">The game piece to add to the tile.</param>
public void AddGamePiece(IGamePiece element)
{
if (element is HeroClixCharacter &&
gamePieces.Count(x => x.GetType().Equals(typeof(HeroClixCharacter))) > 0)
{
throw new InvalidOperationException("A character is already occupying this tile.");
}
gamePieces.Add(element);
}
public void IsValidPiece_IsFalse_IfIncomingPiece_IsNotSelectable()
{
IGamePiece mockPiece = Substitute.For <IGamePiece>();
mockPiece.IsSelectable().Returns(false);
bool isValid = systemUnderTest.IsValidPieceInChain(mockPiece, new List <IGamePiece>());
Assert.IsFalse(isValid);
}
public void WhenNoChain_StartChain_SendsMessageWithAddedPiece()
{
CreateChainManager_WithNoChain();
IGamePiece mockPiece = Substitute.For <IGamePiece>();
systemUnderTest.StartChain(mockPiece);
MyMessenger.Received().Send <IGamePiece>(GameMessages.PIECE_ADDED_TO_CHAIN, mockPiece);
}
public GamePiecePM(IGamePiece i_piece) : base(i_piece)
{
GamePiece = i_piece;
ListenForMessages(true);
UpdateProperties();
ResetIsOnProperty();
}
public void WhenPieceIsAddedToChain_IfNotPMsPiece_IsOnProperty_IsFalse()
{
IGamePiece notSamePiece = Substitute.For <IGamePiece>();
GamePiecePM systemUnderTest = CreateSystem();
systemUnderTest.OnPieceAddedToChain(notSamePiece);
Assert.IsFalse(systemUnderTest.ViewModel.GetPropertyValue <bool>(GamePiecePM.IS_ON_PROPERTY));
}
public void MovePiece(ref List <IGameField> fields, int pieceTurn, int dieRoll)
{
IGamePiece piece = GetPiece(pieceTurn);
IGameField currentField = fields[piece.Position]; // Used so we can reset the earlier used position
IGameField fieldToMove = fields[(piece.Position + dieRoll)];
currentField.RemovePiece(piece);
}
public void WhenNoChain_StartChain_AddsPieceToChain()
{
CreateChainManager_WithNoChain();
IGamePiece mockPiece = Substitute.For <IGamePiece>();
systemUnderTest.StartChain(mockPiece);
Assert.Contains(mockPiece, systemUnderTest.Chain);
}
public void TestStraightLineOnlyLogic(int i_firstIndex, int i_secondIndex, int i_incomingIndex, bool i_expectedValidation)
{
SetCurrentDungeonToAllowStraightLinesOnly(true);
List <IGamePiece> mockChain = CreateChainFromTwoIndices(i_firstIndex, i_secondIndex);
IGamePiece mockIncomingPiece = CreateMockPieceWithIndex(i_incomingIndex);
bool isValid = systemUnderTest.IsValidPieceInChain(mockIncomingPiece, mockChain);
Assert.AreEqual(i_expectedValidation, isValid);
}
public void WhenChainCanceled_PiecesInChain_AreFailed()
{
systemUnderTest.Chain = new List <IGamePiece>();
IGamePiece mockPiece = Substitute.For <IGamePiece>();
systemUnderTest.Chain.Add(mockPiece);
systemUnderTest.CancelChain();
mockPiece.Received().PieceFailedMatch();
}
private void RandomizeBoard()
{
for (int i = 0; i < BoardPieces.GetLength(0); ++i)
{
for (int j = 0; j < BoardPieces.GetLength(1); ++j)
{
IGamePiece piece = BoardPieces[i, j];
piece.Randomize();
}
}
}
public void WhenActiveChain_ContinuingChain_IfChainIsValid_AddPieceToChain()
{
CreateChainManager_WithEmptyActiveChain();
ChainValidator.IsValidPieceInChain(Arg.Any <IGamePiece>(), Arg.Any <List <IGamePiece> >()).Returns(true);
IGamePiece mockPiece = Substitute.For <IGamePiece>();
systemUnderTest.ContinueChain(mockPiece);
Assert.Contains(mockPiece, systemUnderTest.Chain);
}
private List <IGamePiece> CreateChainFromTwoIndices(int i_first, int i_second)
{
List <IGamePiece> mockChain = new List <IGamePiece>();
IGamePiece firstPiece = CreateMockPieceWithIndex(i_first);
IGamePiece secondPiece = CreateMockPieceWithIndex(i_second);
mockChain.Add(firstPiece);
mockChain.Add(secondPiece);
return(mockChain);
}
private bool IsValidPieceForChain(IGamePiece i_piece, List <IGamePiece> i_chainInProgress, List <int> i_targetChain)
{
if (i_chainInProgress.Contains(i_piece) || i_piece.PieceType != i_targetChain[i_chainInProgress.Count])
{
return(false);
}
else
{
return(true);
}
}
public void WhenActiveChain_ContinuingChain_IfChainIsValid_SendsPieceAddedEvent()
{
CreateChainManager_WithEmptyActiveChain();
ChainValidator.IsValidPieceInChain(Arg.Any <IGamePiece>(), Arg.Any <List <IGamePiece> >()).Returns(true);
IGamePiece mockPiece = Substitute.For <IGamePiece>();
systemUnderTest.ContinueChain(mockPiece);
MyMessenger.Received().Send <IGamePiece>(GameMessages.PIECE_ADDED_TO_CHAIN, mockPiece);
}
public bool IsValidPieceInChain(IGamePiece i_piece, List <IGamePiece> i_chain)
{
if (i_chain.Count == 0 || i_chain.Count == 1 || !CurrentDungeon.Data.StraightMovesOnly())
{
return(true);
}
int direction = GetDirectionOfChain(i_chain);
bool isStraightLine = IsStraightLine(i_piece.Index, i_chain[i_chain.Count - 1].Index, direction);
return(isStraightLine);
}
public void ContinueChain(IGamePiece i_piece)
{
if (IsActiveChain() && ChainValidator.IsValidPieceInChain(i_piece, mChain))
{
AddPieceToChain(i_piece);
SendPieceAddedEvent(i_piece);
}
else
{
CancelChain();
}
}
private void RunDiagonalTest(int i_incomingPieceIndex, int i_lastPlayedPieceIndex, bool i_expectedValidation)
{
IGamePiece mockIncomingPiece = CreateMockPieceWithIndex(i_incomingPieceIndex);
IGamePiece mockLastPlayedPiece = CreateMockPieceWithIndex(i_lastPlayedPieceIndex);
List <IGamePiece> mockChain = new List <IGamePiece>();
mockChain.Add(mockLastPlayedPiece);
bool isValid = systemUnderTest.IsValidPieceInChain(mockIncomingPiece, mockChain);
Assert.AreEqual(i_expectedValidation, isValid);
}
public void IsValidPiece_IsFalse_IfIncomingPiee_IAlreadyInChain()
{
ChainValidator_DuplicatePieces systemUnderTest = new ChainValidator_DuplicatePieces();
IGamePiece mockPiece = Substitute.For <IGamePiece>();
List <IGamePiece> mockChain = new List <IGamePiece>()
{
mockPiece
};
bool isValid = systemUnderTest.IsValidPieceInChain(mockPiece, mockChain);
Assert.IsFalse(isValid);
}
public void WhenProcessingChain_IfChainDoesNotMatchAnyMonster_PiecesFailedMatch_IsCalled()
{
IGamePiece mockPiece = Substitute.For <IGamePiece>();
List <IGamePiece> chain = new List <IGamePiece>()
{
mockPiece
};
MonsterManager.DoesMoveMatchAnyCurrentMonsters(Arg.Any <List <IGamePiece> >()).Returns(false);
systemUnderTest.Process(chain);
mockPiece.Received().PieceFailedMatch();
}
public void IfSearchIsEmpty_BoardIsValid()
{
IGamePiece[,] mockBoard = new IGamePiece[, ] {
{ new GamePiece(0, 0), new GamePiece(0, 0), new GamePiece(0, 0), new GamePiece(0, 0) },
{ new GamePiece(0, 0), new GamePiece(1, 0), new GamePiece(0, 0), new GamePiece(0, 0) },
{ new GamePiece(0, 0), new GamePiece(2, 0), new GamePiece(0, 0), new GamePiece(0, 0) },
{ new GamePiece(0, 0), new GamePiece(3, 0), new GamePiece(0, 0), new GamePiece(0, 0) }
};
MonsterManager.GetCurrentMonsterCombos().Returns(new List <List <int> >());
bool isOnBoard = systemUnderTest.IsMonsterComboAvailableOnBoard(mockBoard);
Assert.IsTrue(isOnBoard);
}
public void Grab(IGamePiece o)
{
this.Holding = o;
}
