Software Guru Conference & Expo 2014

Juego "Gato" Hecho En Java!

Hola compañeros, como les comenté estoy aprendiendo a programar en Java e hice el juego "Gato" para ir practicando y aprendiendo las sintaxis del lenguaje, como podran ver por falta de experiencia y conocimiento resultaron demasiadas lineas de código para lo que hace el programa, pero bueno son cosas que debo mejorar y tambien hacer un código mucho menos enredoso =S, como sea dejo el código para quien guste probar el juego en consola y me den sus opiniones para mejorar, se aceptan criticas constructivas, no insultos jaja, y espero le sirva el código a los que como yo son nuevos programando.

ESPECIFICACIONES DEL JUEGO:

En sí es algo muy sencillo, solo pueden tirar 2 jugadores humanos, no tiene la opción para que juegues contra la máquina, hay que volver a correr el programa de nuevo cada vez que gana alguno de los jugadores gana o se empata.

PD: Dejé comentarios dentro del programa especificando alguna de las funciones de los métodos que cree, para que el que se tome la molestia de checarlo se pierda en mi laberinto de código lo menos posible jaja, gracias por leer saludos!.

PD2: Dejo un adjunto con el código del programa, por alguna razon cuando le doy en "leer más" no sé ve mi post completo :S.

 /*AUTOR: LEONARDO J.L. 28/08/2009
  GATO VER 1.0
  CODIGO FUENTE PARA LIBRE DISTRIBUCION jajaja*/

 
import java.io.*;
public class JuegoGato{

  //Variables.  
    public char [] [] tablero;
    public char jugadorUno;
    public char jugadorDos;
    public boolean turno;
    int contador;        

 //Constructor(Inicializa Variables).
    public JuegoGato(){
       
        tablero      = new char[3][3];               
        jugadorUno   = 'X';
        jugadorDos   = 'O';
        turno        = true;  //Si El Valor De "turno" Es Igual A "true" El Turno Es Del Jugador 1, De Lo Contrario Es Jugador 2.
        int contador = 0;     //Lleva Cuenta De Las Veces Que Han Participado Los Jugadores 1 y 2.
        inicializarTablero();  
    }
       
  //Inicia El Arreglo, Especifica El Numero Que Le Corresponde A Cada Casilla.
    public void inicializarTablero(){
       
        int posicion = 1;
       
        for(int i=0;i<3;i++){
               
                for(int j=0; j<3;j++){
                       
                        tablero[i][j] = Integer.toString(posicion).charAt(0);
                        posicion++;
                }                      
        }
    }
   
  //Imprime El Formato Del Tablero.
    public void imprimirTablero(){
               
        for(int i=0;i<3;i++){
               
                for(int j=0;j<3;j++){
                       
                        if(j<2)
                       
                                System.out.print(" " + tablero[i][j] + " |");
                       
                        else
                               
                                System.out.print(" " + tablero[i][j] + " ");
                                                               
                }
               
                if(i<2)
                       
                        System.out.println("\n-----------");                                                                   
        }
        System.out.println();
        System.out.println();
        System.out.println();
    }
   
  //Indica La Posicion Donde Se Ingresara El Dato Dentro Del Arreglo Por Medio De Parametros.  
    public void indicarPosicionArreglo (int a, int b, char c) {tablero [a][b]=c;}
  //Manipula el valor De La Variable "turno".  
    public void setTurno               (boolean d)            {turno         =d;}
  //Manipula el valor De La Variable "contador".  
    public void setContador            (int e)                {contador      =e;}
   
  //Regresa Valor De La Posicion Del Arreglo Indicada Por Medio De Parametros.  
    public char getPosicionArreglo (int a, int b)  {return tablero[a][b];}
       
  //Regresa Valor De La Variable "jugadorUno".
    public char getJugadorUno      ()  {return jugadorUno   ;}            
   
  //Regresa Valor De La Variable "jugadorDos".
    public char getJugadorDos      ()  {return jugadorDos   ;}            
 
  //Regresa Valor De La Variable "turno".
    public boolean getTurno        ()  {return turno        ;}
  //Regresa Valor De La Variable "contador".              
    public int getContador         ()  {return contador     ;}          
   
   
  //Imprime e Indica El El Turno Del Jugador Que Le Toca Elejir Una Casilla Con Ayuda del Metodo "getTurno()".
    public void indicarTurno(){
       
        if(getTurno()==true)
               
                System.out.println("JUGADOR 1: Elija Una Casilla Ingresando El Numero Correspondiente.");
               
        else
               
                System.out.println("JUGADOR 2: Elija Una Casilla Ingresando El Numero Correspondiente.");      
    }
   
  //Regresa El Caracter De Tipo Char Para Posteriormente Ingresarlo A Alguna Posicion Del Arreglo, Usandolo En Otro Metodo.
    public char obtenerFigura(){
       
        if(getTurno()==true)
               
                return jugadorUno;
               
        else
               
                return jugadorDos;     
    }
   
