Updates

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

@@ -0,0 +1,29 @@
+package io.github.simplex.luck;
+
+import io.github.simplex.luck.player.PlayerConfig;
+import io.github.simplex.luck.player.PlayerHandler;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public final class FeelingLucky extends JavaPlugin {
+    public PlayerHandler handler;
+    private static final List<PlayerConfig> configList = new ArrayList<>();
+
+    @Override
+    public void onEnable() {
+        handler = new PlayerHandler(this);
+        configList.forEach(PlayerConfig::load);
+        this.getServer().getPluginManager().registerEvents(handler, this);
+    }
+
+    @Override
+    public void onDisable() {
+        configList.forEach(PlayerConfig::save);
+    }
+
+    public static List<PlayerConfig> getConfigList() {
+        return configList;
+    }
+}

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

@@ -0,0 +1,21 @@
+package io.github.simplex.luck;
+
+import org.bukkit.Bukkit;
+
+public class SneakyWorker {
+    public static void sneakyTry(SneakyTry sneakyTry) {
+        try {
+            sneakyTry.tryThis();
+        } catch (Exception ex) {
+            String sb = "An error of type: "
+                    + ex.getClass().getSimpleName()
+                    + " has occurred. A cause will be printed. \n\n"
+                    + ex.getCause();
+            Bukkit.getLogger().severe(sb);
+        }
+    }
+
+    public interface SneakyTry {
+        void tryThis() throws Exception;
+    }
+}

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

