A ver, para modular el código y tenerlo un poco más ordenado, puedes crear dos clases adicionales, una para trabajar con el archivo de texto y otra para el archivo de ranking.
La del archivo de texto puedes hacer que lea el texto una sola vez en su constructor y guardar las líneas obtenidas en un atributo.
Así, con un método puedes pedirle una palabra al azar tantas veces como quieras sin tener que repetir lecturas en disco.
El constructor de esta clase recibiría la ruta del archivo que ha de leer, haría la lectura y obtendría el texto.
Este proceso, en Java es obligatorio controlar posibles excepciones (archivo no existe, archivo no es legible por estar corrupto o protegido...), así que el constructor de esta clase debería "lanzar" estas excepciones para poder recibirlas en la clase principal del programa.
Porque en la clase principal, el programa solo debería ejecutarse si ha sido posible obtener un texto (no han habido excepciones). Si no es así, debería informar del problema en pantalla y terminar, ya que no tiene sentido ofrecer al usuario poder jugar si no tenemos palabras.
Esta podría ser la clase ArchivoTexto
mport java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Random;
public class ArchivoTexto{
private StringBuilder texto; //Texto que se leera desde fichero
public ArchivoTexto(String ruta) throws Exception {
texto = new StringBuilder();
try {
BufferedReader lector = new BufferedReader(new FileReader(ruta));
//Los archivos de texto se leen línea a línea
String linea = lector.readLine();
while (linea != null) {
texto.append(linea + "\n");
linea = lector.readLine();
}
lector.close();
//Comprobamos que realmente hemos obtenido algún texto
if (texto.toString().isBlank())
throw new Exception("No se obtuvo texto.\nEl archivo: " + ruta + " parece estar en blanco.");
else {
System.out.println("Archivo texto: OK");
System.out.println("Texto obtenido:\n" + toString());
}
} catch (FileNotFoundException e) {
throw new Exception("No se encuentra fichero en " + ruta);
} catch (IOException e) {
throw new Exception("Error accediendo a fichero.\n" + e.getLocalizedMessage());
}
}
public String getPalabraAzar() {
//Construimos un array con todas las palabras del texto
String[] palabras = texto.toString().split(" ");
//Generamos un indice al azar, según la cantidad de palabras obtenidas
Random azar = new Random();
int indice = azar.nextInt(palabras.length);
//Retornamos palabra al azar
return palabras[indice];
}
@Override
public String toString() {
return texto.toString();
}
}
La clase ArchivoRanking es un poco parecida, pero más simple.
Su constructor también recibe la ruta del archivo donde se han de escribir las puntuaciones, pero simplemente lo guarda en un atributo.
Escribiremos un método que reciba como argumentos el nombre del jugador y los puntos para intentar escribirlos en el archivo.
Para este proceso también es obligado controlar posibles excepciones.
Pero en esta ocasión no es necesaria "lanzarlas" al programa principal, porque podemos permitir que el programa siga ejecutándose aunque esté fallando el proceso de guardar las puntuaciones.
El jugador al menos podrá seguir jugando ya que en teoría si dispondremos de palabras.
Así que la posibles excepciones las gestionará el método de forma interna, sin lanzarlas.
En todo caso, podemos hacer que el método sea boolean. Así si todo ha ido bien, retornará true.
Si ha fallado por ocurrir una excepción, mostramos en pantalla el mensaje de error y retornamos false.
Esta sería la clase ArchivoRanking
import java.io.BufferedWriter;
import java.io.FileWriter;
public class ArchivoRanking {
private String ruta;
public ArchivoRanking(String ruta) {
this.ruta = ruta;
}
public boolean guardarPuntuacion(String nombre, int puntos) {
try {
BufferedWriter escritor = new BufferedWriter(new FileWriter(ruta, true));
escritor.write("Nombre: " + nombre + " --- Puntos: " + puntos);
escritor.newLine();
escritor.close();
return true;
} catch (Exception e) {
System.out.println("Error al crear o acceder al archivo: " + ruta + "\n" + e.getLocalizedMessage());
return false;
}
}
}
Y ya luego, en el programa principal, colocaremos dos objetos de estas clases como atributos de ámbito global para que estén totalmente accesibles dentro de esta clase.
Lo primero que haremos será inicializar el objeto ArchivoTexto, que obligatoriamente tenemos que poner try catch para capturar las posibles excepciones que puede lanzar.
Si todo va bien, automáticamente se mostrará en pantalla el texto que se ha obtenido.
Ya luego solo hay que inicializar el objeto ArchivoRanking y ya puede comenzar el resto del programa, con el menú y el código para jugar al Ahorcado.
public class Ahorcado {
private static ArchivoTexto texto;
private static ArchivoRanking ranking;
public static void main(String[] args) {
try {
texto = new ArchivoTexto("info.txt");
ranking = new ArchivoRanking("ranking.txt");
String oculta = texto.getPalabraAzar();
//A partir de aquí, código para el menú y juego del ahorcado
} catch (Exception e) {
System.out.println(e.getMessage());
}
System.out.println("\n\t\tFIN DE PROGRAMA");
}
}
El objeto ArchivoTexto nos dará una palabra "oculta" al azar, siempre que se la pidamos.
Y el objeto ArchivoRanking guardará las puntuaciones que le vayamos indicando.
Como puedes ver, separando estos procesos en distintas clases, el código queda más ordenado.
Si algo no se entiende, solo tienes que preguntar.
Un saludo.
Tema: código Java juego del ahorcado con opciones puntuaciones palabras aleatorias (Leído 2273 veces)
RSS -
WAP2