/// <summary>
/// Verifica se a linha inicia em uma arena e termina em outra
/// </summary>
/// <param name="startPos">Primeira posição do brasão </param>
/// <param name="count">Número de repetições do brasão</param>
/// <returns>True se a linha iniciar em uma arena e terminar em outra</returns>
private bool IsExtraPoint(int startPos, int count, Arena.DIRECTION dir)
{
int lastPos = 0;
if (dir.Equals(Arena.DIRECTION.diagonalS))
{
lastPos = startPos - count + 1;
}
else
{
lastPos = startPos + count - 1;
}
return((int)startPos / 3 != (int)lastPos / 3);
}
/// <summary>
/// Marca os pontos extras se existir linhas extras
/// </summary>
/// <param name="firstPos">int[] - vetor com os valor da linha e coluna do primeiro brasão encontrado</param>
/// <param name="count">int - número de repetições do brasão</param>
/// <param name="dir">Arena.DIRECTION - direção da linha</param>
private void ScoreExtraPoints(int[] firstPos, int count, Arena.DIRECTION dir, int player)
{
bool hasScore = false;
if (count >= NUM_ROW_COL)
{
hasScore = IsExtraPoint(firstPos[1], count, dir);
}
if (hasScore)
{
int points = count * this.extraPoint;
GameManager.instance.ScorePoints(points, player);
}
}
/// <summary>
/// Verifica se existe pontos na diagonal da arena
/// </summary>
private void VerifyDiagonalExtraPoint(Arena.DIRECTION dir)
{
Debug.Log("Verificando linhas " + dir.ToString());
int previewArms = -1;
int arms = 0;
int count = 1;
int[] firstPos = new int[2];
int player = -1;
for (int i = 0; i < this.numHorizontalArenas * NUM_ROW_COL; i++)
{
if (dir.Equals(Arena.DIRECTION.diagonalP))
{
arms = board[i, i];
}
else if (dir.Equals(Arena.DIRECTION.diagonalS))
{
arms = board[i, (NUM_ROW_COL * this.numHorizontalArenas) - 1 - i];
}
if (previewArms == arms)
{
count++;
}
else
{
player = previewArms == Player.ARMS1 ? 0 : 1;
ScoreExtraPoints(firstPos, count, Arena.DIRECTION.diagonalP, player);
previewArms = arms;
count = 1;
if (dir.Equals(Arena.DIRECTION.diagonalP))
{
firstPos[0] = i;
firstPos[1] = i;
}
else if (dir.Equals(Arena.DIRECTION.diagonalS))
{
firstPos[0] = i;
firstPos[1] = (NUM_ROW_COL * this.numHorizontalArenas) - 1 - i;
}
}
}
if (count >= NUM_ROW_COL)
{
ScoreExtraPoints(firstPos, count, dir, player);
}
}
/// <summary>
/// Pinta a campo com a cor do jogador
/// </summary>
/// <param name="color">Cor do jogador</param>
public void PaintMe(Player player, Arena.DIRECTION dir)
{
switch (dir)
{
case Arena.DIRECTION.horizontal:
this.spriteIndex |= 1;
break;
case Arena.DIRECTION.vertical:
this.spriteIndex |= 2;
break;
case Arena.DIRECTION.diagonalP:
this.spriteIndex |= 4;
break;
case Arena.DIRECTION.diagonalS:
this.spriteIndex |= 8;
break;
}
Image img = GetComponent <Image>();
img.sprite = player.armsSprite[this.spriteIndex];
}
/// <summary>
/// Verifica a existencia de combinação entre brasões em linhas, colunas e diagonal
/// </summary>
/// <param name="arena">Arena no tabuleiro</param>
/// <param name="row">Linha selecionada</param>
/// <param name="col">Coluna selecionada</param>
/// <returns></returns>
private bool CheckMatchLine(Arena arena, int row, int col)
{
bool result = false;
int localRow = (NUM_ROW_COL * arena.row) + row;
int localCol = (NUM_ROW_COL * arena.col) + col;
int arms = board[localRow, localCol];
int startRow = NUM_ROW_COL * arena.row;
int startCol = NUM_ROW_COL * arena.col;
// Verifica combinação de brasões entre colunas (linha vertical)
bool horizontalLine = board[localRow, startCol] == arms &&
board[localRow, startCol + 1] == arms &&
board[localRow, startCol + 2] == arms;
// Verifica combinação de brasões entre linhas (linha horizontal)
bool verticalLine = board[startRow, localCol] == arms &&
board[startRow + 1, localCol] == arms &&
board[startRow + 2, localCol] == arms;
// verifica combinação na diagonal primaria da matriz
bool primaryDiagonal = board[startRow, startCol] == arms &&
board[startRow + 1, startCol + 1] == arms &&
board[startRow + 2, startCol + 2] == arms &&
row == col;
// verifica combinação na diagonal secundária da matriz
bool secundaryDiagonal = board[startRow + NUM_ROW_COL - 1, startCol] == arms &&
board[startRow + 1, startCol + 1] == arms &&
board[startRow, startCol + NUM_ROW_COL - 1] == arms &&
(row + col == NUM_ROW_COL - 1);
if (verticalLine || horizontalLine || primaryDiagonal || secundaryDiagonal)
{
GameManager manager = GameManager.instance;
Arena.DIRECTION dir = Arena.DIRECTION.diagonalP;
if (verticalLine)
{
dir = Arena.DIRECTION.vertical;
manager.ScorePoints(this.linePoint);
arena.PaintLine(row, col, dir);
}
if (horizontalLine)
{
dir = Arena.DIRECTION.horizontal;
manager.ScorePoints(this.linePoint);
arena.PaintLine(row, col, dir);
}
if (primaryDiagonal)
{
dir = Arena.DIRECTION.diagonalP;
manager.ScorePoints(this.linePoint);
arena.PaintLine(row, col, dir);
}
if (secundaryDiagonal)
{
dir = Arena.DIRECTION.diagonalS;
manager.ScorePoints(this.linePoint);
arena.PaintLine(row, col, dir);
}
result = true;
}
return(result);
}
/// <summary>
/// Verifica se as linhas do tabuleiro possuem pontos extras
/// </summary>
/// <param name="dir">Direçãodas linhas</param>
private void VerifyExtraLines(Arena.DIRECTION dir)
{
int previewArms = -1;
int arms = 0;
int count = 1;
int[] firstPos = new int[2];
int totalA, totalB = 0;
int player = -1;
if (dir.Equals(Arena.DIRECTION.horizontal))
{
totalA = this.numHorizontalArenas * NUM_ROW_COL;
totalB = this.numVerticalArenas * NUM_ROW_COL;
}
else
{
totalA = this.numVerticalArenas * NUM_ROW_COL;
totalB = this.numHorizontalArenas * NUM_ROW_COL;
}
Debug.Log("Verificando linhas " + dir.ToString());
for (int i = 0; i < totalA; i++)
{
previewArms = -1;
if (count >= NUM_ROW_COL)
{
player = arms == Player.ARMS1 ? 0 : 1;
ScoreExtraPoints(firstPos, count, dir, player);
count = 0;
}
for (int j = 0; j < totalB; j++)
{
if (dir.Equals(Arena.DIRECTION.horizontal))
{
arms = board[i, j];
}
else
{
arms = board[j, i];
}
if (previewArms == arms)
{
count++;
}
else
{
player = previewArms == Player.ARMS1 ? 0 : 1;
ScoreExtraPoints(firstPos, count, dir, player);
previewArms = arms;
count = 1;
firstPos[0] = i;
firstPos[1] = j;
}
}
}
if (count >= NUM_ROW_COL)
{
ScoreExtraPoints(firstPos, count, dir, player);
}
}