refactor: migrate package from com.loki to dev.loki

- Change base package from com.loki to dev.loki across all Java files
- Update plugin.yml main class path
- Fix ConfigParseException imports in test files
- Update build.gradle.kts relocate patterns
- Add missing imports in ConfigLoaderTest.java
- Update TODO.md with current status

BREAKING CHANGE: Package namespace changed from com.loki to dev.loki

src/main/java/dev/loki/lomines/block/BukkitBlockSetter.java

@@ -0,0 +1,104 @@
+package dev.loki.lomines.block;
+
+import dev.loki.lomines.LoMinesPlugin;
+import dev.loki.lomines.util.ValidationUtils;
+import dev.loki.lomines.util.location.Cuboid;
+import dev.lolib.scheduler.Scheduler;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.data.BlockData;
+
+import java.util.List;
+import java.util.Map;
+import java.util.function.IntConsumer;
+
+/**
+ * BlockSetter implementation for vanilla Minecraft blocks.
+ * Uses Bukkit API to set blocks with optimal performance settings.
+ */
+public final class BukkitBlockSetter extends BlockSetter {
+
+    private final Map<String, Double> weights;
+    private final LoMinesPlugin plugin;
+
+    public BukkitBlockSetter(Map<String, Double> weights, LoMinesPlugin plugin) {
+        this.weights = weights;
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void fill(Cuboid region, IntConsumer callback) {
+        Scheduler.get(plugin).runAsync(() -> {
+            int count = fillSync(region);
+
+            Scheduler.get(plugin).run(() -> {
+                callback.accept(count);
+            });
+        });
+    }
+
+    @Override
+    public void fillAtLocations(List<Location> locations, IntConsumer callback) {
+        if (locations == null || locations.isEmpty()) {
+            Scheduler.get(plugin).run(() -> callback.accept(0));
+            return;
+        }
+        Scheduler.get(plugin).runAsync(() -> {
+            int count = fillAtLocationsSync(locations);
+            Scheduler.get(plugin).run(() -> callback.accept(count));
+        });
+    }
+
+    private int fillSync(Cuboid region) {
+        int count = 0;
+        World world = region.getWorld();
+
+        for (int x = region.getMinX(); x <= region.getMaxX(); x++) {
+            for (int y = region.getMinY(); y <= region.getMaxY(); y++) {
+                for (int z = region.getMinZ(); z <= region.getMaxZ(); z++) {
+                    BlockData data = sampleBlockData();
+                    world.getBlockAt(x, y, z).setBlockData(data, false);
+                    count++;
+                }
+            }
+        }
+
+        return count;
+    }
+
+    private int fillAtLocationsSync(List<Location> locations) {
+        int count = 0;
+        for (Location loc : locations) {
+            if (loc.getWorld() == null) {
+                continue;
+            }
+            BlockData data = sampleBlockData();
+            loc.getBlock().setBlockData(data, false);
+            count++;
+        }
+        return count;
+    }
+
+    private BlockData sampleBlockData() {
+        // Simple weighted random selection
+        double totalWeight = weights.values().stream().mapToDouble(Double::doubleValue).sum();
+        double random = Math.random() * totalWeight;
+
+        double currentWeight = 0;
+        for (Map.Entry<String, Double> entry : weights.entrySet()) {
+            currentWeight += entry.getValue();
+            if (random <= currentWeight) {
+                // Convert string key to BlockData
+                Material material = ValidationUtils.parseMaterialOrDefault(entry.getKey(), Material.STONE);
+                return Bukkit.createBlockData(material);
+            }
+        }
+
+        // Fallback to first entry
+        String firstKey = weights.keySet().iterator().next();
+        Material material = ValidationUtils.parseMaterialOrDefault(firstKey, Material.STONE);
+        return Bukkit.createBlockData(material);
+    }
+}