Merge pull request #67 from mircokroon/dimension_handling_1_16

Inventory saving, better handling of dimensions
mircokroon · Aug 28, 2020 · b1a96ac · b1a96ac
2 parents 7f0811a + 85498a5
commit b1a96ac
Show file tree

Hide file tree

Showing 37 changed files with 815 additions and 156 deletions.
diff --git a/src/main/java/game/Game.java b/src/main/java/game/Game.java
@@ -3,7 +3,7 @@
 import game.data.Coordinate2D;
 import game.data.Coordinate3D;
 import game.data.Dimension;
-import game.data.RegistryLoader;
+import game.data.registries.RegistryLoader;
 import game.data.WorldManager;
 import game.data.chunk.ChunkFactory;
 import game.data.chunk.palette.Palette;
@@ -165,6 +165,8 @@ private static void loadVersionRegistries(Protocol p) {
 
             WorldManager.setGlobalPalette(loader.generateGlobalPalette());
             WorldManager.setEntityMap(loader.generateEntityNames());
+            WorldManager.setMenuRegistry(loader.generateMenuRegistry());
+            WorldManager.setItemRegistry(loader.generateItemRegistry());
 
             WorldManager.startSaveService();
             ChunkFactory.startChunkParserService();

diff --git a/src/main/java/game/data/Container.java b/src/main/java/game/data/Container.java
diff --git a/src/main/java/game/data/Coordinate2D.java b/src/main/java/game/data/Coordinate2D.java
@@ -19,6 +19,11 @@ public Coordinate2D(double x, double z) {
         this.z = (int) z;
     }
 
+    public void offset(int x, int z) {
+        this.x += x;
+        this.z += z;
+    }
+
     public static void setOffset(int x, int z) {
         offsetX = x >> 4 << 4;
         offsetZ = z >> 4 << 4;
@@ -87,4 +92,8 @@ private int toLocal(int pos) {
         }
         return pos;
     }
+
+    public CoordinateDim2D addDimension(Dimension dimension) {
+        return new CoordinateDim2D(this, dimension);
+    }
 }
diff --git a/src/main/java/game/data/Coordinate3D.java b/src/main/java/game/data/Coordinate3D.java
@@ -12,6 +12,10 @@ public Coordinate3D(int x, int y, int z) {
         this.y = y;
     }
 
