Pequeños cambios y revisado los métodos de sala.

Se han hecho algunos pequeños cambios a algunas de las clases, así como creado algunas nuevas.
Revisados los métodos de la clase Room que permiten añadir, mover o eliminar máquinas. Debería ser funcional, pero está sin probar.

core/build.gradle

@@ -1,4 +1,7 @@
 sourceCompatibility = 1.7
+dependencies {
+    implementation 'org.jetbrains:annotations-java5:20.1.0'
+}
 [compileJava, compileTestJava]*.options*.encoding = 'UTF-8'
 
 sourceSets.main.java.srcDirs = [ "src/" ]

core/src/uberelectron/gameSystems/GameManager.java

@@ -0,0 +1,19 @@
+package uberelectron.gameSystems;
+
+public class GameManager
+{
+    public GameManager()
+    {
+
+    }
+
+    
+
+
+
+    public static MachineLoader mcLoader;
+    public static RoomLoader rmLoader;
+    public static Save saveData;
+
+
+}

core/src/uberelectron/gameSystems/Room.java

@@ -1,13 +1,18 @@
 package uberelectron.gameSystems;
 
 import com.badlogic.gdx.math.Vector2;
-import com.badlogic.gdx.utils.Json;
-import com.badlogic.gdx.utils.JsonValue;
 
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.Map;
 
-    /*ToDo: Quizás se podría añadir un contador del número de máquinas puestas,
+    /*ToDo:
+       - Quizás se podría añadir un contador del número de máquinas puestas,
         de esta forma, si no quedan huecos, ComprobarMaquina() retorna false. No es necesario serializarlo.
+       - Añadir serialización para var espacioDisponible.
+       - Revisar métodos de añadir máquinas.
+       - Revisar métodos para mover y eliminar máquinas.
+       - Crear el método para calcular la sala.
     */
 
 /***
@@ -31,6 +36,12 @@ public class Room
         // y construir el objeto pasándolos a un constructor...
     }
 
+    /***
+     * DEBUG CONSTRUCTOR!! Para meter datos de prueba.
+     * @param roomName Nombre de la room.
+     * @param width Ancho.
+     * @param height Alto.
+     */
     public Room(String roomName, int width, int height)
     {
         this.roomName = roomName;
@@ -43,51 +54,51 @@ public class Room
         this.recursosOcupados = new HashMap<>();
 
         //También habría que cargar los atributos desde algún sitio...
-        LoadRoom();
+        bgData = new int[][]
+                {
+                        {2, 2, 2, 2, 2, 2, 2, 2},
+                        {2, 3, 3, 3, 3, 3, 3, 2},
+                        {2, 3, 3, 3, 3, 3, 3, 2},
+                        {2, 3, 3, 3, 3, 3, 3, 2},
+                        {2, 2, 2, 2, 2, 2, 2, 2},
+                };
 
+        for (Machine[] machineDatum : machineData)
+        {
+            Arrays.fill(machineDatum, null);
+        }
     }
 
     /*-------------
      * Methods
      * -------------*/
-    public void LoadRoom()
-    {
-        bgData = new int[][]
-        {
-                {2, 2, 2, 2, 2, 2, 2, 2},
-                {2, 3, 3, 3, 3, 3, 3, 2},
-                {2, 3, 3, 3, 3, 3, 3, 2},
-                {2, 3, 3, 3, 3, 3, 3, 2},
-                {2, 2, 2, 2, 2, 2, 2, 2},
-        };
-
-        for(int y = 0; y < machineData.length; y++)
-        {
-            for(int x = 0; x < machineData[y].length; x++)
-            {
-                machineData[y][x] = null;
-            }
-        }
-    }
 
     public void AddMachine(int x, int y, Machine machineToAdd)
     {
-
+        boolean deRecursos = false;
-        //Comprobamos si tenemos los recursos suficientes para añadir la máquina.
+        //Si es de recursos la movemos a su método correspondiente y listo.
-        if(!ComprobarMaquina(machineToAdd))
+        if(machineToAdd.isEsDeRecursos())
         {
-            System.out.println("No tienes capacidad suficiente para esta máquina...");
+            deRecursos = true;
+        }
+
+        if(!ComprobarMaquina(machineToAdd, x, y))
+        {
+            System.out.println("No se puede añadir la máquina " + machineToAdd.machineID + " a la room " + roomName);
             return;
         }
 
-        //Debería ser algo así. Pero hay que añadir atributos para poder probar...
+        //Añadimos los recursos que consume.
-//        for(String key : machineToAdd.attributes.keySet())
+        for(Map.Entry<String, Integer> resource : machineToAdd.getAttributes().entrySet())
-//        {
+        {
-//            int newCapacidad = recursosOcupados.get(key) + machineToAdd.GetAtributeValue(key);
+            String resourceName = resource.getKey();
-//            recursosOcupados.put(key, newCapacidad);
+            ModificarRecursoSala(resourceName, resource.getValue(), deRecursos);
-//        }
+        }
 
+        //Añadimos un ptr de la máquina en las coordenadas.
         machineData[y][x] = machineToAdd;
+        //Se consume un hueco de espacio en la sala.
+        espacioOcupado += 1;
     }
 
     //He estado pensando en como va esto.
