/// <summary>
/// Searches through the entire more to see if there are any moves left. If so,
/// returns true and the location of the move.
/// </summary>
/// <param name="rowHint">The row of the token that can be switched to make a move. </param>
/// <param name="colHint">The column of the token that can be switched to make a move. </param>
/// <returns>True if a move is possible, false otherwise. </returns>
public virtual bool areMovesLeft(IBasicPokemonToken[,] pokemonGrid, out int rowHint, out int colHint)
{
PokemonGrid = pokemonGrid;
NewPokemonGrid = pokemonGrid;
bool isMove = false;
for (int row = 0; row < gridSize; row++)
{
for (int col = 0; col < gridSize - 1; col++)
{
isMove = testForMove(row, col);
if (isMove)
{
rowHint = row;
colHint = col;
return true;
}
GridOperations.invertGrid(_pokemonGrid);
GridOperations.invertGrid(_newPokemonGrid);
isMove = testForMove(row, col);
GridOperations.invertGrid(_pokemonGrid);
GridOperations.invertGrid(_newPokemonGrid);
if (isMove)
{
rowHint = col;
colHint = row;
return true;
}
}
}
rowHint = -1;
colHint = -1;
return false;
}
public void InvertGrid_NoError_GridInverted()
{
IBasicPokemonToken[,] pokemonToInvert = new IBasicPokemonToken[3, 3];
pokemonToInvert[0, 0] = new BulbasaurToken();
pokemonToInvert[0, 1] = new BulbasaurToken();
pokemonToInvert[0, 2] = new BulbasaurToken();
pokemonToInvert[1, 0] = new CharmanderToken();
pokemonToInvert[1, 1] = new CharmanderToken();
pokemonToInvert[1, 2] = new CharmanderToken();
pokemonToInvert[2, 0] = new BulbasaurToken();
pokemonToInvert[2, 1] = new BulbasaurToken();
pokemonToInvert[2, 2] = new BulbasaurToken();
IBasicPokemonToken[,] invertedPokemon = new IBasicPokemonToken[3, 3];
invertedPokemon[0, 0] = new BulbasaurToken();
invertedPokemon[0, 1] = new CharmanderToken();
invertedPokemon[0, 2] = new BulbasaurToken();
invertedPokemon[1, 0] = new BulbasaurToken();
invertedPokemon[1, 1] = new CharmanderToken();
invertedPokemon[1, 2] = new BulbasaurToken();
invertedPokemon[2, 0] = new BulbasaurToken();
invertedPokemon[2, 1] = new CharmanderToken();
invertedPokemon[2, 2] = new BulbasaurToken();
GridOperations.invertGrid(pokemonToInvert);
Assert.AreEqual(pokemonToInvert, invertedPokemon);
}
/// <summary>
/// Copies a 2-d array of IBasicPokemonTokens to another 2-d array.
/// </summary>
/// <param name="gridToCopy">The 2-d array from which to copy. </param>
/// <param name="gridDestination">The 2-d array to copy to. </param>
public static void copyGrid(IBasicPokemonToken[,] gridToCopy, IBasicPokemonToken[,] gridDestination)
{
int rowLength = gridToCopy.GetLength(0);
int colLength = gridToCopy.GetLength(1);
if (rowLength != gridDestination.GetLength(0) || colLength != gridDestination.GetLength(1))
{
throw new ArithmeticException("Dimensions of grid did not match dimensions of destination grid");
}
else
{
for (int row = 0; row < rowLength; row++)
{
for (int col = 0; col < colLength; col++)
{
gridDestination[row, col] = gridToCopy[row, col];
}
}
}
}
/// <summary>
/// Inverts a square 2-dimensional array of IBasicPokemonTokens.
/// </summary>
/// <param name="gridToInvert">The 2-d array to invert. </param>
public static void invertGrid(IBasicPokemonToken[,] gridToInvert)
{
int rowLength = gridToInvert.GetLength(0);
int colLength = gridToInvert.GetLength(1);
if (rowLength != colLength)
{
throw new ArithmeticException("Grid is not square.");
}
else
{
IBasicPokemonToken[,] invertedGrid = new IBasicPokemonToken[rowLength, colLength];
for (int row = 0; row < rowLength; row++)
{
for (int col = 0; col < colLength; col++)
{
invertedGrid[row, col] = gridToInvert[col, row];
}
}
copyGrid(invertedGrid, gridToInvert);
}
}
public MakingPlayEventArgs(IBasicPokemonToken[,] pokemonGrid)
{
PokemonGrid = pokemonGrid;
}
private IBasicPokemonToken[,] generateStableGrid()
{
int tokenToAdd = 0;
IBasicPokemonToken[,] pokemonGrid = new IBasicPokemonToken[PokemonBoard.gridSize, PokemonBoard.gridSize];
for (int row = 0; row < PokemonBoard.gridSize; row++)
{
for (int col = 0; col < PokemonBoard.gridSize; col++)
{
pokemonGrid[row, col] = (PokemonToken)Activator.CreateInstance(PokemonBoard.TokenList[tokenToAdd++ % 6 + 1]);
}
}
return pokemonGrid;
}
public static ImageBrush getImageBrush(IBasicPokemonToken pokemon)
{
return _pictureDictionary[pokemon.GetType()];
}
/// <summary>
/// Checks to see if a PokemonToken is in the same evolution chain as another PokemonToken
/// </summary>
public bool isSameSpecies(IBasicPokemonToken pokemonToken)
{
return this.Species() == pokemonToken.Species();
}
/// <summary>
/// Begins a play.
/// </summary>
/// <param name="row1">The row of the first location on the grid. </param>
/// <param name="col1">The column of the first location on the grid. </param>
/// <param name="row2">The row of the second location on the grid. </param>
/// <param name="col2">The column of the second location on the grid. </param>
/// <returns>True if a play was made, false otherwise. </returns>
public virtual void tryPlay(IBasicPokemonToken[,] pokemonGrid, int row1, int col1, int row2, int col2)
{
if (GridOperations.arePiecesAdjacent(row1, col1, row2, col2))
{
PokemonGrid = pokemonGrid;
NewPokemonGrid = pokemonGrid;
makePlay(row1, col1, row2, col2);
updateBoard();
OnEndingPlay();
}
}
/// <summary>
/// Searches through the entire board and marks any tokens in the same evolution chain
/// as the given IBasicPokemonToken as null.
/// </summary>
/// <param name="pokemon">The pokemon for which all tokens of the same species will be marked null. </param>
public virtual void markAllTokensOfSameTypeAsNull(IBasicPokemonToken pokemon)
{
int numTokensMarkedNull = 0;
for (int row = 0; row < gridSize; row++)
{
for (int col = 0; col < gridSize; col++)
{
if (_pokemonGrid[row, col].isSameSpecies(pokemon))
{
numTokensMarkedNull++;
updateToken(row, col);
}
}
}
OnPointsAdded((int)Math.Pow(numTokensMarkedNull, 2) * 10);
}
public void InvertGrid_GridNotSquare_ThrowArithmeticException()
{
IBasicPokemonToken[,] pokemonToInvert = new IBasicPokemonToken[3, 4];
GridOperations.invertGrid(pokemonToInvert);
}
public void CopyGrid_GridRowsMismatched_ThrowArithmeticException()
{
IBasicPokemonToken[,] firstGrid = new IBasicPokemonToken[3, 3];
IBasicPokemonToken[,] secondGrid = new IBasicPokemonToken[4, 3];
GridOperations.copyGrid(firstGrid, secondGrid);
}