  //Cambia El Valor De La Variable "turno" Para Llevar El Orden Correcto De Los Turnos Entre Los 2 Jugadores.    
    public void cambiarTurno(){        
       
        if(obtenerFigura()=='X') //Si el Metodo regresa un valor char igual a "X" cambia el valor de "turno" a "false".
               
                setTurno(false);
       
        else
               
                setTurno(true);
    }
     
  //Verifica Si La Posicion Del Arreglo Al Que El Jugador Desea Ingresar El Caracter No Fue Utilizada Antes.  
    public void comprobarEspacio(char espacio, int posicionUno, int posicionDos){
     
      //Si Se Cumple La Condicion Se Ingresa El Valor En La Posicion Del Arreglo Especificada. 
        if(espacio!=getJugadorUno()&&espacio!=getJugadorDos()){
               
           indicarPosicionArreglo(posicionUno, posicionDos,obtenerFigura());//Ingresa EL Caracter Si Se Cumple La Condicion.
           cambiarTurno();                                                  //Cambia El Turno Si Se Cumple La Condicion.  
           contador++;                                                      //Solo Incremente Cuando Se Cumple La Anterior Condicion.              
        }
       
        else
         
         //Imprime El Siguiente Mensaje En Caso De Que No Se Cumpla La Anterior Condicion.                             
           System.out.println("La Casilla Esta Ocupada, Elija Otra Por Favor");                
    }
           
  //Metodo Que Hace Uso De Un "switch" Para Indicar La Posicion Del Arreglo Que El Jugador Elijio En El Juego.  
    public void elegirPosicion(int posicion){
                           
            switch(posicion){
               
                  //Comprueba Si La Posicion Esta Disponible Valiendose Del Metodo "comprobarEspacio()"
                        case 1:comprobarEspacio(getPosicionArreglo(0,0),0,0);break;
                        case 2:comprobarEspacio(getPosicionArreglo(0,1),0,1);break;
                        case 3:comprobarEspacio(getPosicionArreglo(0,2),0,2);break;
                        case 4:comprobarEspacio(getPosicionArreglo(1,0),1,0);break;
                        case 5:comprobarEspacio(getPosicionArreglo(1,1),1,1);break;
                        case 6:comprobarEspacio(getPosicionArreglo(1,2),1,2);break;
                        case 7:comprobarEspacio(getPosicionArreglo(2,0),2,0);break;
                        case 8:comprobarEspacio(getPosicionArreglo(2,1),2,1);break;
                        case 9:comprobarEspacio(getPosicionArreglo(2,2),2,2);break;
                        default:
                          //Imprime El Siguiente Mensaje En Caso De Que El "switch" No Reciba Un Digito Del 1 al 9.    
                                System.out.println("Por Favor, Ingrese Solo Un Digito Del 1 al 9.");break;                             
            }          
    }
   
  //Solo Imprime Un Mensaje Distinto Dependiendo Del Jugador Que Haya Resultado Ganador.
    public void decirGanador(char a){
       
       
        if(a=='X')
                               
                System.out.println("FIN DEL JUEGO: FELICIDADES JUGADOR 1!, HA GANADO!.");
       
               
        else if(a=='O')
                           
                    System.out.println("FIN DEL JUEGO: FELICIDADES JUGADOR 2!, HA GANADO!.");                      
               
                               
    }
   
 //Verifica Las Unicas 8 Combinaciones Que Pueden Dar La Victoria A Uno De Los Jugadores.
    public void buscarGanador(){
                 
      //Ciclo Con Instrucciones Para Comprobar Las 3 Posibilidades De Ganar De Forma Horizontal.
        for(int i=0;i<3;i++){
               
                for(int j=1;j<2;j++){
                       
                        if(tablero[i][j]==tablero[i][j-1]&&tablero[i][j]==tablero[i][j+1]){
                                                       
                           decirGanador(tablero[i][j]);
                           imprimirTablero();
                           setContador(10);
                        }                              
                }                      
        }
   
      //Ciclo Con Instrucciones Para Comprobar Las 3 Posibilidades De Ganar De Forma Vertical.  
        for(int i=0;i<3;i++){
               
                for(int j=1;j<2;j++){
                       
                        if(tablero[j][i]==tablero[j-1][i]&&tablero[j][i]==tablero[j+1][i]){
                       
                           decirGanador(tablero[j][i]);
                           imprimirTablero();
                           setContador(10);
                        }                              
                }
        }
       
      //Instrucciones Para Comprobar La Unica Posibilidad De Ganar De Forma Diagonal.  
        if(tablero[1][1]==tablero[0][0]&&tablero[1][1]==tablero[2][2]){
       
           decirGanador(tablero[1][1]);
           imprimirTablero();
           setContador(10);
        }  
           
      //Ciclo Con Instrucciones Para Comprobar La Unica Posibilidade De Ganar De Forma Diagonal Inversa.
        if(tablero[1][1]==tablero[0][2]&&tablero[1][1]==tablero[2][0]){
               
           decirGanador(tablero[1][1]);
           imprimirTablero();                  
           setContador(10);
        }      
    }    
       
