Prepare for 2.0.0. release

Add option to round coordinates to nearest integer

pom.xml

@@ -1,11 +1,12 @@
-<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>	
+		<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${timestamp}</BUILD_NUMBER>
 	</properties>
@@ -43,7 +44,7 @@
 					<target>1.6</target>
 				</configuration>
 			</plugin>
-			
+
 			<plugin>
 				<groupId>org.apache.maven.plugins</groupId>
 				<artifactId>maven-shade-plugin</artifactId>
@@ -57,14 +58,41 @@
 						<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>
@@ -97,19 +125,15 @@
 			<version>1.4.7-R1.0</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>
@@ -138,5 +162,5 @@
 			<version>2.10.1</version>
 		</dependency>
 	</dependencies>
-	<version>1.9.2</version>
+	<version>2.0.0</version>
 </project>

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

@@ -5,11 +5,13 @@ 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;
 
 /**
@@ -21,6 +23,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 +38,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 +71,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 +86,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 +135,12 @@ 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 int getHealth(Player p);
 }

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

@@ -47,7 +47,7 @@ public class BukkitVersionHelperCB extends BukkitVersionHelperGeneric {
         nmsmaterial = getNMSClass("net.minecraft.server.Material");
         blockbyid = getFieldNoFail(nmsblock, new String[] { "byId" }, nmsblockarray);
         if (blockbyid == null) {
-            blockbyidfunc = getMethod(nmsblock, new String[] { "e" }, new Class[] { int.class });
+            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);
@@ -81,7 +81,11 @@ 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_tileentities = getField(nmschunk, new String[] { "tileEntities" }, Map.class);
+        nmsc_inhabitedticks = getFieldNoFail(nmschunk, new String[] { "s", "q" }, long.class);
+        if (nmsc_inhabitedticks == null) {
+            Log.info("inhabitedTicks field not found - inhabited shader not functional");
+        }
         /** nbt classes */
         nbttagcompound = getNMSClass("net.minecraft.server.NBTTagCompound");
         nbttagbyte = getNMSClass("net.minecraft.server.NBTTagByte");

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;
 
 /**
@@ -51,6 +55,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 +83,10 @@ public abstract class BukkitVersionHelperGeneric extends BukkitVersionHelper {
     protected Field nmst_x;
     protected Field nmst_y;
     protected Field nmst_z;
+    /** Server */
+    protected Method server_getonlineplayers;
+    /** Player */
+    protected Method player_gethealth;
 
     BukkitVersionHelperGeneric() {
         failed = false;
@@ -98,6 +107,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();
@@ -254,13 +269,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 +293,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 +306,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);
@@ -369,4 +399,31 @@ 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
+     */
+    public int 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 int getHealth(Player p) {
+        return p.getHealth();
+    }
+
+}

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

@@ -36,6 +36,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

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

@@ -2,6 +2,7 @@ package org.dynmap.bukkit;
 
 import java.io.File;
 import java.io.IOException;
+import java.io.InputStream;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.InetSocketAddress;
@@ -217,10 +218,7 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
     /**
      * Server access abstraction class
      */
