BLEEDING EDGE 1.3_13

gradle.properties

@@ -1,5 +1,5 @@
 pluginMain=SimplexCorePlugin
 pluginMainPackage=io.github.simplexdev.simplexcore
-pluginVersion=1.3_11
+pluginVersion=1.3_13
 pluginName=SimplexCore
 pluginJarClassifier=BLEEDING

src/main/java/io/github/simplexdev/api/annotations/ReqType.java

@@ -1,7 +1,6 @@
 package io.github.simplexdev.api.annotations;
 
 public enum ReqType {
-    PAPER,
-    WATERFALL,
+    SPIGOT,
     BUNGEECORD
 }

src/main/java/io/github/simplexdev/simplexcore/SimplexCorePlugin.java

@@ -1,14 +1,18 @@
 package io.github.simplexdev.simplexcore;
 
+import io.github.simplexdev.api.annotations.ReqType;
+import io.github.simplexdev.api.annotations.Requires;
 import io.github.simplexdev.simplexcore.command.defaults.Command_info;
 import io.github.simplexdev.simplexcore.config.Yaml;
 import io.github.simplexdev.simplexcore.config.YamlFactory;
+import io.github.simplexdev.simplexcore.crafting.RecipeBuilder;
 import io.github.simplexdev.simplexcore.module.DependencyManagement;
 import io.github.simplexdev.simplexcore.task.Announcer;
 import io.github.simplexdev.simplexcore.listener.DependencyListener;
 import io.github.simplexdev.simplexcore.listener.SimplexListener;
 import io.github.simplexdev.simplexcore.module.SimplexModule;
 
