Nuevos métodos en GameManager y dbConnector.

Se han añadido nuevos métodos y nuevas funcionalidades a la GameManager.
Se han revisado los Todo y arreglado pequeños detalles.

core/src/uberelectron/gameSystems/GameManager.java

@@ -41,6 +41,42 @@ public class GameManager
         return instance;
     }
 
+    /**
+     * Permite comprobar si ya existe el usuario y se puede iniciar sesión
+     * o hay que crear uno nuevo.
+     * @return True si existe, false si no.
+     */
+    public boolean ComprobarExisteUsuario()
+    {
+        return LoginSystem.ComprobarExisteUsuario();
+    }
+
+    /**
+     * Utilizado para autentificar un usuario.
+     */
+    public void AutentificarUsuario()
+    {
+        //Comprobamos que tenemos los datos de usuario.
+        if(!ComprobarExisteUsuario())
+        {
+            Gdx.app.error("GameManager", "No se ha podido autentificar el usuario. " +
+                    "Los datos de usuario no existen.");
+            return;
+        }
+        LoginSystem.AutentificarUsuario();
+    }
+
+
+    /**
+     * Permite comprobar si existe la partida y se puede cargar
+     * o hay que comenzar una nueva.
+     * @return True si existe, false si no.
+     */
+    public boolean ComprobarExistePartida()
+    {
+        return SaveLoader.ComprobarExistePartida(Gdx.files.local(localSavePath + "save.json"));
+    }
+
 
     /**
      * Realiza el guardado del save y de las salas.
@@ -58,6 +94,14 @@ public class GameManager
      */
     public void LoadGameFromJSON()
     {
+        //Comprobamos que existe la partida.
+        if(!ComprobarExistePartida())
+        {
+            Gdx.app.error("GameManager", "No se puede cargar la partida. " +
+                    "El archivo de datos no existe.");
+            return;
+        }
+
         SaveLoader.LoadFromJSON(Gdx.files.local(localSavePath + "save.json"));
 
         //Cargamos desde sus archivos todas las salas que el jugador tenga compradas.
@@ -71,6 +115,34 @@ public class GameManager
         }
     }
 
+    /**
+     * Utilizado para cargar partidas de otros usuarios desde la BD.
+     * Se ha de indicar el usuario de la partida que se quiere cargar.
+     */
+    public void LoadGameFromDB(String username)
+    {
+        //Descargamos todas las salas que tengamos cargadas.
+        RoomLoader.getInstance().UnloadAllRooms();
+
+        //Limpiamos los datos de Save.
+        saveData = null;
+
+        //Cargamos el nuevo Save desde la BD.
+        saveData = dbConnector.GetSaveDataFromDB(username);
+
+        //Cargamos todas las salas que tenga este save.
+        for(Map.Entry<String, Boolean> salas : saveData.ownedRooms.entrySet())
+        {
+            //Comprobamos si tiene la sala.
+            if(salas.getValue())
+            {
+                //Obtenemos los datos de esa sala.
+
+            }
+        }
+    }
+
+
     /**
      * Reinicia la sala indicada.
      * Para ello, copia el archivo por defecto a la carpeta de guardado del jugador.
@@ -157,8 +229,19 @@ public class GameManager
         //Calculamos el dinero obtenido.
         int dineroObtenido = 0;
 
-        //TODO: ¿Cómo iteramos por las salas?
+        //Obtenemos un Ptr al RoomLoader.
-        //  ¿Iteramos por las cargadas o las que se indican en el Save?
+        RoomLoader rl = RoomLoader.getInstance();
+
+        //Iteramos por las salas que posee según el save.
+        for(Map.Entry<String, Boolean> salas : saveData.ownedRooms.entrySet())
+        {
+            //Comprobamos si posee esa sala.
+            if(salas.getValue())
+            {
+                int dineroSala = rl.GetRoomByID(salas.getKey()).dineroPorCiclo;
+                dineroObtenido += dineroSala;
+            }
+        }
 
         //Se itera por las salas y se suma su dinero por ciclo al dinero total.
         saveData.dinero += dineroObtenido;

core/src/uberelectron/gameSystems/LoginSystem.java

@@ -22,6 +22,7 @@ public class LoginSystem
      */
     public static boolean AutentificarUsuario()
     {
+
         //Se llamará al procedimiento de la DB.
         //Se le pasarán los datos de datosUsuario.
         //  si datosUsuario = null -> LoadFromJSON();
@@ -39,6 +40,21 @@ public class LoginSystem
         return datosUsuario.nickname;
     }
 
