Initial building/running Spigot 1.17 code... still very incomplete

bukkit-helper-117/.gitignore

@@ -0,0 +1 @@
+/build/

bukkit-helper-117/build.gradle

@@ -0,0 +1,10 @@
+
+description = 'bukkit-helper-1.17'
+
+dependencies {
+  compile project(':bukkit-helper')
+  compile project(':dynmap-api')
+  compile project(path: ':DynmapCore', configuration: 'shadow')
+  compile group: 'org.spigotmc', name: 'spigot-api', version:'1.17-R0.1-SNAPSHOT'
+  compile group: 'org.spigotmc', name: 'spigot', version:'1.17-R0.1-SNAPSHOT'
+}

bukkit-helper-117/src/main/java/org/dynmap/bukkit/helper/v117/BukkitVersionHelperSpigot117.java

@@ -0,0 +1,354 @@
+package org.dynmap.bukkit.helper.v117;
+
+import org.bukkit.*;
+import org.bukkit.craftbukkit.v1_17_R1.CraftChunk;
+import org.bukkit.entity.Player;
+import org.dynmap.DynmapChunk;
+import org.dynmap.Log;
+import org.dynmap.bukkit.helper.BukkitMaterial;
+import org.dynmap.bukkit.helper.BukkitVersionHelper;
+import org.dynmap.bukkit.helper.BukkitVersionHelperGeneric;
+import org.dynmap.bukkit.helper.BukkitWorld;
+import org.dynmap.bukkit.helper.v117.MapChunkCache117;
+import org.dynmap.renderer.DynmapBlockState;
+import org.dynmap.utils.MapChunkCache;
+import org.dynmap.utils.Polygon;
+
+import net.minecraft.core.IRegistry;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagByte;
+import net.minecraft.nbt.NBTTagByteArray;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagDouble;
+import net.minecraft.nbt.NBTTagFloat;
+import net.minecraft.nbt.NBTTagInt;
+import net.minecraft.nbt.NBTTagIntArray;
+import net.minecraft.nbt.NBTTagLong;
+import net.minecraft.nbt.NBTTagShort;
+import net.minecraft.nbt.NBTTagString;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.level.biome.BiomeBase;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.BlockFluids;
+import net.minecraft.world.level.block.BlockRotatable;
+import net.minecraft.world.level.block.entity.TileEntity;
+import net.minecraft.world.level.block.state.IBlockData;
+import net.minecraft.world.level.material.Material;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+
+
+/**
+ * Helper for isolation of bukkit version specific issues
+ */
+public class BukkitVersionHelperSpigot117 extends BukkitVersionHelper {    
+    public BukkitVersionHelperSpigot117() {
+    }
+    
+    /**
+     * Get block short name list
+     */
+    @Override
+    public String[] getBlockNames() {
+    	int cnt = Block.p.a();
+    	String[] names = new String[cnt];
+    	for (int i = 0; i < cnt; i++) {
+    		IBlockData bd = Block.getByCombinedId(i);
+    		names[i] = IRegistry.W.getKey(bd.getBlock()).toString();
+    		Log.info(i + ": blk=" + names[i] + ", bd=" + bd.toString());
+    	}
+        return names;
+    }
+
+    private IRegistry<BiomeBase> reg = null;
+
+    private IRegistry<BiomeBase> getBiomeReg() {
+    	if (reg == null) {
+    		reg = MinecraftServer.getServer().getCustomRegistry().b(IRegistry.aO);
+    	}
+    	return reg;
+    }
+    
+    private Object[] biomelist;
+    /**
+     * Get list of defined biomebase objects
+     */
+    @Override
+    public Object[] getBiomeBaseList() {
+    	if (biomelist == null) {
+    		biomelist = new Object[1024];
+            for (int i = 0; i < 1024; i++) {
+            	biomelist[i] = getBiomeReg().fromId(i);
+            }
+        }
+        return biomelist;
+    }
+
+    /** Get ID from biomebase */
+    @Override
+    public int getBiomeBaseID(Object bb) {
+    	return getBiomeReg().getId((BiomeBase)bb);
+    }
+    
+    public static IdentityHashMap<IBlockData, DynmapBlockState> dataToState;
+    
+    /**
+     * Initialize block states (org.dynmap.blockstate.DynmapBlockState)
+     */
+    @Override
+    public void initializeBlockStates() {
+    	dataToState = new IdentityHashMap<IBlockData, DynmapBlockState>();
+    	HashMap<String, DynmapBlockState> lastBlockState = new HashMap<String, DynmapBlockState>();
+    	
+    	int cnt = Block.p.a();
+    	// Loop through block data states
+    	for (int i = 0; i < cnt; i++) {
+    		IBlockData bd = Block.getByCombinedId(i);
+    		String bname = IRegistry.W.getKey(bd.getBlock()).toString();
+    		DynmapBlockState lastbs = lastBlockState.get(bname);	// See if we have seen this one
+    		int idx = 0;
+    		if (lastbs != null) {	// Yes
+    			idx = lastbs.getStateCount();	// Get number of states so far, since this is next
+    		}
+    		// Build state name
+    		String sb = "";
+    		String fname = bd.toString();
+    		int off1 = fname.indexOf('[');
+    		if (off1 >= 0) {
+    			int off2 = fname.indexOf(']');
+    			sb = fname.substring(off1+1, off2);
+    		}
+    		Material mat = bd.getMaterial();
+            DynmapBlockState bs = new DynmapBlockState(lastbs, idx, bname, sb, mat.toString());
+            if ((!bd.getFluid().isEmpty()) && ((bd.getBlock() instanceof BlockFluids) == false)) {	// Test if fluid type for block is not empty
+            	bs.setWaterlogged();
+            }
+            if (mat == Material.a) {	// AIR
+            	bs.setAir();
+            }
+    		if (mat == Material.E) {	// LEAVES
+    			bs.setLeaves();
+    		}
+    		if ((bd.getBlock() instanceof BlockRotatable) && (bd.getMaterial() == Material.z)) {	// WOOD
+    			bs.setLog();
+    		}
+    		if (mat.isSolid()) {
+    			bs.setSolid();
+    		}
+    		dataToState.put(bd,  bs);
+    		lastBlockState.put(bname, (lastbs == null) ? bs : lastbs);
+    		Log.verboseinfo(i + ": blk=" + bname + ", idx=" + idx + ", state=" + sb + ", waterlogged=" + bs.isWaterlogged());
+    	}
+    }
+    /**
+     * Create chunk cache for given chunks of given world
+     * @param dw - world
+     * @param chunks - chunk list
+     * @return cache
+     */
+    @Override
+    public MapChunkCache getChunkCache(BukkitWorld dw, List<DynmapChunk> chunks) {
+        MapChunkCache117 c = new MapChunkCache117();
+        c.setChunks(dw, chunks);
+        return c;
+    }
+    
+	/**
+	 * Get biome base water multiplier
+	 */
+    @Override
+	public int getBiomeBaseWaterMult(Object bb) {
+    	BiomeBase biome = (BiomeBase)bb;
+    	return biome.l().b();	// waterColor
+	}
+
+    /** Get temperature from biomebase */
+    @Override
+    public float getBiomeBaseTemperature(Object bb) {
+    	return ((BiomeBase)bb).k();
+    }
+
+    /** Get humidity from biomebase */
+    @Override
+    public float getBiomeBaseHumidity(Object bb) {
+    	return ((BiomeBase)bb).getHumidity();    	
+    }
+    
+    @Override
+    public Polygon getWorldBorder(World world) {
+        Polygon p = null;
+        WorldBorder wb = world.getWorldBorder();
+        if (wb != null) {
+        	Location c = wb.getCenter();
+        	double size = wb.getSize();
+        	if ((size > 1) && (size < 1E7)) {
+        	    size = size / 2;
+        		p = new Polygon();
+        		p.addVertex(c.getX()-size, c.getZ()-size);
+        		p.addVertex(c.getX()+size, c.getZ()-size);
+        		p.addVertex(c.getX()+size, c.getZ()+size);
+        		p.addVertex(c.getX()-size, c.getZ()+size);
+        	}
+        }
+        return p;
+    }
+	// Send title/subtitle to user
+    public void sendTitleText(Player p, String title, String subtitle, int fadeInTicks, int stayTicks, int fadeOutTIcks) {
+    	if (p != null) {
+    		p.sendTitle(title, subtitle, fadeInTicks, stayTicks, fadeOutTIcks);
+    	}
+    }
+    
+    /**
+     * Get material map by block ID
+     */
+    @Override
+    public BukkitMaterial[] getMaterialList() {
+    	return new BukkitMaterial[4096];	// Not used
+    }
+
+	@Override
+	public void unloadChunkNoSave(World w, org.bukkit.Chunk c, int cx, int cz) {
+		Log.severe("unloadChunkNoSave not implemented");
+	}
+
+	private String[] biomenames;
+	@Override
+	public String[] getBiomeNames() {
+    	if (biomenames == null) {
+    		biomenames = new String[1024];
+            for (int i = 0; i < 1024; i++) {
+            	BiomeBase bb = getBiomeReg().fromId(i);
+            	if (bb != null) {
+            		biomenames[i] = bb.toString();
+            	}
+            }
+        }
+        return biomenames;
+	}
+
+	@Override
+	public String getStateStringByCombinedId(int blkid, int meta) {
+        Log.severe("getStateStringByCombinedId not implemented");		
+		return null;
+	}
+	@Override
+    /** Get ID string from biomebase */
+    public String getBiomeBaseIDString(Object bb) {
+        String s = ((BiomeBase)bb).toString();
+        if (s != null) {
+        	String[] ss = s.split("\\.");
+        	return ss[ss.length-1];
+        }
+        return null;
+    }
+
+	@Override
+	public Object getUnloadQueue(World world) {
+		System.out.println("getUnloadQueue not implemented yet");
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	@Override
+	public boolean isInUnloadQueue(Object unloadqueue, int x, int z) {
+		System.out.println("isInUnloadQueue not implemented yet");
+		// TODO Auto-generated method stub
+		return false;
+	}
+
+	@Override
+	public Object[] getBiomeBaseFromSnapshot(ChunkSnapshot css) {
+		System.out.println("getBiomeBaseFromSnapshot not implemented yet");
+		// TODO Auto-generated method stub
+		return new Object[256];
+	}
+
+	@Override
+	public long getInhabitedTicks(Chunk c) {
+		return ((CraftChunk)c).getHandle().getInhabitedTime();
+	}
+
+	@Override
+	public Map<?, ?> getTileEntitiesForChunk(Chunk c) {
+		return ((CraftChunk)c).getHandle().l;
+	}
+
+	@Override
+	public int getTileEntityX(Object te) {
+		TileEntity tileent = (TileEntity) te;
+		return tileent.getPosition().getX();
+	}
+
+	@Override
+	public int getTileEntityY(Object te) {
+		TileEntity tileent = (TileEntity) te;
+		return tileent.getPosition().getY();
+	}
+
+	@Override
+	public int getTileEntityZ(Object te) {
+		TileEntity tileent = (TileEntity) te;
+		return tileent.getPosition().getZ();
+	}
+
+	@Override
+	public Object readTileEntityNBT(Object te) {
+		TileEntity tileent = (TileEntity) te;
+		NBTTagCompound nbt = new NBTTagCompound();
+		tileent.save(nbt);	// readNBT
+        return nbt;
+	}
+
+	@Override
+	public Object getFieldValue(Object nbt, String field) {
+		NBTTagCompound rec = (NBTTagCompound) nbt;
+		NBTBase val = rec.get(field);
+        if(val == null) return null;
+        if(val instanceof NBTTagByte) {
+            return ((NBTTagByte)val).asByte();
+        }
+        else if(val instanceof NBTTagShort) {
+            return ((NBTTagShort)val).asShort();
+        }
+        else if(val instanceof NBTTagInt) {
+            return ((NBTTagInt)val).asInt();
+        }
+        else if(val instanceof NBTTagLong) {
+            return ((NBTTagLong)val).asLong();
+        }
+        else if(val instanceof NBTTagFloat) {
+            return ((NBTTagFloat)val).asFloat();
+        }
+        else if(val instanceof NBTTagDouble) {
+            return ((NBTTagDouble)val).asDouble();
+        }
+        else if(val instanceof NBTTagByteArray) {
+            return ((NBTTagByteArray)val).getBytes();
+        }
+        else if(val instanceof NBTTagString) {
+            return ((NBTTagString)val).asString();
+        }
+        else if(val instanceof NBTTagIntArray) {
+            return ((NBTTagIntArray)val).getInts();
+        }
+        return null;
+	}
+
+	@Override
+	public Player[] getOnlinePlayers() {
+        Collection<? extends Player> p = Bukkit.getServer().getOnlinePlayers();
+        return p.toArray(new Player[0]);
+	}
+
+	@Override
+	public double getHealth(Player p) {
+		return p.getHealth();
+	}
+}

bukkit-helper-117/src/main/java/org/dynmap/bukkit/helper/v117/MapChunkCache117.java

@@ -0,0 +1,492 @@
+package org.dynmap.bukkit.helper.v117;
+
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.craftbukkit.v1_17_R1.CraftWorld;
+import org.dynmap.DynmapChunk;
+import org.dynmap.DynmapCore;
+import org.dynmap.bukkit.helper.AbstractMapChunkCache;
+import org.dynmap.bukkit.helper.BukkitVersionHelper;
+import org.dynmap.bukkit.helper.SnapshotCache;
+import org.dynmap.bukkit.helper.SnapshotCache.SnapshotRec;
+import org.dynmap.renderer.DynmapBlockState;
+import org.dynmap.utils.DynIntHashMap;
+import org.dynmap.utils.VisibilityLimit;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.nbt.NBTTagList;
+import net.minecraft.util.DataBits;
+import net.minecraft.util.datafix.DataBitsPacked;
+import net.minecraft.world.level.ChunkCoordIntPair;
+import net.minecraft.world.level.chunk.Chunk;
+import net.minecraft.world.level.chunk.ChunkStatus;
+import net.minecraft.world.level.chunk.storage.ChunkRegionLoader;
+
+import java.io.IOException;
+import java.util.Arrays;
+
+/**
+ * Container for managing chunks - dependent upon using chunk snapshots, since rendering is off server thread
+ */
+public class MapChunkCache117 extends AbstractMapChunkCache {
+
+	public static class NBTSnapshot implements Snapshot {
+	    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 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) {
+        CraftWorld cw = (CraftWorld) w;
+        NBTTagCompound nbt = null;
+        if (cw.isChunkLoaded(x, z)) {
+            Chunk c = cw.getHandle().getChunkAt(x,  z);
+            if ((c != null) && c.h) {	// c.loaded
+                nbt = ChunkRegionLoader.saveChunk(cw.getHandle(), c);
+            }
+        }
+        if (nbt != null) {
+            nbt = nbt.getCompound("Level");
+            if (nbt != null) {
+                String stat = nbt.getString("Status");
+				ChunkStatus cs = ChunkStatus.a(stat);
+                if ((stat == null) || (!cs.b(ChunkStatus.j))) {	// ChunkStatus.LIGHT
+                    nbt = null;
+                }
+            }
+        }
+        return nbt;
+    }
+    
+    private NBTTagCompound loadChunkNBT(World w, int x, int z) {
+        CraftWorld cw = (CraftWorld) w;
+        NBTTagCompound nbt = null;
+        ChunkCoordIntPair cc = new ChunkCoordIntPair(x, z);
+        try {
+            nbt = cw.getHandle().getChunkProvider().a.read(cc);	// playerChunkMap
+        } catch (IOException iox) {
+        }
+        if (nbt != null) {
+            nbt = nbt.getCompound("Level");
+            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;
+    }   
+    
+    @Override
+    public Snapshot wrapChunkSnapshot(ChunkSnapshot css) {
+        // TODO Auto-generated method stub
+        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;
+    }
+}

settings.gradle

@@ -7,6 +7,7 @@ include ':bukkit-helper-116'
 include ':bukkit-helper-116-2'
 include ':bukkit-helper-116-3'
 include ':bukkit-helper-116-4'
+include ':bukkit-helper-117'
 include ':bukkit-helper'
 include ':dynmap-api'
 include ':DynmapCore'
@@ -34,6 +35,7 @@ project(':bukkit-helper-116').projectDir = "$rootDir/bukkit-helper-116" as File
 project(':bukkit-helper-116-2').projectDir = "$rootDir/bukkit-helper-116-2" as File
 project(':bukkit-helper-116-3').projectDir = "$rootDir/bukkit-helper-116-3" as File
 project(':bukkit-helper-116-4').projectDir = "$rootDir/bukkit-helper-116-4" as File
+project(':bukkit-helper-117').projectDir = "$rootDir/bukkit-helper-117" as File
 project(':bukkit-helper').projectDir = "$rootDir/bukkit-helper" as File
 project(':dynmap-api').projectDir = "$rootDir/dynmap-api" as File
 project(':DynmapCore').projectDir = "$rootDir/DynmapCore" as File

spigot/build.gradle

@@ -47,6 +47,9 @@ dependencies {
     implementation(project(':bukkit-helper-116-4')) {
         transitive = false
     }
+    implementation(project(':bukkit-helper-117')) {
+        transitive = false
+    }
 }
 
 processResources {
@@ -78,6 +81,7 @@ shadowJar {
         include(dependency(':bukkit-helper-116-2'))
         include(dependency(':bukkit-helper-116-3'))
         include(dependency(':bukkit-helper-116-4'))
+        include(dependency(':bukkit-helper-117'))
     }
     relocate('org.bstats', 'org.dynmap.bstats')
     destinationDir = file '../target'

spigot/src/main/java/org/dynmap/bukkit/Helper.java

@@ -12,6 +12,7 @@ import org.dynmap.bukkit.helper.v116.BukkitVersionHelperSpigot116;
 import org.dynmap.bukkit.helper.v116_2.BukkitVersionHelperSpigot116_2;
 import org.dynmap.bukkit.helper.v116_3.BukkitVersionHelperSpigot116_3;
 import org.dynmap.bukkit.helper.v116_4.BukkitVersionHelperSpigot116_4;
+import org.dynmap.bukkit.helper.v117.BukkitVersionHelperSpigot117;
 
 public class Helper {
 
@@ -37,6 +38,9 @@ public class Helper {
                 Log.info("Loading Glowstone support");
                 BukkitVersionHelper.helper = new BukkitVersionHelperGlowstone();
             }
+            else if (v.contains("(MC: 1.17")) {
+                BukkitVersionHelper.helper = new BukkitVersionHelperSpigot117();
+            }
             else if (v.contains("(MC: 1.16.1")) {
                 BukkitVersionHelper.helper = new BukkitVersionHelperSpigot116();
             }