-    public class BukkitServer implements DynmapServerInterface {
-        /* Chunk load handling */
-        private Object loadlock = new Object();
-
+    public class BukkitServer extends DynmapServerInterface {
         @Override
         public int getBlockIDAt(String wname, int x, int y, int z) {
             World w = getServer().getWorld(wname);
@@ -236,7 +234,7 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
         }
         @Override
         public DynmapPlayer[] getOnlinePlayers() {
-            Player[] players = getServer().getOnlinePlayers();
+            Player[] players = helper.getOnlinePlayers();
             DynmapPlayer[] dplay = new DynmapPlayer[players.length];
             for(int i = 0; i < players.length; i++)
                 dplay[i] = new BukkitPlayer(players[i]);
@@ -345,7 +343,7 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
                     break;
                 case SIGN_CHANGE:
                     pm.registerEvents(new Listener() {
-                        @EventHandler(priority=EventPriority.MONITOR, ignoreCancelled=true)
+                        @EventHandler(priority=EventPriority.HIGHEST, ignoreCancelled=true)
                         public void onSignChange(SignChangeEvent evt) {
                             Block b = evt.getBlock();
                             Location l = b.getLocation();
@@ -462,20 +460,18 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
                     public Boolean call() throws Exception {
                         boolean exhausted = true;
                         
-                        synchronized(loadlock) {
-                            if (prev_tick != cur_tick) {
-                                prev_tick = cur_tick;
-                                cur_tick_starttime = System.nanoTime();
-                            }                            
-                            if(chunks_in_cur_tick > 0) {
-                                boolean done = false;
-                                while (!done) {
-                                    int cnt = chunks_in_cur_tick;
-                                    if (cnt > 5) cnt = 5;
-                                    chunks_in_cur_tick -= cc.loadChunks(cnt);
-                                    exhausted = (chunks_in_cur_tick == 0) || ((System.nanoTime() - cur_tick_starttime) > perTickLimit);
-                                    done = exhausted || cc.isDoneLoading();
-                                }
+                        if (prev_tick != cur_tick) {
+                            prev_tick = cur_tick;
+                            cur_tick_starttime = System.nanoTime();
+                        }                            
+                        if(chunks_in_cur_tick > 0) {
+                            boolean done = false;
+                            while (!done) {
+                                int cnt = chunks_in_cur_tick;
+                                if (cnt > 5) cnt = 5;
+                                chunks_in_cur_tick -= cc.loadChunks(cnt);
+                                exhausted = (chunks_in_cur_tick == 0) || ((System.nanoTime() - cur_tick_starttime) > perTickLimit);
+                                done = exhausted || cc.isDoneLoading();
                             }
                         }
                         return exhausted;
@@ -511,7 +507,7 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
         }
         @Override
         public int getCurrentPlayers() {
-            return getServer().getOnlinePlayers().length;
+            return helper.getOnlinePlayers().length;
         }
         @Override
         public boolean isModLoaded(String name) {
@@ -559,14 +555,17 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
         public String getServerIP() {
             return Bukkit.getServer().getIp();
         }
-        @Override
-        public File getModContainerFile(String mod) {
-            return null;
-        }
 
         @Override
-        public List<String> getModList() {
-            return Collections.emptyList();
+        public Map<Integer, String> getBlockIDMap() {
+            String[] bsn = helper.getBlockShortNames();
+            HashMap<Integer, String> map = new HashMap<Integer, String>();
+            for (int i = 0; i < bsn.length; i++) {
+                if (bsn[i] != null) {
+                    map.put(i, bsn[i]);
+                }
+            }
+            return map;
         }
     }
     /**
@@ -637,7 +636,7 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
         @Override
         public int getHealth() {
             if(player != null)
-                return player.getHealth();
+                return helper.getHealth(player);
             else
                 return 0;
         }
@@ -731,13 +730,15 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
         }
     }
     
-    public void loadExtraBiomes() {
+    public void loadExtraBiomes(String mcver) {
         int cnt = 0;
         
+        BiomeMap.loadWellKnownByVersion(mcver);
         /* Find array of biomes in biomebase */
         Object[] biomelist = helper.getBiomeBaseList();
-        /* Loop through list, starting afer well known biomes */
-        for(int i = BiomeMap.LAST_WELL_KNOWN+1; i < biomelist.length; i++) {
+        /* Loop through list, skipping well known biomes */
+        for(int i = 0; i < biomelist.length; i++) {
+            if (!BiomeMap.byBiomeID(i).isDefault()) continue;
             Object bb = biomelist[i];
             if(bb != null) {
                 String id =  helper.getBiomeBaseIDString(bb);
@@ -776,8 +777,18 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
         PluginDescriptionFile pdfFile = this.getDescription();
         version = pdfFile.getVersion();
 
+        /* Get MC version */
+        String bukkitver = getServer().getVersion();
+        String mcver = "1.0.0";
+        int idx = bukkitver.indexOf("(MC: ");
+        if(idx > 0) {
+            mcver = bukkitver.substring(idx+5);
+            idx = mcver.indexOf(")");
+            if(idx > 0) mcver = mcver.substring(0, idx);
+        }
+
         /* Load extra biomes, if any */
-        loadExtraBiomes();
+        loadExtraBiomes(mcver);
              
         /* Set up player login/quit event handler */
         registerPlayerLoginListener();
@@ -806,17 +817,7 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
         File dataDirectory = this.getDataFolder();
         if(dataDirectory.exists() == false)
             dataDirectory.mkdirs();
- 
-        /* Get MC version */
-        String bukkitver = getServer().getVersion();
-        String mcver = "1.0.0";
-        int idx = bukkitver.indexOf("(MC: ");
-        if(idx > 0) {
-            mcver = bukkitver.substring(idx+5);
-            idx = mcver.indexOf(")");
-            if(idx > 0) mcver = mcver.substring(0, idx);
-        }
-        
+         
         /* Instantiate core */
         if(core == null)
             core = new DynmapCore();
@@ -1652,4 +1653,9 @@ public class DynmapPlugin extends JavaPlugin implements DynmapAPI {
             // Failed to submit the stats :-(
         }
     }
+    @Override
+    public void processSignChange(int blkid, String world, int x, int y, int z,
+            String[] lines, String playerid) {
+        core.processSignChange(blkid, world, x, y, z, lines, playerid);
+    }
 }

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

@@ -27,7 +27,7 @@ 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;    
 
@@ -49,12 +49,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 +205,6 @@ public class NewMapChunkCache implements MapChunkCache {
             try {
                 return biomemap[x - x_base][z - z_base];
             } catch (Exception ex) {
-                exceptions++;
                 return BiomeMap.NULL;
             }
         }
@@ -240,7 +234,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 +264,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 +305,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 +332,6 @@ public class NewMapChunkCache implements MapChunkCache {
                 }
                 return ((raccum / 9) << 16) | ((gaccum / 9) << 8) | (baccum / 9);
             } catch (Exception x) {
-                exceptions++;
                 return 0xFFFFFF;
             }
         }
@@ -371,7 +361,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 +582,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 {
@@ -779,6 +776,7 @@ 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][];
     }
@@ -797,8 +795,7 @@ public class NewMapChunkCache implements MapChunkCache {
     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 +805,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 +827,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 +844,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 +871,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;
@@ -919,16 +922,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 +941,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 +968,6 @@ public class NewMapChunkCache implements MapChunkCache {
                     isempty = false;
             }
         }
-        total_loadtime += System.nanoTime() - t0;
 
         return cnt;
     }
@@ -987,6 +999,7 @@ public class NewMapChunkCache implements MapChunkCache {
                 snaparray[i] = null;
             }
             snaparray = null;
+            inhabitedTicks = null;
         }
     }
     private void initSectionData(int idx) {
@@ -1053,22 +1066,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

@@ -14,6 +14,7 @@ import org.dynmap.utils.DynIntHashMap;
 public class SnapshotCache {
     public static class SnapshotRec {
         public ChunkSnapshot ss;
+        public long inhabitedTicks;
         public DynIntHashMap tileData;
     };
 

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
   
@@ -86,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
@@ -219,6 +240,10 @@ 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:
@@ -284,6 +309,9 @@ 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).
 # 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
@@ -386,6 +414,9 @@ 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"
@@ -441,3 +472,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

@@ -116,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.*: