Initial setup for easter plugin

This commit is contained in:
2026-04-02 22:48:21 +02:00
commit 060e8a4541
18 changed files with 934 additions and 0 deletions
@@ -0,0 +1,42 @@
package com.alttd.easter;
import com.alttd.easter.commands.Command;
import com.alttd.easter.config.Config;
import com.alttd.easter.config.Messages;
import org.bukkit.plugin.PluginManager;
import org.bukkit.plugin.java.JavaPlugin;
public final class Easter extends JavaPlugin {
@Override
public void onEnable() {
registerCommands();
registerEvents();
reloadConfigs();
registerSchedulers();
}
@Override
public void onDisable() {
//TODO save data
}
private void registerCommands() {
new Command(this);
}
private void registerEvents() {
PluginManager pluginManager = getServer().getPluginManager();
//TODO register events
}
public void reloadConfigs() {
Config.reload();
Messages.reload();
}
private void registerSchedulers() {
//TODO register schedulers
}
}
@@ -0,0 +1,94 @@
package com.alttd.easter.commands;
import com.alttd.easter.Easter;
import com.alttd.easter.commands.subcommands.*;
import com.alttd.easter.config.Messages;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.command.PluginCommand;
import org.bukkit.command.TabExecutor;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;
@SuppressWarnings("ClassCanBeRecord")
@Slf4j @Getter
public class Command implements CommandExecutor, TabExecutor {
private final List<SubCommand> subCommands;
public Command(Easter easter) {
PluginCommand command = easter.getCommand("easter");
if (command == null) {
subCommands = null;
log.error("Unable to find easter command.");
return;
}
command.setExecutor(this);
command.setTabCompleter(this);
command.setAliases(List.of("pu"));
subCommands = List.of(
new Reload(easter)
);
}
@Override
public boolean onCommand(@NotNull CommandSender commandSender, @NotNull org.bukkit.command.Command command, @NotNull String cmd, @NotNull String[] args) {
if (args.length == 0) {
commandSender.sendRichMessage(Messages.HELP.HELP_MESSAGE_WRAPPER.replaceAll("<commands>", subCommands.stream()
.filter(subCommand -> commandSender.hasPermission(subCommand.getPermission()))
.map(SubCommand::getHelpMessage)
.collect(Collectors.joining("\n"))));
return true;
}
SubCommand subCommand = getSubCommand(args[0]);
if (subCommand == null)
return false;
if (!commandSender.hasPermission(subCommand.getPermission())) {
commandSender.sendRichMessage(Messages.GENERIC.NO_PERMISSION, Placeholder.parsed("permission", subCommand.getPermission()));
return true;
}
boolean executedCorrectly = subCommand.onCommand(commandSender, args);
if (!executedCorrectly) {
commandSender.sendRichMessage(subCommand.getHelpMessage());
}
return true;
}
@Override
public @Nullable List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull org.bukkit.command.Command command, @NotNull String cmd, @NotNull String[] args) {
List<String> res = new ArrayList<>();
if (args.length <= 1) {
res.addAll(subCommands.stream()
.filter(subCommand -> commandSender.hasPermission(subCommand.getPermission()))
.map(SubCommand::getName)
.filter(name -> args.length == 0 || name.startsWith(args[0]))
.toList()
);
} else {
SubCommand subCommand = getSubCommand(args[0]);
if (subCommand != null && commandSender.hasPermission(subCommand.getPermission()))
res.addAll(subCommand.getTabComplete(commandSender, args).stream()
.filter(str -> str.toLowerCase().startsWith(args[args.length - 1].toLowerCase()))
.toList());
}
return res;
}
private SubCommand getSubCommand(String cmdName) {
return subCommands.stream()
.filter(subCommand -> subCommand.getName().equals(cmdName))
.findFirst()
.orElse(null);
}
}
@@ -0,0 +1,22 @@
package com.alttd.easter.commands;
import org.bukkit.command.CommandSender;
import java.util.List;
public abstract class SubCommand {
public SubCommand() {}
public abstract boolean onCommand(CommandSender commandSender, String[] args);
public abstract String getName();
public String getPermission() {
return "playerutils." + getName();
}
public abstract List<String> getTabComplete(CommandSender commandSender, String[] args);
public abstract String getHelpMessage();
}
@@ -0,0 +1,39 @@
package com.alttd.easter.commands.subcommands;
import com.alttd.easter.Easter;
import com.alttd.easter.commands.SubCommand;
import com.alttd.easter.config.Messages;
import org.bukkit.command.CommandSender;
import java.util.List;
public class Reload extends SubCommand {
private final Easter easter;
public Reload(Easter easter) {
this.easter = easter;
}
@Override
public boolean onCommand(CommandSender commandSender, String[] args) {
easter.reloadConfigs();
commandSender.sendRichMessage(Messages.RELOAD.RELOADED);
return true;
}
@Override
public String getName() {
return "reload";
}
@Override
public List<String> getTabComplete(CommandSender commandSender, String[] args) {
return List.of();
}
@Override
public String getHelpMessage() {
return Messages.HELP.RELOAD;
}
}
@@ -0,0 +1,145 @@
package com.alttd.easter.config;
import com.alttd.easter.Easter;
import com.google.common.collect.ImmutableMap;
import lombok.extern.slf4j.Slf4j;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.InvalidConfigurationException;
import org.bukkit.configuration.file.YamlConfiguration;
import org.checkerframework.checker.nullness.qual.NonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@Slf4j @SuppressWarnings({"unused", "SameParameterValue"})
abstract class AbstractConfig {
File file;
YamlConfiguration yaml;
AbstractConfig(Easter easter, String filename) {
init(new File(easter.getDataFolder(), filename), filename);
}
AbstractConfig(File file, String filename) {
init(new File(file.getPath() + File.separator + filename), filename);
}
private void init(File file, String filename) {
this.file = file;
this.yaml = new YamlConfiguration();
try {
yaml.load(file);
} catch (IOException ignore) {
} catch (InvalidConfigurationException e) {
log.error("Could not load {}, please correct your syntax errors", filename, e);
throw new RuntimeException(e);
}
yaml.options().copyDefaults(true);
}
void readConfig(Class<?> clazz, Object instance) {
for (Class<?> declaredClass : clazz.getDeclaredClasses()) {
for (Method method : declaredClass.getDeclaredMethods()) {
if (Modifier.isPrivate(method.getModifiers())) {
if (method.getParameterTypes().length == 0 && method.getReturnType() == Void.TYPE) {
try {
method.setAccessible(true);
method.invoke(instance);
} catch (InvocationTargetException ex) {
throw new RuntimeException(ex.getCause());
} catch (Exception e) {
log.error("Error invoking {}.", method, e);
}
}
}
}
}
save();
}
private void save() {
try {
yaml.save(file);
} catch (IOException e) {
log.error("Could not save {}.", file.toString(), e);
}
}
void set(String prefix, String path, Object val) {
path = prefix + path;
yaml.addDefault(path, val);
yaml.set(path, val);
save();
}
String getString(String prefix, String path, String def) {
path = prefix + path;
yaml.addDefault(path, def);
return yaml.getString(path, yaml.getString(path));
}
boolean getBoolean(String prefix, String path, boolean def) {
path = prefix + path;
yaml.addDefault(path, def);
return yaml.getBoolean(path, yaml.getBoolean(path));
}
int getInt(String prefix, String path, int def) {
path = prefix + path;
yaml.addDefault(path, def);
return yaml.getInt(path, yaml.getInt(path));
}
double getDouble(String prefix, String path, double def) {
path = prefix + path;
yaml.addDefault(path, def);
return yaml.getDouble(path, yaml.getDouble(path));
}
<T> List<String> getList(String prefix, String path, T def) {
path = prefix + path;
yaml.addDefault(path, def);
List<?> list = yaml.getList(path, yaml.getList(path));
return list == null ? null : list.stream().map(Object::toString).collect(Collectors.toList());
}
List<String> getStringList(String prefix, String path, List<String> def) {
path = prefix + path;
yaml.addDefault(path, def);
return yaml.getStringList(path);
}
@NonNull
<T> Map<String, T> getMap(String prefix, @NonNull String path, final @Nullable Map<String, T> def) {
path = prefix + path;
final ImmutableMap.Builder<String, T> builder = ImmutableMap.builder();
if (def != null && yaml.getConfigurationSection(path) == null) {
yaml.addDefault(path, def.isEmpty() ? new HashMap<>() : def);
return def;
}
final ConfigurationSection section = yaml.getConfigurationSection(path);
if (section != null) {
for (String key : section.getKeys(false)) {
@SuppressWarnings("unchecked")
final T val = (T) section.get(key);
if (val != null) {
builder.put(key, val);
}
}
}
return builder.build();
}
ConfigurationSection getConfigurationSection(String path) {
return yaml.getConfigurationSection(path);
}
}
@@ -0,0 +1,40 @@
package com.alttd.easter.config;
import lombok.extern.slf4j.Slf4j;
import org.bukkit.configuration.ConfigurationSection;
import java.io.File;
import java.util.HashMap;
import java.util.Set;
@Slf4j public class Config extends AbstractConfig{
static Config config;
Config() {
super(
new File(File.separator
+ "mnt" + File.separator
+ "configs" + File.separator
+ "Easter"),
"config.yml");
}
public static void reload() {
log.info("Reloading config");
config = new Config();
config.readConfig(Config.class, null);
}
public static class SETTINGS {
private static final String prefix = "settings.";
public static boolean DEBUG = false;
public static boolean WARNINGS = true;
@SuppressWarnings("unused")
private static void load() {
DEBUG = config.getBoolean(prefix, "debug", DEBUG);
WARNINGS = config.getBoolean(prefix, "warnings", WARNINGS);
}
}
}
@@ -0,0 +1,63 @@
package com.alttd.easter.config;
import java.io.File;
import java.util.List;
public class Messages extends AbstractConfig {
static Messages config;
Messages() {
super(
new File(File.separator
+ "mnt" + File.separator
+ "configs" + File.separator
+ "Easter"),
"messages.yml");
}
public static void reload() {
config = new Messages();
config.readConfig(Messages.class, null);
}
public static class HELP {
private static final String prefix = "help.";
public static String HELP_MESSAGE_WRAPPER = "<gold>Easter help:\n<commands></gold>";
public static String HELP_MESSAGE = "<green>Show this menu: <gold>/pu help</gold></green>";
public static String RELOAD = "<green>Reload the configs for Easter: <gold>/pu reload</gold></green>";
@SuppressWarnings("unused")
private static void load() {
HELP_MESSAGE_WRAPPER = config.getString(prefix, "help-wrapper", HELP_MESSAGE_WRAPPER);
HELP_MESSAGE = config.getString(prefix, "help", HELP_MESSAGE);
RELOAD = config.getString(prefix, "reload", RELOAD);
}
}
public static class GENERIC {
private static final String prefix = "generic.";
public static String NO_PERMISSION = "<red><hover:show_text:'<red><permission></red>'>You don't have permission for this command</hover></red>";
public static String PLAYER_ONLY = "<red>This command can only be executed as a player</red>";
public static String PLAYER_NOT_FOUND = "<red>Unable to find online player <player></red>";
@SuppressWarnings("unused")
private static void load() {
NO_PERMISSION = config.getString(prefix, "no-permission", NO_PERMISSION);
PLAYER_ONLY = config.getString(prefix, "player-only", PLAYER_ONLY);
PLAYER_NOT_FOUND = config.getString(prefix, "player-only", PLAYER_NOT_FOUND);
}
}
public static class RELOAD {
private static final String prefix = "easter.reload.";
public static String RELOADED = "<green>Reloaded configs</green>";
@SuppressWarnings("unused")
private static void load() {
RELOADED = config.getString(prefix, "reloaded", RELOADED);
}
}
}