Bump to 2.2 GA

Changed default "skin-url" value

pom.xml

@@ -1,11 +1,14 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 	<modelVersion>4.0.0</modelVersion>
-	<groupId>org.dynmap</groupId>
+	<groupId>us.dynmap</groupId>
 	<artifactId>dynmap</artifactId>
 	<name>dynmap</name>
 	<properties>
+		<timestamp>${maven.build.timestamp}</timestamp>
+		<maven.build.timestamp.format>yyyyMMddHHmm</maven.build.timestamp.format>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-		<BUILD_NUMBER>Dev</BUILD_NUMBER>
+		<BUILD_NUMBER>Dev${timestamp}</BUILD_NUMBER>
 	</properties>
 	<url>http://github.com/webbukkit/dynmap/</url>
 	<issueManagement>
@@ -41,7 +44,7 @@
 					<target>1.6</target>
 				</configuration>
 			</plugin>
-			
+
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-shade-plugin</artifactId>
@@ -55,25 +58,44 @@
 						<configuration>
 							<artifactSet>
 								<includes>
-									<include>org.dynmap:dynmap-api:jar:*</include>
-									<include>org.dynmap:DynmapCore:jar:*</include>
+									<include>us.dynmap:dynmap-api:jar:*</include>
+									<include>us.dynmap:DynmapCore:jar:*</include>
 								</includes>
 							</artifactSet>
 						</configuration>
 					</execution>
 				</executions>
 			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-source-plugin</artifactId>
+				<version>2.2.1</version>
+				<executions>
+					<execution>
+						<id>attach-sources</id>
+						<goals>
+							<goal>jar</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-javadoc-plugin</artifactId>
+				<version>2.9.1</version>
+				<executions>
+					<execution>
+						<id>attach-javadocs</id>
+						<goals>
+							<goal>jar</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+
 		</plugins>
 	</build>
 	<repositories>
-		<repository>
-			<releases>
-			</releases>
-			<snapshots>
-			</snapshots>
-			<id>bukkit-repo</id>
-			<url>http://repo.bukkit.org/content/repositories/releases/</url>
-		</repository>
 		<repository>
 			<releases>
 			</releases>
@@ -92,22 +114,18 @@
 		<dependency>
 			<groupId>org.bukkit</groupId>
 			<artifactId>bukkit</artifactId>
-			<version>1.3.2-R3.0</version>
+			<version>1.7.10-R0.1-SNAPSHOT</version>
 		</dependency>
 		<dependency>
-			<groupId>org.dynmap</groupId>
+			<groupId>us.dynmap</groupId>
 			<artifactId>dynmap-api</artifactId>
 			<version>${project.version}</version>
-			<type>jar</type>
-			<scope>compile</scope>
 		</dependency>
 
 		<dependency>
-			<groupId>org.dynmap</groupId>
+			<groupId>us.dynmap</groupId>
 			<artifactId>DynmapCore</artifactId>
 			<version>${project.version}</version>
-			<type>jar</type>
-			<scope>compile</scope>
 		</dependency>
 		<dependency>
 			<groupId>org.getspout</groupId>
@@ -136,5 +154,5 @@
 			<version>2.10.1</version>
 		</dependency>
 	</dependencies>
-	<version>1.7</version>
+	<version>2.2</version>
 </project>

src/main/java/org/dynmap/bukkit/BukkitVersionHelper.java

@@ -5,12 +5,15 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Collections;
 import java.util.Map;
+
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.ChunkSnapshot;
 import org.bukkit.Server;
 import org.bukkit.World;
+import org.bukkit.entity.Player;
 import org.dynmap.Log;
+import org.dynmap.utils.Polygon;
 
 /**
  * Helper for isolation of bukkit version specific issues
@@ -21,6 +24,7 @@ public abstract class BukkitVersionHelper {
     
     public static final BukkitVersionHelper getHelper() {
         if(helper == null) {
+            Log.info("version=" + Bukkit.getServer().getVersion());
             if(Bukkit.getServer().getVersion().contains("MCPC")) {
                 Log.severe("*********************************************************************************");
                 Log.severe("* MCPC-Plus is no longer supported via the Bukkit version of Dynmap.            *");
@@ -35,6 +39,10 @@ public abstract class BukkitVersionHelper {
                 Log.severe("* Add the DynmapCBBridge plugin to enable support for Dynmap-compatible plugins *");
                 Log.severe("*********************************************************************************");
             }
+            else if(Bukkit.getServer().getClass().getName().contains("GlowServer")) {
+                Log.info("Loading Glowstone support");
+                helper = new BukkitVersionHelperGlowstone();
+            }
             else {
                 helper = new BukkitVersionHelperCB();
             }
@@ -64,14 +72,10 @@ public abstract class BukkitVersionHelper {
      * Get ID from biomebase
      */
     public abstract int getBiomeBaseID(Object bb);
-    /** 
-     * Get net.minecraft.server.world for given world
-     */
-    public abstract Object getNMSWorld(World w);
     /**
      *  Get unload queue for given NMS world
      */
-    public abstract Object getUnloadQueue(Object nmsworld);
+    public abstract Object getUnloadQueue(World world);
     /**
      *  For testing unload queue for presence of givne chunk
      */
