Podemos dejar de lado los fantasmas y pensar en los
Player.
EL juego ha de mostrar un menú login al principio, así que hay gestionar una lista de
Player para registrar, modificar, eliminar y comprobar si existen para admitir el login.
Así que podemos crear una clase que se encargue de esta gestión.
En un ArrayList podemos ir insertando o eliminando jugadores.
Los jugadores tienen nombres y contraseñas, puntos e incluso un historial de juego (que ya incluiremos más adelante).
Todo esto debería permanecer cuando cerramos el programa para que esté disponible en las sesiones siguientes. Si no, cada vez que arrancamos el programa habría que crear nuevos jugadores, y no tendrían ningún historial ni puntos.
Así que el gestor debería guardar en disco los
Player que vayamos registrando.
Una forma fácil de hacerlo es "serializando" el ArrayList que va a contener los players, de forma que se guarde en forma de bytes en un archivo en disco.
La clase
GestorPlayer podemos comenzarla así:
public class GestorPlayers{
private ArrayList<Player> players;
private final File ficheroPlayers; //Fichero en disco donde se guardarán los players
public GestorPlayers() {
//Guadaré los datos de jugadores en la carpeta personal del usuario que indique el S.O.
ficheroPlayers = new File(System.getProperty("user.home") + "/JuegoGHOSTS/players.dat");
players = new ArrayList<Player>();
cargarPlayers();
}
/**
* Intentará leer el ArrayList de Players guardado en disco
*/
private void cargarPlayers() {
System.out.println("Buscando datos de Jugadores en disco...");
if (ficheroPlayers.exists()) {
try {
ObjectInputStream lector = new ObjectInputStream(new FileInputStream(ficheroPlayers));
//Leemos datos del disco
Object datos = lector.readObject();
//Si es una
if (datos instanceof ArrayList) {
players = (ArrayList<Player>) datos;
System.out.println("Datos de Jugadores registrados cargados...\n");
}
lector.close();
} catch (FileNotFoundException e) {
System.out.println("\nNo se encuentra:\n" + ficheroPlayers.getAbsolutePath()+ "\n");
} catch (IOException e) {
System.out.println("\nNo se puede acceder a:\n" + ficheroPlayers.getAbsolutePath()+ "\n");
} catch (ClassNotFoundException e) {
System.out.println("Los datos de:\n" + ficheroPlayers.getAbsolutePath() +
"pertenecen a una clase desconocida.\n");
}
}
else {
System.out.println("No existe fichero:\n" + ficheroPlayers.getAbsolutePath());
System.out.println("El juego comenzará sin datos de Jugadores registrados");
}
}
/**
* Intentará guardar el ArrayList de Players en disco.
*/
public void guardarPlayers() {
try {
if (!ficheroPlayers.exists()) { //Si no existe...
//Creamos carpeta/directorio..
File carpeta = new File(System.getProperty("user.home") + "/JuegoGHOSTS");
carpeta.mkdir();
//Creamos fichero en disco..
ficheroPlayers.createNewFile();
}
ObjectOutputStream escritor = new ObjectOutputStream(new FileOutputStream(ficheroPlayers));
escritor.writeObject(players);
escritor.close();
} catch (Exception e) {
System.out.println("\nNo se encuentra o no se puede acceder a:\n" +
ficheroPlayers.getAbsolutePath()+ "\n");
System.out.println("No se ha podido guardar el registro de Jugadores.");
}
}
public Player loginPlayer(String nombre, String password) {
for (Player jugador: players) {
if (jugador.getNombre().equals(nombre)) {
if (jugador.getPassword().equals(password))
return jugador; //Login aceptado
else {
//Nombre correcto, pero no la contraseña
System.out.println("Contraseña errónea");
return null;
}
}
}
//Si el bucle ha finalizado su recorrido, es que no existe ese nombre
System.out.println("No existe Jugador con el nombre: " + nombre);
return null;
}
}Tenemos dos atributos, el ArrayList de jugadores y un objeto File que es donde guadaremos/leeremos los datos en disco.
El constructor inicializa esos atributos. Al objeto File hay que darle nombre y ruta donde vamos a querer tenerlo. En mi caso, lo llamo "players.dat" y lo tendré en una carpeta dentro de mi directorio de usuario personal en mi sistema operativo.
Podemos ponerle cualquier otro nombre y ruta, pero la ruta conviene que no vayamos a tener problemas de permisos de escritura.
Tras inicializar esos atributos, el constructor llama a un método que va a intentar leer ese archivo para recuperar los datos que pueda contener.
Esto lo hace el método
cargarPlayers().
Con la clase
ObjectInputStream de Java intentará acceder a nuestro fichero de jugadores. Comprobará que lo que contiene es un ArrayList y si es así, lo seteará a nuestro atributo.
Si no es un ArrayList, o no tiene datos, o no existe, o no puede acceder.... pues el juego comenzará con el ArrayList vacío.
El siguiente método es
guardarPlayers() quién se encarga de guardar el ArrayList de
Player en disco.
Primero comprueba si existe el archivo. Si no existe, creará su carpeta y luego crearé el archivo.
Y después hará en él la escritura de bytes que componen el ArrayList.
Y ya de paso ponemos también el método
loginPlayer()Este método (no definitivo), es el que usaríamos para loguear a un jugador.
Recibe un nombre y una contraseña, y comprueba en el ArrayList si existe un
Player con esos datos.
Si existe, retorna dicho objeto
Player, si no, retorna valor
null.
Luego se irán añadiendo más métodos, pero de momento ya podemos leer y guardar datos en disco.
Aunque falta un detalle. En Java, para poder serializar objetos, tienen que implementar la interfaz
IterableArrayList ya la implementa, pero en realidad estamos guardando objetos de nuestra clase
Player y para que puedan guardarse, tenemos que implementar dicha interfaz.
Para esto basta con añadir dos palabras a nuestra clase
Player:
public class Player implements Serializable{
private String nombre;
private String password;
private int puntos;
Ya está, nada más. Solo eso.
Los atributos de
Player también deben implementar esa interfaz, pero String ya la trae de serie y el int al ser un tipo de dato primitivo, convertirlo a bytes es pan comido, porque eso es lo que es..., un conjunto de 4 bytes.
Bien, tras todo esto, la clase principal
Ghosts ya podemos comenzar a construirla según pide el enunciado.
Ha de comenzar mostrando un menú con las opciones: login, crear player y salir.
Además, vamos a poner como variables de ámbito global un objeto
Player llamado "logueado" donde tendremos al jugador que haya hecho login o bien tendrá valor
null cuando no haya nadie logueado.
También un objeto
GestorPlayers y un
Scanner para las lecturas de teclado.
Haremos un método para mostrar el menu inicio y que retorne la opción que el usuario escoja.
Y también podemos escribir ya un método para hacer login. Este método pedirá nombre y contraseña para pasarselos al gestor de players, si los datos son correctos en el objeto "logueado" tendremos al
Player correspondiente. Si no lo son, seguirá teniendo valor
nullpublic class Ghosts {
private static Player logueado; //Jugador actualmente logueado
private static GestorPlayers gestorPlayers = new GestorPlayers(); //Gestión de Jugadores
private static Scanner teclado = new Scanner(System.in);
public static void main(String[] args) {
int opcion = 0;
do {
opcion = menuInicio();
switch(opcion) {
case 1:
login();
break;
case 2:
//crearPlayer();
break;
case 3:
System.out.println("\n\n\t\tFIN DE PROGRAMA");
}
//Esta parte solo se ejecuta si hay un usuario logueado
while(logueado != null) {
//menu Principal
}
}while (opcion != 3);
}
private static int menuInicio() {
System.out.println("\n\n\t\tMENU INICIO");
System.out.println("\t\t---- ------\n");
System.out.println("(1) - Login");
System.out.println("(2) - Crear Player");
System.out.println("(3) - SALIR");
System.out.print("Escoja opción: ");
return Integer.parseInt(teclado.nextLine());
}
private static void login() {
System.out.println("\nLOGIN....");
System.out.print("Nombre: ");
String nombre = teclado.nextLine();
System.out.print("Contraseña: ");
String password = teclado.nextLine();
//Si los datos son correctos, tendremos un Player en "logueado"
logueado = gestorPlayers.loginPlayer(nombre, password);
//Si no fueron correctos, "logueado" tendrá valor null
}
}Si lo ejecutamos, lo primero que veremos serán mensajes del Gestor de Players buscando el archivo de registro de jugadores.
Como es la primera vez que lo ejecutamos, ese archivo no existe aún, y eso es lo que nos notificará.
Podemos intentar hacer login, pero como no hay players, no hay forma de loguearse..
Buscando datos de Jugadores en disco...
No existe fichero:
C:\Users\orcok\JuegoGHOSTS\players.dat
El juego comenzará sin datos de Jugadores registrados
MENU INICIO
---- ------
(1) - Login
(2) - Crear Player
(3) - SALIR
Escoja opción: 1
LOGIN....
Nombre: Kabuto
Contraseña: 1234
No existe Jugador con el nombre: Kabuto
MENU INICIO
---- ------
(1) - Login
(2) - Crear Player
(3) - SALIR
Escoja opción: 3
FIN DE PROGRAMAAsí que lo próximo que vamos a querer añadir, será el poder crear nuevos jugadores y así podremos comprobar si se guardan correctamente en disco o no.
Tema: Juego de tablero código Java Ghosts fantasmas turno matriz arreglo bidimensional (Leído 5319 veces)
RSS -
WAP2