Initial commit for HungerGames

2026-05-23 23:06:30 +02:00
commit 16f15400fd
19 changed files with 881 additions and 0 deletions
@@ -0,0 +1,45 @@
+package com.alttd.hunger_games;
+
+import com.alttd.hunger_games.commands.BaseCommand;
+import com.alttd.hunger_games.config.Config;
+import com.alttd.hunger_games.config.Messages;
+import lombok.extern.slf4j.Slf4j;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+@Slf4j
+public final class Main extends JavaPlugin {
+
+    private BaseCommand command;
+
+    @Override
+    public void onEnable() {
+        log.info("Starting HungerGames");
+        reloadConfigs();
+        registerCommands();
+        registerEvents();
+        registerSchedulers();
+    }
+
+    @Override
+    public void onDisable() {
+        log.info("Disabling HungerGames");
+    }
+
+    private void registerCommands() {
+        command = new BaseCommand(this);
+    }
+
+    private void registerEvents() {
+        PluginManager pluginManager = getServer().getPluginManager();
+    }
+
+    public void reloadConfigs() {
+        Config.reload();
+        Messages.reload();
+    }
+
+    private void registerSchedulers() {
+
+    }
+}
@@ -0,0 +1,11 @@
+package com.alttd.hunger_games.commands;
+
+import org.bukkit.command.CommandSender;
+
+import java.util.Optional;
+
+public interface ArgumentParser<T> {
+
+    Optional<T> parse(CommandSender commandSender, String argument);
+
+}
@@ -0,0 +1,94 @@
+package com.alttd.hunger_games.commands;
+
+import com.alttd.hunger_games.Main;
+import com.alttd.hunger_games.config.Messages;
+import lombok.Getter;
+import lombok.extern.slf4j.Slf4j;
+import net.kyori.adventure.text.minimessage.tag.resolver.Placeholder;
+import org.bukkit.command.*;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@Slf4j @Getter
+public class BaseCommand implements CommandExecutor, TabExecutor {
+    private final List<SubCommand> subCommands;
+
+    public BaseCommand(Main main) {
+        PluginCommand command = main.getCommand("hungergames");
+        if (command == null) {
+            subCommands = null;
+            log.error("Unable to find hungergames command.");
+            return;
+        }
+        command.setExecutor(this);
+        command.setTabCompleter(this);
+        command.setAliases(List.of("hg"));
+
+        subCommands = new ArrayList<>(List.of());
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull 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 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);
+    }
+
+    public void addSubCommand(SubCommand subCommand) {
+        if (subCommands.stream().anyMatch(entry -> entry.getName().equalsIgnoreCase(subCommand.getName()))) {
+            return;
+        }
+        subCommands.add(subCommand);
+    }
+}
@@ -0,0 +1,22 @@
+package com.alttd.hunger_games.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 "hungergames." + getName();
+    }
+
+    public abstract List<String> getTabComplete(CommandSender commandSender, String[] args);
+
+    public abstract String getHelpMessage();
+}
@@ -0,0 +1,147 @@
+package com.alttd.hunger_games.config;
+
+
+import com.alttd.hunger_games.Main;
+import com.google.common.collect.ImmutableMap;
+import lombok.NonNull;
+import lombok.extern.slf4j.Slf4j;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import javax.annotation.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(Main main, String filename) {
+        init(new File(main.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,34 @@
+package com.alttd.hunger_games.config;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.io.File;
+
+@Slf4j
+public class Config extends AbstractConfig {
+
+    static Config config;
+
+    Config() {
+        super(
+                new File(File.separator
+                         + "mnt" + File.separator
+                         + "configs" + File.separator
+                         + "HungerGames"),
+                "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.";
+
+        @SuppressWarnings("unused")
+        private static void load() {
+        }
+    }
+}
@@ -0,0 +1,49 @@
+package com.alttd.hunger_games.config;
+
+import java.io.File;
+
+public class Messages extends AbstractConfig {
+    static Messages config;
+
+    Messages() {
+        super(
+                new File(File.separator
+                        + "mnt" + File.separator
+                        + "configs" + File.separator
+                        + "HungerGames"),
+                "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>HungerGames help:\n<commands></gold>";
+        public static String HELP_MESSAGE = "<green>Show this menu: <gold>/hg help</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);
+        }
+    }
+
+    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);
+        }
+    }
+}