1.8.9 support

11 files changed, 958 insertions, 0 deletions

diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189CommandSender.java b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189CommandSender.java
new file mode 100644
index 0000000..6c8bd5a
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189CommandSender.java
@@ -0,0 +1,92 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge;
+
+import me.lucko.spark.common.command.sender.AbstractCommandSender;
+import me.lucko.spark.forge.plugin.Forge189SparkPlugin;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.serializer.gson.GsonComponentSerializer;
+import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.network.rcon.RConConsoleSource;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.IChatComponent;
+import net.minecraftforge.common.ForgeHooks;
+
+import java.util.UUID;
+
+public class Forge189CommandSender extends AbstractCommandSender<ICommandSender> {
+    private final Forge189SparkPlugin plugin;
+
+    public Forge189CommandSender(ICommandSender source, Forge189SparkPlugin plugin) {
+        super(source);
+        this.plugin = plugin;
+    }
+
+    @Override
+    public String getName() {
+        if (super.delegate instanceof EntityPlayer) {
+            return ((EntityPlayer) super.delegate).getGameProfile().getName();
+        } else if (super.delegate instanceof MinecraftServer) {
+            return "Console";
+        } else if (super.delegate instanceof RConConsoleSource) {
+            return "RCON Console";
+        } else {
+            return "unknown:" + super.delegate.getClass().getSimpleName();
+        }
+    }
+
+    @Override
+    public UUID getUniqueId() {
+        if (super.delegate instanceof EntityPlayer) {
+            return ((EntityPlayer) super.delegate).getUniqueID();
+        }
+        return null;
+    }
+
+    @Override
+    public void sendMessage(Component message) {
+        /*
+         * Due to limitations in 1.7.10, messages with \n render incorrectly on the client.
+         * To work around this, we convert the message to a string first, split it by newline,
+         * and send each line individually.
+         * 
+         * This adds a performance penalty, but avoids any weirdness with this old client.
+         */
+        LegacyComponentSerializer serializer = LegacyComponentSerializer.builder()
+                .character(LegacyComponentSerializer.SECTION_CHAR)
+                .extractUrls()
+                .build();
+        String output = serializer.serialize(message);
+        for(String line : output.split("\n")) {
+            Component deserialized = serializer.deserialize(line);
+            IChatComponent mcComponent = IChatComponent.Serializer.jsonToComponent(GsonComponentSerializer.gson().serialize(deserialized));
+            super.delegate.addChatMessage(mcComponent);
+        }
+    }
+
+    @Override
+    public boolean hasPermission(String permission) {
+        return this.plugin.hasPermission(super.delegate, permission);
+    }
+}
diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189PlatformInfo.java b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189PlatformInfo.java
new file mode 100644
index 0000000..6058f51
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189PlatformInfo.java
@@ -0,0 +1,52 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge;
+
+import me.lucko.spark.common.platform.PlatformInfo;
+import net.minecraftforge.common.ForgeVersion;
+
+public class Forge189PlatformInfo implements PlatformInfo {
+    private final Type type;
+
+    public Forge189PlatformInfo(Type type) {
+        this.type = type;
+    }
+
+    @Override
+    public Type getType() {
+        return this.type;
+    }
+
+    @Override
+    public String getName() {
+        return "Forge";
+    }
+
+    @Override
+    public String getVersion() {
+        return ForgeVersion.getVersion();
+    }
+
+    @Override
+    public String getMinecraftVersion() {
+        return "1.8.9";
+    }
+}
diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189PlayerPingProvider.java b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189PlayerPingProvider.java
new file mode 100644
index 0000000..149ca1a
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189PlayerPingProvider.java
@@ -0,0 +1,48 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge;
+
+import com.google.common.collect.ImmutableMap;
+
+import me.lucko.spark.common.monitor.ping.PlayerPingProvider;
+
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.server.MinecraftServer;
+
+import java.util.List;
+import java.util.Map;
+
+public class Forge189PlayerPingProvider implements PlayerPingProvider {
+    private final MinecraftServer server;
+
+    public Forge189PlayerPingProvider(MinecraftServer server) {
+        this.server = server;
+    }
+
+    @Override
+    public Map<String, Integer> poll() {
+        ImmutableMap.Builder<String, Integer> builder = ImmutableMap.builder();
+        for (EntityPlayerMP player : (List<EntityPlayerMP>)this.server.getConfigurationManager().playerEntityList) {
+            builder.put(player.getGameProfile().getName(), player.ping);
+        }
+        return builder.build();
+    }
+}
diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189SparkMod.java b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189SparkMod.java
new file mode 100644
index 0000000..5fce36a
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189SparkMod.java
@@ -0,0 +1,81 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge;
+
+import me.lucko.spark.forge.plugin.Forge189ClientSparkPlugin;
+import me.lucko.spark.forge.plugin.Forge189ServerSparkPlugin;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
+import net.minecraftforge.fml.common.event.FMLServerStoppingEvent;
+import net.minecraftforge.fml.relauncher.Side;
+
+import java.nio.file.Path;
+
+@Mod(
+        modid = "spark",
+        name = "spark",
+        version = "@version@",
+        acceptableRemoteVersions = "*"
+)
+public class Forge189SparkMod {
+
+    private Path configDirectory;
+    private Forge189ServerSparkPlugin activeServerPlugin;
+
+    public String getVersion() {
+        return Forge189SparkMod.class.getAnnotation(Mod.class).version();
+    }
+
+    @Mod.EventHandler
+    public void preInit(FMLPreInitializationEvent e) {
+        this.configDirectory = e.getModConfigurationDirectory().toPath();
+    }
+
+    @Mod.EventHandler
+    public void clientInit(FMLInitializationEvent e) {
+        if (FMLCommonHandler.instance().getSide() == Side.CLIENT) {
+            Forge189ClientSparkPlugin.register(this);
+        }
+    }
+
+    @Mod.EventHandler
+    public void serverInit(FMLServerStartingEvent e) {
+        this.activeServerPlugin = Forge189ServerSparkPlugin.register(this, e);
+    }
+
+    @Mod.EventHandler
+    public void serverStop(FMLServerStoppingEvent e) {
+        if (this.activeServerPlugin != null) {
+            this.activeServerPlugin.disable();
+            this.activeServerPlugin = null;
+        }
+    }
+
+    public Path getConfigDirectory() {
+        if (this.configDirectory == null) {
+            throw new IllegalStateException("Config directory not set");
+        }
+        return this.configDirectory;
+    }
+}
diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189TickHook.java b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189TickHook.java
new file mode 100644
index 0000000..f375d56
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189TickHook.java
@@ -0,0 +1,59 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge;
+
+import me.lucko.spark.common.tick.AbstractTickHook;
+import me.lucko.spark.common.tick.TickHook;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+
+public class Forge189TickHook extends AbstractTickHook implements TickHook {
+    private final TickEvent.Type type;
+
+    public Forge189TickHook(TickEvent.Type type) {
+        this.type = type;
+    }
+
+    @SubscribeEvent
+    public void onTick(TickEvent e) {
+        if (e.phase != TickEvent.Phase.START) {
+            return;
+        }
+
+        if (e.type != this.type) {
+            return;
+        }
+
+        onTick();
+    }
+
+    @Override
+    public void start() {
+        FMLCommonHandler.instance().bus().register(this);
+    }
+
+    @Override
+    public void close() {
+        FMLCommonHandler.instance().bus().unregister(this);
+    }
+
+}
diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189TickReporter.java b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189TickReporter.java
new file mode 100644
index 0000000..b489e8b
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189TickReporter.java
@@ -0,0 +1,65 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge;
+
+import me.lucko.spark.common.tick.SimpleTickReporter;
+import me.lucko.spark.common.tick.TickReporter;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+
+public class Forge189TickReporter extends SimpleTickReporter implements TickReporter {
+    private final TickEvent.Type type;
+
+    public Forge189TickReporter(TickEvent.Type type) {
+        this.type = type;
+    }
+
+    @SubscribeEvent
+    public void onTick(TickEvent e) {
+        if (e.type != this.type) {
+            return;
+        }
+
+        switch (e.phase) {
+            case START:
+                onStart();
+                break;
+            case END:
+                onEnd();
+                break;
+            default:
+                throw new AssertionError(e.phase);
+        }
+    }
+
+    @Override
+    public void start() {
+        FMLCommonHandler.instance().bus().register(this);
+    }
+
+    @Override
+    public void close() {
+        FMLCommonHandler.instance().bus().unregister(this);
+        super.close();
+    }
+
+}
diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189WorldInfoProvider.java b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189WorldInfoProvider.java
new file mode 100644
index 0000000..d98fe41
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/Forge189WorldInfoProvider.java
@@ -0,0 +1,151 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge;
+
+import me.lucko.spark.common.platform.world.AbstractChunkInfo;
+import me.lucko.spark.common.platform.world.CountMap;
+import me.lucko.spark.common.platform.world.WorldInfoProvider;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.multiplayer.ChunkProviderClient;
+import net.minecraft.client.multiplayer.WorldClient;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityList;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.ClassInheritanceMultiMap;
+import net.minecraft.world.WorldServer;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraft.world.chunk.IChunkProvider;
+import net.minecraftforge.fml.relauncher.ReflectionHelper;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public abstract class Forge189WorldInfoProvider implements WorldInfoProvider {
+    public static final class Server extends Forge189WorldInfoProvider {
+        private final MinecraftServer server;
+
+        public Server(MinecraftServer server) {
+            this.server = server;
+        }
+
+        @Override
+        public ChunksResult<ForgeChunkInfo> pollChunks() {
+            ChunksResult<ForgeChunkInfo> data = new ChunksResult<>();
+
+            for (WorldServer level : this.server.worldServers) {
+                ArrayList<ForgeChunkInfo> list = new ArrayList<>();
+                for(Chunk chunk : (List<Chunk>)level.theChunkProviderServer.loadedChunks) {
+                    list.add(new ForgeChunkInfo(chunk));
+                }
+                data.put(level.provider.getDimensionName(), list);
+            }
+
+            return data;
+        }
+
+        @Override
+        public CountsResult pollCounts() {
+            int players = this.server.getCurrentPlayerCount();
+            int entities = 0;
+            int chunks = 0;
+
+            for (WorldServer level : this.server.worldServers) {
+                entities += level.loadedEntityList.size();
+                chunks += level.getChunkProvider().getLoadedChunkCount();
+            }
+
+            return new CountsResult(players, entities, -1, chunks);
+        }
+    }
+
+    @SideOnly(Side.CLIENT)
+    public static final class Client extends Forge189WorldInfoProvider {
+        private final Minecraft client;
+
+        public Client(Minecraft client) {
+            this.client = client;
+        }
+
+        @Override
+        public ChunksResult<ForgeChunkInfo> pollChunks() {
+            ChunksResult<ForgeChunkInfo> data = new ChunksResult<>();
+
+            WorldClient level = this.client.theWorld;
+            if (level == null) {
+                return null;
+            }
+
+            ArrayList<ForgeChunkInfo> list = new ArrayList<>();
+            IChunkProvider provider = level.getChunkProvider();
+            if(provider instanceof ChunkProviderClient) {
+                List<Chunk> chunks = ReflectionHelper.getPrivateValue(ChunkProviderClient.class, (ChunkProviderClient)provider, "chunkListing", "field_73237_c");
+                for(Chunk chunk : chunks) {
+                    list.add(new ForgeChunkInfo(chunk));
+                }
+            }
+
+            data.put(level.provider.getDimensionName(), list);
+
+            return data;
+        }
+
+        @Override
+        public CountsResult pollCounts() {
+            WorldClient level = this.client.theWorld;
+            if (level == null) {
+                return null;
+            }
+
+            return new CountsResult(-1, level.loadedEntityList.size(), -1, level.getChunkProvider().getLoadedChunkCount());
+        }
+    }
+
+    static final class ForgeChunkInfo extends AbstractChunkInfo<Class<? extends Entity>> {
+        private final CountMap<Class<? extends Entity>> entityCounts;
+
+        ForgeChunkInfo(Chunk chunk) {
+            super(chunk.xPosition, chunk.zPosition);
+
+            this.entityCounts = new CountMap.Simple<>(new HashMap<>());
+            for(ClassInheritanceMultiMap<Entity> entityList : chunk.getEntityLists()) {
+                entityList.forEach(entity -> {
+                    this.entityCounts.increment(entity.getClass());
+                });
+            }
+        }
+
+        @Override
+        public CountMap<Class<? extends Entity>> getEntityCounts() {
+            return this.entityCounts;
+        }
+
+        @Override
+        public String entityTypeName(Class<? extends Entity> type) {
+            return (String)EntityList.classToStringMapping.get(type);
+        }
+    }
+
+
+}
diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/plugin/Forge189ClientSparkPlugin.java b/spark-forge189/src/main/java/me/lucko/spark/forge/plugin/Forge189ClientSparkPlugin.java
new file mode 100644
index 0000000..b2cef1d
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/plugin/Forge189ClientSparkPlugin.java
@@ -0,0 +1,105 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge.plugin;
+
+import me.lucko.spark.common.platform.PlatformInfo;
+import me.lucko.spark.common.platform.world.WorldInfoProvider;
+import me.lucko.spark.common.sampler.ThreadDumper;
+import me.lucko.spark.common.tick.TickHook;
+import me.lucko.spark.common.tick.TickReporter;
+import me.lucko.spark.forge.*;
+import net.minecraft.client.Minecraft;
+import net.minecraft.command.ICommandSender;
+import net.minecraftforge.client.ClientCommandHandler;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+import net.minecraftforge.fml.relauncher.ReflectionHelper;
+
+import java.util.stream.Stream;
+
+public class Forge189ClientSparkPlugin extends Forge189SparkPlugin {
+
+    public static void register(Forge189SparkMod mod) {
+        Forge189ClientSparkPlugin plugin = new Forge189ClientSparkPlugin(mod, Minecraft.getMinecraft());
+        plugin.enable();
+
+        // register listeners
+        MinecraftForge.EVENT_BUS.register(plugin);
+
+        // register commands
+        ClientCommandHandler.instance.registerCommand(plugin);
+    }
+
+    private final Minecraft minecraft;
+    private final ThreadDumper gameThreadDumper;
+
+    public Forge189ClientSparkPlugin(Forge189SparkMod mod, Minecraft minecraft) {
+        super(mod);
+        this.minecraft = minecraft;
+        this.gameThreadDumper = new ThreadDumper.Specific((Thread) ReflectionHelper.getPrivateValue(Minecraft.class, minecraft, "mcThread", "field_152352_aC", "aO"));
+    }
+
+    @Override
+    public ThreadDumper getDefaultThreadDumper() {
+        return this.gameThreadDumper;
+    }
+
+    @Override
+    public boolean hasPermission(ICommandSender sender, String permission) {
+        return true;
+    }
+
+    @Override
+    public Stream<Forge189CommandSender> getCommandSenders() {
+        return Stream.of(new Forge189CommandSender(this.minecraft.thePlayer, this));
+    }
+
+    @Override
+    public TickHook createTickHook() {
+        return new Forge189TickHook(TickEvent.Type.CLIENT);
+    }
+
+    @Override
+    public TickReporter createTickReporter() {
+        return new Forge189TickReporter(TickEvent.Type.CLIENT);
+    }
+
+    @Override
+    public WorldInfoProvider createWorldInfoProvider() {
+        return new Forge189WorldInfoProvider.Client(Minecraft.getMinecraft());
+    }
+
+    @Override
+    public void executeSync(Runnable task) {
+        this.minecraft.addScheduledTask(task);
+    }
+
+    @Override
+    public PlatformInfo getPlatformInfo() {
+        return new Forge189PlatformInfo(PlatformInfo.Type.CLIENT);
+    }
+
+    @Override
+    public String getCommandName() {
+        return "sparkc";
+    }
+
+}
diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/plugin/Forge189ServerSparkPlugin.java b/spark-forge189/src/main/java/me/lucko/spark/forge/plugin/Forge189ServerSparkPlugin.java
new file mode 100644
index 0000000..a8ab211
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/plugin/Forge189ServerSparkPlugin.java
@@ -0,0 +1,147 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge.plugin;
+
+import com.google.common.collect.Queues;
+import me.lucko.spark.common.platform.PlatformInfo;
+import me.lucko.spark.common.platform.world.WorldInfoProvider;
+import me.lucko.spark.common.sampler.ThreadDumper;
+import me.lucko.spark.common.tick.TickHook;
+import me.lucko.spark.common.tick.TickReporter;
+import me.lucko.spark.forge.*;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.server.MinecraftServer;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.common.gameevent.TickEvent;
+
+import java.util.Queue;
+import java.util.stream.Stream;
+
+public class Forge189ServerSparkPlugin extends Forge189SparkPlugin {
+    private final Queue<Runnable> scheduledServerTasks = Queues.newArrayDeque();
+
+    private final ThreadDumper.GameThread gameThreadDumper;
+
+    public static Forge189ServerSparkPlugin register(Forge189SparkMod mod, FMLServerStartingEvent event) {
+        Forge189ServerSparkPlugin plugin = new Forge189ServerSparkPlugin(mod, event.getServer());
+        plugin.enable();
+
+        FMLCommonHandler.instance().bus().register(plugin);
+
+        // register commands & permissions
+        event.registerServerCommand(plugin);
+
+        return plugin;
+    }
+
+    @Override
+    public void disable() {
+        super.disable();
+        FMLCommonHandler.instance().bus().unregister(this);
+    }
+
+    @SubscribeEvent
+    public void onServerTickEnd(TickEvent.ServerTickEvent event) {
+        if(event.phase == TickEvent.Phase.START) {
+            synchronized(scheduledServerTasks) {
+                while (!scheduledServerTasks.isEmpty())
+                {
+                    scheduledServerTasks.poll().run();
+                }
+            }
+        }
+    }
+
+    private final MinecraftServer server;
+
+    public Forge189ServerSparkPlugin(Forge189SparkMod mod, MinecraftServer server) {
+        super(mod);
+        this.server = server;
+        this.gameThreadDumper = new ThreadDumper.GameThread();
+        this.gameThreadDumper.setThread(Thread.currentThread());
+    }
+
+    @Override
+    public ThreadDumper getDefaultThreadDumper() {
+        return this.gameThreadDumper.get();
+    }
+
+    @Override
+    public boolean hasPermission(ICommandSender sender, String permission) {
+        if (sender instanceof EntityPlayerMP) {
+            EntityPlayerMP player = (EntityPlayerMP)sender;
+            if(isOp(player))
+                return true;
+            else {
+                String serverOwner = MinecraftServer.getServer().getServerOwner();
+                if(player.getGameProfile().getName() != null && serverOwner != null)
+                    return serverOwner.equals(player.getGameProfile().getName());
+                else
+                    return false;
+            }
+        } else {
+            return true;
+        }
+    }
+
+    @Override
+    public Stream<Forge189CommandSender> getCommandSenders() {
+        return Stream.concat(
+            this.server.getConfigurationManager().playerEntityList.stream(),
+            Stream.of(this.server)
+        ).map(sender -> new Forge189CommandSender(sender, this));
+    }
+
+    @Override
+    public TickHook createTickHook() {
+        return new Forge189TickHook(TickEvent.Type.SERVER);
+    }
+
+    @Override
+    public TickReporter createTickReporter() {
+        return new Forge189TickReporter(TickEvent.Type.SERVER);
+    }
+
+    @Override
+    public WorldInfoProvider createWorldInfoProvider() {
+        return new Forge189WorldInfoProvider.Server(FMLCommonHandler.instance().getMinecraftServerInstance());
+    }
+
+    @Override
+    public void executeSync(Runnable task) {
+        synchronized (scheduledServerTasks) {
+            scheduledServerTasks.add(task);
+        }
+    }
+
+    @Override
+    public PlatformInfo getPlatformInfo() {
+        return new Forge189PlatformInfo(PlatformInfo.Type.SERVER);
+    }
+
+    @Override
+    public String getCommandName() {
+        return "spark";
+    }
+}
diff --git a/spark-forge189/src/main/java/me/lucko/spark/forge/plugin/Forge189SparkPlugin.java b/spark-forge189/src/main/java/me/lucko/spark/forge/plugin/Forge189SparkPlugin.java
new file mode 100644
index 0000000..6ada30c
--- /dev/null
+++ b/spark-forge189/src/main/java/me/lucko/spark/forge/plugin/Forge189SparkPlugin.java
@@ -0,0 +1,150 @@
+/*
+ * This file is part of spark.
+ *
+ *  Copyright (c) lucko (Luck) <luck@lucko.me>
+ *  Copyright (c) contributors
+ *
+ *  This program is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package me.lucko.spark.forge.plugin;
+
+import com.google.common.collect.Lists;
+import me.lucko.spark.common.SparkPlatform;
+import me.lucko.spark.common.SparkPlugin;
+import me.lucko.spark.forge.Forge189CommandSender;
+import me.lucko.spark.forge.Forge189SparkMod;
+import net.minecraft.command.ICommand;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.BlockPos;
+import net.minecraftforge.fml.common.FMLCommonHandler;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.jetbrains.annotations.NotNull;
+
+import java.nio.file.Path;
+import java.util.Collections;
+import java.util.List;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.logging.Level;
+
+public abstract class Forge189SparkPlugin implements SparkPlugin, ICommand {
+
+    private final Forge189SparkMod mod;
+    private final Logger logger;
+    protected final ScheduledExecutorService scheduler;
+    protected final SparkPlatform platform;
+
+    protected Forge189SparkPlugin(Forge189SparkMod mod) {
+        this.mod = mod;
+        this.logger = LogManager.getLogger("spark");
+        this.scheduler = Executors.newSingleThreadScheduledExecutor(r -> {
+            Thread thread = Executors.defaultThreadFactory().newThread(r);
+            thread.setName("spark-forge-async-worker");
+            thread.setDaemon(true);
+            return thread;
+        });
+        this.platform = new SparkPlatform(this);
+    }
+
+    public void enable() {
+        this.platform.enable();
+    }
+
+    public void disable() {
+        this.platform.disable();
+        this.scheduler.shutdown();
+    }
+
+    public abstract boolean hasPermission(ICommandSender sender, String permission);
+
+    @Override
+    public String getVersion() {
+        return this.mod.getVersion();
+    }
+
+    @Override
+    public Path getPluginDirectory() {
+        return this.mod.getConfigDirectory();
+    }
+
+    @Override
+    public void executeAsync(Runnable task) {
+        this.scheduler.execute(task);
+    }
+
+    @Override
+    public void log(Level level, String msg) {
+        if (level == Level.INFO) {
+            this.logger.info(msg);
+        } else if (level == Level.WARNING) {
+            this.logger.warn(msg);
+        } else if (level == Level.SEVERE) {
+            this.logger.error(msg);
+        } else {
+            throw new IllegalArgumentException(level.getName());
+        }
+    }
+
+    // implement ICommand
+
+    @Override
+    public String getCommandName() {
+        return "sparkc";
+    }
+
+    @Override
+    public String getCommandUsage(ICommandSender iCommandSender) {
+        return "/" + getCommandName();
+    }
+
+    private final List<String> aliases = Lists.newArrayList("sparkc", "sparkclient");
+
+    @Override
+    public List<String> getCommandAliases() {
+        return aliases;
+    }
+
+    @Override
+    public void processCommand(ICommandSender sender, String[] args) {
+        this.platform.executeCommand(new Forge189CommandSender(sender, this), args);
+    }
+
+    @Override
+    public List<String> addTabCompletionOptions(ICommandSender sender, String[] args, BlockPos pos) {
+        return this.platform.tabCompleteCommand(new Forge189CommandSender(sender, this), args);
+    }
+
+    @Override
+    public boolean canCommandSenderUseCommand(ICommandSender sender) {
+        return this.platform.hasPermissionForAnyCommand(new Forge189CommandSender(sender, this));
+    }
+
+    @Override
+    public boolean isUsernameIndex(String[] strings, int i) {
+        return false;
+    }
+
+    @Override
+    public int compareTo(@NotNull ICommand o) {
+        return getCommandName().compareTo(o.getCommandName());
+    }
+
+    protected boolean isOp(EntityPlayer player) {
+       return FMLCommonHandler.instance().getMinecraftServerInstance().getConfigurationManager().canSendCommands(player.getGameProfile());
+    }
+
+}
diff --git a/spark-forge189/src/main/resources/mcmod.info b/spark-forge189/src/main/resources/mcmod.info
new file mode 100644
index 0000000..50e5509
--- /dev/null
+++ b/spark-forge189/src/main/resources/mcmod.info
@@ -0,0 +1,8 @@
+[{
+  "modid": "spark",
+  "name": "spark",
+  "description": "${pluginDescription}",
+  "version": "${pluginVersion}",
+  "authors": ["Luck"],
+  "mcversion": "1.8.9"
+}]