Beta 20220422-SNAPSHOT

Changelog:
 - Added a configuration with editable rarity values and rarity types for the different events that can occur, to give the end user more control over how often players receive the effects.
- Modified listeners to use the respective Configuration values.
- Added the ability to reload a specific player configuration with /luck reload -p <player_name>
- Added the ability to reload the main configuration using /luck reload -m
- Added an integrity checker to validate the main configuration on boot.

Author: Paldiu

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

@@ -0,0 +1,91 @@
+package io.github.simplex.luck;
+
+import io.github.simplex.lib.MiniComponent;
+import io.github.simplex.luck.listener.AbstractListener;
+import io.github.simplex.luck.util.SneakyWorker;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+public class Config extends YamlConfiguration {
+    private final FeelingLucky plugin;
+    private File configFile;
+
+    public Config(FeelingLucky plugin) {
+        this.plugin = plugin;
+
+        File dataFolder = plugin.getDataFolder();
+        if (!dataFolder.exists()) dataFolder.mkdirs();
+        File configFile = new File(dataFolder, "config.yml");
+        if (!configFile.exists()) {
+            SneakyWorker.sneakyTry(configFile::createNewFile);
+            plugin.saveResource("config.yml", true);
+        }
+
+        this.configFile = configFile;
+        load();
+
+        if (validateIntegrity()) {
+            File newFile = new File(plugin.getDataFolder(), "config.yml");
+            SneakyWorker.sneakyTry(() -> {
+                Files.delete(Path.of(plugin.getDataFolder().getPath()));
+                newFile.createNewFile();
+                plugin.saveResource("config.yml", true);
+            });
+            this.configFile = newFile;
+            load();
+        }
+    }
+
+    public void save() {
+        SneakyWorker.sneakyTry(() -> save(configFile));
+    }
+
+    public void load() {
+        SneakyWorker.sneakyTry(() -> load(configFile));
+    }
+
+    public void reload() {
+        save();
+        load();
+    }
+
+    public boolean validateIntegrity() {
+        for (String key : getKeys(false)) {
+            if (!configEntries.contains(key)) {
+                plugin.getLogger().severe("The contents of your configuration file is corrupted! Regenerating a new configuration file...");
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public AbstractListener.Rarity getRarity(String name) {
+        return AbstractListener.Rarity.valueOf(getString(name));
+    }
+
+    public double getChance(String path) {
+        return getDouble(path);
+    }
+
+    private List<String> configEntries = new ArrayList<>() {{
+        add("high_rarity_chance");
+        add("medium_rarity_chance");
+        add("low_rarity_chance");
+        add("block_drops");
+        add("bonemeal");
+        add("cheat_death");
+        add("enchanting");
+        add("experience");
+        add("item_drops");
+        add("random_effect");
+        add("restore_hunger");
+        add("take_damage");
+        add("unbreakable");
+    }};
+}

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

@@ -3,10 +3,9 @@
 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.CooldownTimer;
 import io.github.simplex.luck.util.LuckCMD;
-import org.bukkit.Bukkit;
 import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
 
 import java.io.File;
 import java.util.Arrays;
@@ -18,6 +17,7 @@ public final class FeelingLucky extends JavaPlugin {
     private final Map<UUID, PlayerConfig> configMap = new HashMap<>();
 
     private PlayerHandler handler;
+    private Config config;
 
     public Map<UUID, PlayerConfig> getConfigMap() {
         return configMap;
@@ -30,21 +30,26 @@ public void onEnable() {
         getLogger().info("Initialization complete! Attempting to register the Listeners...");
         registerListeners();
         getLogger().info("Registration complete! Attempting to load all player configuration files...");
-        loadConfigurations();
-        Bukkit.getLogger().info("Attempting to load the Luck command...");
+        loadPlayerConfigurations();
+        getLogger().info("Attempting to load the main configuration...");
+        config = new Config(this);
+        getLogger().info("Main Config loaded successfully! Attempting to load the Luck command...");
         new LuckCMD(this);
-        Bukkit.getLogger().info("Successfully loaded the Luck command!");
+        getLogger().info("Successfully loaded the Luck command!");
 
-        Bukkit.getLogger().info("Successfully initialized!");
+        getLogger().info("Successfully initialized!");
     }
 
     @Override
     public void onDisable() {
-        Bukkit.getLogger().info("Saving all player configurations...");
+        getLogger().info("Saving all player configurations...");
         configMap.values().forEach(PlayerConfig::save);
+        getLogger().info("Complete! Saving the main config...");
+        config.save();
+        getLogger().info("Complete! Goodbye! :)");
     }
 
-    private void loadConfigurations() {
+    private void loadPlayerConfigurations() {
         File[] files = getDataFolder().listFiles();
         if (files != null) {
             Arrays.stream(files).forEach(file -> {
@@ -76,4 +81,10 @@ private void registerListeners() {
     public PlayerHandler getHandler() {
         return handler;
     }
+    
+    @Override
+    @NotNull
+    public Config getConfig() {
+        return config;
+    }
 }

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

@@ -0,0 +1,46 @@
+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 org.bukkit.event.Listener;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public abstract class AbstractListener implements Listener {
+    protected final FeelingLucky plugin;
+    protected final Map<AbstractListener, Rarity> listenerRarityMap = new HashMap<>();
+    protected final Config config;
+
+    public AbstractListener(FeelingLucky plugin) {
+        this.plugin = plugin;
+        this.config = plugin.getConfig();
+        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+    }
+
+    protected PlayerHandler getHandler() {
+        return plugin.getHandler();
+    }
+
+    public enum Rarity {
+        HIGH,
+        MED,
+        LOW,
+        NONE
+    }
+
+    public boolean doesQualify(String name, double luck) {
+        switch (config.getRarity(name)) {
+            case HIGH:
+                if (luck < config.getChance("high_rarity_chance")) return false;
+            case MED:
+                if (luck < config.getChance("medium_rarity_chance")) return false;
+            case LOW:
+                if (luck < config.getChance("low_rarity_chance")) return false;
+            case NONE:
+                return true;
+        }
+        throw new IllegalArgumentException("The value for the listener rarity is not a recognized rarity value.");
+    }
+}

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

@@ -6,22 +6,21 @@
 import org.bukkit.entity.Item;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
 import org.bukkit.event.block.BlockDropItemEvent;
 
 import java.util.List;
 
-public record BlockDrops(FeelingLucky plugin) implements Listener {
-    public BlockDrops {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+public final class BlockDrops extends AbstractListener {
+    public BlockDrops(FeelingLucky plugin) {
+        super(plugin);
     }
 
     @EventHandler
     public void extraBlockDrops(BlockDropItemEvent event) {
         Player player = event.getPlayer();
-        Luck luck = plugin.getHandler().getLuckContainer(player);
+        Luck luck = getHandler().getLuckContainer(player);
         List<Item> items = event.getItems();
-        if (luck.quickRNG(luck.getPercentage())) {
+        if (luck.quickRNG(luck.getPercentage()) && doesQualify("block_drops", luck.getPercentage())) {
             items.forEach(SneakyWorker::move);
         }
     }

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

@@ -10,22 +10,21 @@
 import org.bukkit.block.data.BlockData;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
 import org.bukkit.event.block.Action;
 import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.inventory.ItemStack;
 
-public record BonemealFullCrop(FeelingLucky plugin) implements Listener {
-    public BonemealFullCrop {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+public final class BonemealFullCrop extends AbstractListener {
+    public BonemealFullCrop(FeelingLucky plugin) {
+        super(plugin);
     }
 
     @EventHandler
     public void bonemealFullCrop(PlayerInteractEvent event) {
         Player player = event.getPlayer();
         Action action = event.getAction();
         ItemStack bonemeal = ItemBuilder.of(Material.BONE_MEAL).build();
-        Luck luck = plugin.getHandler().getLuckContainer(player);
+        Luck luck = getHandler().getLuckContainer(player);
 
         ItemStack handItem = event.getItem();
         if (handItem == null) return;
@@ -38,12 +37,12 @@ public void bonemealFullCrop(PlayerInteractEvent event) {
         if (action.isRightClick()
                 && handItem.isSimilar(bonemeal)
                 && (data instanceof Ageable crop)
-                && luck.quickRNG(luck.getPercentage())) {
+                && luck.quickRNG(luck.getPercentage())
+                && doesQualify("bonemeal", luck.getPercentage())) {
             crop.setAge(crop.getMaximumAge());
             data.merge(crop);
             block.setBlockData(data);
             player.sendMessage(MiniComponent.info("You got lucky and your crops grew to maturity."));
         }
     }
-
 }

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

@@ -5,26 +5,23 @@
 import io.github.simplex.luck.player.Luck;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
 import org.bukkit.event.entity.PlayerDeathEvent;
 
-public record CheatDeath(FeelingLucky plugin) implements Listener {
+public final class CheatDeath extends AbstractListener {
     public CheatDeath(FeelingLucky plugin) {
-        this.plugin = plugin;
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        super(plugin);
     }
 
     @EventHandler
     public void cheatDeath(PlayerDeathEvent event) {
         Player player = event.getPlayer();
-        Luck luck = plugin.getHandler().getLuckContainer(player);
+        Luck luck = getHandler().getLuckContainer(player);
         double absorption = Math.round(Luck.RNG().nextDouble(5.0, 10.0));
-        if (luck.quickRNG(luck.getPercentage())) {
+        if (luck.quickRNG(luck.getPercentage()) && doesQualify("cheat_death", luck.getPercentage())) {
             event.setCancelled(true);
             player.setHealth(1.0);
             player.setAbsorptionAmount(absorption);
             player.sendMessage(MiniComponent.of("You got lucky and cheated death!").send());
         }
-
     }
 }

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

@@ -5,25 +5,23 @@
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
 import org.bukkit.event.enchantment.EnchantItemEvent;
 
 import java.util.List;
 import java.util.Map;
 
-public record EnchantmentBoost(FeelingLucky plugin) implements Listener {
+public final class EnchantmentBoost extends AbstractListener {
     public EnchantmentBoost(FeelingLucky plugin) {
-        this.plugin = plugin;
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        super(plugin);
     }
 
     @EventHandler
     public void enchantItem(EnchantItemEvent event) {
         Map<Enchantment, Integer> enchMap = event.getEnchantsToAdd();
         List<Enchantment> enchList = enchMap.keySet().stream().toList();
         Player player = event.getEnchanter();
-        Luck luck = plugin.getHandler().getLuckContainer(player);
-        if (luck.quickRNG(luck.getPercentage())) {
+        Luck luck = getHandler().getLuckContainer(player);
+        if (luck.quickRNG(luck.getPercentage()) && doesQualify("enchanting", luck.getPercentage())) {
             Enchantment particular = enchList.get(Luck.RNG().nextInt(enchList.size()));
             int rng = Luck.RNG().nextInt(1, 5);
 
@@ -34,4 +32,8 @@ public void enchantItem(EnchantItemEvent event) {
             enchMap.replace(particular, enchMap.get(particular) + rng);
         }
     }
+
+    public FeelingLucky plugin() {
+        return plugin;
+    }
 }

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

@@ -6,12 +6,10 @@
 import org.bukkit.entity.ExperienceOrb;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
 
-public record ExpBoost(FeelingLucky plugin) implements Listener {
+public final class ExpBoost extends AbstractListener {
     public ExpBoost(FeelingLucky plugin) {
-        this.plugin = plugin;
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+        super(plugin);
     }
 
     @EventHandler
@@ -22,7 +20,7 @@ public void boostExperienceGain(PlayerPickupExperienceEvent event) {
         int rounded = Math.round(math);
         Player player = event.getPlayer();
         Luck luck = plugin.getHandler().getLuckContainer(player);
-        if (luck.quickRNG(luck.getPercentage())) {
+        if (luck.quickRNG(luck.getPercentage()) && doesQualify("experience", luck.getPercentage())) {
             orb.setExperience(rounded);
         }
     }

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

@@ -5,23 +5,22 @@
 import io.github.simplex.luck.player.Luck;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
 import org.bukkit.event.entity.EntityPotionEffectEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
 
-public record IllOmen(FeelingLucky plugin) implements Listener {
-    public IllOmen {
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
+public class IllOmen extends AbstractListener {
+    public IllOmen(FeelingLucky plugin) {
+        super(plugin);
     }
 
     @EventHandler
     public void reconnectCheck(PlayerJoinEvent event) {
         Player player = event.getPlayer();
         PotionEffectType type = PotionEffectType.BAD_OMEN;
-        Luck luck = plugin.getHandler().getLuckContainer(player);
+        Luck luck = getHandler().getLuckContainer(player);
 
         if (player.hasPotionEffect(type)) {
             luck.cache();