1.4.0 Update

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

README.md

@@ -1,4 +1,4 @@
-# <center>FeelingLucky v1.2.0 - A luck driven mechanics plugin.</center>
+# <center>FeelingLucky v1.3.0 - A luck driven mechanics plugin.</center>
 
 ## <center><u><span style="color:blue">Plugin Description:</u></center>
 

build.gradle

@@ -3,7 +3,7 @@ plugins {
 }
 
 group = 'io.github.simplex'
-version = '1.2.1'
+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")
-public class Config extends YamlConfiguration {
-    private final Map<String, Object> configEntries = new HashMap<>() {{
+import io.github.simplex.sql.SQLType;
+import org.bukkit.configuration.file.YamlConfiguration;
+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. " +
-                    "\nPlease use /rgc in the console to regenerate the config file. " +
-                    "\nAlternatively, delete the config.yml and restart your server. " +
-                    "\nIt is safe to ignore this, as default values will be used." +
-                    "\nHowever, it is highly recommended to regenerate the configuration.");
+            Logs.warn("Your configuration file is missing keys. " +
+                      "\nPlease use /rgc in the console to regenerate the config file. " +
+                      "\nAlternatively, delete the config.yml and restart your server. " +
+                      "\nIt is safe to ignore this, as default values will be used." +
+                      "\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()) {
-            if (!disk.getKeys(false).contains(key)) {
-                if (result) result = false;
+        for (String key : configEntries.keySet())
+        {
+            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...");
-        handler = new PlayerHandler(this);
+        getLogger().info("Metrics loaded. Initializing SQL...");
+        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 BlockDrops(FeelingLucky plugin) {
+public final class BlockDrops extends AbstractListener
+{
+    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 CheatDeath(FeelingLucky plugin) {
+public final class CheatDeath extends AbstractListener
+{
+    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;
-import java.util.Map;
-
-public final class EnchantmentBoost extends AbstractListener {
-    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 ExpBoost(FeelingLucky plugin) {
+public final class ExpBoost extends AbstractListener
+{
+    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 GiveDamage(FeelingLucky plugin) {
+public class GiveDamage extends AbstractListener
+{
+    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 Map<Player, List<Entity>> entityMapList = new HashMap<>();
-
-    public HideCheck(FeelingLucky plugin) {
+public class HideCheck extends AbstractListener
+{
+    public HideCheck(FeelingLucky plugin)
+    {
         super(plugin);
         register(this);
     }
 
     @EventHandler
-    public void initPlayerMaps(PlayerJoinEvent event) {
-        entityMapList.put(event.getPlayer(), List.of());
-    }
+    public void checkForSneak(PlayerToggleSneakEvent event)
+    {
+        Player player = event.getPlayer();
+        if (player.isSneaking())
+            return;
 
-    @EventHandler
-    public void checkTargeting(EntityTargetLivingEntityEvent event) {
-        if (event.getTarget() instanceof Player player) {
-            if (event.getEntity() instanceof LivingEntity entity) {
-                List<Entity> buffer = entityMapList.get(player).isEmpty() ?
-                        new ArrayList<>() : entityMapList.get(player);
-                buffer.add(entity);
-                entityMapList.replace(player, buffer);
+        Luck luck = plugin.getHandler().getLuckContainer(player);
+        if (luck.quickRNG(luck.getValue()) && doesQualify("hide_check", luck.getValue()))
+        {
+            player.getNearbyEntities(25, 25, 25)
+                  .stream()
+                  .filter(e -> e instanceof Monster)
+                  .map(e -> (Monster) e)
+                  .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 IllOmen(FeelingLucky plugin) {
+public class IllOmen extends AbstractListener
+{
+    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."));
-        } else if (luck.cached(player) && !player.hasPotionEffect(type)) {
+            asAudience(player).sendMessage(MiniComponent.info("A -25% debuff has been applied to your luck from the " +
+                                                              "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.getEntity() instanceof Player player) {
+        if (event.getCause().equals(cause) && (event.getAction().equals(added) || event.getAction().equals(changed)))
+        {
+            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 ((event.getEntity() instanceof Player player)) {
+        if (old.getType().equals(PotionEffectType.BAD_OMEN) && (event.getAction().equals(cleared) || event.getAction()
+                                                                                                          .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) {
-        if (event.getPlayer().hasPotionEffect(PotionEffectType.BAD_OMEN)) {
+    public void disconnectCheck(PlayerQuitEvent event)
+    {
+        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;
-import java.util.Map;
-import java.util.UUID;
-
-public class ItemDrops extends AbstractListener {
+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) {
-        if (!(event.getEntity() instanceof LivingEntity entity)) {
+    public void checkForPreItemDrop(EntityDamageByEntityEvent event)
+    {
+        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) {
-        if (event.getEntity() instanceof Player) {
+    public void checkForDroppedItems(EntityDeathEvent event)
+    {
+        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);
-            player.sendMessage(MiniComponent.info("Your luck has let you mine all the blocks with one swing."));
+            Material minedBlockType = event.getBlock().getType();
+            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) {
-        Stream.Builder<Block> streamBuilder = Stream.builder();
-        Location start = block.getLocation();
-        World world = block.getWorld();
-        Stream<Tag<Material>> materialStream = Stream.of(Tag.COAL_ORES, Tag.COPPER_ORES, Tag.DIAMOND_ORES, Tag.GOLD_ORES, Tag.IRON_ORES, Tag.EMERALD_ORES, Tag.LAPIS_ORES, Tag.REDSTONE_ORES);
-        for (int x = start.getBlockX() - 15; x <= start.getBlockX() + 15; x++) {
-            for (int y = start.getBlockY() - 15; y <= start.getBlockY() + 15; y++) {
-                for (int z = start.getBlockZ() - 15; z <= start.getBlockZ() + 15; z++) {
-                    Location location = new Location(world, x, y, z);
-                    Material blockType = location.getBlock().getType();
-                    if (materialStream.anyMatch(o -> o.isTagged(blockType))) {
-                        streamBuilder.add(location.getBlock());
-                    }
+    public Set<Block> getOresInArea(@NotNull Block block, Material minedBlockType) {
+        Set<Block> blocks = new HashSet<>();
+        Queue<Block> queue = new LinkedList<>();
+        Set<Location> visited = new HashSet<>();
+        Location initialLocation = block.getLocation();
+
+        queue.add(block);
+        visited.add(initialLocation);
+
+        while (!queue.isEmpty()) {
+            Block currentBlock = queue.poll();
+            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."));
-            player.sendMessage(MiniComponent.info("You have " + timer.remaining(player) + " seconds remaining."));
+            asAudience(player).sendMessage(MiniComponent.err("That feature can only be used once every 30 seconds."));
+            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 RandomEffect(FeelingLucky plugin) {
+public class RandomEffect extends AbstractListener
+{
+    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 RestoreHunger(FeelingLucky plugin) {
+public class RestoreHunger extends AbstractListener
+{
+    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();
-        if (luck.notDefault()) {
+        PotionEffect effect = PotionEffectBuilder.newEffect()
+                                                 .type(PotionEffectType.SATURATION)
+                                                 .amplifier(2)
+                                                 .duration(10)
+                                                 .particles(false)
+                                                 .create();
+        if (luck.notDefault())
+        {
             double percentage = luck.getValue();
-            ListBox.foods.forEach(food -> {
-                if (item.isSimilar(food)) {
-                    if (luck.quickRNG(percentage) && doesQualify("restore_hunger", percentage)) {
-                        event.getPlayer().setExhaustion(event.getPlayer().getExhaustion() + 2);
-                        event.getPlayer().addPotionEffect(effect);
-                    }
-                }
-            });
+            ListBox.foods.forEach(food ->
+                                  {
+                                      if (item.isSimilar(food) && (luck.quickRNG(percentage) && doesQualify(
+                                          "restore_hunger", percentage)))
+                                      {
+                                          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 (luck.notDefault()) {
+        if (ListBox.acceptedCauses.contains(event.getCause()) && (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 (luck.notDefault()) {
+        if (ListBox.sideCauses.contains(event.getCause()) && (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 UnbreakableTool(FeelingLucky plugin) {
+public class UnbreakableTool extends AbstractListener
+{
+    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 (event.getWhoClicked() instanceof Player player) {
-                Luck luck = getHandler().getLuckContainer(player);
-                if (luck.quickRNG(luck.getValue()) && doesQualify("unbreakable", luck.getValue())) {
-                    meta.setUnbreakable(true);
-                    stack.setItemMeta(meta);
-                    inventory.setResult(stack);
-                    player.sendMessage(MiniComponent.info("By the grace of Luck you have crafted an unbreakable tool!"));
+        if (ItemBuilder.isTool(stack.getType()) && (event.getWhoClicked() instanceof Player player))
+        {
+            Luck luck = getHandler().getLuckContainer(player);
+            if (luck.quickRNG(luck.getValue()) && doesQualify("unbreakable", luck.getValue()))
+            {
+                meta.setUnbreakable(true);
+                stack.setItemMeta(meta);
+                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

@@ -25,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);
@@ -85,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;

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;
-import java.io.File;
-import java.io.FileWriter;
-import java.nio.charset.StandardCharsets;
-import java.util.UUID;
-
-public class PlayerConfig {
+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();
-        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;
+        configFile = configFile(plugin, player);
         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() {
-        SneakyWorker.sneakyTry(() -> config.save(configFile));
+    public static PlayerConfig fromDynamicConfig(FeelingLucky plugin, DynamicConfig config)
+    {
+        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() {
-        SneakyWorker.sneakyTry(() -> config = YamlConfiguration.loadConfiguration(configFile));
+    public DynamicConfig toDynamicConfig()
+    {
+        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) {
-        config.set("username", name);
-        save();
+    public String getUsername() {
+        return config.getString("username");
     }
 
-    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");
-        double luck = playerConfig.getConfig().getDouble("luck");
-        double multiplier = playerConfig.getConfig().getDouble("multiplier");
+        String username = playerConfig.getUsername();
+        double luck = playerConfig.getLuck();
+        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
@@ -28,3 +33,28 @@ random_effect: HIGH
 restore_hunger: NONE
 take_damage: MED
 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