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

package org.dynmap;

import java.io.File;
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 org.bukkit.Server;
import org.bukkit.World;
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.plugin.java.JavaPlugin;
import org.bukkit.util.config.Configuration;
import org.dynmap.Event.Listener;
import org.dynmap.debug.Debug;
import org.dynmap.debug.Debugger;
import org.dynmap.debug.LogDebugger;
import org.dynmap.kzedmap.MapTileRenderer;
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;

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 static File tilesDirectory;

    public World getWorld() {
        return getServer().getWorlds().get(0);
    }

    public MapManager getMapManager() {
        return mapManager;
    }

    public HttpServer getWebServer() {
        return webServer;
    }

    public void onEnable() {
        configuration = new Configuration(new File(this.getDataFolder(), "configuration.txt"));
        configuration.load();
        
        loadDebuggers();

        tilesDirectory = getFile(configuration.getString("tilespath", "web/tiles"));
        tilesDirectory.mkdirs();
        
        playerList = new PlayerList(getServer(), getFile("hiddenplayers.txt"));
        playerList.load();

        mapManager = new MapManager(configuration);
        mapManager.startRendering();

        InetAddress bindAddress;
        {
            String address = configuration.getString("webserver-bindaddress", "0.0.0.0");
            try {
                bindAddress = address.equals("0.0.0.0")
                        ? null
                        : InetAddress.getByName(address);
            } catch (UnknownHostException e) {
                bindAddress = null;
            }
        }
        int port = configuration.getInt("webserver-port", 8123);

        webServer = new HttpServer(bindAddress, port);
        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.stopRendering();

        if (webServer != null) {
            webServer.shutdown();
            webServer = null;
        }
        Debug.clearDebuggers();
    }

    public void registerEvents() {
        BlockListener blockListener = new DynmapBlockListener(mapManager);
        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);
        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;
                }
                
            }
        }
    }
}