Fixed disable-webserver not being used (thanks for checking that Kilandor).

also the icon

assembly.xml

@@ -0,0 +1,34 @@
+<assembly xmlns="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/plugins/maven-assembly-plugin/assembly/1.1.0 http://maven.apache.org/xsd/assembly-1.1.0.xsd">
+  <id>build</id>
+  <includeBaseDirectory>false</includeBaseDirectory>
+  <formats>
+    <format>tar.bz2</format>
+    <format>zip</format>
+  </formats>
+  <fileSets>
+    <fileSet>
+      <directory>${project.basedir}</directory>
+      <outputDirectory>/</outputDirectory>
+      <includes>
+        <include>README*</include>
+        <include>LICENSE*</include>
+        <include>NOTICE*</include>
+        <include>LICENSE*</include>
+      </includes>
+    </fileSet>
+    <fileSet>
+      <directory>${project.basedir}/web</directory>
+      <outputDirectory>/dynmap/web</outputDirectory>
+    </fileSet>
+    <fileSet>
+    	<directory>${project.basedir}</directory>
+    	<outputDirectory>/dynmap/</outputDirectory>
+    	<includes>
+    		<include>configuration.txt</include></includes></fileSet>
+  </fileSets>
+  <files>
+  	<file>
+  		<source>${project.build.directory}/${artifactId}-${version}.jar</source>
+  		<outputDirectory>/</outputDirectory>
+  		<destName>dynmap.jar</destName></file></files>
+</assembly>

configuration.txt

@@ -1,49 +1,101 @@
-# All paths in this configuration file are relative to Dynmap's data-folder: minecraft_server/plugins/dynmap/
-
-# How often a tile gets rendered (in seconds).
-renderinterval: 1
-
-# The path where the tile-files are placed.
-tilepath: web/tiles
-
-# The path where the web-files are located.
-webpath: web
-
-# 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
-
-# The TCP-port the webserver will listen on.
-webserver-port: 8123
-
-disabledcommands:
-  - fullrender
-
-# The maptypes Dynmap will use to render.
-maps:
-  - class: org.dynmap.kzedmap.KzedMap
-    renderers:
-      - class: org.dynmap.kzedmap.DefaultTileRenderer
-        prefix: t
-      - class: org.dynmap.kzedmap.CaveTileRenderer
-        prefix: ct
-
-web:
-    # Interval the browser should poll for updates.
-    updaterate: 2000
-    
-    showchatballoons: true
-    showplayerfacesonmap: true
-    showplayerfacesinmenu: true
-    focuschatballoons: false
-    
-    # The name of the map shown when opening Dynmap's page (must be in menu).
-    defaultmap: defaultmap
-    
-    # The maps shown in the menu.
-    shownmaps:
-      - type: KzedMapType
-        name: defaultmap
-        prefix: t
-      - type: KzedMapType
-        name: cavemap
-        prefix: ct
+# All paths in this configuration file are relative to Dynmap's data-folder: minecraft_server/plugins/dynmap/
+
+# How often a tile gets rendered (in seconds).
+renderinterval: 1
+
+# The path where the tile-files are placed.
+tilespath: web/tiles
+
+# The path where the web-files are located.
+webpath: web
+
+# 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
+
+# The TCP-port the webserver will listen on.
+webserver-port: 8123
+
+# Disables Webserver portion of Dynmap (Advanced users only)
+disable-webserver: false
+
+# Writes JSON to file in the webpath
+jsonfile: false
+
+# How often the json file gets written to(in seconds)
+jsonfile-interval: 1
+
+# The maptypes Dynmap will use to render.
+worlds:
+  - name: world
+    maps:
+      - class: org.dynmap.kzedmap.KzedMap
+        renderers:
+          - class: org.dynmap.kzedmap.DefaultTileRenderer
+            prefix: t
+            maximumheight: 127
+          - class: org.dynmap.kzedmap.CaveTileRenderer
+            prefix: ct
+            maximumheight: 127
+  - name: nether
+    maps:
+      - class: org.dynmap.kzedmap.KzedMap
+        renderers:
+          - class: org.dynmap.kzedmap.DefaultTileRenderer
+            prefix: nt
+            maximumheight: 64
+
+web:
+    # Handles the clientside updates differently only enable if using jsonfile
+    jsonfile: false
+
+    # Interval the browser should poll for updates.
+    updaterate: 2000
+    
+    # showchat: modal/balloons
+    showchat: modal
+    messagettl: 15000
+        
+    showplayerfacesonmap: true
+    showplayerfacesinmenu: true
+    focuschatballoons: false
+    joinmessage: "%playername% joined"
+    quitmessage: "%playername% quit"
+    
+    defaultworld: world
+    worlds:
+      - title: World
+        name: world
+        maps:
+          - type: KzedMapType
+            title: Surface
+            name: surface
+            prefix: t
+          - type: KzedMapType
+            title: Cave
+            name: cave
+            prefix: ct
+      - title: Nether
+        name: nether
+        maps:
+          - type: KzedMapType
+            title: Surface
+            name: nether
+            prefix: nt
+      # Example:
+      #- title: Other World           # With what name the world is displayed.
+      #  name: world_other            # The actual name of the world (equal to your directory-name).
+      #  maps:
+      #    - type: KzedMapType        # The type (or perspective) of the map. At the moment, there are no others than KzedMapType.
+      #      title: Surface           # The name of the map that will be displayed.
+      #      name: surface            # The actual name of the map (should be unique for this world).
+      #      prefix: t                # The prefix of the tile-files that are generated.
+      #      icon: block_other.png    # Sets a custom icon for the map. (optional)
+      #    - type: KzedMapType
+      #      title: Cave
+      #      name: cave
+      #      prefix: ct
+
+# Enables debugging.
+#debuggers:
+#  - class: org.dynmap.debug.LogDebugger
+#  - class: org.dynmap.debug.BukkitPlayerDebugger

pom.xml

@@ -1,8 +1,8 @@
 <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.bukkit</groupId>
-  <artifactId>dynamic-map</artifactId>
-  <version>0.0.1-SNAPSHOT</version>
+  <artifactId>dynmap</artifactId>
+  <version>0.13</version>
   <name>DynamicMap</name>
   <url>http://www.bukkit.org</url>
   <build>