  //Metodo Que Contiene El Flujo Y El Orden Del Juego.
    public void jugarGato(){
       
        BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
       
        System.out.println("BIENVENIDO A GATO Ver. 1.0");      
               
        do{
       
                indicarTurno();                
                imprimirTablero();     
                try{elegirPosicion(Integer.parseInt(entrada.readLine()));}
                catch(IOException e){}    
                catch(NumberFormatException e){
                       
                        if(getTurno()==true)
                           
                           System.out.println("ERROR!: Ingreso Un Caracter No Valido, Por Favor, Intente Nuevamente JUGADOR 1.");
                       
                        else
                               
                           System.out.println("ERROR!: Ingreso Un Caracter No Valido, Por Favor, Intente Nuevamente JUGADOR 2.");      
                }
                         
                buscarGanador();
       
        }while(getContador()<9);
       
          if(getContador()==9){
               
                System.out.println("¡GATO!¡JUEGO EMPATADO!");                                        
            imprimirTablero();
            System.out.println("THANKS FOR PLAYING!");             
          }
         
         System.out.println("THANKS FOR PLAYING!");            
    }
   
    public static void main(String [] args){
       
        JuegoGato Objeto = new JuegoGato();
       
        Objeto.jugarGato();    
                                                                                       
    }    
}

AdjuntoTamaño
JuegoGato.txt9.19 KB

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de Leonardo

Por favor, alguien que me de

Necesito que chequen el programita que hice y me den su opinion, estoy aprendiendo a programar.
Necesito consejos de que cosas debo mejorar, gracias por adelantado.

-----------------EDITED--------------
Administrador por favor elimine este post que hice, no obtuve los consejos que queria, y por alguna razon no puedo ver todo lo que escribi en el post, solo veo el link del archivo adjunto, gracias.

gracias = soy novato en esto

gracias = soy novato en esto me ayudo mucho tu codigo.

Imagen de Shadonwk

hola @Leonardo yo sí quisiera

hola @Leonardo yo sí quisiera hacerte una recomendación y es muy sencilla para empezar:

Trata de no dejar tantos espacios en blanco sin que sean necesarios:

tu código

//Ciclo Con Instrucciones Para Comprobar Las 3 Posibilidades De Ganar De Forma Vertical.  
        for(int i=0;i<3;i++){
               
                for(int j=1;j<2;j++){
                       
                        if(tablero[j][i]==tablero[j-1][i]&&tablero[j][i]==tablero[j+1][i]){
                       
                           decirGanador(tablero[j][i]);
                           imprimirTablero();
                           setContador(10);
                        }                              
                }
        }

podria ser:

//Ciclo Con Instrucciones Para Comprobar Las 3 Posibilidades De Ganar De Forma Vertical.  
        for(int i=0;i<3;i++){              
                for(int j=1;j<2;j++){                      
                        if(tablero[j][i]==tablero[j-1][i]&&tablero[j][i]==tablero[j+1][i]){                      
                              decirGanador(tablero[j][i]);
                              imprimirTablero();
                             setContador(10);
                        }                              
                }
        }

otra recomendación aunque mas que recomendación seria un reto, es que intentes hacer el mismo juego pero con una interfaz gráfica, ahí encontraras cosas que tienes que aprender.. en cuanto al código esta bien, dicen que: "la practica hace al maestro"..

chin otra vez contestando un post de hace un año jaja ni pex...espero que a alguien le sirva..

Imagen de Sr. Negativo

Tu código...esta bien

@Leonardo
Necesito que chequen el programita que hice y me den su opinion, estoy aprendiendo a programar.

Para ser novato en Java, sabes programar mejor que muchos que conozco

Imagen de Shadonwk

creo que Sr. Negativo no leyó

creo que Sr. Negativo no leyó la ultima linea de mi comentario anterior XP

Imagen de OscarRyz

@Shadownk Año y medio en realidad

Pero igual vale.

Lo único que podría mencionar es que los if's else's siempre deben de ir con llaves aunque sean de una línea.

A veces, usar el operador ternario da código más breve, pero no todo mundo está acostumbrado a él ( bueno a esta altura ya deberían ).

Lo mismo sucede con las comprobaciones, if( x == true ) , aunque son correctas, lo más acostumbrado es escribir if( x )

Acá va el mismo programa con eso corregido.

/*AUTOR: LEONARDO J.L. 28/08/2009
  GATO VER 1.0.
  CODIGO FUENTE PARA LIBRE DISTRIBUCION jajaja*/

 
import java.io.*;
public class JuegoGato {

  //Variables.  
  public char [] [] tablero;
  public char jugadorUno;
  public char jugadorDos;
  public boolean turno;
  int contador;    
 
