Add a completely new system for late/endgame content (#1754)

* basic work

* typo fixes

* make an enum folder

* location enums

* space project manager

* implement the space project teams

* commands

* move things around and new things

* upgrade work

* requirement work

* if possible use an upgrades values

* cleanup

* more helpers in command

* fix AOOBE

* fix world saved data

* builder for requirements

* add command autocomplete

* fix command npe

* mark world saved data dirty

* switch to saving to json string. this is fine

* fix npe

* fix files not saving correctly. serialization

* spotless

* part 1 of fixing json saving

* working json file saving

* rename fields

* full implementation of SP_Upgrade

* fixes

* cleanup

* texture prep

* documentation part 1

* documentation part 2 and rework of json saving

* fix the missed conversions

* set texture when copying

* more interface usage and fixes

* rework saving.

* Added rudimentary NEI handler for projects

* Revert "Added rudimentary NEI handler for projects"

This reverts commit 6d8210e25b27fee7dc1865d1afa91708a8d9b875.

* address NPEs

* some textures

* higher quality textures, put in the moon as a temp texture

* add a check to create a team if one smt weird happens

* command work

* add ability to localize the space bodies

* Added disabled button and toggle button

* Added possibility to not render the original stacksize of item stacks in NEI

* Added NEI handler

* Fixes item count on tooltip always rendering as 1

* Fix refactor

* 5 new body textures

* fix misspelled texture name

---------

Co-authored-by: minecraft7771 <maxim235@gmx.de>

14 files changed, 2415 insertions, 0 deletions

diff --git a/src/main/java/gregtech/common/misc/spaceprojects/SpaceProjectManager.java b/src/main/java/gregtech/common/misc/spaceprojects/SpaceProjectManager.java
new file mode 100644
index 0000000000..81c7fac375
--- /dev/null
+++ b/src/main/java/gregtech/common/misc/spaceprojects/SpaceProjectManager.java
@@ -0,0 +1,278 @@
+package gregtech.common.misc.spaceprojects;
+
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import net.minecraft.server.MinecraftServer;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import gregtech.api.util.GT_Recipe;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceBody;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceProject;
+
+/**
+ * @author BlueWeabo
+ */
+public class SpaceProjectManager {
+
+    /**
+     * Do not use! Only meant to be used in SpaceProjectWorldSavedData.java
+     */
+    public static Map<UUID, Map<Pair<ISpaceBody, String>, ISpaceProject>> spaceTeamProjects = new HashMap<>();
+    /**
+     * Do not use! Only meant to be used in SpaceProjectWorldSavedData.java Stores a Players UUID to the Leader UUID,
+     * players in lone groups give back their own UUID.
+     */
+    public static Map<UUID, UUID> spaceTeams = new HashMap<>();
+
+    /**
+     * Stores all the locations to a hash map to be accessed easier instead of through an enum
+     */
+    private static final HashMap<String, ISpaceBody> spaceLocations = new HashMap<>();
+
+    /**
+     * Stores all projects that have been made. Only adds them to this map if {@link #addProject(ISpaceProject)} has
+     * been used
+     */
+    private static final Map<String, ISpaceProject> spaceProjects = new HashMap<>();
+
+    // #region Space Project Team Helper methods
+
+    /**
+     * Used to get a specific project of the team dependent on the location and the project's name
+     */
+    public static ISpaceProject getTeamProject(UUID member, ISpaceBody location, String projectName) {
+        Map<Pair<ISpaceBody, String>, ISpaceProject> map = spaceTeamProjects.get(getLeader(member));
+        if (map == null) {
+            return null;
+        }
+        return map.get(Pair.of(location, projectName));
+    }
+
+    /**
+     * Makes a new Map for the teams if they don't have one. Adds a project to the team's project map.
+     *
+     * @param member      Member of the team.
+     * @param location    The location of where the project will belong to.
+     * @param projectName The name of the project being added.
+     * @param project     Project which will be added to the team.
+     * @return Returns true when a project was added to the map of the player. Returns false otherwise.
+     */
+    public static boolean addTeamProject(UUID member, ISpaceBody location, String projectName, ISpaceProject project) {
+        if (!spaceTeamProjects.containsKey(getLeader(member)) || spaceTeamProjects.get(getLeader(member)) == null) {
+            spaceTeamProjects.put(getLeader(member), new HashMap<Pair<ISpaceBody, String>, ISpaceProject>());
+        }
+
+        Map<Pair<ISpaceBody, String>, ISpaceProject> map = spaceTeamProjects.get(getLeader(member));
+        if (map.containsKey(Pair.of(location, projectName))) {
+            return false;
+        }
+
+        project.setProjectLocation(location);
+        map.put(Pair.of(location, projectName), project);
+        SpaceProjectWorldSavedData.INSTANCE.markDirty();
+        return true;
+    }
+
+    /**
+     * Check whether a team has a project or not
+     *
+     * @param member  Member of the team
+     * @param project The project, which you are checking for. This only compares the internal names of the project.
+     * @return True if the team has said project, false otherwise
+     */
+    public static boolean teamHasProject(UUID member, ISpaceProject project) {
+        Map<Pair<ISpaceBody, String>, ISpaceProject> map = spaceTeamProjects.get(getLeader(member));
+        if (map == null) {
+            return false;
+        }
+
+        return map.containsValue(project);
+    }
+
+    /**
+     * Used to handle when 2 players want to join together in a team. Player A can join player B's team. If player C
+     * gets an invite from A, C will join player B's team.
+     *
+     * @param teamMember Member which is joining the teamLeader
+     * @param teamLeader Leader of the party
+     */
+    public static void putInTeam(UUID teamMember, UUID teamLeader) {
+        if (teamMember.equals(teamLeader)) {
+            spaceTeams.put(teamMember, teamLeader);
+        } else if (!spaceTeams.get(teamLeader).equals(teamLeader)) {
+            putInTeam(teamMember, spaceTeams.get(teamLeader));
+        } else {
+            spaceTeams.put(teamMember, teamLeader);
+        }
+
+        SpaceProjectWorldSavedData.INSTANCE.markDirty();
+    }
+
+    /**
+     * Used to give back the UUID of the team leader.
+     *
+     * @return The UUID of the team leader.
+     */
+    public static UUID getLeader(UUID teamMember) {
+        checkOrCreateTeam(teamMember);
+        return spaceTeams.get(teamMember);
+    }
+
+    /**
+     * Used the multiblocks to check whether a given player has a team or not. If they don't have a team create one
+     * where they are their own leader.
+     *
+     * @param teamMember Member to check for.
+     */
+    public static void checkOrCreateTeam(UUID teamMember) {
+        if (spaceTeams.containsKey(teamMember)) {
+            return;
+        }
+
+        spaceTeams.put(teamMember, teamMember);
+        SpaceProjectWorldSavedData.INSTANCE.markDirty();
+    }
+
+    /**
+     * Will give back all the projects a team has made or is making.
+     *
+     * @param member UUID of the team member, used to find the leader of the team.
+     * @return All the projects a team has.
+     */
+    public static Collection<ISpaceProject> getTeamSpaceProjects(UUID member) {
+        Map<Pair<ISpaceBody, String>, ISpaceProject> map = spaceTeamProjects.get(getLeader(member));
+        if (map == null) {
+            return null;
+        }
+
+        return map.values();
+    }
+
+    /**
+     * Getting the project of a Team or a new copy.
+     *
+     * @param member      UUID of the team member, which is used to find the team leader.
+     * @param projectName The name of the project, which needs to be found.
+     * @param location    The location at which the project is found at.
+     * @return the project that the team has or a copy of a project.
+     */
+    public static ISpaceProject getTeamProjectOrCopy(UUID member, String projectName, ISpaceBody location) {
+        Map<Pair<ISpaceBody, String>, ISpaceProject> map = spaceTeamProjects.get(getLeader(member));
+        if (map == null) {
+            return getProject(projectName);
+        }
+
+        return map.getOrDefault(Pair.of(location, projectName), getProject(projectName));
+    }
+
+    // #endregion
+
+    // #region Project Helper methods
+
+    /**
+     * Used to add projects to the internal map.
+     *
+     * @param project Newly created project.
+     */
+    public static void addProject(ISpaceProject project) {
+        spaceProjects.put(project.getProjectName(), project);
+        GT_Recipe.GT_Recipe_Map.sFakeSpaceProjectRecipes.add(
+                new GT_Recipe.GT_Recipe_Map.GT_FakeSpaceProjectRecipe(
+                        false,
+                        project.getTotalItemsCost(),
+                        project.getTotalFluidsCost(),
+                        project.getProjectBuildTime(),
+                        (int) project.getProjectVoltage(),
+                        project.getTotalStages(),
+                        project.getProjectName()));
+    }
+
+    /**
+     * @param projectName Internal name of the project.
+     * @return a copy of the stored project.
+     */
+    public static ISpaceProject getProject(String projectName) {
+        ISpaceProject tProject = spaceProjects.get(projectName);
+        return tProject != null ? tProject.copy() : null;
+    }
+
+    /**
+     * Should only be used for GUIs!
+     *
+     * @return The Map that the projects are stored at.
+     */
+    public static Map<String, ISpaceProject> getProjectsMap() {
+        return spaceProjects;
+    }
+
+    /**
+     * Should only be used for GUIs!
+     *
+     * @return A Collection of all the projects contained in the map.
+     */
+    public static Collection<ISpaceProject> getAllProjects() {
+        return spaceProjects.values();
+    }
+
+    // #endregion
+
+    // #region Location Helper methods
+
+    /**
+     * Adds a location to the internal map. For it to be used later
+     *
+     * @param location to add to the internal map
+     */
+    public static void addLocation(ISpaceBody location) {
+        spaceLocations.put(location.getName(), location);
+    }
+
+    /**
+     *
+     * @return a Collection of all locations, which have been registered.
+     */
+    public static Collection<ISpaceBody> getLocations() {
+        return spaceLocations.values();
+    }
+
+    /**
+     *
+     * @return a Collection fo all location names, which have been registered
+     */
+    public static Collection<String> getLocationNames() {
+        return spaceLocations.keySet();
+    }
+
+    /**
+     *
+     * @param locationName Name used to search for the location
+     * @return The location, which has been registered with said name
+     */
+    public static ISpaceBody getLocation(String locationName) {
+        return spaceLocations.get(locationName);
+    }
+
+    // #endregion
+
+    // #region General Helper methods
+
+    /**
+     * Gets the UUID using the player's username
+     */
+    public static UUID getPlayerUUIDFromName(String playerName) {
+        return MinecraftServer.getServer().func_152358_ax().func_152655_a(playerName).getId();
+    }
+
+    /**
+     * Gets the player's name using their UUID
+     */
+    public static String getPlayerNameFromUUID(UUID playerUUID) {
+        return MinecraftServer.getServer().func_152358_ax().func_152652_a(playerUUID).getName();
+    }
+
+    // #endregion
+}
diff --git a/src/main/java/gregtech/common/misc/spaceprojects/SpaceProjectWorldSavedData.java b/src/main/java/gregtech/common/misc/spaceprojects/SpaceProjectWorldSavedData.java
new file mode 100644
index 0000000000..6dc80db3ec
--- /dev/null
+++ b/src/main/java/gregtech/common/misc/spaceprojects/SpaceProjectWorldSavedData.java
@@ -0,0 +1,275 @@
+package gregtech.common.misc.spaceprojects;
+
+import static gregtech.common.misc.spaceprojects.SpaceProjectManager.spaceTeamProjects;
+import static gregtech.common.misc.spaceprojects.SpaceProjectManager.spaceTeams;
+import static gregtech.common.misc.spaceprojects.enums.JsonVariables.*;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.UUID;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+import net.minecraft.world.WorldSavedData;
+import net.minecraft.world.storage.MapStorage;
+import net.minecraftforge.event.world.WorldEvent;
+
+import org.apache.commons.lang3.tuple.Pair;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonDeserializationContext;
+import com.google.gson.JsonDeserializer;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonSerializationContext;
+import com.google.gson.JsonSerializer;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+
+import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import gregtech.common.misc.spaceprojects.enums.SolarSystem;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceBody;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceProject;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceProject.ISP_Upgrade;
+
+/**
+ * This class is used so that I can write and read to a json file before the world is opened. On server starting is too
+ * late for this as the data stored in the files is needed before entities load their nbt data
+ * 
+ * @author BlueWeabo
+ */
+public class SpaceProjectWorldSavedData extends WorldSavedData {
+
+    public static SpaceProjectWorldSavedData INSTANCE;
+
+    private static final Gson GSON_SPACE_PROJECT = new GsonBuilder().serializeNulls().enableComplexMapKeySerialization()
+            .registerTypeAdapter(spaceTeamProjects.getClass(), new SpaceTeamProjectsMapAdapter())
+            .registerTypeAdapter(Map.class, new SpaceTeamProjectsMapAdapter())
+            .registerTypeAdapter(Pair.of((ISpaceBody) SolarSystem.Ariel, "").getClass(), new PairAdapter())
+            .registerTypeAdapter(Pair.class, new PairAdapter())
+            .registerTypeAdapter(ISpaceProject.class, new SpaceProjectAdapter())
+            .registerTypeAdapter(ISP_Upgrade.class, new SP_UpgradeAdapter())
+            .registerTypeHierarchyAdapter(ISpaceProject.class, new SpaceProjectAdapter())
+            .registerTypeHierarchyAdapter(ISP_Upgrade.class, new SP_UpgradeAdapter()).create();
+    private static final Gson GSON_TEAMS = new GsonBuilder().serializeNulls().create();
+
+    private static final String DATA_NAME = "GT_SpaceProjectData";
+
+    private static final String SPACE_TEAM_PROJECTS_JSON = "spaceTeamProject.json";
+
+    private static final String SPACE_TEAMS_JSON = "spaceTeams.json";
+
+    private static File spaceTeamsFile;
+    private static File teamProjectsFile;
+
+    public SpaceProjectWorldSavedData() {
+        super(DATA_NAME);
+    }
+
+    public SpaceProjectWorldSavedData(String aData) {
+        super(aData);
+    }
+
+    @Override
+    public void readFromNBT(NBTTagCompound aNBT) {
+        try (JsonReader reader = new JsonReader(new FileReader(teamProjectsFile))) {
+            spaceTeamProjects = GSON_SPACE_PROJECT.fromJson(reader, spaceTeamProjects.getClass());
+        } catch (Exception e) {
+            System.out.print("FAILED TO LOAD: " + SPACE_TEAM_PROJECTS_JSON);
+            e.printStackTrace();
+        }
+
+        try (JsonReader reader = new JsonReader(new FileReader(spaceTeamsFile))) {
+            spaceTeams = GSON_TEAMS.fromJson(reader, spaceTeams.getClass());
+        } catch (Exception e) {
+            System.out.print("FAILED TO LOAD: " + SPACE_TEAMS_JSON);
+            e.printStackTrace();
+        }
+
+        if (spaceTeams == null) {
+            spaceTeams = new HashMap<>();
+        }
+    }
+
+    @Override
+    public void writeToNBT(NBTTagCompound aNBT) {
+        try (JsonWriter writer = new JsonWriter(new FileWriter(teamProjectsFile))) {
+            GSON_SPACE_PROJECT.toJson(spaceTeamProjects, spaceTeamProjects.getClass(), writer);
+        } catch (Exception ex) {
+            System.out.print("FAILED TO SAVE: " + SPACE_TEAM_PROJECTS_JSON);
+            ex.printStackTrace();
+        }
+
+        try (JsonWriter writer = new JsonWriter(new FileWriter(spaceTeamsFile))) {
+            GSON_TEAMS.toJson(spaceTeams, spaceTeams.getClass(), writer);
+        } catch (Exception ex) {
+            System.out.print("FAILED TO SAVE: " + SPACE_TEAMS_JSON);
+            ex.printStackTrace();
+        }
+    }
+
+    private static void loadInstance(World aWorld) {
+        spaceTeamProjects.clear();
+        spaceTeams.clear();
+        spaceTeamsFile = new File(aWorld.getSaveHandler().getWorldDirectory(), SPACE_TEAMS_JSON);
+        teamProjectsFile = new File(aWorld.getSaveHandler().getWorldDirectory(), SPACE_TEAM_PROJECTS_JSON);
+        MapStorage tStorage = aWorld.mapStorage;
+        INSTANCE = (SpaceProjectWorldSavedData) tStorage.loadData(SpaceProjectWorldSavedData.class, DATA_NAME);
+        if (INSTANCE == null) {
+            INSTANCE = new SpaceProjectWorldSavedData();
+            tStorage.setData(DATA_NAME, INSTANCE);
+        }
+        INSTANCE.markDirty();
+    }
+
+    @SubscribeEvent
+    public void onWorldLoad(WorldEvent.Load aEvent) {
+        if (!aEvent.world.isRemote && aEvent.world.provider.dimensionId == 0) {
+            loadInstance(aEvent.world);
+        }
+    }
+
+    private static class PairAdapter
+            implements JsonSerializer<Pair<ISpaceBody, String>>, JsonDeserializer<Pair<ISpaceBody, String>> {
+
+        @Override
+        public JsonElement serialize(Pair<ISpaceBody, String> src, Type typeOfSrc, JsonSerializationContext context) {
+            JsonObject pair = new JsonObject();
+            pair.addProperty(PAIR_LEFT, src.getLeft().getName());
+            pair.addProperty(PAIR_RIGHT, src.getRight());
+            return pair;
+        }
+
+        @Override
+        public Pair<ISpaceBody, String> deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
+                throws JsonParseException {
+            Pair<ISpaceBody, String> pair = null;
+            if (json.isJsonObject()) {
+                JsonObject obj = json.getAsJsonObject();
+                pair = Pair.of(
+                        SpaceProjectManager.getLocation(obj.get(PAIR_LEFT).getAsString()),
+                        obj.get(PAIR_RIGHT).getAsString());
+            }
+            return pair;
+        }
+    }
+
+    private static class SpaceProjectAdapter implements JsonSerializer<ISpaceProject>, JsonDeserializer<ISpaceProject> {
+
+        @Override
+        public JsonElement serialize(ISpaceProject src, Type typeOfSrc, JsonSerializationContext context) {
+            JsonObject obj = new JsonObject();
+            obj.addProperty(PROJECT_NAME, src.getProjectName());
+            obj.addProperty(PROJECT_CURRENT_STAGE, src.getCurrentStage());
+            obj.addProperty(PROJECT_LOCATION, src.getProjectLocation().getName());
+            obj.add(PROJECT_CURRENT_UPGRADE, context.serialize(src.getUpgradeBeingBuilt()));
+            obj.add(PROJECT_UPGRADES_BUILT, context.serialize(src.getAllBuiltUpgrades()));
+            return obj;
+        }
+
+        @Override
+        public ISpaceProject deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
+                throws JsonParseException {
+            if (!json.isJsonObject()) {
+                return null;
+            }
+            JsonObject obj = json.getAsJsonObject();
+            String projectName = obj.get(PROJECT_NAME).getAsString();
+            ISpaceProject project = SpaceProjectManager.getProject(projectName);
+            int projectCurrentStage = obj.get(PROJECT_CURRENT_STAGE).getAsInt();
+            ISP_Upgrade[] projectUpgradesBuilt = context
+                    .deserialize(obj.get(PROJECT_UPGRADES_BUILT), ISP_Upgrade.class);
+            ISP_Upgrade projectCurrentUpgrade = context
+                    .deserialize(obj.get(PROJECT_CURRENT_UPGRADE), ISP_Upgrade.class);
+            ISpaceBody projectLocation = SpaceProjectManager.getLocation(obj.get(PROJECT_LOCATION).getAsString());
+            project.setBuiltUpgrade(projectUpgradesBuilt);
+            project.setCurrentUpgradeBeingBuilt(projectCurrentUpgrade);
+            project.setProjectLocation(projectLocation);
+            project.setProjectCurrentStage(projectCurrentStage);
+            return project;
+        }
+    }
+
+    private static class SP_UpgradeAdapter implements JsonSerializer<ISP_Upgrade>, JsonDeserializer<ISP_Upgrade> {
+
+        @Override
+        public JsonElement serialize(ISP_Upgrade src, Type typeOfSrc, JsonSerializationContext context) {
+            JsonObject obj = new JsonObject();
+            obj.addProperty(UPGRADE_NAME, src.getUpgradeName());
+            obj.addProperty(UPGRADE_PROJECT_PARENT, src.getParentProject().getProjectName());
+            obj.addProperty(UPGRADE_CURRENT_STAGE, src.getCurrentStage());
+            return obj;
+        }
+
+        @Override
+        public ISP_Upgrade deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context)
+                throws JsonParseException {
+            if (!json.isJsonObject()) {
+                return null;
+            }
+            JsonObject obj = json.getAsJsonObject();
+            String projectName = obj.get(UPGRADE_PROJECT_PARENT).getAsString();
+            ISpaceProject project = SpaceProjectManager.getProject(projectName);
+            ISP_Upgrade upgrade = project.getUpgrade(obj.get(UPGRADE_NAME).getAsString());
+            if (upgrade == null) {
+                return null;
+            }
+            upgrade = upgrade.copy();
+            upgrade.setUpgradeCurrentStage(obj.get(UPGRADE_CURRENT_STAGE).getAsInt());
+            return upgrade;
+        }
+    }
+
+    private static class SpaceTeamProjectsMapAdapter
+            implements JsonSerializer<Map<UUID, Map<Pair<ISpaceBody, String>, ISpaceProject>>>,
+            JsonDeserializer<Map<UUID, Map<Pair<ISpaceBody, String>, ISpaceProject>>> {
+
+        @Override
+        public JsonElement serialize(Map<UUID, Map<Pair<ISpaceBody, String>, ISpaceProject>> src, Type typeOfSrc,
+                JsonSerializationContext context) {
+            JsonArray map = new JsonArray();
+            for (Entry<UUID, Map<Pair<ISpaceBody, String>, ISpaceProject>> firstEntry : src.entrySet()) {
+                JsonObject teamMap = new JsonObject();
+                teamMap.add(MAP_UUID, context.serialize(firstEntry.getKey()));
+                JsonArray teamProjectMap = new JsonArray();
+                for (Entry<Pair<ISpaceBody, String>, ISpaceProject> secondEntry : firstEntry.getValue().entrySet()) {
+                    JsonObject projectMap = new JsonObject();
+                    projectMap.add(MAP_PAIR, context.serialize(secondEntry.getKey()));
+                    projectMap.add(MAP_PROJECT, context.serialize(secondEntry.getValue()));
+                    teamProjectMap.add(projectMap);
+                }
+                teamMap.add(MAP_MAP, teamProjectMap);
+                map.add(teamMap);
+            }
+            return map;
+        }
+
+        @Override
+        public Map<UUID, Map<Pair<ISpaceBody, String>, ISpaceProject>> deserialize(JsonElement json, Type typeOfT,
+                JsonDeserializationContext context) throws JsonParseException {
+            JsonArray mapArray = json.getAsJsonArray();
+            Map<UUID, Map<Pair<ISpaceBody, String>, ISpaceProject>> map = new HashMap<>();
+            for (JsonElement teamMapElement : mapArray) {
+                JsonObject teamMap = teamMapElement.getAsJsonObject();
+                UUID uuid = context.deserialize(teamMap.get(MAP_UUID), UUID.class);
+                Map<Pair<ISpaceBody, String>, ISpaceProject> projectMap = new HashMap<>();
+                for (JsonElement teamProjectMapElement : teamMap.get(MAP_MAP).getAsJsonArray()) {
+                    JsonObject teamProjectMap = teamProjectMapElement.getAsJsonObject();
+                    Pair<ISpaceBody, String> pair = context.deserialize(teamProjectMap.get(MAP_PAIR), Pair.class);
+                    ISpaceProject project = context.deserialize(teamProjectMap.get(MAP_PROJECT), ISpaceProject.class);
+                    projectMap.put(pair, project);
+                }
+                map.put(uuid, projectMap);
+            }
+            return map;
+        }
+    }
+}
diff --git a/src/main/java/gregtech/common/misc/spaceprojects/base/SP_Requirements.java b/src/main/java/gregtech/common/misc/spaceprojects/base/SP_Requirements.java
new file mode 100644
index 0000000000..0cce6f08f0
--- /dev/null
+++ b/src/main/java/gregtech/common/misc/spaceprojects/base/SP_Requirements.java
@@ -0,0 +1,77 @@
+package gregtech.common.misc.spaceprojects.base;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import gregtech.common.misc.spaceprojects.enums.SpaceBodyType;
+import gregtech.common.misc.spaceprojects.enums.StarType;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceProject;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceProject.ISP_Requirements;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceProject.ISP_Upgrade;
+
+/**
+ * @author BlueWeabo
+ */
+public class SP_Requirements implements ISP_Requirements {
+
+    // #region Variables
+
+    protected SpaceBodyType spaceBody = SpaceBodyType.NONE;
+    protected StarType star = StarType.NotAStar;
+    protected List<ISpaceProject> spaceProjects = new ArrayList<>();
+    protected List<ISP_Upgrade> upgrades = new ArrayList<>();
+
+    // #endregion
+
+    // #region Getters
+
+    @Override
+    public SpaceBodyType getBodyType() {
+        return spaceBody;
+    }
+
+    @Override
+    public StarType getStarType() {
+        return star;
+    }
+
+    @Override
+    public List<ISpaceProject> getProjects() {
+        return spaceProjects;
+    }
+
+    @Override
+    public List<ISP_Upgrade> getUpgrades() {
+        return upgrades;
+    }
+
+    // #endregion
+
+    // #region Setters/Builder
+
+    public SP_Requirements setSpaceBodyType(SpaceBodyType spaceBodyType) {
+        spaceBody = spaceBodyType;
+        return this;
+    }
+
+    public SP_Requirements setStarType(StarType starType) {
+        star = starType;
+        return this;
+    }
+
+    public SP_Requirements setUpgrades(ISP_Upgrade... requirementUpgrades) {
+        for (ISP_Upgrade upgrade : requirementUpgrades) {
+            upgrades.add(upgrade);
+        }
+        return this;
+    }
+
+    public SP_Requirements setSpaceProjects(ISpaceProject... requirementProjects) {
+        for (ISpaceProject project : requirementProjects) {
+            spaceProjects.add(project);
+        }
+        return this;
+    }
+
+    // #endregion
+}
diff --git a/src/main/java/gregtech/common/misc/spaceprojects/base/SP_Upgrade.java b/src/main/java/gregtech/common/misc/spaceprojects/base/SP_Upgrade.java
new file mode 100644
index 0000000000..6a1fe82791
--- /dev/null
+++ b/src/main/java/gregtech/common/misc/spaceprojects/base/SP_Upgrade.java
@@ -0,0 +1,347 @@
+package gregtech.common.misc.spaceprojects.base;
+
+import java.util.UUID;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.StatCollector;
+import net.minecraftforge.fluids.FluidStack;
+
+import gregtech.common.misc.spaceprojects.SpaceProjectManager;
+import gregtech.common.misc.spaceprojects.enums.UpgradeStatus;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceProject;
+import gregtech.common.misc.spaceprojects.interfaces.ISpaceProject.ISP_Upgrade;
+
+/**
+ * @author BlueWeabo
+ */
+public class SP_Upgrade implements ISP_Upgrade {
+
+    // #region Variables
+
+    protected String name;
+    protected String unlocalizedName;
+    protected ItemStack[] itemsCost;
+    protected FluidStack[] fluidsCost;
+    protected int totalStages;
+    protected int currentStage;
+    protected int buildTime;
+    protected long voltage;
+    protected SP_Requirements requirements;
+    protected ISpaceProject projectBelongingTo;
+
+    // #endregion
+
+    // #region Getters
+
+    @Override
+    public String getUpgradeName() {
+        return name;
+    }
+
+    @Override
+    public String getUnlocalizedName() {
+        return unlocalizedName;
+    }
+
+    @Override
+    public String getLocalizedName() {
+        return StatCollector.translateToLocal(unlocalizedName);
+    }
+
+    @Override
+    public ItemStack[] getItemsCostPerStage() {
+        return itemsCost;
+    }
+
+    @Override
+    public ItemStack getItemCostPerStage(int index) {
+        if (itemsCost == null || index < 0 || index >= itemsCost.length) {
+            return null;
+        }
+
+        return itemsCost[index];
+    }
+
+    @Override
+    public ItemStack[] getCurrentItemsProgress() {
+        ItemStack[] currentItemsProgress = new ItemStack[itemsCost.length];
+        int index = 0;
+        for (ItemStack item : itemsCost) {
+            ItemStack copy = item.copy();
+            copy.stackSize *= getCurrentStage();
+            currentItemsProgress[index++] = copy;
+        }
+
+        return currentItemsProgress;
+    }
+
+    @Override
+    public ItemStack getCurrentItemProgress(int index) {
+        if (itemsCost == null || index < 0 || index >= itemsCost.length || itemsCost[index] == null) {
+            return null;
+        }
+
+        ItemStack item = itemsCost[index].copy();
+        item.stackSize *= getCurrentStage();
+        return item;
+    }
+
+    @Override
+    public ItemStack[] getTotalItemsCost() {
+        ItemStack[] totalItemsCost = new ItemStack[itemsCost.length];
+        int index = 0;
+        for (ItemStack item : itemsCost) {
+            ItemStack copy = item.copy();
+            copy.stackSize *= getTotalStages();
+            totalItemsCost[index++] = copy;
+        }
+
+        return totalItemsCost;
+    }
+
+    @Override
+    public ItemStack getTotalItemCost(int index) {
+        if (itemsCost == null || index < 0 || index >= itemsCost.length || itemsCost[index] == null) {
+            return null;
+        }
+
+        ItemStack item = itemsCost[index].copy();
+        item.stackSize *= getTotalStages();
+        return item;
+    }
+
+    @Override
+    public FluidStack[] getFluidsCostPerStage() {
+        return fluidsCost;
+    }
+
+    @Override
+    public FluidStack getFluidCostPerStage(int index) {
+        if (fluidsCost == null || index < 0 || index >= fluidsCost.length) {
+            return null;
+        }
+
+        return fluidsCost[index];
+    }
+
+    @Override
+    public FluidStack[] getCurrentFluidsProgress() {
+        if (fluidsCost == null) {
+            return null;
+        }
+
+        FluidStack[] currentFluidsProgress = new FluidStack[fluidsCost.length];
+        int index = 0;
+        for (FluidStack fluid : fluidsCost) {
+            FluidStack copy = fluid.copy();
+            copy.amount *= getCurrentStage();
+            currentFluidsProgress[index++] = copy;
+        }
+
+        return currentFluidsProgress;
+    }
+
+    @Override
+    public FluidStack getCurrentFluidProgress(int index) {
+        if (fluidsCost == null || index < 0 || index