Java juego tres en raya guardar partida y cargarla luego código FileOutputStream

[Vulkkano]

Buenas, estoy haciendo un 3 en raya y no consigo hacer que me guarde la partida, tengo esto de codigo pero no me funciona, tambien quiero cargar las partidas una vez las guarde, como podria hacerlo.

Os paso lo que tengo de codigo:

Código: [Seleccionar]

package tresraya;


import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.Scanner;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author alexd
 */
public class TresRaya {

    private static int columna;
    private static int fila;

    int tablero[][]= new int [3][3];
   
    public static void main(String[] args) {
        TresRaya mi_tresraya = new TresRaya();             
        Scanner entrada = new Scanner(System.in);
        BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));
        String texto;
        boolean sortir = false;
        do{
            System.out.println("--- Menu 3 en Raya ---");
            System.out.println("\t1) Jugar Tres en Raya");
            System.out.println("\t2) Guardar partida");
            System.out.println("\t3) Carregar Partida");
            System.out.println("\t4) Sortir");
            int opcio = entrada.nextInt();
            entrada.nextLine();
            switch(opcio){
                case 1:
                    mi_tresraya.juego();
                    mi_tresraya.dibujar_tablero();
                    mi_tresraya.jugar_partida();
                        break;
                case 2:
                    mi_tresraya.guardarPartida();
                       break;
                //case 3: cargarPartida();
                  //      break;
                case 4: sortir = true;
                        break;       
                default:
                    System.out.println("Opcio no valida");
            }
       
        }while(!sortir);
    }
   
    public void dibujar_tablero(){         
       int columnas_tablero;
       int filas_tablero;
       
       System.out.println("---- Tres en Raya ----");
       for(int i = 0; i < tablero.length; i++){
            for(int j = 0; j < tablero.length; j++){
               
                if(tablero[i][j] == 0){                   
                    System.out.print("| " + tablero[i][j] + " ");
                }
                if (tablero[i][j] == 1)
                {
                     System.out.print("| " + "X" + " "); 
                }
                if (tablero[i][j] == 3)
                {
                     System.out.print("|" + "  ");
                }
            }
            System.out.print("|");
            System.out.println("");
        }
        System.out.println("-----------------------");   
    }
   
    public void juego(){
        for(int i = 0; i<tablero.length; i++){
            for(int j = 0; j<tablero.length; j++){
                tablero[i][j] = 3;
            }
        }
    }
   
    public void jugar_partida(){
        try {
            BufferedReader teclado = new BufferedReader(new InputStreamReader(System.in));

            boolean fin=false;
           
            System.out.println("¿Cómo quieres jugar X/0?");
            String juego = teclado.readLine().toUpperCase();
            int valor_juego=0;
            if(juego.equals("0")){
                valor_juego=0;
            }
            if(juego.equals("X")){             
                valor_juego=1;
            }
            if(juego.equals("X") || (juego.equals("0"))){
                       
            while(fin==false){
            dibujar_tablero();
            if(valor_juego==1){
                System.out.println("Te toca X");
            }
            if(valor_juego==0){
                System.out.println("Te toca 0");
            }
            System.out.println("Introduce coordenadas de posición: (0,0) ");
            System.out.println("Introduce la fila");
            int fila= Integer.parseInt(teclado.readLine());
            System.out.println("Introduce la columna");
            int columna= Integer.parseInt(teclado.readLine());
            if(tablero[fila][columna]==3){
                boolean ganador;
                tablero[fila][columna]=valor_juego;
                dibujar_tablero();
                ganador=comprobacion(valor_juego);
               
                if(ganador){
                    System.out.println("Ha ganado " + valor_juego);
                    fin=true;
                    juego();
                }else {
                    int estado_empate=0;
                    for(int i=0;i<=2;i++){
                        for(int j=0;j<=2;j++){
                            if((tablero[i][j]==0) || (tablero[i][j]==1)){
                                estado_empate=estado_empate+1;
                            }
                        }
                    }
                    if(estado_empate==9){
                        System.out.println("Se ha empatado");
                        fin=true;
                    }
                    if(valor_juego==1){
                        valor_juego=0;
                    }
                    else{
                        if(valor_juego==0){
                        valor_juego=1;
                        }
                    }
                }
            }else{
                System.out.println("No puede jugar, ya está usado");
            }
            }
            }
        } catch (IOException ex) {
            Logger.getLogger(TresRaya.class.getName()).log(Level.SEVERE, null, ex);
        }
   
}
   

    public boolean comprobacion(int valor_tresraya){
   
        if((tablero[0][0]==valor_tresraya) && (tablero[0][1]==valor_tresraya) && (tablero[0][2]==valor_tresraya)){
            return true;
        }
        if((tablero[1][0]==valor_tresraya) && (tablero[1][1]==valor_tresraya) && (tablero[1][2]==valor_tresraya)){
            return true;
        }
        if((tablero[2][0]==valor_tresraya) && (tablero[2][1]==valor_tresraya) && (tablero[2][2]==valor_tresraya)){
            return true;
        }
        if((tablero[0][0]==valor_tresraya) && (tablero[2][0]==valor_tresraya) && (tablero[3][0]==valor_tresraya)){
            return true;
        }
        if((tablero[0][1]==valor_tresraya) && (tablero[1][1]==valor_tresraya) && (tablero[2][1]==valor_tresraya)){
            return true;
        }
        if((tablero[0][2]==valor_tresraya) && (tablero[1][2]==valor_tresraya) && (tablero[2][2]==valor_tresraya)){
            return true;
        }
        if((tablero[0][0]==valor_tresraya) && (tablero[1][1]==valor_tresraya) && (tablero[2][2]==valor_tresraya)){
            return true;
        }
        if((tablero[0][2]==valor_tresraya) && (tablero[1][1]==valor_tresraya) && (tablero[2][0]==valor_tresraya)){
            return true;
        }
        return false;
    }
   
    public void guardarPartida(){
       try{
        BufferedReader in=new
        BufferedReader(new InputStreamReader(new FileInputStream("D:\\arc.txt")));
        int filas=Integer.parseInt(in.readLine());
        int columnas=Integer.parseInt(in.readLine());
        tablero = new int[fila][columna];
        for(int i = 0; i < fila; i++){
        for(int j = 0; j < columna; j++){
        tablero[ i ][ j ]=(int)(in.read());
        }
        }
        in.close();
        }catch(Exception e){}
    }

   
   
    //public void cargarPartida(){
       
    //}
   
   
}

