Backport generic chunk handler to 1.16.5 for Spigot, Fabric, Forge

bukkit-helper-116-4/src/main/java/org/dynmap/bukkit/helper/v116_4/BukkitVersionHelperSpigot116_4.java

@@ -136,7 +136,7 @@ public class BukkitVersionHelperSpigot116_4 extends BukkitVersionHelperGeneric {
      */
     @Override
     public MapChunkCache getChunkCache(BukkitWorld dw, List<DynmapChunk> chunks) {
-        MapChunkCache116_4 c = new MapChunkCache116_4();
+        MapChunkCache116_4 c = new MapChunkCache116_4(gencache);
         c.setChunks(dw, chunks);
         return c;
     }
@@ -253,4 +253,8 @@ public class BukkitVersionHelperSpigot116_4 extends BukkitVersionHelperGeneric {
         }
         return null;
     }
+	@Override
+    public boolean useGenericCache() {
+    	return true;
+    }
 }

bukkit-helper-116-4/src/main/java/org/dynmap/bukkit/helper/v116_4/MapChunkCache116_4.java

@@ -1,484 +1,87 @@
 package org.dynmap.bukkit.helper.v116_4;
 
 import net.minecraft.server.v1_16_R3.*;
-import org.bukkit.ChunkSnapshot;
+
 import org.bukkit.World;
-import org.bukkit.block.Biome;
 import org.bukkit.craftbukkit.v1_16_R3.CraftWorld;
 import org.dynmap.DynmapChunk;
-import org.dynmap.DynmapCore;
+import org.dynmap.bukkit.helper.BukkitWorld;
-import org.dynmap.bukkit.helper.AbstractMapChunkCache;
+import org.dynmap.common.chunk.GenericChunk;
-import org.dynmap.bukkit.helper.BukkitVersionHelper;
+import org.dynmap.common.chunk.GenericChunkCache;
-import org.dynmap.bukkit.helper.SnapshotCache;
+import org.dynmap.common.chunk.GenericMapChunkCache;
-import org.dynmap.bukkit.helper.SnapshotCache.SnapshotRec;
-import org.dynmap.renderer.DynmapBlockState;
-import org.dynmap.utils.DynIntHashMap;
-import org.dynmap.utils.VisibilityLimit;
 
 import java.io.IOException;
-import java.util.Arrays;
+import java.util.List;
 
 /**
  * Container for managing chunks - dependent upon using chunk snapshots, since rendering is off server thread
  */