+    /**
+     * Comprueba si existen los datos de inicio de sesión del usuario.
+     * @return True si existe el fichero de datos, false si no.
+     */
+    public static boolean ComprobarExisteUsuario()
+    {
+        FileHandle file = Gdx.files.local(localDefaultSavePath + defaultFileName);
+        if(!file.exists())
+        {
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      * Comprueba en la BD si ese nick ya está ocupado.
      * @param username Nombre de usuario a comprobar.
@@ -46,8 +62,7 @@ public class LoginSystem
      */
     public static boolean ComprobarNickDisponible(String username)
     {
-        //TODO: dbConector.comprobarNick.
+        return dbConnector.ComprobarNickDisponible(username);
-        return true;
     }
 
     /**
@@ -69,7 +84,6 @@ public class LoginSystem
         }
 
         //Creamos el usuario.
-        //FIXME: No es demasiado bonito...
         datosUsuario = new LoginData();
         datosUsuario.nickname = username;
         datosUsuario.password = password;
@@ -78,7 +92,7 @@ public class LoginSystem
         SaveToJSON();
 
         //Lo añadimos a la DB.
-        AddUserToDB();
+        dbConnector.AddNewUser(datosUsuario);
 
     }
 
@@ -88,8 +102,7 @@ public class LoginSystem
     private static void LoadFromJSON()
     {
         //Comprobamos si el archivo existe.
-        FileHandle file = Gdx.files.local(localDefaultSavePath + defaultFileName);
+        if(!ComprobarExisteUsuario())
-        if(!file.exists())
         {
             Gdx.app.error("LoginSystem", "No se puede cargar el archivo de datos de usuario. " +
                     "El Archivo no existe");
@@ -97,6 +110,8 @@ public class LoginSystem
         }
 
         //Cargamos desde archivo.
+        FileHandle file = Gdx.files.local(localDefaultSavePath + defaultFileName);
+
         Json json = new Json();
         datosUsuario = json.fromJson(LoginData.class, file);
     }
@@ -115,16 +130,6 @@ public class LoginSystem
         file.writeString(json.prettyPrint(datos), false);
     }
 
-    /**
-     * Añade un usuario a la BD a partir de los datos de usuario.
-     *
-     * @see dbConnector
-     */
-    private static void AddUserToDB()
-    {
-        //Inserta directamente a la DB.
-        //TODO: dbConector.adduser;
-    }
 
 
     private static boolean logged = false;

core/src/uberelectron/gameSystems/Machine.java

@@ -5,15 +5,6 @@ import com.badlogic.gdx.utils.Null;
 
 import java.util.HashMap;
 
-/*
-ToDo:
- - Sistema de Atributos.
- - Revisar constructores y sus parámetros.
- - Revisar Getters/Setters y privacidad de variables.
- - ¿Mover variables arriba?
- - ¿?
- */
-
 
 /**
  * Almacena los datos relativos a una máquina.

core/src/uberelectron/gameSystems/Room.java

@@ -7,10 +7,6 @@ import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 
-    /*ToDo:
-       - Revisar métodos para mover y eliminar máquinas.
-       - Crear el método para calcular la sala.
-    */
 
 /**
  * Clase que contiene los datos de la Sala y permite interactuar con ellos.
@@ -102,7 +98,7 @@ public class Room
 
         //Añadimos el dinero que produce.
         //Todo: Esto debería ser únicamente en máquinas de dinero o
-        // en todas las máquinas. Podemos considerar que si no producen dinero tendrán valor 0.
+        // en todas las máquinas. Podemos considerar que si no producen dinero tendrán valor 0 en dineroProducido.
         dineroPorCiclo += machineToAdd.dineroProducido;
 
         //Se consume un hueco de espacio en la sala.
@@ -309,6 +305,8 @@ public class Room
     /**
      * Elimina la máquina en la posición indicada.
      * Devuelve los recursos que esta máquina consumía/generaba.
+     *
+     * FIXME: Si la máquina es de recursos, hay que comprobar que se puede eliminar.
      * @param posX Posición x de la máquina a eliminar.
      * @param posY Posición y de la máquina a eliminar.
      */
@@ -327,6 +325,41 @@ public class Room
     }
 
 
+    /**
+     * Comprueba si el archivo de guardado de la Room ha sido modificado de forma externa.
+     * Es decir, que no hay más recursos consumidos que disponibles.
+     * Que no hay más huecos utilizados de los disponibles, ...
+     * @return True si se ha modificado, false si parece correcto (se ha modificado pero bien).
+     */
+    public boolean ComprobarRoomHackeada()
+    {
+        if(espacioOcupado > espacioTotal)
+        {
+            Gdx.app.log("Room", "Esta sala tiene más huecos ocupados de los que debe...");
+            return true;
+        }
+
+        //Iteramos por los recursos.
+        for(Map.Entry<String, Integer> recurso : recursosOcupados.entrySet())
+        {
+            //Obtenemos el valor.
+            int valor = recurso.getValue();
+            //Obtenemos el valor máximo que se puede tener.
+            int valorMaximo = recursosMaximos.get(recurso.getKey());
+
+            if(valor > valorMaximo)
+            {
+                Gdx.app.log("Room", "Esta sala está gastando más recursos de los que tiene...");
+                return true;
+            }
+
+        }
+
+        //Si parece en orden...
+        return false;
+    }
+
+
     public String getRoomName() { return roomName; }
 
     public Vector2 getRoomSize() { return roomSize; }

core/src/uberelectron/gameSystems/RoomLoader.java

@@ -96,6 +96,28 @@ public class RoomLoader
         }
     }
 
