evidencia3

src/edu/katheryn_azano/evidencia3/Main.java

@@ -0,0 +1,16 @@
+package edu.katheryn_azano.evidencia3;
+
+import edu.katheryn_azano.evidencia3.process.JuegoGato;
+import edu.katheryn_azano.evidencia3.ui.CLI;
+
+import static edu.katheryn_azano.evidencia3.ui.CLI.launchApp;
+
+public class Main {
+    public static void main(String[] args) {
+        try{
+            launchApp();
+        } catch (Exception e){ //si el usuario ingresa una respuesta que no se puede procesar les arroja "Error inesperado"
+            System.out.println("Error inesperado"+e);
+        }
+    }
+}

src/edu/katheryn_azano/evidencia3/data/PuntajesJugador.java

@@ -0,0 +1,39 @@
+package edu.katheryn_azano.evidencia3.data;
+
+import edu.katheryn_azano.evidencia3.process.Persona;
+
+public class PuntajesJugador {
+    private String nombre;
+    private String simbolo;
+    private String puntaje;
+
+    public PuntajesJugador(String nombre, String simbolo, String puntaje) {
+        this.nombre = nombre;
+        this.simbolo = simbolo;
+        this.puntaje = puntaje;
+    }
+
+    public String getNombre() {
+        return nombre;
+    }
+
+    public void setNombre(String nombre) {
+        this.nombre = nombre;
+    }
+
+    public String getSimbolo() {
+        return simbolo;
+    }
+
+    public void setSimbolo(String simbolo) {
+        this.simbolo = simbolo;
+    }
+
+    public String getPuntaje() {
+        return puntaje;
+    }
+
+    public void setPuntaje(String puntaje) {
+        this.puntaje = puntaje;
+    }
+}

src/edu/katheryn_azano/evidencia3/process/Computadora.java

