1.4.0 Update

Feature Update:
- SQL Support (MySQL, REDIS, SQLite)
- Global Verbosity Control
- Reimplemented Experimental OreVein

.github/workflows/codacy-analysis.yml

@@ -0,0 +1,32 @@
+name: Codacy Security Scan
+
+on:
+  push:
+    branches: [ "master", "main" ]
+  pull_request:
+    branches: [ "master", "main" ]
+
+jobs:
+  codacy-security-scan:
+    name: Codacy Security Scan
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@main
+
+      - name: Run Codacy Analysis CLI
+        uses: codacy/codacy-analysis-cli-action@master
+        with:
+          output: results.sarif
+          format: sarif
+          # Adjust severity of non-security issues
+          gh-code-scanning-compat: true
+          # Force 0 exit code to allow SARIF file generation
+          # This will handover control about PR rejection to the GitHub side
+          max-allowed-issues: 2147483647
+
+      # Upload the SARIF file generated in the previous step
+      - name: Upload SARIF results file
+        uses: github/codeql-action/upload-sarif@main
+        with:
+          sarif_file: results.sarif

README.md

@@ -1,4 +1,4 @@
-# <center>FeelingLucky v1.2.0</center>
+# <center>FeelingLucky v1.3.0 - A luck driven mechanics plugin.</center>
 
 ## <center><u><span style="color:blue">Plugin Description:</u></center>
 
@@ -17,12 +17,13 @@ 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.
+Server owners and/or individuals with console access can run /rgc to regenerate the main configuration file in the case that there are values missing, corrupted, or invalid.
 
 ## <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><span style="color:red">Note: Paper is REQUIRED for this plugin to run. Spigot is not supported, however Spigot support is currently in progress.</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,7 +3,7 @@ plugins {
 }
 
 group = 'io.github.simplex'
-version = '1.2.0'
+version = '1.3.0'
 
 repositories {
     mavenCentral()
@@ -12,7 +12,8 @@ repositories {
 }
 
 dependencies {
-    compileOnly("io.papermc.paper:paper-api:1.19-R0.1-SNAPSHOT")
+    compileOnly("io.papermc.paper:paper-api:1.20.4-R0.1-SNAPSHOT")
+    implementation 'redis.clients:jedis:3.7.0'
 }
 
 def targetJavaVersion = 17

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

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

@@ -1,18 +1,68 @@
 package io.github.simplex.api;
 
+import java.io.Serializable;
 import org.bukkit.entity.Player;
 
-import java.io.Serializable;
+/**
-
+ * The LuckContainer interface represents a container for player luck.
+ * It provides methods to get and set the verbosity of the luck container,
+ * check if a number matches or is close to the luck value, get the multiplier,
+ * get the associated player, and get the luck value.
+ *
+ * This interface is Serializable, which means it can be written to a stream
+ * and restored.
+ */
 public interface LuckContainer extends Serializable {
 
+    /**
+     * Checks if the luck container is verbose.
+     *
+     * @return true if the luck container is verbose, false otherwise.
+     */
+    boolean isVerbose();
+
+    /**
+     * Sets the verbosity of the luck container.
+     *
+     * @param verbose the verbosity to set.
+     */
+    void setVerbose(boolean verbose);
+
+    /**
+     * Checks if a number matches the luck value.
+     *
+     * @param number the number to check.
+     * @return true if the number matches the luck value, false otherwise.
+     */
     boolean isMatch(double number);
 
+    /**
+     * Checks if a number is close to the luck value within a certain range.
+     *
+     * @param number the number to check.
+     * @param range the range within which the number is considered close.
+     * @return true if the number is close to the luck value, false otherwise.
+     */
     boolean isClose(double number, int range);
 
+    /**
+     * Gets the multiplier of the luck container.
+     *
+     * @return the multiplier.
+     */
     double multiplier();
 
+    /**
+     * Gets the player associated with the luck container.
+     *
+     * @return the associated player.
+     */
     Player associatedPlayer();
 
+    /**
+     * Gets the luck value of the luck container.
+     *
+     * @return the luck value.
+     */
     double getValue();
-}
+}

src/main/java/io/github/simplex/lib/Messages.java

@@ -1,21 +1,25 @@
 package io.github.simplex.lib;
 
-import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.ComponentLike;
 
