Beispiel #1
0
        /// <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);
        }
Beispiel #2
0
        /// <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);
                    }
                }
            }
        }
Beispiel #3
0
        /// <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);
                    }
                }
            }
        }
Beispiel #4
0
        /// <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);
            }
        }
Beispiel #5
0
        /// <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);
        }
Beispiel #6
0
        /// <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);
        }
Beispiel #7
0
 /// <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();
 }
Beispiel #8
0
 /// <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);
 }