+
+    /**
+     * Carga la sala del usuario indicado desde la BD.
+     * @param roomName ID de la sala que se quiere cargar.
+     * @param username Usuario dueño de esa sala.
+     */
+    public void LoadRoomFromDB(String roomName, String username)
+    {
+        //Obtenemos los datos de la sala desde la DB en formato JSON.
+        String jsonData = dbConnector.GetRoomDataFromDB(roomName, username);
+
+        //Cargamos la sala a partir de los datos.
+        Room r = loaderJson.fromJson(Room.class, jsonData);
+        r.esOnline = true;
+
+        //Añadimos la nueva sala a las salas cargadas.
+        loadedRooms.put(r.roomName, r);
+
+        Gdx.app.log("RoomLoader", "Se ha cargado la Room " + r.roomName + " correctamente.");
+    }
+
+
     /**
      * Devuelve los datos de la sala en formato JSON.
      * @param roomName Nombre de la sala a obtener.
@@ -115,6 +137,7 @@ public class RoomLoader
         return data;
     }
 
+
     /**
      * Descarga una Room dado su ID.
      * @param roomID ID de la Room a descargar.
@@ -128,6 +151,20 @@ public class RoomLoader
         // En ningún momento estamos comprobando que se haya eliminado correctamente.
     }
 
+    /**
+     * Descarga todas las salas que tenga.
+     */
+    public void UnloadAllRooms()
+    {
+        //Iteramos por todas las salas, descargándolas.
+        for(Room r : loadedRooms.values())
+        {
+            UnloadRoom(r.roomName);
+        }
+        //También podríamos ejecutar directamente un
+        //loadedRooms.clear();
+    }
+
 
     /**
      * Permite saber si una Room está cargada.
@@ -189,7 +226,6 @@ public class RoomLoader
     Room currentRoom;
     HashMap<String, Room> loadedRooms;
 
-    //ToDo: Revisar si lo dejamos así o lo sacamos directamente desde Game.
     MachineLoader mcLoader;
 
     Json loaderJson;
@@ -331,18 +367,23 @@ public class RoomLoader
                     //Añadimos su ptr en la posición.
                     room.machineData[y][x] = mc;
 
-                    //Añadimos los recursos a la sala.
+                    //Añadimos los recursos a la sala. No se rompe nada pues no se comprueba que sean válidos.
                     room.ModificarRecursosPorMaquina(mc, true);
 
-                    //room.machineData_Test[y][x] = yData.get(x).asString();
+                    //Indicamos que se ha ocupado un hueco.
+                    room.espacioOcupado += 1;
+
+                    //Añadimos el dinero que generará esa máquina y la puntuación que da.
+                    room.dineroPorCiclo += mc.dineroProducido;
+                    //TODO: Añadir puntuación que da.
                 }
             }
-            //  ToDo: Los atributos de la sala se generan al cargar la sala contando las máquinas que haya.
-            //      habría que llamar al método que lo haga. O hacerlo al añadir las máquinas.........
-
-            //Iteramos por todas las máquinas de la sala, añadiendo sus recursos manualmente.
 
+            //TODO: Añadir un método que compruebe que los recursos consumidos no son mayores que los máximos.
+            //  En caso de serlo, habrá sido una modificación manual y sería genial que le saltara un mensaje al
+            //  jugador diciendo que le hemos pillado.
 
+            // Utilizar el método: room.comprobarRoomHackeada(). No lo tengo puesto porque no está probado.
 
             return room;
         }

core/src/uberelectron/gameSystems/SaveLoader.java

@@ -16,6 +16,21 @@ public class SaveLoader
 {
     private SaveLoader() {}
 
+    /**
+     * Permite comprobar si existe el archivo de datos de partida.
+     * @return True si existe el archivo, False si no.
+     */
+    public static boolean ComprobarExistePartida(FileHandle file)
+    {
+        //Comprobamos si existe el file.
+        if(file.exists())
+        {
+            return true;
+        }
+        return false;
+    }
+
+
     /**
      * Permite cargar los datos de una partida desde un archivo JSON.
      * @param file FileHandle (internal) del JSON de datos.
@@ -23,7 +38,9 @@ public class SaveLoader
      */
     public static Save LoadFromJSON(FileHandle file)
     {
-        //FileHandle file = Gdx.files.internal(path);
+        //Comprobamos si existe antes de intentar cargarlo.
+        ComprobarExistePartida(file);
+
         Json json = new Json();
         Gdx.app.debug("SaveLoader", "Se están cargado los datos de guardado desde: " + file);
         return json.fromJson(Save.class, file);

core/src/uberelectron/gameSystems/dbConnector.java

@@ -115,6 +115,27 @@ public class dbConnector
     }
 
 