+@Requires(ReqType.SPIGOT)
 public final class SimplexCorePlugin extends SimplexModule<SimplexCorePlugin> {
     private static boolean debug = false;
     private static boolean suspended = false;

src/main/java/io/github/simplexdev/simplexcore/ban/Ban.java

@@ -5,9 +5,10 @@ import io.github.simplexdev.simplexcore.SimplexCorePlugin;
 import io.github.simplexdev.simplexcore.chat.Messages;
 import io.github.simplexdev.simplexcore.config.Yaml;
 import io.github.simplexdev.simplexcore.config.YamlFactory;
+import io.github.simplexdev.simplexcore.listener.SimplexListener;
+import io.github.simplexdev.simplexcore.module.SimplexModule;
 import io.github.simplexdev.simplexcore.utils.TickedTime;
 import io.github.simplexdev.simplexcore.utils.Utilities;
-import io.github.simplexdev.simplexcore.listener.SimplexListener;
 import org.bukkit.command.CommandSender;
 import org.bukkit.configuration.ConfigurationSection;
 import org.bukkit.entity.Player;
@@ -29,23 +30,25 @@ public abstract class Ban implements IBan {
     private final BanType type;
     private final Date banDate;
     private final long banDuration;
+    private final SimplexModule<?> plugin;
 
     private final String banId;
     private final String banReason;
 
-    public Ban(Player player, CommandSender sender) {
-        this(player, sender, BanType.TEMPORARY);
+    public Ban(SimplexModule<?> plugin, Player player, CommandSender sender) {
+        this(plugin, player, sender, BanType.TEMPORARY);
     }
 
-    public Ban(Player player, CommandSender sender, BanType type) {
-        this(player, sender, type, TickedTime.DAY);
+    public Ban(SimplexModule<?> plugin, Player player, CommandSender sender, BanType type) {
+        this(plugin, player, sender, type, TickedTime.DAY);
     }
 
-    public Ban(Player player, CommandSender sender, BanType type, long banDuration) {
-        this(player, sender, type, Utilities.generateBanId(type), Messages.BAN.getMessage(), new Date(), banDuration);
+    public Ban(SimplexModule<?> plugin, Player player, CommandSender sender, BanType type, long banDuration) {
+        this(plugin, player, sender, type, Utilities.generateBanId(type), Messages.BAN.getMessage(), new Date(), banDuration);
     }
 
-    public Ban(Player player, CommandSender sender, BanType type, String banId, String banReason, Date banDate, long banDuration) {
+    public Ban(SimplexModule<?> plugin, Player player, CommandSender sender, BanType type, String banId, String banReason, Date banDate, long banDuration) {
+        this.plugin = plugin;
         this.player = player;
         this.sender = sender;
         this.type = type;

src/main/java/io/github/simplexdev/simplexcore/ban/BanFactory.java

@@ -2,23 +2,22 @@ package io.github.simplexdev.simplexcore.ban;
 
 import io.github.simplexdev.api.IBan;
 import io.github.simplexdev.api.func.VoidSupplier;
-import io.github.simplexdev.simplexcore.SimplexCorePlugin;
 import io.github.simplexdev.simplexcore.chat.Messages;
 import io.github.simplexdev.simplexcore.config.Yaml;
+import io.github.simplexdev.simplexcore.module.SimplexModule;
 import io.github.simplexdev.simplexcore.utils.TickedTime;
 import io.github.simplexdev.simplexcore.utils.Utilities;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
 import java.io.File;
-import java.util.Arrays;
 import java.util.Date;
 import java.util.UUID;
-import java.util.concurrent.atomic.AtomicReference;
 
 import static io.github.simplexdev.simplexcore.utils.Utilities.pathway;
 
 public final class BanFactory {
+    private final SimplexModule<?> plugin;
     private final Player player;
     private final CommandSender sender;
     private final Date banDate;
@@ -27,7 +26,8 @@ public final class BanFactory {
     private String banReason;
     private long banDuration;
 
-    public BanFactory(Player player, CommandSender sender, Date banDate, BanType type) {
+    public BanFactory(SimplexModule<?> plugin, Player player, CommandSender sender, Date banDate, BanType type) {
+        this.plugin = plugin;
         this.player = player;
         this.sender = sender;
         this.banDate = banDate;
@@ -72,7 +72,7 @@ public final class BanFactory {
      * @return A new ban instance.
      */
     public Ban create() {
-        return new Ban(player, sender, type, banDuration) {
+        return new Ban(plugin, player, sender, type, banDuration) {
             @Override
             public UUID getOffender() {
                 return player.getUniqueId();

src/main/java/io/github/simplexdev/simplexcore/ban/BanManager.java

@@ -0,0 +1,66 @@
+package io.github.simplexdev.simplexcore.ban;
+
+import io.github.simplexdev.simplexcore.chat.Messages;
+import io.github.simplexdev.simplexcore.listener.SimplexListener;
+import io.github.simplexdev.simplexcore.module.SimplexModule;
+import org.bukkit.Bukkit;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.bukkit.event.player.AsyncPlayerPreLoginEvent.Result;
+
+public class BanManager extends SimplexListener {
+    private final Map<Ban, BanType> banMap = new HashMap<>();
+    private final SimplexModule<?> plugin;
+
+    public BanManager(SimplexModule<?> plugin) {
+        this.plugin = plugin;
+    }
+
+    public void addBan(Ban ban) {
+        banMap.put(ban, ban.getBanType());
+    }
+
+    @Nullable
+    public Ban getBan(OfflinePlayer player) {
+        if (banMap.isEmpty()) {
+            return null;
+        }
+
+        AtomicReference<Ban> temp = new AtomicReference<>();
+        banMap.forEach((ban, type) -> {
+            if (ban.getOffender().equals(player.getUniqueId())) {
+                temp.set(ban);
+            }
+        });
+        return temp.get();
+    }
+
+    @EventHandler
+    public void banHandler(AsyncPlayerPreLoginEvent event) {
+        UUID player = event.getUniqueId();
+        OfflinePlayer op = Bukkit.getOfflinePlayer(player);
+        Ban ban = getBan(op);
+        if (ban != null) {
+            if (ban.getBanType().equals(BanType.PERMANENT)) {
+                event.disallow(Result.KICK_BANNED, Messages.PERMBAN.getMessage());
+            }
+
+            if (ban.getBanType().equals(BanType.TEMPORARY)
+                    || ban.getBanType().equals(BanType.CUSTOM)) {
+                if ((ban.getDate().getTime()
+                        + ban.getBanDuration()) > (new Date()).getTime()) {
+                    event.disallow(Result.KICK_BANNED, Messages.PERMBAN.getMessage());
+                }
+            }
+        }
+    }
+}

src/main/java/io/github/simplexdev/simplexcore/ban/BanType.java

@@ -3,7 +3,8 @@ package io.github.simplexdev.simplexcore.ban;
 public enum BanType {
     PERMANENT("P-"),
     TEMPORARY("T-"),
-    CUSTOM("C-");
+    CUSTOM("C-"),
+    UNKNOWN("");
 
     private final String prefix;
 
@@ -21,6 +22,18 @@ public enum BanType {
         }
     }
 
+    public static BanType getFromId(String banId) {
+        if (banId.startsWith("P")) {
+            return PERMANENT;
+        } else if (banId.startsWith("T")) {
+            return TEMPORARY;
+        } else if (banId.startsWith("C")){
+            return CUSTOM;
+        } else {
+            return UNKNOWN;
+        }
+    }
+
     public String getPrefix() {
         return prefix;
     }

src/main/java/io/github/simplexdev/simplexcore/chat/ChatUtils.java

@@ -20,7 +20,7 @@ public final class ChatUtils {
     }
 
     public void msg(TextComponent component) {
-        target.sendMessage(component);
+        target.spigot().sendMessage(component);
     }
 
     public void err(Messages message) {

src/main/java/io/github/simplexdev/simplexcore/chat/Messages.java

@@ -1,11 +1,14 @@
 package io.github.simplexdev.simplexcore.chat;
 
+import io.github.simplexdev.simplexcore.CoreState;
+
 public enum Messages {
     NO_PERMS("You do not have permission to use this command!"),
     DISCORD("https://discord.gg/Rumx5dTJuf"),
     BAN("You have been banned from this server."),
     KICK("You have been kicked by a moderator."),
-    AFK_KICK("You were kicked to ensure space for active players.");
+    AFK_KICK("You were kicked to ensure space for active players."),
+    PERMBAN("You are permanently banned from this server.");
 
     String message;
 

src/main/java/io/github/simplexdev/simplexcore/crafting/RecipeBuilder.java

@@ -0,0 +1,105 @@
+package io.github.simplexdev.simplexcore.crafting;
+
+import io.github.simplexdev.simplexcore.module.SimplexModule;
+import io.github.simplexdev.simplexcore.utils.Utilities;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.ShapedRecipe;
+import org.bukkit.inventory.ShapelessRecipe;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public final class RecipeBuilder {
+    private final SimplexModule<?> plugin;
+
+    public RecipeBuilder(SimplexModule<?> plugin) {
+        this.plugin = plugin;
+    }
+
+    public final Worker of(ItemStack result, String recipeName, boolean isShaped) {
+        return new Worker(result, recipeName, isShaped);
+    }
+
+    private final class Worker {
+        private final Map<Character, Material> ingredients = new HashMap<>();
+        private final ItemStack stack;
+        private final NamespacedKey key;
+        private final boolean shaped;
+        private final List<Material> materials = new ArrayList<>();
+        private String[] shape = {"", "", ""};
+
+        public Worker(ItemStack stack, String name, boolean isShaped) {
+            this.stack = stack;
+            this.key = new NamespacedKey(plugin, name);
+            this.shaped = isShaped;
+        }
+
+        private ShapelessRecipe nosha() {
+            ShapelessRecipe recipe = new ShapelessRecipe(key, stack);
+            if (materials.size() > 9 || materials.isEmpty()) return recipe;
+            materials.forEach(recipe::addIngredient);
+            materials.clear();
+            return recipe;
+        }
+
+        private ShapedRecipe sha() {
+            ShapedRecipe recipe = new ShapedRecipe(key, stack);
+            if (ingredients.isEmpty()) return recipe;
+            recipe.shape(shape);
+            ingredients.forEach(recipe::setIngredient);
+            ingredients.clear();
+            return recipe;
+        }
+
+        public void make() {
+            plugin.getServer().addRecipe(shaped ? sha() : nosha());
+        }
+
+        /**
+         * This is for shaped crafting.
+         *
+         * @param identifier The specific identifier
+         * @param ingredient The ingredient represented by the identifier.
+         * @return
+         */
+        public Worker addIngredient(@NotNull Character identifier, @NotNull Material ingredient) {
+            ingredients.put(identifier, ingredient);
+            return this;
+        }
+
+        public Worker setShape(@Nullable String top, @Nullable String middle, @Nullable String bottom) {
+            String a = "";
+            String b = "";
+            String c = "";
+            if (top != null) {
+                a = top;
+            }
+            if (middle != null) {
+                b = middle;
+            }
+            if (bottom != null) {
+                c = bottom;
+            }
+
+            shape = new String[]{a, b, c};
+            return this;
+        }
+
+        /**
+         * This is for shapeless crafting.
+         *
+         * @param ingredients any number (up to nine) of ingredients required to craft this recipe.
+         * @return An appendable instance of this class.
+         */
+        public Worker addIngredients(Material... ingredients) {
+            Utilities.forEach(ingredients, materials::add);
+            return this;
+        }
+    }
+}

src/main/java/io/github/simplexdev/simplexcore/listener/SimplexListener.java

@@ -2,6 +2,7 @@ package io.github.simplexdev.simplexcore.listener;
 
 import io.github.simplexdev.simplexcore.SimplexCorePlugin;
 import io.github.simplexdev.simplexcore.module.SimplexModule;
+import io.github.simplexdev.simplexcore.utils.ReflectionTools;
 import org.bukkit.event.Listener;
 
 import java.lang.reflect.Constructor;
@@ -20,12 +21,8 @@ public abstract class SimplexListener implements Listener {
             return;
         }
 
-        try {
-            Constructor<? extends SimplexListener> constr = cls.getDeclaredConstructor();
-            register(constr.newInstance(), plugin);
-        } catch (NoSuchMethodException | IllegalAccessException | InstantiationException | InvocationTargetException e) {
-            SimplexCorePlugin.getInstance().getLogger().severe("Could not register this listener!");
-        }
+        Constructor<? extends SimplexListener> constr = ReflectionTools.getDeclaredConstructor(cls);
+        register(ReflectionTools.initConstructor(constr), plugin);
     }
 
     /**

src/main/java/io/github/simplexdev/simplexcore/module/ModuleRegistry.java

@@ -29,6 +29,17 @@ public final class ModuleRegistry {
         }
     }
 
+    public <T extends SimplexModule<T>> boolean isSpigot(T addon) {
+        try {
+            Class.forName(org.spigotmc.WatchdogThread.class.getName());
+            return true;
+        } catch (ClassNotFoundException ignored) {
+            addon.stop();
+            SimplexCorePlugin.getInstance().getLogger().severe(addon.getName() + " has been disabled: This module requires Paper!");
+            return false;
+        }
+    }
+
     private <T extends SimplexModule<T>> boolean isBungee(T addon) {
         try {
             Class.forName(net.md_5.bungee.Util.class.getName());
@@ -40,17 +51,6 @@ public final class ModuleRegistry {
         }
     }
 
-    private <T extends SimplexModule<T>> boolean isWaterfall(T addon) {
-        try {
-            Class.forName(io.github.waterfallmc.waterfall.utils.Hex.class.getName());
-            return true;
-        } catch (ClassNotFoundException ignored) {
-            addon.stop();
-            SimplexCorePlugin.getInstance().getLogger().severe(addon.getName() + " has been disabled: This module requires Waterfall!");
-            return false;
-        }
-    }
-
     private boolean checkAnnotation(Requires info, ReqType type) {
         return info.value() == type;
     }
@@ -58,18 +58,14 @@ public final class ModuleRegistry {
     public <T extends SimplexModule<T>> void register(T addon) {
         if (addon.getClass().isAnnotationPresent(Requires.class)) {
             Requires info = addon.getClass().getDeclaredAnnotation(Requires.class);
-            if (checkAnnotation(info, ReqType.PAPER)
-                    && !isPaper(addon)) {
+            if (checkAnnotation(info, ReqType.SPIGOT)
+                    && (!isSpigot(addon) || !isPaper(addon))) {
                 return;
             }
             if (checkAnnotation(info, ReqType.BUNGEECORD)
                     && !isBungee(addon)) {
                 return;
             }
-            if (checkAnnotation(info, ReqType.WATERFALL)
-                    && !isWaterfall(addon)) {
-                return;
-            }
         }
         getModules().add(addon);
     }