+    public Coordinate3D add(Coordinate2D change) {
+        return new Coordinate3D(this.x + change.x, this.y, this.z + change.z);
+    }
+
     public void setTo(int x, int y, int z) {
         this.x = x;
         this.y = y;
@@ -21,16 +25,15 @@ public void setTo(int x, int y, int z) {
     public int getY() {
         return y;
     }
-    public Coordinate2D chunkPos() {
-        return new Coordinate2D(chunkPosX(), chunkPosZ());
-    }
 
-    private int chunkPosX() {
-        return x >> 4;
+    public Coordinate3D withinChunk() {
+        return new Coordinate3D(withinChunk(x), y, withinChunk(z));
     }
 
-    private int chunkPosZ() {
-        return z >> 4;
+    private int withinChunk(int val) {
+        int newVal = val % 16;
+        if (newVal < 0) { return newVal + 16; }
+        return newVal;
     }
 
     @Override

diff --git a/src/main/java/game/data/CoordinateDim2D.java b/src/main/java/game/data/CoordinateDim2D.java
@@ -0,0 +1,59 @@
+package game.data;
+
+/**
+ * 2D coordinates with a dimension component.
+ */
+public class CoordinateDim2D extends Coordinate2D {
+    Dimension dimension;
+
+    public CoordinateDim2D(Coordinate2D coordinate2D, Dimension dimension) {
+        super(coordinate2D.x, coordinate2D.z);
+        this.dimension = dimension;
+    }
+
+    public CoordinateDim2D(int x, int z, Dimension dimension) {
+        super(x, z);
+        this.dimension = dimension;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        if (!super.equals(o)) {
+            return false;
+        }
+
+        CoordinateDim2D that = (CoordinateDim2D) o;
+
+        return dimension == that.dimension;
+    }
+
+    @Override
+    public int hashCode() {
+        int result = super.hashCode();
+        result = 31 * result + (dimension != null ? dimension.hashCode() : 0);
+        return result;
+    }
+
+    public Dimension getDimension() {
+        return dimension;
+    }
+
+    public CoordinateDim2D chunkToDimRegion() {
+        return new CoordinateDim2D(this.chunkToRegion(), this.dimension);
+    }
+
+    public CoordinateDim2D copy() {
+        return new CoordinateDim2D(x, z, dimension);
+    }
+
+    @Override
+    public String toString() {
+        return "(" + x + ", " + z + ", " + dimension + ")";
+    }
+}
diff --git a/src/main/java/game/data/Dimension.java b/src/main/java/game/data/Dimension.java
@@ -13,11 +13,33 @@ public static Dimension fromId(int id) {
         }
     }
 
+    /**
+     * TODO: support custom dimensions?
+     */
+    public static Dimension fromString(String readString) {
+        switch (readString) {
+            case "minecraft:the_end": return END;
+            case "minecraft:the_nether": return NETHER;
+            default: return OVERWORLD;
+        }
+    }
+
     public String getPath() {
         switch (this) {
             case NETHER: return "DIM-1";
             case END: return "DIM1";
             default: return "";
         }
     }
+
+    @Override
+    public String toString() {
+        switch (this) {
+            case OVERWORLD: return "Overworld";
+            case NETHER: return "Nether";
+            case END: return "End";
+            default: return "Unknown";
+        }
+    }
+
 }
diff --git a/src/main/java/game/data/WorldManager.java b/src/main/java/game/data/WorldManager.java
@@ -6,6 +6,9 @@
 import game.data.chunk.entity.EntityNames;
 import game.data.chunk.palette.BlockColors;
 import game.data.chunk.palette.GlobalPalette;
+import game.data.container.ContainerManager;
+import game.data.container.ItemRegistry;
+import game.data.container.MenuRegistry;
 import game.data.region.McaFile;
 import game.data.region.Region;
 import gui.GuiManager;
@@ -48,45 +51,51 @@
 public class WorldManager extends Thread {
     private final static int SAVE_DELAY = 20 * 1000;
 
-    private static Map<Coordinate2D, Region> regions = new ConcurrentHashMap<>();
+    private static Map<CoordinateDim2D, Region> regions = new ConcurrentHashMap<>();
 
     private static WorldManager writer = null;
 
     private static GlobalPalette globalPalette;
     private static EntityNames entityMap;
+    private static MenuRegistry menuRegistry;
+    private static ItemRegistry itemRegistry;
 
     private static BlockColors blockColors;
 
     private static boolean markNewChunks;
 
     private static boolean writeChunks;
 
+    private static ContainerManager containerManager;
+
     private WorldManager() {
 
     }
 
     public static void outlineExistingChunks() throws IOException {
-        Stream<McaFile> files = getMcaFiles(true);
+        Dimension dimension = Game.getDimension();
+        Stream<McaFile> files = getMcaFiles(dimension, true);
 
         GuiManager.drawExistingChunks(
-            files.flatMap(el -> el.getChunkPositions().stream()).collect(Collectors.toList())
+            files.flatMap(el -> el.getChunkPositions(dimension).stream()).collect(Collectors.toList())
         );
     }
 
     public static void drawExistingChunks() throws IOException {
-        Stream<McaFile> files = getMcaFiles(false);
+        Dimension dimension = Game.getDimension();
+        Stream<McaFile> files = getMcaFiles(dimension, false);
 
         // Step 1: parse all the chunks
-        Set<Map.Entry<Coordinate2D, Chunk>> parsedChunks = files.parallel()
-            .flatMap(el -> el.getParsedChunks().entrySet().stream())
+        Set<Map.Entry<CoordinateDim2D, Chunk>> parsedChunks = files.parallel()
+            .flatMap(el -> el.getParsedChunks(dimension).entrySet().stream())
             .collect(Collectors.toSet());
 
         // Step 2: add all chunks to the WorldManager if it doesn't have them yet
-        Set<Coordinate2D> toDelete = new HashSet<>();
+        Set<CoordinateDim2D> toDelete = new HashSet<>();
         parsedChunks.forEach(entry -> {
             if (getChunk(entry.getKey()) == null) {
                 toDelete.add(entry.getKey());
-                loadChunk(entry.getKey(), entry.getValue(), false);
+                loadChunk(entry.getValue(), false);
             }
         });
 
@@ -100,8 +109,8 @@ public static void drawExistingChunks() throws IOException {
     /**
      * Read from the save path to see which chunks have been saved already.
      */
-    private static Stream<McaFile> getMcaFiles(boolean limit) throws IOException {
-        Path exportDir = Paths.get(Game.getExportDirectory(), "region");
+    private static Stream<McaFile> getMcaFiles(Dimension dimension, boolean limit) throws IOException {
+        Path exportDir = Paths.get(Game.getExportDirectory(), dimension.getPath(), "region");
 
         Stream<File> stream = Files.walk(exportDir)
             .filter(el -> el.getFileName().toString().endsWith(".mca"))
@@ -233,23 +242,22 @@ public static void startSaveService() {
 
     /**
      * Add a parsed chunk to the correct region.
-     * @param coordinate the chunk coordinates
      * @param chunk      the chunk
      */
-    public static void loadChunk(Coordinate2D coordinate, Chunk chunk, boolean drawInGui) {
+    public static void loadChunk(Chunk chunk, boolean drawInGui) {
         if (!drawInGui || writeChunks) {
-            Coordinate2D regionCoordinates = coordinate.chunkToRegion();
+            CoordinateDim2D regionCoordinates = chunk.location.chunkToDimRegion();
 
             if (!regions.containsKey(regionCoordinates)) {
                 regions.put(regionCoordinates, new Region(regionCoordinates));
             }
 
-            regions.get(regionCoordinates).addChunk(coordinate, chunk);
+            regions.get(regionCoordinates).addChunk(chunk.location, chunk);
         }
 
         if (drawInGui) {
             // draw the chunk once its been parsed
-            chunk.whenParsed(() -> GuiManager.setChunkLoaded(coordinate, chunk));
+            chunk.whenParsed(() -> GuiManager.setChunkLoaded(chunk.location, chunk));
         }
     }
 
@@ -258,15 +266,15 @@ public static void loadChunk(Coordinate2D coordinate, Chunk chunk, boolean drawI
      * @param coordinate the global chunk coordinates
      * @return the chunk
      */
-    public static Chunk getChunk(Coordinate2D coordinate) {
-        if (!regions.containsKey(coordinate.chunkToRegion())) {
+    public static Chunk getChunk(CoordinateDim2D coordinate) {
+        if (!regions.containsKey(coordinate.chunkToDimRegion())) {
             return null;
         }
-        return regions.get(coordinate.chunkToRegion()).getChunk(coordinate);
+        return regions.get(coordinate.chunkToDimRegion()).getChunk(coordinate);
     }
 
-    public static void unloadChunk(Coordinate2D coordinate) {
-        Region r = regions.get(coordinate.chunkToRegion());
+    public static void unloadChunk(CoordinateDim2D coordinate) {
+        Region r = regions.get(coordinate.chunkToDimRegion());
         if (r != null) {
             r.removeChunk(coordinate);
         }
@@ -280,6 +288,10 @@ public static void setEntityMap(EntityNames names) {
         entityMap = names;
     }
 
+    public static void setMenuRegistry(MenuRegistry menus) {
+        menuRegistry = menus;
+    }
+
     public static GlobalPalette getGlobalPalette() {
         return globalPalette;
     }
@@ -295,6 +307,18 @@ public static boolean markNewChunks() {
         return markNewChunks;
     }
 
+    public static MenuRegistry getMenuRegistry() {
+        return menuRegistry;
+    }
+
+    public static ItemRegistry getItemRegistry() {
+        return itemRegistry;
+    }
+
+    public static void setItemRegistry(ItemRegistry items) {
+        itemRegistry = items;
+    }
+
     /**
      * Loop to call save periodically.
      */
@@ -345,4 +369,15 @@ private static void save() {
         // remove empty regions
         regions.entrySet().removeIf(el -> el.getValue().isEmpty());
     }
+
+    public static ContainerManager getContainerManager() {
+        if (containerManager == null) {
+            containerManager = new ContainerManager();
+        }
+        return containerManager;
+    }
+
+
+
 }
+