Refactoring 2

README.md

@@ -17,4 +17,13 @@ openssl x509 -inform pem -in cert.cer -pubkey -noout > public_key.pem
 When using `mvn`, override with `-Djarsigner.`
 ```
 mvn clean package -Djarsigner.keystore=/home/user/mykeystore.jks -Djarsigner.alias=mykey
-```
+```
+
+### Color scheme
+The following color scheme is used for chat messages:
+- Errors: RED
+- "Soft errors" (like no permission): GRAY
+- Status messages: GRAY
+- Notice / call for action: YELLOW (optionally also BOLD)
+- Information: GOLD
+- Highlight: AQUA (TODO do that)

pom.xml

@@ -2,7 +2,7 @@
   <modelVersion>4.0.0</modelVersion>
   <groupId>eu.m724</groupId>
   <artifactId>giants</artifactId>
-  <version>2.0.11</version>
+  <version>2.0.12-SNAPSHOT</version>
 
   <properties>
     <maven.compiler.release>17</maven.compiler.release>
@@ -147,7 +147,7 @@
 
   <scm>
     <developerConnection>scm:git:git@git.m724.eu:Minecon724/giants.git</developerConnection>
-    <tag>giants-2.0.11</tag>
+    <tag>HEAD</tag>
   </scm>
 
   <distributionManagement>

src/main/java/eu/m724/giants/Configuration.java

@@ -1,139 +0,0 @@
-package eu.m724.giants;
-
-import org.bukkit.Material;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.potion.PotionEffect;
-import org.bukkit.potion.PotionEffectType;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.logging.Logger;
-
-public class Configuration {
-    private final File file;
-    private final Logger logger;
-
-    String updater;
-
-    boolean ai;
-
-    double attackDamage;
-    int attackDelay;
-    Vector attackReach;
-    int jumpMode;
-    int jumpCondition;
-    int jumpDelay;
-    double jumpHeight = -1;
-
-    double chance;
-    List<String> worldBlacklist;
-    Set<PotionEffect> effects = new HashSet<>();
-    Set<Drop> drops = new HashSet<>();
-
-    public Configuration(Plugin plugin, File file) {
-        this.file = file;
-        this.logger = Logger.getLogger(plugin.getLogger().getName() + ".Configuration");
-    }
-
-    public void load() {
-        YamlConfiguration config = YamlConfiguration.loadConfiguration(file);
-
-        updater = config.getString("updater", "true");
-        if (updater.equalsIgnoreCase("true")) {
-            updater = "release";
-        } else if (updater.equalsIgnoreCase("false")) {
-            updater = null;
-        }
-
-        ai = config.getBoolean("ai");
-
-        chance = config.getDouble("chance");
-        attackDamage = config.getDouble("attackDamage");
-        attackDelay = config.getInt("attackDelay");
-        jumpMode = config.getInt("jumpMode");
-        jumpCondition = config.getInt("jumpCondition");
-        jumpDelay = config.getInt("jumpDelay");
-
-        if (jumpMode != 0) {
-            jumpHeight = config.getDouble("jumpHeight", -1);
-            if (jumpHeight == -1) {
-                jumpHeight = defaultJumpHeight();
-            }
-            logger.info("Jumping is experimental.");
-            logger.info("Jump mode: " + jumpMode);
-            logger.info("Jump condition: " + jumpCondition);
-            logger.info("Jump height: " + jumpHeight);
-        }
-
-        double _attackReach = config.getDouble("attackReach");
-        double _attackVerticalReach = config.getDouble("attackVerticalReach");
-        attackReach = new Vector(_attackReach, _attackVerticalReach, _attackReach);
-
-        worldBlacklist = config.getStringList("blacklist");
-
-        for (String line : config.getStringList("effects")) {
-            String[] parts = line.split(":");
-
-            try {
-                PotionEffectType effectType = PotionEffectType.getByName(parts[0]);
-                if (effectType == null) {
-                    throw new IllegalArgumentException("Invalid PotionEffectType");
-                }
-                int amplifier = Integer.parseInt(parts[1]);
-                effects.add(new PotionEffect(effectType, Integer.MAX_VALUE, amplifier));
-            } catch (IllegalArgumentException e) {
-                logger.warning("Parsing a potion effect failed:");
-                logger.warning(line);
-                logger.warning(e.getMessage());
-            }
-        }
-
-        for (Map<?, ?> dropMap : config.getMapList("drops")) {
-            try {
-                ItemStack itemStack;
-                if (dropMap.containsKey("itemStack")) {
-                    itemStack = (ItemStack) dropMap.get("itemStack");
-                } else {
-                    Material material = Material.getMaterial((String) dropMap.get("material"));
-                    if (material == null) {
-                        throw new IllegalArgumentException("Invalid Material");
-                    }
-                    itemStack = new ItemStack(material, 1);
-                }
-
-                int min = (int) dropMap.get("quantityMin");
-                int max = (int) dropMap.get("quantityMax");
-                double chance;
-                try {
-                    chance = (double) dropMap.get("chance");
-                } catch (ClassCastException e) { // pointlessest error ever
-                    chance = ((Integer) dropMap.get("chance")).doubleValue();
-                }
-
-                drops.add(new Drop(itemStack, min, max, chance));
-            } catch (IllegalArgumentException e) {
-                logger.warning("Parsing a drop failed:");
-                logger.warning(e.getMessage());
-            }
-        }
-    }
-
-    public double defaultJumpHeight() {
-        switch (jumpMode) {
-            case 1:
-            case 2:
-                return 0.42;
-            case 3:
-            case 4:
-                return 1.2;
-        }
-
-        return -1;
-    }
-}

src/main/java/eu/m724/giants/Drop.java

@@ -1,25 +1,34 @@
 package eu.m724.giants;
 
+import org.bukkit.Location;
 import org.bukkit.inventory.ItemStack;
 
 import java.util.concurrent.ThreadLocalRandom;
 
-public class Drop {
-    public final ItemStack itemStack;
-    public final int min, max;
-    public final double chance;
-
-    public Drop(ItemStack itemStack, int min, int max, double chance) {
-        this.itemStack = itemStack;
-        this.min = min;
-        this.max = max;
-        this.chance = chance;
-    }
-
-    public ItemStack generateItemStack() {
+public record Drop(ItemStack itemStack, int min, int max, double chance) {
+    /**
+     * Randomizes quantity and returns {@link ItemStack}.<br>
+     * This should be called every drop.
+     *
+     * @return A {@link ItemStack} with randomized quantity
+     */
+    private ItemStack generate() {
         int amount = ThreadLocalRandom.current().nextInt(min, max + 1);
+
         ItemStack itemStack = this.itemStack.clone();
         itemStack.setAmount(amount);
         return itemStack;
     }
+
+    /**
+     * Drops the item at {@code location} taking into account quantity and chance.
+     *
+     * @param location The location to drop the drop at
+     */
+    public void dropAt(Location location) {
+        if (chance > ThreadLocalRandom.current().nextDouble()) {
+            ItemStack itemStack = generate();
+            location.getWorld().dropItemNaturally(location, itemStack);
+        }
+    }
 }

src/main/java/eu/m724/giants/GiantsCommand.java

@@ -1,11 +1,12 @@
 package eu.m724.giants;
 
 import eu.m724.giants.updater.UpdateCommand;
+import net.md_5.bungee.api.ChatColor;
+import org.bukkit.Material;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
 import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
@@ -20,131 +21,89 @@ import java.util.Map;
 
 public class GiantsCommand implements CommandExecutor {
     private final GiantsPlugin plugin;
-    private final Configuration configuration;
 
     private final UpdateCommand updateCommand;
 
-    public GiantsCommand(GiantsPlugin plugin, Configuration configuration, UpdateCommand updateCommand) {
+    public GiantsCommand(GiantsPlugin plugin, UpdateCommand updateCommand) {
         this.plugin = plugin;
-        this.configuration = configuration;
         this.updateCommand = updateCommand;
     }
 
     @Override
     public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
         if (args.length == 0) {
-            sender.sendMessage("Giants " + plugin.getDescription().getVersion());
+            sender.sendMessage(ChatColor.GRAY + "Giants " + plugin.getDescription().getVersion());
             return true;
         }
 
         String action = args[0];
 
         if (!sender.hasPermission("giants.command." + action)) {
-            sender.sendMessage("You don't have permission to use this command, or it doesn't exist.");
+            sender.sendMessage(ChatColor.GRAY + "You don't have permission to use this command, or it doesn't exist.");
             return true;
         }
 
-        Player player = sender instanceof Player ? (Player) sender : null;
-
-        if (action.equals("spawn")) {
-            sender.sendMessage("This command is deprecated. Use /summon giant instead");
-            if (player != null) {
-                if (plugin.isSpawnableAt(player.getLocation())) {
-                    sender.sendMessage("Spawned a Giant");
-                    player.getWorld().spawnEntity(player.getLocation(), EntityType.GIANT);
-                } else {
-                    sender.sendMessage("No space here for a Giant");
-                }
-            } else {
-                sender.sendMessage("Only players can use this command.");
-            }
-        } else if (action.equals("serialize")) {
-            if (player != null) {
-                ItemStack itemStack = player.getInventory().getItemInMainHand();
-
-                List<Map<String, Object>> list = new ArrayList<>();
-                Map<String, Object> map = new LinkedHashMap<>();
-                map.put("chance", 1);
-                map.put("quantityMin", itemStack.getAmount());
-                map.put("quantityMax", itemStack.getAmount());
-                map.put("itemStack", itemStack);
-                list.add(map);
-
-                YamlConfiguration yamlConfiguration = new YamlConfiguration();
-
-                try {
-                    Method method = yamlConfiguration.getClass().getMethod("setInlineComments", String.class, List.class);
-
-                    yamlConfiguration.set("v", list);
-                    method.invoke(yamlConfiguration, "v", List.of("Copy the below content to your config.yml"));
-                } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
-                    yamlConfiguration.set("v", null); // two latter exceptions happen after setting
-                    yamlConfiguration.set("copy_everything_below_to_config_yml", list);
-                }
-
-                long now = System.currentTimeMillis();
-                String name = "item-" + now + ".yml";
-                File file = new File(plugin.getDataFolder(), name);
-
-                try {
-                    yamlConfiguration.save(file);
-                    sender.sendMessage("Saved to plugins/Giants/" + name + ". To add it as a drop, see instructions in the file.");
-                } catch (IOException e) {
-                    sender.sendMessage("Error saving file. See console for details.");
-                    throw new RuntimeException("Error saving file to " + file.getName(), e);
-                }
-            } else {
-                sender.sendMessage("Only players can use this command.");
-            }
-        } else if (action.equals("jm")) { // TODO remove
-            if (args.length > 1) {
-                int mode = Integer.parseInt(args[1]);
-                configuration.jumpMode = mode;
-
-                sender.sendMessage("Jump mode set to " + mode);
-                sender.sendMessage("This command doesn't check if it's valid, an invalid value turns off jumping.");
-
-                if (configuration.jumpHeight == -1) {
-                    configuration.jumpHeight = configuration.defaultJumpHeight();
-                    sender.sendMessage("Jump height set to " + configuration.jumpHeight + ". Modify it with /giants jumpheight");
-                }
-            } else {
-                sender.sendMessage("Jump mode: " + configuration.jumpMode);
-            }
-        } else if (action.equals("jh")) {
-            if (args.length > 1) {
-                double height = Double.parseDouble(args[1]);
-                configuration.jumpHeight = height;
-
-                sender.sendMessage("Jump height set to " + height);
-            } else {
-                sender.sendMessage("Jump height: " + configuration.jumpHeight);
-            }
-        } else if (action.equals("jc")) {
-            if (args.length > 1) {
-                int condition = Integer.parseInt(args[1]);
-                configuration.jumpCondition = condition;
-
-                sender.sendMessage("Jump condition set to " + condition);
-            } else {
-                sender.sendMessage("Jump condition: " + configuration.jumpCondition);
-            }
-        } else if (action.equals("jd")) {
-            if (args.length > 1) {
-                int delay = Integer.parseInt(args[1]);
-                configuration.jumpDelay = delay;
-
-                sender.sendMessage("Jump delay set to " + delay);
-            } else {
-                sender.sendMessage("Jump delay: " + configuration.jumpDelay);
-            }
+        if (action.equals("serialize")) {
+            serializeCommand(sender);
         } else if (action.equals("update")) {
             if (updateCommand != null)
-                updateCommand.onCommand(sender, command, label, args);
+                updateCommand.updateCommand(sender, args);
             else
-                sender.sendMessage("Updater is disabled");
+                sender.sendMessage(ChatColor.GRAY + "Updater is disabled");
         }
 
         return true;
     }
+
+    private void serializeCommand(CommandSender sender) {
+        if (!(sender instanceof Player player)) {
+            sender.sendMessage("Only players can use this command.");
+            return;
+        }
+
+        ItemStack itemStack = player.getInventory().getItemInMainHand();
+
+        if (itemStack.getType() == Material.AIR) {
+            sender.sendMessage(ChatColor.RED + "You must hold an item in your main hand.");
+            return;
+        }
+
+        try {
+            String name = serializeDrop(player.getInventory().getItemInMainHand());
+            sender.sendMessage("Saved to plugins/Giants/" + name + ". Please follow the instructions in that file.");
+        } catch (IOException e) {
+            sender.sendMessage("Error saving file. See console for details.");
+            throw new RuntimeException("Error saving drop configuration file", e);
+        }
+    }
+
+    private String serializeDrop(ItemStack itemStack) throws IOException {
+        List<Map<String, Object>> list = new ArrayList<>();
+        Map<String, Object> map = new LinkedHashMap<>();
+        map.put("chance", 1);
+        map.put("quantityMin", itemStack.getAmount());
+        map.put("quantityMax", itemStack.getAmount());
+        map.put("itemStack", itemStack);
+        list.add(map);
+
+        YamlConfiguration yamlConfiguration = new YamlConfiguration();
+
+        try {
+            Method method = yamlConfiguration.getClass().getMethod("setInlineComments", String.class, List.class);
+
+            yamlConfiguration.set("v", list);
+            method.invoke(yamlConfiguration, "v", List.of("Copy the below content to your config.yml"));
+        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException e) {
+            yamlConfiguration.set("v", null); // two latter exceptions happen after setting
+            yamlConfiguration.set("copy_everything_below_to_config_yml", list);
+        }
+
+        long now = System.currentTimeMillis();
+        String name = "item-" + now + ".yml";
+        File file = new File(plugin.getDataFolder(), name);
+
+        yamlConfiguration.save(file);
+
+        return name;
+    }
 }

src/main/java/eu/m724/giants/GiantsPlugin.java

@@ -1,9 +1,12 @@
 package eu.m724.giants;
 
+import eu.m724.giants.ai.GiantProcessor;
+import eu.m724.giants.configuration.Configuration;
 import eu.m724.giants.updater.PluginUpdater;
 import eu.m724.giants.updater.UpdateCommand;
 import eu.m724.jarupdater.verify.VerificationException;
 import org.bstats.bukkit.Metrics;
+import org.bstats.charts.SimplePie;
 import org.bukkit.Location;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.plugin.java.JavaPlugin;
@@ -15,7 +18,7 @@ import java.io.InputStream;
 public class GiantsPlugin extends JavaPlugin implements CommandExecutor {
 	private final File configFile = new File(getDataFolder(), "config.yml");
 
-	private final Configuration configuration = new Configuration(this, configFile);
+	private static Configuration configuration;
 	private final GiantProcessor giantProcessor = new GiantProcessor(this, configuration);
 
 	@Override
@@ -24,19 +27,18 @@ public class GiantsPlugin extends JavaPlugin implements CommandExecutor {
 			saveResource("config.yml", false);
 		}
 
-		configuration.load();
+		configuration = Configuration.load(this, configFile);
 
 		giantProcessor.start();
 
-		// updater
 		PluginUpdater updater = null;
-
-		if (configuration.updater != null) {
+		UpdateCommand updateCommand = null;
+		if (configuration.updaterEnabled()) {
             try (InputStream keyInputStream = getResource("verifies_downloaded_jars.pem")) {
-                updater = PluginUpdater.build(this, getFile(), configuration.updater, keyInputStream);
+                updater = PluginUpdater.build(this, getFile(), configuration.updaterChannel(), keyInputStream);
             } catch (IOException e) {
-                e.printStackTrace();
                 getLogger().severe("Failed to load updater");
+				e.printStackTrace();
             }
 
             if (updater != null) {
@@ -51,16 +53,24 @@ public class GiantsPlugin extends JavaPlugin implements CommandExecutor {
 
                 }
                 updater.initNotifier();
+				updateCommand = new UpdateCommand(updater);
             }
+
         }
 
-		UpdateCommand updateCommand = new UpdateCommand(updater);
+		getCommand("giants").setExecutor(new GiantsCommand(this, updateCommand));
 
-		getCommand("giants").setExecutor(new GiantsCommand(this, configuration, updateCommand));
-
-		new Metrics(this, 14131);
+		Metrics metrics = new Metrics(this, 14131);
+		metrics.addCustomChart(new SimplePie("jump_mode", () -> String.valueOf(configuration.jumpMode())));
+		metrics.addCustomChart(new SimplePie("jump_condition", () -> String.valueOf(configuration.jumpCondition())));
+		metrics.addCustomChart(new SimplePie("jump_delay", () -> String.valueOf(configuration.jumpDelay())));
+		metrics.addCustomChart(new SimplePie("jump_height", () -> String.valueOf(configuration.jumpHeight())));
     }
 
+	public static Configuration getConfiguration() {
+		return configuration;
+	}
+
 	// TODO api, untested
 
 	/**

src/main/java/eu/m724/giants/ai/GiantJumper.java

@@ -0,0 +1,51 @@
+package eu.m724.giants.ai;
+
+import eu.m724.giants.GiantsPlugin;
+import eu.m724.giants.configuration.Configuration;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.util.Vector;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class GiantJumper {
+    private final Configuration configuration = GiantsPlugin.getConfiguration();
+
+    private final Map<Entity, Long> giantLastJump = new HashMap<>();
+
+    void processJump(Entity giant, Location prevLocation, Location location, Location targetLocation) {
+        long now = System.currentTimeMillis();
+        if (now - giantLastJump.getOrDefault(giant, 0L) < configuration.jumpDelay()) {
+            return;
+        }
+
+        if (giant.isOnGround()) {
+            giantLastJump.put(giant, now);
+            if (configuration.jumpCondition() == 0) {
+                if (targetLocation.subtract(location).getY() > 0) {
+                    jump(giant);
+                }
+            } else if (configuration.jumpCondition() == 1) {
+                Location delta = prevLocation.subtract(location);
+                if (targetLocation.subtract(location).getY() > 0 && (delta.getX() == 0 || delta.getZ() == 0)) {
+                    jump(giant);
+                }
+            } else if (configuration.jumpCondition() == 2) {
+                Location delta = prevLocation.subtract(location);
+                if (delta.getX() == 0 || delta.getZ() == 0) {
+                    jump(giant);
+                }
+
+            } // I could probably simplify that code
+        }
+    }
+
+    private void jump(Entity giant) {
+        if (configuration.jumpMode() == 1) {
+            giant.setVelocity(new Vector(0, configuration.jumpHeight(), 0));
+        } else if (configuration.jumpMode() == 2) {
+            giant.teleport(giant.getLocation().add(0, configuration.jumpHeight(), 0));
+        }
+    }
+}

src/main/java/eu/m724/giants/ai/GiantProcessor.java

@@ -1,5 +1,7 @@
-package eu.m724.giants;
+package eu.m724.giants.ai;
 
+import eu.m724.giants.Drop;
+import eu.m724.giants.configuration.Configuration;
 import org.bukkit.Location;
 import org.bukkit.NamespacedKey;
 import org.bukkit.entity.*;
@@ -8,7 +10,6 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.entity.EntityDeathEvent;
 import org.bukkit.event.entity.EntitySpawnEvent;
 import org.bukkit.event.world.ChunkLoadEvent;
-import org.bukkit.inventory.ItemStack;
 import org.bukkit.persistence.PersistentDataType;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.bukkit.potion.PotionEffect;
@@ -30,7 +31,6 @@ public class GiantProcessor implements Listener {
     final Configuration configuration;
     private final Logger logger;
 
-   // private final Set<Giant> trackedGiants = new HashSet<>();
     final Set<Husk> trackedHusks = new HashSet<>();
     final Map<Entity, Location> giantLocationMap = new HashMap<>();
 
@@ -45,9 +45,9 @@ public class GiantProcessor implements Listener {
         this.huskKey = new NamespacedKey(plugin, "husk");
     }
 
-    void start() {
-        if (configuration.ai) {
-            new GiantRunnable(this).runTaskTimer(plugin, 0, configuration.attackDelay);
+    public void start() {
+        if (configuration.aiEnabled()) {
+            new GiantTicker(this).schedule(plugin);
         }
 
         plugin.getServer().getPluginManager().registerEvents(this, plugin);
@@ -85,7 +85,6 @@ public class GiantProcessor implements Listener {
 
             if (giant instanceof Giant) {
                 trackedHusks.add(husk);
-                //trackedGiants.add((Giant) giant);
 
                 logger.fine("Tracking a loaded Giant at " + giant.getLocation());
             } else {
@@ -98,8 +97,8 @@ public class GiantProcessor implements Listener {
     }
 
     public void applyGiantsLogic(Giant giant) {
-        if (configuration.ai) {
-            // the husk basically moves the giant
+        if (configuration.aiEnabled()) {
+            // The husk moves the giant. That's the magic.
             LivingEntity passenger = (LivingEntity) giant.getWorld().spawnEntity(giant.getLocation(), EntityType.HUSK);
             new PotionEffect(PotionEffectType.INVISIBILITY, Integer.MAX_VALUE, 1).apply(passenger);
             passenger.setInvulnerable(true);
@@ -111,7 +110,7 @@ public class GiantProcessor implements Listener {
             trackedHusks.add((Husk) passenger);
         }
 
-        configuration.effects.forEach(giant::addPotionEffect);
+        configuration.potionEffects().forEach(giant::addPotionEffect);
     }
 
     @EventHandler
@@ -124,11 +123,11 @@ public class GiantProcessor implements Listener {
                 applyGiantsLogic(giant);
         }
 
-        if (configuration.worldBlacklist.contains(e.getLocation().getWorld().getName()))
+        if (configuration.worldBlacklist().contains(e.getLocation().getWorld().getName()))
             return;
 
         if (e.getEntityType() == EntityType.ZOMBIE) {
-            if (configuration.chance > random.nextDouble()) {
+            if (configuration.spawnChance() > random.nextDouble()) {
                 logger.fine("Trying to spawn a Giant by chance at " + e.getLocation());
                 if (isSpawnableAt(e.getLocation())) {
                     logger.fine("Spawned a Giant by chance at " + e.getLocation());
@@ -147,15 +146,10 @@ public class GiantProcessor implements Listener {
             Location location = entity.getLocation();
             logger.fine("A Giant died at " + location);
 
-            for (Drop drop : configuration.drops) {
-                logger.fine("Rolling a drop");
+            for (Drop drop : configuration.drops()) {
+                logger.fine("Rolling a drop: " + drop.itemStack().toString());
 
-                if (drop.chance > random.nextDouble()) {
-                    ItemStack is = drop.generateItemStack();
-                    entity.getWorld().dropItemNaturally(location, is);
-
-                    logger.fine("Dropped " + is);
-                }
+                drop.dropAt(location);
             }
 
             for (Entity passenger : entity.getPassengers()) {

src/main/java/eu/m724/giants/ai/GiantTicker.java

@@ -1,26 +1,29 @@
-package eu.m724.giants;
+package eu.m724.giants.ai;
 
+import eu.m724.giants.GiantsPlugin;
+import eu.m724.giants.configuration.Configuration;
 import org.bukkit.Location;
 import org.bukkit.entity.*;
+import org.bukkit.plugin.Plugin;
 import org.bukkit.scheduler.BukkitRunnable;
-import org.bukkit.util.Vector;
 
-import java.util.HashMap;
-import java.util.Map;
 import java.util.Set;
 
 /**
  * Ticks giants
  */
-public class GiantRunnable extends BukkitRunnable {
+public class GiantTicker extends BukkitRunnable {
+    private final Configuration configuration = GiantsPlugin.getConfiguration();
+    private final GiantJumper jumper = new GiantJumper();
+
     private final GiantProcessor giantProcessor;
-    private final Configuration configuration;
 
-    private final Map<Entity, Long> giantLastJump = new HashMap<>();
-
-    public GiantRunnable(GiantProcessor giantProcessor) {
+    public GiantTicker(GiantProcessor giantProcessor) {
         this.giantProcessor = giantProcessor;
-        this.configuration = giantProcessor.configuration;
+    }
+
+    void schedule(Plugin plugin) {
+        this.runTaskTimer(plugin, 0, configuration.attackDelay());
     }
 
     @Override
@@ -33,13 +36,13 @@ public class GiantRunnable extends BukkitRunnable {
                 if (giant instanceof Giant) {
                     if (giant.isValid()) { // TODO reconsider
                         giant.getWorld().getNearbyEntities(
-                                giant.getBoundingBox().expand(configuration.attackReach),
+                                giant.getBoundingBox().expand(configuration.attackReach()),
                                 e -> (e instanceof Player && !e.isInvulnerable())
-                        ).forEach(p -> ((Player) p).damage(configuration.attackDamage, giant));
+                        ).forEach(p -> ((Player) p).damage(configuration.attackDamage(), giant));
                         giant.setRotation(huskLocation.getYaw(), huskLocation.getPitch());
 
-                        // jumping
-                        if (configuration.jumpMode != 0) {
+                        // TODO move whole into that class?
+                        if (configuration.jumpMode() != 0) {
                             // tracking location is only required for jumping
                             Location prevLocation = giantProcessor.giantLocationMap.get(giant);
                             Location location = giant.getLocation();
@@ -50,7 +53,7 @@ public class GiantRunnable extends BukkitRunnable {
 
                             LivingEntity target = husk.getTarget();
                             if (target != null) {
-                                processJump(giant, prevLocation, location, target.getLocation());
+                                jumper.processJump(giant, prevLocation, location, target.getLocation());
                             }
                         }
                     }
@@ -68,38 +71,5 @@ public class GiantRunnable extends BukkitRunnable {
         }
     }
 
-    private void processJump(Entity giant, Location prevLocation, Location location, Location targetLocation) {
-        long now = System.currentTimeMillis();
-        if (now - giantLastJump.getOrDefault(giant, 0L) < configuration.jumpDelay) {
-            return;
-        }
 
-        if (giant.isOnGround()) {
-            giantLastJump.put(giant, now);
-            if (configuration.jumpCondition == 0) {
-                if (targetLocation.subtract(location).getY() > 0) {
-                    jump(giant);
-                }
-            } else if (configuration.jumpCondition == 1) {
-                Location delta = prevLocation.subtract(location);
-                if (targetLocation.subtract(location).getY() > 0 && (delta.getX() == 0 || delta.getZ() == 0)) {
-                    jump(giant);
-                }
-            } else if (configuration.jumpCondition == 2) {
-                Location delta = prevLocation.subtract(location);
-                if (delta.getX() == 0 || delta.getZ() == 0) {
-                    jump(giant);
-                }
-
-            } // I could probably simplify that code
-        }
-    }
-
-    private void jump(Entity giant) {
-        if (configuration.jumpMode == 1) {
-            giant.setVelocity(new Vector(0, configuration.jumpHeight, 0));
-        } else if (configuration.jumpMode == 2) {
-            giant.teleport(giant.getLocation().add(0, configuration.jumpHeight, 0));
-        }
-    }
 }

src/main/java/eu/m724/giants/configuration/Configuration.java

@@ -0,0 +1,128 @@
+package eu.m724.giants.configuration;
+
+import eu.m724.giants.Drop;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.logging.Logger;
+
+public record Configuration(
+        boolean updaterEnabled,
+        String updaterChannel,
+
+        boolean aiEnabled,
+
+        double attackDamage,
+        int attackDelay,
+        Vector attackReach,
+
+        int jumpMode,
+        int jumpCondition,
+        int jumpDelay,
+        double jumpHeight,
+
+        double spawnChance,
+        List<String> worldBlacklist,
+        List<PotionEffect> potionEffects,
+        List<Drop> drops
+
+) {
+    // TODO not use logger here
+    private static Logger LOGGER;
+
+    public static Configuration load(Plugin plugin, File file) {
+        LOGGER = Logger.getLogger(plugin.getLogger().getName() + ".Configuration");
+
+        YamlConfiguration config = YamlConfiguration.loadConfiguration(file);
+
+        boolean updaterEnabled = true;
+        String updaterChannel = config.getString("updater", "release");
+
+        if (updaterChannel.equalsIgnoreCase("false")) {
+            updaterEnabled = false;
+        }
+
+
+        boolean aiEnabled = config.getBoolean("ai");
+
+        double attackDamage = config.getDouble("attackDamage");
+        int attackDelay = config.getInt("attackDelay");
+        Vector attackReach = new Vector(
+                config.getDouble("attackReach"),
+                config.getDouble("attackVerticalReach"),
+                config.getDouble("attackReach")
+        );
+
+        int jumpMode = config.getInt("jumpMode");
+        int jumpCondition = config.getInt("jumpCondition");
+        int jumpDelay = config.getInt("jumpDelay");
+        double jumpHeight = config.getDouble("jumpHeight", defaultJumpHeight(jumpMode));
+
+        double spawnChance = config.getDouble("chance");
+
+        List<String> worldBlacklist = config.getStringList("blacklist");
+
+        List<PotionEffect> potionEffects = config.getStringList("effects").stream()
+                .map(Configuration::makePotionEffect)
+                .filter(Objects::nonNull)
+                .toList();
+
+        List<Drop> drops = config.getMapList("drops").stream()
+                .map(Configuration::makeDrop)
+                .filter(Objects::nonNull)
+                .toList();
+
+        return new Configuration(
+                updaterEnabled, updaterChannel, aiEnabled, attackDamage, attackDelay, attackReach, jumpMode, jumpCondition, jumpDelay, jumpHeight, spawnChance, worldBlacklist, potionEffects, drops
+        );
+    }
+
+    private static double defaultJumpHeight(int jumpMode) {
+        return switch (jumpMode) {
+            case 1, 2 -> 0.42;
+            case 3, 4 -> 1.2;
+            default -> -1;
+        };
+    }
+
+    private static Drop makeDrop(Map<?, ?> dropMap) {
+        try {
+            return ListParsers.makeDrop(dropMap);
+        } catch (ParseException e) {
+            LOGGER.warning("Failed to parse drop:");
+            LOGGER.warning("  At: " + dropMap);
+            LOGGER.warning("  " + e.getMessage());
+        }
+
+        return null;
+    }
+
+    private static PotionEffect makePotionEffect(String line) {
+        try {
+            return ListParsers.makePotionEffect(line);
+        } catch (ParseException e) {
+            LOGGER.warning("Failed to parse potion effect:");
+            LOGGER.warning("  At line: " + line);
+            LOGGER.warning("  " + e.getMessage());
+        }
+
+        return null;
+    }
+
+
+    static void assertParse(boolean assertion, String message) throws ParseException {
+        if (!assertion) throw new ParseException(message);
+    }
+
+    public static class ParseException extends Exception {
+        public ParseException(String message) {
+            super(message);
+        }
+    }
+}

src/main/java/eu/m724/giants/configuration/ListParsers.java

@@ -0,0 +1,69 @@
+package eu.m724.giants.configuration;
+
+import eu.m724.giants.Drop;
+import eu.m724.giants.configuration.Configuration.ParseException;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+
+import java.util.Map;
+
+import static eu.m724.giants.configuration.Configuration.assertParse;
+
+public class ListParsers {
+    public static PotionEffect makePotionEffect(String line) throws ParseException {
+        if (line == null || line.trim().isEmpty()) {
+            throw new ParseException("Cannot parse empty or null line into a PotionEffect.");
+        }
+
+        String[] parts = line.split(":", 2);
+        assertParse(parts.length == 2, "Invalid PotionEffect format (expected 'TYPE:AMPLIFIER')");
+
+        PotionEffectType effectType = PotionEffectType.getByName(parts[0].trim());
+        assertParse(effectType != null, "Unknown PotionEffectType: " + parts[0].trim());
+
+        int amplifier;
+        try {
+            amplifier = Integer.parseInt(parts[1].trim());
+        } catch (IllegalArgumentException e) {
+            throw new ParseException("Invalid amplifier format (expected integer): " + parts[1].trim());
+        }
+
+        assertParse(amplifier > 0, "Amplifier must be bigger than 0, is: " + amplifier);
+        assertParse(amplifier < 256, "Amplifier must be at most 255, is: " + amplifier);
+
+        return new PotionEffect(effectType, Integer.MAX_VALUE, amplifier);
+    }
+
+    // TODO refactor this
+    public static Drop makeDrop(Map<?, ?> dropMap) throws ParseException {
+        ItemStack itemStack;
+        if (dropMap.containsKey("itemStack")) {
+            itemStack = (ItemStack) dropMap.get("itemStack");
+        } else {
+            Material material = Material.getMaterial((String) dropMap.get("material"));
+            assertParse(material != null, "Invalid Material: " + dropMap.get("material"));
+
+            itemStack = new ItemStack(material, 1);
+        }
+
+        int min = (int) dropMap.get("quantityMin");
+        int max = (int) dropMap.get("quantityMax");
+        assertParse(min > 0, "Minimum quantity must be more than 0, is: " + min);
+        assertParse(max > 0, "Maximum quantity must be more than 0, is: " + max);
+        assertParse(min < 100, "Minimum quantity must be less than 100, is: " + min);
+        assertParse(max < 100, "Maximum quantity must be less than 100, is: " + max);
+
+        double chance = ((Number) dropMap.get("chance")).doubleValue();
+
+        if (chance > 1 && chance <= 100) {
+            chance /= 100; // user might have misunderstood
+        }
+
+        assertParse(chance > 0, "Chance must be more than 0, is: " + chance);
+        assertParse(chance <= 1, "Chance must be at most 1, is: " + chance);
+
+        return new Drop(itemStack, min, max, chance);
+    }
+}

src/main/java/eu/m724/giants/updater/UpdateCommand.java

@@ -4,7 +4,6 @@ import net.md_5.bungee.api.ChatColor;
 import net.md_5.bungee.api.chat.ClickEvent;
 import net.md_5.bungee.api.chat.HoverEvent;
 import net.md_5.bungee.api.chat.TextComponent;
-import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
@@ -37,79 +36,71 @@ public class UpdateCommand {
         }
     }
 
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        if (updater == null) {
-            sender.sendMessage("Updater is disabled");
-            return true;
-        }
-
-        sender.sendMessage("Please wait...");
-        sender.sendMessage("Channel: " + updater.getEnvironment().getChannel());
+    public void updateCommand(CommandSender sender, String[] args) {
+        sender.sendMessage(ChatColor.GRAY + "Please wait...");
+        sender.sendMessage(ChatColor.GRAY + "Channel: " + updater.getEnvironment().getChannel());
 
         if (updater.updatePending) {
-            sender.sendMessage("Server restart required");
+            sender.sendMessage(ChatColor.YELLOW + "" + ChatColor.BOLD + "(!) Server restart required");
         }
 
-        if (args.length == 1) { // remember this function is proxied
+        String action = args.length > 1 ? args[1] : null; // remember this function is proxied
+
+        if (action == null) {
             updater.getLatestVersion().thenAccept(metadata -> {
+                updater.getCurrentVersion().thenAccept(metadata2 -> {
+                    sender.sendMessage(ChatColor.GOLD + "You're on Giants " + metadata2.getLabel() + " released " + formatDate(metadata2.getTimestamp()));
+                    sendChangelogMessage(sender, metadata2.getChangelogUrl());
+                }).exceptionally(e -> {
+                    sender.sendMessage(ChatColor.RED + "Error retrieving information about current version, see console for details. " + e.getMessage());
+                    e.printStackTrace();
+                    return null;
+                });
+
                 if (metadata != null) {
-                    sender.sendMessage("An update is available!");
-                    sender.sendMessage("Giants " + metadata.getLabel() + " released " + formatDate(metadata.getTimestamp()));
+                    sender.sendMessage(ChatColor.YELLOW + "" + ChatColor.BOLD + "An update is available!");
+                    sender.sendMessage(ChatColor.GOLD + "Giants " + metadata.getLabel() + " released " + formatDate(metadata.getTimestamp()));
                     sendChangelogMessage(sender, metadata.getChangelogUrl());
-                    sender.sendMessage("To download: /giants update download");
+                    sender.sendMessage(ChatColor.GOLD + "To download: /giants update download");
                 } else {
-                    sender.sendMessage("No new updates");
-                    updater.getCurrentVersion().thenAccept(metadata2 -> {
-                        sender.sendMessage("You're on Giants " + metadata2.getLabel() + " released " + formatDate(metadata2.getTimestamp()));
-                        sendChangelogMessage(sender, metadata2.getChangelogUrl());
-                    }).exceptionally(e -> {
-                        sender.sendMessage("Error retrieving information about current version, see console for details. " + e.getMessage());
-                        e.printStackTrace();
-                        return null;
-                    });
+                    sender.sendMessage(ChatColor.GRAY + "No new updates");
                 }
             }).exceptionally(e -> {
-                sender.sendMessage("Error checking for update. See console for details.");
+                sender.sendMessage(ChatColor.RED + "Error checking for update. See console for details.");
                 e.printStackTrace();
                 return null;
             });
         } else {
-            String action = args[1]; // remember this function is proxied
-
             if (!sender.hasPermission("giants.update." + action)) {
-                sender.sendMessage("You don't have permission to use this command, or it doesn't exist.");
-                return true;
+                sender.sendMessage(ChatColor.GRAY + "You don't have permission to use this command, or it doesn't exist.");
+                return;
             }
 
             if (action.equals("download")) {
-                sender.sendMessage("Started download");
+                sender.sendMessage(ChatColor.GRAY + "Started download");
 
                 updater.downloadLatestVersion().thenAccept(file -> {
-                    sender.sendMessage("Download finished, install with /giants update install");
+                    sender.sendMessage(ChatColor.GREEN + "Download finished, install with /giants update install"); // TODO make this clickable
                 }).exceptionally(e -> {
-                    sender.sendMessage("Download failed. See console for details.");
+                    sender.sendMessage(ChatColor.RED + "Download failed. See console for details.");
                     e.printStackTrace();
                     return null;
                 });
             } else if (action.equals("install")) {
                 try {
                     updater.installLatestVersion().thenAccept(v -> {
-                        sender.sendMessage("Installation completed, restart server to apply.");
+                        sender.sendMessage(ChatColor.GREEN + "Installation completed, restart server to apply.");
                         updater.updatePending = true;
                     }).exceptionally(e -> {
-                        sender.sendMessage("Install failed, see console for details. " + e.getMessage());
+                        sender.sendMessage(ChatColor.RED + "Install failed, see console for details. " + e.getMessage());
                         e.printStackTrace();
                         return null;
                     });
                 } catch (NoSuchFileException e) {
-                    sender.sendMessage("First, download the update: /giants update download");
+                    sender.sendMessage(ChatColor.YELLOW + "Download the update first: /giants update download");
                 }
-            } else {
-                return false;
             }
         }
-
-        return true;
     }
 
     private String formatDate(long timestamp) {

src/main/java/eu/m724/giants/updater/UpdateNotifier.java

@@ -9,7 +9,6 @@ import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.scheduler.BukkitRunnable;
 
-import java.io.IOException;
 import java.util.concurrent.CompletionException;
 import java.util.function.Consumer;
 
@@ -36,11 +35,7 @@ public class UpdateNotifier extends BukkitRunnable implements Listener { // TODO
         try {
             latestVersion = updater.getLatestVersion().join();
         } catch (CompletionException e) {
-            Throwable ex = e.getCause();
-
-            if (ex instanceof IOException)
-                plugin.getLogger().info("error trying to contact update server: " + ex.getMessage());
-            else e.printStackTrace();
+            plugin.getLogger().info("Error trying to contact update server: " + e.getCause().getMessage());
         }
 
         if (latestVersion == null) return;
@@ -53,7 +48,6 @@ public class UpdateNotifier extends BukkitRunnable implements Listener { // TODO
         }
 
         updateConsumer.accept(latestVersion);
-
     }
 
     @EventHandler

src/main/resources/config.yml

@@ -10,6 +10,20 @@ updater: true
 # If disabled, the giant will not move or attack
 ai: true
 
+# In hearts, 0.5 is half a heart
+attackDamage: 1.0
+
+# Attack delay / speed, in ticks
+# 20 is 1 second
+attackDelay: 20
+
+# Self-explanatory, 0 will attack only colliding (touching) entities
+# There's no wall check yet, so it will hit through walls
+attackReach: 2
+
+# Vertical reach
+attackVerticalReach: 1
+
 # Makes giants jump. Very experimental.
 # I prefer velocity mode
 # 0 - disabled
@@ -27,20 +41,6 @@ jumpDelay: 200
 # -1: auto
 jumpHeight: -1
 
-# In hearts, 0.5 is half a heart
-attackDamage: 1.0
-
-# Attack delay / speed, in ticks
-# 20 is 1 second
-attackDelay: 20
-
-# Self-explanatory, 0 will attack only colliding (touching) entities
-# There's no wall check yet, so it will hit through walls
-attackReach: 2
-
-# Vertical reach
-attackVerticalReach: 1
-
 ###
 
 # Chance of a zombie becoming a giant. This is per each zombie spawn, natural or not.

src/main/resources/plugin.yml

@@ -9,10 +9,8 @@ load: STARTUP
 commands:
   giants:
     description: Utility command for Giants
+
 permissions:
-  giants.command.spawn:
-    description: Permits /giants spawn
-    default: op
   giants.command.serialize:
     description: Permits /giants serialize
     default: op