 //Constructor(Inicializa Variables).
  public JuegoGato() {
    tablero    = new char[3][3];        
    jugadorUno   = 'X';
    jugadorDos   = 'O';
    turno    = true;  //Si El Valor De "turno" Es Igual A "true" El Turno Es Del Jugador 1, De Lo Contrario Es Jugador 2.
    int contador = 0;   //Lleva Cuenta De Las Veces Que Han Participado Los Jugadores 1 y 2.
    inicializarTablero();  
  }
 
  //Inicia El Arreglo, Especifica El Numero Que Le Corresponde A Cada Casilla.
  public void inicializarTablero(){
    int posicion = 1;
    for(int i=0;i<3;i++){
      for(int j=0; j<3;j++){
        tablero[i][j] = Integer.toString(posicion).charAt(0);
        posicion++;
      }        
    }
  }
 
  //Imprime El Formato Del Tablero.
  public void imprimirTablero(){
         
    for(int i=0;i<3;i++){
      for(int j=0;j<3;j++){
        if(j<2) {
          System.out.print(" " + tablero[i][j] + " |");
         } else {
          System.out.print(" " + tablero[i][j] + " ");
         }
      }
     
      if(i<2) {        
        System.out.println("\n-----------");                    
      }
    }
    System.out.println();
    System.out.println();
    System.out.println();
  }
 
  //Indica La Posicion Donde Se Ingresara El Dato Dentro Del Arreglo Por Medio De Parametros.  
  public void indicarPosicionArreglo (int a, int b, char c) {tablero [a][b]=c;}
  //Manipula el valor De La Variable "turno".  
  public void setTurno         (boolean d)      {turno     =d;}
  //Manipula el valor De La Variable "contador".  
  public void setContador      (int e)        {contador    =e;}
 
  //Regresa Valor De La Posicion Del Arreglo Indicada Por Medio De Parametros.  
  public char getPosicionArreglo (int a, int b)  {return tablero[a][b];}
   
  //Regresa Valor De La Variable "jugadorUno".
  public char getJugadorUno    ()  {return jugadorUno   ;}      
   
  //Regresa Valor De La Variable "jugadorDos".
  public char getJugadorDos    ()  {return jugadorDos   ;}      
 
  //Regresa Valor De La Variable "turno".
  public boolean getTurno    ()  {return turno    ;}
  //Regresa Valor De La Variable "contador".        
  public int getContador     ()  {return contador   ;}      
 
 
  //Imprime e Indica El El Turno Del Jugador Que Le Toca Elejir Una Casilla Con Ayuda del Metodo "getTurno()".
  public void indicarTurno(){
    System.out.println( "JUGADOR "+(getTurno()?"1":"2")+": Elija Una Casilla Ingresando El Numero Correspondiente.");
    /*
    if(getTurno()==true) {
      System.out.println("JUGADOR 1: Elija Una Casilla Ingresando El Numero Correspondiente.");
     } else {
      System.out.println("JUGADOR 2: Elija Una Casilla Ingresando El Numero Correspondiente.");    
    }*/

  }
 
  //Regresa El Caracter De Tipo Char Para Posteriormente Ingresarlo A Alguna Posicion Del Arreglo, Usandolo En Otro Metodo.
  public char obtenerFigura(){
    return getTurno() ? jugadorUno : jugadorDos;
    /*
    if(getTurno()==true) {      
      return jugadorUno;      
    } else {      
      return jugadorDos;  
    }
    */

  }
 
  //Cambia El Valor De La Variable "turno" Para Llevar El Orden Correcto De Los Turnos Entre Los 2 Jugadores.  
  public void cambiarTurno(){    
    setTurno(obtenerFigura() != 'X' );
    /*
    if(obtenerFigura()=='X') {//Si el Metodo regresa un valor char igual a "X" cambia el valor de "turno" a "false".
      setTurno(false);
    } else {
      setTurno(true);  
    }
    */

  }
   
  //Verifica Si La Posicion Del Arreglo Al Que El Jugador Desea Ingresar El Caracter No Fue Utilizada Antes.  
  public void comprobarEspacio(char espacio, int posicionUno, int posicionDos){
   
    //Si Se Cumple La Condicion Se Ingresa El Valor En La Posicion Del Arreglo Especificada.  
    if(espacio!=getJugadorUno()&&espacio!=getJugadorDos()){
       
       indicarPosicionArreglo(posicionUno, posicionDos,obtenerFigura());//Ingresa EL Caracter Si Se Cumple La Condicion.
       cambiarTurno();                          //Cambia El Turno Si Se Cumple La Condicion.  
       contador++;                            //Solo Incremente Cuando Se Cumple La Anterior Condicion.      
    } else {
     //Imprime El Siguiente Mensaje En Caso De Que No Se Cumpla La Anterior Condicion.            
       System.out.println("La Casilla Esta Ocupada, Elija Otra Por Favor");          
    }
  }
         
