boba/LoMines
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

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

Browse source 
- 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
This commit is contained in:
loki5512344 2026-05-31 21:34:44 +02:00
parent 41924ea97f
commit f4e9458544
87 changed files with 2185 additions and 1767 deletions
Download patch file Download diff file Expand all files Collapse all files

50
src/main/java/com/loki/lomines/integration/IntegrationManager.java
View file

@ -1,50 +0,0 @@
package com.loki.lomines.integration;
import com.loki.lomines.LoMinesPlugin;
import org.bukkit.Bukkit;
/**
* Manages integrations with external plugins.
* This is a placeholder implementation that will be completed in task 10.1.
*/
public final class IntegrationManager {
private final LoMinesPlugin plugin;
public IntegrationManager(LoMinesPlugin plugin) {
this.plugin = plugin;
}
/**
* Initializes all available integrations.
*/
public void initAll() {
// Check for PlaceholderAPI
if (isPluginEnabled("PlaceholderAPI")) {
plugin.loLogger().info("PlaceholderAPI integration available");
}
// Check for WorldGuard
if (isPluginEnabled("WorldGuard")) {
plugin.loLogger().info("WorldGuard integration available");
}
// Check for Oraxen
if (isPluginEnabled("Oraxen")) {
plugin.loLogger().info("Oraxen integration available");
}
// Check for ItemsAdder
if (isPluginEnabled("ItemsAdder")) {
plugin.loLogger().info("ItemsAdder integration available");
}
}
/**
* Checks if a plugin is enabled.
*/
public boolean isPluginEnabled(String pluginName) {
return Bukkit.getPluginManager().getPlugin(pluginName) != null &&
Bukkit.getPluginManager().isPluginEnabled(pluginName);
}
}

25
src/main/java/com/loki/lomines/ComponentInitializer.java → src/main/java/dev/loki/lomines/ComponentInitializer.java
View file

@ -1,10 +1,10 @@
package com.loki.lomines;
package dev.loki.lomines;
import com.loki.lomines.core.MineTicker;
import com.loki.lomines.core.Mines;
import com.loki.lomines.data.stats.StatsManager;
import com.loki.lomines.integration.IntegrationManager;
import com.loki.lomines.wand.GroupWandManager;
import dev.loki.lomines.core.MineTicker;
import dev.loki.lomines.core.Mines;
import dev.loki.lomines.data.stats.StatsManager;
import dev.loki.lomines.integration.IntegrationManager;
import dev.loki.lomines.wand.GroupWandManager;
import dev.lolib.commands.CommandManager;
import java.io.IOException;
@ -73,10 +73,11 @@ final class ComponentInitializer {
}
record Components(
Mines mines,
GroupWandManager groupWandManager,
StatsManager statsManager,
CommandManager commandManager,
IntegrationManager integrationManager
) {}
Mines mines,
GroupWandManager groupWandManager,
StatsManager statsManager,
CommandManager commandManager,
IntegrationManager integrationManager
) {
}
}

16
src/main/java/com/loki/lomines/LoMinesPlugin.java → src/main/java/dev/loki/lomines/LoMinesPlugin.java
View file

@ -1,10 +1,10 @@
package com.loki.lomines;
package dev.loki.lomines;
import com.loki.lomines.core.MineTicker;
import com.loki.lomines.core.Mines;
import com.loki.lomines.data.stats.StatsManager;
import com.loki.lomines.integration.IntegrationManager;
import com.loki.lomines.wand.GroupWandManager;
import dev.loki.lomines.core.MineTicker;
import dev.loki.lomines.core.Mines;
import dev.loki.lomines.data.stats.StatsManager;
import dev.loki.lomines.integration.IntegrationManager;
import dev.loki.lomines.wand.GroupWandManager;
import dev.lolib.commands.CommandManager;
import dev.lolib.core.LoPlugin;
import dev.lolib.core.dependency.DependencyManager;
@ -73,6 +73,10 @@ public final class LoMinesPlugin extends LoPlugin {
loLogger().info("Statistics saved successfully");
}
if (integrationManager != null) {
integrationManager.shutdown();
}
loLogger().info("LoMines has been disabled!");
} catch (Exception e) {
loLogger().error("Error during plugin shutdown: " + e.getMessage());

20
src/main/java/com/loki/lomines/RegistrationManager.java → src/main/java/dev/loki/lomines/RegistrationManager.java
View file

@ -1,14 +1,14 @@
package com.loki.lomines;
package dev.loki.lomines;
import com.loki.lomines.command.AdminCommands;
import com.loki.lomines.command.MaskCommands;
import com.loki.lomines.command.PlayerCommands;
import com.loki.lomines.command.StatsCommands;
import com.loki.lomines.integration.IntegrationManager;
import com.loki.lomines.listener.BlockBreakListener;
import com.loki.lomines.listener.GroupGuiListener;
import com.loki.lomines.listener.PlayerInteractListener;
import com.loki.lomines.listener.PlayerJoinListener;
import dev.loki.lomines.command.AdminCommands;
import dev.loki.lomines.command.MaskCommands;
import dev.loki.lomines.command.PlayerCommands;
import dev.loki.lomines.command.StatsCommands;
import dev.loki.lomines.integration.IntegrationManager;
import dev.loki.lomines.listener.BlockBreakListener;
import dev.loki.lomines.listener.GroupGuiListener;
import dev.loki.lomines.listener.PlayerInteractListener;
import dev.loki.lomines.listener.PlayerJoinListener;
import dev.lolib.commands.CommandManager;
/**

16
src/main/java/com/loki/lomines/block/BlockSetter.java → src/main/java/dev/loki/lomines/block/BlockSetter.java
View file

@ -1,6 +1,6 @@
package com.loki.lomines.block;
package dev.loki.lomines.block;
import com.loki.lomines.util.Cuboid;
import dev.loki.lomines.util.location.Cuboid;
import org.bukkit.Location;
import java.util.List;
@ -9,27 +9,27 @@ import java.util.function.IntConsumer;
/**
* Abstract base class for block setting strategies.
* Provides a template for filling mine regions with blocks.
*
*
* <p>Implementations:</p>
* <ul>
* <li>BukkitBlockSetter - For vanilla Minecraft blocks</li>
* <li>OraxenBlockSetter - For Oraxen custom blocks</li>
* <li>ItemsAdderBlockSetter - For ItemsAdder custom blocks</li>
* </ul>
*
*
* <p>This is a placeholder that will be fully implemented in task 2.7.</p>
*/
public abstract class BlockSetter {
/**
* Fills a cuboid region with blocks asynchronously.
* The callback is invoked in the main thread after completion.
*
* @param region The region to fill
*
* @param region The region to fill
* @param callback Called with the number of blocks set when complete
*/
public abstract void fill(Cuboid region, IntConsumer callback);
/**
* Places random weighted blocks only at the given locations (mask mode).
*/

39
src/main/java/com/loki/lomines/block/BukkitBlockSetter.java → src/main/java/dev/loki/lomines/block/BukkitBlockSetter.java
View file

@ -1,16 +1,15 @@
package com.loki.lomines.block;
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 com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.util.Cuboid;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.block.data.BlockData;
import org.bukkit.Location;
import java.util.List;
import java.util.Map;
import java.util.function.IntConsumer;
@ -20,26 +19,26 @@ import java.util.function.IntConsumer;
* 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()) {
@ -51,11 +50,11 @@ public final class BukkitBlockSetter extends BlockSetter {
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++) {
@ -65,10 +64,10 @@ public final class BukkitBlockSetter extends BlockSetter {
}
}
}
return count;
}
private int fillAtLocationsSync(List<Location> locations) {
int count = 0;
for (Location loc : locations) {
@ -81,25 +80,25 @@ public final class BukkitBlockSetter extends BlockSetter {
}
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 = Material.valueOf(entry.getKey().toUpperCase());
Material material = ValidationUtils.parseMaterialOrDefault(entry.getKey(), Material.STONE);
return Bukkit.createBlockData(material);
}
}
// Fallback to first entry
String firstKey = weights.keySet().iterator().next();
Material material = Material.valueOf(firstKey.toUpperCase());
Material material = ValidationUtils.parseMaterialOrDefault(firstKey, Material.STONE);
return Bukkit.createBlockData(material);
}
}

0
src/main/java/com/loki/lomines/block/ItemsAdderBlockSetter.java → src/main/java/dev/loki/lomines/block/ItemsAdderBlockSetter.java.disabled
View file

0
src/main/java/com/loki/lomines/block/OraxenBlockSetter.java → src/main/java/dev/loki/lomines/block/OraxenBlockSetter.java.disabled
View file

2
src/main/java/com/loki/lomines/block/package-info.java → src/main/java/dev/loki/lomines/block/package-info.java
View file

@ -9,4 +9,4 @@
* <li>{@code ItemsAdderBlockSetter} - Implementation for ItemsAdder custom blocks</li>
* </ul>
*/
package com.loki.lomines.block;
package dev.loki.lomines.block;

52
src/main/java/com/loki/lomines/command/AdminCommands.java → src/main/java/dev/loki/lomines/command/AdminCommands.java
View file

