FeelingLucky v1.2.0 RC01

Added some more features, this will be now the full official release; this commit is release candidate 1.

Changelog:
- Added HideCheck, which will break the tracking of any mobs targeting the player.
- Added JumpBoost, which adds a little extra height to your jumps.
- Modified OreVein as it previously scanned for all ore types rather than the relative mined ore type.

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,77 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ main ]
+  schedule:
+    - cron: '25 16 * * 4'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'java' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+        
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines. 
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      
+    - name: Codacy Coverage Reporter
+      uses: codacy/codacy-coverage-reporter-action@v1.3.0
+      
+    

README.md

@@ -0,0 +1,28 @@
+# <center>FeelingLucky Beta v1.0.2</center>
+
+## <center><u><span style="color:blue">Plugin Description:</u></center>
+
+### <center><u><span style="color:cyan">For All Users:</u></center>
+
+<b>FeelingLucky</b> is a mechanics plugin designed to expand upon the Luck attribute which Minecraft provides.
+Each user is assigned a tangible Luck stat, which can be viewed by using <b><span style="color:violet">/luck info</color></b>.
+Users can <i>increase</i> their luck stat by using a rabbit's foot, 
+or increase their luck and their luck multiplier by consuming a special rabbits foot purchased from a Butcher villager.
+<b><span style="color:red">Beware</b> though, if you take damage from guardian lasers or a witch's potion, 
+there's a chance your luck will <i>decrease</i> instead.
+
+### <center><u><span style="color:pink">For Administrators:</u></center>
+Admins can modify values in the configuration file, as well as modify individual user's luck stat.
+Admins can set, reset, add to, and take from player's luck stat.
+Admins can also reload the main configuration, as well as individual and all player configurations.
+For this, the command is <b><span style="color:violet">/luck reload -m</color></b> for the main config, 
+<b><span style="color:violet">/luck reload</color></b> to reload all player configurations, and <b><span style="color:violet">/luck reload -p <i>PLAYER_NAME</i></span></b> to reload individual player configuration files.
+
+## <center><u><span style="color:blue">Server Requirements:</u></center>
+
+In order to run <b>FeelingLucky</b> v<b>1.1.0</b>, the latest version of Paper or Spigot is required.
+
+#### <center><span style="color:red">Note: Paper is REQUIRED for this plugin to run. Spigot is not supported, and support for Spigot will not be added in the future.</center></span>
+
+### <center>Note: If you are migrating from an Alpha build, the plugin configuration folder will need to be regenerated.</center>
+

build.gradle

@@ -3,22 +3,16 @@ plugins {
 }
 
 group = 'io.github.simplex'
-version = 'Alpha-1.0'
+version = '1.2.0-RC01'
 
 repositories {
     mavenCentral()
-    maven {
-        name = 'papermc-repo'
-        url = 'https://papermc.io/repo/repository/maven-public/'
-    }
-    maven {
-        name = 'sonatype'
-        url = 'https://s01.oss.sonatype.org/content/groups/public/'
-    }
+    maven { url = uri("https://s01.oss.sonatype.org/content/groups/public/") }
+    maven { url = uri("https://papermc.io/repo/repository/maven-public/")}
 }
 
 dependencies {
-    compileOnly 'io.papermc.paper:paper-api:1.18.1-R0.1-SNAPSHOT'
+    compileOnly("io.papermc.paper:paper-api:1.19-R0.1-SNAPSHOT")
 }
 
 def targetJavaVersion = 17

src/main/java/io/github/simplex/api/LuckContainer.java

@@ -1,16 +1,11 @@
 package io.github.simplex.api;
 