  //Metodo Que Hace Uso De Un "switch" Para Indicar La Posicion Del Arreglo Que El Jugador Elijio En El Juego.  
  public void elegirPosicion(int posicion){
               
      switch(posicion){
     
        //Comprueba Si La Posicion Esta Disponible Valiendose Del Metodo "comprobarEspacio()"
        case 1:comprobarEspacio(getPosicionArreglo(0,0),0,0);break;
        case 2:comprobarEspacio(getPosicionArreglo(0,1),0,1);break;
        case 3:comprobarEspacio(getPosicionArreglo(0,2),0,2);break;
        case 4:comprobarEspacio(getPosicionArreglo(1,0),1,0);break;
        case 5:comprobarEspacio(getPosicionArreglo(1,1),1,1);break;
        case 6:comprobarEspacio(getPosicionArreglo(1,2),1,2);break;
        case 7:comprobarEspacio(getPosicionArreglo(2,0),2,0);break;
        case 8:comprobarEspacio(getPosicionArreglo(2,1),2,1);break;
        case 9:comprobarEspacio(getPosicionArreglo(2,2),2,2);break;
        default:
          //Imprime El Siguiente Mensaje En Caso De Que El "switch" No Reciba Un Digito Del 1 al 9.  
          System.out.println("Por Favor, Ingrese Solo Un Digito Del 1 al 9.");break;          
      }    
  }
 
  //Solo Imprime Un Mensaje Distinto Dependiendo Del Jugador Que Haya Resultado Ganador.
  public void decirGanador(char a){
   
    System.out.println("FIN DEL JUEGO: FELICIDADES JUGADOR "+(a == 'X' ? "1": "2" )+"!, HA GANADO!.");
    /*
    if(a=='X') {
      System.out.println("FIN DEL JUEGO: FELICIDADES JUGADOR 1!, HA GANADO!.");
     } else if(a=='O') {
        System.out.println("FIN DEL JUEGO: FELICIDADES JUGADOR 2!, HA GANADO!.");        
     }*/

  }
 
 //Verifica Las Unicas 8 Combinaciones Que Pueden Dar La Victoria A Uno De Los Jugadores.
  public void buscarGanador(){
         
    //Ciclo Con Instrucciones Para Comprobar Las 3 Posibilidades De Ganar De Forma Horizontal.
    for(int i=0;i<3;i++){
      for(int j=1;j<2;j++){
        if(tablero[i][j]==tablero[i][j-1]&&tablero[i][j]==tablero[i][j+1]){
           decirGanador(tablero[i][j]);
           imprimirTablero();
           setContador(10);
        }          
      }        
    }
   
    //Ciclo Con Instrucciones Para Comprobar Las 3 Posibilidades De Ganar De Forma Vertical.  
    for(int i=0;i<3;i++){
      for(int j=1;j<2;j++){
        if(tablero[j][i]==tablero[j-1][i]&&tablero[j][i]==tablero[j+1][i]){
           decirGanador(tablero[j][i]);
           imprimirTablero();
           setContador(10);
        }            
      }
    }
   
    //Instrucciones Para Comprobar La Unica Posibilidad De Ganar De Forma Diagonal.  
    if(tablero[1][1]==tablero[0][0]&&tablero[1][1]==tablero[2][2]){
       decirGanador(tablero[1][1]);
       imprimirTablero();
       setContador(10);
    }  
       
    //Ciclo Con Instrucciones Para Comprobar La Unica Posibilidade De Ganar De Forma Diagonal Inversa.
    if(tablero[1][1]==tablero[0][2]&&tablero[1][1]==tablero[2][0]){
       decirGanador(tablero[1][1]);
       imprimirTablero();          
       setContador(10);
    }    
  }  
   
  //Metodo Que Contiene El Flujo Y El Orden Del Juego.
  public void jugarGato(){
   
    BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
   
    System.out.println("BIENVENIDO A GATO Ver. 1.0");    
     
    do{
      indicarTurno();        
      imprimirTablero();    
      try{elegirPosicion(Integer.parseInt(entrada.readLine()));}
      catch(IOException e){}  
      catch(NumberFormatException e){

        System.out.println("ERROR!: Ingreso Un Caracter No Valido, Por Favor, Intente Nuevamente JUGADOR " + (getTurno()?"1":"2"));        
       /*
        if(getTurno()==true) {
           System.out.println("ERROR!: Ingreso Un Caracter No Valido, Por Favor, Intente Nuevamente JUGADOR 1.");
         } else {
           System.out.println("ERROR!: Ingreso Un Caracter No Valido, Por Favor, Intente Nuevamente JUGADOR 2.");  
         }
        */

      }
         
      buscarGanador();
   
    } while(getContador()<9);
   
    if(getContador()==9){
      System.out.println("¡GATO!¡JUEGO EMPATADO!");              
      imprimirTablero();
      System.out.println("THANKS FOR PLAYING!");      
    }
     
     System.out.println("THANKS FOR PLAYING!");      
  }
 
  public static void main(String [] args){
    JuegoGato objeto = new JuegoGato();
    objeto.jugarGato();    
                                   
  }  
}

p.d. Recientemente he estado coqueteando con la identación a 2 espacios en vez de 4, no me parece que sea tran grave después de todo.

Imagen de Sr. Negativo

No, no lo lei....ups

chin otra vez contestando un post de hace un año jaja ni pex...espero que a alguien le sirva.
No @Shadonwk no lo lei.

Ni me fijé la fecha del post...ya vez @OscarRyz no es el único que contesta post de hace uno o dos años.

Gracias, ja ja ja la próxima me fijó bien

como lo ago para k se imprima en una ventana

disculpa soy novato en esto pero me gusta solo kiero saber como se ase para imprimir una ventana

Imagen de arterzatij

Buenooo!!!!

Jejejej hoy me puse de ocioso jejeje y aunq ue es un post algo viejo eee pues alguien querra ver que mas se le puede hacer e investigar que es l oque se le cambio al codigo...

Igual habra cosas que se le pueden ver mejor pero hoy fue lo que se me ocurrio....

/**AUTOR: LEONARDO J.L. 28/08/2009
  GATO VER 1.0
  CODIGO FUENTE PARA LIBRE DISTRIBUCION jajaja*/

package gato;

import java.io.*;

public class Gato {

        // Enum
        enum Turno {
                P1, P2
        }

        // Constantes
        private static final int MAX_POS = 9;
       
        private static final int COL_ROW = 3;

        private static final char JUGADOR_UNO = 'X';

        private static final char JUGADOR_DOS = 'O';
       
        private static final char NO_GANADOR = 'N';
       
        private static final String FILA = " %s | %s | %s ";
       
        private static final String LINEA = "\n-----------\n";
       
        private static final String ERROR = "ERROR!: Ingreso Un Caracter No Valido, Por Favor, Intente Nuevamente JUGADOR ";
       
        private static final String GANADOR = "FIN DEL JUEGO: FELICIDADES %s!, HA GANADO!.";
       
        private static final String TURNO = ": Elija Una Casilla Ingresando El Numero Correspondiente.\n";
       
        // Variables.
        public char[] tablero;
        Turno turno;

        /**
         * Lleva Cuenta De Las Veces Que Han Participado Los Jugadores 1 y 2.
         */

        int contador;

        /** Constructor(Inicializa Variables). */
        public Gato() {

                tablero = new char[MAX_POS];
                turno = Turno.P1;
                contador = 0;
                inicializarTablero();
        }
       
        private int getIndice(int i, int j) {
                return (COL_ROW * i) + j;
        }

        /**
         * Inicia El Arreglo, Especifica El Numero Que Le Corresponde A Cada
         * Casilla.
         */

        public void inicializarTablero() {
                for (int i = 0; i < MAX_POS; i++) {
                        tablero[i] = Integer.toString(i + 1).charAt(0);
                }
        }

        /**
         *  Imprime El Formato Del Tablero.
         *
         */

        public void imprimirTablero() {

                StringBuffer buffer = new StringBuffer();
               
                for (int i = 0; i < COL_ROW; i++) {

                        Object[] valoresDeFila = new Object[] {
                                        tablero[getIndice(i, 0)],
                                        tablero[getIndice(i, 1)],
                                        tablero[getIndice(i, 2)] };

                        buffer.append(String.format(FILA, valoresDeFila));

                        if (i < 2) { buffer.append(LINEA); }

                }
                buffer.append("\n\n\n");
               
                System.out.print(buffer.toString());
        }

        /**
         * Indica La Posicion Donde Se Ingresara El Dato Dentro Del Arreglo Por
         * Medio De Parametros
         *
         * @param a
         * @param b
         * @param c
         */

        public void indicarPosicionArreglo(int indice, char c) {
                tablero[indice] = c;
        }

        /**
         * Manipula el valor De La Variable "contador".
         *
         * @param e
         */

        public void setContador(int e) {
                contador = e;
        }

        /**
         * Regresa Valor De La Posicion Del Arreglo Indicada Por Medio De
         * Parametros.
         *
         * @param a
         * @param b
         * @return
         */

        public char getPosicionArreglo(int indice) {
                return tablero[indice];
        }

        /** Regresa Valor De La Variable "contador". */
        public int getContador() {
                return contador;
        }

        /**
         * Imprime e Indica El El Turno Del Jugador Que Le Toca Elejir Una Casilla
         * Con Ayuda del Metodo "getTurno()".
         */

        public void indicarTurno() {
                System.out.println(turno.toString().concat(TURNO));
        }

        /**
         * Regresa El Caracter De Tipo Char Para Posteriormente Ingresarlo A Alguna
         * Posicion Del Arreglo, Usandolo En Otro Metodo.
         *
         * @return
         */

        public char obtenerFigura() {
                return (turno.equals(Turno.P1)) ? JUGADOR_UNO : JUGADOR_DOS;
        }

