Tarea #5 [solución]

Juego del Gato (Tic Tac Toe)

      Complete esta implementación del juego del Gato.

http://www.publijuegos.com/flash/Tic-Tac-Toe.htm

      Para esta tarea programada usted debe enviarme estos archivos:

1. Gato.java
2. CARNET.docx

      En el documento CARNET.docx deben describir su experiencia de aprendizaje para completar esta tarea. Explique qué hizo, cómo lo hizo y por qué lo hizo.

/**
    @(#)Gato.java 2011,2012
    Juego del Gato 3x3 o 5x5 (Tic Tac Toe).
    @author Adolfo Di Mare <adolfo@di-mare.com>
*/

import java.io.*;         // Clases para leer del teclado
import java.util.Scanner; // Clases para leer del teclado
import java.util.Random;  // Clases para números aleatorios

/** Contiene un tablero para jugar Gato 3x3 o 5x5 (Tic Tac Toe). */
public class Gato {
    /** Identifica la persona que juega contra el computador. */
    static public final char JUGADOR = 'X';
    /** Identifica al computador como jugador. */
    static public final char COMPU = 'O';

    /** El tablero para el Gato. */
    private char m_Tablero[][];
    /** Cantidad de jugadas realizadas. */
    private int m_jugadas;

    /** Constructor. */
    public Gato() {
        clear();
    }

    /** Restablece el tablero. Lo deja vacío, sin jugadas.
      * Equivalente a {@code set(3)}.
      */
    public void clear() {
        m_Tablero = new char[][] {
            { 'a' , 'b', 'c' } ,
            { 'd' , 'e', 'f' } ,
            { 'g' , 'h', 'i' }
        };
        m_jugadas = 0;
    }

    /** Restablece el tablero. Lo deja vacío, sin jugadas.
      * Las dimensiones posible para el juego son {@code N==3} o {@code N==5}.
      */
    public void set( int N ) {
        N = ( N==5 ? 5 : 3 ); // otros valores no tienen sentido
        m_Tablero = new char[N][N];

        int desplazamiento = 0;       // genera una jugada
        for ( int i=0; i<m_Tablero.length; ++i ) { // fija la fila
            for ( int j=0; j<m_Tablero[i].length; ++j ) { // varía la columna
                int letra = (int)('a') + desplazamiento;
                m_Tablero[i][j] = (char)(letra);
                desplazamiento++;
            }
        }
        m_jugadas = 0;
    }

    /** Retorna {@code true} cuando {@code quien} ya ganó una fila.
      * Esto quiere decir que en el tablero hay una fila en que todas
      * las fichas son {@code quien}.
      */
    private boolean ganaFilas( char quien ) {
        for ( int i=0; i<m_Tablero.length; ++i ) { // fija la fila
            { /* *** RELLENE CON SU ALGORITMO *** */
            }
        }
        return false;
    }

    /** Retorna {@code true} cuando {@code quien} ya ganó una columna.
      * Esto quiere decir que en el tablero hay una columna en que todas
      * las fichas son {@code quien}.
      */
    private boolean ganaColumnas( char quien ) {
        for ( int j=0; j<m_Tablero[0].length; ++j ) { // fija la columna
            { /* *** RELLENE CON SU ALGORITMO *** */
            }
        }
        return false;
    }

    /** Retorna {@code true} cuando {@code quien} ya ganó una diagonal.
      * Esto quiere decir que en el tablero hay una diagonal en que todas
      * las fichas son {@code quien}.
      */
    private boolean ganaDiagonales( char quien ) {
        // primero revisa la diagonal
        { /* *** RELLENE CON SU ALGORITMO *** */
        }

        // revisa la tras-diagonal
        { /* *** RELLENE CON SU ALGORITMO *** */
        }

        return false;
    }

    /** Retorna {@code true} cuando ya no se pueden hacer más jugadas. */
    private boolean terminado() {
        return (m_jugadas == m_Tablero.length * m_Tablero[0].length);
    }

    /** Genera la jugada del computador.
      * La jugada es una jugada aleatoria, sin estrategia alguna,
      * generada a partir de valores retornados por {@code rand}.
      * @return Retorna {@code true} si hizo la jugada, y {@code false} en caso contrario.
      */
    private boolean genereJugada( Random rand ) {
        if ( terminado() ) { return false; } // ya se acabó el juego
        int DIM = m_Tablero.length * m_Tablero[0].length; // Tamaño del tablero

        boolean terminado = false; // todavía no ha terminado
        int     contador  = 1000;  // cantidad de veces que trata de generar la jugada
        while ( !terminado ) {
            int desplazamiento = rand.nextInt(DIM);    // genera una jugada
            int jugada = (int)('a') + desplazamiento;  // la convierte a (char)

            if ( hagaJugada( (char)(jugada), COMPU ) ) {
                return true;
            }

            contador--;
            terminado = (contador==0);
        }
        return false;
    }