Saludos

[Kabuto]

mmmh, tu método para guardar partida, el principal fallo que tiene es que estás usando clases Reader(BufferedReader, InputStreamReader,... )

Es decir, son clases para "leer", y tu lo que quieres es "escribir".

Si quieres guardar el contenido de la matriz tablero como texto plano, puedes usar BufferedWriter.

Sin embargo, puedes guardarlo directamente como un archivo de bytes. La ventaja es que es más cómodo y rápido de programar, son muy poquitas líneas.
La "desventaja", es que el archivo donde se guarda no será legible a ojos humanos. Pero en un caso como este, supongo que esto no importa, pues el propósito es que el programa pueda cargar y guardar partidas, no obtener un fichero que se pueda leer.


Para ello puedes usar la clase ObjectOutputStream.
Lo que hace es coger un objeto (en Java, una matriz es un objeto) y tal cuál está en ese momento en memoria RAM, lo traspasa a un archivo de bytes.

No es necesario recorrer la matriz  e ir guardando el valor de cada uno de sus elementos, no...
Se coge la matriz entera y se guarda como código binario.

El método podría ser tan sencillo como este:

Código: [Seleccionar]

public void guardarPartida(){
try {
ObjectOutputStream escritor = new ObjectOutputStream(new FileOutputStream("d:/partida3Raya.bin"));
//Escribimos la matriz tal cuál está en memoria RAM, como archivo binario
escritor.writeObject(tablero);
escritor.close();
} catch (FileNotFoundException e) {
System.out.println("No se encuentra fichero: partida3Raya.bin");
} catch (IOException e) {
System.out.println("Problema de acceso a fichero: partida3Raya.bin");
}
}
Luego, para recuperar los datos del archivo y pasarlos a la matriz tablero, usaríamos la clase opuesta, la ObjectInputStream.
Al leer el archivo nos retorna un Object (un objeto), el cuál para poder asignarlo como matriz tablero, habrá que hacer un casting a int[][]