        /**
         *  Cambia El Valor De La Variable "turno" Para Llevar El Orden Correcto De
         *  Los Turnos Entre Los 2 Jugadores.
         */

        public void cambiarTurno() {
                if (obtenerFigura() == JUGADOR_UNO)
                        setTurno(Turno.P2);
                else
                        setTurno(Turno.P1);
        }

        private void setTurno(Turno jugador) {
                turno = jugador;
        }

        /** Verifica Si La Posicion Del Arreglo Al Que El Jugador Desea Ingresar El
         * Caracter No Fue Utilizada Antes.
         * @param espacio
         * @param indice
         */

        public void comprobarEspacio(char espacio, int indice) {

                // Si Se Cumple La Condicion Se Ingresa El Valor En La Posicion Del
                // Arreglo Especificada.
                if (espacio != JUGADOR_UNO && espacio != JUGADOR_DOS) {

                        // Ingresa EL Caracter Si  Se Cumple  La Condicion.
                        indicarPosicionArreglo(indice, obtenerFigura());
                        cambiarTurno(); // Cambia El Turno Si Se Cumple La Condicion.
                        contador++; // Solo Incremente Cuando Se Cumple La Anterior
                                                // Condicion.
                } else {
                        // Imprime El Siguiente Mensaje En Caso De Que No Se Cumpla La
                        // Anterior Condicion.
                        System.out.println("La Casilla Esta Ocupada, Elija Otra Por Favor");
                }
        }

        // Metodo Que Hace Uso De Un "switch" Para Indicar La Posicion Del Arreglo
        // Que El Jugador Elijio En El Juego.
        public void elegirPosicion(int posicion) {
                if (0 <= posicion && posicion <= 8) {
                         comprobarEspacio(getPosicionArreglo(posicion), posicion);
                } else {
                        System.out.println("Por Favor, Ingrese Solo Un Digito Del 1 al 9.");
                }
        }

        /** Solo Imprime Un Mensaje Distinto Dependiendo Del Jugador Que Haya
         *  Resultado Ganador.
         * @param a
         */

        public void decirGanador(char a) {
                System.out.println(String.format(GANADOR, (a == JUGADOR_UNO) ? Turno.P1 : Turno.P2).toString());
        }

        // Verifica Las Unicas 8 Combinaciones Que Pueden Dar La Victoria A Uno De
        // Los Jugadores.
        public char buscarGanador() {

                // Ciclo Con Instrucciones Para Comprobar Las 3 Posibilidades De Ganar
                // De Forma Horizontal.
                for (int i = 0; i < 3; i++) {
                        if (tablero[getIndice(i, 0)] == tablero[getIndice(i, 1)]
                                        && tablero[getIndice(i, 1)] == tablero[getIndice(i, 2)]) {
                                return tablero[getIndice(i, 1)];
                        }
                }

                // Ciclo Con Instrucciones Para Comprobar Las 3 Posibilidades De Ganar
                // De Forma Vertical.
                for (int j = 0; j < 3; j++) {
                        if (tablero[getIndice(0, j)] == tablero[getIndice(1, j)]
                                        && tablero[getIndice(1, j)] == tablero[getIndice(2, j)]) {
                                return tablero[getIndice(1, j)];
                        }
                }

                // Instrucciones Para Comprobar La Unica Posibilidad De Ganar De Forma
                // Diagonal.
                if (tablero[getIndice(0, 0)] == tablero[getIndice(1, 1)]
                                && tablero[getIndice(1, 1)] == tablero[getIndice(2, 2)]) {
                        return tablero[getIndice(1, 1)];
                }

                // Ciclo Con Instrucciones Para Comprobar La Unica Posibilidade De Ganar
                // De Forma Diagonal Inversa.
                if (tablero[getIndice(0, 2)] == tablero[getIndice(1, 1)]
                                && tablero[getIndice(1, 1)] == tablero[getIndice(2, 0)]) {
                        return tablero[getIndice(1, 1)];
                }
               
                return NO_GANADOR;
               
        }

        // Metodo Que Contiene El Flujo Y El Orden Del Juego.
        public void jugarGato() {

                BufferedReader entrada = new BufferedReader(new InputStreamReader(
                                System.in));

                System.out.println("BIENVENIDO A GATO Ver. 1.0");

                do {

                        indicarTurno();
                        imprimirTablero();
                       
                        try {
                                elegirPosicion(Integer.parseInt(entrada.readLine()) - 1);
                        } catch (IOException | NumberFormatException e) {
                                System.out.println(ERROR.concat(turno.toString()));
                        }

                        char ganador = buscarGanador();
                       
                        if (ganador != NO_GANADOR) {
                                decirGanador(ganador);
                                imprimirTablero();
                                setContador(10);
                        }

                } while (getContador() < 9);

                if (getContador() == 9) {
                        System.out.println("¡GATO! ¡JUEGO EMPATADO!");
                        imprimirTablero();
                }

                System.out.println("THANKS FOR PLAYING!");
        }

        public static void main(String[] args) {
                new Gato().jugarGato();
        }
}

Imagen de genitalico

me resulto curioso este post

me resulto curioso este post de hace bastante tiempo, y quise agregar otro que tenia por ahi guardado en mi favoritos..

es el juego del gato, usando el algoritmo minimax,.. el juego esta muy chido y no se le puede ganar nunca a la maquina XD

http://labs.panchosoft.com/gato/

Imagen de marcosaw

Una versión de práctica

Se me hizo bueno el ejercicio ya que también empiezo en esto de java, así que hice una versión con Swing, para practicar (quizá de manera inútil) clases anidadas, lambda y bucles for para atravesar arreglos. Quizá me compliqué la existencia pero fue la forma que se me ocurrió y funciona para dos jugadores humanos. Lo que menos me gusta es el switch de la clase Tiro y que el X y O son asignados automáticamente. Ahí se las dejo.

import java.awt.GridLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;

/**
 *
 * @author marcosaw
 */

public class Gato {
   
    private static int count = 0;
    private static final String[][] tablero = new String[3][3];
   
    private static void ganador(String ficha) {
        for(int i = 0; i < 3; i++) {
            if(tablero[i][0].equals(tablero[i][1]) && tablero[i][0].equals(tablero[i][2])) {
                JOptionPane.showMessageDialog(null, "Ganador: " + ficha + "... Juego terminado");
                System.exit(1);
            }
            if(tablero[0][i].equals(tablero[1][i]) && tablero[0][i].equals(tablero[2][i])) {
                JOptionPane.showMessageDialog(null, "Ganador: " + ficha + "... Juego terminado");
                System.exit(1);
            }
        }
        if(tablero[0][0].equals(tablero[1][1]) && tablero[0][0].equals(tablero[2][2])) {
                JOptionPane.showMessageDialog(null, "Ganador: " + ficha + "... Juego terminado");
                System.exit(1);
            }
        if(tablero[2][0].equals(tablero[1][1]) && tablero[2][0].equals(tablero[0][2])) {
                JOptionPane.showMessageDialog(null, "Ganador: " + ficha + "... Juego terminado");
                System.exit(1);
        }
    }
   
    private static void setTiro(String ficha, String cmd) {
        tablero[new Tiro().getX(cmd) - 1][new Tiro().getY(cmd) - 1] = ficha;
        ganador(ficha);
    }

    public static void main(String[] args) {
        JFrame gato = new JFrame("Juego del gato");
        for(int i = 0; i < 3; i++) {
            for(int j = 0; j < 3; j++) {
                tablero[i][j] = "" + i + j;
            }
        }
       
        gato.setLayout(new GridLayout(3, 3));
        gato.setSize(300, 300);
        gato.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        for (int i = 1; i <= 9; i++) {
            final JButton boton = new JButton(Integer.toString(i));
            boton.addActionListener(
                    e -> {
                        boton.setEnabled(false);
                        if(count % 2 == 0) {
                            boton.setText("O");
                            setTiro("O", e.getActionCommand());
                        } else {
                            boton.setText("X");
                            setTiro("X", e.getActionCommand());
                        }
                        count++;
                    });
            gato.add(boton);
        }
        //gato.pack();
        gato.setVisible(true);
    }
   
    private static class Tiro {
        private int x, y;
        int getX(String cmd) {
            tirar(cmd);
            return x;
        }
       
        int getY(String cmd) {
            tirar(cmd);
            return y;
        }
        private void tirar(String cmd) {
            switch(cmd) {
                case "1":
                    x = 1;
                    y = 1;
                    break;
                case "2":
                    x = 1;
                    y = 2;
                    break;
                case "3":
                    x = 1;
                    y = 3;
                    break;
                case "4":
                    x = 2;
                    y = 1;
                    break;
                case "5":
                    x = 2;
                    y = 2;
                    break;
                case "6":
                    x = 2;
                    y = 3;
                    break;
                case "7":
                    x = 3;
                    y = 1;
                    break;
                case "8":
                    x = 3;
                    y = 2;
                    break;
                case "9":
                    x = 3;
                    y = 3;
            }
        }
    }
}

Imagen de ezamudio

matemáticas

Luego dicen que para qué sirven las matemáticas... en este caso, para escribir menos código. Ese switch de 9 casos podría reducirse bastante con tantita aritmética. Y para qué pasarle un string a algo que espera realmente un dígito? Si cmd fuera tipo int entonces simplemente puedes hacer que x=(cmd-1)/3+1 y y=(i-1)%3+1.

Imagen de marcosaw

Aritmética,

Pensé hacerlo con aritmética, pero no se me ocurrió cómo, pero esa sugerencia que das muy bien, tira la clase Tiro a la basura y el código queda más compacto. La verdad solo estaba practicando anidar una clase, pero evidentemente en este ejemplo es excesivo, Saludos.