@@ -83,11 +87,15 @@ public abstract class BukkitVersionHelper {
     /**
      * Test if normal chunk snapshot
      */
-    public abstract boolean isCraftChunkSnapshot(ChunkSnapshot css);
+//    public abstract boolean isCraftChunkSnapshot(ChunkSnapshot css);
     /** 
      * Remove entities from given chunk
      */
     public abstract void removeEntitiesFromChunk(Chunk c);
+    /**
+     * Get inhabited ticks count from chunk
+     */
+    public abstract long getInhabitedTicks(Chunk c);
     /** 
      * Get tile entities map from chunk
      */
@@ -128,4 +136,16 @@ public abstract class BukkitVersionHelper {
      * Get block material index list
      */
     public abstract int[] getBlockMaterialMap();
+    /**
+     * Get list of online players
+     */
+    public abstract Player[] getOnlinePlayers();
+    /**
+     * Get player health
+     */
+    public abstract double getHealth(Player p);
+    /**
+     * Get world border
+     */
+    public Polygon getWorldBorder(World world) { return null; }
 }

src/main/java/org/dynmap/bukkit/BukkitVersionHelperCB.java

@@ -1,15 +1,18 @@
 package org.dynmap.bukkit;
 
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Map;
+
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.Server;
 import org.bukkit.World;
 import org.dynmap.Log;
 import org.dynmap.common.BiomeMap;
+import org.dynmap.utils.Polygon;
 
 /**
  * Helper for isolation of bukkit version specific issues
@@ -21,6 +24,13 @@ public class BukkitVersionHelperCB extends BukkitVersionHelperGeneric {
     private Field blockbyid;
     private Field blockname;
     private Field material;
+    private Method blockbyidfunc;   // 1.7+ method for getting block by id
+    private Method getworldborder;  // 1.8+ method for getting world border
+    private Class<?> nmsworldborder;
+    private Method worldborderminx;
+    private Method worldbordermaxx;
+    private Method worldborderminz;
+    private Method worldbordermaxz;
     
     BukkitVersionHelperCB() {
     }
@@ -43,22 +53,26 @@ public class BukkitVersionHelperCB extends BukkitVersionHelperGeneric {
         nmsblock = getNMSClass("net.minecraft.server.Block");
         nmsblockarray = getNMSClass("[Lnet.minecraft.server.Block;");
         nmsmaterial = getNMSClass("net.minecraft.server.Material");
-        blockbyid = getField(nmsblock, new String[] { "byId" }, nmsblockarray);
-        blockname = getPrivateField(nmsblock, new String[] { "name" }, String.class);
-        material = getField(nmsblock, new String[] { "material" }, nmsmaterial);
+        blockbyid = getFieldNoFail(nmsblock, new String[] { "byId" }, nmsblockarray);
+        if (blockbyid == null) {
+            blockbyidfunc = getMethod(nmsblock, new String[] { "getById", "e" }, new Class[] { int.class });
+        }
+        blockname = getPrivateField(nmsblock, new String[] { "name", "b" }, String.class);
+        material = getPrivateField(nmsblock, new String[] { "material" }, nmsmaterial);
 
         /* Set up biomebase fields */
         biomebase = getNMSClass("net.minecraft.server.BiomeBase");
         biomebasearray =  getNMSClass("[Lnet.minecraft.server.BiomeBase;");
-        biomebaselist = getField(biomebase, new String[] { "biomes" }, biomebasearray);
+        biomebaselist = getPrivateField(biomebase, new String[] { "biomes" }, biomebasearray);
         biomebasetemp = getField(biomebase, new String[] { "temperature", "F" }, float.class);
         biomebasehumi = getField(biomebase, new String[] { "humidity", "G" }, float.class);
-        biomebaseidstring = getField(biomebase, new String[] { "y" }, String.class);
+        biomebaseidstring = getField(biomebase, new String[] { "y", "af", "ah" }, String.class);
         biomebaseid = getField(biomebase, new String[] { "id" }, int.class);
         /* n.m.s.World */
         nmsworld = getNMSClass("net.minecraft.server.WorldServer");
         chunkprovserver = getNMSClass("net.minecraft.server.ChunkProviderServer");
         nmsw_chunkproviderserver = getField(nmsworld, new String[] { "chunkProviderServer" }, chunkprovserver);
+        getworldborder = getMethodNoFail(nmsworld, new String[] { "af" }, nulltypes);
         
         longhashset = getOBCClassNoFail("org.bukkit.craftbukkit.util.LongHashSet");
         if(longhashset != null) {
@@ -75,8 +89,21 @@ public class BukkitVersionHelperCB extends BukkitVersionHelperGeneric {
         }
         /** n.m.s.Chunk */
         nmschunk = getNMSClass("net.minecraft.server.Chunk");
-        nmsc_removeentities = getMethod(nmschunk, new String[] { "removeEntities" }, new Class[0]);
-        nmsc_tileentities = getField(nmschunk, new String[] { "tileEntities" }, Map.class); 
+        nmsc_removeentities = getMethod(nmschunk, new String[] { "removeEntities" }, nulltypes);
+        nmsc_tileentities = getField(nmschunk, new String[] { "tileEntities" }, Map.class);
+        nmsc_inhabitedticks = getFieldNoFail(nmschunk, new String[] { "s", "q", "u" }, long.class);
+        if (nmsc_inhabitedticks == null) {
+            Log.info("inhabitedTicks field not found - inhabited shader not functional");
+        }
+        /** n.m.s.WorldBorder */
+        nmsworldborder = getNMSClassNoFail("net.minecraft.server.WorldBorder");
+        if (nmsworldborder != null) {
+            worldborderminx = getMethod(nmsworldborder, new String[] { "b" }, nulltypes);
+            worldborderminz = getMethod(nmsworldborder, new String[] { "c" }, nulltypes);
+            worldbordermaxx = getMethod(nmsworldborder, new String[] { "d" }, nulltypes);
+            worldbordermaxz = getMethod(nmsworldborder, new String[] { "e" }, nulltypes);
+        }
+        
         /** nbt classes */
         nbttagcompound = getNMSClass("net.minecraft.server.NBTTagCompound");
         nbttagbyte = getNMSClass("net.minecraft.server.NBTTagByte");
@@ -89,22 +116,31 @@ public class BukkitVersionHelperCB extends BukkitVersionHelperGeneric {
         nbttagstring = getNMSClass("net.minecraft.server.NBTTagString");
         nbttagintarray = getNMSClass("net.minecraft.server.NBTTagIntArray");
         compound_get = getMethod(nbttagcompound, new String[] { "get" }, new Class[] { String.class });
-        nbttagbyte_val = getField(nbttagbyte, new String[] { "data" }, byte.class);
-        nbttagshort_val = getField(nbttagshort, new String[] { "data" }, short.class);
-        nbttagint_val = getField(nbttagint, new String[] { "data" }, int.class);
-        nbttaglong_val = getField(nbttaglong, new String[] { "data" }, long.class);
-        nbttagfloat_val = getField(nbttagfloat, new String[] { "data" }, float.class);
-        nbttagdouble_val = getField(nbttagdouble, new String[] { "data" }, double.class);
-        nbttagbytearray_val = getField(nbttagbytearray, new String[] { "data" }, byte[].class);
-        nbttagstring_val = getField(nbttagstring, new String[] { "data" }, String.class);
-        nbttagintarray_val = getField(nbttagintarray, new String[] { "data" }, int[].class);
+        nbttagbyte_val = getPrivateField(nbttagbyte, new String[] { "data" }, byte.class);
+        nbttagshort_val = getPrivateField(nbttagshort, new String[] { "data" }, short.class);
+        nbttagint_val = getPrivateField(nbttagint, new String[] { "data" }, int.class);
+        nbttaglong_val = getPrivateField(nbttaglong, new String[] { "data" }, long.class);
+        nbttagfloat_val = getPrivateField(nbttagfloat, new String[] { "data" }, float.class);
+        nbttagdouble_val = getPrivateField(nbttagdouble, new String[] { "data" }, double.class);
+        nbttagbytearray_val = getPrivateField(nbttagbytearray, new String[] { "data" }, byte[].class);
+        nbttagstring_val = getPrivateField(nbttagstring, new String[] { "data" }, String.class);
+        nbttagintarray_val = getPrivateField(nbttagintarray, new String[] { "data" }, int[].class);
 
         /** Tile entity */
         nms_tileentity = getNMSClass("net.minecraft.server.TileEntity");
         nmst_readnbt = getMethod(nms_tileentity, new String[] { "b" }, new Class[] { nbttagcompound });
-        nmst_x = getField(nms_tileentity, new String[] { "x" }, int.class); 
-        nmst_y = getField(nms_tileentity, new String[] { "y" }, int.class); 
-        nmst_z = getField(nms_tileentity, new String[] { "z" }, int.class); 
+        nmst_getposition = getMethodNoFail(nms_tileentity, new String[] { "getPosition" }, new Class[0]); // Try 1.8 method
+        if (nmst_getposition == null) {
+            nmst_x = getField(nms_tileentity, new String[] { "x" }, int.class); 
+            nmst_y = getField(nms_tileentity, new String[] { "y" }, int.class); 
+            nmst_z = getField(nms_tileentity, new String[] { "z" }, int.class); 
+        }
+        else {  /* BlockPosition */
+            nms_blockposition = getNMSClass("net.minecraft.server.BlockPosition");
+            nmsbp_getx = getMethod(nms_blockposition, new String[] { "getX" }, new Class[0]);
+            nmsbp_gety = getMethod(nms_blockposition, new String[] { "getY" }, new Class[0]);
+            nmsbp_getz = getMethod(nms_blockposition, new String[] { "getZ" }, new Class[0]);
+        }
     }
     @Override
     public void unloadChunkNoSave(World w, Chunk c, int cx, int cz) {
@@ -117,16 +153,27 @@ public class BukkitVersionHelperCB extends BukkitVersionHelperGeneric {
     @Override
     public String[] getBlockShortNames() {
         try {
-            Object[] byid = (Object[])blockbyid.get(nmsblock);
-            String[] names = new String[byid.length];
-            for (int i = 0; i < names.length; i++) {
-                if (byid[i] != null) {
-                    names[i] = (String)blockname.get(byid[i]);
+            String[] names = new String[4096];
+            if (blockbyid != null)  {
+                Object[] byid = (Object[])blockbyid.get(nmsblock);
+                for (int i = 0; i < names.length; i++) {
+                    if (byid[i] != null) {
+                        names[i] = (String)blockname.get(byid[i]);
+                    }
+                }
+            }
+            else {
+                for (int i = 0; i < names.length; i++) {
+                    Object blk = blockbyidfunc.invoke(nmsblock, i);
+                    if (blk != null) {
+                        names[i] = (String)blockname.get(blk);
+                    }
                 }
             }
             return names;
         } catch (IllegalArgumentException e) {
         } catch (IllegalAccessException e) {
+        } catch (InvocationTargetException e) {
         }
         return new String[0];
     }
@@ -153,28 +200,74 @@ public class BukkitVersionHelperCB extends BukkitVersionHelperGeneric {
      */
     public int[] getBlockMaterialMap() {
         try {
-            Object[] byid = (Object[])blockbyid.get(nmsblock);
-            int[] map = new int[byid.length];
-            ArrayList<Object> mats = new ArrayList<Object>();
-            for (int i = 0; i < map.length; i++) {
-                if (byid[i] != null) {
-                    Object mat = (Object)material.get(byid[i]);
-                    if (mat != null) {
-                        map[i] = mats.indexOf(mat);
-                        if (map[i] < 0) {
-                            map[i] = mats.size();
-                            mats.add(mat);
+            int[] map = new int[4096];
+            if (blockbyid != null) {
+                Object[] byid = (Object[])blockbyid.get(nmsblock);
+                ArrayList<Object> mats = new ArrayList<Object>();
+                for (int i = 0; i < map.length; i++) {
+                    if (byid[i] != null) {
+                        Object mat = (Object)material.get(byid[i]);
+                        if (mat != null) {
+                            map[i] = mats.indexOf(mat);
+                            if (map[i] < 0) {
+                                map[i] = mats.size();
+                                mats.add(mat);
+                            }
+                        }
+                        else {
+                            map[i] = -1;
                         }
                     }
-                    else {
-                        map[i] = -1;
+                }
+            }
+            else {
+                ArrayList<Object> mats = new ArrayList<Object>();
+                for (int i = 0; i < map.length; i++) {
+                    Object blk = blockbyidfunc.invoke(nmsblock, i);
+                    if (blk != null) {
+                        Object mat = (Object)material.get(blk);
+                        if (mat != null) {
+                            map[i] = mats.indexOf(mat);
+                            if (map[i] < 0) {
+                                map[i] = mats.size();
+                                mats.add(mat);
+                            }
+                        }
+                        else {
+                            map[i] = -1;
+                        }
                     }
                 }
             }
             return map;
         } catch (IllegalArgumentException e) {
         } catch (IllegalAccessException e) {
+        } catch (InvocationTargetException e) {
         }
         return new int[0];
     }
+    @Override
+    public Polygon getWorldBorder(World world) {
+        Polygon p = null;
+        if ((getworldborder == null) || (world == null)) {
+            return null;
+        }
+        Object cw = getNMSWorld(world);
+        if (cw == null) return null;
+        Object wb = callMethod(cw, getworldborder, nullargs, null);
+        if (wb != null) {
+            double minx = (Double) callMethod(wb, worldborderminx, nullargs, Double.MIN_VALUE);
+            double minz = (Double) callMethod(wb, worldborderminz, nullargs, Double.MIN_VALUE);
+            double maxx = (Double) callMethod(wb, worldbordermaxx, nullargs, Double.MAX_VALUE);
+            double maxz = (Double) callMethod(wb, worldbordermaxz, nullargs, Double.MAX_VALUE);
+            if (maxx < 1E7) {
+                p = new Polygon();
+                p.addVertex(minx, minz);
+                p.addVertex(minx, maxz);
+                p.addVertex(maxx, maxz);
+                p.addVertex(maxx, minz);
+            }
+        }
+        return p;
+    }
 }

src/main/java/org/dynmap/bukkit/BukkitVersionHelperGeneric.java

@@ -3,13 +3,17 @@ package org.dynmap.bukkit;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.Arrays;
+import java.util.Collection;
 import java.util.Collections;
 import java.util.Map;
+
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.ChunkSnapshot;
 import org.bukkit.Server;
 import org.bukkit.World;
+import org.bukkit.entity.Player;
 import org.dynmap.Log;
 
 /**
@@ -19,7 +23,8 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
     private String obc_package; // Package used for org.bukkit.craftbukkit
     protected String nms_package; // Package used for net.minecraft.server
     private boolean failed;
-    private static final Object[] nullargs = new Object[0];
+    protected static final Object[] nullargs = new Object[0];
+    protected static final Class[] nulltypes = new Class[0];
     private static final Map nullmap = Collections.emptyMap();
     
     /** CraftChunkSnapshot */
@@ -51,6 +56,7 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
     protected Class<?> nmschunk;
     protected Method nmsc_removeentities;
     protected Field nmsc_tileentities;
+    protected Field nmsc_inhabitedticks;
     /** nbt classes */
     protected Class<?> nbttagcompound;
     protected Class<?> nbttagbyte;
@@ -78,6 +84,17 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
     protected Field nmst_x;
     protected Field nmst_y;
     protected Field nmst_z;
+    protected Method nmst_getposition;
+    /** BlockPosition */
+    protected Class<?> nms_blockposition;
+    protected Method nmsbp_getx;
+    protected Method nmsbp_gety;
+    protected Method nmsbp_getz;
+    
+    /** Server */
+    protected Method server_getonlineplayers;
+    /** Player */
+    protected Method player_gethealth;
 
     BukkitVersionHelperGeneric() {
         failed = false;
@@ -98,6 +115,12 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
         /* CraftChunk */
         craftchunk = getOBCClass("org.bukkit.craftbukkit.CraftChunk");
         cc_gethandle = getMethod(craftchunk, new String[] { "getHandle" }, new Class[0]);
+        
+        /** Server */
+        server_getonlineplayers = getMethod(Server.class, new String[] { "getOnlinePlayers" }, new Class[0]);
+        /** Player */
+        player_gethealth = getMethod(Player.class, new String[] { "getHealth" }, new Class[0]);
+        
         /* Get NMS classes and fields */
         if(!failed)
             loadNMS();
@@ -121,7 +144,11 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
     protected Class<?> getNMSClass(String classname) {
         return getClassByName(classname, "net.minecraft.server", nms_package, false);
     }
-    
+
+    protected Class<?> getNMSClassNoFail(String classname) {
+        return getClassByName(classname, "net.minecraft.server", nms_package, true);
+    }
+
     protected Class<?> getClassByName(String classname, String base, String mapping, boolean nofail) {
         String n = classname;
         int idx = classname.indexOf(base);
@@ -216,7 +243,18 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
         failed = true;
         return null;
     }
-    private Object callMethod(Object obj, Method meth, Object[] args, Object def) {
+    protected Method getMethodNoFail(Class<?> cls, String[] ids, Class[] args) {
+        if(cls == null) return null;
+        for(String id : ids) {
+            try {
+                return cls.getMethod(id, args);
+            } catch (SecurityException e) {
+            } catch (NoSuchMethodException e) {
+            }
+        }
+        return null;
+    }
+    protected Object callMethod(Object obj, Method meth, Object[] args, Object def) {
         if((obj == null) || (meth == null)) {
             return def;
         }
@@ -254,13 +292,13 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
     }
 
     /* Get net.minecraft.server.world for given world */
-    public Object getNMSWorld(World w) {
+    protected Object getNMSWorld(World w) {
         return callMethod(w, cw_gethandle, nullargs, null);
     }
 
     /* Get unload queue for given NMS world */
-    public Object getUnloadQueue(Object nmsworld) {
-        Object cps = getFieldValue(nmsworld, nmsw_chunkproviderserver, null); // Get chunkproviderserver
+    public Object getUnloadQueue(World world) {
+        Object cps = getFieldValue(getNMSWorld(world), nmsw_chunkproviderserver, null); // Get chunkproviderserver
         if(cps != null) {
             return getFieldValue(cps, cps_unloadqueue, null);
         }
@@ -278,12 +316,12 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
     public Object[] getBiomeBaseFromSnapshot(ChunkSnapshot css) {
         return (Object[])getFieldValue(css, ccss_biome, null);
     }
-    public boolean isCraftChunkSnapshot(ChunkSnapshot css) {
-        if(craftchunksnapshot != null) {
-            return craftchunksnapshot.isAssignableFrom(css.getClass());
-        }
-        return false;
-    }
+//    public boolean isCraftChunkSnapshot(ChunkSnapshot css) {
+//        if(craftchunksnapshot != null) {
+//            return craftchunksnapshot.isAssignableFrom(css.getClass());
+//        }
+//        return false;
+//    }
     /** Remove entities from given chunk */
     public void removeEntitiesFromChunk(Chunk c) {
         Object omsc = callMethod(c, cc_gethandle, nullargs, null);
@@ -291,6 +329,21 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
             callMethod(omsc, nmsc_removeentities, nullargs, null);
         }
     }
+    /**
+     * Get inhabited ticks count from chunk
+     */
+    private static final Long zero = new Long(0);
+    public long getInhabitedTicks(Chunk c) {
+        if (nmsc_inhabitedticks == null) {
+            return 0;
+        }
+        Object omsc = callMethod(c, cc_gethandle, nullargs, null);
+        if(omsc != null) {
+            return (Long)getFieldValue(omsc, nmsc_inhabitedticks, zero);
+        }
+        return 0;
+    }
+
     /** Get tile entities map from chunk */
     public Map getTileEntitiesForChunk(Chunk c) {
         Object omsc = callMethod(c, cc_gethandle, nullargs, null);
@@ -303,19 +356,37 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
      * Get X coordinate of tile entity
      */
     public int getTileEntityX(Object te) {
-        return (Integer)getFieldValue(te, nmst_x, 0);
+        if (nmst_getposition == null) {
+            return (Integer)getFieldValue(te, nmst_x, 0);
+        }
+        else {
+            Object pos = callMethod(te, nmst_getposition, nullargs, null);
+            return (Integer) callMethod(pos, nmsbp_getx, nullargs, null);
+        }
     }
     /**
      * Get Y coordinate of tile entity
      */
     public int getTileEntityY(Object te) {
-        return (Integer)getFieldValue(te, nmst_y, 0);
+        if (nmst_getposition == null) {
+            return (Integer)getFieldValue(te, nmst_y, 0);
+        }
+        else {
+            Object pos = callMethod(te, nmst_getposition, nullargs, null);
+            return (Integer) callMethod(pos, nmsbp_gety, nullargs, null);
+        }
     }
     /**
      * Get Z coordinate of tile entity
      */
     public int getTileEntityZ(Object te) {
-        return (Integer)getFieldValue(te, nmst_z, 0);
+        if (nmst_getposition == null) {
+            return (Integer)getFieldValue(te, nmst_z, 0);
+        }
+        else {
+            Object pos = callMethod(te, nmst_getposition, nullargs, null);
+            return (Integer) callMethod(pos, nmsbp_getz, nullargs, null);
+        }
     }
     /**
      * Read tile entity NBT
@@ -369,4 +440,32 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
         }
         return null;
     }
+    /**
+     * Get list of online players
+     */
+    public Player[] getOnlinePlayers() {
+        Object players = callMethod(Bukkit.getServer(), server_getonlineplayers, nullargs, null);
+        if (players instanceof Player[]) {  /* Pre 1.7.10 */
+            return (Player[]) players;
+        }
+        else {
+            @SuppressWarnings("unchecked")
+            Collection<? extends Player> p = (Collection<? extends Player>) players;
+            return p.toArray(new Player[0]);
+        }
+    }
+    /**
+     * Get player health
+     */
+    @Override
+    public double getHealth(Player p) {
+        Object health = callMethod(p, player_gethealth, nullargs, null);
+        if (health instanceof Integer) {
+            return (Integer) health;
+        }
+        else {
+            return ((Double) health).intValue();
+        }
+    }
+
 }

src/main/java/org/dynmap/bukkit/BukkitVersionHelperGlowstone.java

@@ -0,0 +1,451 @@
+package org.dynmap.bukkit;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.ChunkSnapshot;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+public class BukkitVersionHelperGlowstone extends BukkitVersionHelper {
+    private Method rawbiome;
+    private Method server_getonlineplayers;
+    
+    public BukkitVersionHelperGlowstone() {
+        try {
+            Class<?> c = Class.forName("net.glowstone.GlowChunkSnapshot");
+            rawbiome = c.getMethod("getRawBiomes", new Class[0]);
+
+            /** Server */
+            server_getonlineplayers = Server.class.getMethod("getOnlinePlayers", new Class[0]);
+        } catch (SecurityException e) {
+        } catch (NoSuchMethodException e) {
+        } catch (ClassNotFoundException e) {
+        }
+        if ((rawbiome == null) && (server_getonlineplayers == null)) {
+            throw new IllegalArgumentException("Error initializing dynmap - Glowstone version incompatible!");
+        }
+    }
+    
+    @Override
+    public Object[] getBiomeBaseList() {
+        return new Object[0];
+    }
+
+    @Override
+    public float getBiomeBaseTemperature(Object bb) {
+        return 0;
+    }
+
+    @Override
+    public float getBiomeBaseHumidity(Object bb) {
+        return 0;
+    }
+
+    @Override
+    public String getBiomeBaseIDString(Object bb) {
+        return "";
+    }
+
+    @Override
+    public int getBiomeBaseID(Object bb) {
+        if (bb != null) 
+            return (Integer) bb;
+        else
+            return 0;
+    }
+
+    @Override
+    public Object getUnloadQueue(World world) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public boolean isInUnloadQueue(Object unloadqueue, int x, int z) {
+        // TODO Auto-generated method stub
+        return false;
+    }
+
+    @Override
+    public Object[] getBiomeBaseFromSnapshot(ChunkSnapshot css) {
+        Integer b[] = new Integer[256];
+        byte[] rb = null;
+        try {
+            rb = (byte[]) rawbiome.invoke(css, new Object[0]);
+        } catch (IllegalArgumentException e) {
+        } catch (IllegalAccessException e) {
+        } catch (InvocationTargetException e) {
+        }
+        if (rb != null) {
+            for (int i = 0; i < 256; i++) {
+                b[i] = Integer.valueOf(255 & (int)rb[i]);
+            }
+        }
+        return b;
+    }
+
+    @Override
+    public void removeEntitiesFromChunk(Chunk c) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public long getInhabitedTicks(Chunk c) {
+        // TODO Auto-generated method stub
+        return 0;
+    }
+
+    @Override
+    public Map getTileEntitiesForChunk(Chunk c) {
+        // TODO Auto-generated method stub
+        return Collections.emptyMap();
+    }
+
+    @Override
+    public int getTileEntityX(Object te) {
+        // TODO Auto-generated method stub
+        return 0;
+    }
+
+    @Override
+    public int getTileEntityY(Object te) {
+        // TODO Auto-generated method stub
+        return 0;
+    }
+
+    @Override
+    public int getTileEntityZ(Object te) {
+        // TODO Auto-generated method stub
+        return 0;
+    }
+
+    @Override
+    public Object readTileEntityNBT(Object te) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public Object getFieldValue(Object nbt, String field) {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    @Override
+    public void unloadChunkNoSave(World w, Chunk c, int cx, int cz) {
+        // TODO Auto-generated method stub
+
+    }
+
+    @Override
+    public String[] getBlockShortNames() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    private static final String[] bnames = {
+       "Ocean",
+       "Plains",
+       "Desert",
+       "Extreme Hills",
+       "Forest",
+       "Taiga",
+       "Swampland",
+       "River",
+       "Hell",
+       "Sky",
+       "FrozenOcean",
+       "FrozenRiver",
+       "Ice Plains",
+       "Ice Mountains",
+       "MushroomIsland",
+       "MushroomIslandShore",
+       "Beach",
+       "DesertHills",
+       "ForestHills",
+       "TaigaHills",
+       "Extreme Hills Edge",
+       "Jungle",
+       "JungleHills",
+       "JungleEdge",
+       "Deep Ocean",
+       "Stone Beach",
+       "Cold Beach",
+       "Birch Forest",
+       "Birch Forest Hills",
+       "Roofed Forest",
+       "Cold Taiga",
+       "Cold Taiga Hills",
+       "Mega Taiga",
+       "Mega Taiga Hills",
+       "Extreme Hills+",
+       "Savanna",
+       "Savanna Plateau",
+       "Mesa",
+       "Mesa Plateau F",
+       "Mesa Plateau",
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       "Sunflower Plains",
+       "Desert M",
+       "Extreme Hills M",
+       "Flower Forest",
+       "Taiga M",
+       "Swampland M",
+       null,
+       null,
+       null,
+       null,
+       null,
+       "Ice Plains Spikes",
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       "Jungle M",
+       null,
+       "JungleEdge M",
+       null,
+       null,
+       null,
+       "Birch Forest M",
+       "Birch Forest Hills M",
+       "Roofed Forest M",
+       "Cold Taiga M",
+       null,
+       "Mega Spruce Taiga",
+       "Mega Spruce Taiga",
+       "Extreme Hills+ M",
+       "Savanna M",
+       "Savanna Plateau M",
+       "Mesa (Bryce)",
+       "Mesa Plateau F M",
+       "Mesa Plateau M",
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null,
+       null
+    };
+
+    @Override
+    public String[] getBiomeNames() {
+        return bnames;
+    }
+
+    @Override
+    public int[] getBlockMaterialMap() {
+        // TODO Auto-generated method stub
+        return null;
+    }
+
+    /**
+     * Get list of online players
+     */
+    public Player[] getOnlinePlayers() {
+        Object players;
+        try {
+            players = server_getonlineplayers.invoke(Bukkit.getServer(), new Object[0]);
+            if (players instanceof Player[]) {  /* Pre 1.7.10 */
+                return (Player[]) players;
+            }
+            else {
+                @SuppressWarnings("unchecked")
+                Collection<? extends Player> p = (Collection<? extends Player>) players;
+                return p.toArray(new Player[0]);
+            }
+        } catch (IllegalArgumentException e) {
+        } catch (IllegalAccessException e) {
+        } catch (InvocationTargetException e) {
+        }
+        return new Player[0];
+    }
+
+    @Override
+    public double getHealth(Player p) {
+        return p.getHealth();
+    }
+
+}

src/main/java/org/dynmap/bukkit/BukkitWorld.java

@@ -2,16 +2,24 @@ package org.dynmap.bukkit;
 /**
  * Bukkit specific implementation of DynmapWorld
  */
+import java.io.File;
+import java.io.IOException;
+import java.io.RandomAccessFile;
+import java.util.Arrays;
 import java.util.List;
 
+import org.bukkit.Chunk;
 import org.bukkit.Location;
 import org.bukkit.World;
+import org.bukkit.block.Block;
 import org.bukkit.permissions.Permission;
 import org.bukkit.permissions.PermissionDefault;
 import org.dynmap.DynmapChunk;
 import org.dynmap.DynmapLocation;
 import org.dynmap.DynmapWorld;
 import org.dynmap.utils.MapChunkCache;
+import org.dynmap.utils.Polygon;
+import org.dynmap.utils.TileFlags;
 
 public class BukkitWorld extends DynmapWorld {
     private World world;
@@ -30,6 +38,20 @@ public class BukkitWorld extends DynmapWorld {
         this.env = env;
         skylight = (env == World.Environment.NORMAL);
         new Permission("dynmap.world." + getName(), "Dynmap access for world " + getName(), PermissionDefault.OP);
+        // Generate non-default environment lighting table
+        switch (env) {
+            case NETHER:
+                {
+                    float f = 0.1F;
+                    for (int i = 0; i <= 15; ++i) {
+                        float f1 = 1.0F - (float)i / 15.0F;
+                        this.setBrightnessTableEntry(i,  (1.0F - f1) / (f1 * 3.0F + 1.0F) * (1.0F - f) + f);
+                    }
+                }
+                break;
+            default:
+                break;
+        }
     }
     /**
      * Set world online
@@ -104,7 +126,10 @@ public class BukkitWorld extends DynmapWorld {
     @Override
     public int getLightLevel(int x, int y, int z) {
         if(world != null) {
-            return world.getBlockAt(x, y, z).getLightLevel();
+            if ((y >= 0) && (y < this.worldheight)) {
+                return world.getBlockAt(x, y, z).getLightLevel();
+            }
+            return 0;
         }
         else {
             return -1;
@@ -129,7 +154,12 @@ public class BukkitWorld extends DynmapWorld {
     @Override
     public int getSkyLightLevel(int x, int y, int z) {
         if(world != null) {
-            return world.getBlockAt(x, y, z).getLightFromSky();
+            if ((y >= 0) && (y < this.worldheight)) {
+                return world.getBlockAt(x, y, z).getLightFromSky();
+            }
+            else {
+                return 15;
+            }
         }
         else {
             return -1;
@@ -160,4 +190,61 @@ public class BukkitWorld extends DynmapWorld {
     public World getWorld() {
         return world;
     }
+    
+    // Return false if unimplemented
+    @Override
+    public int getChunkMap(TileFlags map) {
+        map.clear();
+        if (world == null) return -1;
+        int cnt = 0;
+        // Mark loaded chunks
+        for(Chunk c : world.getLoadedChunks()) {
+            map.setFlag(c.getX(), c.getZ(), true);
+            cnt++;
+        }
+        File f = world.getWorldFolder();
+        File regiondir = new File(f, "region");
+        File[] lst = regiondir.listFiles();
+        if(lst != null) {
+            byte[] hdr = new byte[4096];
+            for(File rf : lst) {
+                if(!rf.getName().endsWith(".mca")) {
+                    continue;
+                }
+                String[] parts = rf.getName().split("\\.");
+                if((!parts[0].equals("r")) && (parts.length != 4)) continue;
+                
+                RandomAccessFile rfile = null;
+                int x = 0, z = 0;
+                try {
+                    x = Integer.parseInt(parts[1]);
+                    z = Integer.parseInt(parts[2]);
+                    rfile = new RandomAccessFile(rf, "r");
+                    rfile.read(hdr, 0, hdr.length);
+                } catch (IOException iox) {
+                    Arrays.fill(hdr,  (byte)0);
+                } catch (NumberFormatException nfx) {
+                    Arrays.fill(hdr,  (byte)0);
+                } finally {
+                    if(rfile != null) {
+                        try { rfile.close(); } catch (IOException iox) {}
+                    }
+                }
+                for (int i = 0; i < 1024; i++) {
+                    int v = hdr[4*i] | hdr[4*i + 1] | hdr[4*i + 2] | hdr[4*i + 3];
+                    if (v == 0) continue;
+                    int xx = (x << 5) | (i & 0x1F);
+                    int zz = (z << 5) | ((i >> 5) & 0x1F);
+                    if (!map.setFlag(xx, zz, true)) {
+                        cnt++;
+                    }
+                }
+            }
+        }
+        return cnt;
+    }
+    @Override
+    public Polygon getWorldBorder() {
+        return DynmapPlugin.plugin.getWorldBorder(world);
+    }
 }

src/main/java/org/dynmap/bukkit/Metrics.java

@@ -56,9 +56,9 @@ import java.util.logging.Level;
  * <p> The metrics class obtains data about a plugin and submits statistics about it to the metrics backend. </p> <p>
  * Public methods provided by this class: </p>
  * <code>
- * Graph createGraph(String name); <br/>
- * void addCustomData(BukkitMetrics.Plotter plotter); <br/>
- * void start(); <br/>
+ * Graph createGraph(String name); <br>
+ * void addCustomData(BukkitMetrics.Plotter plotter); <br>
+ * void start(); <br>
  * </code>
  */
 public class Metrics {
@@ -121,6 +121,8 @@ public class Metrics {
      */
     private volatile BukkitTask task = null;
 
+    private BukkitVersionHelper helper;
+    
     public Metrics(final Plugin plugin) throws IOException {
         if (plugin == null) {
             throw new IllegalArgumentException("Plugin cannot be null");
@@ -146,6 +148,8 @@ public class Metrics {
         // Load the guid then
         guid = configuration.getString("guid");
         debug = configuration.getBoolean("debug", false);
+        
+        helper = BukkitVersionHelper.getHelper();
     }
 
     /**
@@ -359,7 +363,7 @@ public class Metrics {
         boolean onlineMode = Bukkit.getServer().getOnlineMode(); // TRUE if online mode is enabled
         String pluginVersion = description.getVersion();
         String serverVersion = Bukkit.getVersion();
-        int playersOnline = Bukkit.getServer().getOnlinePlayers().length;
+        int playersOnline = helper.getOnlinePlayers().length;
 
         // END server software specific section -- all code below does not use any code outside of this class / Java
 

src/main/java/org/dynmap/bukkit/NewMapChunkCache.java

@@ -22,14 +22,12 @@ import org.dynmap.utils.MapChunkCache;
 import org.dynmap.utils.MapIterator;
 import org.dynmap.utils.BlockStep;
 import org.dynmap.utils.VisibilityLimit;
-import org.getspout.spoutapi.block.SpoutChunk;
 
 /**
  * Container for managing chunks - dependent upon using chunk snapshots, since rendering is off server thread
  */
-public class NewMapChunkCache implements MapChunkCache {
+public class NewMapChunkCache extends MapChunkCache {
     private static boolean init = false;
-    private static boolean use_spout = false;    
 
     private World w;
     private DynmapWorld dw;
@@ -49,12 +47,7 @@ public class NewMapChunkCache implements MapChunkCache {
     private byte[][] sameneighborbiomecnt;
     private BiomeMap[][] biomemap;
     private boolean[][] isSectionNotEmpty; /* Indexed by snapshot index, then by section index */
-    
-    private int chunks_read;    /* Number of chunks actually loaded */
-    private int chunks_attempted;   /* Number of chunks attempted to load */
-    private long total_loadtime;    /* Total time loading chunks, in nanoseconds */
-    
-    private long exceptions;
+    private long[] inhabitedTicks;  /* Index = (x-x_min) + ((z-z_min)*x_dim) */
     
     private static BukkitVersionHelper helper = BukkitVersionHelper.getHelper();
     
@@ -210,7 +203,6 @@ public class NewMapChunkCache implements MapChunkCache {
             try {
                 return biomemap[x - x_base][z - z_base];
             } catch (Exception ex) {
-                exceptions++;
                 return BiomeMap.NULL;
             }
         }
@@ -240,7 +232,6 @@ public class NewMapChunkCache implements MapChunkCache {
                     mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
                 }
             } catch (Exception x) {
-                exceptions++;
                 mult = 0xFFFFFF;
             }
             return mult;
@@ -271,7 +262,6 @@ public class NewMapChunkCache implements MapChunkCache {
                     mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
                 }
             } catch (Exception x) {
-                exceptions++;
                 mult = 0xFFFFFF;
             }
             return mult;
@@ -313,7 +303,6 @@ public class NewMapChunkCache implements MapChunkCache {
                     mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
                 }
             } catch (Exception x) {
-                exceptions++;
                 mult = 0xFFFFFF;
             }
             return mult;
@@ -341,7 +330,6 @@ public class NewMapChunkCache implements MapChunkCache {
                 }
                 return ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
             } catch (Exception x) {
-                exceptions++;
                 return 0xFFFFFF;
             }
         }
@@ -371,7 +359,6 @@ public class NewMapChunkCache implements MapChunkCache {
                     mult = ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
                 }
             } catch (Exception x) {
-                exceptions++;
                 mult = 0xFFFFFF;
             }
             return mult;
@@ -593,6 +580,14 @@ public class NewMapChunkCache implements MapChunkCache {
                 int yoff, int zoff) {
             return null;
         }
+        @Override
+        public long getInhabitedTicks() {
+            try {
+                return inhabitedTicks[chunkindex];
+            } catch (Exception x) {
+                return 0;
+            }
+        }
      }
 
     private class OurEndMapIterator extends OurMapIterator {
@@ -740,8 +735,6 @@ public class NewMapChunkCache implements MapChunkCache {
      */
     public NewMapChunkCache() {
         if(!init) {
-            use_spout = DynmapPlugin.plugin.hasSpout();
-            
             init = true;
         }
     }
@@ -779,26 +772,15 @@ public class NewMapChunkCache implements MapChunkCache {
     
         snapcnt = x_dim * (z_max-z_min+1);
         snaparray = new ChunkSnapshot[snapcnt];
+        inhabitedTicks = new long[snapcnt];
         snaptile = new DynIntHashMap[snapcnt];
         isSectionNotEmpty = new boolean[snapcnt][];
     }
     
-    private ChunkSnapshot checkSpoutData(Chunk c, ChunkSnapshot ss) {
-        if(c instanceof SpoutChunk) {
-            SpoutChunk sc = (SpoutChunk)c;
-            short[] custids = sc.getCustomBlockIds();
-            if(custids != null) {
-                return new SpoutChunkSnapshot(ss, custids, c.getWorld().getMaxHeight());
-            }
-        }
-        return ss;
-    }
-
     public int loadChunks(int max_to_load) {
         if(dw.isLoaded() == false)
             return 0;
-        long t0 = System.nanoTime();
-        Object queue = helper.getUnloadQueue(helper.getNMSWorld(w));
+        Object queue = helper.getUnloadQueue(w);
         
         int cnt = 0;
         if(iterator == null)
@@ -808,6 +790,7 @@ public class NewMapChunkCache implements MapChunkCache {
         //boolean isnormral = w.getEnvironment() == Environment.NORMAL;
         // 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) {
@@ -829,10 +812,12 @@ public class NewMapChunkCache implements MapChunkCache {
             }
             /* Check if cached chunk snapshot found */
             ChunkSnapshot ss = null;
+            long inhabited_ticks = 0;
             DynIntHashMap tileData = null;
             SnapshotRec ssr = DynmapPlugin.plugin.sscache.getSnapshot(dw.getName(), chunk.x, chunk.z, blockdata, biome, biomeraw, highesty); 
             if(ssr != null) {
                 ss = ssr.ss;
+                inhabited_ticks = ssr.inhabitedTicks;
                 if(!vis) {
                     if(hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN)
                         ss = STONE;
@@ -844,10 +829,11 @@ public class NewMapChunkCache implements MapChunkCache {
                 int idx = (chunk.x-x_min) + (chunk.z - z_min)*x_dim;
                 snaparray[idx] = ss;
                 snaptile[idx] = ssr.tileData;
+                inhabitedTicks[idx] = inhabited_ticks;
                 
+                endChunkLoad(startTime, ChunkStats.CACHED_SNAPSHOT_HIT);
                 continue;
             }
-            chunks_attempted++;
             boolean wasLoaded = w.isChunkLoaded(chunk.x, chunk.z);
             boolean didload = false;
             boolean isunloadpending = false;
@@ -870,6 +856,8 @@ public class NewMapChunkCache implements MapChunkCache {
                 tileData = new DynIntHashMap();
 
                 Chunk c = w.getChunkAt(chunk.x, chunk.z);   /* Get the chunk */
+                /* Get inhabited ticks count */
+                inhabited_ticks = helper.getInhabitedTicks(c);
                 if(!vis) {
                     if(hidestyle == HiddenChunkStyle.FILL_STONE_PLAIN)
                         ss = STONE;
@@ -881,9 +869,6 @@ public class NewMapChunkCache implements MapChunkCache {
                 else {
                     if(blockdata || highesty) {
                         ss = c.getChunkSnapshot(highesty, biome, biomeraw);
-                        if(use_spout) {
-                            ss = checkSpoutData(c, ss);
-                        }
                         /* Get tile entity data */
                         List<Object> vals = new ArrayList<Object>();
                         Map<?,?> tileents = helper.getTileEntitiesForChunk(c);
@@ -919,16 +904,18 @@ public class NewMapChunkCache implements MapChunkCache {
                     if(ss != null) {
                         ssr = new SnapshotRec();
                         ssr.ss = ss;
+                        ssr.inhabitedTicks = inhabited_ticks;
                         ssr.tileData = tileData;
                         DynmapPlugin.plugin.sscache.putSnapshot(dw.getName(), chunk.x, chunk.z, ssr, blockdata, biome, biomeraw, highesty);
                     }
                 }
-                snaparray[(chunk.x-x_min) + (chunk.z - z_min)*x_dim] = ss;
-                snaptile[(chunk.x-x_min) + (chunk.z - z_min)*x_dim] = tileData;
+                int chunkIndex = (chunk.x-x_min) + (chunk.z - z_min)*x_dim;
+                snaparray[chunkIndex] = ss;
+                snaptile[chunkIndex] = tileData;
+                inhabitedTicks[chunkIndex] = inhabited_ticks;
                 
                 /* If wasn't loaded before, we need to do unload */
                 if (!wasLoaded) {
-                    chunks_read++;
                     /* Since we only remember ones we loaded, and we're synchronous, no player has
                      * moved, so it must be safe (also prevent chunk leak, which appears to happen
                      * because isChunkInUse defined "in use" as being within 256 blocks of a player,
@@ -936,10 +923,18 @@ public class NewMapChunkCache implements MapChunkCache {
                      * by the MC base server is 21x21 (or about a 160 block radius).
                      * Also, if we did generate it, need to save it */
                     helper.unloadChunkNoSave(w, c, chunk.x, chunk.z);
+                    endChunkLoad(startTime, ChunkStats.UNLOADED_CHUNKS);
                 }
                 else if (isunloadpending) { /* Else, if loaded and unload is pending */
                     w.unloadChunkRequest(chunk.x, chunk.z); /* Request new unload */
+                    endChunkLoad(startTime, ChunkStats.LOADED_CHUNKS);
                 }
+                else {
+                    endChunkLoad(startTime, ChunkStats.LOADED_CHUNKS);
+                }
+            }
+            else {
+                endChunkLoad(startTime, ChunkStats.UNGENERATED_CHUNKS);
             }
             cnt++;
         }
@@ -955,7 +950,6 @@ public class NewMapChunkCache implements MapChunkCache {
                     isempty = false;
             }
         }
-        total_loadtime += System.nanoTime() - t0;
 
         return cnt;
     }
@@ -987,6 +981,7 @@ public class NewMapChunkCache implements MapChunkCache {
                 snaparray[i] = null;
             }
             snaparray = null;
+            inhabitedTicks = null;
         }
     }
     private void initSectionData(int idx) {
@@ -1053,22 +1048,6 @@ public class NewMapChunkCache implements MapChunkCache {
     public DynmapWorld getWorld() {
         return dw;
     }
-    @Override
-    public int getChunksLoaded() {
-        return chunks_read;
-    }
-    @Override
-    public int getChunkLoadsAttempted() {
-        return chunks_attempted;
-    }
-    @Override
-    public long getTotalRuntimeNanos() {
-        return total_loadtime;
-    }
-    @Override
-    public long getExceptionCount() {
-        return exceptions;
-    }
     
     static {
         Biome[] b = Biome.values();

src/main/java/org/dynmap/bukkit/SnapshotCache.java

@@ -3,6 +3,7 @@ package org.dynmap.bukkit;
 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;
@@ -13,6 +14,7 @@ import org.dynmap.utils.DynIntHashMap;
 public class SnapshotCache {
     public static class SnapshotRec {
         public ChunkSnapshot ss;
+        public long inhabitedTicks;
         public DynIntHashMap tileData;
     };
 
@@ -20,9 +22,10 @@ public class SnapshotCache {
     private ReferenceQueue<SnapshotRec> refqueue;
     private long cache_attempts;
     private long cache_success;
-
+    private boolean softref;
+    
     private static class CacheRec {
-        WeakReference<SnapshotRec> ref;
+        Reference<SnapshotRec> ref;
         boolean hasbiome;
         boolean hasrawbiome;
         boolean hasblockdata;
@@ -32,12 +35,12 @@ public class SnapshotCache {
     @SuppressWarnings("serial")
     public class CacheHashMap extends LinkedHashMap<String, CacheRec> {
         private int limit;
-        private IdentityHashMap<WeakReference<SnapshotRec>, String> reverselookup;
+        private IdentityHashMap<Reference<SnapshotRec>, String> reverselookup;
 
         public CacheHashMap(int lim) {
             super(16, (float)0.75, true);
             limit = lim;
-            reverselookup = new IdentityHashMap<WeakReference<SnapshotRec>, String>();
+            reverselookup = new IdentityHashMap<Reference<SnapshotRec>, String>();
         }
         protected boolean removeEldestEntry(Map.Entry<String, CacheRec> last) {
             boolean remove = (size() >= limit);
@@ -51,9 +54,10 @@ public class SnapshotCache {
     /**
      * Create snapshot cache
      */
-    public SnapshotCache(int max_size) {
+    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;
@@ -127,7 +131,10 @@ public class SnapshotCache {
         rec.hasbiome = biome;
         rec.hasrawbiome = biomeraw;
         rec.hashighesty = highesty;
-        rec.ref = new WeakReference<SnapshotRec>(ss, refqueue);
+        if (softref)
+            rec.ref = new SoftReference<SnapshotRec>(ss, refqueue);
+        else
+            rec.ref = new WeakReference<SnapshotRec>(ss, refqueue);
         CacheRec prevrec = snapcache.put(key, rec);
         if(prevrec != null) {
             snapcache.reverselookup.remove(prevrec.ref);

src/main/java/org/dynmap/bukkit/SpoutPluginBlocks.java

@@ -1,265 +0,0 @@
-package org.dynmap.bukkit;
-
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.FileReader;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.lang.reflect.Field;
-import java.net.URL;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-
-import javax.imageio.ImageIO;
-
-import org.bukkit.Material;
-import org.bukkit.plugin.Plugin;
-import org.dynmap.DynmapCore;
-import org.dynmap.Log;
-import org.getspout.spoutapi.block.design.BlockDesign;
-import org.getspout.spoutapi.block.design.GenericBlockDesign;
-import org.getspout.spoutapi.block.design.GenericCuboidBlockDesign;
-import org.getspout.spoutapi.block.design.Texture;
-import org.getspout.spoutapi.material.CustomBlock;
-import org.getspout.spoutapi.material.MaterialData;
-
-/**
- * Handler for pulling spout-defined custom blocks into dynmap
- * 
- * Generates and maintains custom render data file (renderdata/spout-texture.txt) and
- * directory of downloaded image files (texturepacks/standard/spout/plugin.blockid.png)
- */
-public class SpoutPluginBlocks {
-    private Field textXPosField;    /* float[][] textXPos */
-    private Field textYPosField;    /* float[][] textYPos */
-    private HashSet<String> plugins_pending = new HashSet<String>();
-    
-    public SpoutPluginBlocks(Plugin plugin) {
-        /* First, see if any spout plugins that need to be enabled */
-        for(Plugin p : plugin.getServer().getPluginManager().getPlugins()) {
-            List<String> dep = p.getDescription().getDepend();
-            if((dep != null) && (dep.contains("Spout"))) {
-                Log.info("Found Spout plugin: " + p.getName());
-                if(p.isEnabled() == false) {
-                    plugins_pending.add(p.getName());
-                }
-            }
-        }
-    }
-    
-    public boolean isReady() {
-        return plugins_pending.isEmpty();
-    }
-    
-    public void markPluginEnabled(Plugin p) {
-        plugins_pending.remove(p.getName());
-    }
-    
-    private boolean initSpoutAccess() {
-        boolean success = false;
-        try {
-            textXPosField = GenericBlockDesign.class.getDeclaredField("textXPos");
-            textXPosField.setAccessible(true);
-            textYPosField = GenericBlockDesign.class.getDeclaredField("textYPos");
-            textYPosField.setAccessible(true);
-            success = true;
-        } catch (NoSuchFieldException nsfx) {
-            Log.severe("Cannot access needed Spout custom block fields!");
-            Log.severe(nsfx);
-        }
-        return success;
-    }
-    private void addDefaultBlock(StringBuilder sb, CustomBlock blk) {
-        if(blk.isOpaque())
-            sb.append("block:id=" + blk.getCustomId() + ",data=*,allfaces=1\n");
-        else
-            sb.append("block:id=" + blk.getCustomId() + ",allfaces=12049,transparency=TRANSPARENT\n");
-    }
-    
-    private static String fixIDString(String id) {
-        StringBuilder sb = new StringBuilder();
-        int len = id.length();
-        sb.setLength(len);
-        for(int i = 0; i < len; i++) {
-            char c = id.charAt(i);
-            if(Character.isJavaIdentifierStart(c)) {
-                sb.setCharAt(i, c);
-            }
-            else {
-                sb.setCharAt(i, '_');
-            }
-        }
-        return sb.toString();
-    }
-    
-    /* Process spout blocks - return true if something changed */
-    public boolean processSpoutBlocks(DynmapPlugin plugin, DynmapCore core) {
-        File datadir = core.getDataFolder();
-        if(textYPosField == null) {
-            if(initSpoutAccess() == false)
-                return false;
-        }
-        HashMap<String, String> texturelist = new HashMap<String, String>();
-        boolean use_existing_texture = core.configuration.getBoolean("spout/use-existing-textures", true);
-        
-        int cnt = 0;
-        File f = new File(datadir, "texturepacks/standard/spout");
-        if(f.exists() == false)
-            f.mkdirs();
-        List<CustomBlock> blks = new ArrayList<CustomBlock>();
-        CustomBlock[] cb = MaterialData.getCustomBlocks();
-        /* Build new texture file as string */
-        StringBuilder sb = new StringBuilder();
-        /* Loop through blocks - try to freshen files, if needed */
-        for(CustomBlock b : cb) {
-            BlockDesign bd = b.getBlockDesign();
-            if(bd == null) continue;
-            String txtplug = bd.getTexturePlugin();
-            if(txtplug == null) continue;
-            String blkname = b.getName();
-            if(blkname == null) continue;
-            String blkid = txtplug + "." + fixIDString(blkname);
-            /* If not GenericCubiodBlockDesign, we don't handle it */
-            if((bd instanceof GenericCuboidBlockDesign) == false) {
-                Log.info("Block " + blkid + " not suppored - only cubiod blocks");
-                addDefaultBlock(sb, b);
-                continue;
-            }
-            /* Get texture info */
-            Texture txt = bd.getTexture();
-            int w = txt.getWidth();
-            int h = txt.getHeight();
-            int sz = txt.getSpriteSize();
-            GenericCuboidBlockDesign gbd = (GenericCuboidBlockDesign)bd;
-            int[] txtidx = new int[6];
-            /* Fetch quad fields - figure out which texture for which side */
-            try {
-                float[][] textXPos = (float[][])textXPosField.get(gbd);
-                float[][] textYPos = (float[][])textYPosField.get(gbd);
-                /* Quads on cuboid are bottom, west, south, east, north, top */
-                for(int i = 0; i < 6; i++) {
-                    float minx = 1.0F;
-                    float miny = 1.0F;
-                    for(int j = 0; j < 4; j++) {
-                        minx = Math.min(minx, textXPos[i][j]);
-                        miny = Math.min(miny, textYPos[i][j]);
-                    }
-                    txtidx[i] = (int)((minx * w)/sz) + (w/sz)*(int)((miny * h)/sz); 
-                }
-            } catch (Exception iax) {
-                addDefaultBlock(sb, b);
-                continue;
-            }
-            String txname = bd.getTexureURL();
-            
-            String txtid = texturelist.get(txname);    /* Get texture */
-            if(txtid == null) { /* Not found yet */
-                File imgfile = new File(f, blkid + ".png");
-                
-                /* If not reusing loaded textures OR not previously loaded */
-                if((!use_existing_texture) || (!imgfile.exists())) {
-                    BufferedImage img = null;
-                    boolean urlloaded = false;
-                    try {
-                        URL url = new URL(txname);
-                        img = ImageIO.read(url);    /* Load skin for player */
-                        urlloaded = true;
-                    } catch (IOException iox) {
-                        if(txname.startsWith("http") == false) {   /* Not URL - try file */
-                            File tf = new File(txname);
-                            if(tf.exists() == false) {
-                                /* Horrible hack - try to find temp file (some SpoutMaterials versions) */
-                                try {
-                                    File tmpf = File.createTempFile("dynmap", "test");
-
-                                    tf = new File(tmpf.getParent(), txname);
-                                    tmpf.delete();
-                                } catch (IOException iox2) {}
-                            }
-                            if(tf.exists()) {
-                                try {
-                                    img = ImageIO.read(tf);
-                                    urlloaded = true;
-                                } catch (IOException iox3) {
-                                }
-                            }
-                        }
-                        if(img == null) {
-                            Log.severe("Error loading texture for custom block '" + blkid + "' (" + b.getCustomId() + ") from " + txname + "(" + iox.getMessage() + ")");
-                            if(imgfile.exists()) {
-                                try {
-                                    img = ImageIO.read(imgfile);    /* Load existing */
-                                    Log.info("Loaded cached texture file for " + blkid);
-                                } catch (IOException iox2) {
-                                    Log.severe("Error loading cached texture file for " + blkid + " - " + iox2.getMessage());
-                                }
-                            }
-                        }
-                    }
-                    if(img != null) {
-                        try {
-                            if(urlloaded)
-                                ImageIO.write(img, "png", imgfile);
-                        } catch (IOException iox) {
-                            Log.severe("Error writing " + blkid + ".png");
-                        } finally {
-                            img.flush();
-                        }
-                    }
-                }
-                if(imgfile.exists()) {  /* If exists now, log it */
-                    String tfid = "txtid" + texturelist.size();
-                    sb.append("texturefile:id=" + tfid + ",filename=spout/" + blkid + ".png,xcount=" + w/sz + ",ycount=" + h/sz + "\n");                                   
-                    texturelist.put(txname, tfid);
-                }
-            }
-            String txfileid = texturelist.get(txname);
-            if(txfileid != null) {
-                blks.add(b);
-                    
-                sb.append("block:id=" + b.getCustomId() + ",data=*,bottom=" + txtidx[0] + ",west=" +txtidx[1] + ",south=" + txtidx[2] + ",east=" + txtidx[3] + ",north="+txtidx[4]+",top="+txtidx[5]);
-                if(b.getBlockId() == Material.GLASS.getId())
-                    sb.append(",transparency=TRANSPARENT");
-                sb.append(",txtid=" + txfileid + "\n");
-                cnt++;
-            }
-        }
-        String rslt = sb.toString();
-        /* Now, generate spout texture file - see if changed */
-        File st = new File(datadir, "renderdata/spout-texture.txt");
-        if(st.exists()) {
-            FileReader fr = null;
-            StringBuilder sbold = new StringBuilder();
-            try {
-                fr = new FileReader(st);
-                int len;
-                char[] buf = new char[512];
-                while((len = fr.read(buf)) > 0) {
-                    sbold.append(buf, 0, len);
-                }
-            } catch (IOException iox) {
-            } finally {
-                if(fr != null) { try { fr.close(); } catch (IOException iox) {} }
-            }
-            /* If same, no changes */
-            if(sbold.equals(rslt)) {
-                Log.info("Loaded " + cnt + " Spout custom blocks");
-                return false;
-            }
-        }
-        FileWriter fw = null;
-        try {
-            fw = new FileWriter(st);
-            fw.write(rslt);
-        } catch (IOException iox) {
-            Log.severe("Error opening spout texture file - " + st.getPath());
-            return false;
-        } finally {
-            if(fw != null) { try { fw.close(); } catch (IOException iox) {} }
-        }
-        Log.info("Loaded " + cnt + " Spout custom blocks");
-        return false;
-    }
-}

src/main/java/org/dynmap/bukkit/permissions/BukkitPermissions.java

@@ -39,7 +39,7 @@ public class BukkitPermissions implements PermissionProvider {
     }
     @Override
     public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
-        Player p = Bukkit.getPlayerExact(name);
+        Player p = Bukkit.getPlayerExact(player);
         HashSet<String> hasperms = null;
         if (p != null) {
             hasperms = new HashSet<String>();

src/main/java/org/dynmap/bukkit/permissions/GroupManagerPermissions.java

@@ -35,15 +35,16 @@ public class GroupManagerPermissions implements PermissionProvider {
     }
 
     @Override
-    public boolean has(CommandSender sender, String permission) {
+    public boolean has(CommandSender sender, String permission) {        
         Player player = sender instanceof Player ? (Player) sender : null;
-        return (player != null) ? wh.getWorldPermissions(player).has(player, name + "." + permission) : true;
+        boolean rslt = (player != null) ? gm.getWorldsHolder().getDefaultWorld().getPermissionsHandler().permission(player, name + "." + permission) : true;
+        return rslt;
     }
     
     @Override
     public Set<String> hasOfflinePermissions(String player, Set<String> perms) {
         HashSet<String> hasperms = new HashSet<String>();
-        AnjoPermissionsHandler apm = wh.getWorldPermissionsByPlayerName(player);
+        AnjoPermissionsHandler apm = gm.getWorldsHolder().getDefaultWorld().getPermissionsHandler();
         if (apm != null) {
             for (String pp : perms) {
                 if (apm.permission(player, name + "." + pp)) {
@@ -55,10 +56,11 @@ public class GroupManagerPermissions implements PermissionProvider {
     }
     @Override
     public boolean hasOfflinePermission(String player, String perm) {
-        AnjoPermissionsHandler apm = wh.getWorldPermissionsByPlayerName(player);
+        AnjoPermissionsHandler apm = gm.getWorldsHolder().getDefaultWorld().getPermissionsHandler();
+        boolean rslt = false;
         if(apm != null) {
-            return apm.permission(player, name + "." + perm);
+            rslt = apm.permission(player, name + "." + perm);
         }
-        return false;
+        return rslt;
     }
 }

src/main/java/org/dynmap/bukkit/permissions/PEXPermissions.java

@@ -24,8 +24,9 @@ public class PEXPermissions implements PermissionProvider {
         server.getPluginManager().enablePlugin(permissionsPlugin);
         if(permissionsPlugin.isEnabled() == false)
             return null;
-        if(PermissionsEx.isAvailable() == false)
-            return null;
+        //Broken in new dev builds, apparently
+        //if(PermissionsEx.isAvailable() == false)
+        //    return null;
         Log.info("Using PermissionsEx " + permissionsPlugin.getDescription().getVersion() + " for access control");
         return new PEXPermissions(name);
     }

src/main/resources/configuration.txt

@@ -13,8 +13,27 @@
 #   The definitions of these templates are in normal-hi_boost_vhi.txt, nether-hi_boost_vhi.txt, and the_end-hi_boost_vhi.txt
 # To use the HDMap hi-res (16 ppb) map templates, with support for boosting resolution selectively to xhi-res (64 ppb), set value to hi_boost_xhi
 #   The definitions of these templates are in normal-hi_boost_xhi.txt, nether-hi_boost_xhi.txt, and the_end-hi_boost_xhi.txt
-deftemplatesuffix: vlowres
+deftemplatesuffix: hires
 
+# Map storage scheme: only uncommoent one 'type' value
+#  filetree: classic and default scheme: tree of files, with all map data under the directory indicated by 'tilespath' setting
+#  sqlite: single SQLite database file (this can get VERY BIG), located at 'dbfile' setting (default is file dynmap.db in data directory)
+#  mysql: MySQL database, at hostname:port in database, accessed via userid with password
+storage:
+  # Filetree storage (standard tree of image files for maps)
+  type: filetree
+  # SQLite db for map storage (uses dbfile as storage location)
+  #type: sqlite
+  #dbfile: dynmap.db
+  # MySQL DB for map storage (at 'hostname':'port' in database 'database' using user 'userid' password 'password' and table prefix 'prefix'
+  #type: mysql
+  #hostname: localhost
+  #port: 3306
+  #database: dynmap
+  #userid: dynmap
+  #password: dynmap
+  #prefix: ""
+  
 components:
   - class: org.dynmap.ClientConfigurationComponent
   
@@ -26,6 +45,8 @@ components:
     hidewebchatip: false
     trustclientname: false
     includehiddenplayers: false
+    # (optional) if true, color codes in player display names are used
+    use-name-colors: false
     # (optional) if true, player login IDs will be used for web chat when their IPs match
     use-player-login-ip: true
     # (optional) if use-player-login-ip is true, setting this to true will cause chat messages not matching a known player IP to be ignored
@@ -48,6 +69,8 @@ components:
     protected-player-info: false
     # If true, hide players with invisibility potion effects active
     hide-if-invisiblity-potion: true
+    # If true, player names are not shown on map, chat, list
+    hidenames: false
   #- class: org.dynmap.JsonFileClientUpdateComponent
   #  writeinterval: 1
   #  sendhealth: true
@@ -56,6 +79,7 @@ components:
   #  webchat-interval: 5
   #  hidewebchatip: false
   #  includehiddenplayers: false
+  #  use-name-colors: false
   #  use-player-login-ip: false
   #  require-player-login-ip: false
   #  block-banned-player-chat: true
@@ -69,6 +93,7 @@ components:
   #  # Limit length of single chat messages
   #  chatlengthlimit: 256
   #  hide-if-invisiblity-potion: true
+  #  hidenames: false
    
   - class: org.dynmap.SimpleWebChatComponent
     allowchat: true
@@ -80,6 +105,8 @@ components:
     type: markers
     showlabel: false
     enablesigns: false
+    # Default marker set for sign markers
+    default-sign-set: markers
     # (optional) add spawn point markers to standard marker layer
     showspawn: true
     spawnicon: world
@@ -98,6 +125,8 @@ components:
     spawnbedhidebydefault: true
     spawnbedminzoom: 0
     spawnbedformat: "%name%'s bed"
+    # (optional) show world border (vanilla 1.8+)
+    showworldborder: true
     
   - class: org.dynmap.ClientComponent
     type: chat
@@ -187,6 +216,9 @@ usenormalthreadpriority: true
 # Save and restore pending tile renders - prevents their loss on server shutdown or /reload
 saverestorepending: true
 
+# Save period for pending jobs (in seconds): periodic saving for crash recovery of jobs
+save-pending-period: 900
+
 # Zoom-out tile update period - how often to scan for and process tile updates into zoom-out tiles (in seconds)
 zoomoutperiod: 30
 
@@ -210,6 +242,17 @@ enabletilehash: true
 # Optional - enable smooth lighting by default on all maps supporting it (can be set per map as lighting option)
 smooth-lighting: true
 
+# Optional - use world provider lighting table (good for custom worlds with custom lighting curves, like nether)
+#   false=classic Dynmap lighting curve
+use-brightness-table: true
+
+# Optional - render specific block IDs using the texures and models of another block ID: can be used to hide/disguise specific
+#  blocks (e.g. make ores look like stone, hide chests) or to provide simple support for rendering unsupported custom blocks
+block-id-alias:
+#    "14": 1
+#    "15": 1
+#    "16": 1
+  
 # Default image format for HDMaps (png, jpg, jpg-q75, jpg-q80, jpg-q85, jpg-q90, jpg-q95, jpg-q100)
 # Has no effect on maps with explicit format settings
 image-format: png
@@ -233,7 +276,7 @@ custom-colors-support: true
 #refreshskins: false
 
 # Customize URL used for fetching player skins (%player% is macro for name)
-skin-url: "http://s3.amazonaws.com/MinecraftSkins/%player%.png"
+skin-url: "http://skins.minecraft.net/MinecraftSkins/%player%.png"
 
 # Control behavior for new (1.0+) compass orientation (sunrise moved 90 degrees: east is now what used to be south)
 #   default is 'newrose' (preserve pre-1.0 maps, rotate rose)
@@ -268,8 +311,12 @@ tilespath: web/tiles
 # The path where the web-files are located.
 webpath: web
 
+# The path were the /dynmapexp command exports OBJ ZIP files
+exportpath: export
+
 # The network-interface the webserver will bind to (0.0.0.0 for all interfaces, 127.0.0.1 for only local access).
-webserver-bindaddress: 0.0.0.0
+# If not set, uses same setting as server in server.properties (or 0.0.0.0 if not specified)
+#webserver-bindaddress: 0.0.0.0
 
 # The TCP-port the webserver will listen on.
 webserver-port: 8123
@@ -305,14 +352,29 @@ progressloginterval: 100
 # Interval the browser should poll for updates.
 updaterate: 2000
 
-# If nonzero, server will pause fullrender/radiusrender processing when 'fullrenderplayerlimit' or more user's are logged in
+# If nonzero, server will pause fullrender/radiusrender processing when 'fullrenderplayerlimit' or more users are logged in
 fullrenderplayerlimit: 0
+# If nonzero, server will pause update render processing when 'updateplayerlimit' or more users are logged in
+updateplayerlimit: 0
+# Target limit on server thread use - msec per tick
+per-tick-time-limit: 50
+# If TPS of server is below this setting, update renders processing is paused
+update-min-tps: 18.0
+# If TPS of server is below this setting, full/radius renders processing is paused
+fullrender-min-tps: 18.0
+# If TPS of server is below this setting, zoom out processing is paused
+zoomout-min-tps: 18.0
 
 showplayerfacesinmenu: true
 
 # Control whether players that are hidden or not on current map are grayed out (true=yes)
 grayplayerswhenhidden: true
 
+# Use player permissions to order player list: first to last, players are ordered by first permission listed that they have
+# That is, anyone with first listed permission goes before anyone with second, etc, with users with none of the nodes going last
+player-sort-permission-nodes:
+  - bukkit.command.op
+  
 # Set sidebaropened: 'true' to pin menu sidebar opened permanently, 'pinned' to default the sidebar to pinned, but allow it to unpin
 #sidebaropened: true
 
@@ -354,12 +416,17 @@ persist-ids-by-ip: true
 # If true, map text to cyrillic
 cyrillic-support: false
 
+# If true, coordinates will be rounded
+round-coordinates: true
+
 # Messages to customize
 msg:
     maptypes: "Map Types"
     players: "Players"
     chatrequireslogin: "Chat Requires Login"
     chatnotallowed: "You are not permitted to send chat messages"
+    hiddennamejoin: "Player joined"
+    hiddennamequit: "Player quit"
 
 # URL for client configuration (only need to be tailored for proxies or other non-standard configurations)
 url:
@@ -394,6 +461,11 @@ custom-commands:
         preupdatecommand: ""
         # Command run just after any image file is written or updated: run with single parameter with fully qualified file name
         postupdatecommand: ""
+
+# Snapshot cache size, in chunks
+snapshotcachesize: 500
+# Snapshot cache uses soft references (true), else weak references (false)
+soft-ref-cache: true
         
 # Set to true to enable verbose startup messages - can help with debugging map configuration problems
 # Set to false for a much quieter startup log
@@ -402,3 +474,5 @@ verbose: false
 # Enables debugging.
 #debuggers:
 #  - class: org.dynmap.debug.LogDebugger
+# Debug: dump blocks missing render data
+dump-missing-blocks: false

src/main/resources/plugin.yml

@@ -3,7 +3,7 @@ main: org.dynmap.bukkit.DynmapPlugin
 version: "${project.version}-${BUILD_NUMBER}"
 authors: [mikeprimm]
 website: "http://www.minecraftforum.net/topic/1543523-dynmap-dynamic-web-based-maps-for-minecraft/"
-softdepend: [ Permissions, PermissionEx, bPermissions, PermissionsBukkit ]
+softdepend: [ Permissions, PermissionEx, bPermissions, PermissionsBukkit, GroupManager ]
 commands:
   dynmap:
     description: Controls Dynmap.
@@ -30,8 +30,12 @@ commands:
            /<command> resetstats - Reset render statistics.
            /<command> sendtoweb msg - Send message to web users
            /<command> purgequeue - Set tile update queue to empty
+           /<command> purgequeue worldname - Set tile update queue to empty for world 'worldname'
+           /<command> purgemap worldname mapname - Delete all the tiles for map 'mapname' of world 'worldname'
+           /<command> purgeworld worldname - Delete all the files for world 'worldname'
            /<command> pause - Show render pause state
            /<command> pause <all|none|full|update> - Set render pause state
+           /<command> quiet - Stop progress messages from active jobs
            /<command> ids-for-ip <ipaddress> - Show player IDs that have logged in from given IP address
            /<command> ips-for-id <playerid> - Show IP addresses that have been used for the given player ID
            /<command> add-id-for-ip <playerid> <ipaddress> - Add player ID to given IP address
@@ -87,6 +91,17 @@ commands:
            /<command> listcircles - list details of all circles
            /<command> updatecircle <label> <arg>:<value> ... - update attributes of circle with given label
            /<command> updatecircle id:<id> <arg>:<value> ... - update attributes of circle with given ID
+           /<command> getdesc id:<id> type:<icon|area|circle|line> - get description for marker with given ID
+           /<command> getdesc <label> type:<icon|area|circle|line> - get description for marker with given label
+           /<command> resetdesc id:<id> type:<icon|area|circle|line> - clear description for marker with given ID
+           /<command> resetdesc <label> type:<icon|area|circle|line> - clear description for marker with given label
+           /<command> appenddesc id:<id> type:<icon|area|circle|line> desc:"text" - append text line to description for marker with given ID
+           /<command> appenddesc <label> type:<icon|area|circle|line> desc:"text" - append text line to description for marker with given label
+           /<command> importdesc id:<id> type:<icon|area|circle|line> file:<filename> - import description from given file for marker with given ID
+           /<command> importdesc <label> type:<icon|area|circle|line> file:<filename> - import description from given file for marker with given label
+           /<command> importlabel id:<id> type:<icon|area|circle|line> file:<filename> - import label with markup from given file for marker with given ID
+           /<command> importlabel <label> type:<icon|area|circle|line> file:<filename> - import label with markup from given file for marker with given label
+           /<command> getlabel id:<id> type:<icon|area|circle|line> - get label for marker with given ID
            
   dmap:
     description: List and modify dynmap configuration
@@ -101,6 +116,10 @@ commands:
            /<command> mapset worldname:mapname attrib:value attrib:value - update given map on given world with given attributes
            /<command> worldreset worldname - reset given world to default template for world type
            /<command> worldreset worldname templatename - reset given world to given template
+  dynmapexp:
+    description: Map export commands
+    usage: |
+           /<command> shader <shadername> - Export material library for shader <shadername>
            
 permissions:
   dynmap.*:
@@ -120,6 +139,9 @@ permissions:
       dynmap.resetstats: true
       dynmap.sendtoweb: true
       dynmap.purgequeue: true
+      dynmap.purgemap: true
+      dynmap.purgeworld: true
+      dynmap.quiet: true
       dynmap.ids-for-ip: true
       dynmap.ips-for-id: true
       dynmap.webregister: true
@@ -147,6 +169,12 @@ permissions:
       dynmap.marker.updatecircle: true
       dynmap.marker.listcircles: true
       dynmap.marker.deletecircle: true
+      dynmap.marker.getdesc: true
+      dynmap.marker.resetdesc: true
+      dynmap.marker.appenddesc: true
+      dynmap.marker.importdesc: true
+      dynmap.marker.getlabel: true
+      dynmap.marker.importlabel: true
       dynmap.dmap.worldlist: true
       dynmap.dmap.worldset: true
       dynmap.dmap.worldreset: true
@@ -199,9 +227,18 @@ permissions:
   dynmap.purgequeue:
     description: Allows /dynmap purgequeue
     default: op
+  dynmap.purgemap:
+    description: Allows /dynmap purgemap
+    default: op
+  dynmap.purgeworld:
+    description: Allows /dynmap purgeworld
+    default: op
   dynmap.pause:
     description: Allows /dynmap pause
     default: op
+  dynmap.quiet:
+    description: Allows /dynmap quiet
+    default: true
   dynmap.ids-for-ip:
     description: Allows /dynmap ids-for-ip
     default: op
@@ -211,7 +248,7 @@ permissions:
   dynmap.webregister:
     description: Allows /dynmap webregister
     default: true
-  dynmao,webregister.other:
+  dynmap.webregister.other:
     description: Allows /dynmap webregister userid
     default: op
   dynmap.marker.add:
@@ -292,6 +329,24 @@ permissions:
   dynmap.marker.deletecircle:
     description: Allows /dmarker deletecircle
     default: op
+  dynmap.marker.getdesc:
+    description: Allows /dmarker getdesc
+    default: op
+  dynmap.marker.resetdesc:
+    description: Allows /dmarker resetdesc
+    default: op
+  dynmap.marker.appenddesc:
+    description: Allows /dmarker appenddesc
+    default: op
+  dynmap.marker.importdesc:
+    description: Allows /dmarker importdesc
+    default: op
+  dynmap.marker.getlabel:
+    description: Allows /dmarker getlabel
+    default: op
+  dynmap.marker.importlabel:
+    description: Allows /dmarker importlabel
+    default: op
   dynmap.dmap.worldlist:
     description: Allows /dmap worldlist
     default: op