@@ -0,0 +1,175 @@
+package io.github.simplex.luck.listener;
+
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.player.Luck;
+import io.github.simplex.luck.player.PlayerHandler;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Material;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Witch;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityDamageEvent.DamageCause;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerItemConsumeEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class PlayerListener implements Listener {
+    private final FeelingLucky plugin;
+
+    public PlayerListener(FeelingLucky plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler
+    public void takeDamage(EntityDamageEvent event) {
+        Entity entity = event.getEntity();
+        if (!(entity instanceof Player)) {
+            return;
+        }
+        Player player = (Player) event.getEntity();
+        Luck luck = PlayerHandler.getLuckContainer(player);
+        if (ListBox.acceptedCauses.contains(event.getCause())) {
+            if (luck.notDefault()) {
+                double percentage = luck.getPercentage();
+                if (luck.quickRNG(percentage)) {
+                    event.setCancelled(true);
+                    player.damage(event.getDamage() / 2);
+                    player.sendMessage(Component.empty().content("You got lucky and took less damage."));
+                }
+            }
+        }
+
+        if (ListBox.sideCauses.contains(event.getCause())) {
+            if (luck.notDefault()) {
+                double percentage = luck.getPercentage();
+                if (luck.quickRNG(percentage)) {
+                    event.setCancelled(true);
+                    player.getActivePotionEffects().removeIf(p -> ListBox.potionEffects.contains(p.getType()));
+                    player.setFireTicks(0);
+                    player.sendMessage(Component.empty().content("You got lucky and your afflictions were cured."));
+                }
+            }
+        }
+    }
+
+    @EventHandler
+    public void restoreHunger(PlayerItemConsumeEvent event) {
+        ItemStack item = event.getItem();
+        Luck luck = PlayerHandler.getLuckContainer(event.getPlayer());
+        if (luck.notDefault()) {
+            double percentage = luck.getPercentage();
+            ListBox.foods.forEach(food -> {
+                if (item.isSimilar(food)) {
+                    if (luck.quickRNG(percentage)) {
+                        event.getPlayer().setExhaustion(event.getPlayer().getExhaustion() + 2);
+                    }
+                }
+            });
+        }
+    }
+
+    @EventHandler
+    public void rabbitFoot(PlayerInteractEvent event) {
+        Action action = event.getAction();
+        ItemStack foot = new ItemStack(Material.RABBIT_FOOT);
+        Player player = event.getPlayer();
+        Luck luck = PlayerHandler.getLuckContainer(player);
+        if (action.isRightClick() && player.getInventory().getItemInMainHand().isSimilar(foot)) {
+            double rng = luck.RNG().nextDouble(2.0, 5.0);
+            player.getInventory().remove(player.getInventory().getItemInMainHand());
+            luck.addTo(rng);
+
+            player.sendMessage(Component.empty().content("Your luck has been increased by " + rng + " points."));
+        }
+    }
+
+    @EventHandler
+    public void witchesBrew(EntityDamageByEntityEvent event) {
+        Entity eTEMP = event.getDamager();
+        Entity pTEMP = event.getEntity();
+        DamageCause cause = event.getCause();
+
+        if (!(pTEMP instanceof Player player)) {
+            return;
+        }
+
+        if (!(eTEMP instanceof Witch)) {
+            return;
+        }
+
+        Luck luck = PlayerHandler.getLuckContainer(player);
+        if (cause.equals(DamageCause.MAGIC) || cause.equals(DamageCause.POISON)) {
+            if (luck.quickRNG(33.0)) {
+                luck.takeFrom(5.0);
+                plugin.handler.updatePlayer(player, luck);
+            }
+        }
+    }
+
+    private static class ListBox {
+        public static final List<DamageCause> acceptedCauses = new ArrayList<>() {{
+            add(DamageCause.ENTITY_ATTACK);
+            add(DamageCause.ENTITY_SWEEP_ATTACK);
+            add(DamageCause.PROJECTILE);
+            add(DamageCause.ENTITY_EXPLOSION);
+            add(DamageCause.FLY_INTO_WALL);
+            add(DamageCause.LIGHTNING);
+            add(DamageCause.MAGIC);
+        }};
+
+        public static final List<DamageCause> sideCauses = new ArrayList<>() {{
+            add(DamageCause.POISON);
+            add(DamageCause.WITHER);
+            add(DamageCause.FIRE_TICK);
+        }};
+
+        public static final List<PotionEffectType> potionEffects = new ArrayList<>() {{
+            add(PotionEffectType.POISON);
+            add(PotionEffectType.WITHER);
+            add(PotionEffectType.BLINDNESS);
+            add(PotionEffectType.SLOW);
+            add(PotionEffectType.SLOW_DIGGING);
+            add(PotionEffectType.BAD_OMEN);
+            add(PotionEffectType.CONFUSION);
+            add(PotionEffectType.WEAKNESS);
+        }};
+
+        public static final List<ItemStack> foods = new ArrayList<>() {{
+            add(new ItemStack(Material.COOKED_BEEF));
+            add(new ItemStack(Material.COOKED_CHICKEN));
+            add(new ItemStack(Material.COOKED_PORKCHOP));
+            add(new ItemStack(Material.COOKED_COD));
+            add(new ItemStack(Material.COOKED_MUTTON));
+            add(new ItemStack(Material.COOKED_RABBIT));
+            add(new ItemStack(Material.COOKED_SALMON));
+            add(new ItemStack(Material.BEETROOT_SOUP));
+            add(new ItemStack(Material.POTATO));
+            add(new ItemStack(Material.BAKED_POTATO));
+            add(new ItemStack(Material.CARROT));
+            add(new ItemStack(Material.GOLDEN_CARROT));
+            add(new ItemStack(Material.APPLE));
+            add(new ItemStack(Material.GOLDEN_APPLE));
+            add(new ItemStack(Material.ENCHANTED_GOLDEN_APPLE));
+            add(new ItemStack(Material.BEEF));
+            add(new ItemStack(Material.PORKCHOP));
+            add(new ItemStack(Material.CHICKEN));
+            add(new ItemStack(Material.COD));
+            add(new ItemStack(Material.SALMON));
+            add(new ItemStack(Material.MUTTON));
+            add(new ItemStack(Material.RABBIT));
+            add(new ItemStack(Material.MUSHROOM_STEW));
+            add(new ItemStack(Material.BREAD));
+            add(new ItemStack(Material.CAKE));
+            add(new ItemStack(Material.COOKIE));
+        }};
+    }
+}

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

@@ -0,0 +1,120 @@
+package io.github.simplex.luck.player;
+
+import io.github.simplex.api.LuckContainer;
+import org.bukkit.Bukkit;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.Player;
+
+import java.util.SplittableRandom;
+
+public class Luck implements LuckContainer {
+    private final Player player;
+    private final double multiplier;
+    private final double BASE_VALUE;
+    private final PlayerLuckChangeEvent event;
+
+    public Luck(Player player) {
+        this(player, 1.0);
+    }
+
+    public Luck(Player player, double multiplier) {
+        this.player = player;
+        this.multiplier = multiplier;
+        BASE_VALUE = player.getAttribute(Attribute.GENERIC_LUCK).getDefaultValue();
+        event = new PlayerLuckChangeEvent(player);
+    }
+
+    @Override
+    public Attribute asAttribute() {
+        return Attribute.GENERIC_LUCK;
+    }
+
+    @Override
+    public double getNumber() {
+        return associatedPlayer().getAttribute(asAttribute()).getValue();
+    }
+
+    @Override
+    public boolean isMatch(double number) {
+        return getNumber() == number;
+    }
+
+    @Override
+    public boolean isClose(double number, int range) {
+        return ((getNumber() - range <= number) && (number <= getNumber() + range));
+    }
+
+    @Override
+    public double multiplier() {
+        return multiplier;
+    }
+
+    @Override
+    public Player associatedPlayer() {
+        return player;
+    }
+
+    public SplittableRandom RNG() {
+        return new SplittableRandom();
+    }
+
+    public boolean quickRNG(double percentage) {
+        double rng;
+        if (percentage > 99.0) {
+            rng = RNG().nextDouble(100.0, 199.0);
+        } else {
+            rng = RNG().nextDouble(0.0, 99.0);
+        }
+
+        if (multiplier() > 0.0) {
+            return ((percentage * multiplier()) >= rng);
+        }
+
+        return (percentage >= rng);
+    }
+
+    @Override
+    public double baseValue() {
+        return BASE_VALUE;
+    }
+
+    public double defaultValue() {
+        return player.getAttribute(Attribute.GENERIC_LUCK).getDefaultValue();
+    }
+
+    public void setValue(double value) {
+        player.getAttribute(Attribute.GENERIC_LUCK).setBaseValue(value);
+        Bukkit.getPluginManager().callEvent(event);
+    }
+
+    public void addTo(double value) {
+        setValue(baseValue() + value);
+        Bukkit.getPluginManager().callEvent(event);
+    }
+
+    public void takeFrom(double value) {
+        setValue(baseValue() - value);
+        Bukkit.getPluginManager().callEvent(event);
+    }
+
+    public double getPercentage() {
+        return baseValue() - defaultValue();
+    }
+
+    public boolean notDefault() {
+        return baseValue() != defaultValue();
+    }
+
+    public boolean lessThan(double value) {
+        return baseValue() < value;
+    }
+
+    public boolean greaterThan (double value) {
+        return baseValue() > value;
+    }
+
+    @Override
+    public String toString() {
+        return "" + baseValue();
+    }
+}

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

@@ -0,0 +1,51 @@
+package io.github.simplex.luck.player;
+
+import io.github.simplex.luck.FeelingLucky;
+import io.github.simplex.luck.SneakyWorker;
+import org.bukkit.attribute.Attribute;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+
+import java.io.File;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+public class PlayerConfig extends YamlConfiguration {
+    private final File configFile;
+    private volatile YamlConfiguration config;
+
+    @SuppressWarnings("ResultOfMethodCallIgnored")
+    public PlayerConfig(FeelingLucky plugin, Player player) {
+        File dataFolder = new File(plugin.getDataFolder(), "players");
+        if (!dataFolder.exists()) dataFolder.mkdirs();
+        File file = new File(dataFolder, player.getUniqueId() + ".yml");
+        if (!file.exists()) {
+            SneakyWorker.sneakyTry(() -> {
+                file.createNewFile();
+                InputStreamReader reader = new InputStreamReader(plugin.getResource("default_player.yml"));
+                loadConfiguration(reader).save(file);
+            });
+        }
+        configFile = file;
+        config = loadConfiguration(configFile);
+
+        if (config.getString("username").equalsIgnoreCase("replace")) {
+            config.set("username", player.getName());
+            config.set("luck", new Luck(player).defaultValue());
+            config.set("multiplier", "1.0");
+            save();
+        }
+    }
+
+    public void save() {
+        SneakyWorker.sneakyTry(() -> config.save(configFile));
+    }
+
+    public void load() {
+        SneakyWorker.sneakyTry(() -> config = loadConfiguration(configFile));
+    }
+
+    public YamlConfiguration getConfig() {
+        return config;
+    }
+}

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

@@ -0,0 +1,59 @@
+package io.github.simplex.luck.player;
+
+import io.github.simplex.luck.FeelingLucky;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerLoginEvent;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public record PlayerHandler(FeelingLucky plugin) implements Listener {
+    private static final Map<Player, Luck> playerLuckMap = new HashMap<>();
+    private static final List<Player> markedPlayers = new ArrayList<>();
+
+    public static Luck getLuckContainer(Player player) {
+        return playerLuckMap.get(player);
+    }
+
+    @EventHandler
+    public void initializePlayer(PlayerLoginEvent event) {
+        Player player = event.getPlayer();
+        PlayerConfig config = new PlayerConfig(plugin, player);
+
+        String username = config.getString("username");
+        double luckstat = config.getDouble("luck");
+        double multiplier = config.getDouble("multiplier");
+
+        if (!player.getName().equalsIgnoreCase(username)) {
+            config.set("username", player.getName());
+            config.save();
+            config.load();
+        }
+
+        Luck luck = new Luck(player, multiplier);
+        luck.setValue(luckstat);
+
+        FeelingLucky.getConfigList().add(config);
+        playerLuckMap.put(player, luck);
+    }
+
+    public void updatePlayer(Player player, Luck luck) {
+        playerLuckMap.replace(player, luck);
+    }
+
+    public static void markPlayer(Player player) {
+        markedPlayers.add(player);
+    }
+
+    public static void unmarkPlayer(Player player) {
+        markedPlayers.remove(player);
+    }
+
+    public static boolean isMarked(Player player) {
+        return markedPlayers.contains(player);
+    }
+}

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

@@ -0,0 +1,28 @@
+package io.github.simplex.luck.player;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.player.PlayerEvent;
+import org.jetbrains.annotations.NotNull;
+
+public class PlayerLuckChangeEvent extends PlayerEvent {
+    public final HandlerList handlerList = new HandlerList();
+
+    public PlayerLuckChangeEvent(@NotNull Player who) {
+        super(who);
+        Luck luck = PlayerHandler.getLuckContainer(who);
+        if (luck.lessThan(0.0) && !PlayerHandler.isMarked(who)) {
+            PlayerHandler.markPlayer(who);
+            return;
+        }
+
+        if (luck.greaterThan(0.0) && PlayerHandler.isMarked(who)) {
+            PlayerHandler.unmarkPlayer(who);
+        }
+    }
+
+    @Override
+    public @NotNull HandlerList getHandlers() {
+        return handlerList;
+    }
+}