-public enum Messages {
+public enum Messages
+{
 
     NOT_FROM_CONSOLE(MiniComponent.err("This command may only be used in game.")),
     NO_PERMISSION(MiniComponent.err("You do not have permission to use this command.")),
     NO_PLAYER(MiniComponent.warn("That player cannot be found.")),
-    OUT_OF_BOUNDS(MiniComponent.err("Number must be between -1024.0 and 1024.0"));
+    OUT_OF_BOUNDS(MiniComponent.err("Number must be between -1024.0 and 1024.0")),
+    VERBOSE_DISABLED(MiniComponent.err("Verbose mode is currently disabled globally."));
 
-    private final Component message;
+    private final ComponentLike message;
 
-    Messages(Component message) {
+    Messages(ComponentLike message)
+    {
         this.message = message;
     }
 
-    public Component get() {
+    public ComponentLike get()
+    {
         return message;
     }
 }

src/main/java/io/github/simplex/lib/MiniComponent.java

@@ -1,10 +1,12 @@
 package io.github.simplex.lib;
 
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.ComponentLike;
 import net.kyori.adventure.text.format.TextColor;
 import net.kyori.adventure.text.format.TextDecoration;
 import org.bukkit.ChatColor;
 import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.Nullable;
 
 public class MiniComponent {
     private final String content;
@@ -21,17 +23,17 @@ public class MiniComponent {
     }
 
     @Contract("_ -> new")
-    public static Component info(String content) {
+    public static ComponentLike info(String content) {
         return new MiniComponent(content).color(ChatColor.GREEN).send();
     }
 
     @Contract("_ -> new")
-    public static Component warn(String content) {
+    public static ComponentLike warn(String content) {
         return new MiniComponent(content).color(ChatColor.YELLOW).decorate(TextDecoration.ITALIC).send();
     }
 
     @Contract("_ -> new")
-    public static Component err(String content) {
+    public static ComponentLike err(String content) {
         return new MiniComponent(content).color(ChatColor.RED).decorate(TextDecoration.BOLD).send();
     }
 
@@ -45,7 +47,7 @@ public class MiniComponent {
         return this;
     }
 
-    public Component send() {
+    public @Nullable Component send() {
         if (color == null) {
             if (decoration == null) return Component.empty().content(content);
 

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

@@ -1,20 +1,25 @@
 package io.github.simplex.luck;
 
 import io.github.simplex.luck.listener.AbstractListener;
+import io.github.simplex.luck.util.Logs;
 import io.github.simplex.luck.util.SneakyWorker;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.jetbrains.annotations.NotNull;
-
 import java.io.File;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Objects;
 
-@SuppressWarnings("ResultOfMethodCallIgnored")
+import io.github.simplex.sql.SQLType;
-public class Config extends YamlConfiguration {
+import org.bukkit.configuration.file.YamlConfiguration;
-    private final Map<String, Object> configEntries = new HashMap<>() {{
+import org.jetbrains.annotations.NotNull;
+
+public class Config extends YamlConfiguration
+{
+    private final Map<String, Object> configEntries = new HashMap<>()
+    {{
         put("high_rarity_chance", 512.0);
         put("medium_rarity_chance", 128.0);
         put("low_rarity_chance", 64.0);
+        put("global_verbosity", true);
         put("block_drops", "LOW");
         put("bonemeal", "MED");
         put("cheat_death", "MED");
@@ -30,69 +35,183 @@ public class Config extends YamlConfiguration {
         put("take_damage", "MED");
         put("unbreakable", "HIGH");
     }};
-    private File configFile;
+    private final File configFile;
 
-    public Config(FeelingLucky plugin) {
+    public Config(FeelingLucky plugin)
+    {
         File dataFolder = plugin.getDataFolder();
-        if (dataFolder.mkdirs()) {
+        if (dataFolder.mkdirs())
+        {
             plugin.getLogger().info("Created new data folder. Writing new configuration file...");
             plugin.saveResource("config.yml", true);
         }
 
         File configFile = new File(dataFolder, "config.yml");
-        if (!configFile.exists()) {
+        if (!configFile.exists())
+        {
             plugin.getLogger().info("No configuration file exists. Creating a new one...");
             plugin.saveResource("config.yml", true);
         }
 
         this.configFile = configFile;
 
-        if (validateIntegrity(this.configFile)) {
+        if (validateIntegrity(this.configFile))
+        {
             load();
-        } else {
+        }
+        else
+        {
             configEntries.forEach(super::set);
-            plugin.getLogger().warning("Your configuration file is missing keys. " +
+            Logs.warn("Your configuration file is missing keys. " +
-                    "\nPlease use /rgc in the console to regenerate the config file. " +
+                      "\nPlease use /rgc in the console to regenerate the config file. " +
-                    "\nAlternatively, delete the config.yml and restart your server. " +
+                      "\nAlternatively, delete the config.yml and restart your server. " +
-                    "\nIt is safe to ignore this, as default values will be used." +
+                      "\nIt is safe to ignore this, as default values will be used." +
-                    "\nHowever, it is highly recommended to regenerate the configuration.");
+                      "\nHowever, it is highly recommended to regenerate the configuration.");
         }
     }
 
-    public void save() {
+    public void save()
+    {
         SneakyWorker.sneakyTry(() -> save(configFile));
     }
 
-    public void load() {
+    public void load()
+    {
         SneakyWorker.sneakyTry(() -> load(configFile));
     }
 
-    public void reload() {
+    public void reload()
+    {
         save();
         load();
     }
 
-    public boolean validateIntegrity(@NotNull File fromDisk) {
+    public boolean validateIntegrity(@NotNull File fromDisk)
+    {
         YamlConfiguration disk = YamlConfiguration.loadConfiguration(fromDisk);
-        if (disk.getKeys(true).size() <= 0) {
+        if (disk.getKeys(true).isEmpty())
+        {
             return false;
         }
 
         boolean result = true;
 
-        for (String key : configEntries.keySet()) {
+        for (String key : configEntries.keySet())
-            if (!disk.getKeys(false).contains(key)) {
+        {
-                if (result) result = false;
+            if (!disk.getKeys(false).contains(key))
+            {
+                if (result)
+                    result = false;
             }
         }
         return result;
     }
 
-    public AbstractListener.Rarity getRarity(String name) {
+    public AbstractListener.Rarity getRarity(String name)
+    {
         return AbstractListener.Rarity.valueOf(getString(name));
     }
 
-    public double getChance(String path) {
+    public double getChance(String path)
+    {
         return getDouble(path);
     }
+
+    public boolean isVerboseGlobal() {
+        return getBoolean("global_verbosity");
+    }
+
+    public SQLType getSQLType() {
+        return SQLType.fromString(Objects.requireNonNull(getString("database_type")));
+    }
+
+    public SQLiteWrapper getSQLite() {
+        return new SQLiteWrapper();
+    }
+
+    public RedisWrapper getRedis() {
+        return new RedisWrapper();
+    }
+
+    public MySQLWrapper getMySQL() {
+        return new MySQLWrapper();
+    }
+
+    public final class SQLiteWrapper {
+        private final String path;
+
+        public SQLiteWrapper() {
+            this.path = getString("sqlite.path");
+        }
+
+        public String getPath() {
+            return path;
+        }
+    }
+
+    public final class RedisWrapper {
+        private final String host;
+        private final String port;
+        private final String password;
+        private final int database;
+
+        public RedisWrapper() {
+            this.host = getString("redis.host");
+            this.port = getString("redis.port");
+            this.password = getString("redis.password");
+            this.database = getInt("redis.database");
+        }
+
+        public String getHost() {
+            return host;
+        }
+
+        public String getPort() {
+            return port;
+        }
+
+        public String getPassword() {
+            return password;
+        }
+
+        public int getDatabase() {
+            return database;
+        }
+    }
+
+    public final class MySQLWrapper {
+        private final String host;
+        private final int port;
+        private final String database;
+        private final String username;
+        private final String password;
+
+        public MySQLWrapper() {
+            this.host = getString("mysql.host");
+            this.port = getInt("mysql.port");
+            this.database = getString("mysql.database");
+            this.username = getString("mysql.username");
+            this.password = getString("mysql.password");
+        }
+
+        public String getHost() {
+            return host;
+        }
+
+        public int getPort() {
+            return port;
+        }
+
+        public String getDatabase() {
+            return database;
+        }
+
+        public String getUsername() {
+            return username;
+        }
+
+        public String getPassword() {
+            return password;
+        }
+    }
 }

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

@@ -3,28 +3,43 @@ package io.github.simplex.luck;
 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.Logs;
 import io.github.simplex.luck.util.LuckCMD;
 import io.github.simplex.luck.util.RegenerateConfigCMD;
 import io.github.simplex.luck.util.SpecialFootItem;
 import io.github.simplex.metrics.Metrics;
-import org.bukkit.command.CommandMap;
-import org.bukkit.plugin.java.JavaPlugin;
-import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
+import java.sql.SQLException;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.UUID;
 
+import io.github.simplex.sql.MySQL;
+import io.github.simplex.sql.Redis;
+import io.github.simplex.sql.SQLType;
+import io.github.simplex.sql.SQLite;
+import net.kyori.adventure.chat.ChatType;
+import net.kyori.adventure.text.Component;
+import org.bukkit.command.CommandMap;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+
 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 final ChatType.Bound bind = ChatType.CHAT.bind(Component.text(getName()));
     private PlayerHandler handler;
     private Config config;
 
+    private MySQL mysql;
+    private SQLite sqlite;
+    private Redis Redis;
+
+    private boolean shouldLoadPhysical = false;
+
     public Map<UUID, PlayerConfig> getConfigMap() {
         return configMap;
     }
@@ -33,12 +48,14 @@ public final class FeelingLucky extends JavaPlugin {
     public void onEnable() {
         getLogger().info("Initializing metrics...");
         new Metrics(this, 15054);
-        getLogger().info("Metrics loaded. Initializing the PlayerHandler...");
+        getLogger().info("Metrics loaded. Initializing SQL...");
-        handler = new PlayerHandler(this);
+        initSQL();
         getLogger().info("Initialization complete! Attempting to register the Listeners...");
         registerListeners();
-        getLogger().info("Registration complete! Attempting to load all player configuration files...");
+        getLogger().info("Registration complete! Attempting to load all saved player configurations...");
         loadPlayerConfigurations();
+        getLogger().info("Player configurations loaded! Initializing PlayerHandler...");
+        handler = new PlayerHandler(this);
         getLogger().info("Attempting to load the main configuration...");
         config = new Config(this);
         getLogger().info("Main Config loaded successfully! Loading commands...");
@@ -58,6 +75,69 @@ public final class FeelingLucky extends JavaPlugin {
         getLogger().info("Complete! Goodbye! :)");
     }
 
+    private void initSQL() {
+        switch (config.getSQLType()) {
+            case MYSQL -> {
+                try {
+                    mysql = new MySQL(this);
+                } catch (Exception e) {
+                    getLogger().severe("Failed to initialize MySQL. Falling back to standard plugin configuration.");
+                    Logs.error(e);
+                    shouldLoadPhysical(true);
+                }
+            }
+            case SQLITE -> {
+                try {
+                    sqlite = new SQLite(this);
+                } catch (SQLException e) {
+                    getLogger().severe("Failed to initialize SQLite. Falling back to standard plugin configuration.");
+                    Logs.error(e);
+                    shouldLoadPhysical(true);
+                }
+            }
+            case REDIS -> {
+                Redis = new Redis(this);
+            }
+        }
+    }
+
+    private void saveToSQL() {
+        switch (config.getSQLType()) {
+            case MYSQL -> {
+                mysql.savePlayers();
+            }
+            case SQLITE -> {
+                try {
+                    sqlite.savePlayers();
+                } catch (Exception e) {
+                    Logs.error(e);
+                }
+            }
+            case REDIS -> {
+                Redis = new Redis(this);
+                Redis.savePlayers();
+            }
+        }
+    }
+
+    private void loadPlayersFromSQL() {
+        switch (config.getSQLType()) {
+            case MYSQL -> {
+                mysql.loadPlayers();
+            }
+            case SQLITE -> {
+                try {
+                    sqlite.loadPlayers();
+                } catch (SQLException e) {
+                    Logs.error(e);
+                }
+            }
+            case REDIS -> {
+                Redis.loadPlayers();
+            }
+        }
+    }
+
     private void loadPlayerConfigurations() {
         if (!playerDirectory.exists()) {
             getLogger().info("No directory exists. Creating...");
@@ -66,11 +146,18 @@ public final class FeelingLucky extends JavaPlugin {
             return;
         }
 
+        if (config.getSQLType() != SQLType.NONE && !shouldLoadPhysical()) {
+            loadPlayersFromSQL();
+            getLogger().info("Successfully loaded all configurations from SQL!");
+            return;
+        }
+
         File[] files = playerDirectory.listFiles();
         if (files != null) {
-            Arrays.stream(files).forEach(file -> {
+            Arrays.stream(files).forEach(file ->
+            {
                 UUID uuid = UUID.fromString(file.getName().split("\\.")[0]);
-                configMap.put(uuid, PlayerConfig.initFrom(this, file));
+                configMap.put(uuid, PlayerConfig.initFromFile(this, file));
             });
             configMap.forEach((u, pc) -> pc.load());
             getLogger().info("Successfully loaded all configurations!");
@@ -90,7 +177,7 @@ public final class FeelingLucky extends JavaPlugin {
         new IllOmen(this);
         new ItemDrops(this);
         new JumpBoost(this);
-        new OreVein(this);
+        // new OreVein(this); (Currently unstable & unsafe).
         new PlayerListener(this);
         new RandomEffect(this);
         new RestoreHunger(this);
@@ -113,7 +200,19 @@ public final class FeelingLucky extends JavaPlugin {
         return specialFootItem;
     }
 
+    private void shouldLoadPhysical(boolean state) {
+        shouldLoadPhysical = state;
+    }
+
+    private boolean shouldLoadPhysical() {
+        return shouldLoadPhysical;
+    }
+
     public CommandMap getCommandMap() {
         return getServer().getCommandMap();
     }
+
+    public ChatType.Bound bind() {
+        return bind;
+    }
 }

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

@@ -1,8 +1,9 @@
 package io.github.simplex.luck.listener;
 
-import io.github.simplex.luck.Config;
 import io.github.simplex.luck.FeelingLucky;
 import io.github.simplex.luck.player.PlayerHandler;
+import net.kyori.adventure.audience.Audience;
+import org.bukkit.entity.Player;
 import org.bukkit.event.Listener;
 
 public abstract class AbstractListener implements Listener {
@@ -35,4 +36,8 @@ public abstract class AbstractListener implements Listener {
         LOW,
         NONE
     }
+
+    public Audience asAudience(final Player player) {
+        return player;
+    }
 }

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

@@ -1,28 +1,35 @@
 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.SneakyWorker;
+import java.util.List;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.block.BlockDropItemEvent;
 
-import java.util.List;
+public final class BlockDrops extends AbstractListener
-
+{
-public final class BlockDrops extends AbstractListener {
+    public BlockDrops(FeelingLucky plugin)
-    public BlockDrops(FeelingLucky plugin) {
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void extraBlockDrops(BlockDropItemEvent event) {
+    public void extraBlockDrops(BlockDropItemEvent event)
+    {
         Player player = event.getPlayer();
         Luck luck = getHandler().getLuckContainer(player);
         List<Item> items = event.getItems();
-        if (luck.quickRNG(luck.getValue()) && doesQualify("block_drops", luck.getValue())) {
+        if (luck.quickRNG(luck.getValue()) && doesQualify("block_drops", luck.getValue()))
+        {
             event.getItems().addAll(items.stream().map(SneakyWorker::move).toList());
         }
+
+        if (luck.isVerbose())
+            asAudience(player).sendMessage(MiniComponent.info("You got lucky and received extra drops!"));
     }
 }

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

@@ -4,6 +4,7 @@ import io.github.simplex.lib.ItemBuilder;
 import io.github.simplex.lib.MiniComponent;
 import io.github.simplex.luck.FeelingLucky;
 import io.github.simplex.luck.player.Luck;
+import net.kyori.adventure.audience.Audience;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.Ageable;
@@ -23,6 +24,7 @@ public final class BonemealFullCrop extends AbstractListener {
     @EventHandler
     public void bonemealFullCrop(PlayerInteractEvent event) {
         Player player = event.getPlayer();
+        Audience pAud = player;
         Action action = event.getAction();
         ItemStack bonemeal = ItemBuilder.of(Material.BONE_MEAL).build();
         Luck luck = getHandler().getLuckContainer(player);
@@ -43,6 +45,12 @@ public final class BonemealFullCrop extends AbstractListener {
             crop.setAge(crop.getMaximumAge());
             data.merge(crop);
             block.setBlockData(data);
+
+            if (luck.isVerbose()) {
+                asAudience(player).sendMessage(MiniComponent.info("Your luck has caused your crop to become ready for" +
+                                                                  " " +
+                                                         "harvest!"));
+            }
         }
     }
 }

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

@@ -3,26 +3,35 @@ 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 net.kyori.adventure.audience.Audience;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.entity.PlayerDeathEvent;
 
-public final class CheatDeath extends AbstractListener {
+public final class CheatDeath extends AbstractListener
-    public CheatDeath(FeelingLucky plugin) {
+{
+    public CheatDeath(FeelingLucky plugin)
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void cheatDeath(PlayerDeathEvent event) {
+    public void cheatDeath(PlayerDeathEvent event)
+    {
         Player player = event.getPlayer();
         Luck luck = getHandler().getLuckContainer(player);
         double absorption = Math.round(Luck.RNG().nextDouble(5.0, 10.0));
-        if (luck.quickRNG(luck.getValue()) && doesQualify("cheat_death", luck.getValue())) {
+        if (luck.quickRNG(luck.getValue()) && doesQualify("cheat_death", luck.getValue()))
+        {
             event.setCancelled(true);
             player.setHealth(1.0);
             player.setAbsorptionAmount(absorption);
-            player.sendMessage(MiniComponent.of("You got lucky and cheated death!").send());
+
+            if (luck.isVerbose())
+            {
+                asAudience(player).sendMessage(MiniComponent.info("You got lucky and cheated death!"));
+            }
         }
     }
 }

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

@@ -1,40 +1,52 @@
 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 java.util.List;
+import java.util.Map;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.enchantment.EnchantItemEvent;
 
-import java.util.List;
+public final class EnchantmentBoost extends AbstractListener
-import java.util.Map;
+{
-
+    public EnchantmentBoost(FeelingLucky plugin)
-public final class EnchantmentBoost extends AbstractListener {
+    {
-    public EnchantmentBoost(FeelingLucky plugin) {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void enchantItem(EnchantItemEvent event) {
+    public void enchantItem(EnchantItemEvent event)
+    {
         Map<Enchantment, Integer> enchMap = event.getEnchantsToAdd();
         List<Enchantment> enchList = enchMap.keySet().stream().toList();
         Player player = event.getEnchanter();
         Luck luck = getHandler().getLuckContainer(player);
-        if (luck.quickRNG(luck.getValue()) && doesQualify("enchanting", luck.getValue())) {
+        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);
 
-            if ((enchMap.get(particular) + rng) > particular.getMaxLevel()) {
+            if ((enchMap.get(particular) + rng) > particular.getMaxLevel())
+            {
                 enchMap.replace(particular, particular.getMaxLevel());
             }
 
             enchMap.replace(particular, enchMap.get(particular) + rng);
+
+            if (luck.isVerbose())
+            {
+                asAudience(player).sendMessage(
+                    MiniComponent.info("Your luck has given you an extra random enchantment."));
+            }
         }
     }
 
-    public FeelingLucky plugin() {
+    public FeelingLucky plugin()
+    {
         return plugin;
     }
 }

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

@@ -1,28 +1,38 @@
 package io.github.simplex.luck.listener;
 
 import com.destroystokyo.paper.event.player.PlayerPickupExperienceEvent;
+import io.github.simplex.lib.MiniComponent;
 import io.github.simplex.luck.FeelingLucky;
 import io.github.simplex.luck.player.Luck;
 import org.bukkit.entity.ExperienceOrb;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 
-public final class ExpBoost extends AbstractListener {
+public final class ExpBoost extends AbstractListener
-    public ExpBoost(FeelingLucky plugin) {
+{
+    public ExpBoost(FeelingLucky plugin)
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void boostExperienceGain(PlayerPickupExperienceEvent event) {
+    public void boostExperienceGain(PlayerPickupExperienceEvent event)
+    {
         ExperienceOrb orb = event.getExperienceOrb();
         int n = orb.getExperience();
         int math = (5 * n ^ 2) / (2 * n + 4);
         int rounded = Math.round(math);
         Player player = event.getPlayer();
         Luck luck = plugin.getHandler().getLuckContainer(player);
-        if (luck.quickRNG(luck.getValue()) && doesQualify("experience", luck.getValue())) {
+        if (luck.quickRNG(luck.getValue()) && doesQualify("experience", luck.getValue()))
+        {
             orb.setExperience(rounded);
+            if (luck.isVerbose())
+            {
+                asAudience(player).sendMessage(
+                    MiniComponent.info("Your luck has given you extra experience!"));
+            }
         }
     }
 }

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

@@ -8,20 +8,30 @@ import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.entity.EntityDamageByEntityEvent;
 
-public class GiveDamage extends AbstractListener {
+public class GiveDamage extends AbstractListener
-    public GiveDamage(FeelingLucky plugin) {
+{
+    public GiveDamage(FeelingLucky plugin)
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void playerAttack(EntityDamageByEntityEvent e) {
+    public void playerAttack(EntityDamageByEntityEvent e)
+    {
         if ((e.getDamager() instanceof Player player)
-                && (e.getEntity() instanceof LivingEntity)) {
+            && (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()) && doesQualify("give_damage", luck.getValue())) {
+            if (luck.quickRNG(luck.getValue()) && doesQualify("give_damage", luck.getValue()))
+            {
                 e.setDamage(nextDmg);
+                if (luck.isVerbose())
+                {
+                    asAudience(player).sendMessage(
+                        MiniComponent.info("Your luck gave you a critical hit!"));
+                }
             }
         }
     }

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

@@ -3,58 +3,47 @@ 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.Monster;
 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 class HideCheck extends AbstractListener {
+    public HideCheck(FeelingLucky plugin)
-    public Map<Player, List<Entity>> entityMapList = new HashMap<>();
+    {
-
-    public HideCheck(FeelingLucky plugin) {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void initPlayerMaps(PlayerJoinEvent event) {
+    public void checkForSneak(PlayerToggleSneakEvent event)
-        entityMapList.put(event.getPlayer(), List.of());
+    {
-    }
+        Player player = event.getPlayer();
+        if (player.isSneaking())
+            return;
 
-    @EventHandler
+        Luck luck = plugin.getHandler().getLuckContainer(player);
-    public void checkTargeting(EntityTargetLivingEntityEvent event) {
+        if (luck.quickRNG(luck.getValue()) && doesQualify("hide_check", luck.getValue()))
-        if (event.getTarget() instanceof Player player) {
+        {
-            if (event.getEntity() instanceof LivingEntity entity) {
+            player.getNearbyEntities(25, 25, 25)
-                List<Entity> buffer = entityMapList.get(player).isEmpty() ?
+                  .stream()
-                        new ArrayList<>() : entityMapList.get(player);
+                  .filter(e -> e instanceof Monster)
-                buffer.add(entity);
+                  .map(e -> (Monster) e)
-                entityMapList.replace(player, buffer);
+                  .forEach(m ->
+                           {
+                               final LivingEntity target = m.getTarget();
+                               if (target != null && target.getUniqueId().equals(player.getUniqueId()))
+                               {
+                                   m.setTarget(null);
+                               }
+                           });
+
+            if (luck.isVerbose())
+            {
+                asAudience(player).sendMessage(MiniComponent.info("Your luck has hidden you from sight."));
             }
         }
     }
-
-    @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()) && doesQualify("hide_check", luck.getValue())) {
-            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/IllOmen.java

@@ -11,70 +11,92 @@ import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
-public class IllOmen extends AbstractListener {
+public class IllOmen extends AbstractListener
-    public IllOmen(FeelingLucky plugin) {
+{
+    public IllOmen(FeelingLucky plugin)
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void reconnectCheck(PlayerJoinEvent event) {
+    public void reconnectCheck(PlayerJoinEvent event)
+    {
         Player player = event.getPlayer();
         PotionEffectType type = PotionEffectType.BAD_OMEN;
         Luck luck = getHandler().getLuckContainer(player);
 
-        if (player.hasPotionEffect(type)) {
+        if (player.hasPotionEffect(type))
+        {
             luck.cache();
             double maths = luck.getValue() - (luck.getValue() * 0.25);
             luck.setValue(maths);
-            player.sendMessage(MiniComponent.info("A -25% debuff has been applied to your luck from the Bad Omen status effect."));
+            asAudience(player).sendMessage(MiniComponent.info("A -25% debuff has been applied to your luck from the " +
-        } else if (luck.cached(player) && !player.hasPotionEffect(type)) {
+                                                              "Bad Omen " +
+                                                              "status effect."));
+        }
+        else if (luck.cached(player) && !player.hasPotionEffect(type))
+        {
             luck.restore();
-            player.sendMessage("The -25% debuff to your luck has been removed.");
+            asAudience(player).sendMessage(MiniComponent.info("The -25% debuff to your luck has been removed."));
         }
     }
 
     @EventHandler
-    public void effectApplyCheck(EntityPotionEffectEvent event) {
+    public void effectApplyCheck(EntityPotionEffectEvent event)
+    {
         EntityPotionEffectEvent.Cause cause = EntityPotionEffectEvent.Cause.PATROL_CAPTAIN;
         EntityPotionEffectEvent.Action added = EntityPotionEffectEvent.Action.ADDED;
         EntityPotionEffectEvent.Action changed = EntityPotionEffectEvent.Action.CHANGED;
 
-        if (event.getCause().equals(cause) && (event.getAction().equals(added) || event.getAction().equals(changed))) {
+        if (event.getCause().equals(cause) && (event.getAction().equals(added) || event.getAction().equals(changed)))
-            if (event.getEntity() instanceof Player player) {
+        {
+            if (event.getEntity() instanceof Player player)
+            {
                 Luck luck = plugin.getHandler().getLuckContainer(player);
                 luck.cache();
                 double maths = luck.getValue() - (luck.getValue() * 0.25);
                 luck.setValue(maths);
-                player.sendMessage(MiniComponent.warn("A -25% debuff has been applied to your luck from the Bad Omen status effect."));
+                asAudience(player).sendMessage(
+                    MiniComponent.warn("A -25% debuff has been applied to your luck from the Bad Omen status effect."));
             }
         }
     }
 
     @EventHandler
-    public void effectRemoveCheck(EntityPotionEffectEvent event) {
+    public void effectRemoveCheck(EntityPotionEffectEvent event)
+    {
         PotionEffect old = event.getOldEffect();
         EntityPotionEffectEvent.Action cleared = EntityPotionEffectEvent.Action.CLEARED;
         EntityPotionEffectEvent.Action removed = EntityPotionEffectEvent.Action.REMOVED;
 
-        if (old == null) return;
+        if (old == null)
+            return;
 
-        if (old.getType().equals(PotionEffectType.BAD_OMEN) && (event.getAction().equals(cleared) || event.getAction().equals(removed))) {
+        if (old.getType().equals(PotionEffectType.BAD_OMEN) && (event.getAction().equals(cleared) || event.getAction()
-            if ((event.getEntity() instanceof Player player)) {
+                                                                                                          .equals(
+                                                                                                              removed)))
+        {
+            if ((event.getEntity() instanceof Player player))
+            {
                 Luck luck = plugin.getHandler().getLuckContainer(player);
-                if (luck.cached(player)) {
+                if (luck.cached(player))
+                {
                     luck.restore();
-                    player.sendMessage("The -25% debuff to your luck has been removed.");
+                    asAudience(player).sendMessage(MiniComponent.info("The -25% debuff to your luck has been removed."));
                 }
             }
         }
     }
 
     @EventHandler
-    public void disconnectCheck(PlayerQuitEvent event) {
+    public void disconnectCheck(PlayerQuitEvent event)
-        if (event.getPlayer().hasPotionEffect(PotionEffectType.BAD_OMEN)) {
+    {
+        if (event.getPlayer().hasPotionEffect(PotionEffectType.BAD_OMEN))
+        {
             Luck luck = plugin.getHandler().getLuckContainer(event.getPlayer());
-            if (luck.cached(event.getPlayer())) {
+            if (luck.cached(event.getPlayer()))
+            {
                 luck.restore();
             }
         }

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

@@ -1,7 +1,11 @@
 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 java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Item;
 import org.bukkit.entity.LivingEntity;
@@ -12,30 +16,32 @@ import org.bukkit.event.entity.EntityDeathEvent;
 import org.bukkit.event.entity.EntityDropItemEvent;
 import org.bukkit.inventory.ItemStack;
 
-import java.util.HashMap;
+public class ItemDrops extends AbstractListener
-import java.util.Map;
+{
-import java.util.UUID;
-
-public class ItemDrops extends AbstractListener {
     private final Map<UUID, Player> entityPlayerMap = new HashMap<>();
     private boolean canAffect = false;
 
-    public ItemDrops(FeelingLucky plugin) {
+    public ItemDrops(FeelingLucky plugin)
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void checkForPreItemDrop(EntityDamageByEntityEvent event) {
+    public void checkForPreItemDrop(EntityDamageByEntityEvent event)
-        if (!(event.getEntity() instanceof LivingEntity entity)) {
+    {
+        if (!(event.getEntity() instanceof LivingEntity entity))
+        {
             return;
         }
 
-        if (!(event.getDamager() instanceof Player player)) {
+        if (!(event.getDamager() instanceof Player player))
+        {
             return;
         }
 
-        if (!(entity.getHealth() <= 0.0)) {
+        if (entity.getHealth() > 0.0)
+        {
             return;
         }
 
@@ -43,8 +49,10 @@ public class ItemDrops extends AbstractListener {
     }
 
     @EventHandler
-    public void checkForDroppedItems(EntityDeathEvent event) {
+    public void checkForDroppedItems(EntityDeathEvent event)
-        if (event.getEntity() instanceof Player) {
+    {
+        if (event.getEntity() instanceof Player)
+        {
             canAffect = false;
             return;
         }
@@ -53,23 +61,32 @@ public class ItemDrops extends AbstractListener {
     }
 
     @EventHandler
-    public void itemDrops(EntityDropItemEvent event) {
+    public void itemDrops(EntityDropItemEvent event)
+    {
         Entity entity = event.getEntity();
 
-        if (entityPlayerMap.get(entity.getUniqueId()) == null) return;
+        if (entityPlayerMap.get(entity.getUniqueId()) == null)
+            return;
 
-        if (!canAffect) return;
+        if (!canAffect)
+            return;
 
         Player player = entityPlayerMap.get(entity.getUniqueId());
         Luck luck = getHandler().getLuckContainer(player);
         Item item = event.getItemDrop();
         ItemStack stack = item.getItemStack();
         int amount = stack.getAmount();
-        if (luck.quickRNG(luck.getValue()) && doesQualify("item_drops", luck.getValue())) {
+        if (luck.quickRNG(luck.getValue()) && doesQualify("item_drops", luck.getValue()))
+        {
             int rng = Luck.RNG().nextInt(2, 5);
             amount += rng;
             stack.setAmount(amount);
             event.getItemDrop().setItemStack(stack);
+
+            if (luck.isVerbose())
+            {
+                asAudience(player).sendMessage(MiniComponent.info("Your luck earned you some extra loot!"));
+            }
         }
     }
 }

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

@@ -21,7 +21,11 @@ public class JumpBoost extends AbstractListener {
         Vector velocity = player.getVelocity().clone();
 
         if (luck.quickRNG(luck.getValue()) && doesQualify("jump_boost", luck.getValue())) {
-            player.setVelocity(new Vector(velocity.getX(), velocity.getY() + 3, velocity.getZ()));
+            player.setVelocity(velocity.multiply(2.5));
+
+            if (luck.isVerbose()) {
+                asAudience(player).sendMessage(MiniComponent.info("Your luck gave you an extra boost to your jump!"));
+            }
         }
     }
 }

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

@@ -3,17 +3,24 @@ 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.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
-import org.bukkit.Tag;
 import org.bukkit.World;
 import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.block.BlockBreakEvent;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
 
-import java.util.stream.Stream;
+import java.util.HashSet;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.Set;
 
+@ApiStatus.Experimental
 public class OreVein extends AbstractListener {
 
     public OreVein(FeelingLucky plugin) {
@@ -22,31 +29,49 @@ public class OreVein extends AbstractListener {
     }
 
     @EventHandler
-    public void playerMine(BlockBreakEvent event) {
+    public void playerMine(@NotNull BlockBreakEvent event) {
         Player player = event.getPlayer();
         Luck luck = plugin.getHandler().getLuckContainer(player);
         if (luck.quickRNG(luck.getValue()) && doesQualify("ore_vein", luck.getValue()) && event.getBlock().isValidTool(player.getInventory().getItemInMainHand())) {
-            getOresInArea(event.getBlock()).forEach(Block::breakNaturally);
+            Material minedBlockType = event.getBlock().getType();
-            player.sendMessage(MiniComponent.info("Your luck has let you mine all the blocks with one swing."));
+            Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
+                getOresInArea(event.getBlock(), minedBlockType).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) {
+    public Set<Block> getOresInArea(@NotNull Block block, Material minedBlockType) {
-        Stream.Builder<Block> streamBuilder = Stream.builder();
+        Set<Block> blocks = new HashSet<>();
-        Location start = block.getLocation();
+        Queue<Block> queue = new LinkedList<>();
-        World world = block.getWorld();
+        Set<Location> visited = new HashSet<>();
-        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);
+        Location initialLocation = block.getLocation();
-        for (int x = start.getBlockX() - 15; x <= start.getBlockX() + 15; x++) {
+
-            for (int y = start.getBlockY() - 15; y <= start.getBlockY() + 15; y++) {
+        queue.add(block);
-                for (int z = start.getBlockZ() - 15; z <= start.getBlockZ() + 15; z++) {
+        visited.add(initialLocation);
-                    Location location = new Location(world, x, y, z);
+
-                    Material blockType = location.getBlock().getType();
+        while (!queue.isEmpty()) {
-                    if (materialStream.anyMatch(o -> o.isTagged(blockType))) {
+            Block currentBlock = queue.poll();
-                        streamBuilder.add(location.getBlock());
+            Location currentLocation = currentBlock.getLocation();
-                    }
+
+            // Check if the current block is within the maximum radius from the initial block
+            if (initialLocation.distance(currentLocation) > 16) {
+                continue;
+            }
+
+            blocks.add(currentBlock);
+
+            for (BlockFace face : BlockFace.values()) {
+                Block neighbour = currentBlock.getRelative(face);
+                Location neighbourLocation = neighbour.getLocation();
+
+                if (!visited.contains(neighbourLocation) && neighbour.getType().equals(minedBlockType)) {
+                    queue.add(neighbour);
+                    visited.add(neighbourLocation);
                 }
             }
         }
-        return streamBuilder.build().filter(b -> b.getType().equals(block.getType()));
+
+        return blocks;
     }
-}
+}

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

@@ -37,15 +37,16 @@ public final class PlayerListener extends AbstractListener {
         Luck luck = getHandler().getLuckContainer(player);
 
         if (timer.onCooldown(player)) {
-            player.sendMessage(MiniComponent.err("That feature can only be used once every 30 seconds."));
+            asAudience(player).sendMessage(MiniComponent.err("That feature can only be used once every 30 seconds."));
-            player.sendMessage(MiniComponent.info("You have " + timer.remaining(player) + " seconds remaining."));
+            asAudience(player).sendMessage(MiniComponent.info("You have " + timer.remaining(player) + " seconds " +
+                                                           "remaining."));
             return;
         }
 
         if (action.isRightClick() && player.getInventory().getItemInMainHand().getType().equals(foot.getType())) {
             if (foot.getItemMeta().equals(special.meta()) || foot.equals(special.get())) {
                 luck.setMultiplier(luck.multiplier() + 0.1);
-                player.sendMessage(MiniComponent.info("Your luck multiplier has increased by 0.1!"));
+                asAudience(player).sendMessage(MiniComponent.info("Your luck multiplier has increased by 0.1!"));
             }
             double rng = Luck.RNG().nextDouble(2.0, 5.0);
             rng = Math.round(rng);
@@ -53,7 +54,7 @@ public final class PlayerListener extends AbstractListener {
             luck.addTo(rng);
             plugin.getHandler().updatePlayer(player, luck);
             timer.setCooldown(player.getUniqueId(), System.currentTimeMillis());
-            player.sendMessage(MiniComponent.info("Your luck has been increased by " + rng + " points."));
+            asAudience(player).sendMessage(MiniComponent.info("Your luck has been increased by " + rng + " points."));
         }
     }
 
@@ -76,7 +77,7 @@ public final class PlayerListener extends AbstractListener {
             if (luck.quickRNG(33.0)) {
                 luck.takeFrom(5.0);
                 plugin.getHandler().updatePlayer(player, luck);
-                player.sendMessage(MiniComponent.warn("Your luck has been decreased by 5 points!"));
+                asAudience(player).sendMessage(MiniComponent.warn("Your luck has been decreased by 5 points!"));
             }
         }
     }

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

@@ -4,22 +4,24 @@ 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 java.util.List;
 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 class RandomEffect extends AbstractListener {
+    public RandomEffect(FeelingLucky plugin)
-    public RandomEffect(FeelingLucky plugin) {
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void giveRandomEffect(PlayerRespawnEvent respawn) {
+    public void giveRandomEffect(PlayerRespawnEvent respawn)
+    {
         Player player = respawn.getPlayer();
         Luck luck = plugin.getHandler().getLuckContainer(player);
 
@@ -27,14 +29,21 @@ public class RandomEffect extends AbstractListener {
         int size = effectList.size();
         PotionEffect random = effectList.get(Luck.RNG().nextInt(size - 1));
 
-        if (luck.quickRNG(luck.getValue()) && doesQualify("random_effect", luck.getValue())) {
+        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."));
+            if (luck.isVerbose())
+            {
+                asAudience(player).sendMessage(
+                    MiniComponent.info("Thanks to luck, a random positive potion effect has " +
+                                       "been applied to you."));
+            }
         }
     }
 
     @EventHandler
-    public void giveRandomEffect(PlayerTeleportEvent tp) {
+    public void giveRandomEffect(PlayerTeleportEvent tp)
+    {
         Player player = tp.getPlayer();
         Luck luck = plugin.getHandler().getLuckContainer(player);
 
@@ -42,9 +51,14 @@ public class RandomEffect extends AbstractListener {
         int size = effectList.size();
         PotionEffect random = effectList.get(Luck.RNG().nextInt(size - 1));
 
-        if (luck.quickRNG(luck.getValue()) && doesQualify("random_effect", luck.getValue())) {
+        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."));
+            if (luck.isVerbose())
+            {
+                asAudience(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

@@ -1,5 +1,6 @@
 package io.github.simplex.luck.listener;
 
+import io.github.simplex.lib.MiniComponent;
 import io.github.simplex.lib.PotionEffectBuilder;
 import io.github.simplex.luck.FeelingLucky;
 import io.github.simplex.luck.player.Luck;
@@ -10,27 +11,44 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
-public class RestoreHunger extends AbstractListener {
+public class RestoreHunger extends AbstractListener
-    public RestoreHunger(FeelingLucky plugin) {
+{
+    public RestoreHunger(FeelingLucky plugin)
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void restoreHunger(PlayerItemConsumeEvent event) {
+    public void restoreHunger(PlayerItemConsumeEvent event)
+    {
         ItemStack item = event.getItem();
         Luck luck = getHandler().getLuckContainer(event.getPlayer());
-        PotionEffect effect = PotionEffectBuilder.newEffect().type(PotionEffectType.SATURATION).amplifier(2).duration(10).particles(false).create();
+        PotionEffect effect = PotionEffectBuilder.newEffect()
-        if (luck.notDefault()) {
+                                                 .type(PotionEffectType.SATURATION)
+                                                 .amplifier(2)
+                                                 .duration(10)
+                                                 .particles(false)
+                                                 .create();
+        if (luck.notDefault())
+        {
             double percentage = luck.getValue();
-            ListBox.foods.forEach(food -> {
+            ListBox.foods.forEach(food ->
-                if (item.isSimilar(food)) {
+                                  {
-                    if (luck.quickRNG(percentage) && doesQualify("restore_hunger", percentage)) {
+                                      if (item.isSimilar(food) && (luck.quickRNG(percentage) && doesQualify(
-                        event.getPlayer().setExhaustion(event.getPlayer().getExhaustion() + 2);
+                                          "restore_hunger", percentage)))
-                        event.getPlayer().addPotionEffect(effect);
+                                      {
-                    }
+                                          event.getPlayer().setExhaustion(event.getPlayer().getExhaustion() + 2);
-                }
+                                          event.getPlayer().addPotionEffect(effect);
-            });
+
+                                      }
+                                  });
+
+            if (luck.isVerbose())
+            {
+                asAudience(event.getPlayer())
+                    .sendMessage(MiniComponent.info("Your luck has restored your hunger a little more."));
+            }
         }
     }
 }

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

@@ -25,8 +25,7 @@ public class TakeDamage extends AbstractListener {
         }
         Player player = (Player) event.getEntity();
         Luck luck = getHandler().getLuckContainer(player);
-        if (ListBox.acceptedCauses.contains(event.getCause())) {
+        if (ListBox.acceptedCauses.contains(event.getCause()) && (luck.notDefault())) {
-            if (luck.notDefault()) {
                 double percentage = luck.getValue();
 
                 /*
@@ -38,7 +37,7 @@ public class TakeDamage extends AbstractListener {
                     if (luck.quickRNG(percentage)) {
                         event.setCancelled(true);
                         player.damage(event.getDamage() * 2);
-                        player.sendMessage(MiniComponent.warn("You were unlucky and took double damage!"));
+                        asAudience(player).sendMessage(MiniComponent.warn("You were unlucky and took double damage!"));
                     }
                     return;
                 }
@@ -47,11 +46,10 @@ public class TakeDamage extends AbstractListener {
                     event.setCancelled(true);
                     player.damage(event.getDamage() / 2);
                 }
-            }
+
         }
 
-        if (ListBox.sideCauses.contains(event.getCause())) {
+        if (ListBox.sideCauses.contains(event.getCause()) && (luck.notDefault())) {
-            if (luck.notDefault()) {
                 double percentage = luck.getValue();
 
                 /*
@@ -71,9 +69,10 @@ public class TakeDamage extends AbstractListener {
                     event.setCancelled(true);
                     player.getActivePotionEffects().removeIf(p -> ListBox.potionEffects.contains(p.getType()));
                     player.setFireTicks(0);
-                    player.sendMessage(MiniComponent.info("You got lucky and your afflictions were cured."));
+                    asAudience(player).sendMessage(MiniComponent.info("You got lucky and your afflictions were cured" +
+                                                                      "."));
                 }
-            }
+
         }
     }
 }

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

@@ -11,30 +11,41 @@ import org.bukkit.inventory.CraftingInventory;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
 
-public class UnbreakableTool extends AbstractListener {
+public class UnbreakableTool extends AbstractListener
-    public UnbreakableTool(FeelingLucky plugin) {
+{
+    public UnbreakableTool(FeelingLucky plugin)
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void unbreakableTool(CraftItemEvent event) {
+    public void unbreakableTool(CraftItemEvent event)
+    {
         CraftingInventory inventory = event.getInventory();
         ItemStack stack = inventory.getResult();
 
-        if (stack == null) return;
+        if (stack == null)
+            return;
         ItemMeta meta = stack.getItemMeta();
 
-        if (ItemBuilder.isTool(stack.getType())) {
+        if (ItemBuilder.isTool(stack.getType()) && (event.getWhoClicked() instanceof Player player))
-            if (event.getWhoClicked() instanceof Player player) {
+        {
-                Luck luck = getHandler().getLuckContainer(player);
+            Luck luck = getHandler().getLuckContainer(player);
-                if (luck.quickRNG(luck.getValue()) && doesQualify("unbreakable", luck.getValue())) {
+            if (luck.quickRNG(luck.getValue()) && doesQualify("unbreakable", luck.getValue()))
-                    meta.setUnbreakable(true);
+            {
-                    stack.setItemMeta(meta);
+                meta.setUnbreakable(true);
-                    inventory.setResult(stack);
+                stack.setItemMeta(meta);
-                    player.sendMessage(MiniComponent.info("By the grace of Luck you have crafted an unbreakable tool!"));
+                inventory.setResult(stack);
+
+                if (luck.isVerbose())
+                {
+                    asAudience(player)
+                        .sendMessage(
+                            MiniComponent.info("By the grace of Luck you have crafted an unbreakable tool!"));
                 }
             }
+
         }
     }
 }

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

@@ -0,0 +1,51 @@
+package io.github.simplex.luck.player;
+
+import java.util.UUID;
+
+public class DynamicConfig {
+    private UUID playerUUID;
+    private String username;
+    private double luckValue;
+    private boolean isVerbose;
+    private double multiplier;
+
+    public String getPlayerUUID() {
+        return playerUUID.toString();
+    }
+
+    public void setPlayerUUID(UUID playerUUID) {
+        this.playerUUID = playerUUID;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public void setUsername(String username) {
+        this.username = username;
+    }
+
+    public double getLuckValue() {
+        return luckValue;
+    }
+
+    public void setLuckValue(double luckValue) {
+        this.luckValue = luckValue;
+    }
+
+    public boolean isVerbose() {
+        return isVerbose;
+    }
+
+    public void setVerbose(boolean isVerbose) {
+        this.isVerbose = isVerbose;
+    }
+
+    public double getMultiplier() {
+        return multiplier;
+    }
+
+    public void setMultiplier(double multiplier) {
+        this.multiplier = multiplier;
+    }
+}

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

@@ -4,10 +4,16 @@ import io.github.simplex.api.LuckContainer;
 import io.github.simplex.luck.FeelingLucky;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffectType;
 import org.jetbrains.annotations.Contract;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.*;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
 
 @SuppressWarnings("all")
 public class Luck implements LuckContainer {
@@ -19,6 +25,7 @@ public class Luck implements LuckContainer {
     private double BASE_VALUE;
     private double multiplier;
     private double tempSave;
+    private boolean verbose;
 
     public Luck(FeelingLucky plugin, Player player) {
         this(plugin, player, 1.0);
@@ -34,10 +41,16 @@ public class Luck implements LuckContainer {
         event = new PlayerLuckChangeEvent(this);
     }
 
+    /**
+     * This creates a new instance of a pseudorandom number generator based off entropy provided by the operating system.
+     * This will allow for a much purer randomization, due to entropy being different for each call.
+     *
+     * @return A new instance of SecureRandom. Each time this method is called a new instance is created to provide maximum variation with entropic calculations.
+     */
     @Contract(pure = true,
             value = "-> new")
-    public static @NotNull SplittableRandom RNG() {
+    public static @NotNull SecureRandom RNG() {
-        return new SplittableRandom();
+        return new SecureRandom(SecureRandom.getSeed(20));
     }
 
     public static boolean quickRNGnoMultiplier(double value) {
@@ -53,6 +66,10 @@ public class Luck implements LuckContainer {
         return (value >= actual);
     }
 
+    public boolean playerHasLuckPE() {
+        return player.hasPotionEffect(PotionEffectType.LUCK);
+    }
+
     public FeelingLucky getPlugin() {
         return plugin;
     }
@@ -69,6 +86,23 @@ public class Luck implements LuckContainer {
         return markedPlayers.contains(player);
     }
 
+    @Override
+    public void setVerbose(final boolean verbose) {
+        if (!plugin.getConfig().isVerboseGlobal())
+            return;
+
+        this.verbose = verbose;
+    }
+
+    @Override
+    public boolean isVerbose() {
+        if (plugin.getConfig().isVerboseGlobal()) {
+            return verbose;
+        }
+
+        return false;
+    }
+
     @Override
     public boolean isMatch(double number) {
         return getValue() == number;
@@ -89,6 +123,12 @@ public class Luck implements LuckContainer {
         return player;
     }
 
+    /**
+     * Quickly calculate whether or not the player has enough luck to trigger the condition.
+     *
+     * @param value The players luck value.
+     * @return True if the player meets the criteria, false if they do not.
+     */
     public boolean quickRNG(double value) {
         double rng;
         if (value >= 1024.0) {
@@ -97,13 +137,19 @@ public class Luck implements LuckContainer {
             rng = RNG().nextDouble(0.0, 1024.0);
         }
 
+        AtomicReference<Double> multiplier = new AtomicReference<>(multiplier());
         double actual = Math.round((rng / 1024) * 100);
+        double newVal = Math.round((value / 1024) * 100);
 
-        if (multiplier() > 1.0) {
+        if (playerHasLuckPE()) {
-            return ((value * multiplier()) >= actual);
+            player.getActivePotionEffects()
+                    .stream()
+                    .filter(p -> p.getType().equals(PotionEffectType.LUCK))
+                    .findFirst()
+                    .ifPresent(p -> multiplier.updateAndGet(v -> (v + p.getAmplifier())));
         }
 
-        return (value >= actual);
+        return ((newVal * multiplier.get()) >= actual);
     }
 
     public void reset() {

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

@@ -1,106 +1,209 @@
 package io.github.simplex.luck.player;
 
 import io.github.simplex.luck.FeelingLucky;
-import io.github.simplex.luck.util.SneakyWorker;
+import io.github.simplex.luck.util.Logs;
+import java.io.File;
+import java.io.IOException;
+import java.util.UUID;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
-import org.bukkit.attribute.Attribute;
+import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
 
-import java.io.BufferedWriter;
+public class PlayerConfig
-import java.io.File;
+{
-import java.io.FileWriter;
-import java.nio.charset.StandardCharsets;
-import java.util.UUID;
-
-public class PlayerConfig {
     private final File configFile;
     private final OfflinePlayer player;
-    private volatile YamlConfiguration config;
+    private final FeelingLucky plugin;
+    private YamlConfiguration config;
 
-    @SuppressWarnings("ResultOfMethodCallIgnored")
+
-    public PlayerConfig(FeelingLucky plugin, Player player) {
+    public PlayerConfig(FeelingLucky plugin, Player player)
+    {
+        this.plugin = plugin;
         this.player = player;
-        if (!plugin.getDataFolder().exists()) plugin.getDataFolder().mkdirs();
+        configFile = configFile(plugin, player);
-        File dataFolder = new File(plugin.getDataFolder(), "players");
-        if (!dataFolder.exists()) dataFolder.mkdirs();
-        File file = new File(dataFolder, player.getUniqueId() + ".yml");
-        if (!file.exists()) {
-            String name = "username: " + player.getName();
-            String luck = "luck: " + 0;
-            String multiplier = "multiplier: " + 1.0;
-
-            SneakyWorker.sneakyTry(() -> {
-                file.createNewFile();
-
-                BufferedWriter writer = new BufferedWriter(new FileWriter(file, StandardCharsets.UTF_8));
-                writer.write(name);
-                writer.newLine();
-                writer.write(luck);
-                writer.newLine();
-                writer.write(multiplier);
-                writer.close();
-            });
-        }
-        configFile = file;
         config = YamlConfiguration.loadConfiguration(configFile);
 
         String tempUsername = config.getString("username");
 
-        if (tempUsername == null) {
+        if (tempUsername == null)
+        {
             config.set("username", player.getName());
             config.set("luck", plugin.getHandler().getLuckContainer(player).getDefaultValue());
             config.set("multiplier", "1.0");
+            config.set("verbose", plugin.getConfig().isVerboseGlobal());
             save();
         }
     }
 
-    protected PlayerConfig(FeelingLucky plugin, File file) {
+    protected PlayerConfig(FeelingLucky plugin, File file)
+    {
+        this.plugin = plugin;
         this.configFile = file;
         this.player = Bukkit.getOfflinePlayer(UUID.fromString(file.getName().split("\\.")[0]));
         config = YamlConfiguration.loadConfiguration(configFile);
     }
 
+    protected PlayerConfig(FeelingLucky plugin, DynamicConfig user)
+    {
+        this.plugin = plugin;
+        this.player = Bukkit.getOfflinePlayer(UUID.fromString(user.getPlayerUUID()));
+        configFile = configFile(plugin, player);
+        config = YamlConfiguration.loadConfiguration(configFile);
+    }
+
     @Contract("_, _ -> new")
-    public static PlayerConfig initFrom(FeelingLucky plugin, File file) {
+    public static PlayerConfig initFromFile(FeelingLucky plugin, File file)
+    {
         return new PlayerConfig(plugin, file);
     }
 
-    public void save() {
+    public static PlayerConfig fromDynamicConfig(FeelingLucky plugin, DynamicConfig config)
-        SneakyWorker.sneakyTry(() -> config.save(configFile));
+    {
+        PlayerConfig playerConfig = new PlayerConfig(plugin, config);
+        playerConfig.setUsername(config.getPlayerUUID());
+        playerConfig.setLuck(config.getLuckValue());
+        playerConfig.setMultiplier(config.getMultiplier());
+        playerConfig.setVerbose(config.isVerbose());
+        return playerConfig;
     }
 
-    public void load() {
+    public DynamicConfig toDynamicConfig()
-        SneakyWorker.sneakyTry(() -> config = YamlConfiguration.loadConfiguration(configFile));
+    {
+        DynamicConfig dynamicConfig = new DynamicConfig();
+        dynamicConfig.setPlayerUUID(player.getUniqueId());
+        dynamicConfig.setLuckValue(getLuck());
+        dynamicConfig.setVerbose(isVerbose());
+        dynamicConfig.setMultiplier(getMultiplier());
+        return dynamicConfig;
     }
 
-    public void reload() {
+    @SuppressWarnings("ResultOfMethodCallIgnored")
+    @NotNull
+    private File configFile(FeelingLucky plugin, OfflinePlayer player)
+    {
+        if (!plugin.getDataFolder().exists())
+            plugin.getDataFolder().mkdirs();
+        File dataFolder = new File(plugin.getDataFolder(), "players");
+        if (!dataFolder.exists())
+            dataFolder.mkdirs();
+        File file = new File(dataFolder, player.getUniqueId() + ".yml");
+        if (!file.exists())
+        {
+            try
+            {
+                file.createNewFile();
+                final YamlConfiguration v0 = new YamlConfiguration();
+                v0.set("username", player.getName());
+                v0.set("luck", 0);
+                v0.set("multiplier", 1.0);
+                v0.set("verbose", plugin.getConfig().isVerboseGlobal());
+                v0.save(file);
+            }
+            catch (IOException ex)
+            {
+                Logs.error(ex);
+            }
+        }
+        return file;
+    }
+
+    public void save()
+    {
+        try
+        {
+            config.save(configFile);
+        }
+        catch (IOException ex)
+        {
+            Logs.error(ex);
+        }
+    }
+
+    public void load()
+    {
+        try
+        {
+            config.load(configFile);
+        }
+        catch (IOException | InvalidConfigurationException ex)
+        {
+            Logs.error(ex);
+
+            Logs.warn("Attempting to reinitialize variable... this is dangerous!");
+
+            try
+            {
+                config = YamlConfiguration.loadConfiguration(configFile);
+            }
+            catch (IllegalArgumentException th)
+            {
+                Logs.error(th);
+            }
+
+        }
+    }
+
+    public void reload()
+    {
         save();
         load();
     }
 
-    public OfflinePlayer getPlayer() {
+    public OfflinePlayer getPlayer()
+    {
         return player;
     }
 
-    public void setUsername(String name) {
+    public String getUsername() {
-        config.set("username", name);
+        return config.getString("username");
-        save();
     }
 
-    public void setLuck(double luck) {
+    public double getLuck()
+    {
+        return config.getDouble("luck");
+    }
+
+    public void setLuck(double luck)
+    {
         config.set("luck", luck);
-        save();
+        reload();
     }
 
-    public void setMultiplier(double multiplier) {
+    public double getMultiplier()
+    {
+        return config.getDouble("multiplier");
+    }
+
+    public void setMultiplier(double multiplier)
+    {
         config.set("multiplier", multiplier);
-        save();
+        reload();
     }
 
-    public YamlConfiguration getConfig() {
+    public boolean isVerbose()
+    {
+        return config.getBoolean("verbose");
+    }
+
+    public void setVerbose(final boolean verbose)
+    {
+        config.set("verbose", verbose);
+        reload();
+    }
+
+    public void setUsername(String name)
+    {
+        config.set("username", name);
+        reload();
+    }
+
+    public YamlConfiguration getConfig()
+    {
         return config;
     }
 }

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

@@ -1,6 +1,7 @@
 package io.github.simplex.luck.player;
 
 import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.sql.SQLType;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -38,9 +39,10 @@ public class PlayerHandler implements Listener {
             plugin.getConfigMap().put(player.getUniqueId(), playerConfig);
         }
 
-        String username = playerConfig.getConfig().getString("username");
+        String username = playerConfig.getUsername();
-        double luck = playerConfig.getConfig().getDouble("luck");
+        double luck = playerConfig.getLuck();
-        double multiplier = playerConfig.getConfig().getDouble("multiplier");
+        double multiplier = playerConfig.getMultiplier();
+        boolean verbose = plugin.getConfig().isVerboseGlobal() && playerConfig.isVerbose();
 
         if (!player.getName().equalsIgnoreCase(username)) {
             playerConfig.getConfig().set("username", player.getName());
@@ -49,6 +51,7 @@ public class PlayerHandler implements Listener {
         }
 
         Luck container = new Luck(plugin, player, multiplier);
+        container.setVerbose(verbose);
         container.setValue(luck);
 
         playerLuckMap.put(player, container);

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

@@ -0,0 +1,52 @@
+package io.github.simplex.luck.util;
+
+import org.apache.commons.lang3.exception.ExceptionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class Logs
+{
+    private static final Logger logger = LoggerFactory.getLogger("FeelingLucky");
+
+    private Logs()
+    {
+        throw new AssertionError();
+    }
+
+    public static void info(String message)
+    {
+        logger.info(message);
+    }
+
+    public static void warn(String message)
+    {
+        logger.warn(message);
+    }
+
+    public static void warn(String message, Throwable th)
+    {
+        logger.warn(message, th);
+    }
+
+    public static void warn(Throwable th)
+    {
+        final String msg = ExceptionUtils.getRootCauseMessage(th);
+        logger.warn(msg);
+    }
+
+    public static void error(String message)
+    {
+        logger.error(message);
+    }
+
+    public static void error(String message, Throwable th)
+    {
+        logger.error(message, th);
+    }
+
+    public static void error(Throwable th)
+    {
+        final String msg = ExceptionUtils.getRootCauseMessage(th);
+        logger.error(msg, th);
+    }
+}

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

@@ -114,6 +114,23 @@ public class LuckCMD extends Command implements TabCompleter, PluginIdentifiable
                     return true;
                 }
 
+                if (args[0].equalsIgnoreCase("verbose") && sender instanceof Player player) {
+
+                    if (!plugin.getConfig().isVerboseGlobal()) {
+                        player.sendMessage(Messages.VERBOSE_DISABLED.get());
+                        return true;
+                    }
+
+                    final boolean a1 = Boolean.parseBoolean(args[1]);
+                    Luck luck = plugin.getHandler().getLuckContainer(player);
+                    PlayerConfig config = plugin.getConfigMap().get(player.getUniqueId());
+                    luck.setVerbose(a1);
+                    plugin.getHandler().updatePlayer(player, luck);
+                    config.setVerbose(a1);
+                    sender.sendMessage(MiniComponent.info("Verbose mode set to " + a1 + "."));
+                    return true;
+                }
+
                 if (args[0].equalsIgnoreCase("reset")) {
                     Player player = Bukkit.getPlayer(args[1]);
 

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

@@ -21,7 +21,7 @@ public class SneakyWorker {
                     + ex.getClass().getSimpleName()
                     + " has occurred. A cause will be printed. \n\n"
                     + ex.getCause();
-            Bukkit.getLogger().severe(sb);
+            Logs.error(sb);
         }
     }
 

src/main/java/io/github/simplex/sql/MySQL.java

@@ -0,0 +1,94 @@
+package io.github.simplex.sql;
+
+import io.github.simplex.luck.Config;
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.player.DynamicConfig;
+import io.github.simplex.luck.player.PlayerConfig;
+import io.github.simplex.luck.util.Logs;
+import io.github.simplex.sql.users.MySQLUser;
+
+import java.sql.*;
+import java.util.UUID;
+
+public class MySQL {
+
+    private final Connection connection;
+    private final FeelingLucky plugin;
+
+    public MySQL(FeelingLucky plugin) throws SQLException {
+        this.plugin = plugin;
+
+        Config.MySQLWrapper mySQLWrapper = plugin.getConfig().getMySQL();
+        String host = mySQLWrapper.getHost();
+        int port = mySQLWrapper.getPort();
+        String database = mySQLWrapper.getDatabase();
+        String username = mySQLWrapper.getUsername();
+        String password = mySQLWrapper.getPassword();
+
+        connection = DriverManager.getConnection("jdbc:mysql://" + host + ":" + port + "/" + database, username, password);
+        if (connection != null) {
+            try (PreparedStatement statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS PlayerConfig (playerUUID VARCHAR(36), username VARCHAR(16), luckValue DOUBLE, isVerbose BOOLEAN, multiplier DOUBLE)")) {
+                statement.execute();
+            }
+        }
+    }
+
+    public Connection getConnection() {
+        return connection;
+    }
+
+    public void loadPlayers() {
+        try (PreparedStatement statement = connection.prepareStatement("SELECT * FROM PlayerConfig");
+             ResultSet resultSet = statement.executeQuery()) {
+
+            while (resultSet.next()) {
+                String playerUUID = resultSet.getString("playerUUID");
+                MySQLUser mySQLUser = new MySQLUser(connection, UUID.fromString(playerUUID));
+                DynamicConfig userConfig = mySQLUser.loadUserConfig();
+                PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
+                plugin.getConfigMap().put(UUID.fromString(playerUUID), playerConfig);
+            }
+        } catch (SQLException e) {
+            Logs.error(e);
+        }
+    }
+
+    public void savePlayer(final PlayerConfig playerConfig) {
+        MySQLUser mySQLUser = new MySQLUser(connection, playerConfig.getPlayer().getUniqueId());
+        mySQLUser.saveUserConfig(playerConfig.toDynamicConfig());
+    }
+
+    public void loadPlayer(final UUID playerUUID) {
+        try (PreparedStatement statement = connection.prepareStatement("SELECT * FROM PlayerConfig WHERE playerUUID = ?")) {
+            statement.setString(1, playerUUID.toString());
+            try (ResultSet resultSet = statement.executeQuery()) {
+                if (resultSet.next()) {
+                    MySQLUser mySQLUser = new MySQLUser(connection, playerUUID);
+                    DynamicConfig userConfig = mySQLUser.loadUserConfig();
+                    PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
+                    plugin.getConfigMap().put(playerUUID, playerConfig);
+                }
+            }
+        } catch (SQLException e) {
+            Logs.error(e);
+        }
+    }
+
+    public void savePlayers() {
+        for (UUID playerUUID : plugin.getConfigMap().keySet()) {
+            PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
+            MySQLUser mySQLUser = new MySQLUser(connection, playerUUID);
+            mySQLUser.saveUserConfig(playerConfig.toDynamicConfig());
+        }
+    }
+
+    public void closeConnection() {
+        if (connection != null) {
+            try {
+                connection.close();
+            } catch (SQLException e) {
+                Logs.error(e);
+            }
+        }
+    }
+}

src/main/java/io/github/simplex/sql/Redis.java

@@ -0,0 +1,77 @@
+package io.github.simplex.sql;
+
+import io.github.simplex.luck.Config;
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.player.DynamicConfig;
+import io.github.simplex.luck.player.PlayerConfig;
+import io.github.simplex.sql.users.RedisUser;
+
+import java.util.Set;
+import java.util.UUID;
+
+public class Redis {
+
+    private final redis.clients.jedis.Jedis jedis;
+    private final FeelingLucky plugin;
+
+    public Redis(final FeelingLucky plugin) {
+        this.plugin = plugin;
+
+        final Config.RedisWrapper redisWrapper = plugin.getConfig().getRedis();
+        final String host = redisWrapper.getHost();
+        final String password = redisWrapper.getPassword();
+        final String port = redisWrapper.getPort();
+        final int database = redisWrapper.getDatabase();
+
+        jedis = new redis.clients.jedis.Jedis(host, Integer.parseInt(port));
+        jedis.auth(password);
+        jedis.select(database);
+    }
+
+    public redis.clients.jedis.Jedis getJedis() {
+        return jedis;
+    }
+
+    public void closeConnection() {
+        jedis.close();
+    }
+
+    public void loadPlayers() {
+        Set<String> playerUUIDs = jedis.keys("*");
+        for (String playerUUID : playerUUIDs) {
+            RedisUser redisUser = new RedisUser(jedis, UUID.fromString(playerUUID));
+            DynamicConfig userConfig = redisUser.loadUserConfig();
+
+            // Create a new PlayerConfig instance with the loaded data
+            PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
+
+            // Add the PlayerConfig instance to the map
+            plugin.getConfigMap().put(UUID.fromString(playerUUID), playerConfig);
+        }
+    }
+
+    public void savePlayers() {
+        for (UUID playerUUID : plugin.getConfigMap().keySet()) {
+            PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
+            RedisUser redisUser = new RedisUser(jedis, playerUUID);
+            redisUser.saveUserConfig(playerConfig.toDynamicConfig());
+        }
+    }
+
+    public void loadPlayer(UUID playerUUID) {
+        RedisUser redisUser = new RedisUser(jedis, playerUUID);
+        DynamicConfig userConfig = redisUser.loadUserConfig();
+
+        // Create a new PlayerConfig instance with the loaded data
+        PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
+
+        // Add the PlayerConfig instance to the map
+        plugin.getConfigMap().put(playerUUID, playerConfig);
+    }
+
+    public void savePlayer(UUID playerUUID) {
+        PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
+        RedisUser redisUser = new RedisUser(jedis, playerUUID);
+        redisUser.saveUserConfig(playerConfig.toDynamicConfig());
+    }
+}

src/main/java/io/github/simplex/sql/SQLType.java

@@ -0,0 +1,17 @@
+package io.github.simplex.sql;
+
+public enum SQLType {
+    SQLITE,
+    MYSQL,
+    REDIS,
+    NONE;
+
+    public static SQLType fromString(String type) {
+        return switch (type.toLowerCase()) {
+            case "sqlite" -> SQLITE;
+            case "mysql" -> MYSQL;
+            case "redis" -> REDIS;
+            default -> NONE;
+        };
+    }
+}

src/main/java/io/github/simplex/sql/SQLite.java

@@ -0,0 +1,83 @@
+package io.github.simplex.sql;
+
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.player.DynamicConfig;
+import io.github.simplex.luck.player.PlayerConfig;
+import io.github.simplex.luck.util.Logs;
+import io.github.simplex.sql.users.SQLiteUser;
+
+import java.sql.*;
+import java.util.UUID;
+
+public class SQLite {
+
+    private final Connection connection;
+    private final FeelingLucky plugin;
+
+    public SQLite(final FeelingLucky plugin) throws SQLException {
+        this.plugin = plugin;
+        final String databaseFilePath = plugin.getConfig().getSQLite().getPath();
+
+        connection = DriverManager.getConnection("jdbc:sqlite:" + databaseFilePath);
+        if (connection != null) createTable();
+    }
+
+    public Connection getConnection() {
+        return connection;
+    }
+
+    public void closeConnection() throws SQLException {
+        if (connection != null) {
+            connection.close();
+        }
+    }
+
+    public void createTable() throws SQLException {
+        try (PreparedStatement statement = connection.prepareStatement("CREATE TABLE IF NOT EXISTS PlayerConfig (playerUUID VARCHAR(36), username VARCHAR(16), luckValue DOUBLE, isVerbose BOOLEAN, multiplier DOUBLE)")) {
+            statement.execute();
+        }
+    }
+
+    public void loadPlayers() throws SQLException {
+        try (PreparedStatement statement = connection.prepareStatement("SELECT playerUUID FROM PlayerConfig");
+             ResultSet resultSet = statement.executeQuery()) {
+
+            while (resultSet.next()) {
+                UUID playerUUID = UUID.fromString(resultSet.getString("playerUUID"));
+                SQLiteUser sqliteUser = new SQLiteUser(connection, playerUUID);
+                DynamicConfig userConfig = sqliteUser.loadUserConfig();
+
+                // Create a new PlayerConfig instance with the loaded data
+                PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
+
+                // Add the PlayerConfig instance to the map
+                plugin.getConfigMap().put(playerUUID, playerConfig);
+            }
+        }
+    }
+
+    public void savePlayers() throws SQLException {
+        for (UUID playerUUID : plugin.getConfigMap().keySet()) {
+            PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
+            SQLiteUser sqliteUser = new SQLiteUser(connection, playerUUID);
+            sqliteUser.saveUserConfig(playerConfig.toDynamicConfig());
+        }
+    }
+
+    public void loadPlayer(UUID playerUUID) throws SQLException {
+        SQLiteUser sqliteUser = new SQLiteUser(connection, playerUUID);
+        DynamicConfig userConfig = sqliteUser.loadUserConfig();
+
+        // Create a new PlayerConfig instance with the loaded data
+        PlayerConfig playerConfig = PlayerConfig.fromDynamicConfig(plugin, userConfig);
+
+        // Add the PlayerConfig instance to the map
+        plugin.getConfigMap().put(playerUUID, playerConfig);
+    }
+
+    public void savePlayer(UUID playerUUID) throws SQLException {
+        PlayerConfig playerConfig = plugin.getConfigMap().get(playerUUID);
+        SQLiteUser sqliteUser = new SQLiteUser(connection, playerUUID);
+        sqliteUser.saveUserConfig(playerConfig.toDynamicConfig());
+    }
+}

src/main/java/io/github/simplex/sql/users/MySQLUser.java

@@ -0,0 +1,67 @@
+package io.github.simplex.sql.users;
+
+import io.github.simplex.luck.player.DynamicConfig;
+import io.github.simplex.luck.util.Logs;
+import org.bukkit.Bukkit;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.UUID;
+
+public class MySQLUser {
+
+    private final Connection connection;
+    private final String playerUUID;
+
+    public MySQLUser(Connection connection, UUID playerUUID) {
+        this.connection = connection;
+        this.playerUUID = playerUUID.toString();
+    }
+
+    public DynamicConfig loadUserConfig() {
+        DynamicConfig config = new DynamicConfig();
+        try {
+            PreparedStatement statement = connection.prepareStatement(
+                    "SELECT * FROM PlayerConfig WHERE playerUUID = ?"
+            );
+            statement.setString(1, playerUUID);
+
+            ResultSet resultSet = statement.executeQuery();
+
+            if (resultSet.next()) {
+                config.setPlayerUUID(UUID.fromString(resultSet.getString("uuid")));
+                config.setUsername(Bukkit.getOfflinePlayer(UUID.fromString(resultSet.getString("uuid"))).getName());
+                config.setLuckValue(resultSet.getInt("luckValue"));
+                config.setVerbose(resultSet.getBoolean("isVerbose"));
+                config.setMultiplier(resultSet.getDouble("multiplier"));
+            }
+        } catch (SQLException e) {
+            Logs.error(e);
+        }
+        return config;
+    }
+
+    public void saveUserConfig(DynamicConfig config) {
+        try {
+            PreparedStatement statement = connection.prepareStatement(
+                    "INSERT INTO PlayerConfig (playerUUID, username, luckValue, isVerbose, multiplier) VALUES (?, ?, ?, ?, ?) " +
+                            "ON DUPLICATE KEY UPDATE username = ?, luckValue = ?, isVerbose = ?, multiplier = ?"
+            );
+            statement.setString(1, playerUUID);
+            statement.setString(2, config.getUsername());
+            statement.setDouble(3, config.getLuckValue());
+            statement.setBoolean(4, config.isVerbose());
+            statement.setDouble(5, config.getMultiplier());
+            statement.setString(6, config.getUsername());
+            statement.setDouble(7, config.getLuckValue());
+            statement.setBoolean(8, config.isVerbose());
+            statement.setDouble(9, config.getMultiplier());
+
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            Logs.error(e);
+        }
+    }
+}

src/main/java/io/github/simplex/sql/users/RedisUser.java

@@ -0,0 +1,37 @@
+package io.github.simplex.sql.users;
+
+import io.github.simplex.luck.player.DynamicConfig;
+import org.bukkit.Bukkit;
+import redis.clients.jedis.Jedis;
+
+import java.util.UUID;
+
+public class RedisUser {
+
+    private final Jedis jedis;
+    private final String playerUUID;
+
+    public RedisUser(Jedis jedis, UUID playerUUID) {
+        this.jedis = jedis;
+        this.playerUUID = playerUUID.toString();
+    }
+
+    public DynamicConfig loadUserConfig() {
+        DynamicConfig config = new DynamicConfig();
+        config.setPlayerUUID(UUID.fromString(jedis.hget(playerUUID, "uuid")));
+        config.setUsername(Bukkit.getOfflinePlayer(UUID.fromString(jedis.hget(playerUUID, "username"))).getName());
+        config.setLuckValue(Integer.parseInt(jedis.hget(playerUUID, "luckValue")));
+        config.setVerbose(Boolean.parseBoolean(jedis.hget(playerUUID, "isVerbose")));
+        config.setMultiplier(Double.parseDouble(jedis.hget(playerUUID, "multiplier")));
+
+        return config;
+    }
+
+    public void saveUserConfig(DynamicConfig config) {
+        jedis.hset(playerUUID, "uuid", config.getPlayerUUID());
+        jedis.hset(playerUUID, "username", config.getUsername());
+        jedis.hset(playerUUID, "luckValue", String.valueOf(config.getLuckValue()));
+        jedis.hset(playerUUID, "isVerbose", String.valueOf(config.isVerbose()));
+        jedis.hset(playerUUID, "multiplier", String.valueOf(config.getMultiplier()));
+    }
+}

src/main/java/io/github/simplex/sql/users/SQLiteUser.java

@@ -0,0 +1,65 @@
+package io.github.simplex.sql.users;
+
+import io.github.simplex.luck.player.DynamicConfig;
+import io.github.simplex.luck.util.Logs;
+import org.bukkit.Bukkit;
+
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.util.UUID;
+
+public class SQLiteUser {
+
+    private final Connection connection;
+    private final String playerUUID;
+
+    public SQLiteUser(Connection connection, UUID playerUUID) {
+        this.connection = connection;
+        this.playerUUID = playerUUID.toString();
+    }
+
+    public DynamicConfig loadUserConfig() {
+        DynamicConfig config = new DynamicConfig();
+        try {
+            PreparedStatement statement = connection.prepareStatement(
+                    "SELECT * FROM PlayerConfig WHERE playerUUID = ?"
+            );
+            statement.setString(1, playerUUID);
+
+            ResultSet resultSet = statement.executeQuery();
+
+            if (resultSet.next()) {
+                config.setPlayerUUID(UUID.fromString(resultSet.getString("playerUUID")));
+                config.setUsername(
+                        Bukkit.getOfflinePlayer(
+                                UUID.fromString(
+                                        resultSet.getString("playerUUID")))
+                                .getName());
+                config.setLuckValue(resultSet.getDouble("luckValue"));
+                config.setVerbose(resultSet.getBoolean("isVerbose"));
+                config.setMultiplier(resultSet.getDouble("multiplier"));
+            }
+        } catch (SQLException e) {
+            Logs.error(e);
+        }
+        return config;
+    }
+
+    public void saveUserConfig(DynamicConfig config) {
+        try {
+            PreparedStatement statement = connection.prepareStatement(
+                    "INSERT INTO PlayerConfig (playerUUID, username, luckValue, isVerbose, multiplier) VALUES (?, ?, ?, ?, ?)"
+            );
+            statement.setString(1, playerUUID);
+            statement.setString(2, config.getUsername());
+            statement.setDouble(3, config.getLuckValue());
+            statement.setBoolean(4, config.isVerbose());
+            statement.setDouble(5, config.getMultiplier());
+            statement.executeUpdate();
+        } catch (SQLException e) {
+            Logs.error(e);
+        }
+    }
+}

src/main/resources/config.yml

@@ -8,14 +8,19 @@ high_rarity_chance: 512.0
 medium_rarity_chance: 128.0
 low_rarity_chance: 64.0
 
+# Change whether verbosity is enabled globally or not.
+# If the verbosity is set to true, then all players will have the option to turn it off for themselves only.
+# If the verbosity is set to false, then players will not have the option to turn it on.
+global_verbosity: true
+
 # The following entries are for the rarity level of each event trigger.
 # This will determine which rarity chance to use which ensures players
 # The following values are accepted: NONE, LOW, MED, HIGH
-#     - None implies that there is no rarity chance attributed to that feature.
+#- None implies that there is no rarity chance attributed to that feature.
 # These entries are case-sensitive.
 
 block_drops: LOW
-bonemeal: MED
+bone_meal: MED
 cheat_death: MED
 enchanting: HIGH
 experience: HIGH
@@ -27,4 +32,29 @@ ore_vein: HIGH
 random_effect: HIGH
 restore_hunger: NONE
 take_damage: MED
-unbreakable: HIGH
+unbreakable: HIGH
+
+# This section is for Database storage.
+# If you wish to use a database, you must fill out the following information.
+
+#database_types: MYSQL, SQLITE, REDIS, NONE
+database_type: NONE
+
+# MySQL Database
+mysql:
+  host: localhost
+  port: 3306
+  database: minecraft
+  username: root
+  password: password
+
+# SQLite Database
+sqlite:
+  path: database.db
+
+# Redis Database
+redis:
+  host: localhost
+  port: 6379
+  password: password
+  database: 0