Files
com
META-INF
src
build.gradle
config.yml
plugin.yml
README.txt
settings.gradle
Code
26 3,078
src/main/java/com/mjhomes/MJHomes.java
package com.mjhomes;
import com.cryptomorin.xseries.XSound;
import io.papermc.paper.dialog.Dialog;
import io.papermc.paper.dialog.DialogResponseView;
import io.papermc.paper.registry.data.dialog.ActionButton;
import io.papermc.paper.registry.data.dialog.DialogBase;
import io.papermc.paper.registry.data.dialog.action.DialogAction;
import io.papermc.paper.registry.data.dialog.body.DialogBody;
import io.papermc.paper.registry.data.dialog.input.DialogInput;
import io.papermc.paper.registry.data.dialog.type.DialogType;
import net.kyori.adventure.key.Key;
import net.kyori.adventure.text.Component;
import net.kyori.adventure.text.event.ClickCallback;
import net.kyori.adventure.text.object.ObjectContents;
import net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitTask;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;
import java.util.function.BiConsumer;
public final class MJHomes extends JavaPlugin implements Listener {
private final Map<UUID, Map<Integer, Home>> cache = new HashMap<>();
private final Map<UUID, Long> cooldowns = new HashMap<>();
private final Map<UUID, BukkitTask> pending = new HashMap<>();
private final LegacyComponentSerializer colors = LegacyComponentSerializer.legacyAmpersand();
private record Home(String name, String world, double x, double y, double z, float yaw, float pitch, String icon) {}
@Override
public void onEnable() {
saveDefaultConfig();
getServer().getPluginManager().registerEvents(this, this);
}
@Override
public void onDisable() {
pending.values().forEach(BukkitTask::cancel);
pending.clear();
cache.clear();
}
@EventHandler
public void onQuit(PlayerQuitEvent event) {
UUID id = event.getPlayer().getUniqueId();
BukkitTask task = pending.remove(id);
if (task != null) task.cancel();
cache.remove(id);
}
private File file(UUID id) {
return new File(new File(getDataFolder(), "homes"), id + ".yml");
}
private Map<Integer, Home> homes(Player player) {
return cache.computeIfAbsent(player.getUniqueId(), id -> {
Map<Integer, Home> result = new HashMap<>();
File file = file(id);
if (!file.exists()) return result;
YamlConfiguration yaml = new YamlConfiguration();
try {
yaml.load(file);
} catch (Exception ex) {
getLogger().severe("Cannot load homes for " + id + ": " + ex.getMessage());
throw new IllegalStateException("Cannot load homes", ex);
}
ConfigurationSection section = yaml.getConfigurationSection("homes");
if (section == null) return result;
for (String key : section.getKeys(false)) {
try {
int slot = Integer.parseInt(key);
ConfigurationSection h = section.getConfigurationSection(key);
if (slot < 1 || slot > 30 || h == null || h.getString("name") == null || h.getString("world") == null) continue;
result.put(slot, new Home(h.getString("name"), h.getString("world"), h.getDouble("x"), h.getDouble("y"), h.getDouble("z"), (float) h.getDouble("yaw"), (float) h.getDouble("pitch"), h.getString("icon")));
} catch (NumberFormatException ex) {
getLogger().warning("Invalid home slot " + key + " for " + id);
}
}
return result;
});
}
private boolean save(Player player) {
File file = file(player.getUniqueId());
File directory = file.getParentFile();
if (!directory.isDirectory() && !directory.mkdirs()) {
message(player, "save-failed");
return false;
}
YamlConfiguration yaml = new YamlConfiguration();
homes(player).forEach((slot, h) -> {
String p = "homes." + slot + ".";
yaml.set(p + "name", h.name());
yaml.set(p + "world", h.world());
yaml.set(p + "x", h.x());
yaml.set(p + "y", h.y());
yaml.set(p + "z", h.z());
yaml.set(p + "yaw", h.yaw());
yaml.set(p + "pitch", h.pitch());
yaml.set(p + "icon", h.icon());
});
try {
File temp = new File(directory, file.getName() + ".tmp");
yaml.save(temp);
java.nio.file.Files.move(temp.toPath(), file.toPath(), java.nio.file.StandardCopyOption.REPLACE_EXISTING);
return true;
} catch (IOException ex) {
getLogger().severe("Cannot save homes for " + player.getUniqueId() + ": " + ex.getMessage());
message(player, "save-failed");
return false;
}
}
private boolean put(Player player, int slot, Home home) {
Map<Integer, Home> map = homes(player);
Home previous = home == null ? map.remove(slot) : map.put(slot, home);
if (save(player)) return true;
if (previous == null) map.remove(slot); else map.put(slot, previous);
return false;
}
private int limit(Player player) {
int ceiling = maxSlots();
int limit = Math.max(0, Math.min(ceiling, getConfig().getInt("default-home-limit", 1)));
for (int i = 1; i <= ceiling; i++) if (player.hasPermission("mjhomes.homes." + i)) limit = Math.max(limit, i);
return limit;
}
private int setting(String path, int fallback, int min, int max) {
return Math.max(min, Math.min(max, getConfig().getInt(path, fallback)));
}
private int maxSlots() { return setting("maximum-home-slots", 30, 1, 30); }
private int increment() { return setting("gui.slots-per-expansion", 10, 1, 30); }
private int buttonWidth() { return setting("gui.button-width", 150, 1, 1024); }
private String text(String key, String... replacements) {
String fallback = getConfig().getDefaults() == null ? null : getConfig().getDefaults().getString(key);
String value = getConfig().getString(key, fallback == null ? key : fallback);
for (int i = 0; i + 1 < replacements.length; i += 2) value = value.replace("{" + replacements[i] + "}", replacements[i + 1]);
return value;
}
private Component component(String value) { return colors.deserialize(value); }
private Component gui(String key, String... replacements) { return component(text("gui." + key, replacements)); }
private void message(Player player, String key, String... replacements) { player.sendMessage(component(text("messages." + key, replacements))); }
private boolean valid(String name) {
if (name == null || name.isEmpty() || name.length() > setting("home-name.max-length", 18, 1, 18)) return false;
try {
return name.matches(getConfig().getString("home-name.allowed-pattern", "[A-Za-z0-9_-]+(?: [A-Za-z0-9_-]+)*"));
} catch (java.util.regex.PatternSyntaxException ex) {
getLogger().warning("Invalid home-name.allowed-pattern: " + ex.getMessage());
return false;
}
}
private int find(Player player, String name) {
if (name == null) return -1;
for (Map.Entry<Integer, Home> entry : homes(player).entrySet()) if (entry.getValue().name().equalsIgnoreCase(name)) return entry.getKey();
return -1;
}
private void create(Player player, String name, int requestedSlot) {
if (!valid(name)) { message(player, "invalid-name"); return; }
if (find(player, name) != -1) { message(player, "duplicate"); return; }
Map<Integer, Home> map = homes(player);
int limit = limit(player);
if (map.size() >= limit) { message(player, "limit", "limit", String.valueOf(limit)); return; }
int slot = requestedSlot;
if (slot == 0) {
for (int i = 1; i <= limit; i++) if (!map.containsKey(i)) { slot = i; break; }
}
if (slot < 1 || slot > limit || map.containsKey(slot)) { message(player, "limit", "limit", String.valueOf(limit)); return; }
Location loc = player.getLocation();
Home home = new Home(name, loc.getWorld().getUID().toString(), loc.getX(), loc.getY(), loc.getZ(), loc.getYaw(), loc.getPitch(), null);
if (put(player, slot, home)) message(player, "created", "home", name);