@@ -0,0 +1,121 @@
+package edu.katheryn_azano.evidencia3.process;
+
+import java.util.Random;
+
+class Computadora extends Jugador {
+    static String[] simbolos = {"X", "O", "#", "*", "@", "&", "$", "!", "?", "+"};
+
+    /**
+     * Constructor
+     */
+    public Computadora(String simbolo) {
+       //Genera un simbolo random para la computadora en cada partida
+        super("Computadora", simbolos[new Random().nextInt(simbolos.length)]);
+    }
+
+    /**
+     * Metodo jugada de la computadora para ir vs persona
+     * @param tablero para las jugadas
+     * @return en dado caso de que no se este en algun posible ganador generar un empate
+     */
+    public boolean jugada(Tablero tablero) {
+        // Intentar ganar en la siguiente jugada
+        if (realizarJugadaGanadora(tablero, getSimbolo())) {
+            return true;
+        }
+
+        // Intentar bloquear al jugador humano
+        if (realizarJugadaGanadora(tablero, getSimboloContrario())) {
+            return true;
+        }
+
+        // Si no se encontraron jugadas ganadoras, realizar una jugada aleatoria
+        return realizarJugadaAleatoria(tablero);
+    }
+
+
+    /**
+     * Metodo para que en caso de que solo le falte un simbolo para
+     * ganar, se enfoque de colocarlo ahi en caso de que no fuer bloqueado
+     * por el jugador o en su turno solo falta esa casilla de maracar
+     * @param tablero isntancia del tablero
+     * @param simbolo de la computadora
+     * @return true para realizar la jugada ganadora
+     */
+    private boolean realizarJugadaGanadora(Tablero tablero, String simbolo) {
+        // Buscar una jugada ganadora
+        for (int fila = 0; fila < tablero.getFilas(); fila++) {
+            for (int columna = 0; columna < tablero.getColumnas(); columna++) {
+                if (tablero.esCasillaVacia(fila, columna)) {
+                    // Intentar realizar la jugada en esta casilla
+                    tablero.marcarCasilla(fila, columna, simbolo);
+                    if (tablero.hayGanador(simbolo)) {
+                        // La jugada es ganadora, dejar la ficha en esta casilla y retornar true
+                        return true;
+                    }
+                    // Deshacer la jugada para probar la siguiente casilla
+                    tablero.limpiarCasilla(fila, columna);
+                }
+            }
+        }
+
+        // Si no hay una jugada ganadora, verificar si el oponente puede ganar en el siguiente movimiento y bloquearlo
+        String simboloOponente = getSimboloContrario();
+        for (int fila = 0; fila < tablero.getFilas(); fila++) {
+            for (int columna = 0; columna < tablero.getColumnas(); columna++) {
+                if (tablero.esCasillaVacia(fila, columna)) {
+                    // Intentar realizar la jugada en esta casilla para bloquear al oponente
+                    tablero.marcarCasilla(fila, columna, simboloOponente);
+                    if (tablero.hayGanador(simboloOponente)) {
+                        // Si el oponente puede ganar en su siguiente movimiento, bloquearlo
+                        tablero.limpiarCasilla(fila, columna); // Deshacer la jugada del bloqueo
+                        tablero.marcarCasilla(fila, columna, simbolo); // Realizar la jugada ganadora
+                        return true;
+                    }
+                    // Deshacer la jugada para probar la siguiente casilla
+                    tablero.limpiarCasilla(fila, columna);
+                }
+            }
+        }
+        // No se encontró una jugada ganadora
+        return false;
+    }
+
+    /**
+     *  Metodo para realizar una jugada aleatoria solo en una casilla vacia, sin necesidad
+     *  de ir por ganar
+     * @param tablero instancia del tablero
+     * @return true para el movimiento
+     */
+    private boolean realizarJugadaAleatoria(Tablero tablero) {
+        // Realizar una jugada aleatoria en una casilla vacía
+        int fila, columna;
+        do {
+            fila = new Random().nextInt(tablero.getFilas());
+            columna = new Random().nextInt(tablero.getColumnas());
+        } while (!tablero.esCasillaVacia(fila, columna));
+
+        // Realizar la jugada en el tablero
+        tablero.marcarCasilla(fila, columna, getSimbolo());
+
+        return true;
+    }
+
+    /**
+     * Metodo para que la computadora obtenga el simbolo contrario
+     * y no juege con el mismo
+     * @return simbolo del jugador
+     */
+    private String getSimboloContrario() {
+        // Obtener el símbolo contrario al de la computadora
+        String simboloComputadora = getSimbolo();
+        for (String simbolo : simbolos) {
+            //verifica que en la lista de simbolos no salgan dos repetidos
+            //(el del humano y la computadora)
+            if (!simbolo.equals(simboloComputadora)) {
+                return simbolo;
+            }
+        }
+        return null; // Nunca debería llegar aquí
+    }
+}

src/edu/katheryn_azano/evidencia3/process/JuegoGato.java