@@ -16,7 +16,24 @@
                   <target>1.6</target>
               </configuration>
           </plugin>
-      </plugins>
+          <plugin>
+				<artifactId>maven-assembly-plugin</artifactId>
+				<configuration>
+    				<descriptors>
+        				<descriptor>assembly.xml</descriptor>
+    				</descriptors>
+				</configuration>
+				<executions>
+   					<execution>
+       					<id>build</id>
+        				<phase>package</phase>
+        				<goals>
+            				<goal>single</goal>
+        				</goals>
+    				</execution>
+				</executions>
+			</plugin>
+      	</plugins>
   </build>
   <dependencies>
   	<dependency>

src/main/java/org/dynmap/AsynchronousQueue.java

@@ -0,0 +1,108 @@
+package org.dynmap;
+
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.NoSuchElementException;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+public class AsynchronousQueue<T> {
+    protected static final Logger log = Logger.getLogger("Minecraft");
+
+    private Object lock = new Object();
+    private Thread thread;
+    private LinkedList<T> queue = new LinkedList<T>();
+    private Set<T> set = new HashSet<T>();
+    private Handler<T> handler;
+    private int dequeueTime;
+
+    public AsynchronousQueue(Handler<T> handler, int dequeueTime) {
+        this.handler = handler;
+        this.dequeueTime = dequeueTime;
+    }
+
+    public boolean push(T t) {
+        synchronized (lock) {
+            if (set.add(t)) {
+                queue.addLast(t);
+                return true;
+            }
+            return false;
+        }
+    }
+
+    private T pop() {
+        synchronized (lock) {
+            try {
+                T t = queue.removeFirst();
+                if (!set.remove(t)) {
+                    // This should never happen.
+                }
+                return t;
+            } catch (NoSuchElementException e) {
+                return null;
+            }
+        }
+    }
+
+    public int size() {
+        return set.size();
+    }
+
+    public void start() {
+        synchronized (lock) {
+            thread = new Thread(new Runnable() {
+                @Override
+                public void run() {
+                    running();
+                }
+            });
+            thread.start();
+            try {
+                thread.setPriority(Thread.MIN_PRIORITY);
+            } catch (SecurityException e) {
+                log.info("Failed to set minimum priority for worker thread!");
+            }
+        }
+    }
+
+    public void stop() {
+        synchronized (lock) {
+            if (thread == null)
+                return;
+            Thread oldThread = thread;
+            thread = null;
+
+            log.info("Stopping map renderer...");
+
+            try {
+                oldThread.join();
+            } catch (InterruptedException e) {
+                log.info("Waiting for map renderer to stop is interrupted");
+            }
+        }
+    }
+
+    private void running() {
+        try {
+            while (Thread.currentThread() == thread) {
+                T t = pop();
+                if (t != null) {
+                    handler.handle(t);
+                }
+                sleep(dequeueTime);
+            }
+
+        } catch (Exception ex) {
+            log.log(Level.SEVERE, "Exception on rendering-thread", ex);
+        }
+    }
+
+    private void sleep(int time) {
+        try {
+            Thread.sleep(time);
+        } catch (InterruptedException e) {
+        }
+    }
+}

src/main/java/org/dynmap/Client.java