-import org.bukkit.attribute.Attribute;
 import org.bukkit.entity.Player;
 
 import java.io.Serializable;
 
 public interface LuckContainer extends Serializable {
 
-    Attribute asAttribute();
-
-    double getNumber();
-
     boolean isMatch(double number);
 
     boolean isClose(double number, int range);

src/main/java/io/github/simplex/luck/Config.java

@@ -1,6 +1,5 @@
 package io.github.simplex.luck;
 
-import io.github.simplex.lib.MiniComponent;
 import io.github.simplex.luck.listener.AbstractListener;
 import io.github.simplex.luck.util.SneakyWorker;
 import org.bukkit.configuration.file.YamlConfiguration;
@@ -9,11 +8,26 @@ import java.io.File;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 
+@SuppressWarnings("ResultOfMethodCallIgnored")
 public class Config extends YamlConfiguration {
     private final FeelingLucky plugin;
+    private final List<String> configEntries = new ArrayList<>() {{
+        add("high_rarity_chance");
+        add("medium_rarity_chance");
+        add("low_rarity_chance");
+        add("block_drops");
+        add("bonemeal");
+        add("cheat_death");
+        add("enchanting");
+        add("experience");
+        add("item_drops");
+        add("random_effect");
+        add("restore_hunger");
+        add("take_damage");
+        add("unbreakable");
+    }};
     private File configFile;
 
     public Config(FeelingLucky plugin) {
@@ -33,7 +47,7 @@ public class Config extends YamlConfiguration {
         if (validateIntegrity()) {
             File newFile = new File(plugin.getDataFolder(), "config.yml");
             SneakyWorker.sneakyTry(() -> {
-                Files.delete(Path.of(plugin.getDataFolder().getPath()));
+                Files.delete(Path.of(this.configFile.getPath()));
                 newFile.createNewFile();
                 plugin.saveResource("config.yml", true);
             });
@@ -72,20 +86,4 @@ public class Config extends YamlConfiguration {
     public double getChance(String path) {
         return getDouble(path);
     }
-
-    private List<String> configEntries = new ArrayList<>() {{
-        add("high_rarity_chance");
-        add("medium_rarity_chance");
-        add("low_rarity_chance");
-        add("block_drops");
-        add("bonemeal");
-        add("cheat_death");
-        add("enchanting");
-        add("experience");
-        add("item_drops");
-        add("random_effect");
-        add("restore_hunger");
-        add("take_damage");
-        add("unbreakable");
-    }};
 }

src/main/java/io/github/simplex/luck/FeelingLucky.java

@@ -4,10 +4,14 @@ import io.github.simplex.luck.listener.*;
 import io.github.simplex.luck.player.PlayerConfig;
 import io.github.simplex.luck.player.PlayerHandler;
 import io.github.simplex.luck.util.LuckCMD;
+import io.github.simplex.luck.util.SneakyWorker;
+import io.github.simplex.luck.util.SpecialFootItem;
+import io.github.simplex.metrics.Metrics;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
@@ -15,6 +19,8 @@ import java.util.UUID;
 
 public final class FeelingLucky extends JavaPlugin {
     private final Map<UUID, PlayerConfig> configMap = new HashMap<>();
+    private final File playerDirectory = new File(getDataFolder(), "players");
+    private final SpecialFootItem specialFootItem = new SpecialFootItem();
 
     private PlayerHandler handler;
     private Config config;
@@ -25,7 +31,9 @@ public final class FeelingLucky extends JavaPlugin {
 
     @Override
     public void onEnable() {
-        getLogger().info("Initializing the PlayerHandler...");
+        getLogger().info("Initializing metrics...");
+        new Metrics(this, 15054);
+        getLogger().info("Metrics loaded. Initializing the PlayerHandler...");
         handler = new PlayerHandler(this);
         getLogger().info("Initialization complete! Attempting to register the Listeners...");
         registerListeners();
@@ -50,11 +58,18 @@ public final class FeelingLucky extends JavaPlugin {
     }
 
     private void loadPlayerConfigurations() {
-        File[] files = getDataFolder().listFiles();
+        if (!playerDirectory.exists()) {
+            getLogger().info("No directory exists. Creating...");
+            playerDirectory.mkdirs();
+            getLogger().info("Created new directory \"FeelingLucky/players\".");
+            return;
+        }
+
+        File[] files = playerDirectory.listFiles();
         if (files != null) {
             Arrays.stream(files).forEach(file -> {
                 UUID uuid = UUID.fromString(file.getName().split("\\.")[0]);
-                configMap.put(uuid, PlayerConfig.loadFrom(this, file));
+                configMap.put(uuid, PlayerConfig.initFrom(this, file));
             });
             configMap.forEach((u, pc) -> pc.load());
             getLogger().info("Successfully loaded all configurations!");
@@ -64,27 +79,31 @@ public final class FeelingLucky extends JavaPlugin {
     }
 
     private void registerListeners() {
-        new BlockDrops(this);
-        new BonemealFullCrop(this);
-        new CheatDeath(this);
-        new EnchantmentBoost(this);
-        new ExpBoost(this);
-        new IllOmen(this);
-        new ItemDrops(this);
-        new PlayerListener(this);
-        new RestoreHunger(this);
-        new TakeDamage(this);
-        new UnbreakableTool(this);
-        new VillagerInventory(this);
+        try {
+            Class<?>[] listeners = SneakyWorker.getClasses(AbstractListener.class.getPackage().getName());
+            Arrays.stream(listeners).forEach(l -> {
+                if (AbstractListener.class.isAssignableFrom(l)) {
+                    if (l.equals(AbstractListener.class)) return;
+
+                    SneakyWorker.sneakyTry(() -> l.getDeclaredConstructor(FeelingLucky.class).newInstance(this));
+                }
+            });
+        } catch (IOException | ClassNotFoundException ex) {
+            getLogger().severe(ex.getMessage());
+        }
     }
 
     public PlayerHandler getHandler() {
         return handler;
     }
-    
+
     @Override
     @NotNull
     public Config getConfig() {
         return config;
     }
+
+    public SpecialFootItem getFoot() {
+        return specialFootItem;
+    }
 }

src/main/java/io/github/simplex/luck/listener/AbstractListener.java

@@ -5,12 +5,8 @@ import io.github.simplex.luck.FeelingLucky;
 import io.github.simplex.luck.player.PlayerHandler;
 import org.bukkit.event.Listener;
 
-import java.util.HashMap;
-import java.util.Map;
-
 public abstract class AbstractListener implements Listener {
     protected final FeelingLucky plugin;
-    protected final Map<AbstractListener, Rarity> listenerRarityMap = new HashMap<>();
     protected final Config config;
 
     public AbstractListener(FeelingLucky plugin) {
@@ -23,24 +19,19 @@ public abstract class AbstractListener implements Listener {
         return plugin.getHandler();
     }
 
+    public boolean doesQualify(String name, double luck) {
+        return switch (config.getRarity(name)) {
+            case HIGH -> luck > config.getChance("high_rarity_chance");
+            case MED -> luck > config.getChance("medium_rarity_chance");
+            case LOW -> luck > config.getChance("low_rarity_chance");
+            case NONE -> true;
+        };
+    }
+
     public enum Rarity {
         HIGH,
         MED,
         LOW,
         NONE
     }
-
-    public boolean doesQualify(String name, double luck) {
-        switch (config.getRarity(name)) {
-            case HIGH:
-                if (luck < config.getChance("high_rarity_chance")) return false;
-            case MED:
-                if (luck < config.getChance("medium_rarity_chance")) return false;
-            case LOW:
-                if (luck < config.getChance("low_rarity_chance")) return false;
-            case NONE:
-                return true;
-        }
-        throw new IllegalArgumentException("The value for the listener rarity is not a recognized rarity value.");
-    }
 }

src/main/java/io/github/simplex/luck/listener/BlockDrops.java

@@ -20,8 +20,9 @@ public final class BlockDrops extends AbstractListener {
         Player player = event.getPlayer();
         Luck luck = getHandler().getLuckContainer(player);
         List<Item> items = event.getItems();
-        if (luck.quickRNG(luck.getPercentage()) && doesQualify("block_drops", luck.getPercentage())) {
-            items.forEach(SneakyWorker::move);
+        if (luck.quickRNG(luck.getValue()) && doesQualify("block_drops", luck.getValue())) {
+            event.getItems().clear();
+            event.getItems().addAll(items.stream().map(SneakyWorker::move).toList());
         }
     }
 }

src/main/java/io/github/simplex/luck/listener/BonemealFullCrop.java

@@ -37,8 +37,8 @@ public final class BonemealFullCrop extends AbstractListener {
         if (action.isRightClick()
                 && handItem.isSimilar(bonemeal)
                 && (data instanceof Ageable crop)
-                && luck.quickRNG(luck.getPercentage())
-                && doesQualify("bonemeal", luck.getPercentage())) {
+                && luck.quickRNG(luck.getValue())
+                && doesQualify("bonemeal", luck.getValue())) {
             crop.setAge(crop.getMaximumAge());
             data.merge(crop);
             block.setBlockData(data);

src/main/java/io/github/simplex/luck/listener/CheatDeath.java

@@ -17,7 +17,7 @@ public final class CheatDeath extends AbstractListener {
         Player player = event.getPlayer();
         Luck luck = getHandler().getLuckContainer(player);
         double absorption = Math.round(Luck.RNG().nextDouble(5.0, 10.0));
-        if (luck.quickRNG(luck.getPercentage()) && doesQualify("cheat_death", luck.getPercentage())) {
+        if (luck.quickRNG(luck.getValue()) && doesQualify("cheat_death", luck.getValue())) {
             event.setCancelled(true);
             player.setHealth(1.0);
             player.setAbsorptionAmount(absorption);

src/main/java/io/github/simplex/luck/listener/EnchantmentBoost.java

@@ -21,7 +21,7 @@ public final class EnchantmentBoost extends AbstractListener {
         List<Enchantment> enchList = enchMap.keySet().stream().toList();
         Player player = event.getEnchanter();
         Luck luck = getHandler().getLuckContainer(player);
-        if (luck.quickRNG(luck.getPercentage()) && doesQualify("enchanting", luck.getPercentage())) {
+        if (luck.quickRNG(luck.getValue()) && doesQualify("enchanting", luck.getValue())) {
             Enchantment particular = enchList.get(Luck.RNG().nextInt(enchList.size()));
             int rng = Luck.RNG().nextInt(1, 5);
 

src/main/java/io/github/simplex/luck/listener/ExpBoost.java

@@ -20,7 +20,7 @@ public final class ExpBoost extends AbstractListener {
         int rounded = Math.round(math);
         Player player = event.getPlayer();
         Luck luck = plugin.getHandler().getLuckContainer(player);
-        if (luck.quickRNG(luck.getPercentage()) && doesQualify("experience", luck.getPercentage())) {
+        if (luck.quickRNG(luck.getValue()) && doesQualify("experience", luck.getValue())) {
             orb.setExperience(rounded);
         }
     }

src/main/java/io/github/simplex/luck/listener/GiveDamage.java

@@ -0,0 +1,28 @@
+package io.github.simplex.luck.listener;
+
+import io.github.simplex.lib.MiniComponent;
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.player.Luck;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+
+public class GiveDamage extends AbstractListener {
+    public GiveDamage(FeelingLucky plugin) {
+        super(plugin);
+    }
+
+    @EventHandler
+    public void playerAttack(EntityDamageByEntityEvent e) {
+        if ((e.getDamager() instanceof Player player)
+                && (e.getEntity() instanceof LivingEntity)) {
+            double nextDmg = e.getDamage() + Luck.RNG().nextDouble(1.0, 5.0);
+            Luck luck = plugin.getHandler().getLuckContainer(player);
+            if (luck.quickRNG(luck.getValue())) {
+                e.setDamage(nextDmg);
+                player.sendMessage(MiniComponent.info("Your luck has increased your damage output!"));
+            }
+        }
+    }
+}

src/main/java/io/github/simplex/luck/listener/HideCheck.java

@@ -0,0 +1,59 @@
+package io.github.simplex.luck.listener;
+
+import io.github.simplex.lib.MiniComponent;
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.player.Luck;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.entity.EntityTargetLivingEntityEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerToggleSneakEvent;
+
+import java.util.*;
+
+public class HideCheck extends AbstractListener {
+    public Map<Player, List<Entity>> entityMapList = new HashMap<>();
+
+    public HideCheck(FeelingLucky plugin) {
+        super(plugin);
+    }
+
+    @EventHandler
+    public void initPlayerMaps(PlayerJoinEvent event) {
+        entityMapList.put(event.getPlayer(), List.of());
+    }
+
+    @EventHandler
+    public void checkTargeting(EntityTargetLivingEntityEvent event) {
+        if (event.getTarget() instanceof Player player) {
+            if (event.getEntity() instanceof LivingEntity entity) {
+                List<Entity> buffer = entityMapList.get(player).isEmpty() ?
+                        new ArrayList<>() : entityMapList.get(player);
+                buffer.add(entity);
+                entityMapList.replace(player, buffer);
+            }
+        }
+    }
+
+    @EventHandler
+    public void checkForSneak(PlayerToggleSneakEvent event) {
+        Player player = event.getPlayer();
+        if (!player.isSneaking()) return;
+
+        Luck luck = plugin.getHandler().getLuckContainer(player);
+        if (luck.quickRNG(luck.getValue()) && !luck.isMarked(player)) {
+            entityMapList.get(player).forEach(e -> {
+                e.getTrackedPlayers().remove(player);
+            });
+            player.sendMessage(MiniComponent.info("Your luck has hidden you from sight."));
+        }
+    }
+
+    @EventHandler
+    public void removePlayerOnLeave(PlayerQuitEvent event) {
+        entityMapList.remove(event.getPlayer());
+    }
+}

src/main/java/io/github/simplex/luck/listener/ItemDrops.java

@@ -2,10 +2,10 @@ package io.github.simplex.luck.listener;
 
 import io.github.simplex.luck.FeelingLucky;
 import io.github.simplex.luck.player.Luck;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.entity.*;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Item;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDeathEvent;
@@ -64,7 +64,7 @@ public class ItemDrops extends AbstractListener {
         Item item = event.getItemDrop();
         ItemStack stack = item.getItemStack();
         int amount = stack.getAmount();
-        if (luck.quickRNG(luck.getPercentage()) && doesQualify("item_drops", luck.getPercentage())) {
+        if (luck.quickRNG(luck.getValue()) && doesQualify("item_drops", luck.getValue())) {
             int rng = Luck.RNG().nextInt(2, 5);
             amount += rng;
             stack.setAmount(amount);

src/main/java/io/github/simplex/luck/listener/JumpBoost.java

@@ -0,0 +1,26 @@
+package io.github.simplex.luck.listener;
+
+import com.destroystokyo.paper.event.player.PlayerJumpEvent;
+import io.github.simplex.lib.MiniComponent;
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.player.Luck;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.util.Vector;
+
+public class JumpBoost extends AbstractListener {
+    public JumpBoost(FeelingLucky plugin) {
+        super(plugin);
+    }
+
+    @EventHandler
+    public void detectJumping(PlayerJumpEvent event) {
+        Player player = event.getPlayer(); // Player is never null; they're in game and jumping.
+        Luck luck = plugin.getHandler().getLuckContainer(player);
+
+        if (luck.quickRNG(luck.getValue()) && !luck.isMarked(player)) {
+            player.setVelocity(new Vector(0, 2, 0));
+            player.sendMessage(MiniComponent.info("Your luck has boosted your jump height!"));
+        }
+    }
+}

src/main/java/io/github/simplex/luck/listener/OreVein.java

@@ -0,0 +1,51 @@
+package io.github.simplex.luck.listener;
+
+import io.github.simplex.lib.MiniComponent;
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.player.Luck;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.Tag;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.BlockBreakEvent;
+
+import java.util.stream.Stream;
+
+public class OreVein extends AbstractListener {
+
+    public OreVein(FeelingLucky plugin) {
+        super(plugin);
+    }
+
+    @EventHandler
+    public void playerMine(BlockBreakEvent event) {
+        Player player = event.getPlayer();
+        Luck luck = plugin.getHandler().getLuckContainer(player);
+        if (luck.quickRNG(luck.getValue()) && event.getBlock().isValidTool(player.getInventory().getItemInMainHand())) {
+            getOresInArea(event.getBlock()).forEach(Block::breakNaturally);
+            player.sendMessage(MiniComponent.info("Your luck has let you mine all the blocks with one swing."));
+        }
+    }
+
+    public Stream<Block> getOresInArea(Block block) {
+        Stream.Builder<Block> streamBuilder = Stream.builder();
+        Location start = block.getLocation();
+        World world = block.getWorld();
+        Stream<Tag<Material>> materialStream = Stream.of(Tag.COAL_ORES, Tag.COPPER_ORES, Tag.DIAMOND_ORES, Tag.GOLD_ORES, Tag.IRON_ORES, Tag.EMERALD_ORES, Tag.LAPIS_ORES, Tag.REDSTONE_ORES);
+        for (int x = start.getBlockX() - 15; x <= start.getBlockX() + 15; x++) {
+            for (int y = start.getBlockY() - 15; y <= start.getBlockY() + 15; y++) {
+                for (int z = start.getBlockZ() - 15; z <= start.getBlockZ() + 15; z++) {
+                    Location location = new Location(world, x, y, z);
+                    Material blockType = location.getBlock().getType();
+                    if (materialStream.anyMatch(o -> o.isTagged(blockType))) {
+                        streamBuilder.add(location.getBlock());
+                    }
+                }
+            }
+        }
+        return streamBuilder.build().filter(b -> b.getType().equals(block.getType()));
+    }
+}

src/main/java/io/github/simplex/luck/listener/PlayerListener.java

@@ -5,15 +5,12 @@ import io.github.simplex.luck.FeelingLucky;
 import io.github.simplex.luck.player.Luck;
 import io.github.simplex.luck.util.CooldownTimer;
 import io.github.simplex.luck.util.SpecialFootItem;
-import net.kyori.adventure.text.Component;
-import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Guardian;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Witch;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityDamageEvent;
@@ -34,7 +31,7 @@ public final class PlayerListener extends AbstractListener {
     public void rabbitFoot(PlayerInteractEvent event) {
         Action action = event.getAction();
         ItemStack foot = new ItemStack(Material.RABBIT_FOOT);
-        SpecialFootItem special = new SpecialFootItem();
+        SpecialFootItem special = plugin.getFoot();
         Player player = event.getPlayer();
         Luck luck = getHandler().getLuckContainer(player);
 
@@ -44,10 +41,10 @@ public final class PlayerListener extends AbstractListener {
             return;
         }
 
-        if (action.isRightClick() && player.getInventory().getItemInMainHand().isSimilar(foot)) {
+        if (action.isRightClick() && player.getInventory().getItemInMainHand().getType().equals(foot.getType())) {
             if (foot.getItemMeta().equals(special.meta()) || foot.equals(special.get())) {
-                luck.setMultiplier(luck.multiplier() + 1);
-                player.sendMessage(MiniComponent.info("Your luck multiplier has increased by 1!"));
+                luck.setMultiplier(luck.multiplier() + 0.1);
+                player.sendMessage(MiniComponent.info("Your luck multiplier has increased by 0.1!"));
             }
             double rng = Luck.RNG().nextDouble(2.0, 5.0);
             player.getInventory().remove(player.getInventory().getItemInMainHand());
@@ -81,24 +78,4 @@ public final class PlayerListener extends AbstractListener {
             }
         }
     }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == this) return true;
-        if (obj == null || obj.getClass() != this.getClass()) return false;
-        var that = (PlayerListener) obj;
-        return Objects.equals(this.plugin, that.plugin);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(plugin);
-    }
-
-    @Override
-    public String toString() {
-        return "PlayerListener[" +
-                "plugin=" + plugin + ']';
-    }
-
 }

src/main/java/io/github/simplex/luck/listener/RandomEffect.java

@@ -0,0 +1,49 @@
+package io.github.simplex.luck.listener;
+
+import io.github.simplex.lib.MiniComponent;
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.player.Luck;
+import io.github.simplex.luck.util.ListBox;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.potion.PotionEffect;
+
+import java.util.List;
+
+public class RandomEffect extends AbstractListener {
+    public RandomEffect(FeelingLucky plugin) {
+        super(plugin);
+    }
+
+    @EventHandler
+    public void giveRandomEffect(PlayerRespawnEvent respawn) {
+        Player player = respawn.getPlayer();
+        Luck luck = plugin.getHandler().getLuckContainer(player);
+
+        List<PotionEffect> effectList = ListBox.positiveEffects.stream().map(m -> m.createEffect(120, 5)).toList();
+        int size = effectList.size();
+        PotionEffect random = effectList.get(Luck.RNG().nextInt(size - 1));
+
+        if (luck.quickRNG(luck.getValue()) && doesQualify("random_effect", luck.getValue())) {
+            player.addPotionEffect(random);
+            player.sendMessage(MiniComponent.info("Thanks to luck, a random positive potion effect has been applied to you."));
+        }
+    }
+
+    @EventHandler
+    public void giveRandomEffect(PlayerTeleportEvent tp) {
+        Player player = tp.getPlayer();
+        Luck luck = plugin.getHandler().getLuckContainer(player);
+
+        List<PotionEffect> effectList = ListBox.positiveEffects.stream().map(m -> m.createEffect(120, 5)).toList();
+        int size = effectList.size();
+        PotionEffect random = effectList.get(Luck.RNG().nextInt(size - 1));
+
+        if (luck.quickRNG(luck.getValue()) && doesQualify("random_effect", luck.getValue())) {
+            player.addPotionEffect(random);
+            player.sendMessage(MiniComponent.info("Thanks to luck, a random positive potion effect has been applied to you."));
+        }
+    }
+}

src/main/java/io/github/simplex/luck/listener/RestoreHunger.java

@@ -21,7 +21,7 @@ public class RestoreHunger extends AbstractListener {
         Luck luck = getHandler().getLuckContainer(event.getPlayer());
         PotionEffect effect = PotionEffectBuilder.newEffect().type(PotionEffectType.SATURATION).amplifier(2).duration(10).particles(false).create();
         if (luck.notDefault()) {
-            double percentage = luck.getPercentage();
+            double percentage = luck.getValue();
             ListBox.foods.forEach(food -> {
                 if (item.isSimilar(food)) {
                     if (luck.quickRNG(percentage) && doesQualify("restore_hunger", percentage)) {

src/main/java/io/github/simplex/luck/listener/TakeDamage.java

@@ -25,7 +25,7 @@ public class TakeDamage extends AbstractListener {
         Luck luck = getHandler().getLuckContainer(player);
         if (ListBox.acceptedCauses.contains(event.getCause())) {
             if (luck.notDefault()) {
-                double percentage = luck.getPercentage();
+                double percentage = luck.getValue();
 
                 /*
                  * If a player's luck stat is a negative number, or they are "marked",
@@ -51,7 +51,7 @@ public class TakeDamage extends AbstractListener {
 
         if (ListBox.sideCauses.contains(event.getCause())) {
             if (luck.notDefault()) {
-                double percentage = luck.getPercentage();
+                double percentage = luck.getValue();
 
                 /*
                  * If a player's luck stat is a negative number, or they are "marked",

src/main/java/io/github/simplex/luck/listener/UnbreakableTool.java

@@ -27,7 +27,7 @@ public class UnbreakableTool extends AbstractListener {
         if (ItemBuilder.isTool(stack.getType())) {
             if (event.getWhoClicked() instanceof Player player) {
                 Luck luck = getHandler().getLuckContainer(player);
-                if (luck.quickRNG(luck.getPercentage()) && doesQualify("unbreakable", luck.getPercentage())) {
+                if (luck.quickRNG(luck.getValue()) && doesQualify("unbreakable", luck.getValue())) {
                     meta.setUnbreakable(true);
                     stack.setItemMeta(meta);
                     inventory.setResult(stack);

src/main/java/io/github/simplex/luck/listener/VillagerInventory.java

@@ -7,7 +7,6 @@ import io.github.simplex.luck.util.SpecialFootItem;
 import org.bukkit.Material;
 import org.bukkit.entity.Villager;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerInteractAtEntityEvent;
 import org.bukkit.inventory.MerchantRecipe;
 
@@ -16,12 +15,14 @@ import java.util.Arrays;
 import java.util.List;
 
 public class VillagerInventory extends AbstractListener {
-    private final SpecialFootItem foot = new SpecialFootItem();
-    private final MerchantRecipe recipe = new MerchantRecipe(foot.get(), 0, 2, true);
+    private final MerchantRecipe recipe;
 
     public VillagerInventory(FeelingLucky plugin) {
         super(plugin);
 
+        SpecialFootItem foot = plugin.getFoot();
+        this.recipe = new MerchantRecipe(foot.get(), 0, 2, true);
+
         recipe.setIngredients(Arrays.asList(
                 ItemBuilder.of(Material.EMERALD).build(),
                 ItemBuilder.of(Material.RABBIT_HIDE).build()
@@ -43,7 +44,7 @@ public class VillagerInventory extends AbstractListener {
             Luck luck = plugin.getHandler().getLuckContainer(event.getPlayer());
             if (luck == null) return;
 
-            if (luck.quickRNG(luck.getPercentage())) {
+            if (luck.quickRNG(luck.getValue())) {
                 recipeList.add(recipe);
                 vil.setRecipes(recipeList);
             }

src/main/java/io/github/simplex/luck/player/Luck.java

@@ -3,7 +3,6 @@ package io.github.simplex.luck.player;
 import io.github.simplex.api.LuckContainer;
 import io.github.simplex.luck.FeelingLucky;
 import org.bukkit.Bukkit;
-import org.bukkit.attribute.Attribute;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
@@ -41,9 +40,9 @@ public class Luck implements LuckContainer {
         return new SplittableRandom();
     }
 
-    public static boolean quickRNGnoMultiplier(double percentage) {
+    public static boolean quickRNGnoMultiplier(double value) {
         double rng;
-        if (percentage >= 100.0) {
+        if (value >= 1024.0) {
             rng = 1024.0; // 100% chance to trigger, obviously;
         } else {
             rng = RNG().nextDouble(0.0, 1024.0);
@@ -51,7 +50,7 @@ public class Luck implements LuckContainer {
 
         double actual = Math.round((rng / 1024.0) * 100);
 
-        return (percentage >= actual);
+        return (value >= actual);
     }
 
     public FeelingLucky getPlugin() {
@@ -70,24 +69,14 @@ public class Luck implements LuckContainer {
         return markedPlayers.contains(player);
     }
 
-    @Override
-    public Attribute asAttribute() {
-        return Attribute.GENERIC_LUCK;
-    }
-
-    @Override
-    public double getNumber() {
-        return associatedPlayer().getAttribute(asAttribute()).getValue();
-    }
-
     @Override
     public boolean isMatch(double number) {
-        return getNumber() == number;
+        return getValue() == number;
     }
 
     @Override
     public boolean isClose(double number, int range) {
-        return ((getNumber() - range <= number) && (number <= getNumber() + range));
+        return ((getValue() - range <= number) && (number <= getValue() + range));
     }
 
     @Override
@@ -100,9 +89,9 @@ public class Luck implements LuckContainer {
         return player;
     }
 
-    public boolean quickRNG(double percentage) {
+    public boolean quickRNG(double value) {
         double rng;
-        if (percentage >= 100.0) {
+        if (value >= 1024.0) {
             rng = 1024.0; // 100% chance to trigger, obviously;
         } else {
             rng = RNG().nextDouble(0.0, 1024.0);
@@ -111,10 +100,10 @@ public class Luck implements LuckContainer {
         double actual = Math.round((rng / 1024) * 100);
 
         if (multiplier() > 1.0) {
-            return ((percentage * multiplier()) >= actual);
+            return ((value * multiplier()) >= actual);
         }
 
-        return (percentage >= actual);
+        return (value >= actual);
     }
 
     public void reset() {
@@ -128,7 +117,6 @@ public class Luck implements LuckContainer {
 
     public void setValue(double value) {
         BASE_VALUE = value;
-        player.getAttribute(Attribute.GENERIC_LUCK).setBaseValue(value);
         plugin.getConfigMap().get(associatedPlayer().getUniqueId()).setLuck(value);
         Bukkit.getPluginManager().callEvent(event);
     }
@@ -162,7 +150,7 @@ public class Luck implements LuckContainer {
     }
 
     public double getDefaultValue() {
-        return player.getAttribute(Attribute.GENERIC_LUCK).getDefaultValue();
+        return 0;
     }
 
     public void addTo(double value) {
@@ -181,10 +169,6 @@ public class Luck implements LuckContainer {
         setValue(getValue() + value);
     }
 
-    public double getPercentage() {
-        return getValue() - getDefaultValue();
-    }
-
     public boolean notDefault() {
         return getValue() != getDefaultValue();
     }

src/main/java/io/github/simplex/luck/player/PlayerConfig.java

@@ -29,7 +29,7 @@ public class PlayerConfig {
         File file = new File(dataFolder, player.getUniqueId() + ".yml");
         if (!file.exists()) {
             String name = "username: " + player.getName();
-            String luck = "luck: " + player.getAttribute(Attribute.GENERIC_LUCK).getDefaultValue();
+            String luck = "luck: " + 0;
             String multiplier = "multiplier: " + 1.0;
 
             SneakyWorker.sneakyTry(() -> {
@@ -64,7 +64,7 @@ public class PlayerConfig {
     }
 
     @Contract("_, _ -> new")
-    public static PlayerConfig loadFrom(FeelingLucky plugin, File file) {
+    public static PlayerConfig initFrom(FeelingLucky plugin, File file) {
         return new PlayerConfig(plugin, file);
     }
 

src/main/java/io/github/simplex/luck/util/CooldownTimer.java

@@ -1,7 +1,5 @@
 package io.github.simplex.luck.util;
 
-import io.github.simplex.lib.MiniComponent;
-import net.kyori.adventure.text.Component;
 import org.bukkit.entity.Player;
 
 import java.util.HashMap;
@@ -10,9 +8,8 @@ import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
 public class CooldownTimer {
-    private final Map<UUID, Long> cooldowns = new HashMap<>();
-
     public static final long DEFAULT_COOLDOWN = 30L;
+    private final Map<UUID, Long> cooldowns = new HashMap<>();
 
     public void setCooldown(UUID playerUUID, long time) {
         if (time < 1) {

src/main/java/io/github/simplex/luck/util/ListBox.java

@@ -6,6 +6,7 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.potion.PotionEffectType;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 public class ListBox {
@@ -36,6 +37,25 @@ public class ListBox {
         add(PotionEffectType.WEAKNESS);
     }};
 
+    public static final List<PotionEffectType> positiveEffects = new ArrayList<>() {{
+        add(PotionEffectType.DAMAGE_RESISTANCE);
+        add(PotionEffectType.DOLPHINS_GRACE);
+        add(PotionEffectType.INCREASE_DAMAGE);
+        add(PotionEffectType.ABSORPTION);
+        add(PotionEffectType.SATURATION);
+        add(PotionEffectType.FIRE_RESISTANCE);
+        add(PotionEffectType.WATER_BREATHING);
+        add(PotionEffectType.SPEED);
+        add(PotionEffectType.SLOW_FALLING);
+        add(PotionEffectType.REGENERATION);
+        add(PotionEffectType.NIGHT_VISION);
+        add(PotionEffectType.LUCK);
+        add(PotionEffectType.JUMP);
+        add(PotionEffectType.INVISIBILITY);
+        add(PotionEffectType.HEALTH_BOOST);
+        add(PotionEffectType.FAST_DIGGING);
+    }};
+
     public static final List<ItemStack> foods = new ArrayList<>() {{
         add(new ItemStack(Material.COOKED_BEEF));
         add(new ItemStack(Material.COOKED_CHICKEN));

src/main/java/io/github/simplex/luck/util/LuckCMD.java

@@ -6,10 +6,7 @@ import io.github.simplex.luck.FeelingLucky;
 import io.github.simplex.luck.player.Luck;
 import io.github.simplex.luck.player.PlayerConfig;
 import org.bukkit.Bukkit;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.ConsoleCommandSender;
-import org.bukkit.command.TabCompleter;
+import org.bukkit.command.*;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -18,14 +15,14 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 
-public class LuckCMD extends Command implements TabCompleter {
+public class LuckCMD extends Command implements TabCompleter, PluginIdentifiableCommand {
     private final FeelingLucky plugin;
 
     public LuckCMD(FeelingLucky plugin) {
         super("luck", "FeelingLucky main command.", "/<command> <info | set | reset | give | take> [player] [amount]", List.of());
         this.plugin = plugin;
         setPermission("luck.default");
-        plugin.getServer().getCommandMap().register("luck", "FeelingLucky", this);
+        register(plugin.getServer().getCommandMap());
     }
 
     @Override
@@ -95,7 +92,9 @@ public class LuckCMD extends Command implements TabCompleter {
         if (args.length == 2) {
             if ((sender instanceof ConsoleCommandSender) || sender.hasPermission("luck.admin")) {
                 if (args[0].equalsIgnoreCase("reload") && args[1].equalsIgnoreCase("-m")) {
-
+                    plugin.getConfig().reload();
+                    sender.sendMessage(MiniComponent.info("Configuration successfully reloaded."));
+                    return true;
                 }
 
                 if (args[0].equalsIgnoreCase("info")) {
@@ -143,7 +142,7 @@ public class LuckCMD extends Command implements TabCompleter {
             if ((sender instanceof Player player) && player.hasPermission("luck.default")) {
                 if (args[0].equalsIgnoreCase("info")) {
                     Luck luck = plugin.getHandler().getLuckContainer(player);
-                    player.sendMessage(MiniComponent.info("Your Luck: " + luck.getPercentage()));
+                    player.sendMessage(MiniComponent.info("Your Luck: " + luck.getValue()));
                     return true;
                 }
             } else if (sender instanceof ConsoleCommandSender) {
@@ -160,33 +159,47 @@ public class LuckCMD extends Command implements TabCompleter {
         List<String> completions = new ArrayList<>() {{
             add("info");
         }};
-        List<String> playerNames = new ArrayList<>() {{
-            Bukkit.getOnlinePlayers().forEach(p -> add(p.getName()));
-        }};
-        List<String> adminCommands = List.of("set", "reset", "give", "take");
+        List<String> playerNames = Bukkit.getOnlinePlayers().stream().map(Player::getName).toList();
+        List<String> adminCommands = List.of("set", "reset", "give", "take", "reload");
 
         if ((sender instanceof ConsoleCommandSender) || sender.hasPermission("luck.admin")) {
             completions.addAll(adminCommands);
-            return completions;
+            return completions.stream().filter(n -> n.startsWith(args[0])).toList();
         }
 
-        if (args[0].equalsIgnoreCase("info") && sender.hasPermission("luck.admin")) {
-            return playerNames;
-        }
+        if (adminCommands.contains(args[0])
+                && sender.hasPermission("luck.admin")) {
+            if (args.length == 2) {
+                switch (args[0]) {
+                    case "info":
+                    case "reset":
+                        return playerNames.stream().filter(n -> n.startsWith(args[1])).toList();
+                    case "reload":
+                        return List.of("-m", "-p");
+                }
+            }
 
-        if (completions.contains(args[1]) && sender.hasPermission("luck.admin")) {
-            switch (args[0]) {
-                case "info":
-                case "reset":
-                case "reload":
-                    return new ArrayList<>();
-                case "give":
-                case "take":
-                case "set":
-                    return List.of("amount");
+            if (args.length == 3 && playerNames.contains(args[1])) {
+                switch (args[0]) {
+                    case "give":
+                    case "take":
+                    case "set":
+                        return List.of("amount");
+                }
             }
         }
 
-        return completions;
+        if (args[0].equalsIgnoreCase("reload")
+                && args[1].equalsIgnoreCase("-p")
+                && sender.hasPermission("luck.admin") && (args.length == 3)) {
+            return playerNames.stream().filter(n -> n.startsWith(args[2])).toList();
+        }
+
+        return completions.stream().filter(n -> n.startsWith(args[0])).toList();
+    }
+
+    @Override
+    public @NotNull FeelingLucky getPlugin() {
+        return plugin;
     }
 }

src/main/java/io/github/simplex/luck/util/SneakyWorker.java

@@ -5,6 +5,13 @@ import org.bukkit.Bukkit;
 import org.bukkit.entity.Item;
 import org.bukkit.inventory.ItemStack;
 
+import java.io.File;
+import java.io.IOException;
+import java.net.URL;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.List;
+
 public class SneakyWorker {
     public static void sneakyTry(SneakyTry sneakyTry) {
         try {
@@ -25,11 +32,48 @@ public class SneakyWorker {
         }
     }
 
-    public static void move(Item item) {
+    public static Class<?>[] getClasses(String packageName) throws ClassNotFoundException, IOException {
+        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
+        assert classLoader != null;
+        String path = packageName.replace(".", "/");
+        Enumeration<URL> resources = classLoader.getResources(path);
+        List<File> dirs = new ArrayList<>();
+        while (resources.hasMoreElements()) {
+            URL resource = resources.nextElement();
+            dirs.add(new File(resource.getFile()));
+        }
+        ArrayList<Class<?>> classes = new ArrayList<>();
+        for (File directory : dirs) {
+            classes.addAll(findClasses(directory, packageName));
+        }
+        return classes.toArray(new Class<?>[0]);
+    }
+
+    private static List<Class<?>> findClasses(File directory, String packageName) throws ClassNotFoundException {
+        List<Class<?>> classes = new ArrayList<>();
+        if (!directory.exists()) {
+            return classes;
+        }
+
+        File[] files = directory.listFiles();
+        assert files != null;
+        for (File file : files) {
+            if (file.isDirectory()) {
+                assert !file.getName().contains(".");
+                classes.addAll(findClasses(file, packageName + "." + file.getName().substring(0, file.getName().length() - 6)));
+            } else if (file.getName().endsWith(".class")) {
+                classes.add(Class.forName(packageName + "." + file.getName().substring(0, file.getName().length() - 6)));
+            }
+        }
+        return classes;
+    }
+
+    public static Item move(Item item) {
         ItemStack stack = item.getItemStack();
         int rng = (Luck.RNG().nextInt(2, 5)) + stack.getAmount();
         stack.setAmount(rng);
         item.setItemStack(stack);
+        return item;
     }
 
     public interface SneakyTry {

src/main/java/io/github/simplex/luck/util/SpecialFootItem.java

@@ -12,7 +12,7 @@ public class SpecialFootItem {
         stack = ItemBuilder.of(Material.RABBIT_FOOT)
                 .setName("Enhanced Rabbit Foot")
                 .setAmount(1).setLore("A strange energy radiates from within.",
-                        "This item will increase your luck multiplier by one.")
+                        "This item will increase your luck multiplier by 0.1.")
                 .build();
     }
 

src/main/java/io/github/simplex/metrics/Metrics.java

@@ -0,0 +1,863 @@
+/*
+ * This Metrics class was auto-generated and can be copied into your project if you are
+ * not using a build tool like Gradle or Maven for dependency management.
+ *
+ * IMPORTANT: You are not allowed to modify this class, except changing the package.
+ *
+ * Unallowed modifications include but are not limited to:
+ *  - Remove the option for users to opt-out
+ *  - Change the frequency for data submission
+ *  - Obfuscate the code (every obfucator should allow you to make an exception for specific files)
+ *  - Reformat the code (if you use a linter, add an exception)
+ *
+ * Violations will result in a ban of your plugin and account from bStats.
+ */
+package io.github.simplex.metrics;
+
+import java.io.BufferedReader;
+import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+import java.util.zip.GZIPOutputStream;
+import javax.net.ssl.HttpsURLConnection;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public class Metrics {
+
+    private final Plugin plugin;
+
+    private final MetricsBase metricsBase;
+
+    /**
+     * Creates a new Metrics instance.
+     *
+     * @param plugin Your plugin instance.
+     * @param serviceId The id of the service. It can be found at <a
+     *     href="https://bstats.org/what-is-my-plugin-id">What is my plugin id?</a>
+     */
+    public Metrics(JavaPlugin plugin, int serviceId) {
+        this.plugin = plugin;
+        // Get the config file
+        File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
+        File configFile = new File(bStatsFolder, "config.yml");
+        YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile);
+        if (!config.isSet("serverUuid")) {
+            config.addDefault("enabled", true);
+            config.addDefault("serverUuid", UUID.randomUUID().toString());
+            config.addDefault("logFailedRequests", false);
+            config.addDefault("logSentData", false);
+            config.addDefault("logResponseStatusText", false);
+            // Inform the server owners about bStats
+            config
+                    .options()
+                    .header(
+                            "bStats (https://bStats.org) collects some basic information for plugin authors, like how\n"
+                                    + "many people use their plugin and their total player count. It's recommended to keep bStats\n"
+                                    + "enabled, but if you're not comfortable with this, you can turn this setting off. There is no\n"
+                                    + "performance penalty associated with having metrics enabled, and data sent to bStats is fully\n"
+                                    + "anonymous.")
+                    .copyDefaults(true);
+            try {
+                config.save(configFile);
+            } catch (IOException ignored) {
+            }
+        }
+        // Load the data
+        boolean enabled = config.getBoolean("enabled", true);
+        String serverUUID = config.getString("serverUuid");
+        boolean logErrors = config.getBoolean("logFailedRequests", false);
+        boolean logSentData = config.getBoolean("logSentData", false);
+        boolean logResponseStatusText = config.getBoolean("logResponseStatusText", false);
+        metricsBase =
+                new MetricsBase(
+                        "bukkit",
+                        serverUUID,
+                        serviceId,
+                        enabled,
+                        this::appendPlatformData,
+                        this::appendServiceData,
+                        submitDataTask -> Bukkit.getScheduler().runTask(plugin, submitDataTask),
+                        plugin::isEnabled,
+                        (message, error) -> this.plugin.getLogger().log(Level.WARNING, message, error),
+                        (message) -> this.plugin.getLogger().log(Level.INFO, message),
+                        logErrors,
+                        logSentData,
+                        logResponseStatusText);
+    }
+
+    /**
+     * Adds a custom chart.
+     *
+     * @param chart The chart to add.
+     */
+    public void addCustomChart(CustomChart chart) {
+        metricsBase.addCustomChart(chart);
+    }
+
+    private void appendPlatformData(JsonObjectBuilder builder) {
+        builder.appendField("playerAmount", getPlayerAmount());
+        builder.appendField("onlineMode", Bukkit.getOnlineMode() ? 1 : 0);
+        builder.appendField("bukkitVersion", Bukkit.getVersion());
+        builder.appendField("bukkitName", Bukkit.getName());
+        builder.appendField("javaVersion", System.getProperty("java.version"));
+        builder.appendField("osName", System.getProperty("os.name"));
+        builder.appendField("osArch", System.getProperty("os.arch"));
+        builder.appendField("osVersion", System.getProperty("os.version"));
+        builder.appendField("coreCount", Runtime.getRuntime().availableProcessors());
+    }
+
+    private void appendServiceData(JsonObjectBuilder builder) {
+        builder.appendField("pluginVersion", plugin.getDescription().getVersion());
+    }
+
+    private int getPlayerAmount() {
+        try {
+            // Around MC 1.8 the return type was changed from an array to a collection,
+            // This fixes java.lang.NoSuchMethodError:
+            // org.bukkit.Bukkit.getOnlinePlayers()Ljava/util/Collection;
+            Method onlinePlayersMethod = Class.forName("org.bukkit.Server").getMethod("getOnlinePlayers");
+            return onlinePlayersMethod.getReturnType().equals(Collection.class)
+                    ? ((Collection<?>) onlinePlayersMethod.invoke(Bukkit.getServer())).size()
+                    : ((Player[]) onlinePlayersMethod.invoke(Bukkit.getServer())).length;
+        } catch (Exception e) {
+            // Just use the new method if the reflection failed
+            return Bukkit.getOnlinePlayers().size();
+        }
+    }
+
+    public static class MetricsBase {
+
+        /** The version of the Metrics class. */
+        public static final String METRICS_VERSION = "3.0.0";
+
+        private static final ScheduledExecutorService scheduler =
+                Executors.newScheduledThreadPool(1, task -> new Thread(task, "bStats-Metrics"));
+
+        private static final String REPORT_URL = "https://bStats.org/api/v2/data/%s";
+
+        private final String platform;
+
+        private final String serverUuid;
+
+        private final int serviceId;
+
+        private final Consumer<JsonObjectBuilder> appendPlatformDataConsumer;
+
+        private final Consumer<JsonObjectBuilder> appendServiceDataConsumer;
+
+        private final Consumer<Runnable> submitTaskConsumer;
+
+        private final Supplier<Boolean> checkServiceEnabledSupplier;
+
+        private final BiConsumer<String, Throwable> errorLogger;
+
+        private final Consumer<String> infoLogger;
+
+        private final boolean logErrors;
+
+        private final boolean logSentData;
+
+        private final boolean logResponseStatusText;
+
+        private final Set<CustomChart> customCharts = new HashSet<>();
+
+        private final boolean enabled;
+
+        /**
+         * Creates a new MetricsBase class instance.
+         *
+         * @param platform The platform of the service.
+         * @param serviceId The id of the service.
+         * @param serverUuid The server uuid.
+         * @param enabled Whether or not data sending is enabled.
+         * @param appendPlatformDataConsumer A consumer that receives a {@code JsonObjectBuilder} and
+         *     appends all platform-specific data.
+         * @param appendServiceDataConsumer A consumer that receives a {@code JsonObjectBuilder} and
+         *     appends all service-specific data.
+         * @param submitTaskConsumer A consumer that takes a runnable with the submit task. This can be
+         *     used to delegate the data collection to a another thread to prevent errors caused by
+         *     concurrency. Can be {@code null}.
+         * @param checkServiceEnabledSupplier A supplier to check if the service is still enabled.
+         * @param errorLogger A consumer that accepts log message and an error.
+         * @param infoLogger A consumer that accepts info log messages.
+         * @param logErrors Whether or not errors should be logged.
+         * @param logSentData Whether or not the sent data should be logged.
+         * @param logResponseStatusText Whether or not the response status text should be logged.
+         */
+        public MetricsBase(
+                String platform,
+                String serverUuid,
+                int serviceId,
+                boolean enabled,
+                Consumer<JsonObjectBuilder> appendPlatformDataConsumer,
+                Consumer<JsonObjectBuilder> appendServiceDataConsumer,
+                Consumer<Runnable> submitTaskConsumer,
+                Supplier<Boolean> checkServiceEnabledSupplier,
+                BiConsumer<String, Throwable> errorLogger,
+                Consumer<String> infoLogger,
+                boolean logErrors,
+                boolean logSentData,
+                boolean logResponseStatusText) {
+            this.platform = platform;
+            this.serverUuid = serverUuid;
+            this.serviceId = serviceId;
+            this.enabled = enabled;
+            this.appendPlatformDataConsumer = appendPlatformDataConsumer;
+            this.appendServiceDataConsumer = appendServiceDataConsumer;
+            this.submitTaskConsumer = submitTaskConsumer;
+            this.checkServiceEnabledSupplier = checkServiceEnabledSupplier;
+            this.errorLogger = errorLogger;
+            this.infoLogger = infoLogger;
+            this.logErrors = logErrors;
+            this.logSentData = logSentData;
+            this.logResponseStatusText = logResponseStatusText;
+            checkRelocation();
+            if (enabled) {
+                // WARNING: Removing the option to opt-out will get your plugin banned from bStats
+                startSubmitting();
+            }
+        }
+
+        public void addCustomChart(CustomChart chart) {
+            this.customCharts.add(chart);
+        }
+
+        private void startSubmitting() {
+            final Runnable submitTask =
+                    () -> {
+                        if (!enabled || !checkServiceEnabledSupplier.get()) {
+                            // Submitting data or service is disabled
+                            scheduler.shutdown();
+                            return;
+                        }
+                        if (submitTaskConsumer != null) {
+                            submitTaskConsumer.accept(this::submitData);
+                        } else {
+                            this.submitData();
+                        }
+                    };
+            // Many servers tend to restart at a fixed time at xx:00 which causes an uneven distribution
+            // of requests on the
+            // bStats backend. To circumvent this problem, we introduce some randomness into the initial
+            // and second delay.
+            // WARNING: You must not modify and part of this Metrics class, including the submit delay or
+            // frequency!
+            // WARNING: Modifying this code will get your plugin banned on bStats. Just don't do it!
+            long initialDelay = (long) (1000 * 60 * (3 + Math.random() * 3));
+            long secondDelay = (long) (1000 * 60 * (Math.random() * 30));
+            scheduler.schedule(submitTask, initialDelay, TimeUnit.MILLISECONDS);
+            scheduler.scheduleAtFixedRate(
+                    submitTask, initialDelay + secondDelay, 1000 * 60 * 30, TimeUnit.MILLISECONDS);
+        }
+
+        private void submitData() {
+            final JsonObjectBuilder baseJsonBuilder = new JsonObjectBuilder();
+            appendPlatformDataConsumer.accept(baseJsonBuilder);
+            final JsonObjectBuilder serviceJsonBuilder = new JsonObjectBuilder();
+            appendServiceDataConsumer.accept(serviceJsonBuilder);
+            JsonObjectBuilder.JsonObject[] chartData =
+                    customCharts.stream()
+                            .map(customChart -> customChart.getRequestJsonObject(errorLogger, logErrors))
+                            .filter(Objects::nonNull)
+                            .toArray(JsonObjectBuilder.JsonObject[]::new);
+            serviceJsonBuilder.appendField("id", serviceId);
+            serviceJsonBuilder.appendField("customCharts", chartData);
+            baseJsonBuilder.appendField("service", serviceJsonBuilder.build());
+            baseJsonBuilder.appendField("serverUUID", serverUuid);
+            baseJsonBuilder.appendField("metricsVersion", METRICS_VERSION);
+            JsonObjectBuilder.JsonObject data = baseJsonBuilder.build();
+            scheduler.execute(
+                    () -> {
+                        try {
+                            // Send the data
+                            sendData(data);
+                        } catch (Exception e) {
+                            // Something went wrong! :(
+                            if (logErrors) {
+                                errorLogger.accept("Could not submit bStats metrics data", e);
+                            }
+                        }
+                    });
+        }
+
+        private void sendData(JsonObjectBuilder.JsonObject data) throws Exception {
+            if (logSentData) {
+                infoLogger.accept("Sent bStats metrics data: " + data.toString());
+            }
+            String url = String.format(REPORT_URL, platform);
+            HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
+            // Compress the data to save bandwidth
+            byte[] compressedData = compress(data.toString());
+            connection.setRequestMethod("POST");
+            connection.addRequestProperty("Accept", "application/json");
+            connection.addRequestProperty("Connection", "close");
+            connection.addRequestProperty("Content-Encoding", "gzip");
+            connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+            connection.setRequestProperty("Content-Type", "application/json");
+            connection.setRequestProperty("User-Agent", "Metrics-Service/1");
+            connection.setDoOutput(true);
+            try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
+                outputStream.write(compressedData);
+            }
+            StringBuilder builder = new StringBuilder();
+            try (BufferedReader bufferedReader =
+                         new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+                String line;
+                while ((line = bufferedReader.readLine()) != null) {
+                    builder.append(line);
+                }
+            }
+            if (logResponseStatusText) {
+                infoLogger.accept("Sent data to bStats and received response: " + builder);
+            }
+        }
+
+        /** Checks that the class was properly relocated. */
+        private void checkRelocation() {
+            // You can use the property to disable the check in your test environment
+            if (System.getProperty("bstats.relocatecheck") == null
+                    || !System.getProperty("bstats.relocatecheck").equals("false")) {
+                // Maven's Relocate is clever and changes strings, too. So we have to use this little
+                // "trick" ... :D
+                final String defaultPackage =
+                        new String(new byte[] {'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's'});
+                final String examplePackage =
+                        new String(new byte[] {'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
+                // We want to make sure no one just copy & pastes the example and uses the wrong package
+                // names
+                if (MetricsBase.class.getPackage().getName().startsWith(defaultPackage)
+                        || MetricsBase.class.getPackage().getName().startsWith(examplePackage)) {
+                    throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
+                }
+            }
+        }
+
+        /**
+         * Gzips the given string.
+         *
+         * @param str The string to gzip.
+         * @return The gzipped string.
+         */
+        private static byte[] compress(final String str) throws IOException {
+            if (str == null) {
+                return null;
+            }
+            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+            try (GZIPOutputStream gzip = new GZIPOutputStream(outputStream)) {
+                gzip.write(str.getBytes(StandardCharsets.UTF_8));
+            }
+            return outputStream.toByteArray();
+        }
+    }
+
+    public static class DrilldownPie extends CustomChart {
+
+        private final Callable<Map<String, Map<String, Integer>>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public DrilldownPie(String chartId, Callable<Map<String, Map<String, Integer>>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        public JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Map<String, Integer>> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean reallyAllSkipped = true;
+            for (Map.Entry<String, Map<String, Integer>> entryValues : map.entrySet()) {
+                JsonObjectBuilder valueBuilder = new JsonObjectBuilder();
+                boolean allSkipped = true;
+                for (Map.Entry<String, Integer> valueEntry : map.get(entryValues.getKey()).entrySet()) {
+                    valueBuilder.appendField(valueEntry.getKey(), valueEntry.getValue());
+                    allSkipped = false;
+                }
+                if (!allSkipped) {
+                    reallyAllSkipped = false;
+                    valuesBuilder.appendField(entryValues.getKey(), valueBuilder.build());
+                }
+            }
+            if (reallyAllSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class AdvancedPie extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public AdvancedPie(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                if (entry.getValue() == 0) {
+                    // Skip this invalid
+                    continue;
+                }
+                allSkipped = false;
+                valuesBuilder.appendField(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class MultiLineChart extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public MultiLineChart(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                if (entry.getValue() == 0) {
+                    // Skip this invalid
+                    continue;
+                }
+                allSkipped = false;
+                valuesBuilder.appendField(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class SimpleBarChart extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SimpleBarChart(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                valuesBuilder.appendField(entry.getKey(), new int[] {entry.getValue()});
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public abstract static class CustomChart {
+
+        private final String chartId;
+
+        protected CustomChart(String chartId) {
+            if (chartId == null) {
+                throw new IllegalArgumentException("chartId must not be null");
+            }
+            this.chartId = chartId;
+        }
+
+        public JsonObjectBuilder.JsonObject getRequestJsonObject(
+                BiConsumer<String, Throwable> errorLogger, boolean logErrors) {
+            JsonObjectBuilder builder = new JsonObjectBuilder();
+            builder.appendField("chartId", chartId);
+            try {
+                JsonObjectBuilder.JsonObject data = getChartData();
+                if (data == null) {
+                    // If the data is null we don't send the chart.
+                    return null;
+                }
+                builder.appendField("data", data);
+            } catch (Throwable t) {
+                if (logErrors) {
+                    errorLogger.accept("Failed to get data for custom chart with id " + chartId, t);
+                }
+                return null;
+            }
+            return builder.build();
+        }
+
+        protected abstract JsonObjectBuilder.JsonObject getChartData() throws Exception;
+    }
+
+    public static class SimplePie extends CustomChart {
+
+        private final Callable<String> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SimplePie(String chartId, Callable<String> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            String value = callable.call();
+            if (value == null || value.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("value", value).build();
+        }
+    }
+
+    public static class AdvancedBarChart extends CustomChart {
+
+        private final Callable<Map<String, int[]>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public AdvancedBarChart(String chartId, Callable<Map<String, int[]>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, int[]> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, int[]> entry : map.entrySet()) {
+                if (entry.getValue().length == 0) {
+                    // Skip this invalid
+                    continue;
+                }
+                allSkipped = false;
+                valuesBuilder.appendField(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class SingleLineChart extends CustomChart {
+
+        private final Callable<Integer> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SingleLineChart(String chartId, Callable<Integer> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            int value = callable.call();
+            if (value == 0) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("value", value).build();
+        }
+    }
+
+    /**
+     * An extremely simple JSON builder.
+     *
+     * <p>While this class is neither feature-rich nor the most performant one, it's sufficient enough
+     * for its use-case.
+     */
+    public static class JsonObjectBuilder {
+
+        private StringBuilder builder = new StringBuilder();
+
+        private boolean hasAtLeastOneField = false;
+
+        public JsonObjectBuilder() {
+            builder.append("{");
+        }
+
+        /**
+         * Appends a null field to the JSON.
+         *
+         * @param key The key of the field.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendNull(String key) {
+            appendFieldUnescaped(key, "null");
+            return this;
+        }
+
+        /**
+         * Appends a string field to the JSON.
+         *
+         * @param key The key of the field.
+         * @param value The value of the field.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, String value) {
+            if (value == null) {
+                throw new IllegalArgumentException("JSON value must not be null");
+            }
+            appendFieldUnescaped(key, "\"" + escape(value) + "\"");
+            return this;
+        }
+
+        /**
+         * Appends an integer field to the JSON.
+         *
+         * @param key The key of the field.
+         * @param value The value of the field.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, int value) {
+            appendFieldUnescaped(key, String.valueOf(value));
+            return this;
+        }
+
+        /**
+         * Appends an object to the JSON.
+         *
+         * @param key The key of the field.
+         * @param object The object.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, JsonObject object) {
+            if (object == null) {
+                throw new IllegalArgumentException("JSON object must not be null");
+            }
+            appendFieldUnescaped(key, object.toString());
+            return this;
+        }
+
+        /**
+         * Appends a string array to the JSON.
+         *
+         * @param key The key of the field.
+         * @param values The string array.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, String[] values) {
+            if (values == null) {
+                throw new IllegalArgumentException("JSON values must not be null");
+            }
+            String escapedValues =
+                    Arrays.stream(values)
+                            .map(value -> "\"" + escape(value) + "\"")
+                            .collect(Collectors.joining(","));
+            appendFieldUnescaped(key, "[" + escapedValues + "]");
+            return this;
+        }
+
+        /**
+         * Appends an integer array to the JSON.
+         *
+         * @param key The key of the field.
+         * @param values The integer array.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, int[] values) {
+            if (values == null) {
+                throw new IllegalArgumentException("JSON values must not be null");
+            }
+            String escapedValues =
+                    Arrays.stream(values).mapToObj(String::valueOf).collect(Collectors.joining(","));
+            appendFieldUnescaped(key, "[" + escapedValues + "]");
+            return this;
+        }
+
+        /**
+         * Appends an object array to the JSON.
+         *
+         * @param key The key of the field.
+         * @param values The integer array.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, JsonObject[] values) {
+            if (values == null) {
+                throw new IllegalArgumentException("JSON values must not be null");
+            }
+            String escapedValues =
+                    Arrays.stream(values).map(JsonObject::toString).collect(Collectors.joining(","));
+            appendFieldUnescaped(key, "[" + escapedValues + "]");
+            return this;
+        }
+
+        /**
+         * Appends a field to the object.
+         *
+         * @param key The key of the field.
+         * @param escapedValue The escaped value of the field.
+         */
+        private void appendFieldUnescaped(String key, String escapedValue) {
+            if (builder == null) {
+                throw new IllegalStateException("JSON has already been built");
+            }
+            if (key == null) {
+                throw new IllegalArgumentException("JSON key must not be null");
+            }
+            if (hasAtLeastOneField) {
+                builder.append(",");
+            }
+            builder.append("\"").append(escape(key)).append("\":").append(escapedValue);
+            hasAtLeastOneField = true;
+        }
+
+        /**
+         * Builds the JSON string and invalidates this builder.
+         *
+         * @return The built JSON string.
+         */
+        public JsonObject build() {
+            if (builder == null) {
+                throw new IllegalStateException("JSON has already been built");
+            }
+            JsonObject object = new JsonObject(builder.append("}").toString());
+            builder = null;
+            return object;
+        }
+
+        /**
+         * Escapes the given string like stated in https://www.ietf.org/rfc/rfc4627.txt.
+         *
+         * <p>This method escapes only the necessary characters '"', '\'. and '\u0000' - '\u001F'.
+         * Compact escapes are not used (e.g., '\n' is escaped as "\u000a" and not as "\n").
+         *
+         * @param value The value to escape.
+         * @return The escaped value.
+         */
+        private static String escape(String value) {
+            final StringBuilder builder = new StringBuilder();
+            for (int i = 0; i < value.length(); i++) {
+                char c = value.charAt(i);
+                if (c == '"') {
+                    builder.append("\\\"");
+                } else if (c == '\\') {
+                    builder.append("\\\\");
+                } else if (c <= '\u000F') {
+                    builder.append("\\u000").append(Integer.toHexString(c));
+                } else if (c <= '\u001F') {
+                    builder.append("\\u00").append(Integer.toHexString(c));
+                } else {
+                    builder.append(c);
+                }
+            }
+            return builder.toString();
+        }
+
+        /**
+         * A super simple representation of a JSON object.
+         *
+         * <p>This class only exists to make methods of the {@link JsonObjectBuilder} type-safe and not
+         * allow a raw string inputs for methods like {@link JsonObjectBuilder#appendField(String,
+         * JsonObject)}.
+         */
+        public static class JsonObject {
+
+            private final String value;
+
+            private JsonObject(String value) {
+                this.value = value;
+            }
+
+            @Override
+            public String toString() {
+                return value;
+            }
+        }
+    }
+}

src/main/resources/config.yml

@@ -4,9 +4,9 @@
 # These values must be in the form of doubles, as listed below.
 # The maximum amount of luck that can be attributed is 1024.0, and the minimum is -1024.0
 
-high_rarity_chance: 512
-medium_rarity_chance: 128
-low_rarity_chance: 64
+high_rarity_chance: 512.0
+medium_rarity_chance: 128.0
+low_rarity_chance: 64.0
 
 # The following entries are for the rarity level of each event trigger.
 # This will determine which rarity chance to use which ensures players
@@ -15,12 +15,12 @@ low_rarity_chance: 64
 # These entries are case-sensitive.
 
 block_drops: LOW
-bonemeal: LOW
+bonemeal: MED
 cheat_death: MED
 enchanting: HIGH
 experience: HIGH
 item_drops: LOW
 random_effect: HIGH
-restore_hunger: MED
+restore_hunger: NONE
 take_damage: MED
 unbreakable: HIGH