@@ -0,0 +1,110 @@
+package edu.katheryn_azano.evidencia3.process;
+
+import edu.katheryn_azano.evidencia3.data.PuntajesJugador;
+import edu.katheryn_azano.evidencia3.ui.Idiomas;
+
+import java.util.*;
+
+import static edu.katheryn_azano.evidencia3.process.Computadora.simbolos;
+
+public class JuegoGato {
+    public static final String[] simbolos = {"X", "O", "#", "*", "@", "&", "$", "!", "?", "+"};
+
+    private Tablero tablero;
+    private Persona jugador1;
+    private Persona jugador2;
+    private Idiomas idioma;
+
+    public JuegoGato(Idiomas idioma) {
+        this.tablero = new Tablero();
+        this.idioma = idioma;
+        this.jugador1 = null;
+        this.jugador2 = null;
+    }
+
+    /**
+     * Metodo para generar el turno de manera aleatoria para el modo
+     * Jugador vs Jugador
+     * @param jugador1 nombre y simbolo ingresado por usuario
+     * @param jugador2 nombre y simbolo ingresado por usuario
+     */
+    public static void generarTurnoPersona(Jugador jugador1, Jugador jugador2){
+        Tablero tablero = new Tablero();
+        Random random = new Random();
+        boolean turnoJugador = random.nextBoolean();
+        boolean inGame = true;
+        while (inGame) {
+            if (turnoJugador) {
+                System.out.println(Idiomas.COMIENZA + " " + jugador1.getNombre() + " (" + jugador1.getSimbolo() + ").");
+                inGame = jugador1.jugada(tablero);
+                System.out.println(Idiomas.TERMINA_TURNO);
+                turnoJugador = false;
+            } else {
+                System.out.println( Idiomas.COMIENZA + " " + jugador2.getNombre() + " (" + jugador2.getSimbolo() + ").");
+                inGame = jugador2.jugada(tablero);
+                System.out.println(Idiomas.TERMINA_TURNO);
+                turnoJugador = true;
+            }
+        }
+    }
+
+    /**
+     * Metodo para generar el turno de manera aleatoria para el modo
+     * Jugador vs Computadora
+     * @param persona instancia de Jugador con el nombre y simbolo ingresado
+     * por usuario
+     */
+    public static void generarTurnoComputadora(Jugador persona){
+        Tablero tablero = new Tablero();
+        Jugador computadora = new Computadora(simbolos[new Random().nextInt(simbolos.length)]);
+        Random random = new Random();
+        boolean turnoJugador = random.nextBoolean();
+
+        // Mostrar quién comienza primero
+        if (turnoJugador) {
+            System.out.println(Idiomas.COMIENZA + " " + persona.getNombre() + " (" + persona.getSimbolo() + ").");
+        } else {
+            System.out.println(Idiomas.COMIENZA + " " + computadora.getNombre() + " (" + computadora.getSimbolo() + ").");
+        }
+
+        while (true) {
+            if (turnoJugador) {
+                // Turno del jugador humano
+                System.out.println(Idiomas.TURNO);
+                if (!persona.jugada(tablero)) {
+                    break; // El jugador ha terminado el juego
+                }
+            } else {
+                // Turno de la computadora
+                System.out.println(Idiomas.TURNO_COMPUTADORA);
+                if (!computadora.jugada(tablero)) {
+                    break; // La computadora ha terminado el juego
+                }
+            }
+
+            // Mostrar el tablero después de cada jugada
+            tablero.mostrarTablero();
+
+            // Verificar si hay un ganador o si el tablero está lleno
+            if (tablero.hayGanador(persona.getSimbolo())) {
+                System.out.println(Idiomas.FELICITACION);
+                persona.sumarVictoria();
+                System.out.println("Se sumó");
+                break;
+            } else if (tablero.hayGanador(computadora.getSimbolo())) {
+                System.out.println(Idiomas.COMPUTADORA_GANADORA);
+                break;
+            } else if (tablero.estaLleno()) {
+                System.out.println(Idiomas.EMPATE);
+                break;
+            }
+
+            // Alternar el turno para la siguiente jugada
+            turnoJugador = !turnoJugador;
+        }
+
+        // Mostrar el tablero final
+        tablero.mostrarTablero();
+    }
+
+}

src/edu/katheryn_azano/evidencia3/process/Jugador.java

@@ -0,0 +1,51 @@
+package edu.katheryn_azano.evidencia3.process;
+
+
+public abstract class Jugador {
+    private String nombre;
+    private String simbolo;
+    private int victorias;
+
+    public Jugador(String nombre, String simbolo) {
+        this.nombre = nombre;
+        this.simbolo = simbolo;
+        this.victorias = 0;
+    }
+
+
+    public String getSimbolo() {
+        return simbolo;
+    }
+
+    public void setSimbolo(String simbolo) {
+        this.simbolo = simbolo;
+    }
+
+    public String getNombre() {
+        return nombre;
+    }
+
+    public void setNombre(String nombre) {
+        this.nombre = nombre;
+    }
+
+    public void sumarVictoria() {
+        this.victorias++;
+    }
+
+    public String getVictorias() {
+        return String.valueOf(victorias);
+    }
+
+    public boolean jugada(Tablero tablero){
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "PuntajesJugador " +
+                "nombre:'" + nombre + '\'' +
+                ",simbolo:'" + simbolo + '\'' +
+                ",puntaje:" + victorias ;
+    }
+}