@ -1,8 +1,10 @@
package com.loki.lomines.command;
package dev.loki.lomines.command;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.core.Mine;
import com.loki.lomines.core.Mines;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.core.Mine;
import dev.loki.lomines.core.Mines;
import dev.loki.lomines.util.ErrorHandler;
import dev.loki.lomines.util.MessageFormatter;
import dev.lolib.commands.annotation.Arg;
import dev.lolib.commands.annotation.Command;
import dev.lolib.commands.annotation.Subcommand;
@ -21,10 +23,12 @@ public class AdminCommands {
private final LoMinesPlugin plugin;
private final Mines mines;
private final ErrorHandler errorHandler;
public AdminCommands(LoMinesPlugin plugin) {
this.plugin = plugin;
this.mines = plugin.getMines();
this.errorHandler = new ErrorHandler(plugin.getLogger(), "[LoMines] ");
}
/**
@ -35,15 +39,15 @@ public class AdminCommands {
public void create(CommandSender sender, @Arg("name") String name) {
try {
mines.create(name);
sender.sendMessage(Component.text("Successfully created mine: " + name));
sender.sendMessage(MessageFormatter.success("Successfully created mine: " + name));
sender.sendMessage(Component.text(
"Edit selection & contents in plugins/LoMines/mines/" + name + ".yml — "
+ "for shape-based ore (not full cuboid), paint mask.marker blocks, then: /lm maskscan " + name));
"Edit selection & contents in plugins/LoMines/mines/" + name + ".yml — "
+ "for shape-based ore (not full cuboid), paint mask.marker blocks, then: /lm maskscan " + name));
} catch (IllegalArgumentException e) {
sender.sendMessage(Component.text("Mine already exists: " + name));
errorHandler.handleNotFound(sender, "Mine already exists", name);
} catch (IOException e) {
sender.sendMessage(Component.text("Failed to create mine: " + e.getMessage()));
plugin.loLogger().error("Failed to create mine " + name, e);
errorHandler.handleError(sender, "Failed to create mine: " + e.getMessage(),
"Failed to create mine " + name, e);
}
}
@ -55,12 +59,12 @@ public class AdminCommands {
public void delete(CommandSender sender, @Arg("name") String name) {
try {
mines.delete(name);
sender.sendMessage(Component.text("Successfully deleted mine: " + name));
sender.sendMessage(MessageFormatter.success("Successfully deleted mine: " + name));
} catch (IllegalArgumentException e) {
sender.sendMessage(Component.text("Mine not found: " + name));
errorHandler.handleNotFound(sender, "Mine", name);
} catch (IOException e) {
sender.sendMessage(Component.text("Failed to delete mine: " + e.getMessage()));
plugin.loLogger().error("Failed to delete mine " + name, e);
errorHandler.handleError(sender, "Failed to delete mine: " + e.getMessage(),
"Failed to delete mine " + name, e);
}
}
@ -70,16 +74,16 @@ public class AdminCommands {
*/
@Subcommand(value = "reset", permission = "lomines.admin.reset")
public void reset(
CommandSender sender,
@Arg("mine") String mineName,
@Arg(value = "silent", optional = true, defaultValue = "false") boolean silent
CommandSender sender,
@Arg("mine") String mineName,
@Arg(value = "silent", optional = true, defaultValue = "false") boolean silent
) {
try {
Mine mine = mines.get(mineName);
mine.reset(silent);
sender.sendMessage(Component.text("Resetting mine: " + mineName));
sender.sendMessage(MessageFormatter.success("Resetting mine: " + mineName));
} catch (IllegalArgumentException e) {
sender.sendMessage(Component.text("Mine not found: " + mineName));
errorHandler.handleNotFound(sender, "Mine", mineName);
}
}
@ -90,17 +94,13 @@ public class AdminCommands {
@Subcommand(value = "reload", permission = "lomines.admin.reload")
public void reload(CommandSender sender) {
try {
// Stop all existing mines
mines.getAll().forEach(Mine::stop);
// Reload all mines
mines.loadAll();
int count = mines.getAll().size();
sender.sendMessage(Component.text("Successfully reloaded " + count + " mine(s)"));
sender.sendMessage(MessageFormatter.success("Successfully reloaded " + count + " mine(s)"));
} catch (IOException e) {
sender.sendMessage(Component.text("Failed to reload mines: " + e.getMessage()));
plugin.loLogger().error("Failed to reload mines", e);
errorHandler.handleError(sender, "Failed to reload mines: " + e.getMessage(),
"Failed to reload mines", e);
}
}

29
src/main/java/com/loki/lomines/command/MaskCommands.java → src/main/java/dev/loki/lomines/command/MaskCommands.java
View file

@ -1,13 +1,14 @@
package com.loki.lomines.command;
package dev.loki.lomines.command;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.core.Mines;
import com.loki.lomines.data.config.ConfigParseException;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.core.Mines;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import dev.loki.lomines.util.ErrorHandler;
import dev.loki.lomines.util.MessageFormatter;
import dev.lolib.commands.annotation.Arg;
import dev.lolib.commands.annotation.Command;
import dev.lolib.commands.annotation.Subcommand;
import dev.lolib.scheduler.Scheduler;
import net.kyori.adventure.text.Component;
import org.bukkit.command.CommandSender;
import java.io.IOException;
@ -21,29 +22,27 @@ public class MaskCommands {
private final LoMinesPlugin plugin;
private final Mines mines;
private final ErrorHandler errorHandler;
public MaskCommands(LoMinesPlugin plugin) {
this.plugin = plugin;
this.mines = plugin.getMines();
this.errorHandler = new ErrorHandler(plugin.getLogger(), "[LoMines] ");
}
/**
* Scans selection for marker blocks ({@code mask.marker}, default pink concrete), saves mask positions and switches mine to mask fill mode.
* Run from the server main thread (scheduled automatically).
*/
@Subcommand(value = "maskscan", permission = "lomines.admin.maskscan")
public void maskScan(CommandSender sender, @Arg("mine") String name) {
Scheduler.get(plugin).run(() -> {
try {
int n = mines.scanAndSaveMask(name);
sender.sendMessage(Component.text(
"Mask mode: saved " + n + " cell(s) for mine '" + name
+ "'. Reset will spawn ore only at those positions."));
sender.sendMessage(MessageFormatter.success(
"Mask mode: saved " + n + " cell(s) for mine '" + name
+ "'. Reset will spawn ore only at those positions."));
} catch (IllegalArgumentException e) {
sender.sendMessage(Component.text("Mine not found: " + name));
errorHandler.handleNotFound(sender, "Mine", name);
} catch (IOException | ConfigParseException e) {
sender.sendMessage(Component.text("Mask scan failed: " + e.getMessage()));
plugin.loLogger().error("maskscan failed for " + name, e);
errorHandler.handleError(sender, "Mask scan failed: " + e.getMessage(),
"maskscan failed for " + name, e);
}
});
}

17
src/main/java/com/loki/lomines/command/PlayerCommands.java → src/main/java/dev/loki/lomines/command/PlayerCommands.java
View file

@ -1,7 +1,8 @@
package com.loki.lomines.command;
package dev.loki.lomines.command;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.wand.GroupWandItem;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.util.ErrorHandler;
import dev.loki.lomines.wand.GroupWandItem;
import dev.lolib.commands.annotation.Arg;
import dev.lolib.commands.annotation.Command;
import dev.lolib.commands.annotation.Subcommand;
@ -18,27 +19,29 @@ import org.bukkit.entity.Player;
public class PlayerCommands {
private final LoMinesPlugin plugin;
private final ErrorHandler errorHandler;
public PlayerCommands(LoMinesPlugin plugin) {
this.plugin = plugin;
this.errorHandler = new ErrorHandler(plugin.getLogger(), "[LoMines] ");
}
@Subcommand(value = "wand", permission = "lomines.admin.wand")
public void wand(CommandSender sender) {
if (!(sender instanceof Player player)) {
sender.sendMessage(Component.text("Только для игрока."));
errorHandler.sendError(sender, "Только для игрока.");
return;
}
player.getInventory().addItem(GroupWandItem.create(plugin));
player.sendMessage(Component.text(
"Палочка группы: ЛКМ/ПКМ по блоку — углы, Shift+ПКМ — меню (9 шахт). Задайте /lm group <префикс>",
NamedTextColor.GREEN));
"Палочка группы: ЛКМ/ПКМ по блоку — углы, Shift+ПКМ — меню (9 шахт). Задайте /lm group <префикс>",
NamedTextColor.GREEN));
}
@Subcommand(value = "group", permission = "lomines.admin.wand")
public void group(CommandSender sender, @Arg("prefix") String prefix) {
if (!(sender instanceof Player player)) {
sender.sendMessage(Component.text("Префикс задаётся в игре."));
errorHandler.sendError(sender, "Префикс задаётся в игре.");
return;
}
plugin.getGroupWandManager().getSession(player.getUniqueId()).setBaseName(prefix);

103
src/main/java/com/loki/lomines/command/StatsCommands.java → src/main/java/dev/loki/lomines/command/StatsCommands.java
View file

@ -1,12 +1,13 @@
package com.loki.lomines.command;
package dev.loki.lomines.command;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.core.Mine;
import com.loki.lomines.core.Mines;
import com.loki.lomines.data.Leaderboard;
import com.loki.lomines.data.LeaderboardEntry;
import com.loki.lomines.data.PlayerStats;
import com.loki.lomines.data.StatsManager;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.core.Mine;
import dev.loki.lomines.core.Mines;
import dev.loki.lomines.data.stats.Leaderboard;
import dev.loki.lomines.data.stats.LeaderboardEntry;
import dev.loki.lomines.data.stats.PlayerStats;
import dev.loki.lomines.data.stats.StatsManager;
import dev.loki.lomines.util.ErrorHandler;
import dev.lolib.commands.annotation.Arg;
import dev.lolib.commands.annotation.Command;
import dev.lolib.commands.annotation.Subcommand;
@ -30,10 +31,44 @@ public class StatsCommands {
private final LoMinesPlugin plugin;
private final Mines mines;
private final ErrorHandler errorHandler;
public StatsCommands(LoMinesPlugin plugin) {
this.plugin = plugin;
this.mines = plugin.getMines();
this.errorHandler = new ErrorHandler(plugin.getLogger(), "[LoMines] ");
}
private static void sendTopRows(CommandSender sender, List<LeaderboardEntry> rows) {
if (rows.isEmpty()) {
sender.sendMessage(Component.text("Пока нет данных.", NamedTextColor.GRAY));
return;
}
for (int i = 0; i < rows.size(); i++) {
LeaderboardEntry e = rows.get(i);
String name = formatPlayerName(e.playerId());
sender.sendMessage(Component.text(
(i + 1) + ". " + name + " — " + e.count(),
NamedTextColor.WHITE));
}
}
private static String formatPlayerName(UUID id) {
String name = Bukkit.getOfflinePlayer(id).getName();
return name != null ? name : id.toString();
}
private static int clampLimit(int limit) {
return Math.max(1, Math.min(50, limit));
}
private static Integer tryParsePositiveInt(String s) {
try {
int v = Integer.parseInt(s);
return v > 0 ? v : null;
} catch (NumberFormatException e) {
return null;
}
}
/**
@ -49,13 +84,13 @@ public class StatsCommands {
UUID uuid;
if (name.isEmpty()) {
if (!(sender instanceof Player self)) {
sender.sendMessage(Component.text("Укажите игрока: /lm stats <ник>", NamedTextColor.RED));
errorHandler.sendError(sender, "Укажите игрока: /lm stats <ник>");
return;
}
uuid = self.getUniqueId();
} else {
if (!sender.hasPermission("lomines.stats.others")) {
sender.sendMessage(Component.text("Нет прав смотреть чужую статистику.", NamedTextColor.RED));
errorHandler.handlePermissionDenied(sender, "смотреть чужую статистику");
return;
}
Player online = Bukkit.getPlayerExact(name);
@ -81,10 +116,10 @@ public class StatsCommands {
}
sender.sendMessage(Component.text("По шахтам:", NamedTextColor.GRAY));
byMine.entrySet().stream()
.sorted(Map.Entry.<String, Long>comparingByValue().reversed())
.limit(12)
.forEach(e -> sender.sendMessage(Component.text(
" " + e.getKey() + ": " + e.getValue(), NamedTextColor.DARK_AQUA)));
.sorted(Map.Entry.<String, Long>comparingByValue().reversed())
.limit(12)
.forEach(e -> sender.sendMessage(Component.text(
" " + e.getKey() + ": " + e.getValue(), NamedTextColor.DARK_AQUA)));
}
/**
@ -94,9 +129,9 @@ public class StatsCommands {
*/
@Subcommand(value = "top", permission = "lomines.stats")
public void top(
CommandSender sender,
@Arg(value = "arg1", optional = true, defaultValue = "") String arg1,
@Arg(value = "arg2", optional = true, defaultValue = "") String arg2
CommandSender sender,
@Arg(value = "arg1", optional = true, defaultValue = "") String arg1,
@Arg(value = "arg2", optional = true, defaultValue = "") String arg2
) {
if (isStatsDisabled(sender)) {
return;
@ -126,7 +161,7 @@ public class StatsCommands {
if (mineName != null) {
var found = mines.find(mineName);
if (found.isEmpty()) {
sender.sendMessage(Component.text("Шахта не найдена: " + mineName, NamedTextColor.RED));
errorHandler.handleNotFound(sender, "Шахта", mineName);
return;
}
Mine m = found.get();
@ -141,25 +176,6 @@ public class StatsCommands {
sendTopRows(sender, rows);
}
private static void sendTopRows(CommandSender sender, List<LeaderboardEntry> rows) {
if (rows.isEmpty()) {
sender.sendMessage(Component.text("Пока нет данных.", NamedTextColor.GRAY));
return;
}
for (int i = 0; i < rows.size(); i++) {
LeaderboardEntry e = rows.get(i);
String name = formatPlayerName(e.getPlayerId());
sender.sendMessage(Component.text(
(i + 1) + ". " + name + " — " + e.getCount(),
NamedTextColor.WHITE));
}
}
private static String formatPlayerName(UUID id) {
String name = Bukkit.getOfflinePlayer(id).getName();
return name != null ? name : id.toString();
}
private boolean isStatsDisabled(CommandSender sender) {
if (!plugin.getConfig().getBoolean("statistics-enabled", true)) {
sender.sendMessage(Component.text("Статистика отключена в config.yml.", NamedTextColor.RED));
@ -167,17 +183,4 @@ public class StatsCommands {
}
return false;
}
private static int clampLimit(int limit) {
return Math.max(1, Math.min(50, limit));
}
private static Integer tryParsePositiveInt(String s) {
try {
int v = Integer.parseInt(s);
return v > 0 ? v : null;
} catch (NumberFormatException e) {
return null;
}
}
}

2
src/main/java/com/loki/lomines/command/package-info.java → src/main/java/dev/loki/lomines/command/package-info.java
View file

@ -10,4 +10,4 @@
* <li>{@code WorldGuardCommands} - WorldGuard integration commands</li>
* </ul>
*/
package com.loki.lomines.command;
package dev.loki.lomines.command;

134
src/main/java/com/loki/lomines/core/Mine.java → src/main/java/dev/loki/lomines/core/Mine.java
View file

@ -1,26 +1,21 @@
package com.loki.lomines.core;
package dev.loki.lomines.core;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.block.BlockSetter;
import com.loki.lomines.data.FillMode;
import com.loki.lomines.data.config.MineConfig;
import com.loki.lomines.util.BlockKeys;
import com.loki.lomines.handler.ActionBarHandler;
import com.loki.lomines.handler.MineBlockHandler;
import com.loki.lomines.handler.MineResetHandler;
import com.loki.lomines.util.Cuboid;
import dev.lolib.scheduler.Scheduler;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.block.BlockSetter;
import dev.loki.lomines.data.config.FillMode;
import dev.loki.lomines.data.config.MineConfig;
import dev.loki.lomines.handler.ActionBarHandler;
import dev.loki.lomines.handler.MineBlockHandler;
import dev.loki.lomines.handler.MineResetHandler;
import dev.loki.lomines.util.location.BlockKeys;
import dev.loki.lomines.util.location.Cuboid;
import dev.lolib.scheduler.ScheduledTask;
import dev.lolib.scheduler.Scheduler;
import org.bukkit.Location;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.*;
import java.util.concurrent.atomic.AtomicInteger;
/**
@ -28,7 +23,7 @@ import java.util.concurrent.atomic.AtomicInteger;
* Thread-safe implementation using AtomicInteger for mutable state.
*/
public final class Mine {
// Immutable configuration
private final String name;
private final List<Cuboid> regions;
@ -36,21 +31,23 @@ public final class Mine {
private final BlockSetter blockSetter;
private final LoMinesPlugin plugin;
private final int totalVolume;
/** Block keys for {@link FillMode#MASK}; empty when not mask mode. */
/**
* Block keys for {@link FillMode#MASK}; empty when not mask mode.
*/
private final Set<String> maskBlockKeys;
// Mutable state (thread-safe)
private final AtomicInteger blocks;
private final AtomicInteger ticks;
// Handlers
private final MineResetHandler resetHandler;
private final MineBlockHandler blockHandler;
private final ActionBarHandler actionBarHandler;
// Tasks
private ScheduledTask actionBarTask;
/**
* Creates a new mine instance.
*/
@ -60,7 +57,7 @@ public final class Mine {
this.plugin = plugin;
this.regions = parseRegions(config);
this.blockSetter = createBlockSetter(config, plugin);
if (config.getFillMode() == FillMode.MASK) {
this.maskBlockKeys = new HashSet<>();
for (Location loc : config.getMaskPositions()) {
@ -73,19 +70,19 @@ public final class Mine {
}
this.blocks = new AtomicInteger(Math.max(0, totalVolume));
this.ticks = new AtomicInteger(0);
this.resetHandler = new MineResetHandler(this, plugin);
this.blockHandler = new MineBlockHandler(this, plugin);
this.actionBarHandler = new ActionBarHandler(this);
}
/**
* Starts periodic tasks for this mine.
*/
public void start() {
startActionBarTask();
}
/**
* Stops all tasks for this mine.
*/
@ -95,28 +92,28 @@ public final class Mine {
actionBarTask = null;
}
}
/**
* Resets the mine by filling all regions with blocks.
*/
public void reset(boolean silent) {
resetHandler.reset(silent);
}
/**
* Handles a block break event in this mine.
*/
public void onBlockBreak(Player player, Block block) {
blockHandler.handle(player, block);
}
/**
* Checks if the given location is within any region of this mine.
*/
public boolean contains(Location location) {
return regions.stream().anyMatch(region -> region.contains(location));
}
/**
* Whether breaking this block counts toward mine progress ({@link FillMode#MASK} ignores blocks outside painted cells).
*/
@ -129,14 +126,14 @@ public final class Mine {
}
return maskBlockKeys.contains(BlockKeys.key(location));
}
/**
* Calculates the total volume of all regions in this mine.
*/
public int getTotalVolume() {
return totalVolume;
}
/**
* Calculates the percentage of blocks remaining in the mine.
*/
@ -146,54 +143,56 @@ public final class Mine {
}
return (double) blocks.get() / totalVolume * 100.0;
}
/**
* Parses cuboid regions from selection points in the config.
* Selections are paired: 1-2, 3-4, 5-6, 7-8, 9-10.
*/
private List<Cuboid> parseRegions(MineConfig config) {
List<Location> selections = config.getSelections();
if (selections.isEmpty()) {
throw new IllegalArgumentException("Mine must have at least one region (2 selection points)");
}
if (selections.size() % 2 != 0) {
throw new IllegalArgumentException("Selections must be in pairs (even number of points)");
}
List<Cuboid> cuboids = new ArrayList<>();
for (int i = 0; i < selections.size(); i += 2) {
Location loc1 = selections.get(i);
Location loc2 = selections.get(i + 1);
cuboids.add(new Cuboid(loc1, loc2));
}
return Collections.unmodifiableList(cuboids);
}
/**
* Creates the appropriate BlockSetter based on block configuration.
*/
private BlockSetter createBlockSetter(MineConfig config, LoMinesPlugin plugin) {
Map<String, Double> blocks = config.getBlocks();
if (blocks.isEmpty()) {
throw new IllegalArgumentException("Mine must have at least one block type");
}
// Get the first block key to determine the setter type
String firstKey = blocks.keySet().iterator().next();
if (firstKey.startsWith("oraxen:")) {
return new com.loki.lomines.block.OraxenBlockSetter(blocks, plugin);
// return new dev.loki.lomines.block.OraxenBlockSetter(blocks, plugin);
throw new IllegalArgumentException("Oraxen integration is currently disabled");
} else if (firstKey.startsWith("itemsadder:")) {
return new com.loki.lomines.block.ItemsAdderBlockSetter(blocks, plugin);
// return new dev.loki.lomines.block.ItemsAdderBlockSetter(blocks, plugin);
throw new IllegalArgumentException("ItemsAdder integration is currently disabled");
} else {
return new com.loki.lomines.block.BukkitBlockSetter(blocks, plugin);
return new dev.loki.lomines.block.BukkitBlockSetter(blocks, plugin);
}
}
/**
* Starts the action bar update task.
*/
@ -201,18 +200,41 @@ public final class Mine {
if (!config.isActionBarEnabled()) {
return;
}
actionBarTask = Scheduler.get(plugin).runTimer(() -> {
actionBarHandler.sendToNearbyPlayers();
}, 10L, 10L);
}
public String getName() { return name; }
public MineConfig getConfig() { return config; }
public BlockSetter getBlockSetter() { return blockSetter; }
public List<Cuboid> getRegions() { return regions; }
public AtomicInteger getBlocksAtomic() { return blocks; }
public int getBlocks() { return blocks.get(); }
public int getTicks() { return ticks.get(); }
public AtomicInteger getTicksAtomic() { return ticks; }
public String getName() {
return name;
}
public MineConfig getConfig() {
return config;
}
public BlockSetter getBlockSetter() {
return blockSetter;
}
public List<Cuboid> getRegions() {
return regions;
}
public AtomicInteger getBlocksAtomic() {
return blocks;
}
public int getBlocks() {
return blocks.get();
}
public int getTicks() {
return ticks.get();
}
public AtomicInteger getTicksAtomic() {
return ticks;
}
}

20
src/main/java/com/loki/lomines/core/MineTicker.java → src/main/java/dev/loki/lomines/core/MineTicker.java
View file

@ -1,8 +1,8 @@
package com.loki.lomines.core;
package dev.loki.lomines.core;
import com.loki.lomines.LoMinesPlugin;
import dev.lolib.scheduler.Scheduler;
import dev.loki.lomines.LoMinesPlugin;
import dev.lolib.scheduler.ScheduledTask;
import dev.lolib.scheduler.Scheduler;
/**
* Centralized ticker for all mines.
@ -10,16 +10,16 @@ import dev.lolib.scheduler.ScheduledTask;
* This is more efficient than having each mine run its own ticker.
*/
public final class MineTicker {
private final Mines mines;
private final LoMinesPlugin plugin;
private ScheduledTask tickerTask;
public MineTicker(Mines mines, LoMinesPlugin plugin) {
this.mines = mines;
this.plugin = plugin;
}
/**
* Starts the centralized ticker.
* Ticks all mines every game tick (1L, 1L).
@ -28,14 +28,14 @@ public final class MineTicker {
if (tickerTask != null) {
return; // Already running
}
tickerTask = Scheduler.get(plugin).runTimer(() -> {
for (Mine mine : mines.getAll()) {
tickMine(mine);
}
}, 1L, 1L);
}
/**
* Stops the centralized ticker.
*/
@ -45,13 +45,13 @@ public final class MineTicker {
tickerTask = null;
}
}
/**
* Ticks a single mine, checking if it needs to reset.
*/
private void tickMine(Mine mine) {
int currentTicks = mine.getTicksAtomic().incrementAndGet();
if (currentTicks >= mine.getConfig().getResetTicks()) {
mine.getTicksAtomic().set(0);
mine.reset(false);

14
src/main/java/com/loki/lomines/core/Mines.java → src/main/java/dev/loki/lomines/core/Mines.java
View file

@ -1,8 +1,11 @@
package com.loki.lomines.core;
package dev.loki.lomines.core;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.data.config.ConfigParseException;
import com.loki.lomines.data.config.MineConfig;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.core.service.MaskScanService;
import dev.loki.lomines.core.service.MineFileManager;
import dev.loki.lomines.core.service.MineRepository;
import dev.loki.lomines.data.config.MineConfig;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import org.bukkit.Location;
import java.io.IOException;
@ -45,7 +48,7 @@ public final class Mines {
try (Stream<Path> paths = Files.list(minesFolder)) {
paths.filter(path -> path.toString().endsWith(".yml"))
.forEach(configFile -> loadMineFromFile(configFile));
.forEach(configFile -> loadMineFromFile(configFile));
}
}
@ -111,6 +114,7 @@ public final class Mines {
/**
* Gets a mine by name.
*
* @throws IllegalArgumentException if mine not found
*/
public Mine get(String name) {

2
src/main/java/com/loki/lomines/core/package-info.java → src/main/java/dev/loki/lomines/core/package-info.java
View file

@ -8,4 +8,4 @@
* <li>{@code Mine} - Representation of a single mine with its configuration and state</li>
* </ul>
*/
package com.loki.lomines.core;
package dev.loki.lomines.core;

28
src/main/java/com/loki/lomines/core/MaskScanService.java → src/main/java/dev/loki/lomines/core/service/MaskScanService.java
View file

@ -1,8 +1,10 @@
package com.loki.lomines.core;
package dev.loki.lomines.core.service;
import com.loki.lomines.data.config.ConfigParseException;
import com.loki.lomines.util.location.Cuboid;
import com.loki.lomines.util.selection.MaskScanner;
import dev.loki.lomines.core.Mine;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import dev.loki.lomines.util.ValidationUtils;
import dev.loki.lomines.util.location.Cuboid;
import dev.loki.lomines.util.selection.MaskScanner;
import org.bukkit.Location;
import org.bukkit.Material;
@ -12,17 +14,17 @@ import java.util.List;
/**
* Service for scanning and saving mask positions.
*/
final class MaskScanService {
public final class MaskScanService {
private final MineRepository repository;
private final MineFileManager fileManager;
MaskScanService(MineRepository repository, MineFileManager fileManager) {
public MaskScanService(MineRepository repository, MineFileManager fileManager) {
this.repository = repository;
this.fileManager = fileManager;
}
int scanAndSave(String mineName) throws IOException, ConfigParseException {
public int scanAndSave(String mineName) throws IOException, ConfigParseException {
Mine mine = repository.get(mineName);
Material marker = parseMarkerMaterial(mine.getConfig().getMaskMarkerMaterial());
@ -30,9 +32,9 @@ final class MaskScanService {
List<Location> found = MaskScanner.scan(regions, marker);
fileManager.saveMaskPositions(
mineName,
mine.getConfig().getMaskMarkerMaterial(),
found
mineName,
mine.getConfig().getMaskMarkerMaterial(),
found
);
repository.reload(mineName);
@ -41,10 +43,6 @@ final class MaskScanService {
}
private Material parseMarkerMaterial(String materialName) {
try {
return Material.valueOf(materialName.toUpperCase());
} catch (IllegalArgumentException e) {
return Material.PINK_CONCRETE;
}
return ValidationUtils.parseMaterialOrDefault(materialName, Material.PINK_CONCRETE);
}
}

32
src/main/java/com/loki/lomines/core/MineFileManager.java → src/main/java/dev/loki/lomines/core/service/MineFileManager.java
View file

@ -1,9 +1,9 @@
package com.loki.lomines.core;
package dev.loki.lomines.core.service;
import com.loki.lomines.data.config.ConfigLoader;
import com.loki.lomines.data.config.ConfigParseException;
import com.loki.lomines.data.config.MineConfig;
import com.loki.lomines.util.location.LocationParser;
import dev.loki.lomines.data.config.ConfigLoader;
import dev.loki.lomines.data.config.MineConfig;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import dev.loki.lomines.util.location.LocationParser;
import org.bukkit.Location;
import org.bukkit.configuration.file.YamlConfiguration;
@ -17,21 +17,19 @@ import java.util.Map;
/**
* Handles file operations for mine configurations.
*/
final class MineFileManager {
public record MineFileManager(Path minesFolder) {
private final Path minesFolder;
MineFileManager(Path minesFolder) {
this.minesFolder = minesFolder;
public Path getMinesFolder() {
return minesFolder;
}
void ensureFolderExists() throws IOException {
public void ensureFolderExists() throws IOException {
if (!Files.exists(minesFolder)) {
Files.createDirectories(minesFolder);
}
}
void createDefaultConfig(String name, Location corner1, Location corner2) throws IOException {
public void createDefaultConfig(String name, Location corner1, Location corner2) throws IOException {
Path configFile = minesFolder.resolve(name + ".yml");
YamlConfiguration yaml = new YamlConfiguration();
@ -62,7 +60,7 @@ final class MineFileManager {
yaml.save(configFile.toFile());
}
MineConfig loadConfig(String name) throws IOException, ConfigParseException {
public MineConfig loadConfig(String name) throws IOException, ConfigParseException {
Path configFile = minesFolder.resolve(name + ".yml");
if (!Files.exists(configFile)) {
throw new IOException("Mine config not found: " + configFile);
@ -71,14 +69,14 @@ final class MineFileManager {
return loader.load(configFile);
}
void deleteConfig(String name) throws IOException {
public void deleteConfig(String name) throws IOException {
Path configFile = minesFolder.resolve(name + ".yml");
if (Files.exists(configFile)) {
Files.delete(configFile);
}
}
void saveMaskPositions(String name, String markerMaterial, List<Location> positions) throws IOException {
public void saveMaskPositions(String name, String markerMaterial, List<Location> positions) throws IOException {
Path configFile = minesFolder.resolve(name + ".yml");
YamlConfiguration yaml = YamlConfiguration.loadConfiguration(configFile.toFile());
@ -93,8 +91,4 @@ final class MineFileManager {
yaml.save(configFile.toFile());
}
Path getMinesFolder() {
return minesFolder;
}
}

39
src/main/java/com/loki/lomines/core/MineRepository.java → src/main/java/dev/loki/lomines/core/service/MineRepository.java
View file

@ -1,8 +1,9 @@
package com.loki.lomines.core;
package dev.loki.lomines.core.service;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.data.config.ConfigParseException;
import com.loki.lomines.data.config.MineConfig;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.core.Mine;
import dev.loki.lomines.data.config.MineConfig;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import org.bukkit.Location;
import java.io.IOException;
@ -12,26 +13,26 @@ import java.util.concurrent.ConcurrentHashMap;
/**
* Repository for managing mine instances.
*/
final class MineRepository {
public final class MineRepository {
private final Map<String, Mine> mines = new ConcurrentHashMap<>();
private final LoMinesPlugin plugin;
private final MineFileManager fileManager;
MineRepository(LoMinesPlugin plugin, MineFileManager fileManager) {
public MineRepository(LoMinesPlugin plugin, MineFileManager fileManager) {
this.plugin = plugin;
this.fileManager = fileManager;
}
void add(String name, Mine mine) {
public void add(String name, Mine mine) {
mines.put(name.toLowerCase(), mine);
}
Mine remove(String name) {
public Mine remove(String name) {
return mines.remove(name.toLowerCase());
}
Mine get(String name) {
public Mine get(String name) {
Mine mine = mines.get(name.toLowerCase());
if (mine == null) {
throw new IllegalArgumentException("Mine not found: " + name);
@ -39,46 +40,46 @@ final class MineRepository {
return mine;
}
Optional<Mine> find(String name) {
public Optional<Mine> find(String name) {
return Optional.ofNullable(mines.get(name.toLowerCase()));
}
Collection<Mine> getAll() {
public Collection<Mine> getAll() {
return Collections.unmodifiableCollection(mines.values());
}
Optional<Mine> findByLocation(Location location) {
public Optional<Mine> findByLocation(Location location) {
return mines.values().stream()
.filter(mine -> mine.contains(location))
.findFirst();
.filter(mine -> mine.contains(location))
.findFirst();
}
boolean exists(String name) {
public boolean exists(String name) {
return mines.containsKey(name.toLowerCase());
}
void clear() {
public void clear() {
for (Mine mine : new ArrayList<>(mines.values())) {
mine.stop();
}
mines.clear();
}
Mine createAndStart(String name, MineConfig config) {
public Mine createAndStart(String name, MineConfig config) {
Mine mine = new Mine(name, config, plugin);
add(name, mine);
mine.start();
return mine;
}
void stopAndRemove(String name) {
public void stopAndRemove(String name) {
Mine mine = remove(name);
if (mine != null) {
mine.stop();
}
}
void reload(String name) throws IOException, ConfigParseException {
public void reload(String name) throws IOException, ConfigParseException {
stopAndRemove(name);
MineConfig config = fileManager.loadConfig(name);
Mine mine = createAndStart(name, config);

48
src/main/java/com/loki/lomines/data/config/ConfigLoader.java → src/main/java/dev/loki/lomines/data/config/ConfigLoader.java
View file

@ -1,5 +1,9 @@
package com.loki.lomines.data.config;
package dev.loki.lomines.data.config;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import dev.loki.lomines.data.config.parser.ConfigParser;
import dev.loki.lomines.data.reward.Reward;
import dev.loki.lomines.data.reward.RewardParser;
import org.bukkit.Location;
import org.bukkit.configuration.file.YamlConfiguration;
@ -32,7 +36,7 @@ public final class ConfigLoader {
*
* @param configFile the path to the YAML configuration file
* @return the loaded MineConfig object
* @throws IOException if the file cannot be read
* @throws IOException if the file cannot be read
* @throws ConfigParseException if the configuration is invalid
*/
public MineConfig load(Path configFile) throws IOException, ConfigParseException {
@ -63,33 +67,33 @@ public final class ConfigLoader {
// Build and return config
return MineConfig.builder()
.selections(selections)
.blocks(blocks)
.fillMode(fillMode)
.maskMarkerMaterial(maskMarker)
.maskPositions(maskPositions)
.rewards(rewards)
.resetTicks(yaml.getInt("reset.ticks", 6000))
.resetPercent(yaml.getDouble("reset.percent", 10.0))
.resetOnPercentEnabled(yaml.getBoolean("reset-on-percent", false))
.actionBarEnabled(yaml.getBoolean("actionbar.enabled", true))
.actionBarMessage(yaml.getString("actionbar.message", ""))
.actionBarRange(yaml.getDouble("actionbar.range", 50.0))
.timerFormat(yaml.getString("timer-format", "mm:ss"))
.teleportOnReset(yaml.getBoolean("teleport-on-reset", false))
.teleportLocation(teleportLocation)
.resetCommands(yaml.getStringList("reset-commands"))
.broadcastReset(yaml.getString("broadcast-reset", ""))
.build();
.selections(selections)
.blocks(blocks)
.fillMode(fillMode)
.maskMarkerMaterial(maskMarker)
.maskPositions(maskPositions)
.rewards(rewards)
.resetTicks(yaml.getInt("reset.ticks", 6000))
.resetPercent(yaml.getDouble("reset.percent", 10.0))
.resetOnPercentEnabled(yaml.getBoolean("reset-on-percent", false))
.actionBarEnabled(yaml.getBoolean("actionbar.enabled", true))
.actionBarMessage(yaml.getString("actionbar.message", ""))
.actionBarRange(yaml.getDouble("actionbar.range", 50.0))
.timerFormat(yaml.getString("timer-format", "mm:ss"))
.teleportOnReset(yaml.getBoolean("teleport-on-reset", false))
.teleportLocation(teleportLocation)
.resetCommands(yaml.getStringList("reset-commands"))
.broadcastReset(yaml.getString("broadcast-reset", ""))
.build();
}
/**
* Saves a MineConfig to a YAML file.
* Serializes the config and writes it to the specified file.
*
* @param config the MineConfig to save
* @param config the MineConfig to save
* @param configFile the path to the YAML configuration file
* @throws IOException if the file cannot be written
* @throws IOException if the file cannot be written
* @throws IllegalArgumentException if config or configFile is null
*/
public void save(MineConfig config, Path configFile) throws IOException {

21
src/main/java/com/loki/lomines/data/config/ConfigSerializer.java → src/main/java/dev/loki/lomines/data/config/ConfigSerializer.java
View file

@ -1,16 +1,13 @@
package com.loki.lomines.data.config;
package dev.loki.lomines.data.config;
import com.loki.lomines.util.LocationParser;
import dev.loki.lomines.data.reward.Reward;
import dev.loki.lomines.util.location.LocationParser;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.inventory.ItemStack;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.*;
/**
* Serializes MineConfig objects to YAML format.
@ -22,7 +19,7 @@ final class ConfigSerializer {
* Serializes a MineConfig to YAML configuration.
*
* @param config the MineConfig to serialize
* @param yaml the YAML configuration to write to
* @param yaml the YAML configuration to write to
*/
void serialize(MineConfig config, YamlConfiguration yaml) {
saveSelections(yaml, config.getSelections());
@ -53,7 +50,7 @@ final class ConfigSerializer {
/**
* Saves selection coordinates to the YAML configuration.
*
* @param yaml the YAML configuration
* @param yaml the YAML configuration
* @param selections the list of selection locations
*/
private void saveSelections(YamlConfiguration yaml, List<Location> selections) {
@ -67,7 +64,7 @@ final class ConfigSerializer {
/**
* Saves block contents to the YAML configuration.
*
* @param yaml the YAML configuration
* @param yaml the YAML configuration
* @param blocks the map of block string key to weight
*/
private void saveBlocks(YamlConfiguration yaml, Map<String, Double> blocks) {
@ -81,7 +78,7 @@ final class ConfigSerializer {
/**
* Saves mask positions to the YAML configuration.
*
* @param yaml the YAML configuration
* @param yaml the YAML configuration
* @param maskPositions the list of mask positions
*/
private void saveMaskPositions(YamlConfiguration yaml, List<Location> maskPositions) {
@ -100,7 +97,7 @@ final class ConfigSerializer {
/**
* Saves rewards to the YAML configuration.
*
* @param yaml the YAML configuration
* @param yaml the YAML configuration
* @param rewards the list of rewards
*/
private void saveRewards(YamlConfiguration yaml, List<Reward> rewards) {

28
src/main/java/com/loki/lomines/data/config/ConfigValidator.java → src/main/java/dev/loki/lomines/data/config/ConfigValidator.java
View file

@ -1,7 +1,9 @@
package com.loki.lomines.data.config;
package dev.loki.lomines.data.config;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import dev.loki.lomines.data.reward.Reward;
import dev.loki.lomines.util.ValidationUtils;
import org.bukkit.Location;
import org.bukkit.Material;
import java.util.List;
import java.util.Map;
@ -21,14 +23,14 @@ final class ConfigValidator {
void validateSelections(List<Location> selections) throws ConfigParseException {
if (selections.isEmpty()) {
throw new ConfigParseException(
"No selection coordinates found. At least one selection pair (2 points) is required"
"No selection coordinates found. At least one selection pair (2 points) is required"
);
}
if (selections.size() % 2 != 0) {
throw new ConfigParseException(
"Invalid number of selection coordinates: " + selections.size() +
". Selections must be in pairs (even number)"
"Invalid number of selection coordinates: " + selections.size() +
". Selections must be in pairs (even number)"
);
}
}
@ -42,7 +44,7 @@ final class ConfigValidator {
void validateBlocks(Map<String, Double> blocks) throws ConfigParseException {
if (blocks.isEmpty()) {
throw new ConfigParseException(
"No blocks defined in 'contents' section. At least one block is required"
"No blocks defined in 'contents' section. At least one block is required"
);
}
@ -52,7 +54,7 @@ final class ConfigValidator {
if (weight <= 0) {
throw new ConfigParseException(
"Block weight must be positive for '" + key + "', got: " + weight
"Block weight must be positive for '" + key + "', got: " + weight
);
}
@ -71,11 +73,11 @@ final class ConfigValidator {
*/
void validateMaterial(String materialName) throws ConfigParseException {
try {
Material.valueOf(materialName.toUpperCase());
ValidationUtils.validateMaterial(materialName);
} catch (IllegalArgumentException e) {
throw new ConfigParseException(
"Unknown material: '" + materialName + "'. Must be a valid Minecraft material name",
e
"Unknown material: '" + materialName + "'. Must be a valid Minecraft material name",
e
);
}
}
@ -88,7 +90,7 @@ final class ConfigValidator {
*/
void validateMaskMarker(String marker) throws ConfigParseException {
try {
Material.valueOf(marker.toUpperCase());
ValidationUtils.validateMaterial(marker);
} catch (IllegalArgumentException e) {
throw new ConfigParseException("Invalid mask.marker material: '" + marker + "'", e);
}
@ -104,7 +106,7 @@ final class ConfigValidator {
double chance = reward.getChance();
if (chance < 0 || chance > 100) {
throw new ConfigParseException(
"Reward chance must be between 0 and 100, got: " + chance
"Reward chance must be between 0 and 100, got: " + chance
);
}
@ -116,7 +118,7 @@ final class ConfigValidator {
for (org.bukkit.inventory.ItemStack item : reward.getItems()) {
if (item.getAmount() <= 0) {
throw new ConfigParseException(
"Item amount must be positive, got: " + item.getAmount()
"Item amount must be positive, got: " + item.getAmount()
);
}
}

2
src/main/java/com/loki/lomines/data/FillMode.java → src/main/java/dev/loki/lomines/data/config/FillMode.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.data;
package dev.loki.lomines.data.config;
/**
* How mine contents are placed on reset.

53
src/main/java/com/loki/lomines/data/config/MineConfig.java → src/main/java/dev/loki/lomines/data/config/MineConfig.java
View file

@ -1,5 +1,6 @@
package com.loki.lomines.data.config;
package dev.loki.lomines.data.config;
import dev.loki.lomines.data.reward.Reward;
import org.bukkit.Location;
import java.util.List;
@ -19,11 +20,17 @@ public final class MineConfig {
// Blocks
private final Map<String, Double> blocks;
/** How blocks are placed on reset. */
/**
* How blocks are placed on reset.
*/
private final FillMode fillMode;
/** Vanilla material name for {@link FillMode#MASK} scan (e.g. pink_concrete). */
/**
* Vanilla material name for {@link FillMode#MASK} scan (e.g. pink_concrete).
*/
private final String maskMarkerMaterial;
/** Block centers for mask mode; ignored when {@link #fillMode} is {@link FillMode#CUBOID}. */
/**
* Block centers for mask mode; ignored when {@link #fillMode} is {@link FillMode#CUBOID}.
*/
private final List<Location> maskPositions;
// Rewards
@ -76,79 +83,79 @@ public final class MineConfig {
public static MineConfigBuilder builder() {
return new MineConfigBuilder();
}
// Getters
public List<Location> getSelections() {
return selections;
}
public Map<String, Double> getBlocks() {
return blocks;
}
public FillMode getFillMode() {
return fillMode;
}
/**
* Material name for scanning marker blocks (vanilla), e.g. {@code pink_concrete}.
*/
public String getMaskMarkerMaterial() {
return maskMarkerMaterial;
}
public List<Location> getMaskPositions() {
return maskPositions;
}
public List<Reward> getRewards() {
return rewards;
}
public int getResetTicks() {
return resetTicks;
}
public double getResetPercent() {
return resetPercent;
}
public boolean isResetOnPercentEnabled() {
return resetOnPercentEnabled;
}
public List<String> getResetCommands() {
return resetCommands;
}
public String getBroadcastReset() {
return broadcastReset;
}
public boolean isTeleportOnReset() {
return teleportOnReset;
}
public Location getTeleportLocation() {
return teleportLocation;
}
public boolean isActionBarEnabled() {
return actionBarEnabled;
}
public String getActionBarMessage() {
return actionBarMessage;
}
public double getActionBarRange() {
return actionBarRange;
}
public String getTimerFormat() {
return timerFormat;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
@ -172,7 +179,7 @@ public final class MineConfig {
Objects.equals(actionBarMessage, that.actionBarMessage) &&
Objects.equals(timerFormat, that.timerFormat);
}
@Override
public int hashCode() {
return Objects.hash(selections, blocks, fillMode, maskMarkerMaterial, maskPositions, rewards, resetTicks, resetPercent,

11
src/main/java/com/loki/lomines/data/config/MineConfigBuilder.java → src/main/java/dev/loki/lomines/data/config/MineConfigBuilder.java
View file

@ -1,5 +1,6 @@
package com.loki.lomines.data.config;
package dev.loki.lomines.data.config;
import dev.loki.lomines.data.reward.Reward;
import org.bukkit.Location;
import java.util.ArrayList;
@ -119,10 +120,10 @@ public final class MineConfigBuilder {
public MineConfig build() {
return new MineConfig(
selections, blocks, fillMode, maskMarkerMaterial, maskPositions,
rewards, resetTicks, resetPercent, resetOnPercentEnabled,
resetCommands, broadcastReset, teleportOnReset, teleportLocation,
actionBarEnabled, actionBarMessage, actionBarRange, timerFormat
selections, blocks, fillMode, maskMarkerMaterial, maskPositions,
rewards, resetTicks, resetPercent, resetOnPercentEnabled,
resetCommands, broadcastReset, teleportOnReset, teleportLocation,
actionBarEnabled, actionBarMessage, actionBarRange, timerFormat
);
}
}

6
src/main/java/com/loki/lomines/data/config/ConfigParseException.java → src/main/java/dev/loki/lomines/data/config/parser/ConfigParseException.java
View file

@ -1,15 +1,15 @@
package com.loki.lomines.data.config;
package dev.loki.lomines.data.config.parser;
/**
* Exception thrown when configuration parsing fails.
* Provides descriptive error messages for invalid configuration data.
*/
public final class ConfigParseException extends Exception {
public ConfigParseException(String message) {
super(message);
}
public ConfigParseException(String message, Throwable cause) {
super(message, cause);
}

55
src/main/java/com/loki/lomines/data/config/ConfigParser.java → src/main/java/dev/loki/lomines/data/config/parser/ConfigParser.java
View file

@ -1,26 +1,25 @@
package com.loki.lomines.data.config;
package dev.loki.lomines.data.config.parser;
import com.loki.lomines.util.LocationParser;
import dev.loki.lomines.data.config.FillMode;
import dev.loki.lomines.data.reward.Reward;
import dev.loki.lomines.data.reward.RewardParser;
import dev.loki.lomines.util.location.LocationParser;
import org.bukkit.Location;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.*;
/**
* Parses YAML configuration into intermediate data structures.
* Responsible only for reading YAML and converting to Java objects.
* Does not perform validation - that's handled by ConfigValidator.
*/
final class ConfigParser {
public final class ConfigParser {
private final RewardParser rewardParser;
ConfigParser(RewardParser rewardParser) {
public ConfigParser(RewardParser rewardParser) {
this.rewardParser = rewardParser;
}
@ -32,7 +31,7 @@ final class ConfigParser {
* @return list of parsed Location objects
* @throws ConfigParseException if location parsing fails
*/
List<Location> parseSelections(YamlConfiguration yaml) throws ConfigParseException {
public List<Location> parseSelections(YamlConfiguration yaml) throws ConfigParseException {
List<Location> selections = new ArrayList<>();
for (int i = 1; i <= 10; i++) {
@ -41,7 +40,7 @@ final class ConfigParser {
String locationString = yaml.getString(key);
if (locationString == null || locationString.trim().isEmpty()) {
throw new ConfigParseException(
"Selection coordinate at '" + key + "' is empty"
"Selection coordinate at '" + key + "' is empty"
);
}
@ -50,8 +49,8 @@ final class ConfigParser {
selections.add(location);
} catch (ConfigParseException e) {
throw new ConfigParseException(
"Invalid selection coordinate at '" + key + "': " + e.getMessage(),
e
"Invalid selection coordinate at '" + key + "': " + e.getMessage(),
e
);
}
}
@ -68,12 +67,12 @@ final class ConfigParser {
* @return map of block string key to weight
* @throws ConfigParseException if block configuration is invalid
*/
Map<String, Double> parseBlocks(YamlConfiguration yaml) throws ConfigParseException {
public Map<String, Double> parseBlocks(YamlConfiguration yaml) throws ConfigParseException {
ConfigurationSection contentsSection = yaml.getConfigurationSection("contents");
if (contentsSection == null) {
throw new ConfigParseException(
"Missing required 'contents' section in configuration"
"Missing required 'contents' section in configuration"
);
}
@ -98,7 +97,7 @@ final class ConfigParser {
* @param yaml the YAML configuration
* @return the parsed FillMode
*/
FillMode parseFillMode(YamlConfiguration yaml) {
public FillMode parseFillMode(YamlConfiguration yaml) {
String raw = yaml.getString("fill-mode", "cuboid");
if (raw == null || raw.isBlank()) {
return FillMode.CUBOID;
@ -115,7 +114,7 @@ final class ConfigParser {
* @param yaml the YAML configuration
* @return the mask marker material name
*/
String parseMaskMarker(YamlConfiguration yaml) {
public String parseMaskMarker(YamlConfiguration yaml) {
String marker = yaml.getString("mask.marker", "pink_concrete");
if (marker == null || marker.isBlank()) {
return "pink_concrete";
@ -130,7 +129,7 @@ final class ConfigParser {
* @return list of mask positions
* @throws ConfigParseException if position parsing fails
*/
List<Location> parseMaskPositions(YamlConfiguration yaml) throws ConfigParseException {
public List<Location> parseMaskPositions(YamlConfiguration yaml) throws ConfigParseException {
List<String> rawList = yaml.getStringList("mask.positions");
if (rawList == null || rawList.isEmpty()) {
return List.of();
@ -146,8 +145,8 @@ final class ConfigParser {
out.add(LocationParser.parse(line.trim()));
} catch (ConfigParseException e) {
throw new ConfigParseException(
"Invalid mask.positions entry at index " + i + ": " + e.getMessage(),
e
"Invalid mask.positions entry at index " + i + ": " + e.getMessage(),
e
);
}
}
@ -162,7 +161,7 @@ final class ConfigParser {
* @return list of parsed Reward objects
* @throws ConfigParseException if reward configuration is invalid
*/
List<Reward> parseRewards(YamlConfiguration yaml) throws ConfigParseException {
public List<Reward> parseRewards(YamlConfiguration yaml) throws ConfigParseException {
return rewardParser.parseRewards(yaml);
}
@ -173,7 +172,7 @@ final class ConfigParser {
* @return the parsed Location, or null if not configured
* @throws ConfigParseException if the teleport location is invalid
*/
Location parseTeleportLocation(YamlConfiguration yaml) throws ConfigParseException {
public Location parseTeleportLocation(YamlConfiguration yaml) throws ConfigParseException {
if (!yaml.contains("teleport-location")) {
return null;
}
@ -187,8 +186,8 @@ final class ConfigParser {
return LocationParser.parse(locationString);
} catch (ConfigParseException e) {
throw new ConfigParseException(
"Invalid teleport location: " + e.getMessage(),
e
"Invalid teleport location: " + e.getMessage(),
e
);
}
}
@ -201,14 +200,14 @@ final class ConfigParser {
return Double.parseDouble((String) value);
} else {
throw new ConfigParseException(
"Invalid weight type for block '" + key + "': expected number, got " +
(value != null ? value.getClass().getSimpleName() : "null")
"Invalid weight type for block '" + key + "': expected number, got " +
(value != null ? value.getClass().getSimpleName() : "null")
);
}
} catch (NumberFormatException e) {
throw new ConfigParseException(
"Invalid weight value for block '" + key + "': " + value,
e
"Invalid weight value for block '" + key + "': " + value,
e
);
}
}

2
src/main/java/com/loki/lomines/data/package-info.java → src/main/java/dev/loki/lomines/data/package-info.java
View file

@ -12,4 +12,4 @@
* <li>{@code ConfigParseException} - Exception for configuration parsing errors</li>
* </ul>
*/
package com.loki.lomines.data;
package dev.loki.lomines.data;

36
src/main/java/com/loki/lomines/data/reward/Reward.java → src/main/java/dev/loki/lomines/data/reward/Reward.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.data.reward;
package dev.loki.lomines.data.reward;
import org.bukkit.Material;
import org.bukkit.inventory.ItemStack;
@ -10,15 +10,10 @@ import java.util.Objects;
* Immutable reward configuration for mine blocks.
* All collections are copied to ensure immutability.
*/
public final class Reward {
private final List<Material> materials;
private final double chance;
private final List<ItemStack> items;
private final List<String> commands;
private final boolean preventDrops;
public Reward(List<Material> materials, double chance,
List<ItemStack> items, List<String> commands,
public record Reward(List<Material> materials, double chance, List<ItemStack> items, List<String> commands,
boolean preventDrops) {
public Reward(List<Material> materials, double chance,
List<ItemStack> items, List<String> commands,
boolean preventDrops) {
this.materials = List.copyOf(materials);
this.chance = chance;
@ -26,31 +21,32 @@ public final class Reward {
this.commands = List.copyOf(commands);
this.preventDrops = preventDrops;
}
public boolean matches(Material material) {
return materials.contains(material);
}
// JavaBean-style getters for compatibility
public List<Material> getMaterials() {
return materials;
}
public double getChance() {
return chance;
}
public List<ItemStack> getItems() {
return items;
}
public List<String> getCommands() {
return commands;
}
public boolean isPreventDrops() {
return preventDrops;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
@ -62,9 +58,5 @@ public final class Reward {
Objects.equals(items, reward.items) &&
Objects.equals(commands, reward.commands);
}
@Override
public int hashCode() {
return Objects.hash(materials, chance, items, commands, preventDrops);
}
}

17
src/main/java/com/loki/lomines/data/reward/RewardItemParser.java → src/main/java/dev/loki/lomines/data/reward/RewardItemParser.java
View file

@ -1,4 +1,7 @@
package com.loki.lomines.data.reward;
package dev.loki.lomines.data.reward;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import dev.loki.lomines.util.ValidationUtils;
import org.bukkit.Material;
import org.bukkit.inventory.ItemStack;
@ -15,7 +18,7 @@ final class RewardItemParser {
* Parses a single reward item from a map configuration.
*
* @param itemMap the item configuration map
* @param index the index of the item in the list (for error messages)
* @param index the index of the item in the list (for error messages)
* @return the parsed ItemStack
* @throws ConfigParseException if the item configuration is invalid
*/
@ -40,11 +43,11 @@ final class RewardItemParser {
*/
private Material parseMaterial(String typeName) throws ConfigParseException {
try {
return Material.valueOf(typeName.toUpperCase());
return ValidationUtils.validateMaterial(typeName);
} catch (IllegalArgumentException e) {
throw new ConfigParseException(
"Unknown material in item type: '" + typeName + "'",
e
"Unknown material in item type: '" + typeName + "'",
e
);
}
}
@ -69,8 +72,8 @@ final class RewardItemParser {
return Integer.parseInt((String) amountObj);
} else {
throw new ConfigParseException(
"Invalid 'amount' type: expected number, got " +
(amountObj != null ? amountObj.getClass().getSimpleName() : "null")
"Invalid 'amount' type: expected number, got " +
(amountObj != null ? amountObj.getClass().getSimpleName() : "null")
);
}
} catch (NumberFormatException e) {

52
src/main/java/com/loki/lomines/data/reward/RewardParser.java → src/main/java/dev/loki/lomines/data/reward/RewardParser.java
View file

@ -1,4 +1,7 @@
package com.loki.lomines.data.reward;
package dev.loki.lomines.data.reward;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import dev.loki.lomines.util.ValidationUtils;
import org.bukkit.Material;
import org.bukkit.configuration.file.YamlConfiguration;
@ -12,11 +15,11 @@ import java.util.Map;
* Parses reward configurations from YAML.
* Handles reward chance, materials, items, commands, and prevent-drops settings.
*/
final class RewardParser {
public final class RewardParser {
private final RewardItemParser itemParser;
RewardParser() {
public RewardParser() {
this.itemParser = new RewardItemParser();
}
@ -27,7 +30,7 @@ final class RewardParser {
* @return list of parsed Reward objects
* @throws ConfigParseException if reward configuration is invalid
*/
List<Reward> parseRewards(YamlConfiguration yaml) throws ConfigParseException {
public List<Reward> parseRewards(YamlConfiguration yaml) throws ConfigParseException {
List<Reward> rewards = new ArrayList<>();
if (!yaml.contains("random-rewards")) {
@ -44,8 +47,8 @@ final class RewardParser {
if (!(rewardObj instanceof Map)) {
throw new ConfigParseException(
"Invalid reward at index " + i + ": expected map, got " +
(rewardObj != null ? rewardObj.getClass().getSimpleName() : "null")
"Invalid reward at index " + i + ": expected map, got " +
(rewardObj != null ? rewardObj.getClass().getSimpleName() : "null")
);
}
@ -57,8 +60,8 @@ final class RewardParser {
rewards.add(reward);
} catch (ConfigParseException e) {
throw new ConfigParseException(
"Error parsing reward at index " + i + ": " + e.getMessage(),
e
"Error parsing reward at index " + i + ": " + e.getMessage(),
e
);
}
}
@ -96,8 +99,8 @@ final class RewardParser {
} else if (type == Boolean.class) {
if (!(value instanceof Boolean)) {
throw new ConfigParseException(
"Invalid '" + key + "' value: expected boolean, got " +
(value != null ? value.getClass().getSimpleName() : "null")
"Invalid '" + key + "' value: expected boolean, got " +
(value != null ? value.getClass().getSimpleName() : "null")
);
}
return (T) value;
@ -125,8 +128,8 @@ final class RewardParser {
return Double.parseDouble((String) value);
} else {
throw new ConfigParseException(
"Invalid '" + key + "' type: expected number, got " +
(value != null ? value.getClass().getSimpleName() : "null")
"Invalid '" + key + "' type: expected number, got " +
(value != null ? value.getClass().getSimpleName() : "null")
);
}
} catch (NumberFormatException e) {
@ -142,8 +145,8 @@ final class RewardParser {
Object blocksObj = rewardMap.get("blocks");
if (!(blocksObj instanceof List)) {
throw new ConfigParseException(
"Invalid 'blocks' type: expected list, got " +
(blocksObj != null ? blocksObj.getClass().getSimpleName() : "null")
"Invalid 'blocks' type: expected list, got " +
(blocksObj != null ? blocksObj.getClass().getSimpleName() : "null")
);
}
@SuppressWarnings("unchecked")
@ -154,12 +157,12 @@ final class RewardParser {
throw new ConfigParseException("Block name cannot be null or empty");
}
try {
Material material = Material.valueOf(blockName.toUpperCase());
Material material = ValidationUtils.validateMaterial(blockName);
materials.add(material);
} catch (IllegalArgumentException e) {
throw new ConfigParseException(
"Unknown material in reward blocks: '" + blockName + "'",
e
"Unknown material in reward blocks: '" + blockName + "'",
e
);
}
}
@ -173,19 +176,18 @@ final class RewardParser {
return items;
}
Object itemsObj = rewardMap.get("items");
if (!(itemsObj instanceof List)) {
if (!(itemsObj instanceof List<?> itemsList)) {
throw new ConfigParseException(
"Invalid 'items' type: expected list, got " +
(itemsObj != null ? itemsObj.getClass().getSimpleName() : "null")
"Invalid 'items' type: expected list, got " +
(itemsObj != null ? itemsObj.getClass().getSimpleName() : "null")
);
}
List<?> itemsList = (List<?>) itemsObj;
for (int i = 0; i < itemsList.size(); i++) {
Object itemObj = itemsList.get(i);
if (!(itemObj instanceof Map)) {
throw new ConfigParseException(
"Invalid item at index " + i + ": expected map, got " +
(itemObj != null ? itemObj.getClass().getSimpleName() : "null")
"Invalid item at index " + i + ": expected map, got " +
(itemObj != null ? itemObj.getClass().getSimpleName() : "null")
);
}
@SuppressWarnings("unchecked")
@ -205,8 +207,8 @@ final class RewardParser {
Object commandsObj = rewardMap.get("commands");
if (!(commandsObj instanceof List)) {
throw new ConfigParseException(
"Invalid 'commands' type: expected list, got " +
(commandsObj != null ? commandsObj.getClass().getSimpleName() : "null")
"Invalid 'commands' type: expected list, got " +
(commandsObj != null ? commandsObj.getClass().getSimpleName() : "null")
);
}
@SuppressWarnings("unchecked")

55
src/main/java/com/loki/lomines/data/stats/Leaderboard.java → src/main/java/dev/loki/lomines/data/stats/Leaderboard.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.data.stats;
package dev.loki.lomines.data.stats;
import java.util.Comparator;
import java.util.List;
@ -8,27 +8,26 @@ import java.util.stream.Collectors;
/**
* Manages leaderboard functionality with caching.
* Provides methods to retrieve top players by total blocks or by specific mine.
*
* <p>
* Thread-safety: Uses volatile cache and synchronized blocks for thread-safe operations.
* Cache is invalidated when player statistics change.
*/
public final class Leaderboard {
private final StatsManager statsManager;
private final Object cacheLock = new Object();
// Cache for getTopTotal - volatile for visibility across threads
private volatile List<LeaderboardEntry> cachedTopTotal = null;
private final Object cacheLock = new Object();
/**
* Creates a new Leaderboard instance.
*
*
* @param statsManager The stats manager to retrieve player statistics from
*/
public Leaderboard(StatsManager statsManager) {
this.statsManager = statsManager;
}
/**
* Invalidates the cached top total leaderboard.
* Should be called when player statistics change.
@ -38,11 +37,11 @@ public final class Leaderboard {
cachedTopTotal = null;
}
}
/**
* Returns the top players by total blocks mined across all mines.
* Results are cached and reused until invalidateCache() is called.
*
*
* @param limit Maximum number of entries to return
* @return List of leaderboard entries sorted by descending block count
*/
@ -51,52 +50,52 @@ public final class Leaderboard {
if (cachedTopTotal != null) {
return cachedTopTotal.subList(0, Math.min(limit, cachedTopTotal.size()));
}
// Slow path: build cache with double-checked locking
synchronized (cacheLock) {
// Double-check: another thread might have built the cache
if (cachedTopTotal != null) {
return cachedTopTotal.subList(0, Math.min(limit, cachedTopTotal.size()));
}
// Build the cache
cachedTopTotal = statsManager.getAllStats().stream()
.filter(stats -> stats.getTotalBlocks() > 0)
.sorted(Comparator.comparingLong(PlayerStats::getTotalBlocks).reversed())
.map(stats -> new LeaderboardEntry(stats.getPlayerId(), stats.getTotalBlocks()))
.collect(Collectors.toList());
.filter(stats -> stats.getTotalBlocks() > 0)
.sorted(Comparator.comparingLong(PlayerStats::getTotalBlocks).reversed())
.map(stats -> new LeaderboardEntry(stats.getPlayerId(), stats.getTotalBlocks()))
.collect(Collectors.toList());
return cachedTopTotal.subList(0, Math.min(limit, cachedTopTotal.size()));
}
}
/**
* Returns the top players for a specific mine.
* This method does not use caching as mine-specific leaderboards are less frequently accessed.
*
*
* @param mineName The name of the mine
* @param limit Maximum number of entries to return
* @param limit Maximum number of entries to return
* @return List of leaderboard entries sorted by descending block count for the specified mine
*/
public List<LeaderboardEntry> getTopByMine(String mineName, int limit) {
return statsManager.getAllStats().stream()
.map(stats -> new LeaderboardEntry(stats.getPlayerId(), stats.getMineBlocks(mineName)))
.filter(entry -> entry.getCount() > 0)
.sorted(Comparator.comparingLong(LeaderboardEntry::getCount).reversed())
.limit(limit)
.collect(Collectors.toList());
.map(stats -> new LeaderboardEntry(stats.getPlayerId(), stats.getMineBlocks(mineName)))
.filter(entry -> entry.count() > 0)
.sorted(Comparator.comparingLong(LeaderboardEntry::count).reversed())
.limit(limit)
.collect(Collectors.toList());
}
/**
* Returns the position of a player in the total leaderboard.
*
*
* @param playerId The UUID of the player
* @return The 1-based position of the player, or -1 if the player is not in the leaderboard
*/
public int getPosition(UUID playerId) {
List<LeaderboardEntry> top = getTopTotal(Integer.MAX_VALUE);
for (int i = 0; i < top.size(); i++) {
if (top.get(i).getPlayerId().equals(playerId)) {
if (top.get(i).playerId().equals(playerId)) {
return i + 1; // 1-based position
}
}

26
src/main/java/com/loki/lomines/data/stats/LeaderboardEntry.java → src/main/java/dev/loki/lomines/data/stats/LeaderboardEntry.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.data.stats;
package dev.loki.lomines.data.stats;
import java.util.Objects;
import java.util.UUID;
@ -7,24 +7,13 @@ import java.util.UUID;
* Immutable data class representing a single entry in the leaderboard.
* Contains a player's UUID and their block count.
*/
public final class LeaderboardEntry {
private final UUID playerId;
private final long count;
public record LeaderboardEntry(UUID playerId, long count) {
public LeaderboardEntry(UUID playerId, long count) {
this.playerId = Objects.requireNonNull(playerId, "playerId cannot be null");
this.count = count;
}
public UUID getPlayerId() {
return playerId;
}
public long getCount() {
return count;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
@ -32,12 +21,7 @@ public final class LeaderboardEntry {
LeaderboardEntry that = (LeaderboardEntry) o;
return count == that.count && playerId.equals(that.playerId);
}
@Override
public int hashCode() {
return Objects.hash(playerId, count);
}
@Override
public String toString() {
return "LeaderboardEntry{playerId=" + playerId + ", count=" + count + "}";

32
src/main/java/com/loki/lomines/data/stats/PlayerStats.java → src/main/java/dev/loki/lomines/data/stats/PlayerStats.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.data.stats;
package dev.loki.lomines.data.stats;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;
@ -9,46 +9,46 @@ import java.util.concurrent.atomic.AtomicLong;
* This is a placeholder implementation that will be completed in task 5.1.
*/
public final class PlayerStats {
private final UUID playerId;
private final AtomicLong totalBlocks = new AtomicLong(0);
private final ConcurrentHashMap<String, AtomicLong> mineStats = new ConcurrentHashMap<>();
public PlayerStats(UUID playerId) {
this.playerId = playerId;
}
public UUID getPlayerId() {
return playerId;
}
public long getTotalBlocks() {
return totalBlocks.get();
}
public void setTotalBlocks(long value) {
totalBlocks.set(value);
}
public long getMineBlocks(String mineName) {
AtomicLong counter = mineStats.get(mineName.toLowerCase());
return counter != null ? counter.get() : 0;
}
public void incrementTotal() {
totalBlocks.incrementAndGet();
}
public void incrementMine(String mineName) {
mineStats.computeIfAbsent(mineName.toLowerCase(), k -> new AtomicLong(0))
.incrementAndGet();
.incrementAndGet();
}
public void setTotalBlocks(long value) {
totalBlocks.set(value);
}
public void setMineBlocks(String mineName, long value) {
mineStats.computeIfAbsent(mineName.toLowerCase(), k -> new AtomicLong(0))
.set(value);
.set(value);
}
public java.util.Map<String, Long> getMineStatsSnapshot() {
java.util.Map<String, Long> snapshot = new java.util.HashMap<>();
mineStats.forEach((mine, counter) -> snapshot.put(mine, counter.get()));

78
src/main/java/com/loki/lomines/data/stats/StatsManager.java → src/main/java/dev/loki/lomines/data/stats/StatsManager.java
View file

@ -1,8 +1,8 @@
package com.loki.lomines.data.stats;
package dev.loki.lomines.data.stats;
import com.loki.lomines.LoMinesPlugin;
import dev.lolib.scheduler.Scheduler;
import dev.loki.lomines.LoMinesPlugin;
import dev.lolib.scheduler.ScheduledTask;
import dev.lolib.scheduler.Scheduler;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
@ -21,19 +21,19 @@ import java.util.concurrent.ConcurrentHashMap;
* Handles loading, saving, and auto-saving of player statistics.
*/
public final class StatsManager {
private final Map<UUID, PlayerStats> stats = new ConcurrentHashMap<>();
private final LoMinesPlugin plugin;
private final Path statsFile;
private final Leaderboard leaderboard;
private ScheduledTask saveTask;
public StatsManager(LoMinesPlugin plugin) {
this.plugin = plugin;
this.statsFile = plugin.getDataFolder().toPath().resolve("stats.yml");
this.leaderboard = new Leaderboard(this);
}
/**
* Loads statistics from file.
*/
@ -42,31 +42,31 @@ public final class StatsManager {
plugin.loLogger().info("Stats file does not exist, starting with empty statistics");
return;
}
File file = statsFile.toFile();
YamlConfiguration yaml = YamlConfiguration.loadConfiguration(file);
ConfigurationSection playersSection = yaml.getConfigurationSection("players");
if (playersSection == null) {
plugin.loLogger().info("No players section found in stats.yml");
return;
}
for (String uuidString : playersSection.getKeys(false)) {
try {
UUID playerId = UUID.fromString(uuidString);
ConfigurationSection playerSection = playersSection.getConfigurationSection(uuidString);
if (playerSection == null) {
continue;
}
PlayerStats playerStats = getOrCreate(playerId);
// Load total blocks
long totalBlocks = playerSection.getLong("total", 0);
playerStats.setTotalBlocks(totalBlocks);
// Load mine-specific stats
ConfigurationSection minesSection = playerSection.getConfigurationSection("mines");
if (minesSection != null) {
@ -79,25 +79,25 @@ public final class StatsManager {
plugin.loLogger().warn("Invalid UUID in stats.yml: " + uuidString);
}
}
plugin.loLogger().info("Loaded statistics for " + stats.size() + " player(s)");
}
/**
* Saves statistics to file.
*/
public void save() throws IOException {
YamlConfiguration yaml = new YamlConfiguration();
for (Map.Entry<UUID, PlayerStats> entry : stats.entrySet()) {
UUID playerId = entry.getKey();
PlayerStats playerStats = entry.getValue();
String path = "players." + playerId.toString();
// Save total blocks
yaml.set(path + ".total", playerStats.getTotalBlocks());
// Save mine-specific stats
Map<String, Long> mineStats = playerStats.getMineStatsSnapshot();
if (!mineStats.isEmpty()) {
@ -106,36 +106,36 @@ public final class StatsManager {
}
}
}
// Ensure parent directory exists
if (!Files.exists(statsFile.getParent())) {
Files.createDirectories(statsFile.getParent());
}
yaml.save(statsFile.toFile());
}
/**
* Starts auto-save task.
*/
public void startAutoSave() {
// Auto-save every 5 minutes (20 ticks/second * 60 seconds * 5 minutes)
long interval = 20L * 60L * 5L;
saveTask = Scheduler.get(plugin).runTimerAsync(
() -> {
try {
save();
plugin.loLogger().info("Statistics auto-saved");
} catch (IOException e) {
plugin.loLogger().error("Failed to auto-save statistics: " + e.getMessage());
}
},
interval,
interval
() -> {
try {
save();
plugin.loLogger().info("Statistics auto-saved");
} catch (IOException e) {
plugin.loLogger().error("Failed to auto-save statistics: " + e.getMessage());
}
},
interval,
interval
);
}
/**
* Stops auto-save task.
*/
@ -145,14 +145,14 @@ public final class StatsManager {
saveTask = null;
}
}
/**
* Gets or creates player statistics.
*/
public PlayerStats getOrCreate(UUID playerId) {
return stats.computeIfAbsent(playerId, PlayerStats::new);
}
/**
* Increments block count for a player in a specific mine.
*/
@ -160,18 +160,18 @@ public final class StatsManager {
PlayerStats playerStats = getOrCreate(playerId);
playerStats.incrementTotal();
playerStats.incrementMine(mineName);
// Invalidate leaderboard cache
leaderboard.invalidateCache();
}
/**
* Returns all player statistics.
*/
public Collection<PlayerStats> getAllStats() {
return Collections.unmodifiableCollection(stats.values());
}
/**
* Returns the leaderboard instance.
*/

66
src/main/java/com/loki/lomines/gui/GroupCreateGui.java → src/main/java/dev/loki/lomines/gui/GroupCreateGui.java
View file

@ -1,9 +1,9 @@
package com.loki.lomines.gui;
package dev.loki.lomines.gui;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.core.Mines;
import com.loki.lomines.wand.GroupWandManager;
import com.loki.lomines.wand.GroupWandSession;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.core.Mines;
import dev.loki.lomines.wand.GroupWandManager;
import dev.loki.lomines.wand.GroupWandSession;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.Bukkit;
@ -20,31 +20,37 @@ import java.util.List;
* 6-row chest: left column = create; center 3×3 = nine sub-mines with shared settings.
*/
public final class GroupCreateGui {
private static final int SIZE = 54;
/** Create group (same YAML defaults for every created mine). */
/**
* Create group (same YAML defaults for every created mine).
*/
public static final int SLOT_CREATE = 0;
/** Shows /lm group prefix. */
/**
* Shows /lm group prefix.
*/
public static final int SLOT_INFO = 8;
/** 3×3 mine slots mapping index 0..8 */
private static final int SIZE = 54;
/**
* 3×3 mine slots mapping index 0..8
*/
private static final int[] MINE_SLOTS = {10, 11, 12, 19, 20, 21, 28, 29, 30};
private GroupCreateGui() {
}
public static void open(LoMinesPlugin plugin, Player player) {
GroupCreateGuiHolder holder = new GroupCreateGuiHolder(player.getUniqueId());
Inventory inv = Bukkit.createInventory(holder, SIZE,
Component.text("LoMines · группа (9 шахт)", NamedTextColor.DARK_GREEN));
Component.text("LoMines · группа (9 шахт)", NamedTextColor.DARK_GREEN));
holder.setInventory(inv);
fill(plugin, player, inv);
player.openInventory(inv);
}
public static void refresh(LoMinesPlugin plugin, Player player, Inventory inv) {
fill(plugin, player, inv);
}
private static void fill(LoMinesPlugin plugin, Player player, Inventory inv) {
GroupWandSession session = plugin.getGroupWandManager().getSession(player.getUniqueId());
for (int i = 0; i < SIZE; i++) {
@ -56,7 +62,7 @@ public final class GroupCreateGui {
inv.setItem(MINE_SLOTS[i], mineSlotItem(session, i));
}
}
private static ItemStack filler() {
ItemStack pane = new ItemStack(Material.GRAY_STAINED_GLASS_PANE);
ItemMeta meta = pane.getItemMeta();
@ -66,21 +72,21 @@ public final class GroupCreateGui {
}
return pane;
}
private static ItemStack createButton() {
ItemStack stack = new ItemStack(Material.LIME_CONCRETE);
ItemMeta meta = stack.getItemMeta();
if (meta != null) {
meta.displayName(Component.text("Создать группу", NamedTextColor.GREEN));
meta.lore(List.of(
Component.text("Создаёт шахты с префиксом_1 … _9", NamedTextColor.GRAY),
Component.text("для слотов, где заданы оба угла", NamedTextColor.GRAY)
Component.text("Создаёт шахты с префиксом_1 … _9", NamedTextColor.GRAY),
Component.text("для слотов, где заданы оба угла", NamedTextColor.GRAY)
));
stack.setItemMeta(meta);
}
return stack;
}
private static ItemStack infoPaper(GroupWandSession session) {
ItemStack stack = new ItemStack(Material.PAPER);
ItemMeta meta = stack.getItemMeta();
@ -88,8 +94,8 @@ public final class GroupCreateGui {
if (session.hasBaseName()) {
meta.displayName(Component.text("Префикс: " + session.getBaseName(), NamedTextColor.AQUA));
meta.lore(List.of(
Component.text("Файлы: " + session.getBaseName() + "_1.yml … _9.yml", NamedTextColor.GRAY),
Component.text("Настройки одинаковые; правьте один и копируйте при нужде", NamedTextColor.DARK_GRAY)
Component.text("Файлы: " + session.getBaseName() + "_1.yml … _9.yml", NamedTextColor.GRAY),
Component.text("Настройки одинаковые; правьте один и копируйте при нужде", NamedTextColor.DARK_GRAY)
));
} else {
meta.displayName(Component.text("Задайте префикс", NamedTextColor.RED));
@ -99,7 +105,7 @@ public final class GroupCreateGui {
}
return stack;
}
private static ItemStack mineSlotItem(GroupWandSession session, int index) {
boolean active = session.getActiveSlot() == index;
boolean ready = session.isSlotReady(index);
@ -126,14 +132,14 @@ public final class GroupCreateGui {
List<Component> lore = new ArrayList<>();
lore.add(Component.text(active ? "Активный слот палочки" : "ПКМ — выбрать активным", NamedTextColor.GRAY));
lore.add(Component.text(
ready ? "Готово (2 точки)" : (session.getPos1(index) != null ? "Нужна 2-я точка" : "Нужны 2 точки"),
NamedTextColor.DARK_GRAY));
ready ? "Готово (2 точки)" : (session.getPos1(index) != null ? "Нужна 2-я точка" : "Нужны 2 точки"),
NamedTextColor.DARK_GRAY));
meta.lore(lore);
stack.setItemMeta(meta);
}
return stack;
}
public static int mineSlotIndex(int rawSlot) {
for (int i = 0; i < MINE_SLOTS.length; i++) {
if (MINE_SLOTS[i] == rawSlot) {
@ -142,7 +148,7 @@ public final class GroupCreateGui {
}
return -1;
}
/**
* @return true if handled (caller should cancel event)
*/
@ -169,7 +175,7 @@ public final class GroupCreateGui {
}
return true;
}
private static void runCreate(LoMinesPlugin plugin, Player player, GroupWandSession session) {
if (!session.hasBaseName()) {
player.sendMessage(Component.text("Сначала: /lm group <префикс>", NamedTextColor.RED));
@ -204,7 +210,7 @@ public final class GroupCreateGui {
return;
}
player.sendMessage(Component.text(
"Создано шахт: " + created + (skipped > 0 ? " (пропущено существующих: " + skipped + ")" : ""),
NamedTextColor.GREEN));
"Создано шахт: " + created + (skipped > 0 ? " (пропущено существующих: " + skipped + ")" : ""),
NamedTextColor.GREEN));
}
}

18
src/main/java/com/loki/lomines/gui/GroupCreateGuiHolder.java → src/main/java/dev/loki/lomines/gui/GroupCreateGuiHolder.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.gui;
package dev.loki.lomines.gui;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
@ -9,24 +9,24 @@ import java.util.UUID;
* Marks the group-create menu and ties it to a player.
*/
public final class GroupCreateGuiHolder implements InventoryHolder {
private final UUID playerId;
private Inventory inventory;
public GroupCreateGuiHolder(UUID playerId) {
this.playerId = playerId;
}
public UUID getPlayerId() {
return playerId;
}
void setInventory(Inventory inventory) {
this.inventory = inventory;
}
@Override
public Inventory getInventory() {
return inventory;
}
void setInventory(Inventory inventory) {
this.inventory = inventory;
}
}

2
src/main/java/com/loki/lomines/gui/package-info.java → src/main/java/dev/loki/lomines/gui/package-info.java
View file

@ -10,4 +10,4 @@
* <li>{@code MineRewardEditor} - Editor for a specific reward</li>
* </ul>
*/
package com.loki.lomines.gui;
package dev.loki.lomines.gui;

56
src/main/java/com/loki/lomines/handler/ActionBarHandler.java → src/main/java/dev/loki/lomines/handler/ActionBarHandler.java
View file

@ -1,8 +1,8 @@
package com.loki.lomines.handler;
package dev.loki.lomines.handler;
import com.loki.lomines.core.Mine;
import com.loki.lomines.util.Cuboid;
import com.loki.lomines.util.TimeFormatter;
import dev.loki.lomines.core.Mine;
import dev.loki.lomines.util.format.TimeFormatter;
import dev.loki.lomines.util.location.Cuboid;
import dev.lolib.utils.ActionBar;
import org.bukkit.Location;
import org.bukkit.entity.Player;
@ -12,13 +12,13 @@ import org.bukkit.entity.Player;
* Sends formatted messages to players within range of the mine.
*/
public final class ActionBarHandler {
private final Mine mine;
public ActionBarHandler(Mine mine) {
this.mine = mine;
}
/**
* Sends action bar messages to all players within range of the mine.
*/
@ -26,61 +26,61 @@ public final class ActionBarHandler {
if (!mine.getConfig().isActionBarEnabled()) {
return;
}
Location center = calculateCenter();
if (center == null || center.getWorld() == null) {
return;
}
double range = mine.getConfig().getActionBarRange();
String message = formatMessage();
center.getWorld().getNearbyEntities(center, range, range, range).stream()
.filter(entity -> entity instanceof Player)
.map(entity -> (Player) entity)
.forEach(player -> ActionBar.send(player, message));
.filter(entity -> entity instanceof Player)
.map(entity -> (Player) entity)
.forEach(player -> ActionBar.send(player, message));
}
/**
* Calculates the center point of the mine.
* Uses the center of the first region.
*
*
* @return The center location, or null if no regions exist
*/
private Location calculateCenter() {
if (mine.getRegions().isEmpty()) {
return null;
}
Cuboid firstRegion = mine.getRegions().get(0);
int centerX = (firstRegion.getMinX() + firstRegion.getMaxX()) / 2;
int centerY = (firstRegion.getMinY() + firstRegion.getMaxY()) / 2;
int centerZ = (firstRegion.getMinZ() + firstRegion.getMaxZ()) / 2;
return new Location(firstRegion.getWorld(), centerX, centerY, centerZ);
}
/**
* Formats the action bar message with placeholders.
*
*
* @return The formatted message
*/
private String formatMessage() {
String template = mine.getConfig().getActionBarMessage();
String formatted = template
.replace("%mine%", mine.getName())
.replace("%percent%", String.format("%.1f", mine.getPercentFilled()))
.replace("%blocks%", String.valueOf(mine.getBlocks()))
.replace("%total%", String.valueOf(mine.getTotalVolume()))
.replace("%time%", formatTime());
.replace("%mine%", mine.getName())
.replace("%percent%", String.format("%.1f", mine.getPercentFilled()))
.replace("%blocks%", String.valueOf(mine.getBlocks()))
.replace("%total%", String.valueOf(mine.getTotalVolume()))
.replace("%time%", formatTime());
return formatted;
}
/**
* Formats the time remaining until reset.
*
*
* @return Formatted time string
*/
private String formatTime() {

28
src/main/java/com/loki/lomines/handler/MineBlockHandler.java → src/main/java/dev/loki/lomines/handler/MineBlockHandler.java
View file

@ -1,8 +1,8 @@
package com.loki.lomines.handler;
package dev.loki.lomines.handler;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.core.Mine;
import com.loki.lomines.data.config.MineConfig;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.core.Mine;
import dev.loki.lomines.data.config.MineConfig;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
@ -11,35 +11,35 @@ import org.bukkit.entity.Player;
* Coordinates reward checking, statistics updates, and reset condition checks.
*/
public final class MineBlockHandler {
private final Mine mine;
private final LoMinesPlugin plugin;
private final MineRewardHandler rewardHandler;
public MineBlockHandler(Mine mine, LoMinesPlugin plugin) {
this.mine = mine;
this.plugin = plugin;
this.rewardHandler = new MineRewardHandler(mine.getConfig(), plugin);
}
/**
* Handles a block break event in the mine.
*
*
* @param player The player who broke the block
* @param block The block that was broken
* @param block The block that was broken
*/
public void handle(Player player, Block block) {
int remaining = mine.getBlocksAtomic().decrementAndGet();
rewardHandler.checkRewards(player, block);
if (plugin.getConfig().getBoolean("statistics-enabled", true)) {
plugin.getStatsManager().incrementBlocks(player.getUniqueId(), mine.getName());
}
checkResetConditions(remaining);
}
/**
* Checks if reset conditions are met and triggers reset if needed.
*/
@ -50,7 +50,7 @@ public final class MineBlockHandler {
return;
}
double percent = (double) remaining / total * 100.0;
if (config.isResetOnPercentEnabled() && percent <= config.getResetPercent()) {
mine.reset(false);
}

51
src/main/java/com/loki/lomines/handler/MineResetHandler.java → src/main/java/dev/loki/lomines/handler/MineResetHandler.java
View file

@ -1,11 +1,10 @@
package com.loki.lomines.handler;
package dev.loki.lomines.handler;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.core.Mine;
import dev.loki.lomines.data.config.FillMode;
import dev.loki.lomines.util.location.Cuboid;
import dev.lolib.scheduler.Scheduler;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.core.Mine;
import com.loki.lomines.data.FillMode;
import com.loki.lomines.util.Cuboid;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.minimessage.MiniMessage;
import org.bukkit.Location;
@ -18,7 +17,7 @@ import java.util.concurrent.atomic.AtomicInteger;
/**
* Handles mine reset operations.
* Ensures thread-safe reset execution and prevents concurrent resets.
*
*
* <p>Reset process:</p>
* <ol>
* <li>Check if reset is already running (atomic check)</li>
@ -28,27 +27,27 @@ import java.util.concurrent.atomic.AtomicInteger;
* </ol>
*/
public final class MineResetHandler {
private final Mine mine;
private final LoMinesPlugin plugin;
private final AtomicBoolean running = new AtomicBoolean(false);
public MineResetHandler(Mine mine, LoMinesPlugin plugin) {
this.mine = mine;
this.plugin = plugin;
}
/**
* Resets the mine by filling all regions with blocks.
* If a reset is already in progress, this call is ignored.
*
*
* @param silent If true, suppresses broadcast messages
*/
public void reset(boolean silent) {
if (!running.compareAndSet(false, true)) {
return;
}
try {
resetAllRegions(silent);
} catch (Exception e) {
@ -57,7 +56,7 @@ public final class MineResetHandler {
e.printStackTrace();
}
}
/**
* Fills all regions asynchronously and coordinates completion.
*/
@ -65,23 +64,23 @@ public final class MineResetHandler {
List<Cuboid> regions = mine.getRegions();
AtomicInteger completed = new AtomicInteger(0);
AtomicInteger totalBlocks = new AtomicInteger(0);
if (mine.getBlockSetter() == null) {
plugin.loLogger().warn("BlockSetter not initialized for mine " + mine.getName());
running.set(false);
return;
}
if (mine.getConfig().getFillMode() == FillMode.MASK) {
mine.getBlockSetter().fillAtLocations(mine.getConfig().getMaskPositions(), placed ->
Scheduler.get(plugin).run(() -> onResetComplete(placed, silent)));
Scheduler.get(plugin).run(() -> onResetComplete(placed, silent)));
return;
}
for (Cuboid region : regions) {
mine.getBlockSetter().fill(region, blocksSet -> {
totalBlocks.addAndGet(blocksSet);
if (completed.incrementAndGet() == regions.size()) {
Scheduler.get(plugin).run(() -> {
onResetComplete(totalBlocks.get(), silent);
@ -90,7 +89,7 @@ public final class MineResetHandler {
});
}
}
/**
* Called when all regions have been filled.
* Executes post-reset actions in the main thread.
@ -98,20 +97,20 @@ public final class MineResetHandler {
private void onResetComplete(int totalBlocks, boolean silent) {
mine.getBlocksAtomic().set(totalBlocks);
mine.getTicksAtomic().set(0);
executeResetCommands();
if (!silent) {
broadcastReset();
}
if (mine.getConfig().isTeleportOnReset()) {
teleportPlayers();
}
running.set(false);
}
/**
* Executes commands configured for reset.
*/
@ -122,7 +121,7 @@ public final class MineResetHandler {
plugin.getServer().dispatchCommand(plugin.getServer().getConsoleSender(), parsed);
}
}
/**
* Broadcasts reset message to players.
*/
@ -134,7 +133,7 @@ public final class MineResetHandler {
plugin.getServer().broadcast(component);
}
}
/**
* Teleports players standing inside the mine to the configured location.
*/

36
src/main/java/com/loki/lomines/handler/MineRewardHandler.java → src/main/java/dev/loki/lomines/handler/MineRewardHandler.java
View file

@ -1,8 +1,8 @@
package com.loki.lomines.handler;
package dev.loki.lomines.handler;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.data.config.MineConfig;
import com.loki.lomines.data.Reward;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.data.config.MineConfig;
import dev.loki.lomines.data.reward.Reward;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.entity.Player;
@ -16,54 +16,54 @@ import java.util.Random;
* Checks configured rewards and gives items/executes commands based on chance.
*/
public final class MineRewardHandler {
private final List<Reward> rewards;
private final LoMinesPlugin plugin;
private final Random random = new Random();
public MineRewardHandler(MineConfig config, LoMinesPlugin plugin) {
this.rewards = config.getRewards();
this.plugin = plugin;
}
/**
* Checks and applies rewards for a broken block.
*
*
* @param player The player who broke the block
* @param block The block that was broken
* @param block The block that was broken
*/
public void checkRewards(Player player, Block block) {
Material material = block.getType();
for (Reward reward : rewards) {
if (reward.matches(material) && rollChance(reward.getChance())) {
if (reward.matches(material) && rollChance(reward.chance())) {
giveReward(player, reward);
}
}
}
/**
* Rolls a random chance check.
*
*
* @param chance The chance percentage (0-100)
* @return true if the roll succeeds
*/
private boolean rollChance(double chance) {
return random.nextDouble() * 100.0 < chance;
}
/**
* Gives a reward to the player.
*
*
* @param player The player to give the reward to
* @param reward The reward to give
*/
private void giveReward(Player player, Reward reward) {
for (ItemStack item : reward.getItems()) {
for (ItemStack item : reward.items()) {
player.getInventory().addItem(item.clone());
}
for (String command : reward.getCommands()) {
for (String command : reward.commands()) {
String parsed = command.replace("%player%", player.getName());
plugin.getServer().dispatchCommand(plugin.getServer().getConsoleSender(), parsed);
}

2
src/main/java/com/loki/lomines/handler/package-info.java → src/main/java/dev/loki/lomines/handler/package-info.java
View file

@ -9,4 +9,4 @@
* <li>{@code ActionBarHandler} - Displays information in action bar</li>
* </ul>
*/
package com.loki.lomines.handler;
package dev.loki.lomines.handler;

74
src/main/java/dev/loki/lomines/integration/IntegrationManager.java Normal file
View file

@ -0,0 +1,74 @@
package dev.loki.lomines.integration;
import dev.loki.lomines.LoMinesPlugin;
import org.bukkit.Bukkit;
/**
* Manages integrations with external plugins.
*/
public final class IntegrationManager {
private final LoMinesPlugin plugin;
// private PlaceholderAPIIntegration placeholderAPI;
public IntegrationManager(LoMinesPlugin plugin) {
this.plugin = plugin;
}
/**
* Initializes all available integrations.
*/
public void initAll() {
// initPlaceholderAPI();
checkWorldGuard();
checkOraxen();
checkItemsAdder();
}
// private void initPlaceholderAPI() {
// if (isPluginEnabled("PlaceholderAPI")) {
// try {
// placeholderAPI = new PlaceholderAPIIntegration(plugin);
// placeholderAPI.register();
// plugin.loLogger().info("PlaceholderAPI integration enabled");
// } catch (Exception e) {
// plugin.loLogger().warn("Failed to enable PlaceholderAPI integration: " + e.getMessage());
// }
// }
// }
private void checkWorldGuard() {
if (isPluginEnabled("WorldGuard")) {
plugin.loLogger().info("WorldGuard detected (integration not yet implemented)");
}
}
private void checkOraxen() {
if (isPluginEnabled("Oraxen")) {
plugin.loLogger().info("Oraxen integration available");
}
}
private void checkItemsAdder() {
if (isPluginEnabled("ItemsAdder")) {
plugin.loLogger().info("ItemsAdder integration available");
}
}
/**
* Checks if a plugin is enabled.
*/
public boolean isPluginEnabled(String pluginName) {
return Bukkit.getPluginManager().getPlugin(pluginName) != null &&
Bukkit.getPluginManager().isPluginEnabled(pluginName);
}
/**
* Unregisters all integrations.
*/
public void shutdown() {
// if (placeholderAPI != null) {
// placeholderAPI.unregister();
// }
}
}

2
src/main/java/com/loki/lomines/integration/package-info.java → src/main/java/dev/loki/lomines/integration/package-info.java
View file

@ -8,4 +8,4 @@
* <li>{@code WGRegionManager} - WorldGuard region management</li>
* </ul>
*/
package com.loki.lomines.integration;
package dev.loki.lomines.integration;

14
src/main/java/com/loki/lomines/listener/BlockBreakListener.java → src/main/java/dev/loki/lomines/listener/BlockBreakListener.java
View file

@ -1,7 +1,7 @@
package com.loki.lomines.listener;
package dev.loki.lomines.listener;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.core.Mine;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.core.Mine;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
@ -14,17 +14,17 @@ import java.util.Optional;
* This is a placeholder implementation that will be completed in task 11.1.
*/
public final class BlockBreakListener implements Listener {
private final LoMinesPlugin plugin;
public BlockBreakListener(LoMinesPlugin plugin) {
this.plugin = plugin;
}
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockBreak(BlockBreakEvent event) {
Optional<Mine> mine = plugin.getMines().findByLocation(event.getBlock().getLocation());
if (mine.isPresent()) {
Mine m = mine.get();
if (m.appliesToBlock(event.getBlock().getLocation())) {

16
src/main/java/com/loki/lomines/listener/GroupGuiListener.java → src/main/java/dev/loki/lomines/listener/GroupGuiListener.java
View file

@ -1,8 +1,8 @@
package com.loki.lomines.listener;
package dev.loki.lomines.listener;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.gui.GroupCreateGui;
import com.loki.lomines.gui.GroupCreateGuiHolder;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.gui.GroupCreateGui;
import dev.loki.lomines.gui.GroupCreateGuiHolder;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
@ -14,13 +14,13 @@ import org.bukkit.inventory.InventoryView;
* Handles clicks in the group-create chest GUI.
*/
public final class GroupGuiListener implements Listener {
private final LoMinesPlugin plugin;
public GroupGuiListener(LoMinesPlugin plugin) {
this.plugin = plugin;
}
@EventHandler
public void onInventoryClick(InventoryClickEvent event) {
InventoryView view = event.getView();
@ -41,7 +41,7 @@ public final class GroupGuiListener implements Listener {
}
GroupCreateGui.handleClick(plugin, player, raw);
}
@EventHandler
public void onInventoryDrag(InventoryDragEvent event) {
if (event.getInventory().getHolder() instanceof GroupCreateGuiHolder) {

26
src/main/java/com/loki/lomines/listener/PlayerInteractListener.java → src/main/java/dev/loki/lomines/listener/PlayerInteractListener.java
View file

@ -1,9 +1,9 @@
package com.loki.lomines.listener;
package dev.loki.lomines.listener;
import com.loki.lomines.LoMinesPlugin;
import com.loki.lomines.gui.GroupCreateGui;
import com.loki.lomines.wand.GroupWandItem;
import com.loki.lomines.wand.GroupWandSession;
import dev.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.gui.GroupCreateGui;
import dev.loki.lomines.wand.GroupWandItem;
import dev.loki.lomines.wand.GroupWandSession;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.block.Block;
@ -19,13 +19,13 @@ import org.bukkit.inventory.EquipmentSlot;
* Group wand: ЛКМ / ПКМ по блоку — углы; Shift+ПКМ — GUI группы.
*/
public final class PlayerInteractListener implements Listener {
private final LoMinesPlugin plugin;
public PlayerInteractListener(LoMinesPlugin plugin) {
this.plugin = plugin;
}
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = false)
public void onPlayerInteract(PlayerInteractEvent event) {
if (event.getHand() != EquipmentSlot.HAND) {
@ -36,13 +36,13 @@ public final class PlayerInteractListener implements Listener {
return;
}
Action action = event.getAction();
if (player.isSneaking() && (action == Action.RIGHT_CLICK_AIR || action == Action.RIGHT_CLICK_BLOCK)) {
event.setCancelled(true);
GroupCreateGui.open(plugin, player);
return;
}
if (action == Action.LEFT_CLICK_BLOCK && event.hasBlock()) {
event.setCancelled(true);
Block block = event.getClickedBlock();
@ -53,10 +53,10 @@ public final class PlayerInteractListener implements Listener {
int slot = session.getActiveSlot();
session.setPos1(slot, block.getLocation());
player.sendMessage(Component.text(
"Угол 1 для шахты " + (slot + 1) + " установлен.", NamedTextColor.GREEN));
"Угол 1 для шахты " + (slot + 1) + " установлен.", NamedTextColor.GREEN));
return;
}
if (action == Action.RIGHT_CLICK_BLOCK && !player.isSneaking()) {
event.setCancelled(true);
Block block = event.getClickedBlock();
@ -67,7 +67,7 @@ public final class PlayerInteractListener implements Listener {
int slot = session.getActiveSlot();
session.setPos2(slot, block.getLocation());
player.sendMessage(Component.text(
"Угол 2 для шахты " + (slot + 1) + " установлен.", NamedTextColor.GREEN));
"Угол 2 для шахты " + (slot + 1) + " установлен.", NamedTextColor.GREEN));
}
}
}

10
src/main/java/com/loki/lomines/listener/PlayerJoinListener.java → src/main/java/dev/loki/lomines/listener/PlayerJoinListener.java
View file

@ -1,6 +1,6 @@
package com.loki.lomines.listener;
package dev.loki.lomines.listener;
import com.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.LoMinesPlugin;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
@ -10,13 +10,13 @@ import org.bukkit.event.player.PlayerJoinEvent;
* This is a placeholder implementation that will be completed in task 11.3.
*/
public final class PlayerJoinListener implements Listener {
private final LoMinesPlugin plugin;
public PlayerJoinListener(LoMinesPlugin plugin) {
this.plugin = plugin;
}
@EventHandler
public void onPlayerJoin(PlayerJoinEvent event) {
// Load or create player statistics

2
src/main/java/com/loki/lomines/listener/package-info.java → src/main/java/dev/loki/lomines/listener/package-info.java
View file

@ -9,4 +9,4 @@
* <li>{@code SelectionParticleTask} - Displays particles for active selections</li>
* </ul>
*/
package com.loki.lomines.listener;
package dev.loki.lomines.listener;

84
src/main/java/dev/loki/lomines/util/ErrorHandler.java Normal file
View file

@ -0,0 +1,84 @@
package dev.loki.lomines.util;
import org.bukkit.command.CommandSender;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
* Унифицированная обработка ошибок и отправка сообщений
*/
public class ErrorHandler {
private final Logger logger;
private final String prefix;
public ErrorHandler(Logger logger, String prefix) {
this.logger = logger;
this.prefix = prefix;
}
/**
* Отправить сообщение об ошибке игроку
*/
public void sendError(CommandSender sender, String message) {
sender.sendMessage(MessageFormatter.error(message));
}
/**
* Отправить сообщение об ошибке игроку с причиной
*/
public void sendError(CommandSender sender, String message, String reason) {
sender.sendMessage(MessageFormatter.error(message + ": " + reason));
}
/**
* Залогировать ошибку
*/
public void logError(String message) {
logger.log(Level.SEVERE, prefix + message);
}
/**
* Залогировать ошибку с исключением
*/
public void logError(String message, Throwable throwable) {
logger.log(Level.SEVERE, prefix + message, throwable);
}
/**
* Отправить ошибку игроку и залогировать
*/
public void handleError(CommandSender sender, String userMessage, String logMessage) {
sendError(sender, userMessage);
logError(logMessage);
}
/**
* Отправить ошибку игроку и залогировать с исключением
*/
public void handleError(CommandSender sender, String userMessage, String logMessage, Throwable throwable) {
sendError(sender, userMessage);
logError(logMessage, throwable);
}
/**
* Обработать ошибку валидации
*/
public void handleValidationError(CommandSender sender, String fieldName, String value) {
sendError(sender, "Некорректное значение для " + fieldName + ": " + value);
}
/**
* Обработать ошибку "не найдено"
*/
public void handleNotFound(CommandSender sender, String entityType, String identifier) {
sendError(sender, entityType + " '" + identifier + "' не найден");
}
/**
* Обработать ошибку доступа
*/
public void handlePermissionDenied(CommandSender sender, String action) {
sendError(sender, "У вас нет прав для: " + action);
}
}

59
src/main/java/dev/loki/lomines/util/MessageFormatter.java Normal file
View file

@ -0,0 +1,59 @@
package dev.loki.lomines.util;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import net.kyori.adventure.text.format.TextDecoration;
/**
* Utility class for formatting messages with consistent styling.
*/
public final class MessageFormatter {
private static final String PREFIX = "[LoMines] ";
private MessageFormatter() {
}
/**
* Creates a success message (green).
*/
public static Component success(String message) {
return Component.text(PREFIX + message, NamedTextColor.GREEN);
}
/**
* Creates an error message (red).
*/
public static Component error(String message) {
return Component.text(PREFIX + message, NamedTextColor.RED);
}
/**
* Creates a warning message (yellow).
*/
public static Component warning(String message) {
return Component.text(PREFIX + message, NamedTextColor.YELLOW);
}
/**
* Creates an info message (gray).
*/
public static Component info(String message) {
return Component.text(PREFIX + message, NamedTextColor.GRAY);
}
/**
* Creates a highlighted message (aqua, bold).
*/
public static Component highlight(String message) {
return Component.text(message, NamedTextColor.AQUA)
.decoration(TextDecoration.BOLD, true);
}
/**
* Creates a plain message without prefix.
*/
public static Component plain(String message) {
return Component.text(message);
}
}

62
src/main/java/dev/loki/lomines/util/ValidationUtils.java Normal file
View file

@ -0,0 +1,62 @@
package dev.loki.lomines.util;
import org.bukkit.Material;
import java.util.Optional;
/**
* Utility class for validation operations.
*/
public final class ValidationUtils {
private ValidationUtils() {
}
/**
* Validates and parses a material name.
*
* @param materialName the material name to validate
* @return the Material if valid
* @throws IllegalArgumentException if material is invalid
*/
public static Material validateMaterial(String materialName) {
if (materialName == null || materialName.isBlank()) {
throw new IllegalArgumentException("Material name cannot be null or empty");
}
try {
return Material.valueOf(materialName.toUpperCase());
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Invalid material: " + materialName);
}
}
/**
* Safely parses a material name, returning Optional.
*
* @param materialName the material name to parse
* @return Optional containing the Material if valid, empty otherwise
*/
public static Optional<Material> parseMaterial(String materialName) {
if (materialName == null || materialName.isBlank()) {
return Optional.empty();
}
try {
return Optional.of(Material.valueOf(materialName.toUpperCase()));
} catch (IllegalArgumentException e) {
return Optional.empty();
}
}
/**
* Parses a material name with a fallback default.
*
* @param materialName the material name to parse
* @param defaultMaterial the default material if parsing fails
* @return the parsed Material or the default
*/
public static Material parseMaterialOrDefault(String materialName, Material defaultMaterial) {
return parseMaterial(materialName).orElse(defaultMaterial);
}
}

85
src/main/java/com/loki/lomines/util/format/ChunkUtils.java → src/main/java/dev/loki/lomines/util/format/ChunkUtils.java
View file

@ -1,5 +1,6 @@
package com.loki.lomines.util.format;
package dev.loki.lomines.util.format;
import dev.loki.lomines.util.location.Cuboid;
import org.bukkit.Chunk;
import org.bukkit.World;
@ -10,23 +11,23 @@ import java.util.Set;
/**
* Utility class for updating chunks after block modifications.
* Automatically detects Paper API availability and uses the most efficient method.
*
*
* <p>Paper detection is done through method reflection rather than Class.forName
* to provide a more reliable mechanism as per requirement 21.4.</p>
*/
public final class ChunkUtils {
private static final boolean IS_PAPER = detectPaper();
private static final Method SEND_CHUNK_CHANGE_METHOD = findSendChunkChangeMethod();
private ChunkUtils() {
throw new UnsupportedOperationException("Utility class");
}
/**
* Updates all chunks within the given cuboid region.
* Uses Paper API if available for better performance, otherwise falls back to Bukkit API.
*
*
* @param region The cuboid region whose chunks should be updated
* @throws IllegalArgumentException if region is null
*/
@ -34,20 +35,20 @@ public final class ChunkUtils {
if (region == null) {
throw new IllegalArgumentException("Region cannot be null");
}
Set<ChunkCoordinate> chunks = getAffectedChunks(region);
World world = region.getWorld();
for (ChunkCoordinate coord : chunks) {
Chunk chunk = world.getChunkAt(coord.x, coord.z);
updateChunk(chunk);
}
}
/**
* Detects if Paper API is available by checking for Paper-specific methods.
* This is more reliable than Class.forName as it checks for actual functionality.
*
*
* @return true if Paper API is available, false otherwise
*/
private static boolean detectPaper() {
@ -61,17 +62,17 @@ public final class ChunkUtils {
return false;
}
}
/**
* Finds the sendChunkChange method if running on Paper.
*
*
* @return The sendChunkChange method, or null if not available
*/
private static Method findSendChunkChangeMethod() {
if (!IS_PAPER) {
return null;
}
try {
Class<?> chunkClass = Chunk.class;
// Paper 1.21 has sendChunkChange() method
@ -80,10 +81,10 @@ public final class ChunkUtils {
return null;
}
}
/**
* Updates a single chunk using the appropriate API.
*
*
* @param chunk The chunk to update
*/
private static void updateChunk(Chunk chunk) {
@ -93,10 +94,10 @@ public final class ChunkUtils {
updateChunkBukkit(chunk);
}
}
/**
* Updates a chunk using Paper API.
*
*
* @param chunk The chunk to update
*/
private static void updateChunkPaper(Chunk chunk) {
@ -107,11 +108,11 @@ public final class ChunkUtils {
updateChunkBukkit(chunk);
}
}
/**
* Updates a chunk using Bukkit API.
* Forces chunk to be resent to all players by marking it as modified.
*
*
* @param chunk The chunk to update
*/
private static void updateChunkBukkit(Chunk chunk) {
@ -120,7 +121,7 @@ public final class ChunkUtils {
// We can force a refresh by unloading and reloading, but that's expensive
// Instead, we rely on the natural chunk update mechanism
// Players will see the changes when the chunk is next sent to them
// For Bukkit, we can use the World's refreshChunk method if available
World world = chunk.getWorld();
try {
@ -132,54 +133,42 @@ public final class ChunkUtils {
// This is acceptable as blocks are already set
}
}
/**
* Calculates all chunk coordinates that are affected by the given region.
*
*
* @param region The cuboid region
* @return Set of chunk coordinates
*/
private static Set<ChunkCoordinate> getAffectedChunks(Cuboid region) {
Set<ChunkCoordinate> chunks = new HashSet<>();
// Convert block coordinates to chunk coordinates
int minChunkX = region.getMinX() >> 4;
int maxChunkX = region.getMaxX() >> 4;
int minChunkZ = region.getMinZ() >> 4;
int maxChunkZ = region.getMaxZ() >> 4;
for (int chunkX = minChunkX; chunkX <= maxChunkX; chunkX++) {
for (int chunkZ = minChunkZ; chunkZ <= maxChunkZ; chunkZ++) {
chunks.add(new ChunkCoordinate(chunkX, chunkZ));
}
}
return chunks;
}
/**
* Simple immutable holder for chunk coordinates.
*/
private static final class ChunkCoordinate {
final int x;
final int z;
ChunkCoordinate(int x, int z) {
this.x = x;
this.z = z;
}
* Simple immutable holder for chunk coordinates.
*/
private record ChunkCoordinate(int x, int z) {
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof ChunkCoordinate)) return false;
ChunkCoordinate other = (ChunkCoordinate) obj;
return x == other.x && z == other.z;
}
@Override
public int hashCode() {
return 31 * x + z;
}
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof ChunkCoordinate other)) return false;
return x == other.x && z == other.z;
}
}
}

24
src/main/java/com/loki/lomines/util/format/TimeFormatter.java → src/main/java/dev/loki/lomines/util/format/TimeFormatter.java
View file

@ -1,23 +1,23 @@
package com.loki.lomines.util.format;
package dev.loki.lomines.util.format;
/**
* Utility class for formatting time from Minecraft ticks to human-readable formats.
* Minecraft runs at 20 ticks per second.
*/
public final class TimeFormatter {
private static final int TICKS_PER_SECOND = 20;
private static final int SECONDS_PER_MINUTE = 60;
private static final int MINUTES_PER_HOUR = 60;
private TimeFormatter() {
throw new UnsupportedOperationException("Utility class");
}
/**
* Formats time from Minecraft ticks to a human-readable string.
*
* @param ticks the number of Minecraft ticks
* @param ticks the number of Minecraft ticks
* @param format the desired format: "mm:ss", "hh:mm:ss", "s", "m", or "h"
* @return the formatted time string
* @throws IllegalArgumentException if the format is not recognized
@ -26,13 +26,13 @@ public final class TimeFormatter {
if (format == null || format.trim().isEmpty()) {
throw new IllegalArgumentException("Format cannot be null or empty");
}
if (ticks < 0) {
ticks = 0;
}
int totalSeconds = ticks / TICKS_PER_SECOND;
return switch (format.toLowerCase()) {
case "mm:ss" -> formatMinutesSeconds(totalSeconds);
case "hh:mm:ss" -> formatHoursMinutesSeconds(totalSeconds);
@ -40,12 +40,12 @@ public final class TimeFormatter {
case "m" -> String.valueOf(totalSeconds / SECONDS_PER_MINUTE);
case "h" -> String.valueOf(totalSeconds / (SECONDS_PER_MINUTE * MINUTES_PER_HOUR));
default -> throw new IllegalArgumentException(
"Unknown time format: '" + format + "'. " +
"Supported formats: mm:ss, hh:mm:ss, s, m, h"
"Unknown time format: '" + format + "'. " +
"Supported formats: mm:ss, hh:mm:ss, s, m, h"
);
};
}
/**
* Formats time as "mm:ss" (minutes:seconds).
*/
@ -54,7 +54,7 @@ public final class TimeFormatter {
int seconds = totalSeconds % SECONDS_PER_MINUTE;
return String.format("%02d:%02d", minutes, seconds);
}
/**
* Formats time as "hh:mm:ss" (hours:minutes:seconds).
*/

8
src/main/java/com/loki/lomines/util/location/BlockKeys.java → src/main/java/dev/loki/lomines/util/location/BlockKeys.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.util.location;
package dev.loki.lomines.util.location;
import org.bukkit.Location;
import org.bukkit.block.Block;
@ -7,14 +7,14 @@ import org.bukkit.block.Block;
* Stable string keys for block-aligned locations (world + block integer coords).
*/
public final class BlockKeys {
private BlockKeys() {
}
public static String key(Block block) {
return key(block.getLocation());
}
public static String key(Location loc) {
return loc.getWorld().getName() + ":" + loc.getBlockX() + ":" + loc.getBlockY() + ":" + loc.getBlockZ();
}

83
src/main/java/com/loki/lomines/util/location/Cuboid.java → src/main/java/dev/loki/lomines/util/location/Cuboid.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.util.location;
package dev.loki.lomines.util.location;
import org.bukkit.Location;
import org.bukkit.World;
@ -6,11 +6,11 @@ import org.bukkit.World;
/**
* Immutable representation of a rectangular 3D region (cuboid) in a Minecraft world.
* Used to define mine boundaries and check block containment.
*
*
* <p>This class is thread-safe due to its immutability.</p>
*/
public final class Cuboid {
private final World world;
private final int minX;
private final int minY;
@ -18,11 +18,11 @@ public final class Cuboid {
private final int maxX;
private final int maxY;
private final int maxZ;
/**
* Creates a cuboid from two corner locations.
* The locations must be in the same world.
*
*
* @param loc1 First corner location
* @param loc2 Second corner location (opposite corner)
* @throws IllegalArgumentException if locations are in different worlds or null
@ -31,30 +31,30 @@ public final class Cuboid {
if (loc1 == null || loc2 == null) {
throw new IllegalArgumentException("Locations cannot be null");
}
if (loc1.getWorld() == null || loc2.getWorld() == null) {
throw new IllegalArgumentException("Location worlds cannot be null");
}
if (!loc1.getWorld().equals(loc2.getWorld())) {
throw new IllegalArgumentException("Locations must be in the same world");
}
this.world = loc1.getWorld();
// Calculate min/max coordinates
this.minX = Math.min(loc1.getBlockX(), loc2.getBlockX());
this.minY = Math.min(loc1.getBlockY(), loc2.getBlockY());
this.minZ = Math.min(loc1.getBlockZ(), loc2.getBlockZ());
this.maxX = Math.max(loc1.getBlockX(), loc2.getBlockX());
this.maxY = Math.max(loc1.getBlockY(), loc2.getBlockY());
this.maxZ = Math.max(loc1.getBlockZ(), loc2.getBlockZ());
}
/**
* Checks if a location is contained within this cuboid.
*
*
* @param location The location to check
* @return true if the location is within this cuboid, false otherwise
*/
@ -62,23 +62,23 @@ public final class Cuboid {
if (location == null || location.getWorld() == null) {
return false;
}
if (!location.getWorld().equals(world)) {
return false;
}
int x = location.getBlockX();
int y = location.getBlockY();
int z = location.getBlockZ();
return x >= minX && x <= maxX
&& y >= minY && y <= maxY
&& z >= minZ && z <= maxZ;
&& y >= minY && y <= maxY
&& z >= minZ && z <= maxZ;
}
/**
* Calculates the volume of this cuboid in blocks.
*
*
* @return The number of blocks contained in this cuboid
*/
public int getVolume() {
@ -87,87 +87,86 @@ public final class Cuboid {
int depth = maxZ - minZ + 1;
return width * height * depth;
}
/**
* Gets the world this cuboid is in.
*
*
* @return The world
*/
public World getWorld() {
return world;
}
/**
* Gets the minimum X coordinate.
*
*
* @return Minimum X
*/
public int getMinX() {
return minX;
}
/**
* Gets the minimum Y coordinate.
*
*
* @return Minimum Y
*/
public int getMinY() {
return minY;
}
/**
* Gets the minimum Z coordinate.
*
*
* @return Minimum Z
*/
public int getMinZ() {
return minZ;
}
/**
* Gets the maximum X coordinate.
*
*
* @return Maximum X
*/
public int getMaxX() {
return maxX;
}
/**
* Gets the maximum Y coordinate.
*
*
* @return Maximum Y
*/
public int getMaxY() {
return maxY;
}
/**
* Gets the maximum Z coordinate.
*
*
* @return Maximum Z
*/
public int getMaxZ() {
return maxZ;
}
@Override
public String toString() {
return String.format("Cuboid[world=%s, min=(%d,%d,%d), max=(%d,%d,%d), volume=%d]",
world.getName(), minX, minY, minZ, maxX, maxY, maxZ, getVolume());
world.getName(), minX, minY, minZ, maxX, maxY, maxZ, getVolume());
}
@Override
public boolean equals(Object obj) {
if (this == obj) return true;
if (!(obj instanceof Cuboid)) return false;
Cuboid other = (Cuboid) obj;
if (!(obj instanceof Cuboid other)) return false;
return world.equals(other.world)
&& minX == other.minX && minY == other.minY && minZ == other.minZ
&& maxX == other.maxX && maxY == other.maxY && maxZ == other.maxZ;
&& minX == other.minX && minY == other.minY && minZ == other.minZ
&& maxX == other.maxX && maxY == other.maxY && maxZ == other.maxZ;
}
@Override
public int hashCode() {
int result = world.hashCode();

52
src/main/java/com/loki/lomines/util/location/LocationParser.java → src/main/java/dev/loki/lomines/util/location/LocationParser.java
View file

@ -1,6 +1,6 @@
package com.loki.lomines.util.location;
package dev.loki.lomines.util.location;
import com.loki.lomines.data.config.ConfigParseException;
import dev.loki.lomines.data.config.parser.ConfigParseException;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
@ -14,14 +14,14 @@ import java.util.regex.Pattern;
* Format: "world;x;y;z;yaw;pitch"
*/
public final class LocationParser {
private static final Pattern LOCATION_PATTERN =
Pattern.compile("([^;]+);(-?\\d+\\.?\\d*);(-?\\d+\\.?\\d*);(-?\\d+\\.?\\d*);(-?\\d+\\.?\\d*);(-?\\d+\\.?\\d*)");
private static final Pattern LOCATION_PATTERN =
Pattern.compile("([^;]+);(-?\\d+\\.?\\d*);(-?\\d+\\.?\\d*);(-?\\d+\\.?\\d*);(-?\\d+\\.?\\d*);(-?\\d+\\.?\\d*)");
private LocationParser() {
throw new UnsupportedOperationException("Utility class");
}
/**
* Parses a location string in the format "world;x;y;z;yaw;pitch".
*
@ -33,15 +33,15 @@ public final class LocationParser {
if (locationString == null || locationString.trim().isEmpty()) {
throw new ConfigParseException("Location string cannot be null or empty");
}
Matcher matcher = LOCATION_PATTERN.matcher(locationString.trim());
if (!matcher.matches()) {
throw new ConfigParseException(
"Invalid location format: '" + locationString + "'. " +
"Expected format: 'world;x;y;z;yaw;pitch'"
"Invalid location format: '" + locationString + "'. " +
"Expected format: 'world;x;y;z;yaw;pitch'"
);
}
try {
String worldName = matcher.group(1);
double x = Double.parseDouble(matcher.group(2));
@ -49,24 +49,24 @@ public final class LocationParser {
double z = Double.parseDouble(matcher.group(4));
float yaw = Float.parseFloat(matcher.group(5));
float pitch = Float.parseFloat(matcher.group(6));
World world = Bukkit.getWorld(worldName);
if (world == null) {
throw new ConfigParseException(
"World '" + worldName + "' does not exist or is not loaded"
"World '" + worldName + "' does not exist or is not loaded"
);
}
return new Location(world, x, y, z, yaw, pitch);
} catch (NumberFormatException e) {
throw new ConfigParseException(
"Invalid number format in location string: '" + locationString + "'",
e
"Invalid number format in location string: '" + locationString + "'",
e
);
}
}
/**
* Formats a Location object to a string in the format "world;x;y;z;yaw;pitch".
*
@ -78,19 +78,19 @@ public final class LocationParser {
if (location == null) {
throw new IllegalArgumentException("Location cannot be null");
}
World world = location.getWorld();
if (world == null) {
throw new IllegalArgumentException("Location world cannot be null");
}
return String.format(Locale.US, "%s;%.2f;%.2f;%.2f;%.2f;%.2f",
world.getName(),
location.getX(),
location.getY(),
location.getZ(),
location.getYaw(),
location.getPitch()
world.getName(),
location.getX(),
location.getY(),
location.getZ(),
location.getYaw(),
location.getPitch()
);
}
}

2
src/main/java/com/loki/lomines/util/package-info.java → src/main/java/dev/loki/lomines/util/package-info.java
View file

@ -11,4 +11,4 @@
* <li>{@code ChunkUtils} - Utilities for chunk operations</li>
* </ul>
*/
package com.loki.lomines.util;
package dev.loki.lomines.util;

7
src/main/java/com/loki/lomines/util/selection/MaskScanner.java → src/main/java/dev/loki/lomines/util/selection/MaskScanner.java
View file

@ -1,5 +1,6 @@
package com.loki.lomines.util.selection;
package dev.loki.lomines.util.selection;
import dev.loki.lomines.util.location.Cuboid;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
@ -12,10 +13,10 @@ import java.util.List;
* Finds all blocks of a given vanilla material inside cuboid regions (marker paint for mask mode).
*/
public final class MaskScanner {
private MaskScanner() {
}
/**
* Collects block centers for every block whose type equals {@code marker} inside {@code regions}.
*/

53
src/main/java/com/loki/lomines/util/selection/Selection.java → src/main/java/dev/loki/lomines/util/selection/Selection.java
View file

@ -1,5 +1,6 @@
package com.loki.lomines.util.selection;
package dev.loki.lomines.util.selection;
import dev.loki.lomines.util.location.Cuboid;
import org.bukkit.Location;
import java.util.ArrayList;
@ -10,27 +11,27 @@ import java.util.Optional;
* Manages selection points for defining mine regions.
* Stores up to 10 points (5 pairs) for multi-regional mines.
* Points are organized in pairs where indices 2i and 2i+1 form a pair for i ∈ [0, 4].
*
*
* <p>This class is NOT thread-safe and should be used per-player.</p>
*/
public final class Selection {
private static final int MAX_POINTS = 10;
private static final int MAX_PAIRS = 5;
private final Location[] points;
/**
* Creates a new empty selection.
*/
public Selection() {
this.points = new Location[MAX_POINTS];
}
/**
* Sets a point at the specified index.
*
* @param index The point index (0-9)
*
* @param index The point index (0-9)
* @param location The location to set
* @throws IllegalArgumentException if index is out of bounds
*/
@ -38,10 +39,10 @@ public final class Selection {
validateIndex(index);
points[index] = location;
}
/**
* Gets a point at the specified index.
*
*
* @param index The point index (0-9)
* @return Optional containing the location if set, empty otherwise
* @throws IllegalArgumentException if index is out of bounds
@ -50,11 +51,11 @@ public final class Selection {
validateIndex(index);
return Optional.ofNullable(points[index]);
}
/**
* Gets a pair of points as an array.
* A pair consists of points at indices 2*pairIndex and 2*pairIndex+1.
*
*
* @param pairIndex The pair index (0-4)
* @return Array of two locations [point1, point2], may contain nulls
* @throws IllegalArgumentException if pairIndex is out of bounds
@ -63,12 +64,12 @@ public final class Selection {
validatePairIndex(pairIndex);
int firstIndex = pairIndex * 2;
int secondIndex = firstIndex + 1;
return new Location[] { points[firstIndex], points[secondIndex] };
return new Location[]{points[firstIndex], points[secondIndex]};
}
/**
* Checks if a pair has both points set.
*
*
* @param pairIndex The pair index (0-4)
* @return true if both points in the pair are set, false otherwise
* @throws IllegalArgumentException if pairIndex is out of bounds
@ -79,7 +80,7 @@ public final class Selection {
int secondIndex = firstIndex + 1;
return points[firstIndex] != null && points[secondIndex] != null;
}
/**
* Clears all selection points.
*/
@ -88,50 +89,50 @@ public final class Selection {
points[i] = null;
}
}
/**
* Converts all complete pairs to Cuboid regions.
* Only pairs with both points set are converted.
*
*
* @return List of Cuboid regions created from complete pairs
*/
public List<Cuboid> toCuboids() {
List<Cuboid> cuboids = new ArrayList<>();
for (int pairIndex = 0; pairIndex < MAX_PAIRS; pairIndex++) {
if (hasPair(pairIndex)) {
Location[] pair = getPair(pairIndex);
cuboids.add(new Cuboid(pair[0], pair[1]));
}
}
return cuboids;
}
/**
* Validates that an index is within valid bounds [0, 9].
*
*
* @param index The index to validate
* @throws IllegalArgumentException if index is out of bounds
*/
private void validateIndex(int index) {
if (index < 0 || index >= MAX_POINTS) {
throw new IllegalArgumentException(
"Point index must be between 0 and " + (MAX_POINTS - 1) + ", got: " + index
"Point index must be between 0 and " + (MAX_POINTS - 1) + ", got: " + index
);
}
}
/**
* Validates that a pair index is within valid bounds [0, 4].
*
*
* @param pairIndex The pair index to validate
* @throws IllegalArgumentException if pairIndex is out of bounds
*/
private void validatePairIndex(int pairIndex) {
if (pairIndex < 0 || pairIndex >= MAX_PAIRS) {
throw new IllegalArgumentException(
"Pair index must be between 0 and " + (MAX_PAIRS - 1) + ", got: " + pairIndex
"Pair index must be between 0 and " + (MAX_PAIRS - 1) + ", got: " + pairIndex
);
}
}

30
src/main/java/com/loki/lomines/util/selection/SelectionManager.java → src/main/java/dev/loki/lomines/util/selection/SelectionManager.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.util.selection;
package dev.loki.lomines.util.selection;
import java.util.Map;
import java.util.Optional;
@ -9,25 +9,25 @@ import java.util.concurrent.ConcurrentHashMap;
* Manages player selections for mine region definition.
* Stores a Selection object for each player, allowing multiple players
* to have independent selections simultaneously.
*
*
* <p>This class is thread-safe and can be accessed from multiple threads.</p>
*
*
* <p><b>Validates:</b> Requirements 12.7, 16.7</p>
*/
public final class SelectionManager {
private final Map<UUID, Selection> selections;
/**
* Creates a new SelectionManager with thread-safe storage.
*/
public SelectionManager() {
this.selections = new ConcurrentHashMap<>();
}
/**
* Gets the selection for a player, creating a new one if it doesn't exist.
*
*
* @param playerId The player's UUID
* @return The player's Selection object
* @throws IllegalArgumentException if playerId is null
@ -36,10 +36,10 @@ public final class SelectionManager {
validatePlayerId(playerId);
return selections.computeIfAbsent(playerId, id -> new Selection());
}
/**
* Gets the selection for a player if it exists.
*
*
* @param playerId The player's UUID
* @return Optional containing the Selection if it exists, empty otherwise
* @throws IllegalArgumentException if playerId is null
@ -48,10 +48,10 @@ public final class SelectionManager {
validatePlayerId(playerId);
return Optional.ofNullable(selections.get(playerId));
}
/**
* Checks if a player has a selection.
*
*
* @param playerId The player's UUID
* @return true if the player has a selection, false otherwise
* @throws IllegalArgumentException if playerId is null
@ -60,10 +60,10 @@ public final class SelectionManager {
validatePlayerId(playerId);
return selections.containsKey(playerId);
}
/**
* Clears the selection for a player, removing it from storage.
*
*
* @param playerId The player's UUID
* @throws IllegalArgumentException if playerId is null
*/
@ -71,10 +71,10 @@ public final class SelectionManager {
validatePlayerId(playerId);
selections.remove(playerId);
}
/**
* Validates that a player ID is not null.
*
*
* @param playerId The player ID to validate
* @throws IllegalArgumentException if playerId is null
*/

30
src/main/java/com/loki/lomines/wand/GroupWandItem.java → src/main/java/dev/loki/lomines/wand/GroupWandItem.java
View file

@ -1,6 +1,6 @@
package com.loki.lomines.wand;
package dev.loki.lomines.wand;
import com.loki.lomines.LoMinesPlugin;
import dev.loki.lomines.LoMinesPlugin;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.format.NamedTextColor;
import org.bukkit.Material;
@ -15,37 +15,39 @@ import java.util.List;
* Blaze rod marked with PDC so only this item drives group wand behaviour.
*/
public final class GroupWandItem {
private static final String KEY = "group_wand";
/** Same namespace as {@code plugin.yml} name, avoids IDE needing full {@link org.bukkit.plugin.Plugin} classpath. */
/**
* Same namespace as {@code plugin.yml} name, avoids IDE needing full {@link org.bukkit.plugin.Plugin} classpath.
*/
private static final String NAMESPACE = "lomines";
private GroupWandItem() {
}
public static NamespacedKey key(LoMinesPlugin plugin) {
return new NamespacedKey(NAMESPACE, KEY);
}
public static ItemStack create(LoMinesPlugin plugin) {
ItemStack item = new ItemStack(Material.BLAZE_ROD);
ItemMeta meta = item.getItemMeta();
if (meta != null) {
meta.displayName(Component.text("LoMines · группа", NamedTextColor.GOLD));
meta.lore(List.of(
Component.text("ЛКМ блок — угол 1 (слот ", NamedTextColor.GRAY)
.append(Component.text("1–9", NamedTextColor.YELLOW))
.append(Component.text(" в меню)", NamedTextColor.GRAY)),
Component.text("ПКМ блок — угол 2", NamedTextColor.GRAY),
Component.text("Shift+ПКМ — меню: 9 шахт, одни настройки", NamedTextColor.GRAY),
Component.text("/lm group <префикс> — имена префикс_1…префикс_9", NamedTextColor.DARK_GRAY)
Component.text("ЛКМ блок — угол 1 (слот ", NamedTextColor.GRAY)
.append(Component.text("1–9", NamedTextColor.YELLOW))
.append(Component.text(" в меню)", NamedTextColor.GRAY)),
Component.text("ПКМ блок — угол 2", NamedTextColor.GRAY),
Component.text("Shift+ПКМ — меню: 9 шахт, одни настройки", NamedTextColor.GRAY),
Component.text("/lm group <префикс> — имена префикс_1…префикс_9", NamedTextColor.DARK_GRAY)
));
meta.getPersistentDataContainer().set(key(plugin), PersistentDataType.BYTE, (byte) 1);
item.setItemMeta(meta);
}
return item;
}
public static boolean isWand(LoMinesPlugin plugin, ItemStack stack) {
if (stack == null || stack.getType() == Material.AIR) {
return false;

8
src/main/java/com/loki/lomines/wand/GroupWandManager.java → src/main/java/dev/loki/lomines/wand/GroupWandManager.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.wand;
package dev.loki.lomines.wand;
import java.util.Map;
import java.util.UUID;
@ -8,13 +8,13 @@ import java.util.concurrent.ConcurrentHashMap;
* Per-player {@link GroupWandSession} for the group wand workflow.
*/
public final class GroupWandManager {
private final Map<UUID, GroupWandSession> sessions = new ConcurrentHashMap<>();
public GroupWandSession getSession(UUID playerId) {
return sessions.computeIfAbsent(playerId, u -> new GroupWandSession());
}
public void removeSession(UUID playerId) {
sessions.remove(playerId);
}

35
src/main/java/com/loki/lomines/wand/GroupWandSession.java → src/main/java/dev/loki/lomines/wand/GroupWandSession.java
View file

@ -1,4 +1,4 @@
package com.loki.lomines.wand;
package dev.loki.lomines.wand;
import org.bukkit.Location;
@ -9,67 +9,66 @@ import java.util.Arrays;
* each slot has its own cuboid (pos1 + pos2).
*/
public final class GroupWandSession {
private static final int SLOTS = 9;
private String baseName = "";
private int activeSlot;
private final Location[] pos1 = new Location[SLOTS];
private final Location[] pos2 = new Location[SLOTS];
private String baseName = "";
private int activeSlot;
public String getBaseName() {
return baseName;
}
public void setBaseName(String baseName) {
this.baseName = baseName != null ? baseName.trim() : "";
}
public boolean hasBaseName() {
return baseName != null && !baseName.isEmpty();
}
public int getActiveSlot() {
return activeSlot;
}
public void setActiveSlot(int activeSlot) {
if (activeSlot < 0 || activeSlot >= SLOTS) {
throw new IllegalArgumentException("activeSlot 0..8");
}
this.activeSlot = activeSlot;
}
public Location getPos1(int index) {
return pos1[index];
}
public Location getPos2(int index) {
return pos2[index];
}
public void setPos1(int index, Location loc) {
pos1[index] = loc;
}
public void setPos2(int index, Location loc) {
pos2[index] = loc;
}
public boolean isSlotReady(int index) {
return pos1[index] != null && pos2[index] != null;
}
public void clearCorners(int index) {
pos1[index] = null;
pos2[index] = null;
}
public void clearAll() {
Arrays.fill(pos1, null);
Arrays.fill(pos2, null);
}
public int countReadySlots() {
int n = 0;
for (int i = 0; i < SLOTS; i++) {

6
src/main/resources/plugin.yml
View file

@ -1,11 +1,11 @@
name: LoMines
version: ${version}
description: ${description}
main: com.loki.lomines.LoMinesPlugin
main: dev.loki.lomines.LoMinesPlugin
author: loki
api-version: "1.21"
website: https://github.com/loki/lomines
softdepend: [PlaceholderAPI, WorldGuard, Oraxen, ItemsAdder]
softdepend: [ PlaceholderAPI, WorldGuard, Oraxen, ItemsAdder ]
# LoAPI will handle dependency loading via DependencyManager
# Dependencies: commons-math3 and commons-io will be loaded at runtime
@ -13,7 +13,7 @@ softdepend: [PlaceholderAPI, WorldGuard, Oraxen, ItemsAdder]
commands:
lm:
description: Main LoMines command
aliases: [lomines, mine, mines]
aliases: [ lomines, mine, mines ]
permission: lomines.use
usage: /<command> <subcommand>