@@ -95,22 +106,37 @@ public class Room
     // Podemos usar Atributo y Atributo_max y almacenar todos en un único HashMap.
     // También podemos tener dos HashMap, uno para los atributos y otro para los máximos.
     //      Con unos if-else comprobamos/añadimos en el que corresponda según sea la máquina.
-    public boolean ComprobarCapacidad(String attribute, int valorComprobar)
+
+    /***
+     * Comprueba si se tiene la capacidad suficiente de un recurso para añadir el valor indicado.
+     * @param attribute Nombre del recurso a comprobar.
+     * @param valorComprobar Cantidad que se pretende añadir.
+     * @return True si es posible añadir esa cantidad, False si no hay capacidad suficiente.
+     */
+    public boolean ComprobarCapacidadRecurso(String attribute, int valorComprobar)
     {
         Integer max = recursosMaximos.get(attribute);
-        if(max == null)
+        Integer ocupados = recursosOcupados.get(attribute);
+        if(max == null || ocupados == null)
         {
-            System.err.println("El atributo " + attribute + "_max no existe en la sala " + roomName);
+            System.err.println("El atributo " + attribute + " no existe en la sala " + roomName);
+            return false;
         }
-        if(valorComprobar <= max)
+        if((ocupados + valorComprobar) <= max)
         {
             return true;
         }
         return false;
     }
 