-public class MapChunkCache116_4 extends AbstractMapChunkCache {
+public class MapChunkCache116_4 extends GenericMapChunkCache {
-
+	private World w;
-	public static class NBTSnapshot implements Snapshot {
+	/**
-	    private static interface Section {
+	 * Construct empty cache
-	        public DynmapBlockState getBlockType(int x, int y, int z);
+	 */
-	        public int getBlockSkyLight(int x, int y, int z);
+	public MapChunkCache116_4(GenericChunkCache cc) {
-	        public int getBlockEmittedLight(int x, int y, int z);
+		super(cc);
-	        public boolean isEmpty();
+		init();
-	    }
-	    private final int x, z;
-	    private final Section[] section;
-	    private final int[] hmap; // Height map
-	    private final int[] biome;
-	    private final Object[] biomebase;
-	    private final long captureFulltime;
-	    private final int sectionCnt;
-	    private final long inhabitedTicks;
-
-	    private static final int BLOCKS_PER_SECTION = 16 * 16 * 16;
-	    private static final int COLUMNS_PER_CHUNK = 16 * 16;
-        private static final int V1_15_BIOME_PER_CHUNK = 4 * 4 * 64;
-	    private static final byte[] emptyData = new byte[BLOCKS_PER_SECTION / 2];
-	    private static final byte[] fullData = new byte[BLOCKS_PER_SECTION / 2];
-
-	    static
-	    {
-	        Arrays.fill(fullData, (byte)0xFF);
-	    }
-	    
-	    private static byte[] dataCopy(byte[] v) {
-	    	if (Arrays.equals(v, emptyData))
-	    		return emptyData;
-	    	else if (Arrays.equals(v, fullData))
-	    		return fullData;
-	    	else
-	    		return v.clone();
-	    }
-
-	    private static class EmptySection implements Section {
-	        @Override
-	        public DynmapBlockState getBlockType(int x, int y, int z) {
-	            return DynmapBlockState.AIR;
-	        }
-	        @Override
-	        public int getBlockSkyLight(int x, int y, int z) {
-	            return 15;
-	        }
-	        @Override
-	        public int getBlockEmittedLight(int x, int y, int z) {
-	            return 0;
-	        }
-	        @Override
-	        public boolean isEmpty() {
-	            return true;
-	        }
-	    }
-	    
-	    private static final EmptySection empty_section = new EmptySection();
-	    
-	    private static class StdSection implements Section {
-	        DynmapBlockState[] states;
-	        byte[] skylight;
-	        byte[] emitlight;
-
-	        public StdSection() {
-	            states = new DynmapBlockState[BLOCKS_PER_SECTION];
-	            Arrays.fill(states,  DynmapBlockState.AIR);
-	            skylight = emptyData;
-	            emitlight = emptyData;
-	        }
-	        @Override
-	        public DynmapBlockState getBlockType(int x, int y, int z) {
-	            return states[((y & 0xF) << 8) | (z << 4) | x];
-	        }
-	        @Override
-	        public int getBlockSkyLight(int x, int y, int z) {
-	            int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
-	            return (skylight[off] >> (4 * (x & 1))) & 0xF;
-	        }
-	        @Override
-	        public int getBlockEmittedLight(int x, int y, int z)
-	        {
-	            int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
-	            return (emitlight[off] >> (4 * (x & 1))) & 0xF;
-	        }
-	        @Override
-	        public boolean isEmpty() {
-	            return false;
-	        }
-	    }
-	    /**
-	     * Construct empty chunk snapshot
-	     *
-	     * @param x
-	     * @param z
-	     */
-	    public NBTSnapshot(int worldheight, int x, int z, long captime, long inhabitedTime)
-	    {
-	        this.x = x;
-	        this.z = z;
-	        this.captureFulltime = captime;
-	        this.biome = new int[COLUMNS_PER_CHUNK];
-	        this.biomebase = new Object[COLUMNS_PER_CHUNK];
-	        this.sectionCnt = worldheight / 16;
-	        /* Allocate arrays indexed by section */
-	        this.section = new Section[this.sectionCnt+1];
-
-	        /* Fill with empty data */
-	        for (int i = 0; i <= this.sectionCnt; i++) {
-	            this.section[i] = empty_section;
-	        }
-
-	        /* Create empty height map */
-	        this.hmap = new int[16 * 16];
-	        
-	        this.inhabitedTicks = inhabitedTime;
-	    }
-
-	    public NBTSnapshot(NBTTagCompound nbt, int worldheight) {
-	        this.x = nbt.getInt("xPos");
-	        this.z = nbt.getInt("zPos");
-	        this.captureFulltime = 0;
-	        this.hmap = nbt.getIntArray("HeightMap");
-	        this.sectionCnt = worldheight / 16;
-	        if (nbt.hasKey("InhabitedTime")) {
-	            this.inhabitedTicks = nbt.getLong("InhabitedTime");
-	        }
-	        else {
-	            this.inhabitedTicks = 0;
-	        }
-	        /* Allocate arrays indexed by section */
-	        this.section = new Section[this.sectionCnt+1];
-	        /* Fill with empty data */
-	        for (int i = 0; i <= this.sectionCnt; i++) {
-	            this.section[i] = empty_section;
-	        }
-	        /* Get sections */
-	        NBTTagList sect = nbt.getList("Sections", 10);
-	        for (int i = 0; i < sect.size(); i++) {
-	            NBTTagCompound sec = sect.getCompound(i);
-	            int secnum = sec.getByte("Y");
-	            if (secnum >= this.sectionCnt) {
-	                //Log.info("Section " + (int) secnum + " above world height " + worldheight);
-	                continue;
-	            }
-	            if (secnum < 0)
-	            	continue;
-	            //System.out.println("section(" + secnum + ")=" + sec.asString());
-	            // Create normal section to initialize
-	            StdSection cursect = new StdSection();
-	            this.section[secnum] = cursect;
-	            DynmapBlockState[] states = cursect.states;
-	            DynmapBlockState[] palette = null;
-	            // If we've got palette and block states list, process non-empty section
-	            if (sec.hasKeyOfType("Palette", 9) && sec.hasKeyOfType("BlockStates", 12)) {
-	            	NBTTagList plist = sec.getList("Palette", 10);
-	            	long[] statelist = sec.getLongArray("BlockStates");
-	            	palette = new DynmapBlockState[plist.size()];
-	            	for (int pi = 0; pi < plist.size(); pi++) {
-	            		NBTTagCompound tc = plist.getCompound(pi);
-	            		String pname = tc.getString("Name");
-                        if (tc.hasKey("Properties")) {
-                            StringBuilder statestr = new StringBuilder();
-                            NBTTagCompound prop = tc.getCompound("Properties");
-                            for (String pid : prop.getKeys()) {
-                                if (statestr.length() > 0) statestr.append(',');
-                                statestr.append(pid).append('=').append(prop.get(pid).asString());
-                            }
-	            			palette[pi] = DynmapBlockState.getStateByNameAndState(pname, statestr.toString());
-	            		}
-	            		if (palette[pi] == null) {
-	            			palette[pi] = DynmapBlockState.getBaseStateByName(pname);
-	            		}
-	            		if (palette[pi] == null) {
-	            			palette[pi] = DynmapBlockState.AIR;
-	            		}
-	            	}
-	            	int recsperblock = (4096 + statelist.length - 1) / statelist.length;
-	            	int bitsperblock = 64 / recsperblock;
-	            	DataBits db = null;
-	            	DataBitsPacked dbp = null;
-	            	try {
-	            		db = new DataBits(bitsperblock, 4096, statelist);
-	            	} catch (Exception x) {	// Handle legacy encoded
-		            	bitsperblock = (statelist.length * 64) / 4096;
-	            		dbp = new DataBitsPacked(bitsperblock, 4096, statelist);
-	            	}
-        			if (bitsperblock > 8) {	// Not palette
-            			for (int j = 0; j < 4096; j++) {
-            				int v = (db != null) ? db.a(j) : dbp.a(j);
-            				states[j] = DynmapBlockState.getStateByGlobalIndex(v);
-            			}
-        			}
-        			else {
-            			for (int j = 0; j < 4096; j++) {
-            				int v = (db != null) ? db.a(j) : dbp.a(j);
-            				states[j] = (v < palette.length) ? palette[v] : DynmapBlockState.AIR;
-            			}
-        			}
-				}
-	            if (sec.hasKey("BlockLight")) {
-					cursect.emitlight = dataCopy(sec.getByteArray("BlockLight"));
-	            }
-				if (sec.hasKey("SkyLight")) {
-					cursect.skylight = dataCopy(sec.getByteArray("SkyLight"));
-				}
-	        }
-	        /* Get biome data */
-	        this.biome = new int[COLUMNS_PER_CHUNK];
-	        this.biomebase = new Object[COLUMNS_PER_CHUNK];
-	        Object[] bbl = BukkitVersionHelper.helper.getBiomeBaseList();
-	        if (nbt.hasKey("Biomes")) {
-            	int[] bb = nbt.getIntArray("Biomes");
-            	if (bb != null) {
-            	    // If v1.15+ format
-            	    if (bb.length > COLUMNS_PER_CHUNK) {
-            	        // For now, just pad the grid with the first 16
-                        for (int i = 0; i < COLUMNS_PER_CHUNK; i++) {
-                            int off = ((i >> 4) & 0xC) + ((i >> 2) & 0x3);
-                            int bv = bb[off + 64];   // Offset to y=64
-                            if (bv < 0) bv = 0;
-                            this.biome[i] = bv;
-                            this.biomebase[i] = bbl[bv];
-                        }
-            	    }
-            	    else { // Else, older chunks
-            	        for (int i = 0; i < bb.length; i++) {
-            	            int bv = bb[i];
-            	            if (bv < 0) bv = 0;
-            	            this.biome[i] = bv;
-            	            this.biomebase[i] = bbl[bv];
-            	        }
-            	    }
-	            }
-	        }
-	    }
-	    
-	    public int getX()
-	    {
-	        return x;
-	    }
-
-	    public int getZ()
-	    {
-	        return z;
-	    }
-	    
-	    public DynmapBlockState getBlockType(int x, int y, int z)
-	    {
-	        return section[y >> 4].getBlockType(x, y, z);
-	    }
-
-	    public int getBlockSkyLight(int x, int y, int z)
-	    {
-	        return section[y >> 4].getBlockSkyLight(x, y, z);
-	    }
-
-	    public int getBlockEmittedLight(int x, int y, int z)
-	    {
-	        return section[y >> 4].getBlockEmittedLight(x, y, z);
-	    }
-
-	    public int getHighestBlockYAt(int x, int z)
-	    {
-	        return hmap[z << 4 | x];
-	    }
-
-	    public final long getCaptureFullTime()
-	    {
-	        return captureFulltime;
-	    }
-
-	    public boolean isSectionEmpty(int sy)
-	    {
-	        return section[sy].isEmpty();
-	    }
-	    
-	    public long getInhabitedTicks() {
-	        return inhabitedTicks;
-	    }
-
-		@Override
-		public Biome getBiome(int x, int z) {
-	        return AbstractMapChunkCache.getBiomeByID(biome[z << 4 | x]);
-		}
-
-		@Override
-		public Object[] getBiomeBaseFromSnapshot() {
-			return this.biomebase;
-		}
 	}
 	
-    private NBTTagCompound fetchLoadedChunkNBT(World w, int x, int z) {
+	private boolean isLitChunk(NBTTagCompound nbt) {
+		if ((nbt != null) && nbt.hasKey("Level")) {
+    		nbt = nbt.getCompound("Level");
+    	}
+        if (nbt != null) {
+            String stat = nbt.getString("Status");
+			ChunkStatus cs = ChunkStatus.a(stat);
+            if ((stat != null) && cs.b(ChunkStatus.LIGHT)) {	// ChunkStatus.LIGHT
+            	return true;
+            }
+        }
+        return false;
+	}
+
+	// Load generic chunk from existing and already loaded chunk
+	protected GenericChunk getLoadedChunk(DynmapChunk chunk) {
         CraftWorld cw = (CraftWorld) w;
         NBTTagCompound nbt = null;
-        if (cw.isChunkLoaded(x, z)) {
+        GenericChunk gc = null;
-            Chunk c = cw.getHandle().getChunkAt(x,  z);
+        if (cw.isChunkLoaded(chunk.x, chunk.z)) {
+            Chunk c = cw.getHandle().getChunkAt(chunk.x,  chunk.z);
             if ((c != null) && c.loaded) {
                 nbt = ChunkRegionLoader.saveChunk(cw.getHandle(), c);
             }
-        }
+            if (!isLitChunk(nbt)) {
-        if (nbt != null) {
+            	nbt = null;
-            nbt = nbt.getCompound("Level");
+            }
             if (nbt != null) {
-                String stat = nbt.getString("Status");
+            	gc = parseChunkFromNBT(new NBT.NBTCompound(nbt));
-				ChunkStatus cs = ChunkStatus.a(stat);
-                if ((stat == null) || (!cs.b(ChunkStatus.LIGHT))) {
-                    nbt = null;
-                }
             }
         }
-        return nbt;
+    	return gc;
-    }
+	}
 	
-    private NBTTagCompound loadChunkNBT(World w, int x, int z) {
+	// Load generic chunk from unloaded chunk
+	protected GenericChunk loadChunk(DynmapChunk chunk) {
         CraftWorld cw = (CraftWorld) w;
         NBTTagCompound nbt = null;
-        ChunkCoordIntPair cc = new ChunkCoordIntPair(x, z);
+        ChunkCoordIntPair cc = new ChunkCoordIntPair(chunk.x,  chunk.z);
+        GenericChunk gc = null;
         try {
             nbt = cw.getHandle().getChunkProvider().playerChunkMap.read(cc);
         } catch (IOException iox) {
         }
+        if (!isLitChunk(nbt)) {
+        	nbt = null;
+        }
         if (nbt != null) {
-            nbt = nbt.getCompound("Level");
+        	gc = parseChunkFromNBT(new NBT.NBTCompound(nbt));
-            if (nbt != null) {
-            	String stat = nbt.getString("Status");
-            	if ((stat == null) || (stat.equals("full") == false)) {
-                    nbt = null;
-                    if ((stat == null) || stat.equals("") && DynmapCore.migrateChunks()) {
-                        Chunk c = cw.getHandle().getChunkAt(x, z);
-                        if (c != null) {
-                            nbt = fetchLoadedChunkNBT(w, x, z);
-                            cw.getHandle().unloadChunk(c);
-                        }
-                    }
-            	}
-            }
         }
-        return nbt;
+    	return gc;
-    }   
+	}
 
-    @Override
+	public void setChunks(BukkitWorld dw, List<DynmapChunk> chunks) {
-    public Snapshot wrapChunkSnapshot(ChunkSnapshot css) {
+		this.w = dw.getWorld();
-        // TODO Auto-generated method stub
+		super.setChunks(dw, chunks);
-        return null;
+	}
-    }
-    
-    // Load chunk snapshots
-    @Override
-    public int loadChunks(int max_to_load) {
-        if(dw.isLoaded() == false)
-            return 0;        
-        int cnt = 0;
-        if(iterator == null)
-            iterator = chunks.listIterator();
-
-        DynmapCore.setIgnoreChunkLoads(true);
-        // Load the required chunks.
-        while((cnt < max_to_load) && iterator.hasNext()) {
-            long startTime = System.nanoTime();
-            DynmapChunk chunk = iterator.next();
-            boolean vis = true;
-            if(visible_limits != null) {
-                vis = false;
-                for(VisibilityLimit limit : visible_limits) {
-                    if (limit.doIntersectChunk(chunk.x, chunk.z)) {
-                        vis = true;
-                        break;
-                    }
-                }
-            }
-            if(vis && (hidden_limits != null)) {
-                for(VisibilityLimit limit : hidden_limits) {
-                    if (limit.doIntersectChunk(chunk.x, chunk.z)) {
-                        vis = false;
-                        break;
-                    }
-                }
-            }
-            /* Check if cached chunk snapshot found */
-            Snapshot ss = null;
-            long inhabited_ticks = 0;
-            DynIntHashMap tileData = null;
-            int idx = (chunk.x-x_min) + (chunk.z - z_min)*x_dim;
-            SnapshotRec ssr = SnapshotCache.sscache.getSnapshot(dw.getName(), chunk.x, chunk.z, blockdata, biome, biomeraw, highesty); 
-            if(ssr != null) {
-                inhabited_ticks = ssr.inhabitedTicks;
-                if(!vis) {
-                    if(hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN)
-                        ss = STONE;
-                    else if(hidestyle == HiddenChunkStyle.FILL_OCEAN)
-                        ss = OCEAN;
-                    else
-                        ss = EMPTY;
-                }
-                else {
-                    ss = ssr.ss;
-                }
-                snaparray[idx] = ss;
-                snaptile[idx] = ssr.tileData;
-                inhabitedTicks[idx] = inhabited_ticks;
-                
-                endChunkLoad(startTime, ChunkStats.CACHED_SNAPSHOT_HIT);
-                continue;
-            }
-            // Fetch NTB for chunk if loaded
-            NBTTagCompound nbt = fetchLoadedChunkNBT(w, chunk.x, chunk.z); 
-            boolean did_load = false;
-            if (nbt == null) {
-                // Load NTB for chunk, if it exists
-                nbt = loadChunkNBT(w, chunk.x, chunk.z);
-                did_load = true;
-            }
-            if (nbt != null) {
-                NBTSnapshot nss = new NBTSnapshot(nbt, w.getMaxHeight());
-                ss = nss;
-                inhabited_ticks = nss.getInhabitedTicks();
-                if(!vis) {
-                    if(hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN)
-                        ss = STONE;
-                    else if(hidestyle == HiddenChunkStyle.FILL_OCEAN)
-                        ss = OCEAN;
-                    else
-                        ss = EMPTY;
-                }
-            }
-            else {
-                ss = EMPTY;
-            }
-            ssr = new SnapshotRec();
-            ssr.ss = ss;
-            ssr.inhabitedTicks = inhabited_ticks;
-            ssr.tileData = tileData;
-            SnapshotCache.sscache.putSnapshot(dw.getName(), chunk.x, chunk.z, ssr, blockdata, biome, biomeraw, highesty);
-            snaparray[idx] = ss;
-            snaptile[idx] = ssr.tileData;
-            inhabitedTicks[idx] = inhabited_ticks;
-            if (nbt == null)
-                endChunkLoad(startTime, ChunkStats.UNGENERATED_CHUNKS);
-            else if (did_load)
-                endChunkLoad(startTime, ChunkStats.UNLOADED_CHUNKS);
-            else
-                endChunkLoad(startTime, ChunkStats.LOADED_CHUNKS);
-            cnt++;
-        }
-        DynmapCore.setIgnoreChunkLoads(false);
-
-        if(iterator.hasNext() == false) {   /* If we're done */
-            isempty = true;
-            /* Fill missing chunks with empty dummy chunk */
-            for(int i = 0; i < snaparray.length; i++) {
-                if(snaparray[i] == null)
-                    snaparray[i] = EMPTY;
-                else if(snaparray[i] != EMPTY)
-                    isempty = false;
-            }
-        }
-
-        return cnt;
-    }
 }
+

bukkit-helper-116-4/src/main/java/org/dynmap/bukkit/helper/v116_4/NBT.java

@@ -0,0 +1,121 @@
+package org.dynmap.bukkit.helper.v116_4;
+
+import org.dynmap.common.chunk.GenericBitStorage;
+import org.dynmap.common.chunk.GenericNBTCompound;
+import org.dynmap.common.chunk.GenericNBTList;
+
+import net.minecraft.server.v1_16_R3.DataBits;
+import net.minecraft.server.v1_16_R3.NBTTagCompound;
+import net.minecraft.server.v1_16_R3.NBTTagList;
+
+import java.util.Set;
+
+public class NBT {
+
+	public static class NBTCompound implements GenericNBTCompound {
+		private final NBTTagCompound obj;
+		public NBTCompound(NBTTagCompound t) {
+			this.obj = t;
+		}
+		@Override
+		public Set<String> getAllKeys() {
+			return obj.getKeys();
+		}
+		@Override
+		public boolean contains(String s) {
+			return obj.hasKey(s);
+		}
+		@Override
+		public boolean contains(String s, int i) {
+			return obj.hasKeyOfType(s, i);
+		}
+		@Override
+		public byte getByte(String s) {
+			return obj.getByte(s);
+		}
+		@Override
+		public short getShort(String s) {
+			return obj.getShort(s);
+		}
+		@Override
+		public int getInt(String s) {
+			return obj.getInt(s);
+		}
+		@Override
+		public long getLong(String s) {
+			return obj.getLong(s);
+		}
+		@Override
+		public float getFloat(String s) {
+			return obj.getFloat(s);
+		}
+		@Override
+		public double getDouble(String s) {
+			return obj.getDouble(s);
+		}
+		@Override
+		public String getString(String s) {
+			return obj.getString(s);
+		}
+		@Override
+		public byte[] getByteArray(String s) {
+			return obj.getByteArray(s);
+		}
+		@Override
+		public int[] getIntArray(String s) {
+			return obj.getIntArray(s);
+		}
+		@Override
+		public long[] getLongArray(String s) {
+			return obj.getLongArray(s);
+		}
+		@Override
+		public GenericNBTCompound getCompound(String s) {
+			return new NBTCompound(obj.getCompound(s));
+		}
+		@Override
+		public GenericNBTList getList(String s, int i) {
+			return new NBTList(obj.getList(s, i));
+		}
+		@Override
+		public boolean getBoolean(String s) {
+			return obj.getBoolean(s);
+		}
+		@Override
+		public String getAsString(String s) {
+			return obj.get(s).asString();
+		}
+		@Override
+		public GenericBitStorage makeBitStorage(int bits, int count, long[] data) {
+			return new OurBitStorage(bits, count, data);
+		}		
+	}
+	public static class NBTList implements GenericNBTList {
+		private final NBTTagList obj;
+		public NBTList(NBTTagList t) {
+			obj = t;
+		}
+		@Override
+		public int size() {
+			return obj.size();
+		}
+		@Override
+		public String getString(int idx) {
+			return obj.getString(idx);
+		}
+		@Override
+		public GenericNBTCompound getCompound(int idx) {
+			return new NBTCompound(obj.getCompound(idx));
+		}
+	}
+	public static class OurBitStorage implements GenericBitStorage {
+		private final DataBits bs;
+		public OurBitStorage(int bits, int count, long[] data) {
+			bs = new DataBits(bits, count, data);
+		}
+		@Override
+		public int get(int idx) {
+			return bs.a(idx);
+		}
+	}
+}

fabric-1.16.4/src/main/java/org/dynmap/fabric_1_16_4/ChunkSnapshot.java

@@ -1,302 +0,0 @@
-package org.dynmap.fabric_1_16_4;
-
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
-import net.minecraft.util.collection.PackedIntegerArray;
-import net.minecraft.util.math.MathHelper;
-import net.minecraft.util.math.WordPackedArray;
-import org.dynmap.Log;
-import org.dynmap.renderer.DynmapBlockState;
-
-import java.util.Arrays;
-
-/**
- * Represents a static, thread-safe snapshot of chunk of blocks
- * Purpose is to allow clean, efficient copy of a chunk data to be made, and then handed off for processing in another thread (e.g. map rendering)
- */
-public class ChunkSnapshot {
-    private static interface Section {
-        public DynmapBlockState getBlockType(int x, int y, int z);
-
-        public int getBlockSkyLight(int x, int y, int z);
-
-        public int getBlockEmittedLight(int x, int y, int z);
-
-        public boolean isEmpty();
-    }
-
-    private final int x, z;
-    private final Section[] section;
-    private final int[] hmap; // Height map
-    private final int[] biome;
-    private final long captureFulltime;
-    private final int sectionCnt;
-    private final long inhabitedTicks;
-
-    private static final int BLOCKS_PER_SECTION = 16 * 16 * 16;
-    private static final int COLUMNS_PER_CHUNK = 16 * 16;
-    private static final byte[] emptyData = new byte[BLOCKS_PER_SECTION / 2];
-    private static final byte[] fullData = new byte[BLOCKS_PER_SECTION / 2];
-
-    static {
-        Arrays.fill(fullData, (byte) 0xFF);
-    }
-
-    private static class EmptySection implements Section {
-        @Override
-        public DynmapBlockState getBlockType(int x, int y, int z) {
-            return DynmapBlockState.AIR;
-        }
-
-        @Override
-        public int getBlockSkyLight(int x, int y, int z) {
-            return 15;
-        }
-
-        @Override
-        public int getBlockEmittedLight(int x, int y, int z) {
-            return 0;
-        }
-
-        @Override
-        public boolean isEmpty() {
-            return true;
-        }
-    }
-
-    private static final EmptySection empty_section = new EmptySection();
-
-    private static class StdSection implements Section {
-        DynmapBlockState[] states;
-        byte[] skylight;
-        byte[] emitlight;
-
-        public StdSection() {
-            states = new DynmapBlockState[BLOCKS_PER_SECTION];
-            Arrays.fill(states, DynmapBlockState.AIR);
-            skylight = emptyData;
-            emitlight = emptyData;
-        }
-
-        @Override
-        public DynmapBlockState getBlockType(int x, int y, int z) {
-            return states[((y & 0xF) << 8) | (z << 4) | x];
-        }
-
-        @Override
-        public int getBlockSkyLight(int x, int y, int z) {
-            int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
-            return (skylight[off] >> (4 * (x & 1))) & 0xF;
-        }
-
-        @Override
-        public int getBlockEmittedLight(int x, int y, int z) {
-            int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
-            return (emitlight[off] >> (4 * (x & 1))) & 0xF;
-        }
-
-        @Override
-        public boolean isEmpty() {
-            return false;
-        }
-    }
-
-    /**
-     * Construct empty chunk snapshot
-     *
-     * @param x
-     * @param z
-     */
-    public ChunkSnapshot(int worldheight, int x, int z, long captime, long inhabitedTime) {
-        this.x = x;
-        this.z = z;
-        this.captureFulltime = captime;
-        this.biome = new int[COLUMNS_PER_CHUNK];
-        this.sectionCnt = worldheight / 16;
-        /* Allocate arrays indexed by section */
-        this.section = new Section[this.sectionCnt+1];
-
-        /* Fill with empty data */
-        for (int i = 0; i <= this.sectionCnt; i++) {
-            this.section[i] = empty_section;
-        }
-
-        /* Create empty height map */
-        this.hmap = new int[16 * 16];
-
-        this.inhabitedTicks = inhabitedTime;
-    }
-
-    public static class StateListException extends Exception {
-        private static boolean loggedOnce = false;
-
-        public StateListException(int x, int z, int actualLength, int expectedLength, int expectedLegacyLength) {
-            if (Log.verbose || !loggedOnce) {
-                loggedOnce = true;
-                Log.info("Skipping chunk at x=" + x + ",z=" + z + ". Expected statelist of length " + expectedLength + " or " + expectedLegacyLength + " but got " + actualLength + ". This can happen if the chunk was not yet converted to the 1.16 format which can be fixed by visiting the chunk.");
-                if (!Log.verbose) {
-                    Log.info("You will only see this message once. Turn on verbose logging in the configuration to see all messages.");
-                }
-            }
-        }
-    }
-
-    public ChunkSnapshot(CompoundTag nbt, int worldheight) throws StateListException {
-        this.x = nbt.getInt("xPos");
-        this.z = nbt.getInt("zPos");
-        this.captureFulltime = 0;
-        this.hmap = nbt.getIntArray("HeightMap");
-        this.sectionCnt = worldheight / 16;
-        if (nbt.contains("InhabitedTime")) {
-            this.inhabitedTicks = nbt.getLong("InhabitedTime");
-        } else {
-            this.inhabitedTicks = 0;
-        }
-        /* Allocate arrays indexed by section */
-        this.section = new Section[this.sectionCnt+1];
-        /* Fill with empty data */
-        for (int i = 0; i <= this.sectionCnt; i++) {
-            this.section[i] = empty_section;
-        }
-        /* Get sections */
-        ListTag sect = nbt.getList("Sections", 10);
-        for (int i = 0; i < sect.size(); i++) {
-            CompoundTag sec = sect.getCompound(i);
-            int secnum = sec.getByte("Y");
-            if (secnum >= this.sectionCnt) {
-                //Log.info("Section " + (int) secnum + " above world height " + worldheight);
-                continue;
-            }
-            if (secnum < 0)
-                continue;
-            //System.out.println("section(" + secnum + ")=" + sec.asString());
-            // Create normal section to initialize
-            StdSection cursect = new StdSection();
-            this.section[secnum] = cursect;
-            DynmapBlockState[] states = cursect.states;
-            DynmapBlockState[] palette = null;
-            // If we've got palette and block states list, process non-empty section
-            if (sec.contains("Palette", 9) && sec.contains("BlockStates", 12)) {
-                ListTag plist = sec.getList("Palette", 10);
-                long[] statelist = sec.getLongArray("BlockStates");
-                palette = new DynmapBlockState[plist.size()];
-                for (int pi = 0; pi < plist.size(); pi++) {
-                    CompoundTag tc = plist.getCompound(pi);
-                    String pname = tc.getString("Name");
-                    if (tc.contains("Properties")) {
-                        StringBuilder statestr = new StringBuilder();
-                        CompoundTag prop = tc.getCompound("Properties");
-                        for (String pid : prop.getKeys()) {
-                            if (statestr.length() > 0) statestr.append(',');
-                            statestr.append(pid).append('=').append(prop.get(pid).asString());
-                        }
-                        palette[pi] = DynmapBlockState.getStateByNameAndState(pname, statestr.toString());
-                    }
-                    if (palette[pi] == null) {
-                        palette[pi] = DynmapBlockState.getBaseStateByName(pname);
-                    }
-                    if (palette[pi] == null) {
-                        palette[pi] = DynmapBlockState.AIR;
-                    }
-                }
-
-                PackedIntegerArray db = null;
-                WordPackedArray dbp = null;
-
-                int bitsperblock = (statelist.length * 64) / 4096;
-                int expectedStatelistLength = (4096 + (64 / bitsperblock) - 1) / (64 / bitsperblock);
-                if (statelist.length == expectedStatelistLength) {
-                    db = new PackedIntegerArray(bitsperblock, 4096, statelist);
-                } else {
-                    int expectedLegacyStatelistLength = MathHelper.roundUpToMultiple(bitsperblock * 4096, 64) / 64;
-                    if (statelist.length == expectedLegacyStatelistLength) {
-                        dbp = new WordPackedArray(bitsperblock, 4096, statelist);
-                    } else {
-                        throw new StateListException(x, z, statelist.length, expectedStatelistLength, expectedLegacyStatelistLength);
-                    }
-                }
-
-                if (bitsperblock > 8) {    // Not palette
-                    for (int j = 0; j < 4096; j++) {
-                        int v = db != null ? db.get(j) : dbp.get(j);
-                        states[j] = DynmapBlockState.getStateByGlobalIndex(v);
-                    }
-                } else {
-                    for (int j = 0; j < 4096; j++) {
-                        int v = db != null ? db.get(j) : dbp.get(j);
-                        states[j] = (v < palette.length) ? palette[v] : DynmapBlockState.AIR;
-                    }
-                }
-            }
-            if (sec.contains("BlockLight")) {
-                cursect.emitlight = sec.getByteArray("BlockLight");
-            }
-            if (sec.contains("SkyLight")) {
-                cursect.skylight = sec.getByteArray("SkyLight");
-            }
-        }
-        /* Get biome data */
-        this.biome = new int[COLUMNS_PER_CHUNK];
-        if (nbt.contains("Biomes")) {
-            int[] bb = nbt.getIntArray("Biomes");
-            if (bb != null) {
-                // If v1.15+ format
-                if (bb.length > COLUMNS_PER_CHUNK) {
-                    // For now, just pad the grid with the first 16
-                    for (int i = 0; i < COLUMNS_PER_CHUNK; i++) {
-                        int off = ((i >> 4) & 0xC) + ((i >> 2) & 0x3);
-                        int bv = bb[off + 64];   // Offset to y=64
-                        if (bv < 0) bv = 0;
-                        this.biome[i] = bv;
-                    }
-                } else { // Else, older chunks
-                    for (int i = 0; i < bb.length; i++) {
-                        int bv = bb[i];
-                        if (bv < 0) bv = 0;
-                        this.biome[i] = bv;
-                    }
-                }
-            }
-        }
-    }
-
-    public int getX() {
-        return x;
-    }
-
-    public int getZ() {
-        return z;
-    }
-
-    public DynmapBlockState getBlockType(int x, int y, int z) {
-        return section[y >> 4].getBlockType(x, y, z);
-    }
-
-    public int getBlockSkyLight(int x, int y, int z) {
-        return section[y >> 4].getBlockSkyLight(x, y, z);
-    }
-
-    public int getBlockEmittedLight(int x, int y, int z) {
-        return section[y >> 4].getBlockEmittedLight(x, y, z);
-    }
-
-    public int getHighestBlockYAt(int x, int z) {
-        return hmap[z << 4 | x];
-    }
-
-    public int getBiome(int x, int z) {
-        return biome[z << 4 | x];
-    }
-
-    public final long getCaptureFullTime() {
-        return captureFulltime;
-    }
-
-    public boolean isSectionEmpty(int sy) {
-        return section[sy].isEmpty();
-    }
-
-    public long getInhabitedTicks() {
-        return inhabitedTicks;
-    }
-}

fabric-1.16.4/src/main/java/org/dynmap/fabric_1_16_4/DynmapPlugin.java

@@ -39,6 +39,7 @@ import org.dynmap.common.BiomeMap;
 import org.dynmap.common.DynmapCommandSender;
 import org.dynmap.common.DynmapListenerManager;
 import org.dynmap.common.DynmapPlayer;
+import org.dynmap.common.chunk.GenericChunkCache;
 import org.dynmap.fabric_1_16_4.command.DmapCommand;
 import org.dynmap.fabric_1_16_4.command.DmarkerCommand;
 import org.dynmap.fabric_1_16_4.command.DynmapCommand;
@@ -65,7 +66,7 @@ public class DynmapPlugin {
     DynmapCore core;
     private PermissionProvider permissions;
     private boolean core_enabled;
-    public SnapshotCache sscache;
+    public GenericChunkCache sscache;
     public PlayerList playerList;
     MapManager mapManager;
     /**
@@ -504,7 +505,7 @@ public class DynmapPlugin {
         }
 
         playerList = core.playerList;
-        sscache = new SnapshotCache(core.getSnapShotCacheSize(), core.useSoftRefInSnapShotCache());
+        sscache = new GenericChunkCache(core.getSnapShotCacheSize(), core.useSoftRefInSnapShotCache());
         /* Get map manager from core */
         mapManager = core.getMapManager();
 

fabric-1.16.4/src/main/java/org/dynmap/fabric_1_16_4/NBT.java

@@ -0,0 +1,120 @@
+package org.dynmap.fabric_1_16_4;
+
+import org.dynmap.common.chunk.GenericBitStorage;
+import org.dynmap.common.chunk.GenericNBTCompound;
+import org.dynmap.common.chunk.GenericNBTList;
+
+import java.util.Set;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.util.collection.PackedIntegerArray;
+
+public class NBT {
+
+	public static class NBTCompound implements GenericNBTCompound {
+		private final CompoundTag obj;
+		public NBTCompound(CompoundTag t) {
+			this.obj = t;
+		}
+		@Override
+		public Set<String> getAllKeys() {
+			return obj.getKeys();
+		}
+		@Override
+		public boolean contains(String s) {
+			return obj.contains(s);
+		}
+		@Override
+		public boolean contains(String s, int i) {
+			return obj.contains(s, i);
+		}
+		@Override
+		public byte getByte(String s) {
+			return obj.getByte(s);
+		}
+		@Override
+		public short getShort(String s) {
+			return obj.getShort(s);
+		}
+		@Override
+		public int getInt(String s) {
+			return obj.getInt(s);
+		}
+		@Override
+		public long getLong(String s) {
+			return obj.getLong(s);
+		}
+		@Override
+		public float getFloat(String s) {
+			return obj.getFloat(s);
+		}
+		@Override
+		public double getDouble(String s) {
+			return obj.getDouble(s);
+		}
+		@Override
+		public String getString(String s) {
+			return obj.getString(s);
+		}
+		@Override
+		public byte[] getByteArray(String s) {
+			return obj.getByteArray(s);
+		}
+		@Override
+		public int[] getIntArray(String s) {
+			return obj.getIntArray(s);
+		}
+		@Override
+		public long[] getLongArray(String s) {
+			return obj.getLongArray(s);
+		}
+		@Override
+		public GenericNBTCompound getCompound(String s) {
+			return new NBTCompound(obj.getCompound(s));
+		}
+		@Override
+		public GenericNBTList getList(String s, int i) {
+			return new NBTList(obj.getList(s, i));
+		}
+		@Override
+		public boolean getBoolean(String s) {
+			return obj.getBoolean(s);
+		}
+		@Override
+		public String getAsString(String s) {
+			return obj.get(s).asString();
+		}
+		@Override
+		public GenericBitStorage makeBitStorage(int bits, int count, long[] data) {
+			return new OurBitStorage(bits, count, data);
+		}		
+	}
+	public static class NBTList implements GenericNBTList {
+		private final ListTag obj;
+		public NBTList(ListTag t) {
+			obj = t;
+		}
+		@Override
+		public int size() {
+			return obj.size();
+		}
+		@Override
+		public String getString(int idx) {
+			return obj.getString(idx);
+		}
+		@Override
+		public GenericNBTCompound getCompound(int idx) {
+			return new NBTCompound(obj.getCompound(idx));
+		}
+	}
+	public static class OurBitStorage implements GenericBitStorage {
+		private final PackedIntegerArray bs;
+		public OurBitStorage(int bits, int count, long[] data) {
+			bs = new PackedIntegerArray(bits, count, data);
+		}
+		@Override
+		public int get(int idx) {
+			return bs.get(idx);
+		}
+	}
+}

fabric-1.16.4/src/main/java/org/dynmap/fabric_1_16_4/SnapshotCache.java

@@ -1,201 +0,0 @@
-package org.dynmap.fabric_1_16_4;
-
-import org.dynmap.utils.DynIntHashMap;
-
-import java.lang.ref.Reference;
-import java.lang.ref.ReferenceQueue;
-import java.lang.ref.SoftReference;
-import java.lang.ref.WeakReference;
-import java.util.IdentityHashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-public class SnapshotCache {
-    public static class SnapshotRec {
-        public ChunkSnapshot ss;
-        public DynIntHashMap tileData;
-    }
-
-    private CacheHashMap snapcache;
-    private ReferenceQueue<SnapshotRec> refqueue;
-    private long cache_attempts;
-    private long cache_success;
-    private boolean softref;
-
-    private static class CacheRec {
-        Reference<SnapshotRec> ref;
-        boolean hasbiome;
-        boolean hasrawbiome;
-        boolean hasblockdata;
-        boolean hashighesty;
-    }
-
-    @SuppressWarnings("serial")
-    public class CacheHashMap extends LinkedHashMap<String, CacheRec> {
-        private int limit;
-        private IdentityHashMap<Reference<SnapshotRec>, String> reverselookup;
-
-        public CacheHashMap(int lim) {
-            super(16, (float) 0.75, true);
-            limit = lim;
-            reverselookup = new IdentityHashMap<Reference<SnapshotRec>, String>();
-        }
-
-        protected boolean removeEldestEntry(Map.Entry<String, CacheRec> last) {
-            boolean remove = (size() >= limit);
-            if (remove && (last != null) && (last.getValue() != null)) {
-                reverselookup.remove(last.getValue().ref);
-            }
-            return remove;
-        }
-    }
-
-    /**
-     * Create snapshot cache
-     */
-    public SnapshotCache(int max_size, boolean softref) {
-        snapcache = new CacheHashMap(max_size);
-        refqueue = new ReferenceQueue<SnapshotRec>();
-        this.softref = softref;
-    }
-
-    private String getKey(String w, int cx, int cz) {
-        return w + ":" + cx + ":" + cz;
-    }
-
-    /**
-     * Invalidate cached snapshot, if in cache
-     */
-    public void invalidateSnapshot(String w, int x, int y, int z) {
-        String key = getKey(w, x >> 4, z >> 4);
-        synchronized (snapcache) {
-            CacheRec rec = snapcache.remove(key);
-            if (rec != null) {
-                snapcache.reverselookup.remove(rec.ref);
-                rec.ref.clear();
-            }
-        }
-        //processRefQueue();
-    }
-
-    /**
-     * Invalidate cached snapshot, if in cache
-     */
-    public void invalidateSnapshot(String w, int x0, int y0, int z0, int x1, int y1, int z1) {
-        for (int xx = (x0 >> 4); xx <= (x1 >> 4); xx++) {
-            for (int zz = (z0 >> 4); zz <= (z1 >> 4); zz++) {
-                String key = getKey(w, xx, zz);
-                synchronized (snapcache) {
-                    CacheRec rec = snapcache.remove(key);
-                    if (rec != null) {
-                        snapcache.reverselookup.remove(rec.ref);
-                        rec.ref.clear();
-                    }
-                }
-            }
-        }
-        //processRefQueue();
-    }
-
-    /**
-     * Look for chunk snapshot in cache
-     */
-    public SnapshotRec getSnapshot(String w, int chunkx, int chunkz,
-                                   boolean blockdata, boolean biome, boolean biomeraw, boolean highesty) {
-        String key = getKey(w, chunkx, chunkz);
-        processRefQueue();
-        SnapshotRec ss = null;
-        CacheRec rec;
-        synchronized (snapcache) {
-            rec = snapcache.get(key);
-            if (rec != null) {
-                ss = rec.ref.get();
-                if (ss == null) {
-                    snapcache.reverselookup.remove(rec.ref);
-                    snapcache.remove(key);
-                }
-            }
-        }
-        if (ss != null) {
-            if ((blockdata && (!rec.hasblockdata)) ||
-                    (biome && (!rec.hasbiome)) ||
-                    (biomeraw && (!rec.hasrawbiome)) ||
-                    (highesty && (!rec.hashighesty))) {
-                ss = null;
-            }
-        }
-        cache_attempts++;
-        if (ss != null) cache_success++;
-
-        return ss;
-    }
-
-    /**
-     * Add chunk snapshot to cache
-     */
-    public void putSnapshot(String w, int chunkx, int chunkz, SnapshotRec ss,
-                            boolean blockdata, boolean biome, boolean biomeraw, boolean highesty) {
-        String key = getKey(w, chunkx, chunkz);
-        processRefQueue();
-        CacheRec rec = new CacheRec();
-        rec.hasblockdata = blockdata;
-        rec.hasbiome = biome;
-        rec.hasrawbiome = biomeraw;
-        rec.hashighesty = highesty;
-        if (softref)
-            rec.ref = new SoftReference<SnapshotRec>(ss, refqueue);
-        else
-            rec.ref = new WeakReference<SnapshotRec>(ss, refqueue);
-        synchronized (snapcache) {
-            CacheRec prevrec = snapcache.put(key, rec);
-            if (prevrec != null) {
-                snapcache.reverselookup.remove(prevrec.ref);
-            }
-            snapcache.reverselookup.put(rec.ref, key);
-        }
-    }
-
-    /**
-     * Process reference queue
-     */
-    private void processRefQueue() {
-        Reference<? extends SnapshotRec> ref;
-        while ((ref = refqueue.poll()) != null) {
-            synchronized (snapcache) {
-                String k = snapcache.reverselookup.remove(ref);
-                if (k != null) {
-                    snapcache.remove(k);
-                }
-            }
-        }
-    }
-
-    /**
-     * Get hit rate (percent)
-     */
-    public double getHitRate() {
-        if (cache_attempts > 0) {
-            return (100.0 * cache_success) / (double) cache_attempts;
-        }
-        return 0.0;
-    }
-
-    /**
-     * Reset cache stats
-     */
-    public void resetStats() {
-        cache_attempts = cache_success = 0;
-    }
-
-    /**
-     * Cleanup
-     */
-    public void cleanup() {
-        if (snapcache != null) {
-            snapcache.clear();
-            snapcache.reverselookup.clear();
-            snapcache.reverselookup = null;
-            snapcache = null;
-        }
-    }
-}

forge-1.16.5/src/main/java/org/dynmap/forge_1_16_5/ChunkSnapshot.java

@@ -1,286 +0,0 @@
-package org.dynmap.forge_1_16_5;
-
-import java.util.Arrays;
-
-import org.dynmap.Log;
-import org.dynmap.renderer.DynmapBlockState;
-import org.dynmap.utils.DataBitsPacked;
-
-import net.minecraft.nbt.CompoundNBT;
-import net.minecraft.nbt.ListNBT;
-import net.minecraft.util.BitArray;
-
-/**
- * Represents a static, thread-safe snapshot of chunk of blocks
- * Purpose is to allow clean, efficient copy of a chunk data to be made, and then handed off for processing in another thread (e.g. map rendering)
- */
-public class ChunkSnapshot
-{
-    private static interface Section {
-        public DynmapBlockState getBlockType(int x, int y, int z);
-        public int getBlockSkyLight(int x, int y, int z);
-        public int getBlockEmittedLight(int x, int y, int z);
-        public boolean isEmpty();
-    }
-
-    private final int x, z;
-    private final Section[] section;
-    private final int[] hmap; // Height map
-    private final int[] biome;
-    private final long captureFulltime;
-    private final int sectionCnt;
-    private final long inhabitedTicks;
-
-    private static final int BLOCKS_PER_SECTION = 16 * 16 * 16;
-    private static final int COLUMNS_PER_CHUNK = 16 * 16;
-    private static final byte[] emptyData = new byte[BLOCKS_PER_SECTION / 2];
-    private static final byte[] fullData = new byte[BLOCKS_PER_SECTION / 2];
-
-    static
-    {
-        Arrays.fill(fullData, (byte)0xFF);
-    }
-
-    private static class EmptySection implements Section {
-        @Override
-        public DynmapBlockState getBlockType(int x, int y, int z) {
-            return DynmapBlockState.AIR;
-        }
-        @Override
-        public int getBlockSkyLight(int x, int y, int z) {
-            return 15;
-        }
-        @Override
-        public int getBlockEmittedLight(int x, int y, int z) {
-            return 0;
-        }
-        @Override
-        public boolean isEmpty() {
-            return true;
-        }
-    }
-    
-    private static final EmptySection empty_section = new EmptySection();
-    
-    private static class StdSection implements Section {
-        DynmapBlockState[] states;
-        byte[] skylight;
-        byte[] emitlight;
-
-        public StdSection() {
-            states = new DynmapBlockState[BLOCKS_PER_SECTION];
-            Arrays.fill(states,  DynmapBlockState.AIR);
-            skylight = emptyData;
-            emitlight = emptyData;
-        }
-        @Override
-        public DynmapBlockState getBlockType(int x, int y, int z) {
-            return states[((y & 0xF) << 8) | (z << 4) | x];
-        }
-        @Override
-        public int getBlockSkyLight(int x, int y, int z) {
-            int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
-            return (skylight[off] >> (4 * (x & 1))) & 0xF;
-        }
-        @Override
-        public int getBlockEmittedLight(int x, int y, int z)
-        {
-            int off = ((y & 0xF) << 7) | (z << 3) | (x >> 1);
-            return (emitlight[off] >> (4 * (x & 1))) & 0xF;
-        }
-        @Override
-        public boolean isEmpty() {
-            return false;
-        }
-    }
-    /**
-     * Construct empty chunk snapshot
-     *
-     * @param x
-     * @param z
-     */
-    public ChunkSnapshot(int worldheight, int x, int z, long captime, long inhabitedTime)
-    {
-        this.x = x;
-        this.z = z;
-        this.captureFulltime = captime;
-        this.biome = new int[COLUMNS_PER_CHUNK];
-        this.sectionCnt = worldheight / 16;
-        /* Allocate arrays indexed by section */
-        this.section = new Section[this.sectionCnt+1];
-
-        /* Fill with empty data */
-        for (int i = 0; i <= this.sectionCnt; i++) {
-            this.section[i] = empty_section;
-        }
-
-        /* Create empty height map */
-        this.hmap = new int[16 * 16];
-        
-        this.inhabitedTicks = inhabitedTime;
-    }
-
-    public ChunkSnapshot(CompoundNBT nbt, int worldheight) {
-        this.x = nbt.getInt("xPos");
-        this.z = nbt.getInt("zPos");
-        this.captureFulltime = 0;
-        this.hmap = nbt.getIntArray("HeightMap");
-        this.sectionCnt = worldheight / 16;
-        if (nbt.contains("InhabitedTime")) {
-            this.inhabitedTicks = nbt.getLong("InhabitedTime");
-        }
-        else {
-            this.inhabitedTicks = 0;
-        }
-        /* Allocate arrays indexed by section */
-        this.section = new Section[this.sectionCnt+1];
-        /* Fill with empty data */
-        for (int i = 0; i <= this.sectionCnt; i++) {
-            this.section[i] = empty_section;
-        }
-        /* Get sections */
-        ListNBT sect = nbt.getList("Sections", 10);
-        for (int i = 0; i < sect.size(); i++) {
-            CompoundNBT sec = sect.getCompound(i);
-            int secnum = sec.getByte("Y");
-            if (secnum >= this.sectionCnt) {
-                //Log.info("Section " + (int) secnum + " above world height " + worldheight);
-                continue;
-            }
-            if (secnum < 0)
-                continue;
-            //System.out.println("section(" + secnum + ")=" + sec.asString());
-            // Create normal section to initialize
-            StdSection cursect = new StdSection();
-            this.section[secnum] = cursect;
-            DynmapBlockState[] states = cursect.states;
-            DynmapBlockState[] palette = null;
-            // If we've got palette and block states list, process non-empty section
-            if (sec.contains("Palette", 9) && sec.contains("BlockStates", 12)) {
-                ListNBT plist = sec.getList("Palette", 10);
-                long[] statelist = sec.getLongArray("BlockStates");
-                palette = new DynmapBlockState[plist.size()];
-                for (int pi = 0; pi < plist.size(); pi++) {
-                    CompoundNBT tc = plist.getCompound(pi);
-                    String pname = tc.getString("Name");
-                    if (tc.contains("Properties")) {
-                        StringBuilder statestr = new StringBuilder();
-                        CompoundNBT prop = tc.getCompound("Properties");
-                        for (String pid : prop.keySet()) {
-                            if (statestr.length() > 0) statestr.append(',');
-                            statestr.append(pid).append('=').append(prop.get(pid).getString());
-                        }
-                        palette[pi] = DynmapBlockState.getStateByNameAndState(pname, statestr.toString());
-                    }
-                    if (palette[pi] == null) {
-                        palette[pi] = DynmapBlockState.getBaseStateByName(pname);
-                    }
-                    if (palette[pi] == null) {
-                        palette[pi] = DynmapBlockState.AIR;
-                    }
-                }
-            	int recsperblock = (4096 + statelist.length - 1) / statelist.length;
-            	int bitsperblock = 64 / recsperblock;
-            	BitArray db = null;
-            	DataBitsPacked dbp = null;
-            	try {
-            		db = new BitArray(bitsperblock, 4096, statelist);
-            	} catch (Exception x) {	// Handle legacy encoded
-	            	bitsperblock = (statelist.length * 64) / 4096;
-            		dbp = new DataBitsPacked(bitsperblock, 4096, statelist);
-            	}
-                if (bitsperblock > 8) {	// Not palette
-                    for (int j = 0; j < 4096; j++) {
-                    	int v = (dbp != null) ? dbp.getAt(j) : db.getAt(j);
-                        states[j] = DynmapBlockState.getStateByGlobalIndex(v);
-                    }
-                }
-                else {
-                    for (int j = 0; j < 4096; j++) {
-                    	int v = (dbp != null) ? dbp.getAt(j) : db.getAt(j);
-                        states[j] = (v < palette.length) ? palette[v] : DynmapBlockState.AIR;
-                    }
-                }
-            }
-            if (sec.contains("BlockLight")) {
-                cursect.emitlight = sec.getByteArray("BlockLight");
-            }
-            if (sec.contains("SkyLight")) {
-                cursect.skylight = sec.getByteArray("SkyLight");
-            }
-        }
-        /* Get biome data */
-        this.biome = new int[COLUMNS_PER_CHUNK];
-        if (nbt.contains("Biomes")) {
-            int[] bb = nbt.getIntArray("Biomes");
-        	if (bb != null) {
-        		// If v1.15+ format
-        		if (bb.length > COLUMNS_PER_CHUNK) {
-        	        // For now, just pad the grid with the first 16
-                    for (int i = 0; i < COLUMNS_PER_CHUNK; i++) {
-                        int off = ((i >> 4) & 0xC) + ((i >> 2) & 0x3);
-                        int bv = bb[off + 64];   // Offset to y=64
-                        if (bv < 0) bv = 0;
-                        this.biome[i] = bv;
-                    }
-        	    }
-        	    else { // Else, older chunks
-        	        for (int i = 0; i < bb.length; i++) {
-        	            int bv = bb[i];
-        	            if (bv < 0) bv = 0;
-        	            this.biome[i] = bv;
-        	        }
-        	    }
-            }
-        }
-    }
-    
-    public int getX()
-    {
-        return x;
-    }
-
-    public int getZ()
-    {
-        return z;
-    }
-    
-    public DynmapBlockState getBlockType(int x, int y, int z)
-    {
-        return section[y >> 4].getBlockType(x, y, z);
-    }
-
-    public int getBlockSkyLight(int x, int y, int z)
-    {
-        return section[y >> 4].getBlockSkyLight(x, y, z);
-    }
-
-    public int getBlockEmittedLight(int x, int y, int z)
-    {
-        return section[y >> 4].getBlockEmittedLight(x, y, z);
-    }
-
-    public int getHighestBlockYAt(int x, int z)
-    {
-        return hmap[z << 4 | x];
-    }
-
-    public int getBiome(int x, int z)
-    {
-        return biome[z << 4 | x];
-    }
-
-    public final long getCaptureFullTime()
-    {
-        return captureFulltime;
-    }
-
-    public boolean isSectionEmpty(int sy)
-    {
-        return section[sy].isEmpty();
-    }
-    
-    public long getInhabitedTicks() {
-        return inhabitedTicks;
-    }
-}

forge-1.16.5/src/main/java/org/dynmap/forge_1_16_5/DynmapPlugin.java

@@ -107,6 +107,7 @@ import org.dynmap.common.BiomeMap;
 import org.dynmap.common.DynmapCommandSender;
 import org.dynmap.common.DynmapPlayer;
 import org.dynmap.common.DynmapServerInterface;
+import org.dynmap.common.chunk.GenericChunkCache;
 import org.dynmap.common.DynmapListenerManager.EventType;
 import org.dynmap.debug.Debug;
 import org.dynmap.forge_1_16_5.DmapCommand;
@@ -146,7 +147,7 @@ public class DynmapPlugin
     private DynmapCore core;
     private PermissionProvider permissions;
     private boolean core_enabled;
-    public SnapshotCache sscache;
+    public GenericChunkCache sscache;
     public PlayerList playerList;
     private MapManager mapManager;
     private static net.minecraft.server.MinecraftServer server;
@@ -1546,7 +1547,7 @@ public class DynmapPlugin
         }
 
         playerList = core.playerList;
-        sscache = new SnapshotCache(core.getSnapShotCacheSize(), core.useSoftRefInSnapShotCache());
+        sscache = new GenericChunkCache(core.getSnapShotCacheSize(), core.useSoftRefInSnapShotCache());
         /* Get map manager from core */
         mapManager = core.getMapManager();
 

forge-1.16.5/src/main/java/org/dynmap/forge_1_16_5/ForgeWorld.java

@@ -8,7 +8,6 @@ import net.minecraft.util.RegistryKey;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.world.gen.Heightmap.Type;
 import net.minecraft.world.IServerWorld;
-import net.minecraft.world.IWorld;
 import net.minecraft.world.LightType;
 import net.minecraft.world.World;
 import net.minecraft.world.border.WorldBorder;
@@ -206,7 +205,7 @@ public class ForgeWorld extends DynmapWorld
     public MapChunkCache getChunkCache(List<DynmapChunk> chunks)
     {
     	if(world != null) {
-    		ForgeMapChunkCache c = new ForgeMapChunkCache();
+    		ForgeMapChunkCache c = new ForgeMapChunkCache(DynmapPlugin.plugin.sscache);
     		c.setChunks(this, chunks);
     		return c;
     	}

forge-1.16.5/src/main/java/org/dynmap/forge_1_16_5/NBT.java

@@ -0,0 +1,120 @@
+package org.dynmap.forge_1_16_5;
+
+import org.dynmap.common.chunk.GenericBitStorage;
+import org.dynmap.common.chunk.GenericNBTCompound;
+import org.dynmap.common.chunk.GenericNBTList;
+
+import java.util.Set;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.nbt.ListNBT;
+import net.minecraft.util.BitArray;
+
+public class NBT {
+
+	public static class NBTCompound implements GenericNBTCompound {
+		private final CompoundNBT obj;
+		public NBTCompound(CompoundNBT t) {
+			this.obj = t;
+		}
+		@Override
+		public Set<String> getAllKeys() {
+			return obj.keySet();
+		}
+		@Override
+		public boolean contains(String s) {
+			return obj.contains(s);
+		}
+		@Override
+		public boolean contains(String s, int i) {
+			return obj.contains(s, i);
+		}
+		@Override
+		public byte getByte(String s) {
+			return obj.getByte(s);
+		}
+		@Override
+		public short getShort(String s) {
+			return obj.getShort(s);
+		}
+		@Override
+		public int getInt(String s) {
+			return obj.getInt(s);
+		}
+		@Override
+		public long getLong(String s) {
+			return obj.getLong(s);
+		}
+		@Override
+		public float getFloat(String s) {
+			return obj.getFloat(s);
+		}
+		@Override
+		public double getDouble(String s) {
+			return obj.getDouble(s);
+		}
+		@Override
+		public String getString(String s) {
+			return obj.getString(s);
+		}
+		@Override
+		public byte[] getByteArray(String s) {
+			return obj.getByteArray(s);
+		}
+		@Override
+		public int[] getIntArray(String s) {
+			return obj.getIntArray(s);
+		}
+		@Override
+		public long[] getLongArray(String s) {
+			return obj.getLongArray(s);
+		}
+		@Override
+		public GenericNBTCompound getCompound(String s) {
+			return new NBTCompound(obj.getCompound(s));
+		}
+		@Override
+		public GenericNBTList getList(String s, int i) {
+			return new NBTList(obj.getList(s, i));
+		}
+		@Override
+		public boolean getBoolean(String s) {
+			return obj.getBoolean(s);
+		}
+		@Override
+		public String getAsString(String s) {
+			return obj.get(s).getString();
+		}
+		@Override
+		public GenericBitStorage makeBitStorage(int bits, int count, long[] data) {
+			return new OurBitStorage(bits, count, data);
+		}		
+	}
+	public static class NBTList implements GenericNBTList {
+		private final ListNBT obj;
+		public NBTList(ListNBT t) {
+			obj = t;
+		}
+		@Override
+		public int size() {
+			return obj.size();
+		}
+		@Override
+		public String getString(int idx) {
+			return obj.getString(idx);
+		}
+		@Override
+		public GenericNBTCompound getCompound(int idx) {
+			return new NBTCompound(obj.getCompound(idx));
+		}
+	}
+	public static class OurBitStorage implements GenericBitStorage {
+		private final BitArray bs;
+		public OurBitStorage(int bits, int count, long[] data) {
+			bs = new BitArray(bits, count, data);
+		}
+		@Override
+		public int get(int idx) {
+			return bs.getAt(idx);
+		}
+	}
+}

forge-1.16.5/src/main/java/org/dynmap/forge_1_16_5/SnapshotCache.java

@@ -1,191 +0,0 @@
-package org.dynmap.forge_1_16_5;
-
-import java.lang.ref.Reference;
-import java.lang.ref.ReferenceQueue;
-import java.lang.ref.WeakReference;
-import java.lang.ref.SoftReference;
-import java.util.IdentityHashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-
-import org.dynmap.utils.DynIntHashMap;
-
-public class SnapshotCache {
-    public static class SnapshotRec {
-        public ChunkSnapshot ss;
-        public DynIntHashMap tileData;
-    };
-
-    private CacheHashMap snapcache;
-    private ReferenceQueue<SnapshotRec> refqueue;
-    private long cache_attempts;
-    private long cache_success;
-    private boolean softref;
-
-    private static class CacheRec {
-        Reference<SnapshotRec> ref;
-        boolean hasbiome;
-        boolean hasrawbiome;
-        boolean hasblockdata;
-        boolean hashighesty;
-    }
-    
-    @SuppressWarnings("serial")
-    public class CacheHashMap extends LinkedHashMap<String, CacheRec> {
-        private int limit;
-        private IdentityHashMap<Reference<SnapshotRec>, String> reverselookup;
-
-        public CacheHashMap(int lim) {
-            super(16, (float)0.75, true);
-            limit = lim;
-            reverselookup = new IdentityHashMap<Reference<SnapshotRec>, String>();
-        }
-        protected boolean removeEldestEntry(Map.Entry<String, CacheRec> last) {
-            boolean remove = (size() >= limit);
-            if(remove && (last != null) && (last.getValue() != null)) {
-                reverselookup.remove(last.getValue().ref);
-            }
-            return remove;
-        }
-    }
-
-    /**
-     * Create snapshot cache
-     */
-    public SnapshotCache(int max_size, boolean softref) {
-        snapcache = new CacheHashMap(max_size);
-        refqueue = new ReferenceQueue<SnapshotRec>();
-        this.softref = softref;
-    }
-    private String getKey(String w, int cx, int cz) {
-        return w + ":" + cx + ":" + cz;
-    }
-    /**
-     * Invalidate cached snapshot, if in cache
-     */
-    public void invalidateSnapshot(String w, int x, int y, int z) {
-        String key = getKey(w, x>>4, z>>4);
-        synchronized(snapcache) {
-            CacheRec rec = snapcache.remove(key);
-            if(rec != null) {
-                snapcache.reverselookup.remove(rec.ref);
-                rec.ref.clear();
-            }
-        }
-        //processRefQueue();
-    }
-    /**
-     * Invalidate cached snapshot, if in cache
-     */
-    public void invalidateSnapshot(String w, int x0, int y0, int z0, int x1, int y1, int z1) {
-        for(int xx = (x0>>4); xx <= (x1>>4); xx++) {
-            for(int zz = (z0>>4); zz <= (z1>>4); zz++) {
-                String key = getKey(w, xx, zz);
-                synchronized(snapcache) {
-                    CacheRec rec = snapcache.remove(key);
-                    if(rec != null) {
-                        snapcache.reverselookup.remove(rec.ref);
-                        rec.ref.clear();
-                    }
-                }
-            }
-        }
-        //processRefQueue();
-    }
-    /**
-     * Look for chunk snapshot in cache
-     */
-    public SnapshotRec getSnapshot(String w, int chunkx, int chunkz, 
-            boolean blockdata, boolean biome, boolean biomeraw, boolean highesty) {
-        String key = getKey(w, chunkx, chunkz);
-        processRefQueue();
-        SnapshotRec ss = null;
-        CacheRec rec;
-        synchronized(snapcache) {
-            rec = snapcache.get(key);
-            if(rec != null) {
-                ss = rec.ref.get();
-                if(ss == null) {
-                    snapcache.reverselookup.remove(rec.ref);
-                    snapcache.remove(key);
-                }
-            }
-        }
-        if(ss != null) {
-            if((blockdata && (!rec.hasblockdata)) ||
-                    (biome && (!rec.hasbiome)) ||
-                    (biomeraw && (!rec.hasrawbiome)) ||
-                    (highesty && (!rec.hashighesty))) {
-                ss = null;
-            }
-        }
-        cache_attempts++;
-        if(ss != null) cache_success++;
-
-        return ss;
-    }
-    /**
-     * Add chunk snapshot to cache
-     */
-    public void putSnapshot(String w, int chunkx, int chunkz, SnapshotRec ss, 
-            boolean blockdata, boolean biome, boolean biomeraw, boolean highesty) {
-        String key = getKey(w, chunkx, chunkz);
-        processRefQueue();
-        CacheRec rec = new CacheRec();
-        rec.hasblockdata = blockdata;
-        rec.hasbiome = biome;
-        rec.hasrawbiome = biomeraw;
-        rec.hashighesty = highesty;
-        if (softref)
-            rec.ref = new SoftReference<SnapshotRec>(ss, refqueue);
-        else
-            rec.ref = new WeakReference<SnapshotRec>(ss, refqueue);
-        synchronized(snapcache) {
-            CacheRec prevrec = snapcache.put(key, rec);
-            if(prevrec != null) {
-                snapcache.reverselookup.remove(prevrec.ref);
-            }
-            snapcache.reverselookup.put(rec.ref, key);
-        }
-    }
-    /**
-     * Process reference queue
-     */
-    private void processRefQueue() {
-        Reference<? extends SnapshotRec> ref;
-        while((ref = refqueue.poll()) != null) {
-            synchronized(snapcache) {
-                String k = snapcache.reverselookup.remove(ref);
-                if(k != null) {
-                    snapcache.remove(k);
-                }
-            }
-        }
-    }
-    /**
-     * Get hit rate (percent)
-     */
-    public double getHitRate() {
-        if(cache_attempts > 0) {
-            return (100.0*cache_success)/(double)cache_attempts;
-        }
-        return 0.0;
-    }
-    /**
-     * Reset cache stats
-     */
-    public void resetStats() {
-        cache_attempts = cache_success = 0;
-    }
-    /**
-     * Cleanup
-     */
-    public void cleanup() {
-        if(snapcache != null) {
-            snapcache.clear();
-            snapcache.reverselookup.clear();
-            snapcache.reverselookup = null;
-            snapcache = null;
-        }
-    }
-}