    /** Hace la jugada del jugador {@code quien}.
      * @return Retorna {@code true} si hizo la jugada,
      * y {@code false} en caso contrario.
      */
    private boolean hagaJugada( char jugada , char quien ) {
        for ( int i=0; i<m_Tablero.length; ++i ) { // fija la fila
            for ( int j=0; j<m_Tablero[i].length; ++j ) { // varía la columna
                if ( m_Tablero[i][j] == jugada ) {
                    m_Tablero[i][j] = quien;
                    m_jugadas++;
                    return true;
                }
            }
        }
        return false;
    }

    /** Elimina del tablero todas las letras de posición.
      * Las sustitutye por un espacio en blanco.
      */
    private void borraLetras() {
        for ( int i=0; i<m_Tablero.length; ++i ) { // fija la fila
            for ( int j=0; j<m_Tablero[i].length; ++j ) { // varía la columna
                if ( m_Tablero[i][j] != COMPU && m_Tablero[i][j] != JUGADOR ) {
                    m_Tablero[i][j] = ' ';
                }
            }
        }
    }

    /** Retorna {@code true} si ganó la computadora. */
    private boolean ganaCOMPU() {
        { /* *** RELLENE CON SU ALGORITMO *** */
        }
        return false;
    }
    /** Retorna {@code true} si ganó el jugador. */
    private boolean ganaJUGADOR() {
        { /* *** RELLENE CON SU ALGORITMO *** */
        }
        return false;
    }

    /** Graba el tablero en la salida {@code OUT}. */
    private void grabeTablero( PrintStream OUT ) {
        for ( int i=0; i<m_Tablero.length; ++i ) {
            for ( int j=0; j<m_Tablero.length; ++j ) {
                OUT.print( "+---" );
            }
            OUT.print( "+\n" );

            for ( int j=0; j<m_Tablero[0].length; ++j ) {
                OUT.print( "| " +  m_Tablero[i][j] + " " );
            }
            OUT.print( "|\n" );
        }
        for ( int j=0; j<m_Tablero.length; ++j ) {
            OUT.print( "+---" );
        }
        OUT.print( "+\n" );
    }

    /** Rutina que juega el Gato. */
    public void juegue( Random rand , Scanner sc ) throws IOException {
        char ch;
        boolean sigueEmpatado = true; // ... hasta que alguien gane

        do {
            grabeTablero( System.out );
            do { // no acepta jugadas inválidas
                ch = sc.nextLine().charAt(0);
            } while ( !hagaJugada( ch , JUGADOR ) );
            genereJugada( rand );
            if ( ganaCOMPU() ) {
                borraLetras();
                grabeTablero( System.out );
                System.out.print( "\n CHAPA!!! Te gane" );
                sigueEmpatado = false; // ya alguien ganó
                break;
            }
            else if ( ganaJUGADOR() ) {
                borraLetras();
                grabeTablero( System.out );
                System.out.print( "\n Te concedo que tuviste suerte y ganaste... " );
                sigueEmpatado = false;
                break;
            }
        } while ( ! terminado() );

        if ( sigueEmpatado ) {
            grabeTablero( System.out );
            System.out.print( "\n Ni tu ni yo..." );
        }

        return;
    }  // juegue()
} // Gato

// EOF: Gato.java

/**
    @(#)MainGato.java 2011,2012
    Programa principal para el juego del Gato.
    @author Adolfo Di Mare <adolfo@di-mare.com>
*/

import java.io.*;         // Clases para leer del teclado
import java.util.Scanner; // Clases para leer del teclado
import java.util.Random;  // Clases para números aleatorios

/** Contiene el método {@code main()} del programa del Gato. */
public class MainGato {
    /** Programa principal.
      * OJO: tira la excepción <code>IOException</code> cuando {@code System.in} no funciona.
      */
    public static void main( String args[] ) throws IOException {
    /** Programa principal.
      * OJO: tira la excepción <code>IOException</code> cuando {@code System.in} no funciona.
      */
        Random rand = new Random( 123456789 );
        Scanner sc = new Scanner(System.in); // System.in es la consola (teclado)
        System.out.print( " 3x3 o 5x5 ??? " );
        char ch = sc.nextLine().charAt(0);
        Gato G = new Gato();             // instancia del juego
        G.set( (int)(ch) - (int)('0') );
        G.juegue( rand,sc );
        sc.close(); // Cierra la consola de lectura
    }

} // MainGato

// EOF: MainGato.java

      Entregue su tarea por correo electrónico, como lo hizo anteriormente.

Entrega de Tareas

Soluciones

Adolfo Di Mare <adolfo@di-mare.com>.
Copyright © 2011
Derechos de autor reservados © 2011