Código: [Seleccionar]

public void cargarPartida(){
try {
ObjectInputStream lector = new ObjectInputStream(new FileInputStream("d:/partida3Raya.bin"));
//Leemos los bytes del archivo y nos retornará un Object, al que haremos casting a matriz int[]
tablero = (int[][]) lector.readObject();
lector.close();
} catch (FileNotFoundException e) {
System.out.println("No se encuentra fichero: partida3Raya.bin");
} catch (IOException e) {
System.out.println("Problema de acceso a fichero: partida3Raya.bin");
} catch (ClassNotFoundException e) {
System.out.println("Los datos obtenidos no permiten recuperar la partida");
}

}

Bien, ambos métodos deberían funcionar.
Pero ahora se te presenta otro problema. 
¿Cómo puede el usuario, en mitad de una partida, salirse de ella para regresar al menú y ordenar que se guarde la partida?

A ver si se te ocurre como solucionarlo.

Un saludo.

[Vulkkano]

se puede hacer de manera que guarde en un archivo .txt?

[Kabuto]

Sí, pero será más laborioso.
Tendrás que decidir una forma de escribir los datos de manera que luego, al leerlo, te sea fácil desde el código interpretar lo que estás leyendo para reconstruir la matriz/tablero.

Por ejemplo, escribir los valores separados por comas, en tres líneas de texto:

0,0,1
2,0,2
0,0,1

Cada línea representa una fila de la matriz, y las comas las separa en columnas.
Luego se puede leer línea por línea.
Cada línea la dividimos en tres partes usando el método split(",")
Así sabemos que la primera parte, de la primera línea, es el valor de la posición 0,0 en la matriz
La segunda parte, de la primera línea es 0,1
La tercera parte es 0,2

Luego en la segunda línea, la primera parte corresponde a 1,0
Etc, etc...

Los valores de la matriz guardados como texto, los leeremos como String. Por tanto, habrá que convertirlos a int para poder devolverlos a la matriz..

Este podría ser el método para guardar como texto:

Código: [Seleccionar]

public void guardarPartidaTxt() {
try {
BufferedWriter escritor = new BufferedWriter(new FileWriter("d:/partida3Raya.txt"));
//Escribimos las tres filas de la matriz, con sus valores separados por comas
for (int fila = 0; fila < tablero.length; fila++) {
escritor.write(tablero[fila][0] + "," + tablero[fila][1] + "," + tablero[fila][2]);
escritor.newLine();
}
escritor.close();

} catch (IOException e) {
System.out.println("Problema de acceso a fichero: partida3Raya.txt");
}
}
Y este para leer el txt:

Código: [Seleccionar]

public void cargarPartidaTxt() {
try {
BufferedReader lector = new BufferedReader(new FileReader("d:/partida3Raya.txt"));
//Leemos primera linea, equivale a primera fila
String linea = lector.readLine();
int fila = 0;
while (linea != null) {
//Separamos valores
String[] valores = linea.split(",");
//Asignamos a donde corresponde en la matriz
tablero[fila][0] = Integer.parseInt(valores[0]);
tablero[fila][1] = Integer.parseInt(valores[1]);
tablero[fila][2] = Integer.parseInt(valores[2]);
//Pasamos a la siguiente linea y siguiente fila
linea = lector.readLine();
fila++;
}
lector.close();
} catch (FileNotFoundException e) {
System.out.println("No se encuentra fichero: partida3Raya.txt");
} catch (IOException e) {
System.out.println("Problema de acceso a fichero: partida3Raya.txt");
}
}