Link Log

Una manera de perder el tiempo…

Juego del gato en Java

with 8 comments

Bueno, este es un pequeño programa que simula el juego del gato, esta muy sencillo y fácil de entender.

public class JuegoGato {
public static void main( String args[] ){
String gato[][] = new String [3][3];
gato[0][0] = new String( “x” );
gato[0][1] = new String( “o” );
gato[0][2] = new String( “x” );

gato[1][0] = new String( “o” );
gato[1][1] = new String( “x” );
gato[1][2] = new String( “o” );

gato[2][0] = new String( “o” );
gato[2][1] = new String( “o” );
gato[2][2] = new String( “x” );

for (int i=0; i < gato.length; i++) {
for (int j=0; j < gato[i].length; j++) {
System.out.print(gato[i][j]+”\t”);
}
System.out.println(“”);
}
System.out.println(“Juego Ganado por x”);
}
}

El resultado seria:

x o x
o x o
o o x

Juego ganado por x

About these ads

Written by Link X

November 18, 2007 at 1:21 am

Posted in Java, Programación

Tagged with , ,

8 Responses

Subscribe to comments with RSS.

  1. The game does not work son of a ….

    dann

    August 22, 2008 at 7:40 pm

  2. the game does work your the dum one that doesnt know how to fix it

    jairo

    March 11, 2009 at 6:54 pm

  3. No corre tu programa esta un poco mal escrito jaja. Corregi un poco el tuyo y funciona lo prove gracias.

    class G {
    public static void main( String[] args){
    String gato[][] = new String [3][3];
    gato[0][0] =”x”;
    gato[0][1] =”o”;
    gato[0][2] =”x”;

    gato[1][0] =”o”;
    gato[1][1] =”x”;
    gato[1][2] =”o”;

    gato[2][0] =”o”;
    gato[2][1] =”o”;
    gato[2][2] =”x”;

    for (int i=0; i < gato.length; i++) {
    for (int j=0; j < gato[i].length; j++) {
    System.out.print(gato[i][j]+” “);
    }
    System.out.println(“”);
    }
    System.out.println(“Juego Ganado por x”);
    }
    }

    HV

    April 26, 2009 at 5:39 pm

    • class G {
      public static void main( String[] args){
      String gato[][] = new String [3][3];
      gato[0][0] =(“x”);
      gato[0][1] =(“o”);
      gato[0][2] =(“x”);

      gato[1][0] =(“o”);
      gato[1][1] =(“x”);
      gato[1][2] =(“o”);

      gato[2][0] =(“o”);
      gato[2][1] =(“o”);
      gato[2][2] =(“x”);

      en consola asi se ejecuta, ya esta bien :-)

      for (int i=0; i < gato.length; i++) {
      for (int j=0; j < gato[i].length; j++) {
      System.out.print(gato[i][j]+" ");
      }
      System.out.println("");
      }
      System.out.println("Juego Ganado por x" );
      }
      }

      angie

      June 19, 2010 at 9:29 pm

  4. … la gracia sería ingresar tu mismo los elementos en el arreglo para poder “jugar” realmente

    Richard

    September 10, 2010 at 8:12 am

  5. public class JuegoGato {
    public static void main( String args[] ){
    String gato[][] = new String [3][3];
    gato[0][0] = new String( “x” );
    gato[0][1] = new String( “o” );
    gato[0][2] = new String( “x” );

    gato[1][0] = new String( “o” );
    gato[1][1] = new String( “x” );
    gato[1][2] = new String( “o” );

    gato[2][0] = new String( “o” );
    gato[2][1] = new String( “o” );
    gato[2][2] = new String( “x” );

    for (int i=0; i < gato.length; i++) {
    for (int j=0; j < gato[i].length; j++) {
    System.out.print(gato[i][j]+"\t");
    }
    System.out.println("");
    }
    System.out.println("Juego Ganado por x");
    }
    }

    Guillermo Cuevas

    October 26, 2010 at 9:53 am

  6. esta muy bueno… asi lo necesito pero en netbeans

    oscar

    June 8, 2011 at 11:11 pm

  7. 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];
    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.

    seleccionSigno();
    inicializarTablero();

    }

    public void seleccionSigno (){
    int error=1;

    while (error==1){
    System.out.println(“elija su ficha X ó O , ingrese solo mayusculas “);

    String jugadorUno=LecturaPantalla.leer();
    if(jugadorUno.equals(“X”)){
    jugadorDos=’O';
    error=0;
    }
    else{
    if(jugadorUno.equals(“O”)){
    jugadorDos=’X';
    error=0;
    }
    else{
    System.out.println(“Ficha mal ingresada intente nuevamente”);
    }

    }
    }
    }
    //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("GRACIAS POR JUGAR!");
    }

    System.out.println("GRACIAS POR JUGAr!");
    }

    public static void main(String [] args){

    JuegoGato Objeto = new JuegoGato();

    Objeto.jugarGato();

    }
    } miren tengo esto pero quiero que al elegir la ficha pueda asignarsela a jugadorUno

    nyabhingiman@chilerastafari.cl

    December 1, 2012 at 10:57 am


Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Follow

Get every new post delivered to your Inbox.

%d bloggers like this: