Initial commit

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

@@ -0,0 +1,20 @@
+package io.github.simplex.api;
+
+import org.bukkit.attribute.Attribute;
+import org.bukkit.entity.Player;
+
+public interface LuckContainer {
+    Attribute asAttribute();
+
+    double getNumber();
+
+    boolean isMatch(double number);
+
+    boolean isClose(double number, int range);
+
+    double multiplier();
+
+    Player associatedPlayer();
+
+    double baseValue();
+}

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

@@ -0,0 +1,41 @@
+package io.github.simplex.crumb;
+
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+
+public class Config extends YamlConfiguration {
+    private final String CONFIG_NAME = "config.yml";
+
+    private final File dataFolder;
+    private final Crumb plugin;
+    private final File configFile;
+
+    @SuppressWarnings("ResultOfMethodCallIgnored")
+    public Config(Crumb plugin, boolean copyResource) {
+        this.plugin = plugin;
+        this.dataFolder = plugin.getDataFolder();
+        if (!dataFolder.exists()) dataFolder.mkdirs();
+        File file = new File(dataFolder, CONFIG_NAME);
+        if (!file.exists()) {
+            SneakyWorker.sneakyTry(() -> {
+                file.createNewFile();
+                plugin.saveResource(CONFIG_NAME, true);
+            });
+        }
+        if (copyResource) plugin.saveResource(CONFIG_NAME, true);
+        configFile = file;
+        loadConfiguration(configFile);
+    }
+
+    public void save() {
+        SneakyWorker.sneakyTry(() -> super.save(configFile));
+    }
+
+    public void load() {
+        SneakyWorker.sneakyTry(() -> {
+            super.load(configFile);
+        });
+    }
+}

src/main/java/io/github/simplex/crumb/Crumb.java

@@ -0,0 +1,21 @@
+package io.github.simplex.crumb;
+
+import org.bukkit.plugin.java.JavaPlugin;
+
+public final class Crumb extends JavaPlugin {
+    public Config config;
+    public PlayerHandler handler;
+
+    @Override
+    public void onEnable() {
+        config = new Config(this, false);
+        handler = new PlayerHandler(this);
+        this.getServer().getPluginManager().registerEvents(handler, this);
+    }
+
+    @Override
+    public void onDisable() {
+        config.save();
+        // Plugin shutdown logic
+    }
+}

src/main/java/io/github/simplex/crumb/Luck.java

@@ -0,0 +1,108 @@
+package io.github.simplex.crumb;
+
+import io.github.simplex.api.LuckContainer;
+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;
+
+    public Luck(Player player) {
+        this.player = player;
+        multiplier = 1.0;
+        BASE_VALUE = player.getAttribute(Attribute.GENERIC_LUCK).getDefaultValue();
+    }
+
+    public Luck(Player player, double multiplier) {
+        this.player = player;
+        this.multiplier = multiplier;
+        BASE_VALUE = player.getAttribute(Attribute.GENERIC_LUCK).getDefaultValue();
+    }
+
+    @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 >= (rng * multiplier()));
+        }
+
+        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);
+    }
+
+    public void addTo(double value) {
+        setValue(baseValue() + value);
+    }
+
+    public void takeFrom(double value) {
+        setValue(baseValue() - value);
+    }
+
+    public double getPercentage() {
+        return baseValue() - defaultValue();
+    }
+
+    public boolean isDefault() {
+        return baseValue() == defaultValue();
+    }
+
+    @Override
+    public String toString() {
+        return "" + baseValue();
+    }
+}

src/main/java/io/github/simplex/crumb/PlayerHandler.java

@@ -0,0 +1,58 @@
+package io.github.simplex.crumb;
+
+import org.bukkit.attribute.Attribute;
+import org.bukkit.configuration.ConfigurationSection;
+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 class PlayerHandler implements Listener {
+    private final Map<Player, Luck> playerLuckMap = new HashMap<>();
+    private final List<Player> markedPlayers = new ArrayList<>();
+    private final Crumb plugin;
+
+    public PlayerHandler(Crumb plugin) {
+        this.plugin = plugin;
+    }
+
+    public Luck getLuckContainer(Player player) {
+        return playerLuckMap.get(player);
+    }
+
+    @EventHandler
+    public void initializePlayer(PlayerLoginEvent event) {
+        Player player = event.getPlayer();
+        String uuid = player.getUniqueId().toString();
+        ConfigurationSection identifier = plugin.config.getConfigurationSection(uuid);
+        Luck luck = new Luck(player);
+        if (identifier == null) {
+            identifier = plugin.config.createSection(player.getUniqueId().toString());
+            identifier.set("luck", luck.defaultValue());
+            plugin.config.save();
+        }
+        luck.setValue(identifier.getDouble("luck"));
+        playerLuckMap.put(player, luck);
+    }
+
+    public void updatePlayer(Player player, Luck luck) {
+        playerLuckMap.replace(player, luck);
+    }
+
+    public void markPlayer(Player player) {
+        markedPlayers.add(player);
+    }
+
+    public void unmarkPlayer(Player player) {
+        markedPlayers.remove(player);
+    }
+
+    public boolean isMarked(Player player) {
+        return markedPlayers.contains(player);
+    }
+}

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

@@ -0,0 +1,17 @@
+package io.github.simplex.crumb;
+
+import org.bukkit.Bukkit;
+
+public class SneakyWorker {
+    public static void sneakyTry(SneakyTry sneakyTry) {
+        try {
+            sneakyTry.tryThis();
+        } catch (Exception ex) {
+            Bukkit.getLogger().severe(ex.getMessage());
+        }
+    }
+
+    interface SneakyTry {
+        void tryThis() throws Exception;
+    }
+}

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

@@ -0,0 +1,175 @@
+package io.github.simplex.crumb.listener;
+
+import io.github.simplex.crumb.Crumb;
+import io.github.simplex.crumb.Luck;
+import net.kyori.adventure.text.Component;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+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 Crumb plugin;
+
+    public PlayerListener(Crumb 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 = plugin.handler.getLuckContainer(player);
+        if (ListBox.acceptedCauses.contains(event.getCause())) {
+            if (!luck.isDefault()) {
+                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.isDefault()) {
+                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 = plugin.handler.getLuckContainer(event.getPlayer());
+        if (!luck.isDefault()) {
+            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 = plugin.handler.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 = plugin.handler.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));
+        }};
+    }
+}