Introduce cache that can be shared more easily

diff --git a/java/com/irtimaled/bbor/client/ClientProxy.java b/java/com/irtimaled/bbor/client/ClientProxy.java
index 5b39b04a86ab2fae7a22eae2c345371b1d6e2861..35955a790fe9fad42e6dd5a6bb6f8edd3e2544ca 100644 (file)
--- a/java/com/irtimaled/bbor/client/ClientProxy.java
+++ b/java/com/irtimaled/bbor/client/ClientProxy.java
@@ -65,14 +65,6 @@ public class ClientProxy extends CommonProxy {
         Minecraft.getMinecraft().gameSettings.keyBindings = ArrayUtils.addAll(Minecraft.getMinecraft().gameSettings.keyBindings, activeHotKey, outerBoxOnlyHotKey);
     }
 
-    @Override
-    public void setWorldData(WorldData worldData) {
-        worldSpawnBoundingBox = null;
-        spawnChunksBoundingBox = null;
-        lazySpawnChunksBoundingBox = null;
-        super.setWorldData(worldData);
-    }
-
     public void render(float partialTicks) {
         EntityPlayer entityPlayer = Minecraft.getMinecraft().player;
         PlayerData.setPlayerPosition(partialTicks, entityPlayer);
@@ -80,8 +72,9 @@ public class ClientProxy extends CommonProxy {
         if (this.active) {
             DimensionType dimensionType = DimensionType.getById(entityPlayer.dimension);
             Map<BoundingBox, Set<BoundingBox>> boundingBoxes = null;
-            if (boundingBoxCacheMap.containsKey(dimensionType)) {
-                boundingBoxes = boundingBoxCacheMap.get(dimensionType).getBoundingBoxes();
+            BoundingBoxCache boundingBoxCache = dimensionCache.getBoundingBoxes(dimensionType);
+            if (boundingBoxCache != null) {
+                boundingBoxes = boundingBoxCache.getBoundingBoxes();
             }
             renderBoundingBoxes(boundingBoxes, getClientBoundingBoxes(dimensionType));
         }
@@ -147,7 +140,7 @@ public class ClientProxy extends CommonProxy {
             loadVillageNbtFile(localStructuresFolder, cache, "Villages.dat");
         }
 
-        boundingBoxCacheMap.put(DimensionType.OVERWORLD, cache);
+        dimensionCache.put(DimensionType.OVERWORLD, cache);
     }
 
     private void loadNetherStructures(File localStructuresFolder) {
@@ -157,7 +150,7 @@ public class ClientProxy extends CommonProxy {
         if (ConfigManager.drawVillages.getBoolean()) {
             loadVillageNbtFile(localStructuresFolder, cache, "villages_nether.dat");
         }
-        boundingBoxCacheMap.put(DimensionType.NETHER, cache);
+        dimensionCache.put(DimensionType.NETHER, cache);
     }
 
     private void loadEndStructures(File localStructuresFolder) {
@@ -168,7 +161,7 @@ public class ClientProxy extends CommonProxy {
         if (ConfigManager.drawEndCities.getBoolean()) {
             loadStructureNbtFile(localStructuresFolder, cache, "EndCity.dat", StructureType.EndCity.getColor(), "*");
         }
-        boundingBoxCacheMap.put(DimensionType.THE_END, cache);
+        dimensionCache.put(DimensionType.THE_END, cache);
     }
 
     private void loadVillageNbtFile(File localStructuresFolder, BoundingBoxCache cache, String fileName) {
@@ -243,8 +236,8 @@ public class ClientProxy extends CommonProxy {
         long seed = data.getLong("RandomSeed");
         int spawnX = data.getInteger("SpawnX");
         int spawnZ = data.getInteger("SpawnZ");
-        setWorldData(new WorldData(seed, spawnX, spawnZ));
-        Logger.info("Loaded level.dat (seed: %d, spawn: %d,%d)", worldData.getSeed(), worldData.getSpawnX(), worldData.getSpawnZ());
+        dimensionCache.setWorldData(seed, spawnX, spawnZ);
+        Logger.info("Loaded level.dat (seed: %d, spawn: %d,%d)", seed, spawnX, spawnZ);
     }
 
     private NBTTagCompound loadNbtFile(File file) {
@@ -260,13 +253,10 @@ public class ClientProxy extends CommonProxy {
     public void playerDisconnectedFromServer() {
         active = false;
         if (ConfigManager.keepCacheBetweenSessions.getBoolean()) return;
-        worldData = null;
         worldSpawnBoundingBox = null;
         spawnChunksBoundingBox = null;
-        for (BoundingBoxCache cache : boundingBoxCacheMap.values()) {
-            cache.close();
-        }
-        boundingBoxCacheMap.clear();
+        lazySpawnChunksBoundingBox = null;
+        dimensionCache.clear();
     }
 
     private void renderBoundingBoxes(Map<BoundingBox, Set<BoundingBox>> map, Set<BoundingBox> clientBoundingBoxes) {
@@ -603,6 +593,7 @@ public class ClientProxy extends CommonProxy {
     }
 
     private Set<BoundingBox> getClientBoundingBoxes(DimensionType dimensionType) {
+        WorldData worldData = dimensionCache.getWorldData();
         if (worldData == null || dimensionType != DimensionType.OVERWORLD) {
             return null;
         }
@@ -643,6 +634,7 @@ public class ClientProxy extends CommonProxy {
     }
 
     private boolean isSlimeChunk(int chunkX, int chunkZ) {
+        WorldData worldData = dimensionCache.getWorldData();
         Random r = new Random(worldData.getSeed() +
                 (long) (chunkX * chunkX * 4987142) +
                 (long) (chunkX * 5947611) +

diff --git a/java/com/irtimaled/bbor/common/CommonProxy.java b/java/com/irtimaled/bbor/common/CommonProxy.java
index e6284d0006c76d83768818da397755942e6836b2..02f74f046829e389d473fff6d01491388fdef670 100644 (file)
--- a/java/com/irtimaled/bbor/common/CommonProxy.java
+++ b/java/com/irtimaled/bbor/common/CommonProxy.java
@@ -2,8 +2,6 @@ package com.irtimaled.bbor.common;
 
 import com.irtimaled.bbor.Logger;
 import com.irtimaled.bbor.ReflectionHelper;
-import com.irtimaled.bbor.common.models.WorldData;
-import com.irtimaled.bbor.config.ConfigManager;
 import net.minecraft.world.DimensionType;
 import net.minecraft.world.World;
 import net.minecraft.world.chunk.Chunk;
@@ -11,45 +9,36 @@ import net.minecraft.world.chunk.IChunkProvider;
 import net.minecraft.world.gen.ChunkProviderServer;
 import net.minecraft.world.gen.IChunkGenerator;
 
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
 public class CommonProxy {
-    public Map<DimensionType, BoundingBoxCache> boundingBoxCacheMap = new ConcurrentHashMap<>();
+    protected DimensionCache dimensionCache = new DimensionCache();
 
-    protected WorldData worldData;
     private IEventHandler eventHandler = null;
 
-    public void init() {
-    }
-
     public void worldLoaded(World world) {
         IChunkProvider chunkProvider = world.getChunkProvider();
         if (chunkProvider instanceof ChunkProviderServer) {
             IChunkGenerator chunkGenerator = ReflectionHelper.getPrivateValue(ChunkProviderServer.class, (ChunkProviderServer) chunkProvider, IChunkGenerator.class);
-            setWorldData(new WorldData(world.getSeed(), world.getWorldInfo().getSpawnX(), world.getWorldInfo().getSpawnZ()));
+            dimensionCache.setWorldData(world.getSeed(), world.getWorldInfo().getSpawnX(), world.getWorldInfo().getSpawnZ());
             DimensionType dimensionType = world.provider.getDimensionType();
-            Logger.info("create world dimension: %s, %s (chunkprovider: %s) (seed: %d)", dimensionType, world.getClass().toString(), chunkGenerator.getClass().toString(), worldData.getSeed());
-            boundingBoxCacheMap.put(dimensionType, new DimensionProcessor(eventHandler, world, dimensionType, chunkGenerator));
+            Logger.info("create world dimension: %s, %s (chunkprovider: %s) (seed: %d)", dimensionType, world.getClass().toString(), chunkGenerator.getClass().toString(), world.getSeed());
+            DimensionProcessor boundingBoxCache = new DimensionProcessor(eventHandler, world, dimensionType, chunkGenerator);
+            dimensionCache.put(dimensionType, boundingBoxCache);
         }
     }
 
     public void chunkLoaded(Chunk chunk) {
         DimensionType dimensionType = chunk.getWorld().provider.getDimensionType();
-        if (boundingBoxCacheMap.containsKey(dimensionType)) {
-            boundingBoxCacheMap.get(dimensionType).refresh();
-        }
+        dimensionCache.refresh(dimensionType);
     }
 
-    public WorldData getWorldData() {
-        return worldData;
-    }
-
-    public void setWorldData(WorldData worldData) {
-        this.worldData = worldData;
+    public void init() {
     }
 
     public void setEventHandler(IEventHandler eventHandler) {
         this.eventHandler = eventHandler;
     }
+
+    public DimensionCache getDimensionCache() {
+        return dimensionCache;
+    }
 }

diff --git a/java/com/irtimaled/bbor/common/DimensionCache.java b/java/com/irtimaled/bbor/common/DimensionCache.java
new file mode 100644 (file)
index 0000000..a6c8f24
--- /dev/null
+++ b/java/com/irtimaled/bbor/common/DimensionCache.java
@@ -0,0 +1,42 @@
+package com.irtimaled.bbor.common;
+
+import com.irtimaled.bbor.common.models.WorldData;
+import net.minecraft.world.DimensionType;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class DimensionCache {
+    private final Map<DimensionType, BoundingBoxCache> map = new ConcurrentHashMap<>();
+    private WorldData worldData;
+
+    void refresh(DimensionType dimensionType) {
+        if (map.containsKey(dimensionType)) {
+            map.get(dimensionType).refresh();
+        }
+    }
+
+    public void put(DimensionType dimensionType, BoundingBoxCache boundingBoxCache) {
+        map.put(dimensionType, boundingBoxCache);
+    }
+
+    public BoundingBoxCache getBoundingBoxes(DimensionType dimensionType) {
+        return map.get(dimensionType);
+    }
+
+    public void clear() {
+        worldData = null;
+        for (BoundingBoxCache cache : map.values()) {
+            cache.close();
+        }
+        map.clear();
+    }
+
+    public void setWorldData(long seed, int spawnX, int spawnZ) {
+        this.worldData = new WorldData(seed, spawnX, spawnZ);
+    }
+
+    public WorldData getWorldData() {
+        return worldData;
+    }
+}

diff --git a/java/com/irtimaled/bbor/forge/ForgeCommonProxy.java b/java/com/irtimaled/bbor/forge/ForgeCommonProxy.java
index c5e630d086919ac4d56b9e022b3f61537e31795c..b1f7a3bfb4337121495c75c0773604d9a5036d03 100644 (file)
--- a/java/com/irtimaled/bbor/forge/ForgeCommonProxy.java
+++ b/java/com/irtimaled/bbor/forge/ForgeCommonProxy.java
@@ -3,6 +3,7 @@ package com.irtimaled.bbor.forge;
 import com.irtimaled.bbor.Logger;
 import com.irtimaled.bbor.common.BoundingBoxCache;
 import com.irtimaled.bbor.common.CommonProxy;
+import com.irtimaled.bbor.common.DimensionCache;
 import com.irtimaled.bbor.common.IEventHandler;
 import com.irtimaled.bbor.common.models.BoundingBox;
 import com.irtimaled.bbor.common.models.WorldData;
@@ -80,7 +81,7 @@ public class ForgeCommonProxy implements IEventHandler {
             DimensionType dimensionType = DimensionType.getById(player.dimension);
             playerDimensions.put(player, dimensionType);
 
-            sendToPlayer(player, getProxy().boundingBoxCacheMap.get(dimensionType));
+            sendToPlayer(player, getDimensionCache().getBoundingBoxes(dimensionType));
         }
     }
 
@@ -96,7 +97,7 @@ public class ForgeCommonProxy implements IEventHandler {
             initializeClient(player);
             DimensionType dimensionType = DimensionType.getById(player.dimension);
             playerDimensions.put(player, dimensionType);
-            sendToPlayer(player, getProxy().boundingBoxCacheMap.get(dimensionType));
+            sendToPlayer(player, getDimensionCache().getBoundingBoxes(dimensionType));
         }
     }
 
@@ -117,15 +118,13 @@ public class ForgeCommonProxy implements IEventHandler {
                 playerDimensions.remove(player);
             } else {
                 DimensionType dimensionType = playerDimensions.get(player);
-                if (getProxy().boundingBoxCacheMap.containsKey(dimensionType)) {
-                    sendToPlayer(player, getProxy().boundingBoxCacheMap.get(dimensionType));
-                }
+                sendToPlayer(player, getDimensionCache().getBoundingBoxes(dimensionType));
             }
         }
     }
 
     private void initializeClient(EntityPlayerMP player) {
-        network.sendTo(InitializeClientMessage.from(getProxy().getWorldData()), player);
+        network.sendTo(InitializeClientMessage.from(getDimensionCache().getWorldData()), player);
     }
 
     private void sendToPlayer(EntityPlayerMP player, BoundingBoxCache boundingBoxCache) {
@@ -175,23 +174,26 @@ public class ForgeCommonProxy implements IEventHandler {
     }
 
     public void setWorldData(WorldData worldData) {
-        getProxy().setWorldData(worldData);
+        getDimensionCache().setWorldData(worldData.getSeed(), worldData.getSpawnX(), worldData.getSpawnZ());
     }
 
     public void addBoundingBox(DimensionType dimensionType, BoundingBox key, Set<BoundingBox> boundingBoxes) {
-        Map<DimensionType, BoundingBoxCache> boundingBoxCacheMap = getProxy().boundingBoxCacheMap;
-        if (!boundingBoxCacheMap.containsKey(dimensionType)) {
-            boundingBoxCacheMap.put(dimensionType, new BoundingBoxCache());
+        DimensionCache dimensionCache = getDimensionCache();
+        BoundingBoxCache cache = dimensionCache.getBoundingBoxes(dimensionType);
+        if (cache == null) {
+            dimensionCache.put(dimensionType, cache = new BoundingBoxCache());
         }
-
-        boundingBoxCacheMap.get(dimensionType).addBoundingBoxes(key, boundingBoxes);
+        cache.addBoundingBoxes(key, boundingBoxes);
     }
 
     public void removeBoundingBox(DimensionType dimensionType, BoundingBox key) {
-        Map<DimensionType, BoundingBoxCache> boundingBoxCacheMap = getProxy().boundingBoxCacheMap;
-
-        if (boundingBoxCacheMap.containsKey(dimensionType)) {
-            boundingBoxCacheMap.get(dimensionType).removeBoundingBox(key);
+        BoundingBoxCache cache = getDimensionCache().getBoundingBoxes(dimensionType);
+        if (cache != null) {
+            cache.removeBoundingBox(key);
         }
     }
+
+    private DimensionCache getDimensionCache() {
+        return getProxy().getDimensionCache();
+    }
 }