/// <summary>
/// Hacemos dos comprobaciones, que la posición está dentro del tablero
/// y que cumple con las reglas del juego.
/// </summary>
/// <param name="tablero">Tablero en la situación actual de juego
/// </param>
/// <param name="posicion">Posición elegida por el jugador cuya
/// legalidad queremos comprobar</param>
/// <param name="color">Color del jugador</param>
/// <returns>True si la jugada es correcta, false en caso contrario
/// </returns>
private Boolean ComprobarJugada(Tablero tablero, Posicion posicion, Color color)
{
Boolean movimientoValido;
movimientoValido = Reglas.PosicionDentroTablero(posicion.Row, posicion.Col);
if (!movimientoValido)
{
return(false);
}
movimientoValido = Reglas.PosicionLegal(tablero, posicion.Row, posicion.Col, color);
if (!movimientoValido)
{
return(false);
}
return(true);
}
/// <summary>
/// Método que inicia el proceso de cambio de color en función de las
/// reglas del juego y a partir de la posición elegida para realizar
/// la jugada
/// </summary>
/// <param name="tablero">Tablero en su situación actual</param>
/// <param name="color">Color del jugador</param>
/// <param name="row">Fila</param>
/// <param name="col">Columna</param>
public static void CambioDeColor(Tablero tablero, Color color, int row,
int col, out int piezasComidas)
{
piezasComidas = 0;
/* Comprobamos las direcciones que cumplen que la pieza es dis-
* tinta a la que colocamos y no está vacía alrededor de la posición
* que hemos elegido */
for (int i = row - 1; i < row + 2; i++)
{
for (int j = col - 1; j < col + 2; j++)
{
if (ComprobarCasilla(tablero, color, i, j))
{
ComprobarDireccion(tablero, color, i - row, j - col, row,
col, out piezasComidas);
}
}
}
}
/// <summary>
/// Método para comprobar en qué casillas podemos colocar piezas.
/// </summary>
/// <param name="tablero">Tablero en su situación actual</param>
public void ComprobarValidas(Tablero tablero)
{
posicionesValidas = new Queue();
Posicion posicion;
for (int row = 1; row < 9; row++)
{
for (int col = 1; col < 9; col++)
{
if (Reglas.PosicionLegal(tablero, row, col, color))
{
posicion = new Posicion();
posicion.Row = row;
posicion.Col = col;
posicionesValidas.Enqueue(posicion);
}
}
}
}
/// <summary>
/// Método para pedir posición al jugador
/// </summary>
/// <param name="tablero">Tablero en su sitúación actual</param>
public void Movimiento(Tablero tablero)
{
Posicion posicion = null;
Boolean movimientoValido = false, pasa = false;
int piezasComidas = 0;
/* Pedimos posición de juego al jugador hasta que la que
* introduzca cumpla con las reglas del juego */
do
{
posicion = ElegirPosicion(tablero);
if (posicion.Col == 0)
{
if (posicion.Row == 0)
{
pasa = true;
break;
}
}
movimientoValido = ComprobarJugada(tablero, posicion, color);
if (!movimientoValido)
{
Console.WriteLine("Jugada " +
"INCORRECTA. Vuelve a introducir posición.");
}
} while (!movimientoValido);
/* Cambiamos de color las fichas 'comidas' y colocamos la pieza
* en la posición elegida en caso de no pasar turno */
if (!pasa)
{
Reglas.CambioDeColor(tablero, color, posicion.Row,
posicion.Col, out piezasComidas);
ActualizarTablero(tablero, posicion.Row, posicion.Col);
}
}
/// <summary>
/// Buscamos posición que genere una mayor ganancia de piezas del
/// rival
/// </summary>
/// <param name="tablero">Tablero del que queremos obtener
/// distintas opciones de juego</param>
/// <param name="profundidad">rango de movimientos máximos que
/// podemos simular en cascada</param>
/// <returns></returns>
public Posicion ElegirPosicion_bis(Tablero tablero)
{
int piezasComidas;
int row, col;
Posicion posicionElegida = new Posicion();
Tablero tableroCopia = new Tablero();
tableroCopia.Copiar(tablero);
foreach (Posicion posicion in posicionesValidas)
{
Reglas.CambioDeColor(tableroCopia, color, posicion.Row,
posicion.Col, out piezasComidas);
row = posicion.Row;
col = posicion.Col;
fichasComidas[row, col] += piezasComidas;
}
ImprimirMatriz();
posicionElegida = ComprobarMejorPosicion();
return(posicionElegida);
}
/// <summary>
/// Método donde decidimos la forma de actual de la IA.
/// En este caso, elgimos de forma aleatoria entre las posiciones
/// válidas
/// </summary>
/// <returns>Posicion elegida</returns>
public Posicion ElegirPosicion(Tablero tablero)
{
Random random = new Random(Guid.NewGuid().GetHashCode());
Posicion posicion = new Posicion();
int posicionElegida;
if (posicionesValidas.Count != 0)
{
posicionElegida = random.Next(1, posicionesValidas.Count);
}
else
{
posicionElegida = 0;
posicion.Col = 0;
posicion.Row = 0;
}
for (int i = 0; i < posicionElegida; i++)
{
posicion = new Posicion();
posicion = (Posicion)posicionesValidas.Dequeue();
}
return(posicion);
}
/// <summary>
/// Método para actualizar tablero
/// </summary>
/// <param name="jugador">Participante que está realizando
/// movimiento</param>
/// <param name="row">Fila</param>
/// <param name="col">Columna</param>
public void ActualizarTablero(Tablero tablero, int row, int col)
{
tablero.SetBoard(row, col, color);
tablero.MostrarTablero();
}
/// <summary>
/// Comprobamos si una casilla cumple no estar vacía y ser de color
/// distinto a la del jugador, es decir, si es susceptible de ser
/// 'comida' por el jugador
/// </summary>
/// <param name="tablero">Tablero en su situación actual</param>
/// <param name="color">Color del jugador</param>
/// <param name="row">Fila</param>
/// <param name="col">Columna</param>
/// <returns>True en caso de ser casilla susceptible de ser comida,
/// false en caso contrario</returns>
private static Boolean ComprobarCasilla(Tablero tablero, Color color, int row, int col)
{
return(tablero.GetBoard()[row, col] != (char)color &&
tablero.GetBoard()[row, col] != (char)Color.VACIO);
}