fix(world): make new world generation deterministic

engine/src/main/java/org/destinationsol/SolApplication.java

@@ -350,7 +350,7 @@ public void play(boolean tut, String shipName, boolean isNewGame, WorldConfig wo
         entitySystemManager.initialise();
 
         solGame.createUpdateSystems();
-        solGame.startGame(shipName, isNewGame, worldConfig, entitySystemManager);
+        solGame.startGame(shipName, isNewGame, entitySystemManager);
 
         if (!isNewGame) {
             try {

engine/src/main/java/org/destinationsol/game/GalaxyFiller.java

@@ -43,6 +43,7 @@
 
 import javax.inject.Inject;
 import java.util.ArrayList;
+import java.util.List;
 
 public class GalaxyFiller {
     private static final float STATION_CONSUME_SECTOR = 45f;
@@ -140,7 +141,7 @@ public void fill(SolGame game, HullConfigManager hullConfigManager, ItemManager
             return;
         }
         createStarPorts(game);
-        ArrayList<SolarSystem> systems = game.getGalaxyBuilder().getBuiltSolarSystems();
+        List<SolarSystem> systems = game.getGalaxyBuilder().getBuiltSolarSystems();
 
         JSONObject rootNode = Validator.getValidatedJSON(moduleName + ":startingStation", "engine:schemaStartingStation");
 

engine/src/main/java/org/destinationsol/game/SaveManager.java

@@ -20,6 +20,8 @@
 import com.badlogic.gdx.math.Vector2;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import com.google.gson.JsonParser;
 import com.google.gson.stream.JsonReader;
@@ -232,16 +234,29 @@ public static ShipConfig readShip(HullConfigManager hullConfigs, ItemManager ite
     }
 
     /**
-     * Saves the world to a file. Currently stores the seed used to generate the world and the number of systems
-     * @param numberOfSystems
+     * Saves the world to a file. Currently stores the seed used to generate the world,
+     * the number of systems and the generators used.
+     * @param worldConfig the current world configuration.
      */
-    public static void saveWorld(int numberOfSystems) {
+    public static void saveWorld(WorldConfig worldConfig) {
         Long seed = SolRandom.getSeed();
         String fileName = SaveManager.getResourcePath(Const.WORLD_SAVE_FILE_NAME);
 
         JsonObject world = new JsonObject();
         world.addProperty("seed", seed);
-        world.addProperty("systems", numberOfSystems);
+        world.addProperty("systems", worldConfig.getNumberOfSystems());
+
+        JsonArray solarSystemGenerators = new JsonArray();
+        for (String solarSystemGenerator : worldConfig.getSolarSystemGenerators()) {
+            solarSystemGenerators.add(solarSystemGenerator);
+        }
+        world.add("solarSystemGenerators", solarSystemGenerators);
+
+        JsonArray featureGenerators = new JsonArray();
+        for (String featureGenerator : worldConfig.getFeatureGenerators()) {
+            featureGenerators.add(featureGenerator);
+        }
+        world.add("featureGenerators", featureGenerators);
 
         Gson gson = new GsonBuilder().setPrettyPrinting().create();
         String stringToWrite = gson.toJson(world);
@@ -272,6 +287,26 @@ public static Optional<WorldConfig> loadWorld() {
                     config.setNumberOfSystems(world.get("systems").getAsInt());
                 }
 
+                if (world.has("solarSystemGenerators")) {
+                    List<String> solarSystemGenerators = new ArrayList<>();
+                    for (JsonElement value : world.getAsJsonArray("solarSystemGenerators")) {
+                        if (value.isJsonPrimitive() && value.getAsJsonPrimitive().isString()) {
+                            solarSystemGenerators.add(value.getAsString());
+                        }
+                    }
+                    config.setSolarSystemGenerators(solarSystemGenerators);
+                }
+
+                if (world.has("featureGenerators")) {
+                    List<String> featureGenerators = new ArrayList<>();
+                    for (JsonElement value : world.getAsJsonArray("featureGenerators")) {
+                        if (value.isJsonPrimitive() && value.getAsJsonPrimitive().isString()) {
+                            featureGenerators.add(value.getAsString());
+                        }
+                    }
+                    config.setFeatureGenerators(featureGenerators);
+                }
+
                 logger.debug("Successfully loaded the world file");
                 return Optional.of(config);
             } catch (FileNotFoundException e) {

engine/src/main/java/org/destinationsol/game/SolGame.java

@@ -149,6 +149,8 @@ public class SolGame {
     protected SolCam solCam;
     @Inject
     protected ModuleManager moduleManager;
+    @Inject
+    protected WorldConfig worldConfig;
 
     protected SolApplication solApplication;
     private Hero hero;
@@ -236,7 +238,7 @@ public void createUpdateSystems() {
         }
     }
 
-    public void startGame(String shipName, boolean isNewGame, WorldConfig worldConfig, EntitySystemManager entitySystemManager) {
+    public void startGame(String shipName, boolean isNewGame, EntitySystemManager entitySystemManager) {
         this.entitySystemManager = entitySystemManager;
 
         respawnState = new RespawnState();
@@ -331,7 +333,7 @@ public void onGameEnd(Context context) {
             if (!hero.isTranscendent()) {
                 saveShip();
             }
-            SaveManager.saveWorld(getPlanetManager().getSystems().size());
+            SaveManager.saveWorld(worldConfig);
 
             try {
                 context.get(SerialisationManager.class).serialise();
@@ -603,6 +605,10 @@ public DrawableManager getDrawableManager() {
         return drawableManager;
     }
 
+    public WorldConfig getWorldConfig() {
+        return worldConfig;
+    }
+
     public void setRespawnState() {
         respawnState.setRespawnMoney(.75f * hero.getMoney());
         if (hero.isNonTranscendent()) {

engine/src/main/java/org/destinationsol/game/StarPort.java

@@ -125,7 +125,7 @@ public void update(SolGame game) {
             ship.setMoney(ship.getMoney() - FARE);
             Transcendent transcendent = new Transcendent(ship, fromPlanet, toPlanet, game);
             if (transcendent.getShip().getPilot().isPlayer()) {
-                SaveManager.saveWorld(game.getPlanetManager().getSystems().size());
+                SaveManager.saveWorld(game.getWorldConfig());
                 game.getHero().setTranscendent(transcendent);
             }
             ObjectManager objectManager = game.getObjectManager();
@@ -404,7 +404,7 @@ public void update(SolGame game) {
                 SolShip ship = this.ship.toObject(game);
                 if (ship.getPilot().isPlayer()) {
                     game.getHero().setSolShip(ship, game);
-                    SaveManager.saveWorld(game.getPlanetManager().getSystems().size());
+                    SaveManager.saveWorld(game.getWorldConfig());
                 }
                 objectManager.addObjDelayed(ship);
                 blip(game, ship);

engine/src/main/java/org/destinationsol/game/WorldConfig.java

@@ -17,18 +17,29 @@
 
 import org.destinationsol.game.planet.SystemsBuilder;
 
+import java.util.ArrayList;
+import java.util.List;
+
 public class WorldConfig {
     protected long seed;
     protected int numberOfSystems;
+    private List<String> solarSystemGenerators;
+    private List<String> featureGenerators;
 
     public WorldConfig() {
         seed = System.currentTimeMillis();
         numberOfSystems = SystemsBuilder.DEFAULT_SYSTEM_COUNT;
+        solarSystemGenerators = new ArrayList<>();
+        featureGenerators = new ArrayList<>();
     }
 
-    public WorldConfig(long seed, int numberOfSystems) {
+    public WorldConfig(long seed, int numberOfSystems,
+                       List<String> solarSystemGenerators,
+                       List<String> featureGenerators) {
         this.seed = seed;
         this.numberOfSystems = numberOfSystems;
+        this.solarSystemGenerators = solarSystemGenerators;
+        this.featureGenerators = featureGenerators;
     }
 
     public long getSeed() {
@@ -46,4 +57,20 @@ public int getNumberOfSystems() {
     public void setNumberOfSystems(int numberOfSystems) {
         this.numberOfSystems = numberOfSystems;
     }
+
+    public List<String> getSolarSystemGenerators() {
+        return solarSystemGenerators;
+    }
+
+    public void setFeatureGenerators(List<String> featureGenerators) {
+        this.featureGenerators = featureGenerators;
+    }
+
+    public List<String> getFeatureGenerators() {
+        return featureGenerators;
+    }
+
+    public void setSolarSystemGenerators(List<String> solarSystemGenerators) {
+        this.solarSystemGenerators = solarSystemGenerators;
+    }
 }

engine/src/main/java/org/destinationsol/world/GalaxyBuilder.java

@@ -52,41 +52,78 @@ public class GalaxyBuilder {
     private ArrayList<SolarSystem> builtSolarSystems = new ArrayList<>();
     private ModuleManager moduleManager;
     private SolarSystemConfigManager solarSystemConfigManager;
-    private final int numberOfSystems;
     private BeanContext beanContext;
+    private WorldConfig worldConfig;
 
     @Inject
     public GalaxyBuilder(WorldConfig worldConfig, ModuleManager moduleManager, SolarSystemConfigManager solarSystemConfigManager, BeanContext beanContext) {
         this.moduleManager = moduleManager;
         this.solarSystemConfigManager = solarSystemConfigManager;
         this.beanContext = beanContext;
         solarSystemConfigManager.loadDefaultSolarSystemConfigs();
-        numberOfSystems = worldConfig.getNumberOfSystems();
+        this.worldConfig = worldConfig;
+
+        if (worldConfig.getSolarSystemGenerators().isEmpty()) {
+            populateSolarSystemGeneratorList();
+        } else {
+            for (String typeName : worldConfig.getSolarSystemGenerators()) {
+                Iterable<Class<? extends SolarSystemGenerator>> generatorTypes =
+                        moduleManager.getEnvironment().getSubtypesOf(SolarSystemGenerator.class, type -> type.getName().equals(typeName));
+                if (!generatorTypes.iterator().hasNext()) {
+                    logger.error("Unable to find SolarSystemGenerator type {}! World generation will likely be incorrect.", typeName);
+                    continue;
+                }
+
+                for (Class<? extends SolarSystemGenerator> generatorType : generatorTypes) {
+                    solarSystemGeneratorTypes.add(generatorType);
+                }
+            }
+        }
+
+        if (worldConfig.getFeatureGenerators().isEmpty()) {
+            populateFeatureGeneratorList();
+        } else {
+            for (String typeName : worldConfig.getFeatureGenerators()) {
+                Iterable<Class<? extends FeatureGenerator>> generatorTypes =
+                        moduleManager.getEnvironment().getSubtypesOf(FeatureGenerator.class, type -> type.getName().equals(typeName));
+                if (!generatorTypes.iterator().hasNext()) {
+                    logger.error("Unable to find FeatureGenerator type {}! World generation will likely be incorrect.", typeName);
+                    continue;
+                }
 
-        populateSolarSystemGeneratorList();
-        populateFeatureGeneratorList();
+                for (Class<? extends FeatureGenerator> generatorType : generatorTypes) {
+                    featureGeneratorTypes.add(generatorType);
+                }
+            }
+        }
     }
 
     /**
      * This method uses reflection to retrieve all SolarSystemGenerator classes. They are added to the list
      * of SolarSystemGenerators.
      */
     private void populateSolarSystemGeneratorList() {
-        //It is necessary to use an iterator as getSubtypesOf() returns an Iterable
-        moduleManager.getEnvironment().getSubtypesOf(SolarSystemGenerator.class).iterator().forEachRemaining(solarSystemGeneratorTypes::add);
+        List<String> systemGeneratorTypeNames = new ArrayList<>();
+        for (Class<? extends SolarSystemGenerator> systemGeneratorType : moduleManager.getEnvironment().getSubtypesOf(SolarSystemGenerator.class)) {
+            solarSystemGeneratorTypes.add(systemGeneratorType);
+            systemGeneratorTypeNames.add(systemGeneratorType.getName());
+        }
+        worldConfig.setSolarSystemGenerators(systemGeneratorTypeNames);
     }
 
     /**
      * This method uses reflection to retrieve all concrete FeatureGenerator classes. They are added to the list
      * of FeatureGenerators.
      */
     private void populateFeatureGeneratorList() {
-
+        List<String> featureGeneratorTypeNames = new ArrayList<>();
         for (Class<? extends FeatureGenerator> generator : moduleManager.getEnvironment().getSubtypesOf(FeatureGenerator.class)) {
             if (!Modifier.isAbstract(generator.getModifiers())) {
                 featureGeneratorTypes.add(generator);
+                featureGeneratorTypeNames.add(generator.getName());
             }
         }
+        worldConfig.setFeatureGenerators(featureGeneratorTypeNames);
     }
 
     /**
@@ -112,7 +149,7 @@ public void buildWithRandomSolarSystemGenerators() {
      */
     public ArrayList<SolarSystemGenerator> initializeRandomSolarSystemGenerators() {
         ArrayList<SolarSystemGenerator> generatorArrayList = new ArrayList<>();
-        for (int i = 0; i < numberOfSystems; i++) {
+        for (int i = 0; i < worldConfig.getNumberOfSystems(); i++) {
             Class<? extends SolarSystemGenerator> solarSystemGenerator = solarSystemGeneratorTypes.get(SolRandom.seededRandomInt(solarSystemGeneratorTypes.size()));
             try {
                 SolarSystemGenerator generator = solarSystemGenerator.newInstance();
@@ -199,19 +236,19 @@ private void calculateRandomWorldPositionAtDistance(Vector2 result, float distan
         SolMath.fromAl(result, angle, distance);
     }
 
-    public ArrayList<Class<? extends SolarSystemGenerator>> getSolarSystemGeneratorTypes() {
+    public List<Class<? extends SolarSystemGenerator>> getSolarSystemGeneratorTypes() {
         return solarSystemGeneratorTypes;
     }
 
-    public ArrayList<SolarSystemGenerator> getActiveSolarSystemGenerators() {
+    public List<SolarSystemGenerator> getActiveSolarSystemGenerators() {
         return activeSolarSystemGenerators;
     }
 
-    public ArrayList<Class<? extends FeatureGenerator>> getFeatureGeneratorTypes() {
+    public List<Class<? extends FeatureGenerator>> getFeatureGeneratorTypes() {
         return featureGeneratorTypes;
     }
 
-    public ArrayList<SolarSystem> getBuiltSolarSystems() {
+    public List<SolarSystem> getBuiltSolarSystems() {
         return builtSolarSystems;
     }
 }

engine/src/main/java/org/destinationsol/world/generators/SolarSystemGenerator.java

@@ -466,7 +466,7 @@ private boolean isOtherGeneratorType(int index) {
                 && !PlanetGenerator.class.isAssignableFrom(featureGeneratorTypes.get(index));
     }
 
-    public void setFeatureGeneratorTypes(ArrayList<Class<? extends FeatureGenerator>> generators) {
+    public void setFeatureGeneratorTypes(List<Class<? extends FeatureGenerator>> generators) {
         featureGeneratorTypes.addAll(generators);
     }