Representa el juego de Triqui.

Triqui.cs

// ===++===
//
//    OrtizOL
//
// ===--===
/*============================================================
//
// Clase: Triqui.cs
//
// Original en: http://goo.gl/jgd3e1 
//
// Propósito: Implementar la lógica de la entidad Triqui.
//
============================================================*/

using System;

namespace Triqui.Modelo
{
    /// <summary>
    /// Representa el tablero lógico de triqui.
    /// </summary>
    public class Triqui
    {
        #region Campos
        /// <summary>
        /// Las 9 casillas que integran el tablero lógico de triqui.
        /// </summary>
        private Casilla[] casillas;
        #endregion

        #region Constructores
        /// <summary>
        /// Crea una instancia del juego de Triqui.
        /// </summary>
        public Triqui()
        {
            // Crea las nueve casillas:
            casillas = new Casilla[9];

            for(int i = 0; i < casillas.Length; ++i)
            {
                casillas[i] = new Casilla();
            }
        }
        #endregion

        #region Métodos
        /// <summary>
        /// Comprueba que una determinada casilla esté vacía.
        /// </summary>
        /// <param name="casilla">Posición de la casilla comprobar su estado.</param>
        /// <returns>true si la casilla está vacía; false, en caso contrario.</returns>
        public bool CasillaVacia(PosicionCasilla casilla)
        {
            return casillas[(int)casilla - 1].EstaVacia();
        }
        /// <summary>
        /// Comprueba si la columna central está llena.
        /// </summary>
        /// <param name="marcaJugador">Marca del jugador a comprobar en la columna.</param>
        /// <returns>true si la columna está llena, false en caso contrario.</returns>
        public bool ColumnaCentralLlena(char marcaJugador)
        {
            if (casillas[1].ContieneMarca(marcaJugador) && casillas[4].ContieneMarca(marcaJugador) && casillas[7].ContieneMarca(marcaJugador))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Comprueba si la columna derecha está vacía.
        /// </summary>
        /// <param name="marcaJugador">Marca del jugador a comprobar en la columna.</param>
        /// <returns>true si la columna está llena, false en caso contrario.</returns>
        public bool ColumnaDerechaLlena(char marcaJugador)
        {
            if (casillas[2].ContieneMarca(marcaJugador) && casillas[5].ContieneMarca(marcaJugador) && casillas[8].ContieneMarca(marcaJugador))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Comprueba si la columna de la izquierda está llena.
        /// </summary>
        /// <param name="marcaJugador">Marca del jugador a comprobar en la columna.</param>
        /// <returns>true si la columna está llena, false en caso contrario.</returns>
        public bool ColumnaIzquierdaLlena(char marcaJugador)
        {
            if (casillas[0].ContieneMarca(marcaJugador) && casillas[3].ContieneMarca(marcaJugador) && casillas[6].ContieneMarca(marcaJugador))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Comprueba si la diagonal creciente está llena.
        /// </summary>
        /// <param name="marcaJugador">Marca del jugador a comprobar en la columna.</param>
        /// <returns>true si la diagonal está llena, false en caso contrario.</returns>
        public bool DiagonalCrecienteLlena(char marcaJugador)
        {
            if (casillas[6].ContieneMarca(marcaJugador) && casillas[4].ContieneMarca(marcaJugador) && casillas[2].ContieneMarca(marcaJugador))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Comprueba si la diagonal decreciente está llena.
        /// </summary>
        /// <param name="marcaJugador">Marca del jugador a comprobar en la columna.</param>
        /// <returns>true si la diagonal está llena, false en caso contrario.</returns>
        public bool DiagonalDecrecienteLlena(char marcaJugador)
        {
            if (casillas[0].ContieneMarca(marcaJugador) && casillas[4].ContieneMarca(marcaJugador) && casillas[8].ContieneMarca(marcaJugador))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Comprueba si la fila inferior está llena.
        /// </summary>
        /// <param name="marcaJugador">Marca del jugador a comprobar en la columna.</param>
        /// <returns>true si la columna está llena, false en caso contrario.</returns>
        public bool FilaInferiorLlena(char marcaJugador)
        {
            if (casillas[6].ContieneMarca(marcaJugador) && casillas[7].ContieneMarca(marcaJugador) && casillas[8].ContieneMarca(marcaJugador))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Comprueba si la fila media está llena.
        /// </summary>
        /// <param name="marcaJugador">Marca del jugador a comprobar en la columna.</param>
        /// <returns>true si la columna está llena, false en caso contrario.</returns>
        public bool FilaMediaLlena(char marcaJugador)
        {
            if (casillas[3].ContieneMarca(marcaJugador) && casillas[4].ContieneMarca(marcaJugador) && casillas[5].ContieneMarca(marcaJugador))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Comprueba si la fila superior está llena.
        /// </summary>
        /// <param name="marcaJugador">Marca del jugador a comprobar en la columna.</param>
        /// <returns>true si la columna está llena, false en caso contrario.</returns>
        public bool FilaSuperiorLlena( char marcaJugador)
        {
            if (casillas[0].ContieneMarca(marcaJugador) && casillas[1].ContieneMarca(marcaJugador) && casillas[2].ContieneMarca(marcaJugador))
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        /// <summary>
        /// Comprueba si un jugador (persona o PC) ha ganado el juego.
        /// </summary>
        /// <param name="marcaJugador">Marca del jugador a comprobar.</param>
        /// <returns>true si el jugador ha ganado el juego; false, en caso contrario.</returns>
        public bool GanoJuego(char marcaJugador)
        {
            return ( 
                    ColumnaCentralLlena(marcaJugador) || ColumnaDerechaLlena(marcaJugador) || ColumnaIzquierdaLlena(marcaJugador) || 
                    DiagonalDecrecienteLlena(marcaJugador) || DiagonalCrecienteLlena(marcaJugador) || 
                    FilaInferiorLlena(marcaJugador) || FilaMediaLlena(marcaJugador) || FilaSuperiorLlena(marcaJugador)
                );
        }
        /// <summary>
        /// Marca una casilla del tablero de triqui con la marca de un jugador.
        /// </summary>
        /// <param name="posicionCasilla">Casilla a marcar.</param>
        /// <param name="marcaJugador">Marca del jugador a comprobar.</param>
        public void MarcarCasilla(PosicionCasilla posicionCasilla, char marcaJugador)
        {
            casillas[(int)posicionCasilla - 1].Marca = marcaJugador;
        }
        /// <summary>
        /// Limpia el tablero para un nuevo juego.
        /// </summary>
        public void LimpiarTablero()
        {
            foreach(Casilla casilla in casillas)
            {
                casilla.Limpiar();
            }
        }
        /// <summary>
        /// Obtiene la marca sobre un casilla dada.
        /// </summary>
        /// <param name="posicionCasilla">Posición de la casilla a obtener la marca.</param>
        /// <returns>Marca del jugador en la casilla.</returns>
        public char ObtenerMarcaCasilla(PosicionCasilla posicionCasilla)
        {
            if (posicionCasilla != PosicionCasilla.Ninguna)
            {
                return casillas[(int)posicionCasilla - 1].Marca;
            }
            else
            {
                return Casilla.CASILLA_VACIA;
            }
        }
        /// <summary>
        /// Comprueba si el tablero de triqui está vacío.
        /// </summary>
        /// <returns>true si el tablero está vacío; en caso contrario, false.</returns>
        public bool TableroLleno()
        {
            foreach (Casilla casilla in casillas)
            {
                if (!casilla.EstaVacia())
                {
                    continue;
                }
                else
                {
                    return false;
                }
            }

            return true;
        }
        #endregion

        #region Puntos de extensión:
        /// <summary>
        /// Punto de extensión no. 1.
        /// </summary>
        /// <returns>Respuesta dada por el punto de extensión.</returns>
        public string Metodo1()
        {
            return "Respuesta 1";
        }
        /// <summary>
        /// Punto de extensión no. 2.
        /// </summary>
        /// <returns>Respuesta dada por el punto de extensión.</returns>
        public string Metodo2()
        {
            return "Respuesta 2";
        }
        #endregion
    }
}