+    /**
+     * Permite comprobar si el Nick indicado está disponible en la DB
+     * y puede ser utilizado para crear un nuevo usuario.
+     * @param nick UserName que se quiere comprobar.
+     * @return True si el nick está disponible. False si ya está en uso.
+     */
+    public static boolean ComprobarNickDisponible(String nick)
+    {
+        //TODO: Hacer consulta y devolver resultado.
+        return true;
+    }
+
+    /**
+     * Dados los datos de usuario, añade un nuevo usuario a la DB.
+     * @param datosUsuario Datos del usuario que se quiere añadir.
+     */
+    public static void AddNewUser(LoginData datosUsuario)
+    {
+        //TODO: Añadir un nuevo usuario a la BD.
+    }
+
     /**
      * Devuelve el ID de partida del jugador. Utiliza el usuario con el que está autentificado.
      * Sólo se realiza la consulta una vez, luego el valor se guarda.
@@ -175,6 +196,7 @@ public class dbConnector
     public static void UploadSave()
     {
         //TODO: Guardar los datos.
+        //  También habrá que guardar la puntuación total.
 
     }
 
@@ -241,21 +263,24 @@ public class dbConnector
             Gdx.app.error("dbConnector", "No se ha podido cargar la partida del usuario " + username);
         }
 
-        //Obtenemos las salas.
+        //FIXME: También tiene que obtener una lista con las salas que se tienen
-
+        //  Es necesario para rellenar el HashMap de salas compradas y poder cargarlas.
-        //TODO: Completar la carga del Save.
-        //  Supongo que también cargará las salas de ese save.
-
 
         CerrarStatement(stt);
 
         return s;
     }
 
-    public static String GetRoomDataFromDB(String roomName)
+    /**
+     * Permite cargar la sala del usuario indicado desde DB.
+     * @param roomName Nombre de la sala a cargar.
+     * @param username Nombre del usuario creador de la sala.
+     * @return
+     */
+    public static String GetRoomDataFromDB(String roomName, String username)
     {
         //Obtenemos los datos necesarios.
-        int idPartida = GetIDPartidaFromDB();
+        int idPartida = GetIDPartidaFromDB(username);
 
         //Creamos el Statement.
         Statement stt = CrearStatement();
@@ -265,13 +290,14 @@ public class dbConnector
         try
         {
             ResultSet rs = stt.executeQuery("select sala_data from salas where" +
-                    "nombre = '" + roomName + "', " +
+                    "nombre = '" + roomName + "' and " +
                     "id_partida = " + idPartida + ";");
             datosJSON = rs.getString(0);
         } catch (SQLException e)
         {
             Gdx.app.error("dbConnector", "No se han podido obtener los datos de la " + roomName);
         }
+        CerrarStatement(stt);
 
         return datosJSON;
     }