diff options
17 files changed, 1048 insertions, 17 deletions
diff --git a/build.gradle b/build.gradle index f1a0a8e..f96ec86 100644 --- a/build.gradle +++ b/build.gradle @@ -26,7 +26,9 @@ subprojects { tasks.withType(JavaCompile) { options.encoding = 'UTF-8' - options.release = 8 + if (JavaVersion.current() != JavaVersion.VERSION_1_8) { + options.release = 8 + } } processResources { diff --git a/gradle.properties b/gradle.properties index 1c3cd0d..bf86fb7 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,5 +1 @@ -org.gradle.jvmargs=-Xmx2G -org.gradle.parallel=true - -# thanks, forge -org.gradle.daemon=false
\ No newline at end of file +org.gradle.jvmargs=-Xmx2G
\ No newline at end of file diff --git a/jitpack.yml b/jitpack.yml new file mode 100644 index 0000000..56acad0 --- /dev/null +++ b/jitpack.yml @@ -0,0 +1,2 @@ +before_install: + - ./gradlew :spark-forge1710:setupCIWorkspace diff --git a/settings.gradle b/settings.gradle index 5dd9582..fe12f64 100644 --- a/settings.gradle +++ b/settings.gradle @@ -12,15 +12,5 @@ rootProject.name = 'spark' include ( 'spark-api', 'spark-common', - 'spark-bukkit', - 'spark-bungeecord', - 'spark-velocity', - 'spark-velocity4', - 'spark-sponge7', - 'spark-sponge8', - 'spark-forge', - 'spark-fabric', - 'spark-nukkit', - 'spark-waterdog', - 'spark-minestom' + 'spark-forge1710' ) diff --git a/spark-forge1710/build.gradle b/spark-forge1710/build.gradle new file mode 100644 index 0000000..8fd166d --- /dev/null +++ b/spark-forge1710/build.gradle @@ -0,0 +1,92 @@ +buildscript { + repositories { + mavenCentral() + maven { url = "https://maven.minecraftforge.net" } + } + dependencies { + classpath ('com.anatawa12.forge:ForgeGradle:1.2-1.0.+') { + changing = true + } + } +} + +plugins { + id 'com.github.johnrengelman.shadow' version '7.0.0' +} + +apply plugin: 'forge' + +// These settings allow you to choose what version of Java you want to be compatible with. Forge 1.7.10 runs on Java 6 to 8. +sourceCompatibility = 1.8 +targetCompatibility = 1.8 + +minecraft { + version = "1.7.10-10.13.4.1614-1.7.10" + runDir = "run" + mappings = 'stable_12' + + replaceIn 'src/main/java/me/lucko/spark/forge/Forge1710SparkMod.java' + replace "@version@", project.pluginVersion +} + +configurations { + shade + implementation.extendsFrom shade +} + +// https://github.com/MinecraftForge/ForgeGradle/issues/627#issuecomment-533927535 +configurations.all { + resolutionStrategy { + force 'org.lwjgl.lwjgl:lwjgl-platform:2.9.4-nightly-20150209' + } +} + +dependencies { + shade project(':spark-common') +} + +processResources { + from(sourceSets.main.resources.srcDirs) { + include 'mcmod.info' + expand ( + 'pluginVersion': project.pluginVersion, + 'pluginDescription': project.pluginDescription + ) + } +} + +jar { + manifest { + attributes 'FMLAT': 'spark_at.cfg' + } +} + +shadowJar { + archiveName = 'spark-forge1710.jar' + configurations = [project.configurations.shade] + + relocate 'okio', 'me.lucko.spark.lib.okio' + relocate 'okhttp3', 'me.lucko.spark.lib.okhttp3' + relocate 'net.kyori.adventure', 'me.lucko.spark.lib.adventure' + relocate 'net.kyori.examination', 'me.lucko.spark.lib.adventure.examination' + relocate 'net.bytebuddy', 'me.lucko.spark.lib.bytebuddy' + relocate 'org.tukaani.xz', 'me.lucko.spark.lib.xz' + relocate 'com.google.protobuf', 'me.lucko.spark.lib.protobuf' + relocate 'org.objectweb.asm', 'me.lucko.spark.lib.asm' + relocate 'one.profiler', 'me.lucko.spark.lib.asyncprofiler' + + exclude 'module-info.class' + exclude 'META-INF/maven/**' + exclude 'META-INF/proguard/**' +} + +reobf.reobf(shadowJar) { spec -> + spec.classpath = sourceSets.main.compileClasspath; +} + +artifacts { + archives shadowJar + shadow shadowJar +} + +build.dependsOn(shadowJar)
\ No newline at end of file diff --git a/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710CommandSender.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710CommandSender.java new file mode 100644 index 0000000..71344a3 --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710CommandSender.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.Forge1710SparkPlugin; +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 Forge1710CommandSender extends AbstractCommandSender<ICommandSender> { + private final Forge1710SparkPlugin plugin; + + public Forge1710CommandSender(ICommandSender source, Forge1710SparkPlugin 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-forge1710/src/main/java/me/lucko/spark/forge/Forge1710PlatformInfo.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710PlatformInfo.java new file mode 100644 index 0000000..d9c8351 --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710PlatformInfo.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 Forge1710PlatformInfo implements PlatformInfo { + private final Type type; + + public Forge1710PlatformInfo(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.7.10"; + } +} diff --git a/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710PlayerPingProvider.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710PlayerPingProvider.java new file mode 100644 index 0000000..11ee45a --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710PlayerPingProvider.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 Forge1710PlayerPingProvider implements PlayerPingProvider { + private final MinecraftServer server; + + public Forge1710PlayerPingProvider(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-forge1710/src/main/java/me/lucko/spark/forge/Forge1710SparkMod.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710SparkMod.java new file mode 100644 index 0000000..5cdd62e --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710SparkMod.java @@ -0,0 +1,82 @@ +/* + * 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 cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.Mod.EventHandler; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; +import cpw.mods.fml.common.event.FMLServerStartingEvent; +import cpw.mods.fml.common.event.FMLServerStoppingEvent; +import cpw.mods.fml.relauncher.Side; +import me.lucko.spark.forge.plugin.Forge1710ClientSparkPlugin; +import me.lucko.spark.forge.plugin.Forge1710ServerSparkPlugin; + +import java.nio.file.Path; + +@Mod( + modid = "spark", + name = "spark", + version = "@version@", + acceptableRemoteVersions = "*" +) +public class Forge1710SparkMod { + + private Path configDirectory; + private Forge1710ServerSparkPlugin activeServerPlugin; + + public String getVersion() { + return Forge1710SparkMod.class.getAnnotation(Mod.class).version(); + } + + @EventHandler + public void preInit(FMLPreInitializationEvent e) { + this.configDirectory = e.getModConfigurationDirectory().toPath(); + } + + @EventHandler + public void clientInit(FMLInitializationEvent e) { + if (FMLCommonHandler.instance().getSide() == Side.CLIENT) { + Forge1710ClientSparkPlugin.register(this); + } + } + + @EventHandler + public void serverInit(FMLServerStartingEvent e) { + this.activeServerPlugin = Forge1710ServerSparkPlugin.register(this, e); + } + + @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-forge1710/src/main/java/me/lucko/spark/forge/Forge1710TickHook.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710TickHook.java new file mode 100644 index 0000000..44cb11a --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710TickHook.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 cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.gameevent.TickEvent; +import me.lucko.spark.common.tick.AbstractTickHook; +import me.lucko.spark.common.tick.TickHook; + +public class Forge1710TickHook extends AbstractTickHook implements TickHook { + private final TickEvent.Type type; + + public Forge1710TickHook(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-forge1710/src/main/java/me/lucko/spark/forge/Forge1710TickReporter.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710TickReporter.java new file mode 100644 index 0000000..d46c4d6 --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710TickReporter.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 cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.gameevent.TickEvent; +import me.lucko.spark.common.tick.SimpleTickReporter; +import me.lucko.spark.common.tick.TickReporter; + +public class Forge1710TickReporter extends SimpleTickReporter implements TickReporter { + private final TickEvent.Type type; + + public Forge1710TickReporter(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-forge1710/src/main/java/me/lucko/spark/forge/Forge1710WorldInfoProvider.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710WorldInfoProvider.java new file mode 100644 index 0000000..7252d71 --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/Forge1710WorldInfoProvider.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; + +import cpw.mods.fml.relauncher.ReflectionHelper; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +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.world.WorldServer; +import net.minecraft.world.chunk.Chunk; +import net.minecraft.world.chunk.IChunkProvider; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; + +public abstract class Forge1710WorldInfoProvider implements WorldInfoProvider { + public static final class Server extends Forge1710WorldInfoProvider { + 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 Forge1710WorldInfoProvider { + 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, "chunkMapping", "field_73236_b"); + 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(List<Entity> entityList : chunk.entityLists) { + 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-forge1710/src/main/java/me/lucko/spark/forge/plugin/Forge1710ClientSparkPlugin.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/plugin/Forge1710ClientSparkPlugin.java new file mode 100644 index 0000000..446a0c9 --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/plugin/Forge1710ClientSparkPlugin.java @@ -0,0 +1,104 @@ +/* + * 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 cpw.mods.fml.common.gameevent.TickEvent; +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 java.util.stream.Stream; + +public class Forge1710ClientSparkPlugin extends Forge1710SparkPlugin { + + public static void register(Forge1710SparkMod mod) { + Forge1710ClientSparkPlugin plugin = new Forge1710ClientSparkPlugin(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 Forge1710ClientSparkPlugin(Forge1710SparkMod mod, Minecraft minecraft) { + super(mod); + this.minecraft = minecraft; + this.gameThreadDumper = new ThreadDumper.Specific(minecraft.mcThread); + } + + @Override + public ThreadDumper getDefaultThreadDumper() { + return this.gameThreadDumper; + } + + @Override + public boolean hasPermission(ICommandSender sender, String permission) { + return true; + } + + @Override + public Stream<Forge1710CommandSender> getCommandSenders() { + return Stream.of(new Forge1710CommandSender(this.minecraft.thePlayer, this)); + } + + @Override + public TickHook createTickHook() { + return new Forge1710TickHook(TickEvent.Type.CLIENT); + } + + @Override + public TickReporter createTickReporter() { + return new Forge1710TickReporter(TickEvent.Type.CLIENT); + } + + @Override + public WorldInfoProvider createWorldInfoProvider() { + return new Forge1710WorldInfoProvider.Client(Minecraft.getMinecraft()); + } + + @Override + public void executeSync(Runnable task) { + this.minecraft.addScheduledTask(task); + } + + @Override + public PlatformInfo getPlatformInfo() { + return new Forge1710PlatformInfo(PlatformInfo.Type.CLIENT); + } + + @Override + public String getCommandName() { + return "sparkc"; + } + +} diff --git a/spark-forge1710/src/main/java/me/lucko/spark/forge/plugin/Forge1710ServerSparkPlugin.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/plugin/Forge1710ServerSparkPlugin.java new file mode 100644 index 0000000..db9f299 --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/plugin/Forge1710ServerSparkPlugin.java @@ -0,0 +1,144 @@ +/* + * 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 cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.event.FMLServerStartingEvent; +import cpw.mods.fml.common.eventhandler.SubscribeEvent; +import cpw.mods.fml.common.gameevent.TickEvent; +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.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.server.MinecraftServer; + +import java.util.List; +import java.util.Queue; +import java.util.concurrent.FutureTask; +import java.util.stream.Stream; + +public class Forge1710ServerSparkPlugin extends Forge1710SparkPlugin { + private final Queue<Runnable> scheduledServerTasks = Queues.newArrayDeque(); + + private final ThreadDumper.GameThread gameThreadDumper; + + public static Forge1710ServerSparkPlugin register(Forge1710SparkMod mod, FMLServerStartingEvent event) { + Forge1710ServerSparkPlugin plugin = new Forge1710ServerSparkPlugin(mod, event.getServer()); + plugin.enable(); + + FMLCommonHandler.instance().bus().register(plugin); + + // register commands & permissions + event.registerServerCommand(plugin); + + return plugin; + } + + @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 Forge1710ServerSparkPlugin(Forge1710SparkMod mod, MinecraftServer server) { + super(mod); + this.server = server; + this.gameThreadDumper = new ThreadDumper.GameThread(); + this.scheduledServerTasks.add(() -> 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<Forge1710CommandSender> getCommandSenders() { + return Stream.concat( + ((List<EntityPlayer>)this.server.getConfigurationManager().playerEntityList).stream(), + Stream.of(this.server) + ).map(sender -> new Forge1710CommandSender(sender, this)); + } + + @Override + public TickHook createTickHook() { + return new Forge1710TickHook(TickEvent.Type.SERVER); + } + + @Override + public TickReporter createTickReporter() { + return new Forge1710TickReporter(TickEvent.Type.SERVER); + } + + @Override + public WorldInfoProvider createWorldInfoProvider() { + return new Forge1710WorldInfoProvider.Server(FMLCommonHandler.instance().getMinecraftServerInstance()); + } + + @Override + public void executeSync(Runnable task) { + synchronized (scheduledServerTasks) { + scheduledServerTasks.add(task); + } + } + + @Override + public PlatformInfo getPlatformInfo() { + return new Forge1710PlatformInfo(PlatformInfo.Type.SERVER); + } + + @Override + public String getCommandName() { + return "spark"; + } +} diff --git a/spark-forge1710/src/main/java/me/lucko/spark/forge/plugin/Forge1710SparkPlugin.java b/spark-forge1710/src/main/java/me/lucko/spark/forge/plugin/Forge1710SparkPlugin.java new file mode 100644 index 0000000..26e1752 --- /dev/null +++ b/spark-forge1710/src/main/java/me/lucko/spark/forge/plugin/Forge1710SparkPlugin.java @@ -0,0 +1,145 @@ +/* + * 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 cpw.mods.fml.common.FMLCommonHandler; +import me.lucko.spark.common.SparkPlatform; +import me.lucko.spark.common.SparkPlugin; +import me.lucko.spark.forge.Forge1710CommandSender; +import me.lucko.spark.forge.Forge1710SparkMod; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.entity.player.EntityPlayer; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +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 Forge1710SparkPlugin implements SparkPlugin, ICommand { + + private final Forge1710SparkMod mod; + private final Logger logger; + protected final ScheduledExecutorService scheduler; + protected final SparkPlatform platform; + + protected Forge1710SparkPlugin(Forge1710SparkMod 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 getCommandName(); + } + + @Override + public String getCommandUsage(ICommandSender iCommandSender) { + return "/" + getCommandName(); + } + + @Override + public List<String> getCommandAliases() { + return Collections.singletonList(getCommandName()); + } + + @Override + public void processCommand(ICommandSender sender, String[] args) { + this.platform.executeCommand(new Forge1710CommandSender(sender, this), args); + } + + @Override + public List<String> addTabCompletionOptions(ICommandSender sender, String[] args) { + return this.platform.tabCompleteCommand(new Forge1710CommandSender(sender, this), args); + } + + @Override + public boolean canCommandSenderUseCommand(ICommandSender sender) { + return this.platform.hasPermissionForAnyCommand(new Forge1710CommandSender(sender, this)); + } + + @Override + public boolean isUsernameIndex(String[] strings, int i) { + return false; + } + + @Override + public int compareTo(Object o) { + return getCommandName().compareTo(((ICommand)o).getCommandName()); + } + + protected boolean isOp(EntityPlayer player) { + return FMLCommonHandler.instance().getMinecraftServerInstance().getConfigurationManager().canSendCommands(player.getGameProfile()); + } + +} diff --git a/spark-forge1710/src/main/resources/META-INF/spark_at.cfg b/spark-forge1710/src/main/resources/META-INF/spark_at.cfg new file mode 100644 index 0000000..ff29bd3 --- /dev/null +++ b/spark-forge1710/src/main/resources/META-INF/spark_at.cfg @@ -0,0 +1 @@ +public net.minecraft.client.Minecraft field_152352_aC # mcThread
\ No newline at end of file diff --git a/spark-forge1710/src/main/resources/mcmod.info b/spark-forge1710/src/main/resources/mcmod.info new file mode 100644 index 0000000..1c2c241 --- /dev/null +++ b/spark-forge1710/src/main/resources/mcmod.info @@ -0,0 +1,7 @@ +[{ + "modid": "spark", + "name": "spark", + "description": "${pluginDescription}", + "version": "${pluginVersion}", + "authors": ["Luck"] +}] |