-    public boolean ComprobarMaquina(Machine maquinaComprobar)
+    /***
+     * Permite comprobar si se puede añadir una máquina a la sala.
+     * @param maquinaComprobar Ptr a la máquina que se quiere comprobar.
+     * @return True si es posible añadir la máquina, False si no hay recursos o espacio suficiente.
+     */
+    public boolean ComprobarRecursos(Machine maquinaComprobar)
     {
+
         //En principio, las máquinas de recursos siempre se pueden poner.
         if(maquinaComprobar.esDeRecursos)
         {
@@ -121,7 +147,7 @@ public class Room
         for(String key : maquinaComprobar.attributes.keySet())
         {
             int value = maquinaComprobar.GetAtributeValue(key);
-            if(!ComprobarCapacidad(key, value))
+            if(!ComprobarCapacidadRecurso(key, value))
             {
                 return false;
             }
@@ -130,7 +156,146 @@ public class Room
     }
 
 
+    /***
+     * Permite comprobar si hy hueco (se puede poner una máquina) en la posición indicada.
+     * @param x posición x.
+     * @param y posición y.
+     * @return True si hay hueco y se puede poner una máquina. False si la posición ya está ocupada.
+     */
+    public boolean ComprobarPosicion(int x, int y)
+    {
+        Machine mc = machineData[y][x];
+        if(mc == null)
+        {
+            return true;
+        }
+        return false;
+    }
 
+    /***
+     * Realiza todas las comprobaciones para ver si es posible colocar la máquina indicada en la posición indicada.
+     * Hace uso del los otros métodos de comprobación.
+     * @param maquinaComprobar Ptr a la máquina. Permite comprobar si se tiene la capacidad de recursos necesaria.
+     * @param x Posición X.
+     * @param y Posición Y.
+     * @return True si es posible colocar la máquina y en esa posición. False si no se puede.
+     */
+    public boolean ComprobarMaquina(Machine maquinaComprobar, int x, int y)
+    {
+        //Comprobamos si queda hueco en la room para añadir más máquinas.
+        if((espacioOcupado+1) > espacioTotal)
+        {
+            System.out.println("No queda hueco en la room " + roomName + ", no se pueden añadir más máquinas.");
+            return false;
+        }
+
+        //Comprobamos si la posición es válida.
+        if(!ComprobarPosicion(x, y))
+        {
+            System.out.println("No se puede poner una máquina en x:" + x + ", y:"
+                                       + y + " de la room " + roomName
+                                       + ". La posición ya está ocupada.");
+            return false;
+        }
+
+        //Comprobamos que tenemos todos los recursos necesarios.
+        if(!ComprobarRecursos(maquinaComprobar))
+        {
+            System.out.println("No tienes capacidad de recursos suficiente para esta máquina...");
+            return false;
+        }
+
+        //Si está correcto, true.
+        return true;
+    }
+
+
+    /***
+     * Permite modificar de forma segura los recursos de la sala. Pueden sumarse o restarse.
+     * @param resourceName Nombre del recurso a modificar.
+     * @param mod Modificador a aplicar (positivo suma, negativo se resta).
+     * @param esMaximo Indica si se trata de la capacidad máxima de la sala (true= o de la capacidad ocupada (false).
+     * @return True si se ha conseguido modificar. False si ha ocurrido un error.
+     */
+    public boolean ModificarRecursoSala(String resourceName, int mod, boolean esMaximo)
+    {
+        //Obtenemos los actuales recursos ocupados.
+        Integer act = null;
+        if(esMaximo)
+        {
+            act = recursosMaximos.get(resourceName);
+        }
+        if(!esMaximo)
+        {
+            act = recursosOcupados.get(resourceName);
+        }
+        if(act == null)
+        {
+            System.err.println("La room" + roomName + " no tiene el recurso " + resourceName);
+            return false;
+        }
+        //Añadimos el modificador y lo actualizamos.
+        act += mod;
+        if(esMaximo)
+        {
+            recursosMaximos.put(resourceName, act);
+        }
+        if(!esMaximo)
+        {
+            recursosOcupados.put(resourceName, act);
+        }
+        return true;
+    }
+
+    /***
+     * Mueve una máquina de una casilla a otra.
+     * Como solo la movemos, no hace falta modificar atributos de la sala.
+     * @param oldX Posición X antigua.
+     * @param oldY Posición y antigua.
+     * @param newX Posición x nueva.
+     * @param newY Posición y nueva.
+     */
+    public void MoverMaquina(int oldX, int oldY, int newX, int newY)
+    {
+        //Comprobamos si la posición nueva está disponible.
+        if(!ComprobarPosicion(newX, newY))
+        {
+            System.out.println("La posición nueva: " + newX + ", " + newY + " ya está ocupada.");
+            return;
+        }
+
+        //Comprobamos si existe una máquina en la posición antigua.
+        Machine mc = machineData[oldY][oldX];
+        if(mc == null)
+        {
+            System.out.println("No existe ninguna máquina en la posición inicia: " + newX + ", " + newY);
+            return;
+        }
+        //Si está correcto, la movemos.
+        machineData[oldY][oldX] = null;
+        machineData[newY][newX] = mc;
+    }
+
+
+    /***
+     * Elimina la máquina en la posición indicada.
+     * Devuelve los recursos que esta máquina consumía/generaba.
+     * @param posX Posición x de la máquina a eliminar.
+     * @param posY Posición y de la máquina a eliminar.
+     */
+    public void EliminarMaquina(int posX, int posY)
+    {
+        //Obtenemos la máquina de esta posición.
+        Machine mc = machineData[posY][posX];
+
+        boolean deRecursos = mc.isEsDeRecursos();
+
+        //Iteramos por sus recursos, modificándolos.
+        for(Map.Entry<String, Integer> recurso : mc.getAttributes().entrySet())
+        {
+            ModificarRecursoSala(recurso.getKey(), -recurso.getValue(), deRecursos);
+        }
+    }
     /*-------------
      * Variables
      * -------------*/
@@ -155,4 +320,9 @@ public class Room
     HashMap<String, Integer> recursosMaximos;
 
     boolean esOnline = false;
+    //Contador de la cantidad de máquinas añadidas.
+    int espacioOcupado;
+    //Indica cuantas máquinas caben en la sala.
+    //Puede serializarse (recomendable) o calcularse con las dimensiones de la sala.
+    int espacioTotal;
 }

core/src/uberelectron/gameSystems/SaveLoader.java

@@ -0,0 +1,36 @@
+package uberelectron.gameSystems;
+
+import com.badlogic.gdx.Gdx;
+import com.badlogic.gdx.files.FileHandle;
+import com.badlogic.gdx.utils.Json;
+import com.badlogic.gdx.utils.JsonWriter;
+
+public class SaveLoader
+{
+    public SaveLoader()
+    {
+
+    }
+
+    public static Save LoadFromJSON(String path)
+    {
+        FileHandle file = Gdx.files.internal(path);
+        Json json = new Json();
+
+        return json.fromJson(Save.class, file);
+    }
+
+    public static void SaveToJSON(Save saveToSerialize, String path)
+    {
+        //Creamos y configuramos el serializador.
+        Json json = new Json();
+        json.setOutputType(JsonWriter.OutputType.json);
+        json.setUsePrototypes(false);
+
+        String data = json.toJson(saveToSerialize);
+        FileHandle file = Gdx.files.local(path);
+        file.writeString(json.prettyPrint(data), false);
+        System.out.println("Se ha guardado un save en " + path);
+    }
+
+}

core/src/uberelectron/gameSystems/UserData.java

@@ -0,0 +1,19 @@
+package uberelectron.gameSystems;
+
+/***
+ * Almacena los datos del usuario.
+ *
+ * @author Daniel García
+ */
+public class UserData
+{
+    public UserData()
+    {
+
+    }
+
+    String nickname;
+    int id;
+    String password;
+
+}