diff --git a/build.gradle b/build.gradle index 67e8a5a..cb35653 100644 --- a/build.gradle +++ b/build.gradle @@ -3,6 +3,31 @@ plugins { id 'java' } + +import org.gradle.internal.os.OperatingSystem + +project.ext.lwjglVersion = "3.3.4" + +switch (OperatingSystem.current()) { + case OperatingSystem.LINUX: + project.ext.lwjglNatives = "natives-linux" + break + case OperatingSystem.WINDOWS: + project.ext.lwjglNatives = "natives-windows" + break + case OperatingSystem.MAC_OS: + project.ext.lwjglNatives = "natives-macos" +} + +configurations.configureEach { + // Removes LWJGL2 dependencies + exclude group: "org.lwjgl.lwjgl" +} + +configurations { + includeInJar +} + group = project.mod_group archivesBaseName = project.mod_name version = project.mod_version @@ -10,7 +35,8 @@ version = project.mod_version loom { gluedMinecraftJar() noIntermediateMappings() - customMinecraftManifest.set("https://github.com/Turnip-Labs/bta-manifest-repo/releases/download/v${project.bta_version}/${project.bta_version}.json") + + customMinecraftMetadata.set("https://downloads.betterthanadventure.net/bta-client/${project.bta_channel}/v${project.bta_version}/manifest.json") } repositories { @@ -24,6 +50,14 @@ repositories { name = 'Fabric' url = 'https://maven.fabricmc.net/' } + maven { + name = 'SignalumMavenInfrastructure' + url = 'https://maven.thesignalumproject.net/infrastructure' + } + maven { + name = 'SignalumMavenReleases' + url = 'https://maven.thesignalumproject.net/releases' + } ivy { url = "https://github.com/Better-than-Adventure" patternLayout { @@ -33,25 +67,18 @@ repositories { metadataSources { artifact() } } ivy { - url = "https://github.com/Turnip-Labs" - patternLayout { - artifact "[organisation]/releases/download/v[revision]/[module]-[revision].jar" - m2compatible = true - } - metadataSources { artifact() } - } - ivy { - url = "https://github.com/Turnip-Labs" + url = "https://downloads.betterthanadventure.net/bta-client/${project.bta_channel}/" patternLayout { - artifact "[organisation]/releases/download/[revision]/[module]-[revision].jar" + artifact "/v[revision]/client.jar" m2compatible = true } metadataSources { artifact() } } ivy { - url = "https://github.com/Turnip-Labs" + + url = "https://downloads.betterthanadventure.net/bta-server/${project.bta_channel}/" patternLayout { - artifact "[organisation]/releases/download/[revision]/[module]-bta-[revision].jar" + artifact "/v[revision]/server.jar" m2compatible = true } metadataSources { artifact() } @@ -64,22 +91,7 @@ repositories { } metadataSources { artifact() } } - ivy { - url = "https://github.com/MartinSVK12" - patternLayout { - artifact "[organisation]/releases/download/[revision]/[module]-[revision].jar" - m2compatible = true - } - metadataSources { artifact() } - } - ivy { - url = "https://github.com/MelonModding" - patternLayout { - artifact "[organisation]/releases/download/[revision]/[module]-[revision].jar" - m2compatible = true - } - metadataSources { artifact() } - } + } dependencies { @@ -87,15 +99,21 @@ dependencies { mappings loom.layered() {} modRuntimeOnly "objects:client:43db9b498cb67058d2e12d394e6507722e71bb45" // https://piston-data.mojang.com/v1/objects/43db9b498cb67058d2e12d394e6507722e71bb45/client.jar - modImplementation "fabric-loader:fabric-loader:${project.loader_version}" - // Helper library - // If you do not need Halplibe you can comment this line out or delete this line - modImplementation "com.github.Turnip-Labs:bta-halplibe:${project.halplibe_version}" + modImplementation "net.fabricmc:fabric-loader:${project.loader_version}" + + modImplementation "com.github.UselessSolutions:serverlibe:${project.serverlibe_version}" implementation "org.slf4j:slf4j-api:1.8.0-beta4" implementation "org.apache.logging.log4j:log4j-slf4j18-impl:2.16.0" + implementation "com.github.electronstudio:sdl2gdx:1.0.3" + includeInJar "com.github.electronstudio:sdl2gdx:1.0.3" + implementation "net.dv8tion:JDA:5.2.2" + includeInJar "net.dv8tion:JDA:5.2.2" + implementation "club.minnced:discord-webhooks:0.8.4" + includeInJar "club.minnced:discord-webhooks:0.8.4" + implementation 'com.google.guava:guava:33.0.0-jre' implementation group: 'com.google.code.gson', name: 'gson', version: '2.10.1' var log4jVersion = "2.20.0" @@ -104,7 +122,24 @@ dependencies { implementation("org.apache.logging.log4j:log4j-1.2-api:${log4jVersion}") implementation("io.github.llamalad7:mixinextras-common:0.5.0-beta.3") include(implementation("org.apache.commons:commons-lang3:3.12.0")) - implementation "serverlibe:serverlibe:${project.serverlibe_version}" + + modImplementation("com.github.zarzelcow:legacy-lwjgl3:1.0.4") + implementation platform("org.lwjgl:lwjgl-bom:$lwjglVersion") + + runtimeOnly "org.lwjgl:lwjgl::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-assimp::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-glfw::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-openal::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-opengl::$lwjglNatives" + runtimeOnly "org.lwjgl:lwjgl-stb::$lwjglNatives" + implementation "org.lwjgl:lwjgl:$lwjglVersion" + implementation "org.lwjgl:lwjgl-assimp:$lwjglVersion" + implementation "org.lwjgl:lwjgl-glfw:$lwjglVersion" + implementation "org.lwjgl:lwjgl-openal:$lwjglVersion" + implementation "org.lwjgl:lwjgl-opengl:$lwjglVersion" + implementation "org.lwjgl:lwjgl-stb:$lwjglVersion" + implementation 'org.xerial:sqlite-jdbc:3.47.0.0' + } java { @@ -121,6 +156,8 @@ jar { from("LICENSE") { rename { "${it}_${archivesBaseName}" } } + from(configurations.named("includeInJar").get().collect { zipTree(it) }) + duplicatesStrategy = DuplicatesStrategy.EXCLUDE } processResources { diff --git a/gradle.properties b/gradle.properties index e7a20f2..d46828b 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,18 +1,17 @@ org.gradle.jvmargs=-Xmx2G # BTA -bta_version=7.2_01 -# Loader & Mod Menu -loader_version=0.15.6-babric.6-bta +bta_version=7.3 +bta_channel=release -# HalpLibe -halplibe_version=4.1.3 +# Loader & Mod Menu +loader_version=0.15.6-bta.7 # ServerLibe -serverlibe_version=beta.2.2 +serverlibe_version=beta.2.7-7.3 # Mod -mod_version=0.1.2-7.2_01 +mod_version=1.0.0pre3-7.3 mod_group=MelonModding mod_name=MelonUtilities diff --git a/lib/slf4j-api-1.7.36.jar b/lib/slf4j-api-1.7.36.jar new file mode 100644 index 0000000..7d3ce68 Binary files /dev/null and b/lib/slf4j-api-1.7.36.jar differ diff --git a/lib/sqlite-jdbc-3.46.0.1.jar b/lib/sqlite-jdbc-3.46.0.1.jar new file mode 100644 index 0000000..2e8d1e7 Binary files /dev/null and b/lib/sqlite-jdbc-3.46.0.1.jar differ diff --git a/lib/sqlite-jdbc-3.47.0.0.jar b/lib/sqlite-jdbc-3.47.0.0.jar new file mode 100644 index 0000000..e69de29 diff --git a/lib/sqlite-jdbc-3.47.1.0.jar b/lib/sqlite-jdbc-3.47.1.0.jar new file mode 100644 index 0000000..3c40c09 Binary files /dev/null and b/lib/sqlite-jdbc-3.47.1.0.jar differ diff --git a/lib/sqlite-jdbc-3.47.2.0.jar b/lib/sqlite-jdbc-3.47.2.0.jar new file mode 100644 index 0000000..568e55f Binary files /dev/null and b/lib/sqlite-jdbc-3.47.2.0.jar differ diff --git a/lib/sqlite-jdbc-3.48.0.0.jar b/lib/sqlite-jdbc-3.48.0.0.jar new file mode 100644 index 0000000..282200b Binary files /dev/null and b/lib/sqlite-jdbc-3.48.0.0.jar differ diff --git a/src/main/java/MelonUtilities/MelonUtilities.java b/src/main/java/MelonUtilities/MelonUtilities.java index 51f90d6..9abe505 100644 --- a/src/main/java/MelonUtilities/MelonUtilities.java +++ b/src/main/java/MelonUtilities/MelonUtilities.java @@ -1,223 +1,90 @@ package MelonUtilities; -import MelonUtilities.commands.helper.HelperCommand; -import MelonUtilities.commands.home.DelHomeCommand; -import MelonUtilities.commands.home.HomeCommand; -import MelonUtilities.commands.home.SetHomeCommand; -import MelonUtilities.commands.kit.KitCommand; -import MelonUtilities.commands.kit.KittenCommand; -import MelonUtilities.commands.lock.LockCommand; -import MelonUtilities.commands.misc.WhereAmICommand; -import MelonUtilities.commands.role.RoleCommand; -import MelonUtilities.commands.rollback.RollbackCommand; -import MelonUtilities.commands.rules.RulesCommand; -import MelonUtilities.commands.tpa.TPACommand; -import MelonUtilities.commands.tpa.TPADenyCommand; -import MelonUtilities.commands.tpa.TPAcceptCommand; -import MelonUtilities.commands.utility.MUCommand; -import MelonUtilities.config.*; -import MelonUtilities.config.custom.classes.Crew; -import MelonUtilities.config.custom.jsonadapters.CrewJsonAdapter; -import MelonUtilities.config.datatypes.ConfigData; -import MelonUtilities.config.datatypes.KitData; -import MelonUtilities.config.datatypes.PlayerData; -import MelonUtilities.config.datatypes.RoleData; -import MelonUtilities.config.custom.classes.Home; -import MelonUtilities.config.custom.jsonadapters.HomeJsonAdapter; -import MelonUtilities.utility.RollbackManager; + +import MelonUtilities.utility.discord.DiscordChatRelay; +import MelonUtilities.utility.discord.DiscordClient; +import MelonUtilities.command.commands.*; +import MelonUtilities.config.Data; +import MelonUtilities.config.datatypes.data.Config; +import MelonUtilities.listeners.ChatInputListener; import MelonUtilities.utility.MUtil; -import com.google.gson.FieldNamingPolicy; -import com.google.gson.Gson; -import com.google.gson.GsonBuilder; import net.fabricmc.api.ModInitializer; -import net.minecraft.core.data.gamerule.GameRuleBoolean; -import net.minecraft.core.data.gamerule.GameRules; -import net.minecraft.core.data.registry.recipe.adapter.ItemStackJsonAdapter; -import net.minecraft.core.item.ItemStack; +import net.minecraft.core.net.command.CommandManager; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import turniplabs.halplibe.HalpLibe; -import turniplabs.halplibe.helper.CommandHelper; -import turniplabs.halplibe.util.GameStartEntrypoint; -import turniplabs.halplibe.util.RecipeEntrypoint; - -import java.util.HashMap; - -import static net.minecraft.server.util.helper.PlayerList.updateList; - +import org.useless.serverlibe.ServerLibe; -public class MelonUtilities implements ModInitializer, GameStartEntrypoint, RecipeEntrypoint { - public static final String MOD_ID = "melonutilities"; - public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); +public class MelonUtilities implements ModInitializer { - public static final Gson GSON = (new GsonBuilder()).setFieldNamingPolicy(FieldNamingPolicy.LOWER_CASE_WITH_UNDERSCORES).setPrettyPrinting().excludeFieldsWithoutExposeAnnotation().registerTypeAdapter(ItemStack.class, new ItemStackJsonAdapter()).registerTypeAdapter(Home.class, new HomeJsonAdapter()).registerTypeAdapter(Crew.class, new CrewJsonAdapter()).create(); + public static final String MOD_ID = "melonutilities"; + public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID); - public static GameRuleBoolean FIRE_TICKS = GameRules.register(new GameRuleBoolean("doFireTick", true)); - - public static final HashMap colorMap = new HashMap<>(); - static{ - colorMap.put("purple", "§a"); - colorMap.put("blue", "§b"); - colorMap.put("brown", "§c"); - colorMap.put("green", "§d"); - colorMap.put("red", "§e"); - colorMap.put("black", "§f"); - colorMap.put("orange", "§1"); - colorMap.put("magenta", "§2"); - colorMap.put("light_blue", "§3"); - colorMap.put("yellow", "§4"); - colorMap.put("lime", "§5"); - colorMap.put("pink", "§6"); - colorMap.put("grey", "§7"); - colorMap.put("gray", "§7"); - colorMap.put("light_grey", "§8"); - colorMap.put("light_gray", "§8"); - colorMap.put("cyan", "§9"); - colorMap.put("white", "§0"); + public static void reloadAll() { + if(Data.MainConfig.config.enableKits) Data.Kits.reload(); + if(Data.MainConfig.config.enableRoles) Data.Roles.reload(); + Data.Users.reload(); + Data.MainConfig.reload(); } - public static void updateAll() { - // Crew - // Helper - HelperCommand.buildHelperSyntax(); - // Home - // Kit - Data.kits.loadAll(KitData.class); - KitCommand.buildKitSyntax(); - // Lock - // Misc - // Role - Data.roles.loadAll(RoleData.class); - RoleCommand.buildRoleSyntax(); - // Tpa - // Utility - // Warp - // Anything Else - Data.configs.loadAll(ConfigData.class); - Data.playerData.loadAll(PlayerData.class); - updateList(); - + public static void registerCommands(){ + if(Data.MainConfig.config.enableContainerLocking) CommandManager.registerCommand(new CommandLock()); + if(Data.MainConfig.config.enableRoles) CommandManager.registerCommand(new CommandRole()); + if(Data.MainConfig.config.enableRollback) CommandManager.registerCommand(new CommandRollback()); + if(Data.MainConfig.config.enableElevators) CommandManager.registerCommand(new CommandElevator()); + if(Data.MainConfig.config.enableTPA) CommandManager.registerCommand(new CommandTPA()); + if(Data.MainConfig.config.enableTPA) CommandManager.registerCommand(new CommandTPAHere()); + if(Data.MainConfig.config.enableTPA) CommandManager.registerCommand(new CommandTPAccept()); + if(Data.MainConfig.config.enableTPA) CommandManager.registerCommand(new CommandTPDeny()); + if(Data.MainConfig.config.enableHomes) CommandManager.registerCommand(new CommandHome()); + if(Data.MainConfig.config.enableWarps) CommandManager.registerCommand(new CommandWarp()); + CommandManager.registerCommand(new CommandMelonUtilities()); } - public void updateRoles(){ - Data.configs.loadAll(ConfigData.class); - Data.roles.loadAll(RoleData.class); - RoleCommand.buildRoleSyntax(); - updateList(); + public void loadData(){ + LOGGER.info("Loading Utility Data..."); + reloadAll(); + LOGGER.info("Utility Data Loaded!"); } - public void updateKits(){ - Data.configs.loadAll(ConfigData.class); - Data.kits.loadAll(KitData.class); - KitCommand.buildKitSyntax(); + public void registerListeners(){ + LOGGER.info("Registering ServerLibe Listeners..."); + ServerLibe.registerListener(new ChatInputListener()); + LOGGER.info("ServerLibe Listeners Registered!"); } - @Override - public void onInitialize() { - if (HalpLibe.isClient) return; + @Override + public void onInitialize() { LOGGER.info("MelonUtilities initializing!"); - // Crew - // Helper - HelperCommand.buildHelperSyntax(); - // Home - SetHomeCommand.buildSyntax(); - DelHomeCommand.buildSyntax(); - HomeCommand.buildSyntax(); - // Kit - Data.kits.loadAll(KitData.class); - KitCommand.buildKitSyntax(); - // Lock - LockCommand.buildLockSyntax(); - // Misc - // Role - Data.roles.loadAll(RoleData.class); - RoleCommand.buildRoleSyntax(); - // Rollback - RollbackCommand.buildSyntax(); - RollbackManager.onInit(); - // Tpa - // Utility - // Warp - // ServerLibe - - // In order for methods inside your listeners to be recognized by ServerLibe you must - // register them into ServerLibe like such - //ServerLibe.registerListener(new GuiTestListener()); // Example Listener - //ServerLibe.registerListener(new DebugInfoListener()); // Prints out debug info to chat on a number of events, disable by default because it's annoying - - // Anything Else - Data.playerData.loadAll(PlayerData.class); - MUtil.timeOnInit = System.currentTimeMillis(); - - Data.configs.loadAll(ConfigData.class); - - + loadData(); + registerListeners(); + new Thread(() -> { + if (DiscordClient.init()) { + DiscordChatRelay.sendServerStartMessage(); + } + }).start(); LOGGER.info("MelonUtilities initialized!"); - } - - @Override - public void beforeGameStart() { - } - @Override - public void afterGameStart() { - if (HalpLibe.isClient) return; - // Crew - // Helper - // Home - CommandHelper.createCommand(new SetHomeCommand()); - CommandHelper.createCommand(new HomeCommand()); - CommandHelper.createCommand(new DelHomeCommand()); - // Kit - CommandHelper.createCommand(new KitCommand()); - CommandHelper.createCommand(new KittenCommand()); - // Lock - CommandHelper.createCommand(new LockCommand()); - // Misc - CommandHelper.createCommand(new WhereAmICommand()); - // Role - CommandHelper.createCommand(new RoleCommand()); - // Rollback - CommandHelper.createCommand(new RollbackCommand()); - // Tpa - CommandHelper.createCommand(new TPACommand()); - CommandHelper.createCommand(new TPAcceptCommand()); - CommandHelper.createCommand(new TPADenyCommand()); - // Utility - CommandHelper.createCommand(new HelperCommand()); - CommandHelper.createCommand(new MUCommand()); - // Warp - - // Rules - CommandHelper.createCommand(new RulesCommand()); - // Anything Else - - Data.configs.loadAll(ConfigData.class); - ConfigData config = Data.configs.getOrCreate("config", ConfigData.class); - config.lastSnapshot = correctTimeIfZERO(Data.configs.getOrCreate("config", ConfigData.class).lastSnapshot); + public static void afterServerStart(){ + Data.Users.reload(); + MUtil.timeOnInit = System.currentTimeMillis(); + Config config = Data.MainConfig.config; + config.lastSnapshot = correctTimeIfZERO(config.lastSnapshot); config.lastBackup = correctTimeIfZERO(config.lastBackup); config.lastSnapshotPrune = correctTimeIfZERO(config.lastSnapshotPrune); config.lastBackupPrune = correctTimeIfZERO(config.lastBackupPrune); - Data.configs.saveAll(); - + Data.MainConfig.save(); } - private double correctTimeIfZERO(double d){ + public static double correctTimeIfZERO(double d){ if(d == 0.0d){ return System.currentTimeMillis(); } return d; } - @Override - public void onRecipesReady() { - - } - - @Override - public void initNamespaces() { - + public static void info(String s) { + LOGGER.info(s); } } diff --git a/src/main/java/MelonUtilities/command/arguments/ArgumentTypeColor.java b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeColor.java new file mode 100644 index 0000000..cccada3 --- /dev/null +++ b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeColor.java @@ -0,0 +1,52 @@ +package MelonUtilities.command.arguments; + +import MelonUtilities.utility.MUtil; +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; + +import java.util.*; +import java.util.concurrent.CompletableFuture; + +public class ArgumentTypeColor implements ArgumentType { + private static final List EXAMPLES = Arrays.asList("red", "green", "blue"); + + public ArgumentTypeColor() { + } + + public static ArgumentType color() { + return new ArgumentTypeColor(); + } + + public String parse(StringReader reader) throws CommandSyntaxException { + final String string = reader.readString(); + + for (Map.Entry entry : MUtil.colorSectionMap.entrySet()) { + if (entry.getKey().equalsIgnoreCase(string)) { + return string; + } + } + throw new CommandSyntaxException(CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument(), () -> "Failed to Find Color: " + string + " (Color Doesn't Exist)"); + } + + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + for(Map.Entry entry : MUtil.colorSectionMap.entrySet()){ + if (entry.getKey().startsWith(builder.getRemainingLowerCase())) { + builder.suggest(entry.getKey()); + } + } + + return builder.buildFuture(); + } + + public Collection colors() { + return new ArrayList<>(MUtil.colorSectionMap.keySet()); + } + + public Collection getExamples() { + return EXAMPLES; + } +} diff --git a/src/main/java/MelonUtilities/command/arguments/ArgumentTypeHome.java b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeHome.java new file mode 100644 index 0000000..4a368bc --- /dev/null +++ b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeHome.java @@ -0,0 +1,57 @@ +package MelonUtilities.command.arguments; + +import MelonUtilities.config.Data; +import MelonUtilities.config.datatypes.data.Home; +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.core.entity.player.Player; +import net.minecraft.server.net.command.ServerCommandSource; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.concurrent.CompletableFuture; + +public class ArgumentTypeHome implements ArgumentType { + private static final List EXAMPLES = Arrays.asList("home", "base", "mobspawner"); + + public ArgumentTypeHome() { + } + + public static ArgumentType home() { + return new ArgumentTypeHome(); + } + + public String parse(StringReader reader) throws CommandSyntaxException { + return reader.readString(); + } + + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + + if(context.getSource() instanceof ServerCommandSource){ + Player sender = ((ServerCommandSource) context.getSource()).getSender(); + for(Home home : homes(sender)){ + if (home.name.startsWith(builder.getRemaining())) { + builder.suggest(home.name); + } + } + } + + return builder.buildFuture(); + } + + public Collection homes(Player sender) { + return new ArrayList<>(Data.Users.userDataHashMap.get(sender.uuid).homeData); + } + + + + public Collection getExamples() { + return EXAMPLES; + } +} diff --git a/src/main/java/MelonUtilities/command/arguments/ArgumentTypeRole.java b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeRole.java new file mode 100644 index 0000000..24a60f7 --- /dev/null +++ b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeRole.java @@ -0,0 +1,52 @@ +package MelonUtilities.command.arguments; + +import MelonUtilities.config.Data; +import MelonUtilities.config.datatypes.data.Role; +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import java.util.*; +import java.util.concurrent.CompletableFuture; + +public class ArgumentTypeRole implements ArgumentType{ + private static final List EXAMPLES = Arrays.asList("owner", "noob", "supporter"); + + public ArgumentTypeRole() { + } + + public static ArgumentType role() { + return new ArgumentTypeRole(); + } + + public Role parse(StringReader reader) throws CommandSyntaxException { + final String string = reader.readString(); + + for (Role role : roles()) { + if (role.roleID.equalsIgnoreCase(string)) { + return role; + } + } + throw new CommandSyntaxException(CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument(), () -> "Failed to find Role: " + string + " (Role Doesn't Exist)"); + } + + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + for(Role role : roles()){ + if (role.roleID.startsWith(builder.getRemaining())) { + builder.suggest(role.roleID); + } + } + + return builder.buildFuture(); + } + + public Collection roles() { + return new ArrayList<>(Data.Roles.roleDataHashMap.values()); + } + + public Collection getExamples() { + return EXAMPLES; + } +} diff --git a/src/main/java/MelonUtilities/command/arguments/ArgumentTypeUsername.java b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeUsername.java new file mode 100644 index 0000000..1c1d42f --- /dev/null +++ b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeUsername.java @@ -0,0 +1,115 @@ +package MelonUtilities.command.arguments; + +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.entity.player.PlayerServer; + +import java.util.Arrays; +import java.util.Collection; +import java.util.concurrent.CompletableFuture; + +public class ArgumentTypeUsername implements ArgumentType { + private final ArgumentTypeUsername.StringType type; + + @Override + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + for(PlayerServer player : MinecraftServer.getInstance().playerList.playerEntities){ + builder.suggest(player.username); + } + + return builder.buildFuture(); + } + + private ArgumentTypeUsername(ArgumentTypeUsername.StringType type) { + this.type = type; + } + + public static ArgumentTypeUsername word() { + return new ArgumentTypeUsername(ArgumentTypeUsername.StringType.SINGLE_WORD); + } + + public static ArgumentTypeUsername string() { + return new ArgumentTypeUsername(ArgumentTypeUsername.StringType.QUOTABLE_PHRASE); + } + + public static ArgumentTypeUsername greedyString() { + return new ArgumentTypeUsername(ArgumentTypeUsername.StringType.GREEDY_PHRASE); + } + + public static String getString(CommandContext context, String name) { + return (String)context.getArgument(name, String.class); + } + + public ArgumentTypeUsername.StringType getType() { + return this.type; + } + + public String parse(StringReader reader) throws CommandSyntaxException { + if (this.type == ArgumentTypeUsername.StringType.GREEDY_PHRASE) { + String text = reader.getRemaining(); + reader.setCursor(reader.getTotalLength()); + return text; + } else { + return this.type == ArgumentTypeUsername.StringType.SINGLE_WORD ? reader.readUnquotedString() : reader.readString(); + } + } + + public String toString() { + return "string()"; + } + + public Collection getExamples() { + return this.type.getExamples(); + } + + public static String escapeIfRequired(String input) { + char[] var1 = input.toCharArray(); + int var2 = var1.length; + + for(int var3 = 0; var3 < var2; ++var3) { + char c = var1[var3]; + if (!StringReader.isAllowedInUnquotedString(c)) { + return escape(input); + } + } + + return input; + } + + private static String escape(String input) { + StringBuilder result = new StringBuilder("\""); + + for(int i = 0; i < input.length(); ++i) { + char c = input.charAt(i); + if (c == '\\' || c == '"') { + result.append('\\'); + } + + result.append(c); + } + + result.append("\""); + return result.toString(); + } + + public static enum StringType { + SINGLE_WORD(new String[]{"word", "words_with_underscores"}), + QUOTABLE_PHRASE(new String[]{"\"quoted phrase\"", "word", "\"\""}), + GREEDY_PHRASE(new String[]{"word", "words with spaces", "\"and symbols\""}); + + private final Collection examples; + + private StringType(String... examples) { + this.examples = Arrays.asList(examples); + } + + public Collection getExamples() { + return this.examples; + } + } +} diff --git a/src/main/java/MelonUtilities/command/arguments/ArgumentTypeWarp.java b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeWarp.java new file mode 100644 index 0000000..d1a7a7d --- /dev/null +++ b/src/main/java/MelonUtilities/command/arguments/ArgumentTypeWarp.java @@ -0,0 +1,58 @@ +package MelonUtilities.command.arguments; + +import MelonUtilities.config.Data; +import MelonUtilities.config.datatypes.data.Warp; +import com.mojang.brigadier.StringReader; +import com.mojang.brigadier.arguments.ArgumentType; +import com.mojang.brigadier.context.CommandContext; +import com.mojang.brigadier.exceptions.CommandSyntaxException; +import com.mojang.brigadier.suggestion.Suggestions; +import com.mojang.brigadier.suggestion.SuggestionsBuilder; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.List; +import java.util.concurrent.CompletableFuture; + +public class ArgumentTypeWarp implements ArgumentType { + private static final List EXAMPLES = Arrays.asList("warp", "base", "mobspawner"); + + public ArgumentTypeWarp() { + } + + public static ArgumentType warp() { + return new ArgumentTypeWarp(); + } + + public Warp parse(StringReader reader) throws CommandSyntaxException { + final String string = reader.readString(); + + for (Warp warp : warps()) { + if (warp.name.equalsIgnoreCase(string)) { + return warp; + } + } + throw new CommandSyntaxException(CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherUnknownArgument(), () -> "Failed to find Warp: " + string + " (Warp Doesn't Exist)"); + } + + public CompletableFuture listSuggestions(CommandContext context, SuggestionsBuilder builder) { + for(Warp warp : warps()){ + if (warp.name.startsWith(builder.getRemaining())) { + builder.suggest(warp.name); + } + } + + return builder.buildFuture(); + } + + public Collection warps() { + return new ArrayList<>(Data.MainConfig.config.warpData); + } + + + + public Collection getExamples() { + return EXAMPLES; + } +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicElevator.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicElevator.java new file mode 100644 index 0000000..206ccc5 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicElevator.java @@ -0,0 +1,29 @@ +package MelonUtilities.command.commandlogic; + +import MelonUtilities.config.Data; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.feedback.FeedbackType; +import com.mojang.brigadier.Command; +import net.minecraft.server.entity.player.PlayerServer; + +public class CommandLogicElevator { + public static int elevatorAllowobstructions(PlayerServer sender){ + if(Data.MainConfig.config.allowObstructions){ + Data.MainConfig.config.allowObstructions = false; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Allow Obstructions Disabled"); + } else { + Data.MainConfig.config.allowObstructions = true; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Allow Obstructions Enabled!"); + } + return Command.SINGLE_SUCCESS; + } + + public static int elevatorCooldown(PlayerServer sender, int cooldownValue) { + Data.MainConfig.config.elevatorCooldown = cooldownValue; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Elevator Cooldown Set to %" + cooldownValue); + return Command.SINGLE_SUCCESS; + } +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicHome.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicHome.java new file mode 100644 index 0000000..33daa64 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicHome.java @@ -0,0 +1,56 @@ +package MelonUtilities.command.commandlogic; + +import MelonUtilities.config.Data; +import MelonUtilities.config.datatypes.data.Home; +import MelonUtilities.utility.MUtil; +import MelonUtilities.utility.feedback.FeedbackArg; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.feedback.FeedbackType; +import com.mojang.brigadier.Command; +import net.minecraft.core.net.command.TextFormatting; +import net.minecraft.server.entity.player.PlayerServer; + +public class CommandLogicHome { + public static int homeTP(PlayerServer sender, Home targetHome){ + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Teleporting to Home %s", new FeedbackArg(targetHome)); + MUtil.sendToHome(sender, targetHome); + return Command.SINGLE_SUCCESS; + } + + public static int homeList(PlayerServer sender){ + if (Data.Users.userDataHashMap.get(sender.uuid).homeData.isEmpty()) { + sender.sendMessage(TextFormatting.GRAY + "< " + TextFormatting.LIGHT_GRAY + "Homes: " + TextFormatting.GRAY + " >"); + sender.sendMessage(TextFormatting.GRAY + " -No Homes Created-"); + return Command.SINGLE_SUCCESS; + } + sender.sendMessage(TextFormatting.GRAY + "< " + TextFormatting.LIGHT_GRAY + "Homes: " + TextFormatting.GRAY + " >"); + for (Home home : Data.Users.userDataHashMap.get(sender.uuid).homeData) { + sender.sendMessage(TextFormatting.GRAY + " > " + TextFormatting.LIGHT_GRAY + home.toDescriptiveString()); + } + sender.sendMessage(TextFormatting.GRAY + "<>"); + return Command.SINGLE_SUCCESS; + } + + public static int homeDelete(PlayerServer sender, Home targetHome){ + Data.Users.getOrCreate(sender.uuid).homeData.remove(targetHome); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Deleted Home %s", new FeedbackArg(targetHome)); + return Command.SINGLE_SUCCESS; + } + + public static int homeCreate(PlayerServer sender, String name){ + Data.Users.getOrCreate(sender.uuid).homeData.add(new Home(name, sender.x, sender.y, sender.z, sender.dimension)); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Created Home %s", new FeedbackArg(name)); + return Command.SINGLE_SUCCESS; + } + + public static int homeRename(PlayerServer sender, Home targetHome, String name){ + Data.Users.getOrCreate(sender.uuid).homeData.remove(targetHome); + targetHome.name = name; + Data.Users.getOrCreate(sender.uuid).homeData.add(targetHome); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Renamed Home %s to %s", new FeedbackArg(targetHome), new FeedbackArg(name)); + return Command.SINGLE_SUCCESS; + } +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicLock.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicLock.java new file mode 100644 index 0000000..dbb9dbe --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicLock.java @@ -0,0 +1,490 @@ +package MelonUtilities.command.commandlogic; + +import MelonUtilities.config.Data; +import MelonUtilities.interfaces.Lockable; +import MelonUtilities.utility.MUtil; +import MelonUtilities.utility.feedback.FeedbackArg; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.feedback.FeedbackType; +import com.mojang.brigadier.Command; +import net.minecraft.core.block.entity.*; +import net.minecraft.core.util.collection.Pair; +import net.minecraft.core.util.helper.UUIDHelper; +import net.minecraft.core.util.phys.HitResult; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.entity.player.PlayerServer; + +import java.util.UUID; + +public class CommandLogicLock { + + public static int lock(PlayerServer sender){ + HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); + if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Lock Container! (Not Looking at Container)"); + return Command.SINGLE_SUCCESS; + } + + TileEntity container = sender.world.getTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); + if(container != null){ + if (container instanceof Lockable) { + Lockable lockable = ((Lockable) container); + if (!lockable.getIsLocked()) { + if (container instanceof TileEntityChest) { + Lockable otherLockable = (Lockable) MUtil.getOtherChest(sender.world, (TileEntityChest) container); + if (otherLockable != null) { + lockable.setIsLocked(true); + otherLockable.setIsLocked(true); + lockable.setLockOwner(sender.uuid); + otherLockable.setLockOwner(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locked Double Chest!"); + return Command.SINGLE_SUCCESS; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locked Chest!"); + } else if (container instanceof TileEntityFurnaceBlast) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locked Blast Furnace!"); + } else if (container instanceof TileEntityFurnace) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locked Furnace!"); + } else if (container instanceof TileEntityDispenser) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locked Dispenser!"); + } else if (container instanceof TileEntityMeshGold) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locked Golden Mesh!"); + } else if (container instanceof TileEntityTrommel) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locked Trommel!"); + } else if (container instanceof TileEntityBasket) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locked Basket!"); + } else if (container instanceof TileEntityActivator) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locked Activator!"); + } + + lockable.setIsLocked(true); + lockable.setLockOwner(sender.uuid); + return Command.SINGLE_SUCCESS; + + } else if (lockable.getIsLocked() && !lockable.getLockOwner().equals(sender.uuid)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Lock Container! (Not Owned By You)"); + return Command.SINGLE_SUCCESS; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Lock Container! (Already Locked)"); + return Command.SINGLE_SUCCESS; + } + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Lock Container! (Not Looking at Container)"); + return Command.SINGLE_SUCCESS; + } + + public static int lockOnBlockPlaced(PlayerServer sender){ + UUID senderUUID = sender.uuid; + + if(Data.Users.getOrCreate(senderUUID).lockOnBlockPlaced){ + Data.Users.getOrCreate(senderUUID).lockOnBlockPlaced = false; + Data.Users.save(senderUUID); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Locking on Block Placed Disabled"); + } else { + Data.Users.getOrCreate(senderUUID).lockOnBlockPlaced = true; + Data.Users.save(senderUUID); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locking on Block Placed Enabled!"); + } + return Command.SINGLE_SUCCESS; + } + + public static int lockOnBlockPunched(PlayerServer sender){ + UUID senderUUID = sender.uuid; + + if(Data.Users.getOrCreate(senderUUID).lockOnBlockPunched){ + Data.Users.getOrCreate(senderUUID).lockOnBlockPunched = false; + Data.Users.save(senderUUID); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Locking on Block Punched Disabled"); + } else { + Data.Users.getOrCreate(senderUUID).lockOnBlockPunched = true; + Data.Users.save(senderUUID); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Locking on Block Punched Enabled!"); + } + return Command.SINGLE_SUCCESS; + } + + public static int lockTrust(PlayerServer sender, String targetUsername){ + + Pair profile; + try { + profile = MUtil.getProfileFromUsername(targetUsername); + } catch (NullPointerException e) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust %s to Container! (Player Does not Exist)", new FeedbackArg(targetUsername)); + return 0; + } + String targetUsernameOrDisplayName = profile.getRight(); + UUID targetUUID = profile.getLeft(); + + HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); + if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust %s to Container! (Not Looking at Container)", new FeedbackArg(targetUsernameOrDisplayName)); + return Command.SINGLE_SUCCESS; + } + + TileEntity container = sender.world.getTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); + + if(container != null) { + if (container instanceof Lockable) { + Lockable lockable = ((Lockable) container); + if (lockable.getIsLocked()) { + + if (!lockable.getLockOwner().equals(sender.uuid)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust %s to Container! (Not Owned By You)", new FeedbackArg(targetUsernameOrDisplayName)); + return Command.SINGLE_SUCCESS; + } + + if (lockable.getTrustedPlayers().contains(targetUUID)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust %s to Container! (Player already Trusted)", new FeedbackArg(targetUsernameOrDisplayName)); + return Command.SINGLE_SUCCESS; + } + + if (container instanceof TileEntityChest) { + Lockable otherLockable = (Lockable) MUtil.getOtherChest(sender.world, (TileEntityChest) container); + if (otherLockable != null) { + lockable.addTrustedPlayer(targetUUID); + otherLockable.addTrustedPlayer(targetUUID); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to this Double Chest!", new FeedbackArg(targetUsernameOrDisplayName)); + return Command.SINGLE_SUCCESS; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to this Chest!", new FeedbackArg(targetUsernameOrDisplayName)); + } else if (container instanceof TileEntityFurnaceBlast) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to this Blast Furnace!", new FeedbackArg(targetUsernameOrDisplayName)); + } else if (container instanceof TileEntityFurnace) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to this Furnace!", new FeedbackArg(targetUsernameOrDisplayName)); + } else if (container instanceof TileEntityDispenser) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to this Dispenser!", new FeedbackArg(targetUsernameOrDisplayName)); + } else if (container instanceof TileEntityMeshGold) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to this Golden Mesh!", new FeedbackArg(targetUsernameOrDisplayName)); + } else if (container instanceof TileEntityTrommel) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to this Trommel!", new FeedbackArg(targetUsernameOrDisplayName)); + } else if (container instanceof TileEntityBasket) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to this Basket!", new FeedbackArg(targetUsernameOrDisplayName)); + } else if (container instanceof TileEntityActivator) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to this Activator!", new FeedbackArg(targetUsernameOrDisplayName)); + } + lockable.addTrustedPlayer(targetUUID); + } else { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust %s to Container! (Container not Locked)", new FeedbackArg(targetUsernameOrDisplayName)); + } + return Command.SINGLE_SUCCESS; + } + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust %s to Container! (Not Looking at Container)", new FeedbackArg(targetUsernameOrDisplayName)); + return Command.SINGLE_SUCCESS; + } + + public static int lockTrustAll(PlayerServer sender, String targetUsername){ + PlayerServer target = MinecraftServer.getInstance().playerList.getPlayerEntity(targetUsername); + UUID targetUUID; + + if(target != null){ + targetUUID = target.uuid; + String targetDisplayName = target.getDisplayName(); + if(!Data.Users.getOrCreate(sender.uuid).usersTrustedToAllContainers.containsKey(targetUUID)){ + + Data.Users.getOrCreate(sender.uuid).usersTrustedToAllContainers.put(targetUUID, targetUsername); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to all Containers!", new FeedbackArg(targetDisplayName)); + return Command.SINGLE_SUCCESS; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust %s to all Containers! (Player is Already Trusted)", new FeedbackArg(targetDisplayName)); + return Command.SINGLE_SUCCESS; + } else { + UUIDHelper.runConversionAction(targetUsername, targetuuid -> + { + if(!Data.Users.getOrCreate(sender.uuid).usersTrustedToAllContainers.containsKey(targetuuid)){ + + Data.Users.getOrCreate(sender.uuid).usersTrustedToAllContainers.put(targetuuid, targetUsername); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted %s to all Containers!", new FeedbackArg(targetUsername)); + return; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust %s to all Containers! (Player is Already Trusted)", new FeedbackArg(targetUsername)); + }, + username -> FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust %s to all Containers! (Player Does not Exist)", new FeedbackArg(targetUsername)) + ); + } + return Command.SINGLE_SUCCESS; + } + + public static int lockTrustCommunity(PlayerServer sender) { + HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); + if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust Community to Container! (Not Looking at Container)"); + return Command.SINGLE_SUCCESS; + } + + TileEntity container = sender.world.getTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); + + if(container != null) { + if (container instanceof Lockable) { + Lockable lockable = ((Lockable) container); + if (lockable.getIsLocked()) { + + if (!lockable.getLockOwner().equals(sender.uuid)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust Community to Container! (Not Owned By You)"); + return Command.SINGLE_SUCCESS; + } + + if (lockable.getIsCommunityContainer()){ + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust Community to Container! (Community already Trusted)"); + return Command.SINGLE_SUCCESS; + } + + if (container instanceof TileEntityChest) { + Lockable otherLockable = (Lockable) MUtil.getOtherChest(sender.world, (TileEntityChest) container); + if (otherLockable != null) { + lockable.setIsCommunityContainer(true); + otherLockable.setIsCommunityContainer(true); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted Community to this Double Chest!"); + return Command.SINGLE_SUCCESS; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted Community to this Chest!"); + } else if (container instanceof TileEntityFurnaceBlast) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted Community to this Blast Furnace!"); + } else if (container instanceof TileEntityFurnace) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted Community to this Furnace!"); + } else if (container instanceof TileEntityDispenser) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted Community to this Dispenser!"); + } else if (container instanceof TileEntityMeshGold) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted Community to this Golden Mesh!"); + } else if (container instanceof TileEntityTrommel) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted Community to this Trommel!"); + } else if (container instanceof TileEntityBasket) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted Community to this Basket!"); + } else if (container instanceof TileEntityActivator) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Trusted Community to this Activator!"); + } + lockable.setIsCommunityContainer(true); + } else { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust Community to Container! (Container not Locked)"); + } + return Command.SINGLE_SUCCESS; + } + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Trust Community to Container! (Not Looking at Container)"); + return Command.SINGLE_SUCCESS; + } + + public static int lockUntrust(PlayerServer sender, String targetUsername){ + PlayerServer target = MinecraftServer.getInstance().playerList.getPlayerEntity(targetUsername); + UUID targetUUID; + String targetDisplayName; + + if(target != null){ + targetUUID = target.uuid; + targetDisplayName = target.getDisplayName(); + } else { + targetUUID = UUIDHelper.getUUIDFromName(targetUsername); + if(targetUUID == null){ + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust %s from Container! (Player Does not Exist)", new FeedbackArg(targetUsername)); + return 0; + } + targetDisplayName = targetUsername; + } + + HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); + if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust %s from Container! (Not Looking at Container)", new FeedbackArg(targetDisplayName)); + return Command.SINGLE_SUCCESS; + } + + TileEntity container = sender.world.getTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); + + if(container != null) { + if (container instanceof Lockable) { + Lockable lockable = ((Lockable) container); + if (lockable.getIsLocked()) { + + if (!lockable.getLockOwner().equals(sender.uuid)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust %s from Container! (Not Owned By You)", new FeedbackArg(targetDisplayName)); + return Command.SINGLE_SUCCESS; + } + + if (!lockable.getTrustedPlayers().contains(targetUUID)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust %s from Container! (Player not Trusted)", new FeedbackArg(targetDisplayName)); + return Command.SINGLE_SUCCESS; + } + + if (container instanceof TileEntityChest) { + Lockable otherLockable = (Lockable) MUtil.getOtherChest(sender.world, (TileEntityChest) container); + if (otherLockable != null) { + lockable.removeTrustedPlayer(targetUUID); + otherLockable.removeTrustedPlayer(targetUUID); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from this Double Chest!", new FeedbackArg(targetDisplayName)); + return Command.SINGLE_SUCCESS; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from this Chest!", new FeedbackArg(targetDisplayName)); + } else if (container instanceof TileEntityFurnaceBlast) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from this Blast Furnace!", new FeedbackArg(targetDisplayName)); + } else if (container instanceof TileEntityFurnace) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from this Furnace!", new FeedbackArg(targetDisplayName)); + } else if (container instanceof TileEntityDispenser) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from this Dispenser!", new FeedbackArg(targetDisplayName)); + } else if (container instanceof TileEntityMeshGold) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from this Golden Mesh!", new FeedbackArg(targetDisplayName)); + } else if (container instanceof TileEntityTrommel) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from this Trommel!", new FeedbackArg(targetDisplayName)); + } else if (container instanceof TileEntityBasket) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from this Basket!", new FeedbackArg(targetDisplayName)); + } else if (container instanceof TileEntityActivator) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from this Activator!", new FeedbackArg(targetDisplayName)); + } + lockable.removeTrustedPlayer(targetUUID); + } else { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust %s from Container! (Container not Locked)", new FeedbackArg(targetDisplayName)); + } + return Command.SINGLE_SUCCESS; + } + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust %s from Container! (Not Looking at Container)", new FeedbackArg(targetDisplayName)); + return Command.SINGLE_SUCCESS; + } + + public static int lockUntrustAll(PlayerServer sender, String targetUsername){ + PlayerServer target = MinecraftServer.getInstance().playerList.getPlayerEntity(targetUsername); + UUID targetUUID; + + if(target != null){ + targetUUID = target.uuid; + String targetDisplayName = target.getDisplayName(); + if(Data.Users.getOrCreate(sender.uuid).usersTrustedToAllContainers.containsKey(targetUUID)){ + Data.Users.getOrCreate(sender.uuid).usersTrustedToAllContainers.remove(targetUUID); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from all Containers!", new FeedbackArg(targetDisplayName)); + return Command.SINGLE_SUCCESS; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust %s from all Containers! (Player is Not Trusted)", new FeedbackArg(targetDisplayName)); + return Command.SINGLE_SUCCESS; + } else { + UUIDHelper.runConversionAction(targetUsername, targetuuid -> { + if(Data.Users.getOrCreate(sender.uuid).usersTrustedToAllContainers.containsKey(targetuuid)){ + + Data.Users.getOrCreate(sender.uuid).usersTrustedToAllContainers.remove(targetuuid, targetUsername); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted %s from all Containers!", new FeedbackArg(targetUsername)); + return; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust %s from all Containers! (Player is Not Trusted)", new FeedbackArg(targetUsername)); + }, username -> FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust %s from all Containers! (Player Does not Exist)", new FeedbackArg(targetUsername))); + } + return Command.SINGLE_SUCCESS; + } + + public static int lockUntrustCommunity(PlayerServer sender){ + HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); + if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust Community from Container! (Not Looking at Container)"); + return Command.SINGLE_SUCCESS; + } + + TileEntity container = sender.world.getTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); + + if(container != null) { + if (container instanceof Lockable) { + Lockable lockable = ((Lockable) container); + if (lockable.getIsLocked()) { + + if (!lockable.getLockOwner().equals(sender.uuid)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust Community from Container! (Not Owned By You)"); + return Command.SINGLE_SUCCESS; + } + + if (!lockable.getIsCommunityContainer()){ + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust Community from Container! (Community not Trusted)"); + return Command.SINGLE_SUCCESS; + } + + if (container instanceof TileEntityChest) { + Lockable otherLockable = (Lockable) MUtil.getOtherChest(sender.world, (TileEntityChest) container); + if (otherLockable != null) { + lockable.setIsCommunityContainer(false); + otherLockable.setIsCommunityContainer(false); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted Community from this Double Chest!"); + return Command.SINGLE_SUCCESS; + } + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted Community from this Chest!"); + } else if (container instanceof TileEntityFurnaceBlast) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted Community from this Blast Furnace!"); + } else if (container instanceof TileEntityFurnace) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted Community from this Furnace!"); + } else if (container instanceof TileEntityDispenser) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted Community from this Dispenser!"); + } else if (container instanceof TileEntityMeshGold) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted Community from this Golden Mesh!"); + } else if (container instanceof TileEntityTrommel) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted Community from this Trommel!"); + } else if (container instanceof TileEntityBasket) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted Community from this Basket!"); + } else if (container instanceof TileEntityActivator) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Untrusted Community from this Activator!"); + } + lockable.setIsCommunityContainer(false); + } else { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust Community from Container!"); + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "(Container not Locked)"); + } + return Command.SINGLE_SUCCESS; + } + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Untrust Community from Container!"); + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "(Not Looking at Container)"); + return Command.SINGLE_SUCCESS; + } + + public static int lockBypass(PlayerServer sender){ + UUID senderUUID = sender.uuid; + + if(Data.Users.getOrCreate(senderUUID).lockBypass){ + Data.Users.getOrCreate(senderUUID).lockBypass = false; + Data.Users.save(senderUUID); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Lock Bypass Disabled"); + } else { + Data.Users.getOrCreate(senderUUID).lockBypass = true; + Data.Users.save(senderUUID); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Lock Bypass Enabled!"); + } + return Command.SINGLE_SUCCESS; + } + + public static int lockInfo(PlayerServer sender){ + HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); + if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to get info from Container! (Not Looking at Container)"); + return Command.SINGLE_SUCCESS; + } + + TileEntity container = sender.world.getTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); + + if(container != null) { + if (container instanceof Lockable) { + Lockable lockable = ((Lockable) container); + if (container instanceof TileEntityChest) { + Lockable otherLockable = (Lockable) MUtil.getOtherChest(sender.world, (TileEntityChest) container); + if (otherLockable != null) { + MUtil.sendContainerLockInfo(sender, lockable, "Double Chest"); + return Command.SINGLE_SUCCESS; + } + MUtil.sendContainerLockInfo(sender, lockable, "Chest"); + } else if (container instanceof TileEntityFurnaceBlast) { + MUtil.sendContainerLockInfo(sender, lockable, "Blast Furnace"); + } else if (container instanceof TileEntityFurnace) { + MUtil.sendContainerLockInfo(sender, lockable, "Furnace"); + } else if (container instanceof TileEntityDispenser) { + MUtil.sendContainerLockInfo(sender, lockable, "Dispenser"); + } else if (container instanceof TileEntityMeshGold) { + MUtil.sendContainerLockInfo(sender, lockable, "Gold Mesh"); + } else if (container instanceof TileEntityTrommel) { + MUtil.sendContainerLockInfo(sender, lockable, "Trommel"); + } else if (container instanceof TileEntityBasket) { + MUtil.sendContainerLockInfo(sender, lockable, "Basket"); + } else if (container instanceof TileEntityActivator) { + MUtil.sendContainerLockInfo(sender, lockable, "Activator"); + } + return Command.SINGLE_SUCCESS; + } + } + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to get info from Container! (Not Looking at Container)"); + return Command.SINGLE_SUCCESS; + } +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicMelonUtilities.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicMelonUtilities.java new file mode 100644 index 0000000..a0f90af --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicMelonUtilities.java @@ -0,0 +1,49 @@ +package MelonUtilities.command.commandlogic; + +import MelonUtilities.config.Data; +import MelonUtilities.utility.feedback.FeedbackArg; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.feedback.FeedbackType; +import com.mojang.brigadier.Command; +import net.minecraft.server.entity.player.PlayerServer; + +import static net.minecraft.server.player.PlayerListBox.updateList; + +public class CommandLogicMelonUtilities { + public static int melonutilitiesReload(PlayerServer sender){ + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Reloading MelonUtilities..."); + + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Reloading Player Data..."); + Data.Users.reload(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Reloaded %s Player(s)!", new FeedbackArg(Data.Users.userDataHashMap.size())); + + //TODO FeedbackHandler.sendFeedback(FeedbackType.destructive, source, "Building Helper Syntax..."); + //TODO HelperCommand.buildHelperSyntax(); + //TODO FeedbackHandler.sendFeedback(FeedbackType.success, source, "Helper Syntax Built!"); + + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Reloading Kit Data..."); + Data.Kits.reload(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Reloaded %s Kit(s)!", new FeedbackArg(Data.Kits.kitDataHashMap.size())); + + //TODO FeedbackHandler.sendFeedback(FeedbackType.destructive, source, "Building Kit Syntax..."); + //TODO KitCommand.buildKitSyntax(); + //TODO FeedbackHandler.sendFeedback(FeedbackType.success, source, "Kit Syntax Built!"); + + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Reloading Role Data..."); + Data.Roles.reload(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Reloaded %s Role(s)!", new FeedbackArg(Data.Roles.roleDataHashMap.size())); + + //TODO FeedbackHandler.sendFeedback(FeedbackType.destructive, source, "Building Rollback Syntax..."); + //TODO RollbackCommand.buildSyntax(); + //TODO FeedbackHandler.sendFeedback(FeedbackType.success, source, "Rollback Syntax Built!"); + + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Reloading General Configs..."); + Data.MainConfig.reload(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Reloaded Configs!"); + + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Updating Player List..."); + updateList(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Updated List!"); + return Command.SINGLE_SUCCESS; + } +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicRole.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicRole.java new file mode 100644 index 0000000..090c0bd --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicRole.java @@ -0,0 +1,461 @@ +package MelonUtilities.command.commandlogic; + +import MelonUtilities.config.Data; +import MelonUtilities.config.datatypes.data.Role; +import MelonUtilities.utility.MUtil; +import MelonUtilities.utility.builders.RoleBuilder; +import MelonUtilities.utility.classes.Icon; +import MelonUtilities.utility.feedback.FeedbackArg; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.feedback.FeedbackType; +import com.mojang.brigadier.Command; +import net.minecraft.core.entity.player.Player; +import net.minecraft.core.item.Items; +import net.minecraft.core.net.command.TextFormatting; +import net.minecraft.core.util.collection.Pair; +import net.minecraft.server.entity.player.PlayerServer; + +import java.util.UUID; + +@SuppressWarnings("SameReturnValue") +public class CommandLogicRole { + static Icon inputUsernameIcon = new Icon("[Input Username]", (byte) TextFormatting.WHITE.id, Items.LABEL.getDefaultStack()); + /*public static int role(PlayerServer sender) { + ServerGuiBuilder roleGui = new ServerGuiBuilder(); + + roleGui.setSize(0); + //------------------------------------- + roleGui.setContainerSlot(2, (roleGuiInventory -> new ServerSlotButton(roleGrantIcon.icon, roleGuiInventory, 2, () -> { + ServerGuiBuilder roleGrantGui = new ServerGuiBuilder(); + roleGrantGui.setSize((int)Math.floor((Data.Roles.roleDataHashMap.size() + 1) / 9.0F)); + int i = 0; + for(Role role : Data.Roles.roleDataHashMap.values()){ + int finalI = i; + Icon roleIcon = new Icon(role.roleID, (byte) TextFormatting.WHITE.id, Items.LABEL.getDefaultStack()); + //------------------------------------- + roleGrantGui.setContainerSlot(i, (roleGrantGuiInventory -> new ServerSlotButton(roleIcon.icon, roleGrantGuiInventory, finalI, () -> { + ServerGuiBuilder roleGrantToGui = new ServerGuiBuilder(); + List onlinePlayers = MinecraftServer.getInstance().playerList.playerEntities; + roleGrantToGui.setSize((int)Math.floor((onlinePlayers.size() + 2) / 9.0F)); + int j = 0; + for(PlayerServer target : onlinePlayers){ + int finalJ = j; + Icon playerIcon = new Icon(target.username, (byte) TextFormatting.WHITE.id, Items.ARMOR_CHESTPLATE_IRON.getDefaultStack()); + //------------------------------------- + roleGrantToGui.setContainerSlot(j, (roleGrantToGuiInventory -> new ServerSlotButton(playerIcon.icon, roleGrantToGuiInventory, finalJ, () -> { + roleGrant(sender, target, role); + sender.usePersonalCraftingInventory(); + }))); + //------------------------------------- + j++; + } + int finalJ1 = j; + roleGrantToGui.setContainerSlot(j+1, (roleGrantToGuiInventory -> new ServerSlotButton(inputUsernameIcon.icon, roleGrantToGuiInventory, finalJ1+1, () -> { + ((PlayerCustomInputFunctionInterface) sender).melonutilities$setCustomInputFunction(customInput -> roleGrant(sender, customInput, role)); + sender.usePersonalCraftingInventory(); + }))); + GuiHelper.openCustomServerGui(sender, roleGrantToGui.build(sender, "To Player: ")); + }))); + //------------------------------------- + i++; + } + GuiHelper.openCustomServerGui(sender, roleGrantGui.build(sender, "Grant Role: ")); + }))); + //------------------------------------- + roleGui.setContainerSlot(3, (inventory -> new ServerSlotButton(roleReloadIcon.icon, inventory, 3, () -> { + roleReload(sender); + sender.usePersonalCraftingInventory(); + }))); + //------------------------------------- + roleGui.setContainerSlot(5, (inventory -> new ServerSlotButton(roleListIcon.icon, inventory, 5, () -> { + roleList(sender); + sender.usePersonalCraftingInventory(); + }))); + //------------------------------------- + roleGui.setContainerSlot(6, (inventory -> new ServerSlotButton(roleRevokeIcon.icon, inventory, 6, () -> { + ServerGuiBuilder roleRevokeGui = new ServerGuiBuilder(); + roleRevokeGui.setSize(0); + + }))); + //------------------------------------- + GuiHelper.openCustomServerGui(sender, roleGui.build(sender, "Role Command:")); + + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Opened Role GUI!"); + return Command.SINGLE_SUCCESS; + }*/ + + //static Icon roleReloadIcon = new Icon("[Reload]", (byte) TextFormatting.ORANGE.id, Items.REPEATER.getDefaultStack()); + public static int roleReload(PlayerServer sender) { + Data.Roles.reload(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Reloaded %s Role(s)!", new FeedbackArg(Data.Roles.roleDataHashMap.size())); + Data.MainConfig.reload(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Reloaded Config!"); + return Command.SINGLE_SUCCESS; + } + + //static Icon roleListIcon = new Icon("[List]", (byte) TextFormatting.LIGHT_GRAY.id, Items.PAPER.getDefaultStack()); + public static int roleList(PlayerServer sender) { + if (Data.Roles.roleDataHashMap.isEmpty()) { + sender.sendMessage(TextFormatting.GRAY + "< " + TextFormatting.LIGHT_GRAY + "Roles: " + TextFormatting.GRAY + " >"); + sender.sendMessage(TextFormatting.GRAY + " -No Roles Created-"); + return Command.SINGLE_SUCCESS; + } + sender.sendMessage(TextFormatting.GRAY + "< " + TextFormatting.LIGHT_GRAY + "Roles: " + TextFormatting.GRAY + " >"); + for (Role role : Data.Roles.roleDataHashMap.values()) { + sender.sendMessage(TextFormatting.GRAY + " > " + TextFormatting.LIGHT_GRAY + "Role ID: " + TextFormatting.GRAY + "[" + TextFormatting.LIGHT_GRAY + role.roleID + TextFormatting.GRAY + "]" + TextFormatting.LIGHT_GRAY + " - Priority: " + TextFormatting.GRAY + "[" + TextFormatting.LIGHT_GRAY + role.priority + TextFormatting.GRAY + "]"); + sender.sendMessage(TextFormatting.GRAY + " > " + RoleBuilder.buildRoleDisplay(role) + + RoleBuilder.buildRoleUsername(role, sender.getDisplayName()) + + RoleBuilder.buildRoleTextFormat(role) + "text" + ); + } + sender.sendMessage(TextFormatting.GRAY + "<>"); + return Command.SINGLE_SUCCESS; + } + + //static Icon roleRevokeIcon = new Icon("[Revoke]", (byte) TextFormatting.RED.id, Items.DUST_REDSTONE.getDefaultStack()); + public static int roleRevoke(PlayerServer sender, Player target, Role role){ + + if (role.playersGrantedRole.contains(target.uuid)) { + role.playersGrantedRole.remove(target.uuid); + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Revoked Role %s from Player %s", new FeedbackArg(role.roleID), new FeedbackArg(target.getDisplayName())); + } else { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Revoke Role %s from Player %s", new FeedbackArg(role.roleID), new FeedbackArg(target.getDisplayName())); + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "(Player does not have Role!)"); + } + + return Command.SINGLE_SUCCESS; + } + + //static Icon roleGrantIcon = new Icon("[Grant]", (byte) TextFormatting.LIME.id, Items.OLIVINE.getDefaultStack()); + public static void roleGrant(PlayerServer sender, String targetUsername, Role role) { + Pair profile; + try { + profile = MUtil.getProfileFromUsername(targetUsername); + } catch (NullPointerException e) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Grant Role %s to Player %s (Player Does not Exist)", new FeedbackArg(role.roleID), new FeedbackArg(targetUsername)); + return; + } + + String targetUsernameOrDisplayName = profile.getRight(); + UUID targetUUID = profile.getLeft(); + + if (!role.playersGrantedRole.contains(targetUUID)) { + role.playersGrantedRole.add(targetUUID); + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Granted Role %s to Player %s", new FeedbackArg(role.roleID), new FeedbackArg(targetUsernameOrDisplayName)); + } else { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Grant Role %s to Player %s", new FeedbackArg(role.roleID), new FeedbackArg(targetUsernameOrDisplayName)); + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "(Player already has Role!)"); + } + } + + public static int roleGrant(PlayerServer sender, Player target, Role role){ + if (!role.playersGrantedRole.contains(target.uuid)){ + role.playersGrantedRole.add(target.uuid); + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Granted Role %s to Player %s", new FeedbackArg(role.roleID), new FeedbackArg(target.getDisplayName())); + } else { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Grant Role %s to Player %s", new FeedbackArg(role.roleID), new FeedbackArg(target.getDisplayName())); + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "(Player already has Role!)"); + return 0; + } + return Command.SINGLE_SUCCESS; + } + + public static int roleCreate(PlayerServer sender, String roleID, int rolePriority) { + if (Data.Roles.roleDataHashMap.containsKey(roleID)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Failed to Create Role with RoleID %s (Role Already Exists)", new FeedbackArg(roleID)); + return Command.SINGLE_SUCCESS; + } + Role role = Data.Roles.create(roleID); + role.displayName = roleID; + role.priority = rolePriority; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Created Role %s with Priority %s", new FeedbackArg(role.roleID), new FeedbackArg(role.priority)); + return Command.SINGLE_SUCCESS; + } + + public static int roleDelete(PlayerServer sender, Role role) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Deleted Role %s", new FeedbackArg(role.roleID)); + role.delete(); + return Command.SINGLE_SUCCESS; + } + + public static int roleSetDefaultroleROLEID(PlayerServer sender, Role role) { + Data.MainConfig.config.defaultRole = role.roleID; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Default Role to %s", new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + + } + + public static int roleSetDefaultroleNone(PlayerServer sender) { + Data.MainConfig.config.defaultRole = null; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Removed Default Role"); + return Command.SINGLE_SUCCESS; + } + + public static int roleSetDisplaymodeSingle(PlayerServer sender) { + Data.MainConfig.config.displayMode = "single"; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Mode to %s", new FeedbackArg("single")); + return Command.SINGLE_SUCCESS; + } + + public static int roleSetDisplaymodeMulti(PlayerServer sender) { + Data.MainConfig.config.displayMode = "multi"; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Mode to %s", new FeedbackArg("multi")); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditPriority(PlayerServer sender, Role role, int priorityValue){ + role.priority = priorityValue; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Priority for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(priorityValue)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayName(PlayerServer sender, Role role, String displayName) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Name for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(displayName)); + role.displayName = displayName; + role.save(); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayColorCOLOR(PlayerServer sender, Role role, String color) { + role.displayColor = color; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Color for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg().argColor(TextFormatting.getColorFormatting(color))); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayColorHEX(PlayerServer sender, Role role, String hex) { + role.displayColor = hex; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Color for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg("#" + hex).argColor(hex)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayUnderline(PlayerServer sender, Role role, boolean value) { + role.isDisplayUnderlined = value; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Underline for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(value)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayBold(PlayerServer sender, Role role, boolean value) { + role.isDisplayBold = value; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Bold for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(value)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayItalics(PlayerServer sender, Role role, boolean value) { + role.isDisplayItalics = value; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Italics for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(value)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayBorderColorCOLOR(PlayerServer sender, Role role, String color) { + role.displayBorderColor = color; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Border Color for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(color).argColor(TextFormatting.getColorFormatting(color))); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayBorderColorHEX(PlayerServer sender, Role role, String hex) { + role.displayBorderColor = hex; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Border Color for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg("#" + hex).argColor(hex)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayBorderStyleNone(PlayerServer sender, Role role) { + role.isUsernameBorderBracket = false; + role.isUsernameBorderNone = true; + role.isUsernameBorderCaret = false; + role.isUsernameBorderCurly = false; + role.isUsernameBorderCustom = false; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Border to %s for Role %s", new FeedbackArg("□None□").noBorder(), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayBorderStyleBracket(PlayerServer sender, Role role) { + role.isDisplayBorderBracket = true; + role.isDisplayBorderNone = false; + role.isDisplayBorderCaret = false; + role.isDisplayBorderCurly = false; + role.isDisplayBorderCustom = false; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Border to %s for Role %s", new FeedbackArg("Bracket").bracketBorder(), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayBorderStyleCurly(PlayerServer sender, Role role) { + role.isDisplayBorderBracket = false; + role.isDisplayBorderNone = false; + role.isDisplayBorderCaret = false; + role.isDisplayBorderCurly = true; + role.isDisplayBorderCustom = false; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Border to %s for Role %s", new FeedbackArg("Curly").curlyBorder(), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayBorderStyleCaret(PlayerServer sender, Role role) { + role.isDisplayBorderBracket = false; + role.isDisplayBorderNone = false; + role.isDisplayBorderCaret = true; + role.isDisplayBorderCurly = false; + role.isDisplayBorderCustom = false; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Border to %s for Role %s", new FeedbackArg("Caret").caretBorder(), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayBorderStyleCustomPrefix(PlayerServer sender, Role role, String customAffix) { + role.isDisplayBorderBracket = false; + role.isDisplayBorderNone = false; + role.isDisplayBorderCaret = false; + role.isDisplayBorderCurly = false; + role.isDisplayBorderCustom = true; + role.customDisplayBorderPrefix = customAffix; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Border Prefix to %s for Role %s", new FeedbackArg(customAffix), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditDisplayBorderStyleCustomSuffix(PlayerServer sender, Role role, String customAffix) { + role.isDisplayBorderBracket = false; + role.isDisplayBorderNone = false; + role.isDisplayBorderCaret = false; + role.isDisplayBorderCurly = false; + role.isDisplayBorderCustom = true; + role.customDisplayBorderSuffix = customAffix; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Display Border Suffix to %s for Role %s", new FeedbackArg(customAffix), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditUsernameBorderColorCOLOR(PlayerServer sender, Role role, String color) { + role.usernameBorderColor = color; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Username Border Color for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(color).argColor(TextFormatting.getColorFormatting(color))); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditUsernameBorderColorHEX(PlayerServer sender, Role role, String hex) { + role.usernameBorderColor = hex; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Username Border Color for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg("#" + hex).argColor(hex)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditUsernameBorderStyleNone(PlayerServer sender, Role role) { + role.isUsernameBorderBracket = false; + role.isUsernameBorderNone = true; + role.isUsernameBorderCaret = false; + role.isUsernameBorderCurly = false; + role.isUsernameBorderCustom = false; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Username Border to %s for Role %s", new FeedbackArg("□None□").noBorder(), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditUsernameBorderStyleBracket(PlayerServer sender, Role role) { + role.isUsernameBorderBracket = true; + role.isUsernameBorderNone = false; + role.isUsernameBorderCaret = false; + role.isUsernameBorderCurly = false; + role.isUsernameBorderCustom = false; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Username Border to %s for Role %s", new FeedbackArg("Bracket").bracketBorder(), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditUsernameBorderStyleCurly(PlayerServer sender, Role role) { + role.isUsernameBorderBracket = false; + role.isUsernameBorderNone = false; + role.isUsernameBorderCaret = false; + role.isUsernameBorderCurly = true; + role.isUsernameBorderCustom = false; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Username Border to %s for Role %s", new FeedbackArg("Curly").curlyBorder(), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditUsernameBorderStyleCaret(PlayerServer sender, Role role) { + role.isUsernameBorderBracket = false; + role.isUsernameBorderNone = false; + role.isUsernameBorderCaret = true; + role.isUsernameBorderCurly = false; + role.isUsernameBorderCustom = false; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Username Border to %s for Role %s", new FeedbackArg("Caret").caretBorder(), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditUsernameBorderStyleCustomPrefix(PlayerServer sender, Role role, String customAffix) { + role.isUsernameBorderBracket = false; + role.isUsernameBorderNone = false; + role.isUsernameBorderCaret = false; + role.isUsernameBorderCurly = false; + role.isUsernameBorderCustom = true; + role.customUsernameBorderPrefix = customAffix; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Username Border Prefix to %s for Role %s", new FeedbackArg(customAffix), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditUsernameBorderStyleCustomSuffix(PlayerServer sender, Role role, String customAffix) { + role.isUsernameBorderBracket = false; + role.isUsernameBorderNone = false; + role.isUsernameBorderCaret = false; + role.isUsernameBorderCurly = false; + role.isUsernameBorderCustom = true; + role.customUsernameBorderSuffix = customAffix; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Username Border Suffix to %s for Role %s", new FeedbackArg(customAffix), new FeedbackArg(role.roleID)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditTextColorCOLOR(PlayerServer sender, Role role, String color) { + role.textColor = color; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Text Color for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(color).argColor(TextFormatting.getColorFormatting(color))); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditTextColorHEX(PlayerServer sender, Role role, String hex) { + role.textColor = hex; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Text Color for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg("#" + hex).argColor(hex)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditTextUnderline(PlayerServer sender, Role role, boolean value) { + role.isTextUnderlined = value; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Text Underline for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(value)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditTextBold(PlayerServer sender, Role role, boolean value) { + role.isTextBold = value; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Text Bold for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(value)); + return Command.SINGLE_SUCCESS; + } + + public static int roleEditTextItalics(PlayerServer sender, Role role, boolean value) { + role.isTextItalics = value; + role.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Set Text Italics for Role %s to %s", new FeedbackArg(role.roleID), new FeedbackArg(value)); + return Command.SINGLE_SUCCESS; + } +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicRollback.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicRollback.java new file mode 100644 index 0000000..ee41e3f --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicRollback.java @@ -0,0 +1,220 @@ +package MelonUtilities.command.commandlogic; + +import MelonUtilities.config.Data; +import MelonUtilities.utility.MUtil; +import MelonUtilities.utility.feedback.FeedbackArg; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.feedback.FeedbackType; +import MelonUtilities.utility.managers.RollbackManager; +import com.mojang.brigadier.Command; +import com.mojang.nbt.NbtIo; +import com.mojang.nbt.tags.CompoundTag; +import net.minecraft.core.entity.Entity; +import net.minecraft.core.entity.player.Player; +import net.minecraft.core.item.ItemStack; +import net.minecraft.core.item.Items; +import net.minecraft.core.net.command.TextFormatting; +import net.minecraft.core.net.packet.PacketBlockRegionUpdate; +import net.minecraft.core.world.chunk.Chunk; +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.entity.player.PlayerServer; +import org.useless.serverlibe.api.gui.GuiHelper; +import org.useless.serverlibe.api.gui.ServerGuiBuilder; +import org.useless.serverlibe.api.gui.slot.ServerSlotButton; + +import java.io.File; +import java.io.IOException; +import java.nio.file.Files; +import java.text.SimpleDateFormat; +import java.util.HashMap; +import java.util.Map; + +import static MelonUtilities.utility.managers.RollbackManager.*; + +public class CommandLogicRollback { + public static int rollback(PlayerServer sender) { + int x1 = sender.chunkCoordX; + int z1 = sender.chunkCoordZ; + + File chunkDir = new File("./rollbackdata/snapshots/" + sender.world.dimension.id + "/c[x." + x1 + "-z." + z1 + "]"); + chunkDir.mkdirs(); + + if (!chunkDir.isDirectory()){ + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Chunk has never been Modified!"); + return 0; + } + + HashMap captures = RollbackManager.getSortedCaptures(sender.world, chunkDir); + + ServerGuiBuilder rollbackGui = new ServerGuiBuilder(); + rollbackGui.setSize((int)Math.floor((captures.size() + 1) / 9.0F)); + int i = 0; + for(Map.Entry capture : captures.entrySet()){ + int finalI = i; + if(capture.getValue().getName().contains(".dat")){ + rollbackGui.setContainerSlot(i, (inventory -> + { + ItemStack snapshotIcon = Items.PAPER.getDefaultStack(); + SimpleDateFormat sdf = new SimpleDateFormat("MMM/dd/yyyy HH:mm:ss"); + snapshotIcon.setCustomName("Snapshot: [" + sdf.format(capture.getKey()) + "]"); + snapshotIcon.setCustomColor((byte) TextFormatting.LIGHT_BLUE.id); + return new ServerSlotButton(snapshotIcon, inventory, finalI, () -> { + for(Entity entity : sender.world.loadedEntityList){ + if(entity.chunkCoordX == x1 && entity.chunkCoordZ == z1){ + if(!(entity instanceof Player)){ + entity.remove(); + } + } + } + try { + CompoundTag tag = NbtIo.readCompressed(Files.newInputStream(capture.getValue().toPath())); + rollbackChunk(sender.world.getChunkFromChunkCoords(x1, z1), tag); + MinecraftServer.getInstance().playerList.sendPacketToAllPlayersInDimension(new PacketBlockRegionUpdate(x1 * 16, 0, z1 * 16, 16, 256, 16, sender.world), sender.world.dimension.id); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "%s Rolled Back to %s", new FeedbackArg(x1, z1), new FeedbackArg(sdf.format(capture.getKey()))); + sender.usePersonalCraftingInventory(); + } catch (IOException e) { + throw new RuntimeException(e); + } + }); + })); + } else if(capture.getValue().getName().contains(".mcr")){ + rollbackGui.setContainerSlot(i, (inventory -> + { + ItemStack backupIcon = Items.BOOK.getDefaultStack(); + SimpleDateFormat sdf = new SimpleDateFormat("MMM/dd/yyyy HH:mm:ss"); + backupIcon.setCustomName("Backup: [" + sdf.format(capture.getKey()) + "]"); + backupIcon.setCustomColor((byte) TextFormatting.CYAN.id); + return new ServerSlotButton(backupIcon, inventory, finalI, () -> { + for(Entity entity : sender.world.loadedEntityList){ + if(entity.chunkCoordX == x1 && entity.chunkCoordZ == z1){ + if(!(entity instanceof Player)){ + entity.remove(); + } + } + } + File backupDir = capture.getValue().getParentFile().getParentFile().getParentFile(); + Chunk chunk1 = sender.world.getChunkFromChunkCoords(x1, z1); + rollbackChunkFromBackup(chunk1, backupDir); + MinecraftServer.getInstance().playerList.sendPacketToAllPlayersInDimension(new PacketBlockRegionUpdate(chunk1.xPosition * 16, 0, chunk1.zPosition * 16, 16, 256, 16, sender.world), sender.world.dimension.id); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "%s Rolled Back to %s", new FeedbackArg(x1, z1), new FeedbackArg(sdf.format(capture.getKey()))); + sender.usePersonalCraftingInventory(); + }); + })); + } + i++; + } + GuiHelper.openCustomServerGui(sender, rollbackGui.build(sender, "Captures:")); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Opened Rollback GUI!"); + return Command.SINGLE_SUCCESS; + } + + public static int rollbackArea(PlayerServer sender, int x1, int z1, int x2, int z2) { + File chunkDir = new File("./rollbackdata/snapshots/" + sender.world.dimension.id + "/c[x." + x1 + "-z." + z1 + "]"); + chunkDir.mkdirs(); + + if (!chunkDir.isDirectory()){ + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "Chunk has never been Modified!"); + return 0; + } + + + HashMap captures = null; + int minX = Math.min(x1, x2); + int maxX = Math.max(x1, x2); + int minZ = Math.min(z1, z2); + int maxZ = Math.max(z1, z2); + for (int _x = minX; _x <= maxX; _x++) { + for (int _z = minZ; _z <= maxZ; _z++) { + HashMap _captures = RollbackManager.getSortedCaptures(sender.world, new File("./rollbackdata/snapshots/" + sender.world.dimension.id + "/c[x." + _x + "-z." + _z + "]")); + if (captures == null || captures.size() < _captures.size()) { + captures = _captures; + } + } + } + ServerGuiBuilder rollbackGui = new ServerGuiBuilder(); + rollbackGui.setSize((int)Math.ceil((captures.size() + 1) / 9.0F)); + int i = 0; + for(Map.Entry capture : captures.entrySet()){ + int finalI = i; + if(capture.getValue().getName().contains(".dat")){ + rollbackGui.setContainerSlot(i, (inventory -> + { + ItemStack snapshotIcon = Items.PAPER.getDefaultStack(); + SimpleDateFormat sdf = new SimpleDateFormat("MMM/dd/yyyy HH:mm:ss"); + snapshotIcon.setCustomName("Snapshot: [" + sdf.format(capture.getKey()) + "]"); + snapshotIcon.setCustomColor((byte) TextFormatting.LIME.id); + return new ServerSlotButton(snapshotIcon, inventory, finalI, () -> { + RollbackManager.rollbackChunkArea(sender, MUtil.getChunkGridFromCorners(sender.world, x1, z1, x2, z2), capture); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "%s "+ TextFormatting.ORANGE + "- %s Rolled Back to " + TextFormatting.ORANGE + "~%s", new FeedbackArg(x1,z1), new FeedbackArg(x2,z2), new FeedbackArg(sdf.format(capture.getKey()))); + }); + })); + } else if(capture.getValue().getName().contains(".mcr")){ + rollbackGui.setContainerSlot(i, (inventory -> + { + ItemStack backupIcon = Items.BOOK.getDefaultStack(); + SimpleDateFormat sdf = new SimpleDateFormat("MMM/dd/yyyy HH:mm:ss"); + backupIcon.setCustomName("Backup: [" + sdf.format(capture.getKey()) + "]"); + backupIcon.setCustomColor((byte) TextFormatting.GREEN.id); + return new ServerSlotButton(backupIcon, inventory, finalI, () -> { + RollbackManager.rollbackChunkArea(sender, MUtil.getChunkGridFromCorners(sender.world, x1, z1, x2, z2), capture); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "%s "+ TextFormatting.ORANGE + "- %s Rolled Back to " + TextFormatting.ORANGE + "~%s", new FeedbackArg(x1,z1), new FeedbackArg(x2,z2), new FeedbackArg(sdf.format(capture.getKey()))); + }); + })); + } + i++; + } + GuiHelper.openCustomServerGui(sender, rollbackGui.build(sender, "Captures:")); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Opened Rollback GUI!"); + return Command.SINGLE_SUCCESS; + } + + public static int rollbackTakeSnapshot(PlayerServer sender) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Taking a Snapshot!"); + takeSnapshot(); + return Command.SINGLE_SUCCESS; + } + + public static int rollbackTakeBackup(PlayerServer sender) { + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Taking a Backup!"); + takeBackup(); + return Command.SINGLE_SUCCESS; + } + + public static int rollbackPruneSnapshots(PlayerServer sender) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Pruning Snapshots.."); + pruneSnapshots(); + return Command.SINGLE_SUCCESS; + } + + public static int rollbackPruneBackups(PlayerServer sender) { + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Pruning Backups.."); + pruneBackups(); + return Command.SINGLE_SUCCESS; + } + + public static int rollbackAutoSnapshots(PlayerServer sender) { + if(Data.MainConfig.config.snapshotsEnabled){ + Data.MainConfig.config.snapshotsEnabled = false; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Automatic Snapshots Disabled"); + } else { + Data.MainConfig.config.snapshotsEnabled = true; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Automatic Snapshots Enabled!"); + } + return Command.SINGLE_SUCCESS; + } + + public static int rollbackAutoBackups(PlayerServer sender) { + if(Data.MainConfig.config.backupsEnabled){ + Data.MainConfig.config.backupsEnabled = false; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Automatic Backups Disabled"); + } else { + Data.MainConfig.config.backupsEnabled = true; + Data.MainConfig.save(); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Automatic Backups Enabled!"); + } + return Command.SINGLE_SUCCESS; + } +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicTPA.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicTPA.java new file mode 100644 index 0000000..718d46b --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicTPA.java @@ -0,0 +1,37 @@ +package MelonUtilities.command.commandlogic; + +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.feedback.FeedbackType; +import MelonUtilities.utility.managers.TpaManager; +import com.mojang.brigadier.Command; +import net.minecraft.server.entity.player.PlayerServer; + +public class CommandLogicTPA { + public static int tpa(PlayerServer sender, String targetUsername) { + + assert sender.world != null; + PlayerServer target = (PlayerServer) sender.world.getPlayerEntityByName(targetUsername); + + if (target != null) { + TpaManager.addRequest(sender, target, false); + } else { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, targetUsername + " does not exist!"); + } + + return Command.SINGLE_SUCCESS; + } + + public static int tpaccept(PlayerServer sender){ + if (!TpaManager.acceptRequest(sender)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "No pending request found to accept!"); + } + return Command.SINGLE_SUCCESS; + } + + public static int tpdeny(PlayerServer sender){ + if (!TpaManager.denyRequest(sender)) { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, "No pending request found to deny!"); + } + return Command.SINGLE_SUCCESS; + } +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicTPAHere.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicTPAHere.java new file mode 100644 index 0000000..c3cc6a5 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicTPAHere.java @@ -0,0 +1,23 @@ +package MelonUtilities.command.commandlogic; + +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.feedback.FeedbackType; +import MelonUtilities.utility.managers.TpaManager; +import com.mojang.brigadier.Command; +import net.minecraft.server.entity.player.PlayerServer; + +public class CommandLogicTPAHere { + public static int tpaHere(PlayerServer sender, String targetUsername){ + + assert sender.world != null; + PlayerServer target = (PlayerServer) sender.world.getPlayerEntityByName(targetUsername); + + if(target != null){ + TpaManager.addRequest(sender, target, true); + } else { + FeedbackHandlerServer.sendFeedback(FeedbackType.error, sender, targetUsername + " does not exist!"); + } + + return Command.SINGLE_SUCCESS; + } +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicUnlock.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicUnlock.java new file mode 100644 index 0000000..3878d79 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicUnlock.java @@ -0,0 +1,4 @@ +package MelonUtilities.command.commandlogic; + +public class CommandLogicUnlock { +} diff --git a/src/main/java/MelonUtilities/command/commandlogic/CommandLogicWarp.java b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicWarp.java new file mode 100644 index 0000000..648dc55 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commandlogic/CommandLogicWarp.java @@ -0,0 +1,56 @@ +package MelonUtilities.command.commandlogic; + +import MelonUtilities.config.Data; +import MelonUtilities.config.datatypes.data.Warp; +import MelonUtilities.utility.MUtil; +import MelonUtilities.utility.feedback.FeedbackArg; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.feedback.FeedbackType; +import com.mojang.brigadier.Command; +import net.minecraft.core.net.command.TextFormatting; +import net.minecraft.server.entity.player.PlayerServer; + +public class CommandLogicWarp { + public static int warpTP(PlayerServer sender, Warp targetWarp){ + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Teleporting to Warp %s", new FeedbackArg(targetWarp)); + MUtil.sendToWarp(sender, targetWarp); + return Command.SINGLE_SUCCESS; + } + + public static int warpList(PlayerServer sender){ + if (Data.MainConfig.config.warpData.isEmpty()) { + sender.sendMessage(TextFormatting.GRAY + "< " + TextFormatting.LIGHT_GRAY + "Warps: " + TextFormatting.GRAY + " >"); + sender.sendMessage(TextFormatting.GRAY + " -No Warps Created-"); + return Command.SINGLE_SUCCESS; + } + sender.sendMessage(TextFormatting.GRAY + "< " + TextFormatting.LIGHT_GRAY + "Warps: " + TextFormatting.GRAY + " >"); + for (Warp warp : Data.MainConfig.config.warpData) { + sender.sendMessage(TextFormatting.GRAY + " > " + TextFormatting.LIGHT_GRAY + warp.toDescriptiveString()); + } + sender.sendMessage(TextFormatting.GRAY + "<>"); + return Command.SINGLE_SUCCESS; + } + + public static int warpDelete(PlayerServer sender, Warp targetWarp){ + Data.MainConfig.config.warpData.remove(targetWarp); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.destructive, sender, "Deleted Warp %s", new FeedbackArg(targetWarp)); + return Command.SINGLE_SUCCESS; + } + + public static int warpCreate(PlayerServer sender, String name){ + Data.MainConfig.config.warpData.add(new Warp(name, sender.x, sender.y, sender.z, sender.dimension)); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Created Warp %s", new FeedbackArg(name)); + return Command.SINGLE_SUCCESS; + } + + public static int warpRename(PlayerServer sender, Warp targetWarp, String name){ + Data.MainConfig.config.warpData.remove(targetWarp); + targetWarp.name = name; + Data.MainConfig.config.warpData.add(targetWarp); + Data.Users.save(sender.uuid); + FeedbackHandlerServer.sendFeedback(FeedbackType.success, sender, "Renamed Warp %s to %s", new FeedbackArg(targetWarp), new FeedbackArg(name)); + return Command.SINGLE_SUCCESS; + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandElevator.java b/src/main/java/MelonUtilities/command/commands/CommandElevator.java new file mode 100644 index 0000000..19433bc --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandElevator.java @@ -0,0 +1,51 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.commandlogic.CommandLogicElevator; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.arguments.IntegerArgumentType; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import com.mojang.brigadier.builder.RequiredArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.server.entity.player.PlayerServer; + +public class CommandElevator implements CommandManager.CommandRegistry{ + + public static ArgumentBuilder> elevatorAllowObstructions(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("allowobstructions") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicElevator.elevatorAllowobstructions(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> elevatorCooldown(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("cooldown") + .then(RequiredArgumentBuilder.argument("cooldownvalue", IntegerArgumentType.integer(0, 256)) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + int cooldownValue = context.getArgument("cooldownvalue", Integer.class); + return CommandLogicElevator.elevatorCooldown(sender, cooldownValue); + } + ) + ) + ); + return builder; + } + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder builder = LiteralArgumentBuilder.literal("elevator").requires(CommandSource::hasAdmin); + + elevatorAllowObstructions(builder); + elevatorCooldown(builder); + + dispatcher.register(builder); + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandHome.java b/src/main/java/MelonUtilities/command/commands/CommandHome.java new file mode 100644 index 0000000..da757ec --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandHome.java @@ -0,0 +1,120 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.arguments.ArgumentTypeHome; +import MelonUtilities.command.commandlogic.CommandLogicHome; +import MelonUtilities.config.Data; +import MelonUtilities.config.datatypes.data.Home; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.arguments.StringArgumentType; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import com.mojang.brigadier.builder.RequiredArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.server.entity.player.PlayerServer; + +public class CommandHome implements CommandManager.CommandRegistry { + public static ArgumentBuilder> homeTP(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("tp") + .then(RequiredArgumentBuilder.argument("home", ArgumentTypeHome.home()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String targetHomeName = context.getArgument("home", String.class); + for(Home home : Data.Users.getOrCreate(sender.uuid).homeData){ + if(targetHomeName.equals(home.name)){ + return CommandLogicHome.homeTP(sender, home); + } + } + return 0; + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> homeDelete(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("delete") + .then(RequiredArgumentBuilder.argument("home", ArgumentTypeHome.home()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String targetHomeName = context.getArgument("home", String.class); + for(Home home : Data.Users.getOrCreate(sender.uuid).homeData){ + if(targetHomeName.equals(home.name)){ + return CommandLogicHome.homeDelete(sender, home); + } + } + return 0; + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> homeCreate(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("create") + .then(RequiredArgumentBuilder.argument("name", StringArgumentType.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String name = context.getArgument("name", String.class); + return CommandLogicHome.homeCreate(sender, name); + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> homeRename(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("rename") + .then(RequiredArgumentBuilder.argument("home", ArgumentTypeHome.home()) + .then(RequiredArgumentBuilder.argument("name", StringArgumentType.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String targetHomeName = context.getArgument("home", String.class); + String name = context.getArgument("name", String.class); + for(Home home : Data.Users.getOrCreate(sender.uuid).homeData){ + if(targetHomeName.equals(home.name)){ + return CommandLogicHome.homeRename(sender, home, name); + } + } + return 0; + } + ) + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> homeList(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("list") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicHome.homeList(sender); + } + ) + ); + return builder; + } + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder builder = LiteralArgumentBuilder.literal("home"); + + homeTP(builder); + homeDelete(builder); + homeRename(builder); + homeCreate(builder); + homeList(builder); + + dispatcher.register(builder); + } + +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandLock.java b/src/main/java/MelonUtilities/command/commands/CommandLock.java new file mode 100644 index 0000000..72ee6e5 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandLock.java @@ -0,0 +1,176 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.arguments.ArgumentTypeUsername; +import MelonUtilities.command.commandlogic.CommandLogicLock; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import com.mojang.brigadier.builder.RequiredArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.server.entity.player.PlayerServer; + +@SuppressWarnings("UnusedReturnValue") +public class CommandLock implements CommandManager.CommandRegistry{ + public static ArgumentBuilder> lockOnBlockPlaced(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("onblockplaced") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicLock.lockOnBlockPlaced(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> lockOnBlockPunched(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("onblockpunched") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicLock.lockOnBlockPunched(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> lockTrust(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("trust") + .then(RequiredArgumentBuilder.argument("username", ArgumentTypeUsername.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String targetUsername = context.getArgument("username", String.class).toLowerCase(); + return CommandLogicLock.lockTrust(sender, targetUsername); + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> lockTrustAll(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("trustall") + .then(RequiredArgumentBuilder.argument("username", ArgumentTypeUsername.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String targetUsername = context.getArgument("username", String.class).toLowerCase(); + return CommandLogicLock.lockTrustAll(sender, targetUsername); + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> lockTrustCommunity(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("trustcommunity") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicLock.lockTrustCommunity(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> lockUntrust(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("untrust") + .then(RequiredArgumentBuilder.argument("username", ArgumentTypeUsername.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String targetUsername = context.getArgument("username", String.class).toLowerCase(); + return CommandLogicLock.lockUntrust(sender, targetUsername); + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> lockUntrustAll(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("untrustall") + .then(RequiredArgumentBuilder.argument("username", ArgumentTypeUsername.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String targetUsername = context.getArgument("username", String.class).toLowerCase(); + return CommandLogicLock.lockUntrustAll(sender, targetUsername); + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> lockUntrustCommunity(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("untrustcommunity") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicLock.lockUntrustCommunity(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> lockBypass(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("bypass").requires(CommandSource::hasAdmin) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicLock.lockBypass(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> lockInfo(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("info") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicLock.lockInfo(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> lock(ArgumentBuilder> builder) { + builder.executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicLock.lock(sender); + } + ); + return builder; + } + + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder builder = LiteralArgumentBuilder.literal("lock"); + + lock(builder); + lockOnBlockPlaced(builder); + lockOnBlockPunched(builder); + lockTrust(builder); + lockTrustAll(builder); + lockTrustCommunity(builder); + lockUntrust(builder); + lockUntrustAll(builder); + lockUntrustCommunity(builder); + lockBypass(builder); + lockInfo(builder); + + dispatcher.register(builder); + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandMelonUtilities.java b/src/main/java/MelonUtilities/command/commands/CommandMelonUtilities.java new file mode 100644 index 0000000..bc13f86 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandMelonUtilities.java @@ -0,0 +1,24 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.commandlogic.CommandLogicMelonUtilities; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.server.entity.player.PlayerServer; + +public class CommandMelonUtilities implements CommandManager.CommandRegistry{ + @Override + public void register(CommandDispatcher dispatcher) { + dispatcher.register((LiteralArgumentBuilder.literal("melonutilities").requires(CommandSource::hasAdmin)) + .then(LiteralArgumentBuilder.literal("reload") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); + return CommandLogicMelonUtilities.melonutilitiesReload(sender); + } + ) + ) + ); + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandRole.java b/src/main/java/MelonUtilities/command/commands/CommandRole.java new file mode 100644 index 0000000..a239b39 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandRole.java @@ -0,0 +1,515 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.arguments.ArgumentTypeColor; +import MelonUtilities.command.arguments.ArgumentTypeRole; +import MelonUtilities.command.commandlogic.CommandLogicRole; +import MelonUtilities.config.datatypes.data.Role; +import MelonUtilities.utility.MUtil; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.arguments.BoolArgumentType; +import com.mojang.brigadier.arguments.IntegerArgumentType; +import com.mojang.brigadier.arguments.StringArgumentType; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import com.mojang.brigadier.builder.RequiredArgumentBuilder; +import net.minecraft.core.entity.player.Player; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.core.net.command.arguments.ArgumentTypeEntity; +import net.minecraft.core.net.command.helpers.EntitySelector; +import net.minecraft.server.entity.player.PlayerServer; + +@SuppressWarnings("UnusedReturnValue") +public class CommandRole implements CommandManager.CommandRegistry{ + + public static ArgumentBuilder> roleCreate(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("create") + .then(RequiredArgumentBuilder.argument("roleID", StringArgumentType.string()) + .then(RequiredArgumentBuilder.argument("priorityvalue", IntegerArgumentType.integer(0, 99)) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String roleID = context.getArgument("roleID", String.class); + int rolePriority = context.getArgument("priorityvalue", Integer.class); + return CommandLogicRole.roleCreate(sender, roleID, rolePriority); + } + ) + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> roleDelete(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("delete") + .then(RequiredArgumentBuilder.argument("role", ArgumentTypeRole.role()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleDelete(sender, role); + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> roleEdit(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("edit") + .then(RequiredArgumentBuilder.argument("role", ArgumentTypeRole.role()) + .then(LiteralArgumentBuilder.literal("priority") + .then(RequiredArgumentBuilder.argument("priorityvalue", IntegerArgumentType.integer(0, 99)) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + int priorityValue = context.getArgument("priorityvalue", Integer.class); + return CommandLogicRole.roleEditPriority(sender, role, priorityValue); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("display") + .then(LiteralArgumentBuilder.literal("name") + .then(RequiredArgumentBuilder.argument("displayname", StringArgumentType.greedyString()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String displayName = context.getArgument("displayName", String.class); + return CommandLogicRole.roleEditDisplayName(sender, role, displayName); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("color") + .then(RequiredArgumentBuilder.argument("color", ArgumentTypeColor.color()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String color = context.getArgument("color", String.class); + return CommandLogicRole.roleEditDisplayColorCOLOR(sender, role, color); + } + ) + ) + .then(RequiredArgumentBuilder.argument("hex", StringArgumentType.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String hex = MUtil.breakDownHex(context.getArgument("hex", String.class)); + return CommandLogicRole.roleEditDisplayColorHEX(sender, role, hex); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("underline") + .then(RequiredArgumentBuilder.argument("value", BoolArgumentType.bool()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + boolean value = context.getArgument("value", Boolean.class); + return CommandLogicRole.roleEditDisplayUnderline(sender, role, value); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("bold") + .then(RequiredArgumentBuilder.argument("value", BoolArgumentType.bool()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + boolean value = context.getArgument("value", Boolean.class); + return CommandLogicRole.roleEditDisplayBold(sender, role, value); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("italics") + .then(RequiredArgumentBuilder.argument("value", BoolArgumentType.bool()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + boolean value = context.getArgument("value", Boolean.class); + return CommandLogicRole.roleEditDisplayItalics(sender, role, value); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("border") + .then(LiteralArgumentBuilder.literal("color") + .then(RequiredArgumentBuilder.argument("color", ArgumentTypeColor.color()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String color = context.getArgument("color", String.class); + return CommandLogicRole.roleEditDisplayBorderColorCOLOR(sender, role, color); + } + ) + ) + .then(RequiredArgumentBuilder.argument("hex", StringArgumentType.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String hex = MUtil.breakDownHex(context.getArgument("hex", String.class)); + return CommandLogicRole.roleEditDisplayBorderColorHEX(sender, role, hex); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("style") + .then(LiteralArgumentBuilder.literal("none") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleEditDisplayBorderStyleNone(sender, role); + } + ) + ) + .then(LiteralArgumentBuilder.literal("bracket") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleEditDisplayBorderStyleBracket(sender, role); + } + ) + ) + .then(LiteralArgumentBuilder.literal("curly") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleEditDisplayBorderStyleCurly(sender, role); + } + ) + ) + .then(LiteralArgumentBuilder.literal("caret") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleEditDisplayBorderStyleCaret(sender, role); + } + ) + ) + .then(LiteralArgumentBuilder.literal("custom") + .then(LiteralArgumentBuilder.literal("prefix") + .then(RequiredArgumentBuilder.argument("customaffix", StringArgumentType.greedyString()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String customAffix = context.getArgument("customaffix", String.class); + return CommandLogicRole.roleEditDisplayBorderStyleCustomPrefix(sender, role, customAffix); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("suffix") + .then(RequiredArgumentBuilder.argument("customaffix", StringArgumentType.greedyString()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String customAffix = context.getArgument("customaffix", String.class); + return CommandLogicRole.roleEditDisplayBorderStyleCustomSuffix(sender, role, customAffix); + } + ) + ) + ) + ) + ) + ) + ) + .then(LiteralArgumentBuilder.literal("username") + .then(LiteralArgumentBuilder.literal("border") + .then(LiteralArgumentBuilder.literal("color") + .then(RequiredArgumentBuilder.argument("color", ArgumentTypeColor.color()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String color = context.getArgument("color", String.class); + return CommandLogicRole.roleEditUsernameBorderColorCOLOR(sender, role, color); + } + ) + ) + .then(RequiredArgumentBuilder.argument("hex", StringArgumentType.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String hex = MUtil.breakDownHex(context.getArgument("hex", String.class)); + return CommandLogicRole.roleEditUsernameBorderColorHEX(sender, role, hex); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("style") + .then(LiteralArgumentBuilder.literal("none") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleEditUsernameBorderStyleNone(sender, role); + } + ) + ) + .then(LiteralArgumentBuilder.literal("bracket") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleEditUsernameBorderStyleBracket(sender, role); + } + ) + ) + .then(LiteralArgumentBuilder.literal("curly") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleEditUsernameBorderStyleCurly(sender, role); + } + ) + ) + .then(LiteralArgumentBuilder.literal("caret") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleEditUsernameBorderStyleCaret(sender, role); + } + ) + ) + .then(LiteralArgumentBuilder.literal("custom") + .then(LiteralArgumentBuilder.literal("prefix") + .then(RequiredArgumentBuilder.argument("customaffix", StringArgumentType.greedyString()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String customAffix = context.getArgument("customaffix", String.class); + return CommandLogicRole.roleEditUsernameBorderStyleCustomPrefix(sender, role, customAffix); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("suffix") + .then(RequiredArgumentBuilder.argument("customaffix", StringArgumentType.greedyString()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String customAffix = context.getArgument("customaffix", String.class); + return CommandLogicRole.roleEditUsernameBorderStyleCustomSuffix(sender, role, customAffix); + } + ) + ) + ) + ) + ) + ) + ) + .then(LiteralArgumentBuilder.literal("text") + .then(LiteralArgumentBuilder.literal("color") + .then(RequiredArgumentBuilder.argument("color", ArgumentTypeColor.color()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String color = context.getArgument("color", String.class); + return CommandLogicRole.roleEditTextColorCOLOR(sender, role, color); + } + ) + ) + .then(RequiredArgumentBuilder.argument("hex", StringArgumentType.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + String hex = MUtil.breakDownHex(context.getArgument("hex", String.class)); + return CommandLogicRole.roleEditTextColorHEX(sender, role, hex); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("underline") + .then(RequiredArgumentBuilder.argument("value", BoolArgumentType.bool()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + boolean value = context.getArgument("value", Boolean.class); + return CommandLogicRole.roleEditTextUnderline(sender, role, value); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("bold") + .then(RequiredArgumentBuilder.argument("value", BoolArgumentType.bool()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + boolean value = context.getArgument("value", Boolean.class); + return CommandLogicRole.roleEditTextBold(sender, role, value); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("italics") + .then(RequiredArgumentBuilder.argument("value", BoolArgumentType.bool()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + boolean value = context.getArgument("value", Boolean.class); + return CommandLogicRole.roleEditTextItalics(sender, role, value); + } + ) + ) + ) + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> roleGrant(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("grant") + .then(RequiredArgumentBuilder.argument("role", ArgumentTypeRole.role()) + .then(RequiredArgumentBuilder.argument("target", ArgumentTypeEntity.player()) + .executes( + context -> + { + Role role = context.getArgument("role", Role.class); + Player target = (Player)context.getArgument("target", EntitySelector.class).get(context.getSource()).get(0); + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRole.roleGrant(sender, target, role); + } + ) + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> roleRevoke(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("revoke") + .then(RequiredArgumentBuilder.argument("role", ArgumentTypeRole.role()) + .then(RequiredArgumentBuilder.argument("target", ArgumentTypeEntity.player()) + .executes(context -> + { + Role role = context.getArgument("role", Role.class); + Player target = (Player)context.getArgument("target", EntitySelector.class).get(context.getSource()).get(0); + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRole.roleRevoke(sender, target, role); + } + ) + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> roleSet(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("set") + .then(LiteralArgumentBuilder.literal("defaultrole") + .then(RequiredArgumentBuilder.argument("role", ArgumentTypeRole.role()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Role role = context.getArgument("role", Role.class); + return CommandLogicRole.roleSetDefaultroleROLEID(sender, role); + } + ) + ) + .then(LiteralArgumentBuilder.literal("none") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRole.roleSetDefaultroleNone(sender); + } + ) + ) + ) + .then(LiteralArgumentBuilder.literal("displaymode") + .then(LiteralArgumentBuilder.literal("single") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRole.roleSetDisplaymodeSingle(sender); + } + ) + ) + .then(LiteralArgumentBuilder.literal("multi") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRole.roleSetDisplaymodeMulti(sender); + } + ) + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> roleList(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("list") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRole.roleList(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> roleReload(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("reload") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRole.roleReload(sender); + } + ) + ); + return builder; + } + +/* public static ArgumentBuilder> role(ArgumentBuilder> builder) { + builder.executes( + context -> CommandLogicRole.role((PlayerServer) context.getSource().getSender()) + ); + return builder; + }*/ + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder commandBuilder = LiteralArgumentBuilder.literal("role").requires(CommandSource::hasAdmin); + + //role(commandBuilder); + roleCreate(commandBuilder); + roleDelete(commandBuilder); + roleGrant(commandBuilder); + roleRevoke(commandBuilder); + roleEdit(commandBuilder); + roleList(commandBuilder); + roleReload(commandBuilder); + roleSet(commandBuilder); + + dispatcher.register(commandBuilder); + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandRollback.java b/src/main/java/MelonUtilities/command/commands/CommandRollback.java new file mode 100644 index 0000000..5009323 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandRollback.java @@ -0,0 +1,138 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.commandlogic.CommandLogicRollback; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import com.mojang.brigadier.builder.RequiredArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.core.net.command.arguments.ArgumentTypeChunkCoordinates; +import net.minecraft.core.net.command.helpers.Coordinates2D; +import net.minecraft.server.entity.player.PlayerServer; + +@SuppressWarnings("UnusedReturnValue") +public class CommandRollback implements CommandManager.CommandRegistry{ + public static ArgumentBuilder> rollback(ArgumentBuilder> builder) { + builder.requires(CommandSource::hasAdmin).executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRollback.rollback(sender); + } + ); + return builder; + } + + public static ArgumentBuilder> rollbackArea(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("area") + .then(RequiredArgumentBuilder.argument("x1 z1", ArgumentTypeChunkCoordinates.chunkCoordinates()) + .then(RequiredArgumentBuilder.argument("x2 z2", ArgumentTypeChunkCoordinates.chunkCoordinates()) + .executes(context -> + { + CommandSource source = context.getSource(); + PlayerServer sender = (PlayerServer) context.getSource().getSender(); + if (sender == null) return 0; + Coordinates2D chunk1 = context.getArgument("x1 z1", Coordinates2D.class); + Coordinates2D chunk2 = context.getArgument("x2 z2", Coordinates2D.class); + int x1 = chunk1.getX(source); + int z1 = chunk1.getZ(source); + int x2 = chunk2.getX(source); + int z2 = chunk2.getZ(source); + return CommandLogicRollback.rollbackArea(sender, x1, z1, x2, z2); + } + ) + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> rollbackTakeSnapshot(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("takesnapshot") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRollback.rollbackTakeSnapshot(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> rollbackTakeBackup(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("takebackup") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRollback.rollbackTakeBackup(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> rollbackPruneSnapshots(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("prunesnapshots") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRollback.rollbackPruneSnapshots(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> rollbackPruneBackups(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("prunebackups") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRollback.rollbackPruneBackups(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> rollbackAutoSnapshots(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("autosnapshots") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRollback.rollbackAutoSnapshots(sender); + } + ) + ); + return builder; + } + + public static ArgumentBuilder> rollbackAutoBackups(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("autobackups") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicRollback.rollbackAutoBackups(sender); + } + ) + ); + return builder; + } + + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder builder = LiteralArgumentBuilder.literal("rollback"); + + rollback(builder); + rollbackArea(builder); + rollbackTakeSnapshot(builder); + rollbackTakeBackup(builder); + rollbackPruneSnapshots(builder); + rollbackPruneBackups(builder); + rollbackAutoSnapshots(builder); + rollbackAutoBackups(builder); + + dispatcher.register(builder); + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandTPA.java b/src/main/java/MelonUtilities/command/commands/CommandTPA.java new file mode 100644 index 0000000..faed180 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandTPA.java @@ -0,0 +1,37 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.arguments.ArgumentTypeUsername; +import MelonUtilities.command.commandlogic.CommandLogicTPA; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import com.mojang.brigadier.builder.RequiredArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.server.entity.player.PlayerServer; + +@SuppressWarnings("UnusedReturnValue") +public class CommandTPA implements CommandManager.CommandRegistry{ + + public static ArgumentBuilder> tpa(ArgumentBuilder> builder) { + builder.then(RequiredArgumentBuilder.argument("target", ArgumentTypeUsername.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String targetUsername = context.getArgument("target", String.class); + return CommandLogicTPA.tpa(sender, targetUsername); + } + ) + ); + return builder; + } + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder builder = LiteralArgumentBuilder.literal("tpa"); + + tpa(builder); + + dispatcher.register(builder); + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandTPAHere.java b/src/main/java/MelonUtilities/command/commands/CommandTPAHere.java new file mode 100644 index 0000000..f969ac7 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandTPAHere.java @@ -0,0 +1,37 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.arguments.ArgumentTypeUsername; +import MelonUtilities.command.commandlogic.CommandLogicTPAHere; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import com.mojang.brigadier.builder.RequiredArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.server.entity.player.PlayerServer; + +@SuppressWarnings("UnusedReturnValue") +public class CommandTPAHere implements CommandManager.CommandRegistry{ + + public static ArgumentBuilder> tpahere(ArgumentBuilder> builder) { + builder.then(RequiredArgumentBuilder.argument("target", ArgumentTypeUsername.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String targetUsername = context.getArgument("target", String.class); + return CommandLogicTPAHere.tpaHere(sender, targetUsername); + } + ) + ); + return builder; + } + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder builder = LiteralArgumentBuilder.literal("tpahere"); + + tpahere(builder); + + dispatcher.register(builder); + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandTPAccept.java b/src/main/java/MelonUtilities/command/commands/CommandTPAccept.java new file mode 100644 index 0000000..c00704d --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandTPAccept.java @@ -0,0 +1,33 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.commandlogic.CommandLogicTPA; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.server.entity.player.PlayerServer; + +@SuppressWarnings("UnusedReturnValue") +public class CommandTPAccept implements CommandManager.CommandRegistry{ + + public static ArgumentBuilder> tpaccept(ArgumentBuilder> builder) { + builder.executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicTPA.tpaccept(sender); + } + ); + return builder; + } + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder builder = LiteralArgumentBuilder.literal("tpaccept"); + + tpaccept(builder); + + dispatcher.register(builder); + } +} + diff --git a/src/main/java/MelonUtilities/command/commands/CommandTPDeny.java b/src/main/java/MelonUtilities/command/commands/CommandTPDeny.java new file mode 100644 index 0000000..9a5237a --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandTPDeny.java @@ -0,0 +1,32 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.commandlogic.CommandLogicTPA; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.server.entity.player.PlayerServer; + +@SuppressWarnings("UnusedReturnValue") +public class CommandTPDeny implements CommandManager.CommandRegistry{ + + public static ArgumentBuilder> tpdeny(ArgumentBuilder> builder) { + builder.executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicTPA.tpdeny(sender); + } + ); + return builder; + } + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder builder = LiteralArgumentBuilder.literal("tpdeny"); + + tpdeny(builder); + + dispatcher.register(builder); + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandUnlock.java b/src/main/java/MelonUtilities/command/commands/CommandUnlock.java new file mode 100644 index 0000000..21556a6 --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandUnlock.java @@ -0,0 +1,12 @@ +package MelonUtilities.command.commands; + +import com.mojang.brigadier.CommandDispatcher; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; + +public class CommandUnlock implements CommandManager.CommandRegistry{ + @Override + public void register(CommandDispatcher commandDispatcher) { + + } +} diff --git a/src/main/java/MelonUtilities/command/commands/CommandWarp.java b/src/main/java/MelonUtilities/command/commands/CommandWarp.java new file mode 100644 index 0000000..41e87be --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/CommandWarp.java @@ -0,0 +1,105 @@ +package MelonUtilities.command.commands; + +import MelonUtilities.command.arguments.ArgumentTypeWarp; +import MelonUtilities.command.commandlogic.CommandLogicWarp; +import MelonUtilities.config.datatypes.data.Warp; +import com.mojang.brigadier.CommandDispatcher; +import com.mojang.brigadier.arguments.StringArgumentType; +import com.mojang.brigadier.builder.ArgumentBuilder; +import com.mojang.brigadier.builder.LiteralArgumentBuilder; +import com.mojang.brigadier.builder.RequiredArgumentBuilder; +import net.minecraft.core.net.command.CommandManager; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.server.entity.player.PlayerServer; + +@SuppressWarnings("UnusedReturnValue") +public class CommandWarp implements CommandManager.CommandRegistry{ + public static ArgumentBuilder> warpTP(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("tp") + .then(RequiredArgumentBuilder.argument("warp", ArgumentTypeWarp.warp()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Warp warp = context.getArgument("warp", Warp.class); + return CommandLogicWarp.warpTP(sender, warp); + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> warpDelete(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("delete").requires(CommandSource::hasAdmin) + .then(RequiredArgumentBuilder.argument("warp", ArgumentTypeWarp.warp()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Warp warp = context.getArgument("warp", Warp.class); + return CommandLogicWarp.warpDelete(sender, warp); + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> warpCreate(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("create").requires(CommandSource::hasAdmin) + .then(RequiredArgumentBuilder.argument("name", StringArgumentType.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + String name = context.getArgument("name", String.class); + return CommandLogicWarp.warpCreate(sender, name); + } + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> warpRename(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("rename").requires(CommandSource::hasAdmin) + .then(RequiredArgumentBuilder.argument("warp", ArgumentTypeWarp.warp()) + .then(RequiredArgumentBuilder.argument("name", StringArgumentType.string()) + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + Warp warp = context.getArgument("warp", Warp.class); + String name = context.getArgument("name", String.class); + return CommandLogicWarp.warpRename(sender, warp, name); + } + ) + ) + ) + ); + return builder; + } + + public static ArgumentBuilder> warpList(ArgumentBuilder> builder) { + builder.then(LiteralArgumentBuilder.literal("list") + .executes(context -> + { + PlayerServer sender = (PlayerServer) context.getSource().getSender(); if(sender == null){return 0;} + return CommandLogicWarp.warpList(sender); + } + ) + ); + return builder; + } + + @Override + public void register(CommandDispatcher dispatcher) { + LiteralArgumentBuilder builder = LiteralArgumentBuilder.literal("warp"); + + warpTP(builder); + warpDelete(builder); + warpRename(builder); + warpCreate(builder); + warpList(builder); + + dispatcher.register(builder); + } + +} diff --git a/src/main/java/MelonUtilities/commands/crew/CrewCommand.java b/src/main/java/MelonUtilities/command/commands/CrewCommandOld.djava similarity index 89% rename from src/main/java/MelonUtilities/commands/crew/CrewCommand.java rename to src/main/java/MelonUtilities/command/commands/CrewCommandOld.djava index 02aed03..8d5c749 100644 --- a/src/main/java/MelonUtilities/commands/crew/CrewCommand.java +++ b/src/main/java/MelonUtilities/command/commands/CrewCommandOld.djava @@ -1,17 +1,17 @@ -package MelonUtilities.commands.crew; +package MelonUtilities.command.crew; -import MelonUtilities.utility.SyntaxBuilder; +import MelonUtilities.utility.syntax.SyntaxBuilder; import net.minecraft.core.net.command.Command; import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; +import net.minecraft.core.net.command.CommandSource; import net.minecraft.core.net.command.TextFormatting; -public class CrewCommand extends Command { +public class CrewCommandOld extends Command { public static SyntaxBuilder syntax = new SyntaxBuilder(); private final static String COMMAND = "crew"; - public CrewCommand(){super(COMMAND, "c");} + public CrewCommandOld(){super(COMMAND, "c");} public static void buildRoleSyntax(){ syntax.clear(); @@ -39,7 +39,7 @@ public static void buildRoleSyntax(){ } @Override - public boolean execute(CommandHandler commandHandler, CommandSender commandSender, String[] strings) { + public boolean execute(CommandHandler commandHandler, CommandSource commandSource, String[] strings) { return false; } @@ -49,7 +49,7 @@ public boolean opRequired(String[] strings) { } @Override - public void sendCommandSyntax(CommandHandler commandHandler, CommandSender commandSender) { + public void sendCommandSyntax(CommandHandler commandHandler, CommandSource commandSource) { } } diff --git a/src/main/java/MelonUtilities/command/commands/HelperCommandOld.djava b/src/main/java/MelonUtilities/command/commands/HelperCommandOld.djava new file mode 100644 index 0000000..1261a6d --- /dev/null +++ b/src/main/java/MelonUtilities/command/commands/HelperCommandOld.djava @@ -0,0 +1,114 @@ +package MelonUtilities.command.helper; + +import MelonUtilities.config.Data; +import MelonUtilities.config.datatypes.PlayerData; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.syntax.SyntaxBuilder; +import MelonUtilities.utility.helpers.UUIDHelper; +import net.minecraft.core.net.command.Command; +import net.minecraft.core.net.command.CommandHandler; +import net.minecraft.core.net.command.CommandSource; +import net.minecraft.core.net.command.TextFormatting; +import net.minecraft.server.entity.player.ServerPlayer; + +public class HelperCommandOld extends Command { + + private final static String COMMAND = "helper"; + + public HelperCommandOld() {super(COMMAND, "h");} + + public static SyntaxBuilder syntax = new SyntaxBuilder(); + + public static void buildHelperSyntax(){ + syntax.clear(); + syntax.append("title", TextFormatting.LIGHT_GRAY + "< Command Syntax > ([] = optional, <> = variable, / = or)"); + syntax.append("helper", "title", TextFormatting.LIGHT_GRAY + " > /helper "); + syntax.append("helperAdd", "helper", TextFormatting.LIGHT_GRAY + " > add "); + syntax.append("helperRemove", "helper", TextFormatting.LIGHT_GRAY + " > remove "); + } + + private boolean add(CommandHandler handler, CommandSource source, String[] args){ + String username = args[1]; + ServerPlayer player = (ServerPlayer) handler.getPlayer(username); + + if (player != null && !Data.user.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper) { + FeedbackHandler.sendFeedback(FeedbackType.success, source, "You are now a Helper!"); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Setting " + TextFormatting.GRAY + username + TextFormatting.LIME + " to Helper."); + + Data.user.loadAll(PlayerData.class); + Data.user.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper = true; + Data.user.saveAll(); + + return true; + } else if (Data.user.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper){ + handler.sendCommandFeedback(source, TextFormatting.GRAY + username + TextFormatting.RED + " is already a helper!"); + return true; + } else if (player == null) { + FeedbackHandler.sendFeedback(FeedbackType.success, source, TextFormatting.LIME + "Setting " + TextFormatting.GRAY + username + TextFormatting.LIME + " to Helper."); + + Data.user.loadAll(PlayerData.class); + Data.user.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper = true; + Data.user.saveAll(); + + return true; + } + return true; + } + + private boolean remove(CommandHandler handler, CommandSource source, String[] args){ + String username = args[1]; + ServerPlayer player = (ServerPlayer) handler.getPlayer(username); + + if (player != null && Data.user.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper) { + FeedbackHandler.sendFeedback(FeedbackType.destructive, source, "You are no longer a Helper!"); + FeedbackHandler.sendFeedback(FeedbackType.success, source, TextFormatting.LIME + "Removing " + TextFormatting.GRAY + username + TextFormatting.LIME + " from Helper List."); + + Data.user.loadAll(PlayerData.class); + Data.user.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper = false; + Data.user.saveAll(); + + return true; + } else if(!Data.user.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper){ + FeedbackHandler.error(source, TextFormatting.GRAY + username + TextFormatting.RED + " isn't a helper!"); + return true; + } else if (player == null) { + FeedbackHandler.sendFeedback(FeedbackType.success, source, TextFormatting.LIME + "Removing " + TextFormatting.GRAY + username + TextFormatting.LIME + " from Helper List."); + + Data.user.loadAll(PlayerData.class); + Data.user.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper = false; + Data.user.saveAll(); + + return true; + } + return true; + } + + @Override + public boolean execute(CommandHandler handler, CommandSource source, String[] args) { + + if (args.length == 0) { + return false; + } + + switch(args[0]){ + case "add": + return add(handler, source, args); + case "remove": + return remove(handler, source, args); + } + + source.sendMessage(TextFormatting.RED + "Helper Command Failed (Invalid Syntax)"); + syntax.printAllLines(source); + return true; + } + + @Override + public boolean opRequired(String[] args) { + return true; + } + + @Override + public void sendCommandSyntax(CommandHandler handler, CommandSource source) { + syntax.printAllLines(source); + } +} diff --git a/src/main/java/MelonUtilities/commands/kit/KitCommand.java b/src/main/java/MelonUtilities/command/commands/KitCommandOld.djava similarity index 61% rename from src/main/java/MelonUtilities/commands/kit/KitCommand.java rename to src/main/java/MelonUtilities/command/commands/KitCommandOld.djava index a5acbe4..d3e3d65 100644 --- a/src/main/java/MelonUtilities/commands/kit/KitCommand.java +++ b/src/main/java/MelonUtilities/command/commands/KitCommandOld.djava @@ -1,14 +1,14 @@ -package MelonUtilities.commands.kit; +package MelonUtilities.command.kit; import MelonUtilities.config.Data; -import MelonUtilities.utility.FeedbackHandler; -import MelonUtilities.utility.SyntaxBuilder; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; +import MelonUtilities.utility.syntax.SyntaxBuilder; import MelonUtilities.config.datatypes.KitData; import net.minecraft.core.entity.EntityItem; import net.minecraft.core.item.ItemStack; import net.minecraft.core.net.command.Command; import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; +import net.minecraft.core.net.command.CommandSource; import net.minecraft.core.net.command.TextFormatting; import net.minecraft.core.player.inventory.InventoryPlayer; @@ -21,7 +21,7 @@ //TODO Needs a complete rewrite: Switch Statements need put into separate classes similar to Roles, as well as Integration with CommandSyntaxBuilder -public class KitCommand extends Command { +public class KitCommandOld extends Command { private final static String COMMAND = "kit"; private final static String NAME = "Kit"; public static HashMap> cooldowns = new HashMap<>(); @@ -46,7 +46,7 @@ public static String hmsConversion(long millis) { return String.format("%02d:%02d:%02d [h:m:s]", h, m, s); } - public KitCommand() { + public KitCommandOld() { super(COMMAND); } @@ -91,9 +91,9 @@ public static int[] evalInventory(InventoryPlayer inventory, ItemStack compariso return slotEval; } - public static void insertItemAtSlot(int idealSlot, ItemStack item, CommandSender sender){ + public static void insertItemAtSlot(int idealSlot, ItemStack item, CommandSource source){ - int[] slotEval = evalInventory(sender.getPlayer().inventory, item); + int[] slotEval = evalInventory(source.getSender().inventory, item); for (int i = 0; i < 36; i++) { @@ -106,11 +106,11 @@ public static void insertItemAtSlot(int idealSlot, ItemStack item, CommandSender } if(slot == 0){ - sender.getPlayer().inventory.setInventorySlotContents(currentID, new ItemStack(item)); + source.getSender().inventory.setInventorySlotContents(currentID, new ItemStack(item)); return; } - ItemStack inventoryStack = sender.getPlayer().inventory.getStackInSlot(currentID); + ItemStack inventoryStack = source.getSender().inventory.getStackInSlot(currentID); if(slot == 1){ inventoryStack.stackSize += item.stackSize; @@ -124,13 +124,13 @@ public static void insertItemAtSlot(int idealSlot, ItemStack item, CommandSender inventoryStack.stackSize = item.getMaxStackSize(); ItemStack newStack = new ItemStack(item); newStack.stackSize = stackSum - item.getMaxStackSize(); - insertItemAtSlot((currentID + 1) % 36, newStack, sender); + insertItemAtSlot((currentID + 1) % 36, newStack, source); return; } } - EntityItem itemToDrop = new EntityItem(sender.getPlayer().world, sender.getPlayer().x, sender.getPlayer().y + 1, sender.getPlayer().z, new ItemStack(item)); + EntityItem itemToDrop = new EntityItem(source.getSender().world, source.getSender().x, source.getSender().y + 1, source.getSender().z, new ItemStack(item)); itemToDrop.delayBeforeCanPickup = 10; - sender.getPlayer().world.entityJoinedWorld(itemToDrop); + source.getSender().world.entityJoinedWorld(itemToDrop); } static int listIndexOf(ItemStack[] items, ItemStack target) { @@ -156,7 +156,7 @@ public static void buildKitSyntax(){ } @Override - public boolean execute(CommandHandler handler, CommandSender sender, String[] args) { + public boolean execute(CommandHandler handler, CommandSource source, String[] args) { { if (args.length == 0) { return false; @@ -164,8 +164,8 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (args[0].equals("give")) { if (args.length == 1) { - FeedbackHandler.success(sender, "Failed to Give Kit (Invalid Syntax)"); - FeedbackHandler.syntax(sender, "/kit give []"); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Failed to Give Kit (Invalid Syntax)"); + FeedbackHandler.syntax(source, "/kit give []"); return true; } @@ -177,8 +177,8 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (args.length > 2 && args[2].equals("true")) { - if (System.currentTimeMillis() - cooldowns.getOrDefault(kit, new HashMap<>()).getOrDefault(sender.getPlayer().username, 0L) > cooldown) { - cooldowns.get(kit).put(sender.getPlayer().username, System.currentTimeMillis()); + if (System.currentTimeMillis() - cooldowns.getOrDefault(kit, new HashMap<>()).getOrDefault(source.getSender().username, 0L) > cooldown) { + cooldowns.get(kit).put(source.getSender().username, System.currentTimeMillis()); int counter = 0; @@ -186,7 +186,7 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (kitdata.kitItemNames.get(counter) != null) { item.setCustomName(kitdata.kitItemNames.get(counter)); } - sender.getPlayer().inventory.setInventorySlotContents(kitdata.kitItemSlots.get(counter++), new ItemStack(item)); + source.getSender().inventory.setInventorySlotContents(kitdata.kitItemSlots.get(counter++), new ItemStack(item)); } //give items ^ @@ -196,19 +196,19 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (kitdata.kitArmorNames.get(counter) != null) { armor.setCustomName(kitdata.kitArmorNames.get(counter)); } - sender.getPlayer().inventory.setInventorySlotContents(kitdata.kitArmorSlots.get(counter++), new ItemStack(armor)); + source.getSender().inventory.setInventorySlotContents(kitdata.kitArmorSlots.get(counter++), new ItemStack(armor)); } //give armor ^ Data.kits.saveAll(); - FeedbackHandler.success(sender, "Given Kit: '" + kit + "' to " + sender.getPlayer().username); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Given Kit: '" + kit + "' to " + source.getSender().username); return true; } } - if (System.currentTimeMillis() - cooldowns.getOrDefault(kit, new HashMap<>()).getOrDefault(sender.getPlayer().username, 0L) > cooldown) { + if (System.currentTimeMillis() - cooldowns.getOrDefault(kit, new HashMap<>()).getOrDefault(source.getSender().username, 0L) > cooldown) { cooldowns.putIfAbsent(kit, new HashMap<>()); - cooldowns.getOrDefault(kit, new HashMap<>()).put(sender.getPlayer().username, System.currentTimeMillis()); + cooldowns.getOrDefault(kit, new HashMap<>()).put(source.getSender().username, System.currentTimeMillis()); int counter = 0; @@ -217,7 +217,7 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (kitdata.kitItemNames.get(counter) != null) { item.setCustomName(kitdata.kitItemNames.get(counter)); } - insertItemAtSlot(kitdata.kitItemSlots.get(counter++), item, sender); + insertItemAtSlot(kitdata.kitItemSlots.get(counter++), item, source); } //give items ^ @@ -227,33 +227,33 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (kitdata.kitArmorNames.get(counter) != null) { armor.setCustomName(kitdata.kitArmorNames.get(counter)); } - if (sender.getPlayer().inventory.getStackInSlot(39 - counter) != null) { - insertItemAtSlot(0, armor, sender); + if (source.getSender().inventory.getStackInSlot(39 - counter) != null) { + insertItemAtSlot(0, armor, source); counter++; continue; } - sender.getPlayer().inventory.setInventorySlotContents(kitdata.kitArmorSlots.get(counter++), new ItemStack(armor)); + source.getSender().inventory.setInventorySlotContents(kitdata.kitArmorSlots.get(counter++), new ItemStack(armor)); } //give armor ^ Data.kits.saveAll(); - FeedbackHandler.success(sender, "Given Kit: '" + kit + "' to " + sender.getPlayer().username); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Given Kit: '" + kit + "' to " + source.getSender().username); return true; } if (!Data.kits.dataHashMap.containsKey(kit)) { - FeedbackHandler.error(sender, "Failed to Give Kit: '" + kit + "' to " + sender.getPlayer().username + " (Kit Doesn't Exist)"); - sender.sendMessage(""); + FeedbackHandler.error(source, "Failed to Give Kit: '" + kit + "' to " + source.getSender().username + " (Kit Doesn't Exist)"); + source.sendMessage(""); } else { - FeedbackHandler.destructive(sender, "You've already used this kit... time left until next kit: "); - FeedbackHandler.destructive(sender, hmsConversion(cooldown - (System.currentTimeMillis() - cooldowns.getOrDefault(kit, new HashMap<>()).getOrDefault(sender.getPlayer().username, 0L)))); + FeedbackHandler.sendFeedback(FeedbackType.destructive, source, "You've already used this kit... time left until next kit: "); + FeedbackHandler.sendFeedback(FeedbackType.destructive, source, hmsConversion(cooldown - (System.currentTimeMillis() - cooldowns.getOrDefault(kit, new HashMap<>()).getOrDefault(source.getSender().username, 0L)))); return true; } } } if (args[0].equals("reset")) { if (args.length == 1) { - FeedbackHandler.error(sender, "Failed to Reset Kit Cooldown (Invalid Syntax)"); - FeedbackHandler.syntax(sender, "/kit reset []"); + FeedbackHandler.error(source, "Failed to Reset Kit Cooldown (Invalid Syntax)"); + FeedbackHandler.syntax(source, "/kit reset []"); return true; } if (args.length > 2) { @@ -261,18 +261,18 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar String player = args[2]; if (handler.playerExists(player)) { cooldowns.getOrDefault(kit, new HashMap<>()).put(handler.getPlayer(player).username, 0L); - FeedbackHandler.success(sender, handler.getPlayer(player).username + "'s Kit: '" + kit + "' Cooldown Reset"); + FeedbackHandler.sendFeedback(FeedbackType.success, source, handler.getPlayer(player).username + "'s Kit: '" + kit + "' Cooldown Reset"); return true; } else { - FeedbackHandler.error(sender, "Failed to Reset " + player + "'s Cooldown for Kit: " + kit); - FeedbackHandler.error(sender, "(Player Doesn't Exist)"); + FeedbackHandler.error(source, "Failed to Reset " + player + "'s Cooldown for Kit: " + kit); + FeedbackHandler.error(source, "(Player Doesn't Exist)"); return true; } } String kit = args[1]; if (Data.kits.dataHashMap.containsKey(kit)) { - cooldowns.getOrDefault(kit, new HashMap<>()).put(sender.getPlayer().username, 0L); - FeedbackHandler.success(sender, "Kit: '" + kit + "' Cooldown Reset!"); + cooldowns.getOrDefault(kit, new HashMap<>()).put(source.getSender().username, 0L); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Kit: '" + kit + "' Cooldown Reset!"); return true; } @@ -282,9 +282,9 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (args[0].equals("reload")) { Data.kits.loadAll(KitData.class); - FeedbackHandler.success(sender, "Reloaded " + Data.kits.dataHashMap.size() + " Kit(s)!"); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Reloaded " + Data.kits.dataHashMap.size() + " Kit(s)!"); buildKitSyntax(); - FeedbackHandler.success(sender, "Built Kit Syntax!"); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Built Kit Syntax!"); return true; } @@ -292,8 +292,8 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (args[0].equals("setcooldown")) { if (args.length == 1) { - FeedbackHandler.error(sender, "Failed to Set Kit Cooldown (Invalid Syntax)"); - FeedbackHandler.syntax(sender, "/kit setcooldown "); + FeedbackHandler.error(source, "Failed to Set Kit Cooldown (Invalid Syntax)"); + FeedbackHandler.syntax(source, "/kit setcooldown "); return true; } @@ -303,7 +303,7 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar KitData kitdata = Data.kits.getOrCreate(kit, KitData.class); kitdata.kitCooldown = Long.parseLong(args[2]); Data.kits.saveAll(); - FeedbackHandler.success(sender, "Set Cooldown for Kit: '" + kit + "' to: " + args[2]); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Set Cooldown for Kit: '" + kit + "' to: " + args[2]); return true; } @@ -317,15 +317,15 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar KitData kitdata = Data.kits.getOrCreate(args[1], KitData.class); - FeedbackHandler.syntax(sender, "< Kit: '" + args[1] + "' List >"); - FeedbackHandler.syntax(sender, " < Cooldown: " + hmsConversion(kitdata.kitCooldown * 1000) + " >"); - FeedbackHandler.syntax(sender, " < Armor: >"); + FeedbackHandler.syntax(source, "< Kit: '" + args[1] + "' List >"); + FeedbackHandler.syntax(source, " < Cooldown: " + hmsConversion(kitdata.kitCooldown * 1000) + " >"); + FeedbackHandler.syntax(source, " < Armor: >"); for (ItemStack armor : kitdata.kitArmorStacks) { - FeedbackHandler.syntax(sender, " > " + armor.getDisplayName()); + FeedbackHandler.syntax(source, " > " + armor.getDisplayName()); } - FeedbackHandler.syntax(sender, " < Items: >"); + FeedbackHandler.syntax(source, " < Items: >"); for (ItemStack item : kitdata.kitItemStacks) { - FeedbackHandler.syntax(sender, " > " + item.getDisplayName() + " * " + item.stackSize); + FeedbackHandler.syntax(source, " > " + item.getDisplayName() + " * " + item.stackSize); } @@ -334,15 +334,15 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar } if (Data.kits.dataHashMap.isEmpty()) { - FeedbackHandler.syntax(sender, "< Kits: >"); - FeedbackHandler.syntax(sender, " -No Kits Created-"); + FeedbackHandler.syntax(source, "< Kits: >"); + FeedbackHandler.syntax(source, " -No Kits Created-"); return true; } - FeedbackHandler.syntax(sender, "< Kits: >"); + FeedbackHandler.syntax(source, "< Kits: >"); for (String kit : Data.kits.dataHashMap.keySet()) { - FeedbackHandler.syntax(sender, " > " + kit); + FeedbackHandler.syntax(source, " > " + kit); } return true; @@ -351,15 +351,15 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (args[0].equals("create")) { if (args.length == 1) { - FeedbackHandler.error(sender, "Failed to Create Kit (Invalid Syntax)"); - FeedbackHandler.syntax(sender, "/kit create []"); + FeedbackHandler.error(source, "Failed to Create Kit (Invalid Syntax)"); + FeedbackHandler.syntax(source, "/kit create []"); return true; } String kit = args[1]; if (Data.kits.dataHashMap.containsKey(kit)) { - FeedbackHandler.error(sender, "Failed to Create Kit: '" + kit + "' (Kit Already Exists)"); + FeedbackHandler.error(source, "Failed to Create Kit: '" + kit + "' (Kit Already Exists)"); return true; } @@ -373,29 +373,29 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar KitData kitdata = Data.kits.getOrCreate(kit, KitData.class); kitdata.kitCooldown = Long.parseLong(args[2]); Data.kits.saveAll(); - FeedbackHandler.success(sender, "Created Kit: '" + kit + "' with Cooldown: " + args[2]); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Created Kit: '" + kit + "' with Cooldown: " + args[2]); return true; } Data.kits.getOrCreate(kit, KitData.class); Data.kits.saveAll(); - FeedbackHandler.success(sender, "Created Kit: '" + kit + "' with Cooldown: 0"); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Created Kit: '" + kit + "' with Cooldown: 0"); return true; } if (args[0].equals("addto")) { if (args.length == 1) { - FeedbackHandler.error(sender, "Failed to Add To Kit (Invalid Syntax)"); - syntax.printLayerAndSubLayers("addto", sender); + FeedbackHandler.error(source, "Failed to Add To Kit (Invalid Syntax)"); + syntax.printLayerAndSubLayers("addto", source); return true; } String kit = args[1]; if (!Data.kits.dataHashMap.containsKey(kit)) { - FeedbackHandler.error(sender, "Failed to Add To Kit: '" + kit + "' (Kit Doesn't Exist)"); - FeedbackHandler.syntax(sender, "*Tip: Double Check your Spelling*"); + FeedbackHandler.error(source, "Failed to Add To Kit: '" + kit + "' (Kit Doesn't Exist)"); + FeedbackHandler.syntax(source, "*Tip: Double Check your Spelling*"); return true; } @@ -403,86 +403,86 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (args[2].equals("item")) { - if (sender.getPlayer().getHeldItem() == null) { - FeedbackHandler.error(sender, "Failed to Add To Kit: '" + kit + "' (Held Item is Null)"); - FeedbackHandler.syntax(sender, "*Tip: Hold an item in your hand*"); + if (source.getSender().getHeldItem() == null) { + FeedbackHandler.error(source, "Failed to Add To Kit: '" + kit + "' (Held Item is Null)"); + FeedbackHandler.syntax(source, "*Tip: Hold an item in your hand*"); return true; } - kitdata.additem(new ItemStack(sender.getPlayer().getHeldItem()), listIndexOf(sender.getPlayer().inventory.mainInventory, sender.getPlayer().getHeldItem())); - FeedbackHandler.success(sender, "Added [" + sender.getPlayer().getHeldItem() + "] to Kit: '" + kit + "'"); + kitdata.additem(new ItemStack(source.getSender().getHeldItem()), listIndexOf(source.getSender().inventory.mainInventory, source.getSender().getHeldItem())); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Added [" + source.getSender().getHeldItem() + "] to Kit: '" + kit + "'"); Data.kits.saveAll(); return true; } if (args[2].equals("row")) { - int row = sender.getPlayer().inventory.hotbarOffset; + int row = source.getSender().inventory.hotbarOffset; for (int i = 0; i < 9; i++) { - if (sender.getPlayer().inventory.getStackInSlot(i + row) == null) { + if (source.getSender().inventory.getStackInSlot(i + row) == null) { continue; } - kitdata.additem(new ItemStack(sender.getPlayer().inventory.getStackInSlot(i + row)), listIndexOf(sender.getPlayer().inventory.mainInventory, sender.getPlayer().inventory.getStackInSlot(i + row))); + kitdata.additem(new ItemStack(source.getSender().inventory.getStackInSlot(i + row)), listIndexOf(source.getSender().inventory.mainInventory, source.getSender().inventory.getStackInSlot(i + row))); } Data.kits.saveAll(); - FeedbackHandler.success(sender, "Added Row to Kit: '" + kit + "'"); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Added Row to Kit: '" + kit + "'"); return true; } if (args[2].equals("armor")) { switch (args[3]) { case "head": - if (sender.getPlayer().inventory.getStackInSlot(39) == null) { - FeedbackHandler.error(sender, "Failed to Add To Kit: '" + kit + "' (Equipped Armor is Null)"); - FeedbackHandler.syntax(sender, "*Tip: Equip armor in your " + args[3] + " slot*"); + if (source.getSender().inventory.getStackInSlot(39) == null) { + FeedbackHandler.error(source, "Failed to Add To Kit: '" + kit + "' (Equipped Armor is Null)"); + FeedbackHandler.syntax(source, "*Tip: Equip armor in your " + args[3] + " slot*"); return true; } - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(39), 39); - FeedbackHandler.success(sender, "Added " + sender.getPlayer().inventory.getStackInSlot(39) + " to Kit: '" + kit + "'"); + kitdata.addarmor(source.getSender().inventory.getStackInSlot(39), 39); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Added " + source.getSender().inventory.getStackInSlot(39) + " to Kit: '" + kit + "'"); return true; case "chest": - if (sender.getPlayer().inventory.getStackInSlot(38) == null) { - FeedbackHandler.error(sender, "Failed to Add To Kit: '" + kit + "' (Equipped Armor is Null)"); - FeedbackHandler.syntax(sender, "*Tip: Equip armor in your " + args[3] + " slot*"); + if (source.getSender().inventory.getStackInSlot(38) == null) { + FeedbackHandler.error(source, "Failed to Add To Kit: '" + kit + "' (Equipped Armor is Null)"); + FeedbackHandler.syntax(source, "*Tip: Equip armor in your " + args[3] + " slot*"); return true; } - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(38), 38); - FeedbackHandler.success(sender, "Added " + sender.getPlayer().inventory.getStackInSlot(38) + " to Kit: '" + kit + "'"); + kitdata.addarmor(source.getSender().inventory.getStackInSlot(38), 38); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Added " + source.getSender().inventory.getStackInSlot(38) + " to Kit: '" + kit + "'"); return true; case "legs": - if (sender.getPlayer().inventory.getStackInSlot(37) == null) { - FeedbackHandler.error(sender, "Failed to Add To Kit: '" + kit + "' (Equipped Armor is Null)"); - FeedbackHandler.syntax(sender, "*Tip: Equip armor in your " + args[3] + " slot*"); + if (source.getSender().inventory.getStackInSlot(37) == null) { + FeedbackHandler.error(source, "Failed to Add To Kit: '" + kit + "' (Equipped Armor is Null)"); + FeedbackHandler.syntax(source, "*Tip: Equip armor in your " + args[3] + " slot*"); return true; } - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(37), 37); - FeedbackHandler.success(sender, "Added " + sender.getPlayer().inventory.getStackInSlot(37) + " to Kit: '" + kit + "'"); + kitdata.addarmor(source.getSender().inventory.getStackInSlot(37), 37); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Added " + source.getSender().inventory.getStackInSlot(37) + " to Kit: '" + kit + "'"); return true; case "boots": - if (sender.getPlayer().inventory.getStackInSlot(36) == null) { - FeedbackHandler.error(sender, "Failed to Add To Kit: '" + kit + "' (Equipped Armor is Null)"); - FeedbackHandler.syntax(sender, "*Tip: Equip armor in your " + args[3] + " slot*"); + if (source.getSender().inventory.getStackInSlot(36) == null) { + FeedbackHandler.error(source, "Failed to Add To Kit: '" + kit + "' (Equipped Armor is Null)"); + FeedbackHandler.syntax(source, "*Tip: Equip armor in your " + args[3] + " slot*"); return true; } - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(36), 36); - FeedbackHandler.success(sender, "Added " + sender.getPlayer().inventory.getStackInSlot(36) + " to Kit: '" + kit + "'"); + kitdata.addarmor(source.getSender().inventory.getStackInSlot(36), 36); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Added " + source.getSender().inventory.getStackInSlot(36) + " to Kit: '" + kit + "'"); return true; case "all": - if (sender.getPlayer().inventory.getStackInSlot(39) != null) { - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(39), 39); + if (source.getSender().inventory.getStackInSlot(39) != null) { + kitdata.addarmor(source.getSender().inventory.getStackInSlot(39), 39); } - if (sender.getPlayer().inventory.getStackInSlot(38) != null) { - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(38), 38); + if (source.getSender().inventory.getStackInSlot(38) != null) { + kitdata.addarmor(source.getSender().inventory.getStackInSlot(38), 38); } - if (sender.getPlayer().inventory.getStackInSlot(37) != null) { - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(37), 37); + if (source.getSender().inventory.getStackInSlot(37) != null) { + kitdata.addarmor(source.getSender().inventory.getStackInSlot(37), 37); } - if (sender.getPlayer().inventory.getStackInSlot(36) != null) { - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(36), 36); + if (source.getSender().inventory.getStackInSlot(36) != null) { + kitdata.addarmor(source.getSender().inventory.getStackInSlot(36), 36); } - FeedbackHandler.success(sender, "Added All Armor to Kit: '" + kit + "'"); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Added All Armor to Kit: '" + kit + "'"); return true; } return true; @@ -492,28 +492,28 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar int row = i * 9; for (int j = 0; j < 9; j++) { - if (sender.getPlayer().inventory.getStackInSlot(j + row) == null) { + if (source.getSender().inventory.getStackInSlot(j + row) == null) { continue; } - kitdata.additem(new ItemStack(sender.getPlayer().inventory.getStackInSlot(j + row)), listIndexOf(sender.getPlayer().inventory.mainInventory, sender.getPlayer().inventory.getStackInSlot(j + row))); + kitdata.additem(new ItemStack(source.getSender().inventory.getStackInSlot(j + row)), listIndexOf(source.getSender().inventory.mainInventory, source.getSender().inventory.getStackInSlot(j + row))); } } - if (sender.getPlayer().inventory.getStackInSlot(39) != null) { - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(39), 39); + if (source.getSender().inventory.getStackInSlot(39) != null) { + kitdata.addarmor(source.getSender().inventory.getStackInSlot(39), 39); } - if (sender.getPlayer().inventory.getStackInSlot(38) != null) { - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(38), 38); + if (source.getSender().inventory.getStackInSlot(38) != null) { + kitdata.addarmor(source.getSender().inventory.getStackInSlot(38), 38); } - if (sender.getPlayer().inventory.getStackInSlot(37) != null) { - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(37), 37); + if (source.getSender().inventory.getStackInSlot(37) != null) { + kitdata.addarmor(source.getSender().inventory.getStackInSlot(37), 37); } - if (sender.getPlayer().inventory.getStackInSlot(36) != null) { - kitdata.addarmor(sender.getPlayer().inventory.getStackInSlot(36), 36); + if (source.getSender().inventory.getStackInSlot(36) != null) { + kitdata.addarmor(source.getSender().inventory.getStackInSlot(36), 36); } - FeedbackHandler.success(sender, "Added All Items and Armor to Kit: " + kit); + FeedbackHandler.sendFeedback(FeedbackType.success, source, "Added All Items and Armor to Kit: " + kit); Data.kits.saveAll(); return true; } @@ -523,8 +523,8 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar if (args[0].equals("delete")) { if (args.length == 1) { - FeedbackHandler.error(sender, "Failed to Delete Kit (Invalid Syntax)"); - FeedbackHandler.syntax(sender, "/kit delete "); + FeedbackHandler.error(source, "Failed to Delete Kit (Invalid Syntax)"); + FeedbackHandler.syntax(source, "/kit delete "); return true; } @@ -532,18 +532,18 @@ public boolean execute(CommandHandler handler, CommandSender sender, String[] ar switch (Data.kits.remove(kit)) { case 0: - sender.sendMessage(TextFormatting.ORANGE + "Deleted Kit: '" + kit + "'"); + source.sendMessage(TextFormatting.ORANGE + "Deleted Kit: '" + kit + "'"); return true; case 1: - FeedbackHandler.error(sender, "Failed to Delete Kit: '" + kit + "' (Kit Doesn't Exist)"); + FeedbackHandler.error(source, "Failed to Delete Kit: '" + kit + "' (Kit Doesn't Exist)"); return true; case 2: - FeedbackHandler.error(sender, "Failed to Delete Kit: '" + kit + "' (IO Error)"); + FeedbackHandler.error(source, "Failed to Delete Kit: '" + kit + "' (IO Error)"); return true; } } } - FeedbackHandler.error(sender, " Kit Error: (Invalid Syntax)"); + FeedbackHandler.error(source, " Kit Error: (Invalid Syntax)"); return false; } @@ -566,13 +566,13 @@ public boolean opRequired(String[] args) { } @Override - public void sendCommandSyntax(CommandHandler handler, CommandSender sender) { - if (sender.isAdmin()) { - syntax.printAllLines(sender); + public void sendCommandSyntax(CommandHandler handler, CommandSource source) { + if (source.hasAdmin()) { + syntax.printAllLines(source); } else { - FeedbackHandler.syntax(sender, "< Command Syntax >"); - FeedbackHandler.syntax(sender, " > /kit give []"); - FeedbackHandler.syntax(sender, " > /kit list []"); + FeedbackHandler.syntax(source, "< Command Syntax >"); + FeedbackHandler.syntax(source, " > /kit give []"); + FeedbackHandler.syntax(source, " > /kit list []"); } } } diff --git a/src/main/java/MelonUtilities/commands/kit/KittenCommand.java b/src/main/java/MelonUtilities/command/commands/KittenCommandOld.djava similarity index 53% rename from src/main/java/MelonUtilities/commands/kit/KittenCommand.java rename to src/main/java/MelonUtilities/command/commands/KittenCommandOld.djava index bb490bd..0ba327d 100644 --- a/src/main/java/MelonUtilities/commands/kit/KittenCommand.java +++ b/src/main/java/MelonUtilities/command/commands/KittenCommandOld.djava @@ -1,23 +1,23 @@ -package MelonUtilities.commands.kit; +package MelonUtilities.command.kit; import net.minecraft.core.net.command.Command; import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; +import net.minecraft.core.net.command.CommandSource; -public class KittenCommand extends Command { +public class KittenCommandOld extends Command { private final static String COMMAND = "kitten"; private final static String NAME = "Kitten"; - public KittenCommand() { + public KittenCommandOld() { super(COMMAND); } @Override - public boolean execute(CommandHandler handler, CommandSender sender, String[] strings) { + public boolean execute(CommandHandler handler, CommandSource source, String[] strings) { if(Math.random() > .5) - sender.sendMessage("/ᐠ-ꞈ-ᐟ\\ ɴʏᴀ~"); + source.sendMessage("/ᐠ-ꞈ-ᐟ\\ ɴʏᴀ~"); else{ - sender.sendMessage("/ᐠ - ˕ -マ ɴʏᴀᴀᴀᴀᴀ!"); + source.sendMessage("/ᐠ - ˕ -マ ɴʏᴀᴀᴀᴀᴀ!"); } return true; } @@ -28,7 +28,7 @@ public boolean opRequired(String[] strings) { } @Override - public void sendCommandSyntax(CommandHandler commandHandler, CommandSender commandSender) { + public void sendCommandSyntax(CommandHandler commandHandler, CommandSource commandSource) { } } diff --git a/src/main/java/MelonUtilities/commands/rules/RulesCommand.java b/src/main/java/MelonUtilities/command/commands/RulesCommandOld.djava similarity index 78% rename from src/main/java/MelonUtilities/commands/rules/RulesCommand.java rename to src/main/java/MelonUtilities/command/commands/RulesCommandOld.djava index 964f083..a9018dc 100644 --- a/src/main/java/MelonUtilities/commands/rules/RulesCommand.java +++ b/src/main/java/MelonUtilities/command/commands/RulesCommandOld.djava @@ -1,18 +1,16 @@ -package MelonUtilities.commands.rules; +package MelonUtilities.command.rules; import MelonUtilities.MelonUtilities; -import com.google.gson.JsonArray; import com.google.gson.JsonElement; import com.google.gson.JsonObject; import com.google.gson.JsonParser; import com.google.gson.stream.JsonReader; import net.minecraft.core.net.command.Command; import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; +import net.minecraft.core.net.command.CommandSource; import net.minecraft.server.MinecraftServer; import java.io.File; -import java.io.FileReader; import java.io.IOException; import java.nio.file.Files; import java.util.ArrayList; @@ -20,22 +18,22 @@ import java.util.List; import java.util.Map; -public class RulesCommand extends Command { +public class RulesCommandOld extends Command { public static final File rulesFile = new File("./config/" + MelonUtilities.MOD_ID + "/rules.json"); public static final Map /*lines*/> rulesData = new HashMap<>(); - public RulesCommand() { + public RulesCommandOld() { super("rules"); } @Override - public boolean execute(CommandHandler commandHandler, CommandSender commandSender, String[] strings) { + public boolean execute(CommandHandler commandHandler, CommandSource commandSource, String[] strings) { if (strings.length == 0) { for (Map.Entry> entry : rulesData.entrySet()) { - commandSender.sendMessage(entry.getKey()); + commandSource.sendMessage(entry.getKey()); int i = 1; for (String s : entry.getValue()) { - commandSender.sendMessage(String.format(" - §3§nRule #%s§r: %s", i, s)); - commandSender.sendMessage(""); + commandSource.sendMessage(String.format(" - §3§nRule #%s§r: %s", i, s)); + commandSource.sendMessage(""); i++; } } @@ -63,10 +61,10 @@ public boolean opRequired(String[] strings) { } @Override - public void sendCommandSyntax(CommandHandler commandHandler, CommandSender commandSender) { - commandSender.sendMessage("/rules"); - if (commandSender.isAdmin()) { - commandSender.sendMessage("/rules reload"); + public void sendCommandSyntax(CommandHandler commandHandler, CommandSource commandSource) { + commandSource.sendMessage("/rules"); + if (commandSource.isAdmin()) { + commandSource.sendMessage("/rules reload"); } } diff --git a/src/main/java/MelonUtilities/commands/misc/SmiteCommand.java b/src/main/java/MelonUtilities/command/commands/SmiteCommandOld.djava similarity index 61% rename from src/main/java/MelonUtilities/commands/misc/SmiteCommand.java rename to src/main/java/MelonUtilities/command/commands/SmiteCommandOld.djava index 138660e..720046c 100644 --- a/src/main/java/MelonUtilities/commands/misc/SmiteCommand.java +++ b/src/main/java/MelonUtilities/command/commands/SmiteCommandOld.djava @@ -1,22 +1,22 @@ -package MelonUtilities.commands.misc; +package MelonUtilities.command.misc; -import MelonUtilities.utility.FeedbackHandler; +import MelonUtilities.utility.feedback.FeedbackHandlerServer; import net.minecraft.core.entity.EntityLightningBolt; import net.minecraft.core.net.command.Command; import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; +import net.minecraft.core.net.command.CommandSource; import net.minecraft.core.net.command.LocationTarget; -public class SmiteCommand extends Command { +public class SmiteCommandOld extends Command { private final static String COMMAND = "smite"; - public SmiteCommand() { + public SmiteCommandOld() { super(COMMAND); } @Override - public boolean execute(CommandHandler commandHandler, CommandSender commandSender, String[] strings) { - LocationTarget location = new LocationTarget(commandHandler, commandSender); + public boolean execute(CommandHandler commandHandler, CommandSource commandSource, String[] strings) { + LocationTarget location = new LocationTarget(commandHandler, commandSource); location.getWorld().addWeatherEffect(new EntityLightningBolt(location.getWorld(), location.getX(), location.getY()-1, location.getZ())); return true; } @@ -27,7 +27,7 @@ public boolean opRequired(String[] strings) { } @Override - public void sendCommandSyntax(CommandHandler commandHandler, CommandSender commandSender) { - FeedbackHandler.syntax(commandSender, "smite"); + public void sendCommandSyntax(CommandHandler commandHandler, CommandSource commandSource) { + FeedbackHandler.syntax(commandSource, "smite"); } } diff --git a/src/main/java/MelonUtilities/commands/helper/HelperCommand.java b/src/main/java/MelonUtilities/commands/helper/HelperCommand.java deleted file mode 100644 index 6392979..0000000 --- a/src/main/java/MelonUtilities/commands/helper/HelperCommand.java +++ /dev/null @@ -1,114 +0,0 @@ -package MelonUtilities.commands.helper; - -import MelonUtilities.config.Data; -import MelonUtilities.config.datatypes.PlayerData; -import MelonUtilities.utility.FeedbackHandler; -import MelonUtilities.utility.SyntaxBuilder; -import MelonUtilities.utility.UUIDHelper; -import net.minecraft.core.net.command.Command; -import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; -import net.minecraft.core.net.command.TextFormatting; -import net.minecraft.server.entity.player.EntityPlayerMP; - -public class HelperCommand extends Command { - - private final static String COMMAND = "helper"; - - public HelperCommand() {super(COMMAND, "h");} - - public static SyntaxBuilder syntax = new SyntaxBuilder(); - - public static void buildHelperSyntax(){ - syntax.clear(); - syntax.append("title", TextFormatting.LIGHT_GRAY + "< Command Syntax > ([] = optional, <> = variable, / = or)"); - syntax.append("helper", "title", TextFormatting.LIGHT_GRAY + " > /helper "); - syntax.append("helperAdd", "helper", TextFormatting.LIGHT_GRAY + " > add "); - syntax.append("helperRemove", "helper", TextFormatting.LIGHT_GRAY + " > remove "); - } - - private boolean add(CommandHandler handler, CommandSender sender, String[] args){ - String username = args[1]; - EntityPlayerMP player = (EntityPlayerMP) handler.getPlayer(username); - - if (player != null && !Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper) { - FeedbackHandler.success(sender, "You are now a Helper!"); - FeedbackHandler.success(sender, "Setting " + TextFormatting.GRAY + username + TextFormatting.LIME + " to Helper."); - - Data.playerData.loadAll(PlayerData.class); - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper = true; - Data.playerData.saveAll(); - - return true; - } else if (Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper){ - handler.sendCommandFeedback(sender, TextFormatting.GRAY + username + TextFormatting.RED + " is already a helper!"); - return true; - } else if (player == null) { - FeedbackHandler.success(sender, TextFormatting.LIME + "Setting " + TextFormatting.GRAY + username + TextFormatting.LIME + " to Helper."); - - Data.playerData.loadAll(PlayerData.class); - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper = true; - Data.playerData.saveAll(); - - return true; - } - return true; - } - - private boolean remove(CommandHandler handler, CommandSender sender, String[] args){ - String username = args[1]; - EntityPlayerMP player = (EntityPlayerMP) handler.getPlayer(username); - - if (player != null && Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper) { - FeedbackHandler.destructive(sender, "You are no longer a Helper!"); - FeedbackHandler.success(sender, TextFormatting.LIME + "Removing " + TextFormatting.GRAY + username + TextFormatting.LIME + " from Helper List."); - - Data.playerData.loadAll(PlayerData.class); - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper = false; - Data.playerData.saveAll(); - - return true; - } else if(!Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper){ - FeedbackHandler.error(sender, TextFormatting.GRAY + username + TextFormatting.RED + " isn't a helper!"); - return true; - } else if (player == null) { - FeedbackHandler.success(sender, TextFormatting.LIME + "Removing " + TextFormatting.GRAY + username + TextFormatting.LIME + " from Helper List."); - - Data.playerData.loadAll(PlayerData.class); - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(username).toString(), PlayerData.class).isHelper = false; - Data.playerData.saveAll(); - - return true; - } - return true; - } - - @Override - public boolean execute(CommandHandler handler, CommandSender sender, String[] args) { - - if (args.length == 0) { - return false; - } - - switch(args[0]){ - case "add": - return add(handler, sender, args); - case "remove": - return remove(handler, sender, args); - } - - sender.sendMessage(TextFormatting.RED + "Helper Command Failed (Invalid Syntax)"); - syntax.printAllLines(sender); - return true; - } - - @Override - public boolean opRequired(String[] args) { - return true; - } - - @Override - public void sendCommandSyntax(CommandHandler handler, CommandSender sender) { - syntax.printAllLines(sender); - } -} diff --git a/src/main/java/MelonUtilities/commands/home/DelHomeCommand.java b/src/main/java/MelonUtilities/commands/home/DelHomeCommand.java deleted file mode 100644 index bb076d3..0000000 --- a/src/main/java/MelonUtilities/commands/home/DelHomeCommand.java +++ /dev/null @@ -1,75 +0,0 @@ -package MelonUtilities.commands.home; - -import MelonUtilities.config.Data; -import MelonUtilities.config.datatypes.PlayerData; -import MelonUtilities.utility.FeedbackHandler; -import MelonUtilities.utility.SyntaxBuilder; -import MelonUtilities.config.custom.classes.Home; -import MelonUtilities.utility.UUIDHelper; -import net.minecraft.core.net.command.*; - -import java.util.Objects; - -public class DelHomeCommand extends Command { - - public DelHomeCommand() { - super("delhome"); - } - - public void deleteHome(String name, CommandSender sender){ - for(int i = 0; i < Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).homes.size(); i++) { - if(Objects.equals(Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).homes.get(i).name, name)){ - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).homes.remove(i); - Data.playerData.saveAll(); - return; - } - } - } - - static SyntaxBuilder syntax = new SyntaxBuilder(); - - public static void buildSyntax(){ - syntax.clear(); - syntax.append("title", TextFormatting.LIGHT_GRAY + "< Command Syntax >"); - syntax.append("delhome", TextFormatting.LIGHT_GRAY + " > /delhome []"); - } - - @Override - public boolean execute(CommandHandler handler, CommandSender sender, String[] args) { - Home home = HomeCommand.getHome("home", sender); - - if (args.length == 0 && home != null) { - deleteHome("home", sender); - FeedbackHandler.destructive(sender, "Deleted Home: "); - return true; - } else if (args.length == 0){ - FeedbackHandler.error(sender, "Failed to Delete Home (Home does not exist!)"); - syntax.printLayerAndSubLayers("home", sender); - return true; - } else if (args.length == 1) { - home = HomeCommand.getHome(args[0], sender); - if (home != null) { - deleteHome(args[0], sender); - FeedbackHandler.destructive(sender, "Deleted Home: <" + args[0] + ">"); - return true; - } - FeedbackHandler.error(sender, "Failed to Delete Home (Home does not exist!)"); - syntax.printLayerAndSubLayers("home", sender); - return true; - } - - FeedbackHandler.error(sender, "Failed to Delete Home (Invalid Syntax)"); - syntax.printLayerAndSubLayers("delhome", sender); - return true; - } - - @Override - public boolean opRequired(String[] strings) { - return false; - } - - @Override - public void sendCommandSyntax(CommandHandler handler, CommandSender sender) { - syntax.printAllLines(sender); - } -} diff --git a/src/main/java/MelonUtilities/commands/home/HomeCommand.java b/src/main/java/MelonUtilities/commands/home/HomeCommand.java deleted file mode 100644 index 344e1c8..0000000 --- a/src/main/java/MelonUtilities/commands/home/HomeCommand.java +++ /dev/null @@ -1,106 +0,0 @@ -package MelonUtilities.commands.home; - -import MelonUtilities.config.Data; -import MelonUtilities.config.datatypes.PlayerData; -import MelonUtilities.utility.FeedbackHandler; -import MelonUtilities.utility.SyntaxBuilder; -import MelonUtilities.config.custom.classes.Home; -import MelonUtilities.utility.UUIDHelper; -import net.minecraft.client.entity.player.EntityPlayerSP; -import net.minecraft.core.entity.player.EntityPlayer; -import net.minecraft.core.net.command.*; -import net.minecraft.server.MinecraftServer; -import net.minecraft.server.entity.player.EntityPlayerMP; - -import java.util.Objects; - -public class HomeCommand extends Command { - - public HomeCommand() { - super("home"); - } - - public static Home getHome(String name, CommandSender sender){ - for(int i = 0; i < Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).homes.size(); i++){ - if(Objects.equals(Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).homes.get(i).name, name)){ - return Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).homes.get(i); - } - } - return null; - } - - public static void teleport(double x, double y, double z, EntityPlayer player){ - if (player.world.isClientSide) return; - - if (player instanceof EntityPlayerMP){ - EntityPlayerMP playerMP = (EntityPlayerMP)player; - player.world.playSoundAtEntity(null, player, "mob.ghast.fireball", 1f, 2f); - playerMP.playerNetServerHandler.teleport(x, y, z); - } else if (player instanceof EntityPlayerSP) { - EntityPlayerSP playerSP = (EntityPlayerSP)player; - playerSP.setPos(x, y + playerSP.bbHeight, z); - } - player.world.playSoundAtEntity(null, player, "mob.ghast.fireball", 1f, 2f); - } - - static SyntaxBuilder syntax = new SyntaxBuilder(); - - public static void buildSyntax(){ - syntax.clear(); - syntax.append("title", TextFormatting.LIGHT_GRAY + "< Command Syntax >"); - syntax.append("home", TextFormatting.LIGHT_GRAY + " > /home []"); - } - - @Override - public boolean execute(CommandHandler handler, CommandSender sender, String[] args) { - Home home = getHome("home", sender); - if (args.length == 0 && home != null) { - FeedbackHandler.success(sender, "Teleporting to Home: "); - - return sendHome(sender, home); - } - - if (args.length == 0) { - FeedbackHandler.error(sender, "Failed to Teleport Home (Home does not exist!)"); - - syntax.printLayerAndSubLayers("home", sender); - return true; - } - - if (args.length == 1) { - home = getHome(args[0], sender); - if (home == null) { - FeedbackHandler.error(sender, "Failed to Teleport Home (Home does not exist!)"); - syntax.printLayerAndSubLayers("home", sender); - return true; - } - - FeedbackHandler.success(sender, "Teleporting to Home: <" + args[0] + ">"); - return sendHome(sender, home); - } - - FeedbackHandler.error(sender, "Failed to Teleport Home (Invalid Syntax)"); - syntax.printLayerAndSubLayers("home", sender); - return true; - } - - private boolean sendHome(CommandSender sender, Home home) { - if (sender.getPlayer().dimension != home.dimID) { - MinecraftServer mc = MinecraftServer.getInstance(); - EntityPlayerMP player = (EntityPlayerMP) sender.getPlayer(); - mc.playerList.sendPlayerToOtherDimension(player, home.dimID, false); - } - teleport(home.x, home.y, home.z, sender.getPlayer()); - return true; - } - - @Override - public boolean opRequired(String[] strings) { - return false; - } - - @Override - public void sendCommandSyntax(CommandHandler handler, CommandSender sender) { - syntax.printAllLines(sender); - } -} diff --git a/src/main/java/MelonUtilities/commands/home/SetHomeCommand.java b/src/main/java/MelonUtilities/commands/home/SetHomeCommand.java deleted file mode 100644 index 4f09a00..0000000 --- a/src/main/java/MelonUtilities/commands/home/SetHomeCommand.java +++ /dev/null @@ -1,82 +0,0 @@ -package MelonUtilities.commands.home; - -import MelonUtilities.config.Data; -import MelonUtilities.config.datatypes.PlayerData; -import MelonUtilities.utility.FeedbackHandler; -import MelonUtilities.utility.SyntaxBuilder; -import MelonUtilities.config.custom.classes.Home; -import MelonUtilities.utility.UUIDHelper; -import net.minecraft.core.net.command.Command; -import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; -import net.minecraft.core.net.command.TextFormatting; - -public class SetHomeCommand extends Command { - - public SetHomeCommand() { - super("sethome"); - } - - double scale = Math.pow(10, 1); - - public void addHome(String name, double x, double y, double z, int dimID, CommandSender sender){ - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).homes.add(new Home(name, x, y, z, dimID)); - Data.playerData.saveAll(); - } - - static SyntaxBuilder syntax = new SyntaxBuilder(); - - public static void buildSyntax(){ - syntax.clear(); - syntax.append("title", TextFormatting.LIGHT_GRAY + "< Command Syntax >"); - syntax.append("sethome", TextFormatting.LIGHT_GRAY + " > /sethome []"); - } - - @Override - public boolean execute(CommandHandler handler, CommandSender sender, String[] args) { - - int dimID = sender.getPlayer().dimension; - double x = Math.round(sender.getPlayer().x * scale) / scale; - double y = Math.round(sender.getPlayer().y * scale) / scale; - double z = Math.round(sender.getPlayer().z * scale) / scale; - - Home home = HomeCommand.getHome("home", sender); - - if (args.length == 0 && home == null) { - - addHome("home", x, y, z, dimID, sender); - FeedbackHandler.success(sender, "Set Home: to:"); - FeedbackHandler.success(sender, "[Dimension: " + sender.getPlayer().world.dimension.getTranslatedName() + "]"); - FeedbackHandler.success(sender, "[x: " + x + " y: " + y + " z: " + z + "]"); - return true; - - } else if (args.length == 0) { - sender.sendMessage(TextFormatting.RED + "Failed to Set Home (Home already exists!))"); - syntax.printLayerAndSubLayers("sethome", sender); - return true; - } else if (args.length == 1) { - home = HomeCommand.getHome(args[0], sender); - if(home == null){ - addHome(args[0], x, y, z, dimID, sender); - FeedbackHandler.success(sender, "Set Home: <" + args[0] + "> to:"); - FeedbackHandler.success(sender, "[Dimension: " + sender.getPlayer().world.dimension.getTranslatedName() + "]"); - FeedbackHandler.success(sender, "[x: " + x + " y: " + y + " z: " + z + "]"); - return true; - } - FeedbackHandler.error(sender, "Failed to Set Home (Invalid Syntax)"); - syntax.printLayerAndSubLayers("sethome", sender); - return true; - } - return true; - } - - @Override - public boolean opRequired(String[] strings) { - return false; - } - - @Override - public void sendCommandSyntax(CommandHandler handler, CommandSender sender) { - syntax.printAllLines(sender); - } -} diff --git a/src/main/java/MelonUtilities/commands/lock/LockCommand.java b/src/main/java/MelonUtilities/commands/lock/LockCommand.java deleted file mode 100644 index 9bfe7f3..0000000 --- a/src/main/java/MelonUtilities/commands/lock/LockCommand.java +++ /dev/null @@ -1,481 +0,0 @@ -package MelonUtilities.commands.lock; - -import MelonUtilities.config.Data; -import MelonUtilities.config.datatypes.PlayerData; -import MelonUtilities.interfaces.TileEntityContainerInterface; -import MelonUtilities.utility.FeedbackHandler; -import MelonUtilities.utility.MUtil; -import MelonUtilities.utility.SyntaxBuilder; -import MelonUtilities.utility.UUIDHelper; -import net.minecraft.core.HitResult; -import net.minecraft.core.block.entity.*; -import net.minecraft.core.net.command.Command; -import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; -import net.minecraft.core.net.command.TextFormatting; - -public class LockCommand extends Command { - - private final static String COMMAND = "lock"; - - public LockCommand() { - super(COMMAND, "l"); - } - - public static SyntaxBuilder syntax = new SyntaxBuilder(); - - public static void buildLockSyntax(){ - syntax.clear(); - syntax.append("title", TextFormatting.LIGHT_GRAY + "< Command Syntax > ([] = optional, <> = variable, / = or)"); - syntax.append("lock", "title", TextFormatting.LIGHT_GRAY + " > /lock []"); - syntax.append("lockOnBlockPlaced", "lock", TextFormatting.LIGHT_GRAY + " > onBlockPlaced true/false"); - syntax.append("lockOnBlockPunched", "lock", TextFormatting.LIGHT_GRAY + " > onBlockPunched true/false"); - syntax.append("lockTrust", "lock", TextFormatting.LIGHT_GRAY + " > trust "); - syntax.append("lockTrustAll", "lock", TextFormatting.LIGHT_GRAY + " > trustall "); - syntax.append("lockTrustCommunity", "lock", TextFormatting.LIGHT_GRAY + " > trustcommunity"); - syntax.append("lockUntrust", "lock", TextFormatting.LIGHT_GRAY + " > untrust "); - syntax.append("lockUntrustAll", "lock", TextFormatting.LIGHT_GRAY + " > untrustall "); - syntax.append("lockUntrustCommunity", "lock", TextFormatting.LIGHT_GRAY + " > untrustcommunity"); - syntax.append("lockBypass", "lock", true, TextFormatting.LIGHT_GRAY + " > bypass true/false"); - } - - private boolean onBlockPlaced(CommandHandler handler, CommandSender sender, String[] args){ - if(args[1].equals("true")) { - if(!Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockOnBlockPlaced){ - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockOnBlockPlaced = true; - FeedbackHandler.success(sender, "Lock-On-Block-Placed is now On!"); - return true; - } - FeedbackHandler.error(sender, "Failed to turn Lock-On-Block-Placed On! (Already On)"); - return false; - } - if(args[1].equals("false")) { - if(Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockOnBlockPlaced) { - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockOnBlockPlaced = false; - FeedbackHandler.success(sender, "Lock on Block Placed is now Off!"); - return true; - } - FeedbackHandler.error(sender, "Failed to turn Lock-On-Block-Placed Off! (Already Off)"); - return false; - } - FeedbackHandler.error(sender, "Failed to set Lock Mode! (Invalid Syntax)"); - return false; - } - - private boolean onBlockPunched(CommandHandler handler, CommandSender sender, String[] args){ - if(args[1].equals("true")) { - if(!Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockOnBlockPunched){ - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockOnBlockPunched = true; - FeedbackHandler.success(sender, "Lock-On-Block-Punched is now On!"); - return true; - } - FeedbackHandler.error(sender, "Failed to turn Lock-On-Block-Punched On! (Already On)"); - return true; - } - if(args[1].equals("false")) { - if(Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockOnBlockPunched) { - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockOnBlockPunched = false; - FeedbackHandler.success(sender, "Lock-On-Block-Punched is now Off!"); - return true; - } - FeedbackHandler.error(sender, "Failed to turn Lock-On-Block-Punched Off! (Already Off)"); - return true; - } - FeedbackHandler.error(sender, "Failed to set Lock Mode! (Invalid Syntax)"); - return false; - } - - private boolean trust(CommandHandler handler, CommandSender sender, String[] args){ - if(UUIDHelper.getUUIDFromName(args[1]) != null) { - - HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); - - if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { - FeedbackHandler.error(sender, "Failed to Trust Player to Container! (Not Looking at Container)"); - return true; - } - - TileEntity container = sender.getWorld().getBlockTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); - - if(container != null) { - if (container instanceof TileEntityContainerInterface) { - TileEntityContainerInterface iContainer = ((TileEntityContainerInterface) container); - if (iContainer.getIsLocked()) { - - if (!iContainer.getLockOwner().equals(UUIDHelper.getUUIDFromName(sender.getPlayer().username))) { - FeedbackHandler.error(sender, "Failed to Trust Player to Container! (Not Owned By You)"); - return true; - } - - if (iContainer.getTrustedPlayers().contains(UUIDHelper.getUUIDFromName(args[1]))) { - FeedbackHandler.error(sender, "Failed to Trust Player to Container! (Player already Trusted)"); - return true; - } - - if (container instanceof TileEntityChest) { - TileEntityContainerInterface iOtherContainer = (TileEntityContainerInterface) MUtil.getOtherChest(sender.getWorld(), (TileEntityChest) container); - if (iOtherContainer != null) { - iContainer.addTrustedPlayer(UUIDHelper.getUUIDFromName(args[1])); - iOtherContainer.addTrustedPlayer(UUIDHelper.getUUIDFromName(args[1])); - FeedbackHandler.success(sender, "Trusted " + TextFormatting.GRAY + args[1] + TextFormatting.LIME + " to this Double Chest!"); - return true; - } - FeedbackHandler.success(sender, "Trusted " + TextFormatting.GRAY + args[1] + TextFormatting.LIME + " to this Chest!"); - } else if (container instanceof TileEntityBlastFurnace) { - FeedbackHandler.success(sender, "Trusted " + TextFormatting.GRAY + args[1] + TextFormatting.LIME + " to this Blast Furnace!"); - } else if (container instanceof TileEntityFurnace) { - FeedbackHandler.success(sender, "Trusted " + TextFormatting.GRAY + args[1] + TextFormatting.LIME + " to this Furnace!"); - } else if (container instanceof TileEntityDispenser) { - FeedbackHandler.success(sender, "Trusted " + TextFormatting.GRAY + args[1] + TextFormatting.LIME + " to this Dispenser!"); - } else if (container instanceof TileEntityMeshGold) { - FeedbackHandler.success(sender, "Trusted " + TextFormatting.GRAY + args[1] + TextFormatting.LIME + " to this Golden Mesh!"); - } else if (container instanceof TileEntityTrommel) { - FeedbackHandler.success(sender, "Trusted " + TextFormatting.GRAY + args[1] + TextFormatting.LIME + " to this Trommel!"); - } else if (container instanceof TileEntityBasket) { - FeedbackHandler.success(sender, "Trusted " + TextFormatting.GRAY + args[1] + TextFormatting.LIME + " to this Basket!"); - } - iContainer.addTrustedPlayer(UUIDHelper.getUUIDFromName(args[1])); - return true; - } - } - } - if(container != null) { - FeedbackHandler.error(sender, "Failed to Trust Player to Container! (Container not Locked)"); - return true; - } - FeedbackHandler.error(sender, "Failed to Trust Player to Container! (Not Looking at Container)"); - return true; - } - FeedbackHandler.error(sender, "Failed to Trust " + TextFormatting.GRAY + args[1] + TextFormatting.RED + " to Container!"); - FeedbackHandler.error(sender, "(Player Doesn't Exist)"); - return true; - } - - private boolean trustAll(CommandHandler handler, CommandSender sender, String[] args){ - if(UUIDHelper.getUUIDFromName(args[1]) != null) { - if(!Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).playersTrustedToAllContainers.contains(UUIDHelper.getUUIDFromName(args[1]))){ - Data.playerData.loadAll(PlayerData.class); - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).playersTrustedToAllContainers.add(UUIDHelper.getUUIDFromName(args[1])); - Data.playerData.saveAll(); - FeedbackHandler.success(sender, "Trusted " + TextFormatting.GRAY + args[1] + TextFormatting.LIME + " to all Containers!"); - return true; - } - FeedbackHandler.error(sender, "Failed to Trust " + TextFormatting.GRAY + args[1] + TextFormatting.RED + " to all Containers!"); - FeedbackHandler.error(sender, "(Player is Already Trusted)"); - return true; - } - FeedbackHandler.error(sender, "Failed to Trust " + TextFormatting.GRAY + args[1] + TextFormatting.RED + " to all Containers!"); - FeedbackHandler.error(sender, "(Player Doesn't Exist)"); - return true; - } - - private boolean trustCommunity(CommandHandler handler, CommandSender sender, String[] args){ - - HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); - - if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { - FeedbackHandler.error(sender, "Failed to Trust Community to Container! (Not Looking at Container)"); - return true; - } - - TileEntity container = sender.getWorld().getBlockTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); - - if (container instanceof TileEntityContainerInterface) { - TileEntityContainerInterface iContainer = ((TileEntityContainerInterface) container); - if (iContainer.getIsLocked()) { - - if (!iContainer.getLockOwner().equals(UUIDHelper.getUUIDFromName(sender.getPlayer().username))) { - FeedbackHandler.error(sender, "Failed to Trust Community to Container! (Not Owned By You)"); - return true; - } - - if (container instanceof TileEntityChest) { - TileEntityContainerInterface iOtherContainer = (TileEntityContainerInterface) MUtil.getOtherChest(sender.getWorld(), (TileEntityChest) container); - if (iOtherContainer != null) { - iContainer.setIsCommunityContainer(true); - iOtherContainer.setIsCommunityContainer(true); - FeedbackHandler.destructive(sender, "Trusted Community to this Double Chest!"); - return true; - } - FeedbackHandler.destructive(sender, "Trusted Community to this Chest!"); - } else if (container instanceof TileEntityBlastFurnace) { - FeedbackHandler.destructive(sender, "Trusted Community to this Blast Furnace!"); - } else if (container instanceof TileEntityFurnace) { - FeedbackHandler.destructive(sender, "Trusted Community to this Furnace!"); - } else if (container instanceof TileEntityDispenser) { - FeedbackHandler.destructive(sender, "Trusted Community to this Dispenser!"); - } else if (container instanceof TileEntityMeshGold) { - FeedbackHandler.destructive(sender, "Trusted Community to this Golden Mesh!"); - } else if (container instanceof TileEntityTrommel) { - FeedbackHandler.destructive(sender, "Trusted Community to this Trommel!"); - } else if (container instanceof TileEntityBasket) { - FeedbackHandler.destructive(sender, "Trusted Community to this Basket!"); - } - iContainer.setIsCommunityContainer(true); - return true; - } - } - if(container != null) { - FeedbackHandler.error(sender, "Failed to Trust Community to Container! (Container not Locked)"); - return true; - } - FeedbackHandler.error(sender, "Failed to Trust Community to Container! (Not Looking at Container)"); - return true; - } - - private boolean untrust(CommandHandler handler, CommandSender sender, String[] args){ - if(UUIDHelper.getUUIDFromName(args[1]) != null) { - - HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); - - if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { - FeedbackHandler.error(sender, "Failed to Untrust Player from Container! (Not Looking at Container)"); - return true; - } - - TileEntity container = sender.getWorld().getBlockTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); - - if (container instanceof TileEntityContainerInterface) { - TileEntityContainerInterface iContainer = ((TileEntityContainerInterface) container); - if (iContainer.getIsLocked()) { - - if (!iContainer.getLockOwner().equals(UUIDHelper.getUUIDFromName(sender.getPlayer().username))) { - FeedbackHandler.error(sender, "Failed to Untrust Player from Container! (Not Owned By You)"); - return true; - } - - if (!iContainer.getTrustedPlayers().contains(UUIDHelper.getUUIDFromName(args[1]))) { - FeedbackHandler.error(sender, "Failed to Untrust Player from Container! (Player not Trusted)"); - return true; - } - - if (container instanceof TileEntityChest) { - TileEntityContainerInterface iOtherContainer = (TileEntityContainerInterface) MUtil.getOtherChest(sender.getWorld(), (TileEntityChest) container); - if (iOtherContainer != null) { - iContainer.removeTrustedPlayer(UUIDHelper.getUUIDFromName(args[1])); - iOtherContainer.removeTrustedPlayer(UUIDHelper.getUUIDFromName(args[1])); - FeedbackHandler.destructive(sender, "Untrusted " + TextFormatting.GRAY + args[1] + TextFormatting.ORANGE + " from this Double Chest!"); - return true; - } - FeedbackHandler.destructive(sender, "Untrusted " + TextFormatting.GRAY + args[1] + TextFormatting.ORANGE + " from this Chest!"); - } else if (container instanceof TileEntityBlastFurnace) { - FeedbackHandler.destructive(sender, "Untrusted " + TextFormatting.GRAY + args[1] + TextFormatting.ORANGE + " from this Blast Furnace!"); - } else if (container instanceof TileEntityFurnace) { - FeedbackHandler.destructive(sender, "Untrusted " + TextFormatting.GRAY + args[1] + TextFormatting.ORANGE + " from this Furnace!"); - } else if (container instanceof TileEntityDispenser) { - FeedbackHandler.destructive(sender, "Untrusted " + TextFormatting.GRAY + args[1] + TextFormatting.ORANGE + " from this Dispenser!"); - } else if (container instanceof TileEntityMeshGold) { - FeedbackHandler.destructive(sender, "Untrusted " + TextFormatting.GRAY + args[1] + TextFormatting.ORANGE + " from this Golden Mesh!"); - } else if (container instanceof TileEntityTrommel) { - FeedbackHandler.destructive(sender, "Untrusted " + TextFormatting.GRAY + args[1] + TextFormatting.ORANGE + " from this Trommel!"); - } else if (container instanceof TileEntityBasket) { - FeedbackHandler.destructive(sender, "Untrusted " + TextFormatting.GRAY + args[1] + TextFormatting.ORANGE + " from this Basket!"); - } - iContainer.removeTrustedPlayer(UUIDHelper.getUUIDFromName(args[1])); - return true; - } - } - if(container != null) { - FeedbackHandler.error(sender, "Failed to Untrust Player from Container! (Container not Locked)"); - return true; - } - FeedbackHandler.error(sender, "Failed to Untrust Player from Container! (Not Looking at Container)"); - return true; - } - FeedbackHandler.error(sender, "Failed to Untrust " + TextFormatting.GRAY + args[1] + TextFormatting.RED + " from Container!"); - FeedbackHandler.error(sender, "(Player Doesn't Exist)"); - return true; - } - - private boolean untrustAll(CommandHandler handler, CommandSender sender, String[] args){ - if(UUIDHelper.getUUIDFromName(args[1]) != null) { - if(Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).playersTrustedToAllContainers.contains(UUIDHelper.getUUIDFromName(args[1]))){ - Data.playerData.loadAll(PlayerData.class); - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).playersTrustedToAllContainers.remove(UUIDHelper.getUUIDFromName(args[1])); - Data.playerData.saveAll(); - FeedbackHandler.destructive(sender, "Untrusted " + TextFormatting.GRAY + args[1] + TextFormatting.ORANGE + " from all Containers!"); - return true; - } - FeedbackHandler.error(sender, "Failed to Untrust " + TextFormatting.GRAY + args[1] + TextFormatting.RED + " from all Containers!"); - FeedbackHandler.error(sender, "(Player isn't Trusted)"); - return true; - } - FeedbackHandler.error(sender, "Failed to Untrust " + TextFormatting.GRAY + args[1] + TextFormatting.RED + " from all Containers!"); - FeedbackHandler.error(sender, "(Player Doesn't Exist)"); - return true; - } - - private boolean untrustCommunity(CommandHandler handler, CommandSender sender, String[] args){ - - HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); - - if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { - FeedbackHandler.error(sender, "Failed to Untrust Community from Container! (Not Looking at Container)"); - return true; - } - - TileEntity container = sender.getWorld().getBlockTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); - - if(container != null) { - if (container instanceof TileEntityContainerInterface) { - TileEntityContainerInterface iContainer = ((TileEntityContainerInterface) container); - if (iContainer.getIsLocked()) { - - if (!iContainer.getLockOwner().equals(UUIDHelper.getUUIDFromName(sender.getPlayer().username))) { - FeedbackHandler.error(sender, "Failed to Untrust Community from Container! (Not Owned By You)"); - return true; - } - - if (container instanceof TileEntityChest) { - TileEntityContainerInterface iOtherContainer = (TileEntityContainerInterface) MUtil.getOtherChest(sender.getWorld(), (TileEntityChest) container); - if (iOtherContainer != null) { - iContainer.setIsCommunityContainer(false); - iOtherContainer.setIsCommunityContainer(false); - FeedbackHandler.destructive(sender, "Untrusted Community from this Double Chest!"); - return true; - } - FeedbackHandler.destructive(sender, "Untrusted Community from this Chest!"); - } else if (container instanceof TileEntityBlastFurnace) { - FeedbackHandler.destructive(sender, "Untrusted Community from this Blast Furnace!"); - } else if (container instanceof TileEntityFurnace) { - FeedbackHandler.destructive(sender, "Untrusted Community from this Furnace!"); - } else if (container instanceof TileEntityDispenser) { - FeedbackHandler.destructive(sender, "Untrusted Community from this Dispenser!"); - } else if (container instanceof TileEntityMeshGold) { - FeedbackHandler.destructive(sender, "Untrusted Community from this Golden Mesh!"); - } else if (container instanceof TileEntityTrommel) { - FeedbackHandler.destructive(sender, "Untrusted Community from this Trommel!"); - } else if (container instanceof TileEntityBasket) { - FeedbackHandler.destructive(sender, "Untrusted Community from this Basket!"); - } - iContainer.setIsCommunityContainer(false); - return true; - } - } - } - FeedbackHandler.error(sender, "Failed to Untrust Community from Container! (Not Looking at Container)"); - return true; - } - - - private boolean bypass(CommandHandler handler, CommandSender sender, String[] args) { - if(sender.isAdmin()) { - if (args[1].equals("true")) { - if (!Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockBypass) { - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockBypass = true; - FeedbackHandler.success(sender, "Lock-Bypass is now On!"); - return true; - } - FeedbackHandler.error(sender, "Failed to turn Lock-Bypass On! (Already On)"); - return true; - } - if (args[1].equals("false")) { - if (Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockBypass) { - Data.playerData.getOrCreate(UUIDHelper.getUUIDFromName(sender.getPlayer().username).toString(), PlayerData.class).lockBypass = false; - FeedbackHandler.success(sender, "Lock-Bypass is now Off!"); - return true; - } - FeedbackHandler.error(sender, "Failed to turn Lock-Bypass Off! (Already Off)"); - return true; - } - FeedbackHandler.error(sender, "Failed to set Lock-Bypass! (Invalid Syntax)"); - return false; - } - FeedbackHandler.error(sender, "You don't have permission to use this command!"); - return true; - } - - @Override - public boolean execute(CommandHandler handler, CommandSender sender, String[] args) { - - if (args.length == 0) { - HitResult rayCastResult = MUtil.rayCastFromPlayer(sender); - if (rayCastResult == null || rayCastResult.hitType != HitResult.HitType.TILE) { - FeedbackHandler.error(sender, "Failed to Lock Container! (Not Looking at Container)"); - return true; - } - - TileEntity container = sender.getWorld().getBlockTileEntity(rayCastResult.x, rayCastResult.y, rayCastResult.z); - if(container != null){ - if (container instanceof TileEntityContainerInterface) { - TileEntityContainerInterface iContainer = ((TileEntityContainerInterface) container); - if (!iContainer.getIsLocked()) { - if (container instanceof TileEntityChest) { - TileEntityContainerInterface iOtherContainer = (TileEntityContainerInterface) MUtil.getOtherChest(sender.getWorld(), (TileEntityChest) container); - if (iOtherContainer != null) { - iContainer.setIsLocked(true); - iOtherContainer.setIsLocked(true); - iContainer.setLockOwner(sender.getPlayer().username); - iOtherContainer.setLockOwner(sender.getPlayer().username); - FeedbackHandler.success(sender, "Locked Double Chest!"); - return true; - } - FeedbackHandler.success(sender, "Locked Chest!"); - } else if (container instanceof TileEntityBlastFurnace) { - FeedbackHandler.success(sender, "Locked Blast Furnace!"); - } else if (container instanceof TileEntityFurnace) { - FeedbackHandler.success(sender, "Locked Furnace!"); - } else if (container instanceof TileEntityDispenser) { - FeedbackHandler.success(sender, "Locked Dispenser!"); - } else if (container instanceof TileEntityMeshGold) { - FeedbackHandler.success(sender, "Locked Golden Mesh!"); - } else if (container instanceof TileEntityTrommel) { - FeedbackHandler.success(sender, "Locked Trommel!"); - } else if (container instanceof TileEntityBasket) { - FeedbackHandler.success(sender, "Locked Basket!"); - } - - iContainer.setIsLocked(true); - iContainer.setLockOwner(sender.getPlayer().username); - return true; - - } else if (iContainer.getIsLocked() && !iContainer.getLockOwner().equals(UUIDHelper.getUUIDFromName(sender.getPlayer().username))) { - FeedbackHandler.error(sender, "Failed to Lock Container! (Not Owned By You)"); - return true; - } - FeedbackHandler.error(sender, "Failed to Lock Container! (Already Locked)"); - return true; - } - } - FeedbackHandler.error(sender, "Failed to Lock Container! (Not Looking at Container)"); - return true; - } - - switch(args[0]){ - case "onBlockPlaced": - return onBlockPlaced(handler, sender, args); - case "onBlockPunched": - return onBlockPunched(handler, sender, args); - case "trust": - return trust(handler, sender, args); - case "trustall": - return trustAll(handler, sender, args); - case "trustcommunity": - return trustCommunity(handler, sender, args); - case "untrust": - return untrust(handler, sender, args); - case "untrustall": - return untrustAll(handler, sender, args); - case "untrustcommunity": - return untrustCommunity(handler, sender, args); - case "bypass": - return bypass(handler, sender, args); - case "help": - return false; - } - - FeedbackHandler.error(sender, "Lock Command Failed (Invalid Syntax)"); - syntax.printAllLines(sender); - return true; - } - - @Override - public boolean opRequired(String[] strings) { - return false; - } - - @Override - public void sendCommandSyntax(CommandHandler handler, CommandSender sender) { - syntax.printAllLines(sender); - } -} diff --git a/src/main/java/MelonUtilities/commands/lock/UnlockCommand.java b/src/main/java/MelonUtilities/commands/lock/UnlockCommand.java deleted file mode 100644 index 7e0b864..0000000 --- a/src/main/java/MelonUtilities/commands/lock/UnlockCommand.java +++ /dev/null @@ -1,4 +0,0 @@ -package MelonUtilities.commands.lock; - -public class UnlockCommand { -} diff --git a/src/main/java/MelonUtilities/commands/misc/CompassCommand.java b/src/main/java/MelonUtilities/commands/misc/CompassCommand.java deleted file mode 100644 index 4066a5e..0000000 --- a/src/main/java/MelonUtilities/commands/misc/CompassCommand.java +++ /dev/null @@ -1,39 +0,0 @@ -package MelonUtilities.commands.misc; - -import MelonUtilities.utility.FeedbackHandler; -import net.minecraft.core.item.Item; -import net.minecraft.core.item.ItemStack; -import net.minecraft.core.net.command.Command; -import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; - -/** - * This command gives the player a compass. - ***********************************************************************************/ - -public class CompassCommand extends Command { - private final static String COMMAND = "compass"; - private final static String NAME = "Compass"; - - public CompassCommand() { - super(COMMAND); - } - - @Override - public boolean execute(CommandHandler commandHandler, CommandSender commandSender, String[] strings) { - // Give the player a compass - commandSender.getPlayer().inventory.insertItem(new ItemStack(Item.toolCompass), false); - return false; - } - - @Override - public boolean opRequired(String[] strings) { - return false; - } - - @Override - public void sendCommandSyntax(CommandHandler handler, CommandSender sender) { - // Feedback to the player that it executed - FeedbackHandler.success(sender, "Given 1x " + NAME + " to " + sender.getPlayer().username); - } -} diff --git a/src/main/java/MelonUtilities/commands/misc/WhereAmICommand.java b/src/main/java/MelonUtilities/commands/misc/WhereAmICommand.java deleted file mode 100644 index fe28666..0000000 --- a/src/main/java/MelonUtilities/commands/misc/WhereAmICommand.java +++ /dev/null @@ -1,45 +0,0 @@ -package MelonUtilities.commands.misc; - -import MelonUtilities.utility.FeedbackHandler; -import net.minecraft.core.net.command.Command; -import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; -import net.minecraft.server.entity.player.EntityPlayerMP; - -/** - * This command when run prints out information of the players current coordinates. - ***********************************************************************************/ - -public class WhereAmICommand extends Command { - public WhereAmICommand() { - super("whereami"); - } - - @Override - public boolean execute(CommandHandler commandHandler, CommandSender sender, String[] strings) { - // Get the player and cast it to EntityPlayerMP - EntityPlayerMP player = (EntityPlayerMP) sender.getPlayer(); - - // Get the players coords - // cast to int to shorten them - int px = (int) player.x; - int py = (int) player.y; - int pz = (int) player.z; - - // Send the info to the chat - FeedbackHandler.success(sender, "You are at " + px + " " + py + " " + pz); - - return false; - } - - @Override - public boolean opRequired(String[] strings) { - return false; - } - - @Override - public void sendCommandSyntax(CommandHandler commandHandler, CommandSender commandSender) { - // Feedback is unneeded, since execute is printing the message - //commandSender.sendMessage("whereami"); - } -} diff --git a/src/main/java/MelonUtilities/commands/role/RoleCommand.java b/src/main/java/MelonUtilities/commands/role/RoleCommand.java deleted file mode 100644 index 0a6518f..0000000 --- a/src/main/java/MelonUtilities/commands/role/RoleCommand.java +++ /dev/null @@ -1,490 +0,0 @@ -package MelonUtilities.commands.role; - -import MelonUtilities.commands.role.subcommands.EditRoleDisplaySubcommand; -import MelonUtilities.commands.role.subcommands.EditRoleTextSubcommand; -import MelonUtilities.commands.role.subcommands.EditRoleUsernameSubcommand; -import MelonUtilities.config.Data; -import MelonUtilities.config.datatypes.ConfigData; -import MelonUtilities.utility.FeedbackHandler; -import MelonUtilities.utility.SyntaxBuilder; -import MelonUtilities.utility.RoleBuilder; -import MelonUtilities.config.datatypes.RoleData; -import net.minecraft.core.net.command.Command; -import net.minecraft.core.net.command.CommandHandler; -import net.minecraft.core.net.command.CommandSender; -import net.minecraft.core.net.command.TextFormatting; - -@SuppressWarnings("SameReturnValue") -public class RoleCommand extends Command { - - private final static String COMMAND = "role"; - - public RoleCommand(){super(COMMAND, "r");} - - public static RoleData getRoleFromArg(String arg){return Data.roles.getOrCreate(arg, RoleData.class);} - - public static SyntaxBuilder syntax = new SyntaxBuilder(); - public static void buildRoleSyntax(){ - syntax.clear(); - syntax.append("title", TextFormatting.LIGHT_GRAY + "< Command Syntax > ([] = optional, <> = variable, / = or)"); - syntax.append("create", "title", TextFormatting.LIGHT_GRAY + " > /role create []"); - syntax.append("delete", "title", TextFormatting.LIGHT_GRAY + " > /role delete "); - syntax.append("edit", "title", TextFormatting.LIGHT_GRAY + " > /role edit "); - syntax.append("priority", "edit", TextFormatting.LIGHT_GRAY + " > priority "); -/* syntax.append("perms", "edit", TextFormatting.LIGHT_GRAY + " > perms ");*/ - syntax.append("display", "edit", TextFormatting.LIGHT_GRAY + " > display