@@ -11,17 +11,23 @@ public class Client {
     public static class Player {
         public String type = "player";
         public String name;
+        public String world;
         public double x, y, z;
 
-        public Player(String name, double x, double y, double z) {
+        public Player(String name, String world, double x, double y, double z) {
             this.name = name;
+            this.world = world;
             this.x = x;
             this.y = y;
             this.z = z;
         }
     }
 
-    public static class ChatMessage {
+    public static class Stamped {
+        public long timestamp = System.currentTimeMillis();
+    }
+    
+    public static class ChatMessage extends Stamped {
         public String type = "chat";
         public String playerName;
         public String message;
@@ -31,8 +37,19 @@ public class Client {
             this.message = message;
         }
     }
+    
+    public static class WebChatMessage extends Stamped {
+        public String type = "webchat";
+        public String playerName;
+        public String message;
 
-    public static class Tile {
+        public WebChatMessage(String playerName, String message) {
+            this.playerName = playerName;
+            this.message = message;
+        }
+    }
+
+    public static class Tile extends Stamped {
         public String type = "tile";
         public String name;
 

src/main/java/org/dynmap/DynmapBlockListener.java

@@ -16,13 +16,13 @@ public class DynmapBlockListener extends BlockListener {
     @Override
     public void onBlockPlace(BlockPlaceEvent event) {
         Block blockPlaced = event.getBlockPlaced();
-        mgr.touch(blockPlaced.getX(), blockPlaced.getY(), blockPlaced.getZ());
+        mgr.touch(blockPlaced.getLocation());
     }
 
     public void onBlockDamage(BlockDamageEvent event) {
         if (event.getDamageLevel() == BlockDamageLevel.BROKEN) {
             Block blockBroken = event.getBlock();
-            mgr.touch(blockBroken.getX(), blockBroken.getY(), blockBroken.getZ());
+            mgr.touch(blockBroken.getLocation());
         }
     }
 }

src/main/java/org/dynmap/DynmapPlayerListener.java

@@ -1,71 +1,33 @@
 package org.dynmap;
 
-import org.bukkit.entity.Player;
 import org.bukkit.event.player.PlayerChatEvent;
+import org.bukkit.event.player.PlayerEvent;
 import org.bukkit.event.player.PlayerListener;
-import org.bukkit.util.config.ConfigurationNode;
 
 public class DynmapPlayerListener extends PlayerListener {
-    private MapManager mgr;
-    private PlayerList playerList;
-    private ConfigurationNode configuration;
+    DynmapPlugin plugin;
 
-    public DynmapPlayerListener(MapManager mgr, PlayerList playerList, ConfigurationNode configuration) {
-        this.mgr = mgr;
-        this.playerList = playerList;
-        this.configuration = configuration;
+    public DynmapPlayerListener(DynmapPlugin plugin) {
+        this.plugin = plugin;
     }
 
     @Override
-    public void onPlayerCommand(PlayerChatEvent event) {
-        String[] split = event.getMessage().split(" ");
-        if (split[0].equalsIgnoreCase("/dynmap")) {
-            if (split.length > 1) {
-                if (configuration.getProperty("disabledcommands") instanceof Iterable<?>) {
-                    for(String s : (Iterable<String>)configuration.getProperty("disabledcommands")) {
-                        if (split[1].equals(s)) {
-                            return;
-                        }
-                    }
-                }
-                
-                if (split[1].equals("render")) {
-                    Player player = event.getPlayer();
-                    mgr.touch(player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ());
-                    event.setCancelled(true);
-                } else if (split[1].equals("hide")) {
-                    if (split.length == 2) {
-                        playerList.hide(event.getPlayer().getName());
-                    } else {
-                        for (int i = 2; i < split.length; i++) {
-                            playerList.hide(split[i]);
-                        }
-                    }
-                    event.setCancelled(true);
-                } else if (split[1].equals("show")) {
-                    if (split.length == 2) {
-                        playerList.show(event.getPlayer().getName());
-                    } else {
-                        for (int i = 2; i < split.length; i++) {
-                            playerList.show(split[i]);
-                        }
-                    }
-                    event.setCancelled(true);
-                } else if (split[1].equals("fullrender")) {
-                    Player player = event.getPlayer();
-                    mgr.renderFullWorld(player.getLocation());
-                }
-            }
-        }
+    public void onPlayerChat(PlayerChatEvent event) {
+        plugin.mapManager.pushUpdate(new Client.ChatMessage(event.getPlayer().getName(), event.getMessage()));
     }
 
-    /**
-     * Called when a player sends a chat message
-     * 
-     * @param event
-     *            Relevant event details
-     */
-    public void onPlayerChat(PlayerChatEvent event) {
-        mgr.updateQueue.pushUpdate(new Client.ChatMessage(event.getPlayer().getName(), event.getMessage()));
+    @Override
+    public void onPlayerJoin(PlayerEvent event) {
+        String joinMessage = plugin.configuration.getString("joinmessage", "%playername% joined");
+        joinMessage = joinMessage.replaceAll("%playername%", event.getPlayer().getName());
+        plugin.mapManager.pushUpdate(new Client.ChatMessage("Server", joinMessage));
     }
+
+    @Override
+    public void onPlayerQuit(PlayerEvent event) {
+        String quitMessage = plugin.configuration.getString("quitmessage", "%playername% quit");
+        quitMessage = quitMessage.replaceAll("%playername%", event.getPlayer().getName());
+        plugin.mapManager.pushUpdate(new Client.ChatMessage("Server", quitMessage));
+    }
+
 }

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

@@ -1,45 +1,53 @@
 package org.dynmap;
 
 import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileNotFoundException;
 import java.io.IOException;
+import java.lang.reflect.Constructor;
 import java.net.InetAddress;
 import java.net.UnknownHostException;
+import java.util.List;
 import java.util.Map;
 import java.util.logging.Logger;
+import java.util.Timer;
 
-import org.bukkit.Server;
+import org.bukkit.Location;
 import org.bukkit.World;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
 import org.bukkit.event.Event;
 import org.bukkit.event.Event.Priority;
 import org.bukkit.event.block.BlockListener;
 import org.bukkit.event.player.PlayerListener;
-import org.bukkit.plugin.PluginDescriptionFile;
-import org.bukkit.plugin.PluginLoader;
+import org.bukkit.event.world.WorldEvent;
+import org.bukkit.event.world.WorldListener;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.bukkit.util.config.Configuration;
-import org.dynmap.debug.BukkitPlayerDebugger;
+import org.dynmap.Event.Listener;
+import org.dynmap.debug.Debug;
+import org.dynmap.debug.Debugger;
 import org.dynmap.web.HttpServer;
 import org.dynmap.web.handlers.ClientConfigurationHandler;
 import org.dynmap.web.handlers.ClientUpdateHandler;
 import org.dynmap.web.handlers.FilesystemHandler;
+import org.dynmap.web.handlers.SendMessageHandler;
+import org.dynmap.web.handlers.SendMessageHandler.Message;
+import org.dynmap.web.Json;
 
 public class DynmapPlugin extends JavaPlugin {
 
     protected static final Logger log = Logger.getLogger("Minecraft");
 
-    private HttpServer webServer = null;
-    private MapManager mapManager = null;
-    private PlayerList playerList;
-    private Configuration configuration;
+    public HttpServer webServer = null;
+    public MapManager mapManager = null;
+    public PlayerList playerList;
+    public Configuration configuration;
 
-    private BukkitPlayerDebugger debugger = new BukkitPlayerDebugger(this);
+    public Timer timer;
 
-    public static File dataRoot;
-
-    public DynmapPlugin(PluginLoader pluginLoader, Server instance, PluginDescriptionFile desc, File folder, File plugin, ClassLoader cLoader) {
-        super(pluginLoader, instance, desc, folder, plugin, cLoader);
-        dataRoot = folder;
-    }
+    public static File tilesDirectory;
 
     public World getWorld() {
         return getServer().getWorlds().get(0);
@@ -57,13 +65,32 @@ public class DynmapPlugin extends JavaPlugin {
         configuration = new Configuration(new File(this.getDataFolder(), "configuration.txt"));
         configuration.load();
 
-        debugger.enable();
-        playerList = new PlayerList(getServer());
+        loadDebuggers();
+
+        tilesDirectory = getFile(configuration.getString("tilespath", "web/tiles"));
+        tilesDirectory.mkdirs();
+
+        playerList = new PlayerList(getServer(), getFile("hiddenplayers.txt"));
         playerList.load();
 
-        mapManager = new MapManager(getWorld(), debugger, configuration);
-        mapManager.startManager();
+        mapManager = new MapManager(this, configuration);
+        mapManager.startRendering();
 
+        if (!configuration.getBoolean("disable-webserver", false)) {
+            loadWebserver();
+        }
+
+        if (configuration.getBoolean("jsonfile", false)) {
+            jsonConfig();
+            int jsonInterval = configuration.getInt("jsonfile-interval", 1) * 1000;
+            timer = new Timer();
+            timer.scheduleAtFixedRate(new JsonTimerTask(this, configuration), jsonInterval, jsonInterval);
+        }
+
+        registerEvents();
+    }
+
+    public void loadWebserver() {
         InetAddress bindAddress;
         {
             String address = configuration.getString("webserver-bindaddress", "0.0.0.0");
@@ -78,37 +105,175 @@ public class DynmapPlugin extends JavaPlugin {
         int port = configuration.getInt("webserver-port", 8123);
 
         webServer = new HttpServer(bindAddress, port);
-        webServer.handlers.put("/", new FilesystemHandler(mapManager.webDirectory));
-        webServer.handlers.put("/tiles/", new FilesystemHandler(mapManager.tileDirectory));
-        webServer.handlers.put("/up/", new ClientUpdateHandler(mapManager, playerList, getWorld()));
+        webServer.handlers.put("/", new FilesystemHandler(getFile(configuration.getString("webpath", "web"))));
+        webServer.handlers.put("/tiles/", new FilesystemHandler(tilesDirectory));
+        webServer.handlers.put("/up/", new ClientUpdateHandler(mapManager, playerList, getServer()));
         webServer.handlers.put("/up/configuration", new ClientConfigurationHandler((Map<?, ?>) configuration.getProperty("web")));
 
+        SendMessageHandler messageHandler = new SendMessageHandler();
+        messageHandler.onMessageReceived.addListener(new Listener<SendMessageHandler.Message>() {
+            @Override
+            public void triggered(Message t) {
+                mapManager.pushUpdate(new Client.WebChatMessage(t.name, t.message));
+                log.info("[WEB]" + t.name + ": " + t.message);
+                getServer().broadcastMessage("[WEB]" + t.name + ": " + t.message);
+            }
+        });
+        webServer.handlers.put("/up/sendmessage", messageHandler);
+
         try {
             webServer.startServer();
         } catch (IOException e) {
             log.severe("Failed to start WebServer on " + bindAddress + ":" + port + "!");
         }
-
-        registerEvents();
     }
 
     public void onDisable() {
-        mapManager.stopManager();
+        mapManager.stopRendering();
 
         if (webServer != null) {
             webServer.shutdown();
             webServer = null;
         }
-        debugger.disable();
+
+        if (timer != null) {
+            timer.cancel();
+        }
+
+        Debug.clearDebuggers();
     }
 
     public void registerEvents() {
         BlockListener blockListener = new DynmapBlockListener(mapManager);
-        getServer().getPluginManager().registerEvent(Event.Type.BLOCK_PLACED, blockListener, Priority.Normal, this);
-        getServer().getPluginManager().registerEvent(Event.Type.BLOCK_DAMAGED, blockListener, Priority.Normal, this);
+        getServer().getPluginManager().registerEvent(Event.Type.BLOCK_PLACED, blockListener, Priority.Monitor, this);
+        getServer().getPluginManager().registerEvent(Event.Type.BLOCK_DAMAGED, blockListener, Priority.Monitor, this);
 
-        PlayerListener playerListener = new DynmapPlayerListener(mapManager, playerList, configuration);
-        getServer().getPluginManager().registerEvent(Event.Type.PLAYER_COMMAND, playerListener, Priority.Normal, this);
+        WorldListener worldListener = new WorldListener() {
+            @Override
+            public void onWorldLoaded(WorldEvent event) {
+                mapManager.activateWorld(event.getWorld());
+            }
+        };
+        getServer().getPluginManager().registerEvent(Event.Type.WORLD_LOADED, worldListener, Priority.Monitor, this);
+
+        PlayerListener playerListener = new DynmapPlayerListener(this);
+        //getServer().getPluginManager().registerEvent(Event.Type.PLAYER_COMMAND, playerListener, Priority.Normal, this);
         getServer().getPluginManager().registerEvent(Event.Type.PLAYER_CHAT, playerListener, Priority.Normal, this);
+        getServer().getPluginManager().registerEvent(Event.Type.PLAYER_LOGIN, playerListener, Priority.Normal, this);
+        getServer().getPluginManager().registerEvent(Event.Type.PLAYER_JOIN, playerListener, Priority.Normal, this);
+        getServer().getPluginManager().registerEvent(Event.Type.PLAYER_QUIT, playerListener, Priority.Normal, this);
+    }
+
+    private static File combinePaths(File parent, String path) {
+        return combinePaths(parent, new File(path));
+    }
+
+    private static File combinePaths(File parent, File path) {
+        if (path.isAbsolute())
+            return path;
+        return new File(parent, path.getPath());
+    }
+
+    public File getFile(String path) {
+        return combinePaths(getDataFolder(), path);
+    }
+
+    protected void loadDebuggers() {
+        Object debuggersConfiguration = configuration.getProperty("debuggers");
+        Debug.clearDebuggers();
+        if (debuggersConfiguration != null) {
+            for (Object debuggerConfiguration : (List<?>) debuggersConfiguration) {
+                Map<?, ?> debuggerConfigurationMap = (Map<?, ?>) debuggerConfiguration;
+                try {
+                    Class<?> debuggerClass = Class.forName((String) debuggerConfigurationMap.get("class"));
+                    Constructor<?> constructor = debuggerClass.getConstructor(JavaPlugin.class, Map.class);
+                    Debugger debugger = (Debugger) constructor.newInstance(this, debuggerConfigurationMap);
+                    Debug.addDebugger(debugger);
+                } catch (Exception e) {
+                    log.severe("Error loading debugger: " + e);
+                    e.printStackTrace();
+                    continue;
+                }
+
+            }
+        }
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command cmd, String commandLabel, String[] args) {
+        if (!cmd.getName().equalsIgnoreCase("dynmap"))
+            return false;
+        Player player = null;
+        if (sender instanceof Player)
+            player = (Player) sender;
+        if (args.length > 0) {
+            if (args[0].equals("render")) {
+                if (sender instanceof Player) {
+                    mapManager.touch(((Player) sender).getLocation());
+                    return true;
+                }
+            } else if (args[0].equals("hide")) {
+                if (args.length == 1 && player != null) {
+                    playerList.hide(player.getName());
+                    sender.sendMessage("You are now hidden on Dynmap.");
+                    return true;
+                } else {
+                    for (int i = 1; i < args.length; i++) {
+                        playerList.hide(args[i]);
+                        sender.sendMessage(args[i] + " is now hidden on Dynmap.");
+                    }
+                    return true;
+                }
+            } else if (args[0].equals("show")) {
+                if (args.length == 1 && player != null) {
+                    playerList.show(player.getName());
+                    sender.sendMessage("You are now visible on Dynmap.");
+                    return true;
+                } else {
+                    for (int i = 1; i < args.length; i++) {
+                        playerList.show(args[i]);
+                        sender.sendMessage(args[i] + " is now visible on Dynmap.");
+                    }
+                    return true;
+                }
+            } else if (args[0].equals("fullrender")) {
+                if (player == null || player.isOp()) {
+                    if (args.length > 2) {
+                        for (int i = 1; i < args.length; i++) {
+                            World w = getServer().getWorld(args[i]);
+                            mapManager.renderFullWorld(new Location(w, 0, 0, 0));
+                        }
+                        return true;
+                    } else if (player != null) {
+                        mapManager.renderFullWorld(player.getLocation());
+                        return true;
+                    }
+                } else if (player != null) {
+                    player.sendMessage("Only OPs are allowed to use this command!");
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private void jsonConfig() {
+        File outputFile;
+        Map<?, ?> clientConfig = (Map<?, ?>) configuration.getProperty("web");
+        File webpath = new File(configuration.getString("webpath", "web"), "dynmap_config.json");
+        if (webpath.isAbsolute())
+            outputFile = webpath;
+        else
+            outputFile = new File(getDataFolder(), webpath.toString());
+
+        try {
+            FileOutputStream fos = new FileOutputStream(outputFile);
+            fos.write(Json.stringifyJson(clientConfig).getBytes());
+            fos.close();
+        } catch (FileNotFoundException ex) {
+            System.out.println("FileNotFoundException : " + ex);
+        } catch (IOException ioe) {
+            System.out.println("IOException : " + ioe);
+        }
     }
 }

src/main/java/org/dynmap/DynmapWorld.java

@@ -0,0 +1,12 @@
+package org.dynmap;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.bukkit.World;
+
+public class DynmapWorld {
+    public World world;
+    public List<MapType> maps = new ArrayList<MapType>();
+    public UpdateQueue updates = new UpdateQueue();
+}

src/main/java/org/dynmap/Event.java

@@ -0,0 +1,26 @@
+package org.dynmap;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class Event<T> {
+    private List<Listener<T>> listeners = new LinkedList<Listener<T>>();
+    
+    public synchronized void addListener(Listener<T> l) {
+        listeners.add(l);
+    }
+    
+    public synchronized void removeListener(Listener<T> l) {
+        listeners.remove(l);
+    }
+    
+    public synchronized void trigger(T t) {
+        for (Listener<T> l : listeners) {
+            l.triggered(t);
+        }
+    }
+    
+    public interface Listener<T> {
+        void triggered(T t);
+    }
+}

src/main/java/org/dynmap/Handler.java

@@ -0,0 +1,5 @@
+package org.dynmap;
+
+public interface Handler<T> {
+    void handle(T t);
+}

src/main/java/org/dynmap/JsonTimerTask.java

@@ -0,0 +1,66 @@
+package org.dynmap;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.TimerTask;
+
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.util.config.Configuration;
+import org.dynmap.web.Json;
+
+class JsonTimerTask extends TimerTask {
+    private final DynmapPlugin plugin;
+    private Server server;
+    private MapManager mapManager;
+    private Configuration configuration;
+
+    public JsonTimerTask(DynmapPlugin instance, Configuration config) {
+        this.plugin = instance;
+        this.server = this.plugin.getServer();
+        this.mapManager = this.plugin.getMapManager();
+        this.configuration = config;
+    }
+
+    public void run() {
+        for (World world : this.server.getWorlds()) {
+            long current = System.currentTimeMillis();
+
+            Client.Update update = new Client.Update();
+
+            update.timestamp = current;
+            update.servertime = world.getTime() % 24000;
+
+            Player[] players = mapManager.playerList.getVisiblePlayers();
+            update.players = new Client.Player[players.length];
+            for (int i = 0; i < players.length; i++) {
+                Player p = players[i];
+                Location pl = p.getLocation();
+                update.players[i] = new Client.Player(p.getName(), pl.getWorld().getName(), pl.getX(), pl.getY(), pl.getZ());
+            }
+
+            update.updates = mapManager.getWorldUpdates(world.getName(), current - (configuration.getInt("jsonfile-interval", 1) + 10000));
+
+            File webpath = new File(this.configuration.getString("webpath", "web"), "dynmap_" + world.getName() + ".json");
+            File outputFile;
+            if (webpath.isAbsolute())
+                outputFile = webpath;
+            else {
+                outputFile = new File(plugin.getDataFolder(), webpath.toString());
+            }
+            try {
+                FileOutputStream fos = new FileOutputStream(outputFile);
+                fos.write(Json.stringifyJson(update).getBytes());
+                fos.close();
+            } catch (FileNotFoundException ex) {
+                System.out.println("FileNotFoundException : " + ex);
+            } catch (IOException ioe) {
+                System.out.println("IOException : " + ioe);
+            }
+        }
+    }
+}

src/main/java/org/dynmap/MapLocation.java

@@ -1,6 +0,0 @@
-package org.dynmap;
-
-public class MapLocation {
-    public float x;
-    public float y;
-}

src/main/java/org/dynmap/MapManager.java

@@ -3,84 +3,68 @@ package org.dynmap;
 import java.io.File;
 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.util.config.ConfigurationNode;
-import org.dynmap.debug.Debugger;
+import org.dynmap.debug.Debug;
 
-public class MapManager extends Thread {
+public class MapManager {
     protected static final Logger log = Logger.getLogger("Minecraft");
 
-    private World world;
-    private Debugger debugger;
-    private MapType[] maps;
-    public StaleQueue staleQueue;
-    public UpdateQueue updateQueue;
+    public AsynchronousQueue<MapTile> tileQueue;
+    
+    public Map<String, DynmapWorld> worlds = new HashMap<String, DynmapWorld>();
+    public Map<String, DynmapWorld> inactiveworlds = new HashMap<String, DynmapWorld>();
+    
     public PlayerList playerList;
 
     /* lock for our data structures */
     public static final Object lock = new Object();
 
-    /* whether the worker thread should be running now */
-    private boolean running = false;
-
-    /* path to image tile directory */
-    public File tileDirectory;
-
-    /* web files location */
-    public File webDirectory;
-
-    /* bind web server to ip-address */
-    public String bindaddress = "0.0.0.0";
-
-    /* port to run web server on */
-    public int serverport = 8123;
-
-    /* time to pause between rendering tiles (ms) */
-    public int renderWait = 500;
-
-    public boolean loadChunks = true;
-
-    public void debug(String msg) {
-        debugger.debug(msg);
-    }
-
-    private static File combinePaths(File parent, String path) {
-        return combinePaths(parent, new File(path));
-    }
-
-    private static File combinePaths(File parent, File path) {
-        if (path.isAbsolute())
-            return path;
-        return new File(parent, path.getPath());
-    }
-
-    public MapManager(World world, Debugger debugger, ConfigurationNode configuration) {
-        this.world = world;
-        this.debugger = debugger;
-        this.staleQueue = new StaleQueue();
-        this.updateQueue = new UpdateQueue();
-
-        tileDirectory = combinePaths(DynmapPlugin.dataRoot, configuration.getString("tilespath", "web/tiles"));
-        webDirectory = combinePaths(DynmapPlugin.dataRoot, configuration.getString("webpath", "web"));
-        renderWait = (int) (configuration.getDouble("renderinterval", 0.5) * 1000);
-        loadChunks = configuration.getBoolean("loadchunks", true);
-
-        if (!tileDirectory.isDirectory())
-            tileDirectory.mkdirs();
-
-        maps = loadMapTypes(configuration);
+    public MapManager(DynmapPlugin plugin, ConfigurationNode configuration) {
+        this.tileQueue = new AsynchronousQueue<MapTile>(new Handler<MapTile>() {
+            @Override
+            public void handle(MapTile t) {
+                render(t);
+            }
+        }, (int) (configuration.getDouble("renderinterval", 0.5) * 1000));
+        
+        for(Object worldConfigurationObj : (List<?>)configuration.getProperty("worlds")) {
+            Map<?, ?> worldConfiguration = (Map<?, ?>)worldConfigurationObj;
+            String worldName = (String)worldConfiguration.get("name");
+            DynmapWorld world = new DynmapWorld();
+            if (worldConfiguration.get("maps") != null) {
+                for(MapType map : loadMapTypes((List<?>)worldConfiguration.get("maps"))) {
+                    world.maps.add(map);
+                }
+            }
+            inactiveworlds.put(worldName, world);
+            
+            World bukkitWorld = plugin.getServer().getWorld(worldName);
+            if (bukkitWorld != null)
+                activateWorld(bukkitWorld);
+        }
+        
+        tileQueue.start();
     }
 
     void renderFullWorld(Location l) {
-        debugger.debug("Full render starting...");
-        for (MapType map : maps) {
+        DynmapWorld world = worlds.get(l.getWorld().getName());
+        if (world == null) {
+            log.severe("Could not render: world '" + l.getWorld().getName() + "' not defined in configuration.");
+            return;
+        }
+        World w = world.world;
+        log.info("Full render starting on world '" + w.getName() + "'...");
+        for (MapType map : world.maps) {
             int requiredChunkCount = 200;
             HashSet<MapTile> found = new HashSet<MapTile>();
             HashSet<MapTile> rendered = new HashSet<MapTile>();
@@ -103,21 +87,20 @@ public class MapManager extends Thread {
                 // Unload old chunks.
                 while (loadedChunks.size() >= requiredChunkCount - requiredChunks.length) {
                     DynmapChunk c = loadedChunks.pollFirst();
-                    world.unloadChunk(c.x, c.z, false, true);
+                    w.unloadChunk(c.x, c.z, false, true);
                 }
 
                 // Load the required chunks.
                 for (DynmapChunk chunk : requiredChunks) {
-                    boolean wasLoaded = world.isChunkLoaded(chunk.x, chunk.z);
-                    world.loadChunk(chunk.x, chunk.z, false);
+                    boolean wasLoaded = w.isChunkLoaded(chunk.x, chunk.z);
+                    w.loadChunk(chunk.x, chunk.z, false);
                     if (!wasLoaded)
                         loadedChunks.add(chunk);
                 }
 
-                if (map.render(tile)) {
+                if (render(tile)) {
                     found.remove(tile);
                     rendered.add(tile);
-                    updateQueue.pushUpdate(new Client.Tile(tile.getName()));
                     for (MapTile adjTile : map.getAdjecentTiles(tile)) {
                         if (!found.contains(adjTile) && !rendered.contains(adjTile)) {
                             found.add(adjTile);
@@ -132,99 +115,61 @@ public class MapManager extends Thread {
             // Unload remaining chunks to clean-up.
             while (!loadedChunks.isEmpty()) {
                 DynmapChunk c = loadedChunks.pollFirst();
-                world.unloadChunk(c.x, c.z, false, true);
+                w.unloadChunk(c.x, c.z, false, true);
             }
         }
-        debugger.debug("Full render finished.");
+        log.info("Full render finished.");
     }
 
-    private MapType[] loadMapTypes(ConfigurationNode configuration) {
-        List<?> configuredMaps = (List<?>) configuration.getProperty("maps");
+    public void activateWorld(World w) {
+        DynmapWorld world = inactiveworlds.get(w.getName());
+        if (world == null) {
+            world = worlds.get(w.getName());
+        } else {
+            inactiveworlds.remove(w.getName());
+        }
+        if (world != null) {
+            world.world = w;
+            worlds.put(w.getName(), world);
+            log.info("Activated world '" + w.getName() + "' in Dynmap.");
+        }
+    }
+    
+    private MapType[] loadMapTypes(List<?> mapConfigurations) {
+        Event.Listener<MapTile> invalitateListener = new Event.Listener<MapTile>() {
+            @Override
+            public void triggered(MapTile t) {
+                invalidateTile(t);
+            }
+        };
         ArrayList<MapType> mapTypes = new ArrayList<MapType>();
-        for (Object configuredMapObj : configuredMaps) {
+        for (Object configuredMapObj : mapConfigurations) {
             try {
                 @SuppressWarnings("unchecked")
                 Map<String, Object> configuredMap = (Map<String, Object>) configuredMapObj;
                 String typeName = (String) configuredMap.get("class");
                 log.info("Loading map '" + typeName.toString() + "'...");
                 Class<?> mapTypeClass = Class.forName(typeName);
-                Constructor<?> constructor = mapTypeClass.getConstructor(MapManager.class, World.class, Debugger.class, Map.class);
-                MapType mapType = (MapType) constructor.newInstance(this, world, debugger, configuredMap);
+                Constructor<?> constructor = mapTypeClass.getConstructor(Map.class);
+                MapType mapType = (MapType) constructor.newInstance(configuredMap);
+                mapType.onTileInvalidated.addListener(invalitateListener);
                 mapTypes.add(mapType);
             } catch (Exception e) {
-                debugger.error("Error loading map", e);
+                log.log(Level.SEVERE, "Error loading maptype", e);
+                e.printStackTrace();
             }
         }
         MapType[] result = new MapType[mapTypes.size()];
         mapTypes.toArray(result);
         return result;
     }
-
-    /* initialize and start map manager */
-    public void startManager() {
-        synchronized (lock) {
-            running = true;
-            this.start();
-            try {
-                this.setPriority(MIN_PRIORITY);
-                log.info("Set minimum priority for worker thread");
-            } catch (SecurityException e) {
-                log.info("Failed to set minimum priority for worker thread!");
-            }
-        }
-    }
-
-    /* stop map manager */
-    public void stopManager() {
-        synchronized (lock) {
-            if (!running)
-                return;
-
-            log.info("Stopping map renderer...");
-            running = false;
-
-            try {
-                this.join();
-            } catch (InterruptedException e) {
-                log.info("Waiting for map renderer to stop is interrupted");
-            }
-        }
-    }
-
-    /* the worker/renderer thread */
-    public void run() {
-        try {
-            log.info("Map renderer has started.");
-
-            while (running) {
-                MapTile t = staleQueue.popStaleTile();
-                if (t != null) {
-                    debugger.debug("Rendering tile " + t + "...");
-                    boolean isNonEmptyTile = t.getMap().render(t);
-                    updateQueue.pushUpdate(new Client.Tile(t.getName()));
-
-                    try {
-                        Thread.sleep(renderWait);
-                    } catch (InterruptedException e) {
-                    }
-                } else {
-                    try {
-                        Thread.sleep(500);
-                    } catch (InterruptedException e) {
-                    }
-                }
-            }
-
-            log.info("Map renderer has stopped.");
-        } catch (Exception ex) {
-            debugger.error("Exception on rendering-thread: " + ex.toString());
-            ex.printStackTrace();
-        }
-    }
-
-    public void touch(int x, int y, int z) {
-        for (int i = 0; i < maps.length; i++) {
-            MapTile[] tiles = maps[i].getTiles(new Location(world, x, y, z));
+    
+    public void touch(Location l) {
+        DynmapWorld world = worlds.get(l.getWorld().getName());
+        if (world == null)
+            return;
+        for (int i = 0; i < world.maps.size(); i++) {
+            MapTile[] tiles = world.maps.get(i).getTiles(l);
             for (int j = 0; j < tiles.length; j++) {
                 invalidateTile(tiles[j]);
             }
@@ -232,7 +177,56 @@ public class MapManager extends Thread {
     }
 
     public void invalidateTile(MapTile tile) {
-        debugger.debug("Invalidating tile " + tile.getName());
-        staleQueue.pushStaleTile(tile);
+        Debug.debug("Invalidating tile " + tile.getFilename());
+        tileQueue.push(tile);
+    }
+    
+    public void startRendering() {
+        tileQueue.start();
+    }
+    
+    public void stopRendering() {
+        tileQueue.stop();
+    }
+    
+    public boolean render(MapTile tile) {
+        boolean result = tile.getMap().render(tile, getTileFile(tile));
+        pushUpdate(tile.getWorld(), new Client.Tile(tile.getFilename()));
+        return result;
+    }
+    
+    
+    private HashMap<World, File> worldTileDirectories = new HashMap<World, File>();
+    private File getTileFile(MapTile tile) {
+        World world = tile.getWorld();
+        File worldTileDirectory = worldTileDirectories.get(world);
+        if (worldTileDirectory == null) {
+            worldTileDirectory = new File(DynmapPlugin.tilesDirectory, tile.getWorld().getName());
+            worldTileDirectories.put(world, worldTileDirectory);
+        }
+        worldTileDirectory.mkdirs();
+        return new File(worldTileDirectory, tile.getFilename()); 
+    }
+
+    public void pushUpdate(Object update) {
+        for(DynmapWorld world : worlds.values()) {
+            world.updates.pushUpdate(update);
+        }
+    }
+    
+    public void pushUpdate(World world, Object update) {
+        pushUpdate(world.getName(), update);
+    }
+    
+    public void pushUpdate(String worldName, Object update) {
+        DynmapWorld world = worlds.get(worldName);
+        world.updates.pushUpdate(update);
+    }
+    
+    public Object[] getWorldUpdates(String worldName, long since) {
+        DynmapWorld world = worlds.get(worldName);
+        if (world == null)
+            return new Object[0];
+        return world.updates.getUpdatedObjects(since);
     }
 }

src/main/java/org/dynmap/MapTile.java

@@ -1,15 +1,28 @@
 package org.dynmap;
 
+import org.bukkit.World;
+
 public abstract class MapTile {
+    private World world;
     private MapType map;
 
+    public World getWorld() {
+        return world;
+    }
+    
     public MapType getMap() {
         return map;
     }
 
-    public abstract String getName();
+    public abstract String getFilename();
 
-    public MapTile(MapType map) {
+    public MapTile(World world, MapType map) {
+        this.world = world;
         this.map = map;
     }
+    
+    @Override
+    public int hashCode() {
+        return getFilename().hashCode() ^ getWorld().hashCode();
+    }
 }

src/main/java/org/dynmap/MapType.java

@@ -1,41 +1,17 @@
 package org.dynmap;
 
+import java.io.File;
+
 import org.bukkit.Location;
-import org.bukkit.World;
-import org.dynmap.debug.Debugger;
 
 public abstract class MapType {
-    private MapManager manager;
-
-    public MapManager getMapManager() {
-        return manager;
-    }
-
-    private World world;
-
-    public World getWorld() {
-        return world;
-    }
-
-    private Debugger debugger;
-
-    public Debugger getDebugger() {
-        return debugger;
-    }
-
-    public MapType(MapManager manager, World world, Debugger debugger) {
-        this.manager = manager;
-        this.world = world;
-        this.debugger = debugger;
-    }
-
+    public Event<MapTile> onTileInvalidated = new Event<MapTile>();
+    
     public abstract MapTile[] getTiles(Location l);
 
     public abstract MapTile[] getAdjecentTiles(MapTile tile);
 
     public abstract DynmapChunk[] getRequiredChunks(MapTile tile);
 
-    public abstract boolean render(MapTile tile);
-
-    public abstract boolean isRendered(MapTile tile);
+    public abstract boolean render(MapTile tile, File outputFile);
 }

src/main/java/org/dynmap/PlayerList.java

@@ -16,10 +16,11 @@ import org.bukkit.entity.Player;
 public class PlayerList {
     private Server server;
     private HashSet<String> hiddenPlayerNames = new HashSet<String>();
-    private File hiddenPlayersFile = new File(DynmapPlugin.dataRoot, "hiddenplayers.txt");
+    private File hiddenPlayersFile;
 
-    public PlayerList(Server server) {
+    public PlayerList(Server server, File hiddenPlayersFile) {
         this.server = server;
+        this.hiddenPlayersFile = hiddenPlayersFile;
     }
 
     public void save() {
@@ -68,6 +69,21 @@ public class PlayerList {
             hide(playerName);
     }
 
+    // TODO: Clean this up... one day
+    public Player[] getVisiblePlayers(String worldName) {
+        ArrayList<Player> visiblePlayers = new ArrayList<Player>();
+        Player[] onlinePlayers = server.getOnlinePlayers();
+        for (int i = 0; i < onlinePlayers.length; i++) {
+            Player p = onlinePlayers[i];
+            if (p.getWorld().getName().equals(worldName) && !hiddenPlayerNames.contains(p.getName())) {
+                visiblePlayers.add(p);
+            }
+        }
+        Player[] result = new Player[visiblePlayers.size()];
+        visiblePlayers.toArray(result);
+        return result;
+    }
+    
     public Player[] getVisiblePlayers() {
         ArrayList<Player> visiblePlayers = new ArrayList<Player>();
         Player[] onlinePlayers = server.getOnlinePlayers();

src/main/java/org/dynmap/UpdateQueue.java

@@ -11,7 +11,7 @@ public class UpdateQueue {
 
     private static final int maxUpdateAge = 120000;
 
-    public void pushUpdate(Object obj) {
+    public synchronized void pushUpdate(Object obj) {
         long now = System.currentTimeMillis();
         long deadline = now - maxUpdateAge;
         synchronized (lock) {
@@ -27,7 +27,7 @@ public class UpdateQueue {
 
     private ArrayList<Object> tmpupdates = new ArrayList<Object>();
 
-    public Object[] getUpdatedObjects(long since) {
+    public synchronized Object[] getUpdatedObjects(long since) {
         long now = System.currentTimeMillis();
         long deadline = now - maxUpdateAge;
         Object[] updates;

src/main/java/org/dynmap/debug/BukkitPlayerDebugger.java

@@ -1,8 +1,7 @@
 package org.dynmap.debug;
 
 import java.util.HashSet;
-import java.util.logging.Level;
-import java.util.logging.Logger;
+import java.util.Map;
 
 import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
@@ -11,27 +10,22 @@ import org.bukkit.event.Event.Priority;
 import org.bukkit.event.player.PlayerChatEvent;
 import org.bukkit.event.player.PlayerEvent;
 import org.bukkit.event.player.PlayerListener;
-import org.bukkit.plugin.PluginDescriptionFile;
 import org.bukkit.plugin.java.JavaPlugin;
 
 public class BukkitPlayerDebugger implements Debugger {
-    protected static final Logger log = Logger.getLogger("Minecraft");
-
-    private boolean isLogging = false;
-
     private JavaPlugin plugin;
     private HashSet<Player> debugees = new HashSet<Player>();
     private String debugCommand;
     private String undebugCommand;
     private String prepend;
 
-    public BukkitPlayerDebugger(JavaPlugin plugin) {
+    public BukkitPlayerDebugger(JavaPlugin plugin, Map<String, Object> configuration) {
         this.plugin = plugin;
 
-        PluginDescriptionFile pdfFile = plugin.getDescription();
-        debugCommand = "/debug_" + pdfFile.getName();
-        undebugCommand = "/undebug_" + pdfFile.getName();
-        prepend = pdfFile.getName() + ": ";
+        String name = "dynmap";
+        debugCommand = "/debug_" + name;
+        undebugCommand = "/undebug_" + name;
+        prepend = name + ": ";
     }
 
     public synchronized void enable() {
@@ -63,19 +57,15 @@ public class BukkitPlayerDebugger implements Debugger {
 
     public synchronized void debug(String message) {
         sendToDebuggees(message);
-        if (isLogging)
-            log.info(prepend + message);
     }
 
     public synchronized void error(String message) {
         sendToDebuggees(prepend + ChatColor.RED + message);
-        log.log(Level.SEVERE, prepend + message);
     }
 
     public synchronized void error(String message, Throwable thrown) {
         sendToDebuggees(prepend + ChatColor.RED + message);
         sendToDebuggees(thrown.toString());
-        log.log(Level.SEVERE, prepend + message);
     }
 
     protected class CommandListener extends PlayerListener {

src/main/java/org/dynmap/debug/Debug.java

@@ -0,0 +1,31 @@
+package org.dynmap.debug;
+
+import java.util.ArrayList;
+
+public class Debug {
+    private static ArrayList<Debugger> debuggers = new ArrayList<Debugger>();
+
+    public synchronized static void addDebugger(Debugger d) {
+        debuggers.add(d);
+    }
+    
+    public synchronized static void removeDebugger(Debugger d) {
+        debuggers.remove(d);
+    }
+    
+    public synchronized static void clearDebuggers() {
+        debuggers.clear();
+    }
+    
+    public synchronized static void debug(String message) {
+        for(int i = 0; i < debuggers.size(); i++) debuggers.get(i).debug(message);
+    }
+
+    public synchronized static void error(String message) {
+        for(int i = 0; i < debuggers.size(); i++) debuggers.get(i).error(message);
+    }
+
+    public synchronized static void error(String message, Throwable thrown) {
+        for(int i = 0; i < debuggers.size(); i++) debuggers.get(i).error(message, thrown);
+    }
+}