Replace all world loading with worldformat

Author: NotStirred

chunky/src/java/se/llbit/chunky/map/WorldMapLoader.java

@@ -16,6 +16,7 @@
  */
 package se.llbit.chunky.map;
 
+import java.util.Optional;
 import java.util.function.BiConsumer;
 import se.llbit.chunky.PersistentSettings;
 import se.llbit.chunky.renderer.ChunkViewListener;
@@ -25,6 +26,8 @@
 import se.llbit.chunky.world.region.RegionParser;
 import se.llbit.chunky.world.region.RegionQueue;
 import se.llbit.chunky.world.listeners.ChunkTopographyListener;
+import se.llbit.chunky.world.worldformat.WorldFormat;
+import se.llbit.log.Log;
 
 import java.io.File;
 import java.util.ArrayList;
@@ -64,28 +67,44 @@ public WorldMapLoader(ChunkyFxController controller, MapView mapView) {
     topographyUpdater.start();
   }
 
+  public void loadWorldFromDirectory(File worldLocation) {
+    if (worldLocation == null) {
+      return;
+    }
+    this.loadWorld(WorldFormat.loadWorld(worldLocation).orElse(EmptyWorld.INSTANCE));
+  }
   /**
    * This is called when a new world is loaded
    */
-  public void loadWorld(File worldDir) {
-    if (JavaWorld.isWorldDir(worldDir)) {
-      if (world != null) {
-        world.currentDimension().removeChunkTopographyListener(this);
-      }
-      boolean isSameWorld = !(world instanceof EmptyWorld) && worldDir.equals(world.getWorldDirectory());
-      World newWorld = World.loadWorld(worldDir, currentDimensionId, World.LoggedWarnings.NORMAL);
-      newWorld.currentDimension().addChunkTopographyListener(this);
-      synchronized (this) {
-        world = newWorld;
-        updateRegionChangeWatcher(newWorld.currentDimension());
-
-        File newWorldDir = world.getWorldDirectory();
-        if (newWorldDir != null && !newWorldDir.equals(PersistentSettings.getLastWorld())) {
-          PersistentSettings.setLastWorld(newWorldDir);
-        }
+  public void loadWorld(World newWorld) {
+    if (this.world != null) {
+      this.world.currentDimension().removeChunkTopographyListener(this);
+    }
+    boolean isSameWorld = !(this.world instanceof EmptyWorld) && newWorld.getWorldDirectory().equals(this.world.getWorldDirectory());
+
+    Optional<String> dimensionToLoad = Optional.of(world.currentDimension())
+      .map(Dimension::id)
+      .filter(dimension -> newWorld.availableDimensions().contains(dimension))
+      .or(newWorld::defaultDimension)
+      .or(() -> newWorld.availableDimensions().stream().findFirst());
+
+    if (dimensionToLoad.isEmpty()) {
+      Log.infof("No dimension loaded for world %s", newWorld.toString());
+      return;
+    }
+
+    Dimension loadedDim = newWorld.loadDimension(dimensionToLoad.get());
+    loadedDim.addChunkTopographyListener(this);
+    synchronized (this) {
+      this.world = newWorld;
+      updateRegionChangeWatcher(loadedDim);
+
+      File newWorldDir = this.world.getWorldDirectory();
+      if (!newWorldDir.equals(PersistentSettings.getLastWorld())) {
+        PersistentSettings.setLastWorld(newWorldDir);
       }
-      worldLoadListeners.forEach(listener -> listener.accept(newWorld, isSameWorld));
     }
+    worldLoadListeners.forEach(listener -> listener.accept(newWorld, isSameWorld));
   }
 
   /**
@@ -151,14 +170,12 @@ public void regionUpdated(RegionPosition region) {
   public void reloadWorld() {
     topographyUpdater.clearQueue();
     world.currentDimension().removeChunkTopographyListener(this);
-    World newWorld = World.loadWorld(world.getWorldDirectory(), currentDimensionId,
-        World.LoggedWarnings.NORMAL);
-    newWorld.currentDimension().addChunkTopographyListener(this);
+    world.loadDimension(currentDimensionId);
+    world.currentDimension().addChunkTopographyListener(this);
     synchronized (this) {
-      world = newWorld;
-      updateRegionChangeWatcher(newWorld.currentDimension());
+      updateRegionChangeWatcher(world.currentDimension());
     }
-    worldLoadListeners.forEach(listener -> listener.accept(newWorld, true));
+    worldLoadListeners.forEach(listener -> listener.accept(world, true));
     viewUpdated(mapView.getMapView()); // update visible chunks immediately
   }
 
@@ -174,7 +191,7 @@ private void updateRegionChangeWatcher(Dimension dimension) {
   /**
    * Set the current dimension.
    *
-   * @param value Must be a valid dimension see {@link World#listDimensions()}
+   * @param value Must be a valid dimension see {@link World#availableDimensions()}
    */
   // TODO: change this to show the available dimensions in the UI.
   public void setDimension(String value) {

chunky/src/java/se/llbit/chunky/renderer/scene/Scene.java

@@ -53,6 +53,7 @@
 import se.llbit.chunky.world.biome.Biome;
 import se.llbit.chunky.world.biome.BiomePalette;
 import se.llbit.chunky.world.biome.Biomes;
+import se.llbit.chunky.world.worldformat.WorldFormat;
 import se.llbit.json.*;
 import se.llbit.log.Log;
 import se.llbit.math.*;
@@ -543,11 +544,8 @@ public synchronized void loadScene(RenderContext context, String sceneName, Task
       loadedWorld = EmptyWorld.INSTANCE;
       if (!worldPath.isEmpty()) {
         File worldDirectory = new File(worldPath);
-        if (JavaWorld.isWorldDir(worldDirectory)) {
-          loadedWorld = World.loadWorld(worldDirectory, worldDimension, World.LoggedWarnings.NORMAL);
-        } else {
-          Log.info("Could not load world: " + worldPath);
-        }
+        loadedWorld = WorldFormat.loadWorld(worldDirectory).orElse(EmptyWorld.INSTANCE);
+        loadedWorld.loadDimension(this.worldDimension);
       }
 
       loadDump(context, taskTracker);

chunky/src/java/se/llbit/chunky/ui/controller/WorldChooserController.java

@@ -40,7 +40,6 @@
 import se.llbit.log.Log;
 
 import java.io.File;
-import java.io.IOException;
 import java.net.URL;
 import java.text.DateFormat;
 import java.util.*;
@@ -135,7 +134,7 @@ public void populate(WorldMapLoader mapLoader) {
       File directory = chooser.showDialog(stage);
       if (directory != null) {
         if (directory.isDirectory()) {
-          this.loadWorld(World.loadWorld(directory, mapLoader.getDimension(), World.LoggedWarnings.NORMAL), mapLoader);
+          this.loadWorld(WorldFormat.loadWorld(directory).orElse(EmptyWorld.INSTANCE), mapLoader);
           stage.close();
         } else {
           Log.warn("Non-directory selected.");
@@ -171,7 +170,7 @@ private void loadWorld(World world, WorldMapLoader mapLoader) {
           }
         }
       });
-    mapLoader.loadWorld(world.getWorldDirectory());
+    mapLoader.loadWorld(world);
   }
 
   /**
@@ -196,18 +195,7 @@ protected List<World> call() {
           File[] worldDirs = worldSavesDir.listFiles();
           if (worldDirs != null) {
             for (File dir : worldDirs) {
-              for (WorldFormat worldFormat : WorldFormat.worldFormats) {
-                if (worldFormat.isValid(dir.toPath())) {
-                  try {
-                    World world = worldFormat.loadWorld(dir.toPath(), String.valueOf(World.OVERWORLD_DIMENSION));
-                    if (world != EmptyWorld.INSTANCE) {
-                      worlds.add(world);
-                    }
-                  } catch (IOException e) {
-                    throw new RuntimeException(e);
-                  }
-                }
-              }
+              WorldFormat.loadWorld(dir).ifPresent(worlds::add);
             }
           }
         }

chunky/src/java/se/llbit/chunky/world/EmptyWorld.java

@@ -40,11 +40,15 @@ private EmptyWorld() {
   }
 
   @Override
-  public Set<String> listDimensions() {
+  public Set<String> availableDimensions() {
     return Collections.emptySet();
   }
 
   @Override
+  public Optional<String> defaultDimension() {
+    return Optional.empty();
+  }
+
   @Override
   public EmptyDimension loadDimension(String dimension) {
     return EmptyDimension.INSTANCE;

chunky/src/java/se/llbit/chunky/world/JavaDimension.java

@@ -10,6 +10,7 @@
 
 import java.io.File;
 import java.util.*;
+import java.util.stream.Collectors;
 
 public class JavaDimension extends Dimension {
   protected final Long2ObjectMap<Region> regionMap = new Long2ObjectOpenHashMap<>();
@@ -29,7 +30,13 @@ protected JavaDimension(JavaWorld world, String dimensionId, File dimensionDirec
    * @return {@code true} if player data was reloaded.
    */
   public synchronized boolean reloadPlayerData() {
-    return ((JavaWorld) this.world).reloadPlayerData();
+    boolean changed = ((JavaWorld) this.world).reloadPlayerData();
+    if (changed) {
+      this.setPlayerEntities(((JavaWorld) this.world).playerEntities.stream()
+        .filter(player -> player.dimension.equals(this.id()))
+        .collect(Collectors.toSet()));
+    }
+    return changed;
   }
 
   /**

chunky/src/java/se/llbit/chunky/world/JavaWorld.java

@@ -22,6 +22,7 @@
 import se.llbit.chunky.ui.ProgressTracker;
 import se.llbit.chunky.world.region.MCRegion;
 import se.llbit.log.Log;
+import se.llbit.math.Vector3i;
 import se.llbit.nbt.NamedTag;
 import se.llbit.nbt.Tag;
 import se.llbit.util.MinecraftText;
@@ -70,26 +71,48 @@ public class JavaWorld extends World {
     new String[] { NETHER_DIMENSION_ID, OVERWORLD_DIMENSION_ID, END_DIMENSION_ID }
   ));
 
-  int versionId;
+  protected int versionId;
+
+  /**
+   * In a java world player data is per-world and not per-dimension, so we store it here.
+   */
+  protected final Set<PlayerEntityData> playerEntities;
+
+  /**
+   * In a java world spawn position is per-world and not per-dimension, so we store it here.
+   */
+  protected final Vector3i spawnPos;
 
   /**
    * @param levelName name of the world (not the world directory).
    * @param worldDirectory Minecraft world directory.
    * @param seed
    * @param timestamp
    */
-  protected JavaWorld(String levelName, File worldDirectory, long seed, long timestamp) {
+  protected JavaWorld(String levelName, File worldDirectory, long seed, long timestamp, Set<PlayerEntityData> playerEntities, Vector3i spawnPos) {
     super(levelName, worldDirectory, seed, timestamp);
+    this.playerEntities = playerEntities;
+    this.spawnPos = spawnPos;
   }
 
   @Override
-  public Set<String> listDimensions() {
+  public Set<String> availableDimensions() {
     return new ObjectArraySet<>(VANILLA_DIMENSION_ID_TO_IDX.keySet());
   }
 
+  @Override
+  public Optional<String> defaultDimension() {
+    return Optional.of(OVERWORLD_DIMENSION_ID);
+  }
+
   public Dimension loadDimension(String dimension) {
-    currentDimension = loadDimension(this, this.worldDirectory, dimension, -1, Collections.emptySet());
-    currentDimension.reloadPlayerData();
+    currentDimension = loadDimension(
+      this,
+      this.worldDirectory,
+      dimension,
+      -1,
+      this.playerEntities.stream().filter(player -> player.dimension.equals(dimension)).collect(Collectors.toSet())
+    );
     return currentDimension;
   }
 
@@ -122,7 +145,7 @@ public static World loadWorld(File worldDirectory, LoggedWarnings warnings) {
       }
       Tag versionId = result.get(".Data.Version.Id");
       Tag player = result.get(".Data.Player");
-      Tag spawnX = player.get("SpawnX");
+      Tag spawnX = player.get("SpawnX"); // TODO: not sure what to do with spawn location now. I guess for java worlds: the world should store it and the dimension should set it in the map view when loaded...?
       Tag spawnY = player.get("SpawnY");
       Tag spawnZ = player.get("SpawnZ");
       Tag gameType = result.get(".Data.GameType");
@@ -131,20 +154,19 @@ public static World loadWorld(File worldDirectory, LoggedWarnings warnings) {
 
       long seed = randomSeed.longValue(0);
 
-      Set<PlayerEntityData> playerEntities = getPlayerEntityData(worldDirectory, dimensionId, player);
-
-      JavaWorld world = new JavaWorld(levelName, worldDirectory, seed, modtime);
-      world.gameMode = gameType.intValue(0);
-      world.versionId = versionId.intValue();
-
-      Dimension dimension = loadDimension(world, worldDirectory, dimensionId, modtime, playerEntities);
+      Set<PlayerEntityData> playerEntities = getPlayerEntityData(worldDirectory, player);
 
       boolean haveSpawnPos = !(spawnX.isError() || spawnY.isError() || spawnZ.isError());
+      Vector3i spawnPos;
       if (haveSpawnPos) {
-        dimension.setSpawnPos(new Vector3i(spawnX.intValue(0), spawnY.intValue(0), spawnZ.intValue(0)));
+        spawnPos = new Vector3i(spawnX.intValue(0), spawnY.intValue(0), spawnZ.intValue(0));
+      } else {
+        spawnPos = new Vector3i(0, 0, 0);
       }
 
-      world.currentDimension = dimension;
+      JavaWorld world = new JavaWorld(levelName, worldDirectory, seed, modtime, playerEntities, spawnPos);
+      world.gameMode = gameType.intValue(0);
+      world.versionId = versionId.intValue();
 
       return world;
     } catch (FileNotFoundException e) {
@@ -172,14 +194,12 @@ protected static JavaDimension loadDimension(JavaWorld world, File worldDirector
   }
 
   @NotNull
-  static Set<PlayerEntityData> getPlayerEntityData(File worldDirectory, String dimensionId, Tag player) {
+  static Set<PlayerEntityData> getPlayerEntityData(File worldDirectory, Tag player) {
     Set<PlayerEntityData> playerEntities = new HashSet<>();
     if (!player.isError()) {
       playerEntities.add(new PlayerEntityData(player));
     }
     loadAdditionalPlayers(worldDirectory, playerEntities);
-    // Filter for the players only within the requested dimension
-    playerEntities = playerEntities.stream().filter(playerData -> playerData.dimension.equals(dimensionId)).collect(Collectors.toSet());
     return playerEntities;
   }
 
@@ -206,8 +226,8 @@ synchronized boolean reloadPlayerData() {
       request.add(".Data.Player");
       Map<String, Tag> result = NamedTag.quickParse(in, request);
       Tag player = result.get(".Data.Player");
-
-      currentDimension.setPlayerEntities(getPlayerEntityData(worldDirectory, currentDimension.id(), player));
+      this.playerEntities.clear();
+      this.playerEntities.addAll(getPlayerEntityData(worldDirectory, player));
     } catch (IOException e) {
       Log.infof("Could not read the level.dat file for world %s while trying to reload player data!", levelName);
       return false;
@@ -236,25 +256,12 @@ private static void loadPlayerData(File playerdata, Set<PlayerEntityData> player
     }
   }
 
-  @Override
-  public synchronized JavaDimension currentDimension() {
-    return (JavaDimension) this.currentDimension;
-  }
-
-  /**
-   * @deprecated Use {@link JavaWorld#currentDimension()} -> {@link Dimension#getDimensionDirectory()} ()}. Removed once there are no more usages
-   */
-  @Deprecated
   protected synchronized File getDataDirectory(int dimension) {
     return dimension == 0 ?
       worldDirectory :
       new File(worldDirectory, "DIM" + dimension);
   }
 
-  /**
-    @deprecated Use {@link JavaWorld#currentDimension()} -> {@link JavaDimension#getRegionDirectory()}. Removed once there are no more usages
-   */
-  @Deprecated
   protected synchronized File getRegionDirectory(int dimension) {
     return new File(getDataDirectory(dimension), "region");
   }
@@ -399,7 +406,4 @@ public static boolean isWorldDir(File worldDir) {
     return false;
   }
 
-  public Date getLastModified() {
-    return new Date(this.worldDirectory.lastModified());
-  }
 }