Initial RS-Auger project conversion from SQLite template

src/main/java/com/rsscripting/rsauger/RSAuger.java

@@ -0,0 +1,186 @@
+package com.rsscripting.rsauger;
+
+import com.rsscripting.rsauger.commands.RSPluginCommand;
+import com.rsscripting.rsauger.commands.RSTabCompleter;
+import com.rsscripting.rsauger.config.ConfigManager;
+import com.rsscripting.rsauger.database.DatabaseManager;
+import com.rsscripting.rsauger.listeners.*;
+import com.rsscripting.rsauger.utils.GitHubUpdateChecker;
+import com.rsscripting.rsauger.utils.RSConstants;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.plugin.java.JavaPlugin;
+
+public class RSAuger
+        extends JavaPlugin {
+
+    private static RSAuger instance;
+
+    @Override
+    public void onEnable() {
+
+        saveDefaultConfig();
+
+
+        instance = this;
+
+        /*
+        |--------------------------------------------------------------------------
+        | CONFIG
+        |--------------------------------------------------------------------------
+        */
+
+        ConfigManager.setup();
+
+         /*
+        |--------------------------------------------------------------------------
+        | Database
+        |--------------------------------------------------------------------------
+        */
+
+        DatabaseManager.initialize(
+                this
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | LISTENERS
+        |--------------------------------------------------------------------------
+        */
+
+        /*  Convert */
+        RSConvertListener
+                conversionListener =
+                new RSConvertListener();
+
+        getServer().getPluginManager().registerEvents(
+
+                conversionListener,
+
+                this
+
+        );
+
+        /*  Main Menu */
+        getServer().getPluginManager().registerEvents(
+
+                new RSMenuListener(
+                        conversionListener
+                ),
+
+                this
+
+        );
+
+        /*  Radius */
+        RSRadiusListener radiusListener =
+                new RSRadiusListener(
+                        conversionListener
+                );
+
+        getServer()
+                .getPluginManager()
+                .registerEvents(
+                        radiusListener,
+                        this
+                );
+
+        /*  Admin */
+        RSAdminListener adminListener =
+                new RSAdminListener(
+                        conversionListener
+                );
+
+        getServer()
+                .getPluginManager()
+                .registerEvents(
+                        adminListener,
+                        this
+                );
+
+        /*  Filter */
+        RSFilterListener filterListener =
+                new RSFilterListener(
+                        conversionListener
+                );
+
+        getServer()
+                .getPluginManager()
+                .registerEvents(
+                        filterListener,
+                        this
+                );
+
+        getServer()
+                .getPluginManager()
+                .registerEvents(
+                        new RSBlockBreakListener(),
+                        this
+                );
+
+        /*
+        |--------------------------------------------------------------------------
+        | COMMANDS
+        |--------------------------------------------------------------------------
+        */
+
+        PluginCommand command =
+                getCommand(
+                        RSConstants.COMMAND_ALIAS
+                );
+
+        if (command != null) {
+
+            command.setExecutor(
+                    new RSPluginCommand()
+            );
+
+            command.setTabCompleter(
+                    new RSTabCompleter()
+            );
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | UPDATE CHECKER
+        |--------------------------------------------------------------------------
+        */
+
+        GitHubUpdateChecker.checkForUpdates();
+
+        /*
+        |--------------------------------------------------------------------------
+        | ENABLE MESSAGE
+        |--------------------------------------------------------------------------
+        */
+
+        getLogger().info(
+                RSConstants.PLUGIN_NAME
+                        + " Enabled"
+        );
+
+    }
+
+    @Override
+    public void onDisable() {
+
+        getLogger().info(
+                RSConstants.PLUGIN_NAME
+                        + " Disabled"
+        );
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | GET INSTANCE
+    |--------------------------------------------------------------------------
+    */
+
+    public static RSAuger getInstance() {
+
+        return instance;
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/commands/RSPluginCommand.java

@@ -0,0 +1,102 @@
+package com.rsscripting.rsauger.commands;
+
+import com.rsscripting.rsauger.config.ConfigManager;
+import com.rsscripting.rsauger.utils.RSConstants;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+public class RSPluginCommand
+        implements CommandExecutor {
+
+
+
+    @Override
+    public boolean onCommand(
+
+            @NotNull CommandSender sender,
+            @NotNull Command command,
+            @NotNull String label,
+            @NotNull String @NotNull [] args
+
+    ) {
+
+        /*
+        |--------------------------------------------------------------------------
+        | BASE COMMAND
+        |--------------------------------------------------------------------------
+        */
+
+        if (args.length == 0) {
+
+            sender.sendMessage(
+                    RSConstants.PREFIX
+                            + "Running "
+                            + RSConstants.PLUGIN_NAME
+            );
+
+            return true;
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | RELOAD COMMAND
+        |--------------------------------------------------------------------------
+        */
+
+        if (args[0].equalsIgnoreCase(
+                "reload"
+        )) {
+
+            if (!sender.hasPermission(
+                    RSConstants.ADMIN_PERMISSION
+            )) {
+
+                sender.sendMessage(
+                        RSConstants.PREFIX
+                                + "No permission."
+                );
+
+                return true;
+
+            }
+
+            ConfigManager.reload();
+
+            sender.sendMessage(
+                    RSConstants.PREFIX
+                            + "Configuration reloaded."
+            );
+
+            return true;
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | VERSION COMMAND
+        |--------------------------------------------------------------------------
+        */
+
+        if (args[0].equalsIgnoreCase(
+                "version"
+        )) {
+
+            sender.sendMessage(
+                    RSConstants.PREFIX
+                            + RSConstants.PLUGIN_NAME
+                            + " v"
+                            + RSConstants.VERSION
+            );
+
+            return true;
+
+        }
+
+        return true;
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/commands/RSTabCompleter.java

@@ -0,0 +1,46 @@
+package com.rsscripting.rsauger.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RSTabCompleter
+        implements TabCompleter {
+
+    @Override
+    public List<String> onTabComplete(
+
+            @NotNull CommandSender sender,
+            @NotNull Command command,
+            @NotNull String label,
+            @NotNull String @NotNull [] args
+
+
+    ) {
+
+        List<String> completions =
+                new ArrayList<>();
+
+        /*
+        |--------------------------------------------------------------------------
+        | FIRST ARGUMENT
+        |--------------------------------------------------------------------------
+        */
+
+        if (args.length == 1) {
+
+            completions.add("reload");
+
+            completions.add("version");
+
+        }
+
+        return completions;
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/config/ConfigManager.java

@@ -0,0 +1,56 @@
+package com.rsscripting.rsauger.config;
+
+import com.rsscripting.rsauger.RSAuger;
+import org.bukkit.configuration.file.FileConfiguration;
+
+public class ConfigManager {
+
+    private static FileConfiguration config;
+
+    /*
+    |--------------------------------------------------------------------------
+    | SETUP
+    |--------------------------------------------------------------------------
+    */
+
+    public static void setup() {
+
+        RSAuger.getInstance()
+                .saveDefaultConfig();
+
+        config =
+                RSAuger.getInstance()
+                        .getConfig();
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | RELOAD
+    |--------------------------------------------------------------------------
+    */
+
+    public static void reload() {
+
+        RSAuger.getInstance()
+                .reloadConfig();
+
+        config =
+                RSAuger.getInstance()
+                        .getConfig();
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | GET CONFIG
+    |--------------------------------------------------------------------------
+    */
+
+    public static FileConfiguration get() {
+
+        return config;
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/database/DatabaseManager.java

@@ -0,0 +1,241 @@
+package com.rsscripting.rsauger.database;
+
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.File;
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.util.logging.Level;
+
+public class DatabaseManager {
+
+    private static JavaPlugin plugin;
+
+    private static String databaseUrl;
+
+    public static void initialize(
+            JavaPlugin pluginInstance
+    ) {
+
+        plugin = pluginInstance;
+
+        createDatabase();
+
+        createTables();
+
+        updateDatabase();
+
+    }
+
+    private static void createDatabase() {
+
+        try {
+
+            File databaseFile =
+                    new File(
+                            plugin.getDataFolder(),
+                            "database.db"
+                    );
+
+            if (!plugin.getDataFolder().exists()) {
+
+                if (!plugin.getDataFolder().mkdirs()) {
+
+                    plugin.getLogger().severe(
+                            "Failed to create plugin data folder."
+                    );
+
+                    return;
+
+                }
+
+            }
+
+            databaseUrl =
+                    "jdbc:sqlite:"
+                            + databaseFile.getAbsolutePath();
+
+            Connection connection =
+                    DriverManager.getConnection(
+                            databaseUrl
+                    );
+
+            connection.close();
+
+            plugin.getLogger().info(
+                    "SQLite database initialized."
+            );
+
+        }
+
+        catch (Exception e) {
+
+            plugin.getLogger().log(
+                    Level.SEVERE,
+                    "Failed to initialize database.",
+                    e
+            );
+
+        }
+
+    }
+
+    private static void createTables() {
+
+        try (
+
+                Connection connection =
+                        DriverManager.getConnection(
+                                databaseUrl
+                        )
+
+        ) {
+
+            connection.createStatement().execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS machines (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        world TEXT NOT NULL,
+                        x INTEGER NOT NULL,
+                        y INTEGER NOT NULL,
+                        z INTEGER NOT NULL,
+                        owner_uuid TEXT,
+                        owner_name TEXT,
+                        machine_type TEXT,
+                        radius INTEGER DEFAULT 5,
+                        paused INTEGER DEFAULT 0,
+                        state TEXT DEFAULT 'ACTIVE',
+                        filter_mode TEXT DEFAULT 'ALLOW_ALL',
+                        created_at TEXT                                              
+                    )
+                    """
+            );
+
+            connection.createStatement().execute(
+                    """
+                    CREATE TABLE IF NOT EXISTS machine_filters (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        machine_id INTEGER NOT NULL,
+                        page INTEGER NOT NULL,
+                        slot INTEGER NOT NULL,
+                        item_data TEXT NOT NULL
+                    )
+                    """
+            );
+
+            plugin.getLogger().info(
+                    "Database tables initialized."
+            );
+
+        }
+
+        catch (Exception e) {
+
+            plugin.getLogger().log(
+                    Level.SEVERE,
+                    "Failed to create tables.",
+                    e
+            );
+
+        }
+
+    }
+
+    private static void updateDatabase() {
+
+        try (
+
+                Connection connection =
+                        DriverManager.getConnection(
+                                databaseUrl
+                        )
+
+        ) {
+
+            ensureColumnExists(
+                    connection,
+                    "machines",
+                    "state",
+                    "TEXT DEFAULT 'ACTIVE'"
+            );
+
+            ensureColumnExists(
+                    connection,
+                    "machines",
+                    "error_reason",
+                    "TEXT"
+            );
+
+        }
+
+        catch (Exception e) {
+
+            plugin.getLogger().log(
+                    Level.SEVERE,
+                    "Failed to update database.",
+                    e
+            );
+
+        }
+
+    }
+
+    private static void ensureColumnExists(
+            Connection connection,
+            String table,
+            String column,
+            String definition
+    ) {
+
+        try (
+
+                var columns =
+                        connection
+                                .getMetaData()
+                                .getColumns(
+                                        null,
+                                        null,
+                                        table,
+                                        column
+                                )
+
+        ) {
+
+            if (!columns.next()) {
+
+                connection.createStatement().execute(
+                        "ALTER TABLE "
+                                + table
+                                + " ADD COLUMN "
+                                + column
+                                + " "
+                                + definition
+                );
+
+            }
+
+        }
+
+        catch (Exception e) {
+
+            plugin.getLogger().log(
+                    Level.SEVERE,
+                    "Failed updating column "
+                            + column,
+                    e
+            );
+
+        }
+
+    }
+
+    public static Connection getConnection()
+            throws Exception {
+
+        return DriverManager.getConnection(
+                databaseUrl
+        );
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/gui/RSAdminMenu.java

@@ -0,0 +1,131 @@
+package com.rsscripting.rsauger.gui;
+
+
+import com.rsscripting.rsauger.utils.RSMenuUtils;
+import com.rsscripting.rsauger.utils.VersionUtils;
+import com.rsscripting.rsauger.utils.GitHubUpdateChecker;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import net.kyori.adventure.text.Component;
+
+import java.util.List;
+
+public class RSAdminMenu {
+
+    public static final String MENU_TITLE = "Admin";
+
+    public static void open(
+            Player player
+    ) {
+
+        Inventory menu =
+                Bukkit.createInventory(
+                        new RSMenuHolder(
+                                "ADMIN"
+                        ),
+                        18,
+                        Component.text(
+                                MENU_TITLE
+                        ).color(
+                                NamedTextColor.GOLD
+                        )
+                );
+
+
+        /*
+        |--------------------------------------------------------------------------
+        | FILLER
+        |--------------------------------------------------------------------------
+        */
+
+        ItemStack filler =
+                RSMenuUtils.createFillerPane();
+
+        for (int i = 0; i < menu.getSize(); i++) {
+
+            menu.setItem(i, filler);
+
+        }
+
+        /*
+|--------------------------------------------------------------------------
+| BACK
+|--------------------------------------------------------------------------
+*/
+
+        menu.setItem(
+                4,
+                RSMenuUtils.createMenuItem(
+
+                        Material.OAK_DOOR,
+
+                        "§eBack"
+
+                )
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | RELOAD
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                12,
+                RSMenuUtils.createMenuItem(
+
+                        Material.ENCHANTED_BOOK,
+
+                        "§cReload Plugin"
+
+                )
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | VERSION
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                14,
+                RSMenuUtils.createMenuItem(
+
+                        Material.BOOK,
+
+                        "§ePlugin Version",
+
+                        List.of(
+
+                                "§7Installed: §f"
+                                        + VersionUtils.getVersion(),
+
+                                "",
+
+                                "§7Status: §f"
+                                        + GitHubUpdateChecker.getUpdateStatus(),
+
+                                "",
+
+                                "§7Latest: §f"
+                                        + (
+                                        GitHubUpdateChecker.getLatestVersion()
+                                                == null
+                                                ? "Unknown"
+                                                : GitHubUpdateChecker.getLatestVersion()
+                                )
+
+                        )
+
+                )
+        );
+
+        player.openInventory(menu);
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/gui/RSConversionMenu.java

@@ -0,0 +1,66 @@
+package com.rsscripting.rsauger.gui;
+
+import com.rsscripting.rsauger.utils.RSMenuUtils;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+public class RSConversionMenu {
+
+    public static final String MENU_TITLE = "Activate Item Magnet";
+
+    public static void open(
+            Player player
+    ) {
+
+        Inventory menu =
+                Bukkit.createInventory(
+                        new RSMenuHolder(
+                                "CONVERT"
+                        ),
+                        9,
+                        Component.text(
+                                MENU_TITLE
+                        ).color(
+                                NamedTextColor.BLUE
+                        )
+                );
+
+        /*
+        |--------------------------------------------------------------------------
+        | FILLER
+        |--------------------------------------------------------------------------
+        */
+
+        ItemStack filler =
+                RSMenuUtils.createFillerPane();
+
+        for (int i = 0; i < menu.getSize(); i++) {
+
+            menu.setItem(i, filler);
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | CONVERT BUTTON
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                4,
+                RSMenuUtils.createMenuItem(
+                        Material.CRAFTING_TABLE,
+                        "§aConvert"
+                )
+        );
+
+        player.openInventory(menu);
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/gui/RSFilterMenu.java

@@ -0,0 +1,227 @@
+package com.rsscripting.rsauger.gui;
+
+import com.rsscripting.rsauger.managers.MachineManager;
+import com.rsscripting.rsauger.utils.RSKeys;
+import com.rsscripting.rsauger.utils.RSMenuUtils;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Map;
+
+public class RSFilterMenu {
+
+    public static final String MENU_TITLE =
+            "Filter";
+
+    public static void open(
+            Player player,
+            Block block
+    ) {
+
+        open(
+                player,
+                block,
+                1
+        );
+
+    }
+
+    public static void open(
+            Player player,
+            Block block,
+            int page
+    ) {
+
+        RSMenuHolder holder =
+                new RSMenuHolder(
+                        "FILTER"
+                );
+
+        holder.setPage(
+                page
+        );
+
+        Inventory menu =
+                Bukkit.createInventory(
+                        holder,
+                        54,
+                        Component.text(
+                                MENU_TITLE
+                                        + " ["
+                                        + holder.getPage()
+                                        + "]"
+                        ).color(
+                                NamedTextColor.BLUE
+                        )
+                );
+
+        /*
+        |--------------------------------------------------------------------------
+        | TOP ROW FILLER
+        |--------------------------------------------------------------------------
+        */
+
+        ItemStack filler =
+                RSMenuUtils.createFillerPane();
+
+        for (int i = 0; i < 9; i++) {
+
+            menu.setItem(
+                    i,
+                    filler
+            );
+
+        }
+
+/*
+|--------------------------------------------------------------------------
+| FILTER MODE
+|--------------------------------------------------------------------------
+*/
+
+        String filterMode =
+                MachineManager.getFilterMode(
+                        block
+                );
+
+        Material filterMaterial;
+
+        String filterName;
+
+        if (filterMode.equals(
+                RSKeys.FILTER_WHITELIST
+        )) {
+
+            filterMaterial =
+                    Material.WHITE_WOOL;
+
+            filterName =
+                    "§aWhitelist";
+
+        }
+
+        else if (filterMode.equals(
+                RSKeys.FILTER_BLACKLIST
+        )) {
+
+            filterMaterial =
+                    Material.BLACK_WOOL;
+
+            filterName =
+                    "§cBlacklist";
+
+        }
+
+        else {
+
+            filterMaterial =
+                    Material.LIME_WOOL;
+
+            filterName =
+                    "§aAllow All";
+
+        }
+
+        menu.setItem(
+                3,
+                RSMenuUtils.createMenuItem(
+                        filterMaterial,
+                        filterName
+                )
+        );
+
+                /*
+        |--------------------------------------------------------------------------
+        | PREVIOUS PAGE
+        |--------------------------------------------------------------------------
+        */
+
+        if (holder.getPage() > 1) {
+
+            menu.setItem(
+                    0,
+                    RSMenuUtils.createMenuItem(
+                            Material.ARROW,
+                            "§ePrevious Page (" + holder.getPage() + ")"
+                    )
+            );
+
+        }
+
+                /*
+        |--------------------------------------------------------------------------
+        | FILTER ITEMS
+        |--------------------------------------------------------------------------
+        */
+
+        Map<Integer, ItemStack> filterItems =
+                MachineManager.getFilterItems(
+                        block,
+                        holder.getPage()
+                );
+
+        for (Integer slot : filterItems.keySet()) {
+
+            menu.setItem(
+                    slot,
+                    filterItems.get(
+                            slot
+                    )
+            );
+
+        }
+
+                /*
+        |--------------------------------------------------------------------------
+        | NEXT PAGE
+        |--------------------------------------------------------------------------
+        */
+
+        int highestPage =
+                MachineManager.getHighestFilterPage(
+                        block
+                );
+
+        if (holder.getPage()
+                <= highestPage) {
+
+            menu.setItem(
+                    8,
+                    RSMenuUtils.createMenuItem(
+                            Material.ARROW,
+                            "§eNext Page (" + holder.getPage() + ")"
+                    )
+            );
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | BACK
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                5,
+                RSMenuUtils.createMenuItem(
+
+                        Material.OAK_DOOR,
+
+                        "§eBack"
+
+                )
+        );
+
+        player.openInventory(
+                menu
+        );
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/gui/RSMainMenu.java

@@ -0,0 +1,162 @@
+package com.rsscripting.rsauger.gui;
+
+import com.rsscripting.rsauger.utils.RSConstants;
+import com.rsscripting.rsauger.utils.RSMenuUtils;
+import com.rsscripting.rsauger.managers.MachineManager;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.List;
+
+public class RSMainMenu {
+
+    public static final String MENU_TITLE = "Main";
+
+    public static void open(
+            Player player,
+            Block block
+    ) {
+
+        Inventory menu =
+                Bukkit.createInventory(
+                        new RSMenuHolder(
+                                "MAIN"
+                        ),
+                        18,
+                        Component.text(
+                                MENU_TITLE
+                        ).color(
+                                NamedTextColor.BLUE
+                        )
+                );
+
+        /*
+        |--------------------------------------------------------------------------
+        | FILLER
+        |--------------------------------------------------------------------------
+        */
+
+        ItemStack filler =
+                RSMenuUtils.createFillerPane();
+
+        for (int i = 0; i < menu.getSize(); i++) {
+
+            menu.setItem(i, filler);
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | CONVERT BACK
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                2,
+                RSMenuUtils.createMenuItem(
+                        Material.COMPOSTER,
+                        "§6Convert Back"
+                )
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | PAUSE / RESUME
+        |--------------------------------------------------------------------------
+        */
+
+        boolean paused =
+                MachineManager.isPaused(
+                        block
+                );
+
+        menu.setItem(
+                6,
+                RSMenuUtils.createMenuItem(
+
+                        paused
+                                ? Material.RED_DYE
+                                : Material.GREEN_DYE,
+
+                        paused
+                                ? "§cPaused"
+                                : "§aRunning"
+
+                )
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | RADIUS
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                11,
+                RSMenuUtils.createMenuItem(
+
+                        Material.COMPASS,
+
+                        "§bRadius",
+
+                        List.of(
+                                "§7Current Radius: §f"
+                                        + MachineManager.getRadius(block)
+                        )
+
+                )
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | FILTER
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                15,
+                RSMenuUtils.createMenuItem(
+
+                        Material.HOPPER,
+
+                        "§eFilter",
+
+                        List.of(
+                                "§7Mode: §f"
+                                        + MachineManager.getFilterMode(block)
+                        )
+
+                )
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | ADMIN
+        |--------------------------------------------------------------------------
+        */
+
+        if (player.hasPermission(
+                RSConstants.ADMIN_PERMISSION
+        )) {
+
+            menu.setItem(
+                    4,
+                    RSMenuUtils.createMenuItem(
+                            Material.COMMAND_BLOCK,
+                            "§cAdmin"
+                    )
+            );
+
+        }
+
+        player.openInventory(menu);
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/gui/RSMenuHolder.java

@@ -0,0 +1,57 @@
+package com.rsscripting.rsauger.gui;
+
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.jetbrains.annotations.NotNull;
+
+public class RSMenuHolder
+        implements InventoryHolder {
+
+    private final String menuId;
+
+    private int page = 1;
+
+    public RSMenuHolder(
+            String menuId
+    ) {
+
+        this.menuId = menuId;
+
+    }
+
+    public String getMenuId() {
+
+        return menuId;
+
+    }
+
+    public int getPage() {
+
+        return page;
+
+    }
+
+    public void setPage(
+            int page
+    ) {
+
+        if (page < 1) {
+
+            page = 1;
+
+        }
+
+        this.page = page;
+
+    }
+
+    @Override
+    public @NotNull Inventory getInventory() {
+
+        throw new UnsupportedOperationException(
+                "RSMenuHolder does not store an inventory."
+        );
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/gui/RSRadiusMenu.java

@@ -0,0 +1,158 @@
+package com.rsscripting.rsauger.gui;
+
+import com.rsscripting.rsauger.managers.MachineManager;
+import com.rsscripting.rsauger.utils.RSMenuUtils;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.List;
+
+public class RSRadiusMenu {
+
+
+    public static void open(
+            Player player,
+            Block block
+    ) {
+
+        Inventory menu =
+                Bukkit.createInventory(
+                        new RSMenuHolder(
+                                "RADIUS"
+                        ),
+                        18,
+                        Component.text(
+                                "Radius: "
+                                        + MachineManager.getRadius(
+                                        block
+                                )
+                        ).color(NamedTextColor.BLUE)
+                );
+
+        /*
+        |--------------------------------------------------------------------------
+        | FILLER
+        |--------------------------------------------------------------------------
+        */
+
+        ItemStack filler =
+                RSMenuUtils.createFillerPane();
+
+        for (int i = 0; i < menu.getSize(); i++) {
+
+            menu.setItem(i, filler);
+
+        }
+
+        /*
+|--------------------------------------------------------------------------
+| BACK
+|--------------------------------------------------------------------------
+*/
+
+        menu.setItem(
+                4,
+                RSMenuUtils.createMenuItem(
+
+                        Material.OAK_DOOR,
+
+                        "§eBack"
+
+                )
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | CURRENT RADIUS
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                13,
+                RSMenuUtils.createMenuItem(
+
+                        Material.COMPASS,
+
+                        "§bCurrent Radius",
+
+                        List.of(
+                                "§7Radius: §f"
+                                        + MachineManager.getRadius(
+                                        block
+                                )
+                        )
+
+                )
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | NEGATIVE BUTTONS
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                10,
+                RSMenuUtils.createMenuItem(
+                        Material.RED_WOOL,
+                        "§c-10"
+                )
+        );
+
+        menu.setItem(
+                11,
+                RSMenuUtils.createMenuItem(
+                        Material.RED_WOOL,
+                        "§c-5"
+                )
+        );
+
+        menu.setItem(
+                12,
+                RSMenuUtils.createMenuItem(
+                        Material.RED_WOOL,
+                        "§c-1"
+                )
+        );
+
+        /*
+        |--------------------------------------------------------------------------
+        | POSITIVE BUTTONS
+        |--------------------------------------------------------------------------
+        */
+
+        menu.setItem(
+                14,
+                RSMenuUtils.createMenuItem(
+                        Material.GREEN_WOOL,
+                        "§a+1"
+                )
+        );
+
+        menu.setItem(
+                15,
+                RSMenuUtils.createMenuItem(
+                        Material.GREEN_WOOL,
+                        "§a+5"
+                )
+        );
+
+        menu.setItem(
+                16,
+                RSMenuUtils.createMenuItem(
+                        Material.GREEN_WOOL,
+                        "§a+10"
+                )
+        );
+
+        player.openInventory(menu);
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/gui/session/GuiSession.java

@@ -0,0 +1,29 @@
+package com.rsscripting.rsauger.gui.session;
+
+import org.bukkit.block.Block;
+
+import java.util.UUID;
+
+public class GuiSession {
+
+    private final UUID playerUuid;
+
+    private Block selectedBlock;
+
+    public GuiSession(UUID playerUuid) {
+        this.playerUuid = playerUuid;
+    }
+
+    public UUID getPlayerUuid() {
+        return playerUuid;
+    }
+
+    public Block getSelectedBlock() {
+        return selectedBlock;
+    }
+
+    public void setSelectedBlock(Block selectedBlock) {
+        this.selectedBlock = selectedBlock;
+    }
+
+}

src/main/java/com/rsscripting/rsauger/gui/session/GuiSessionManager.java

@@ -0,0 +1,35 @@
+package com.rsscripting.rsauger.gui.session;
+
+import org.bukkit.entity.Player;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class GuiSessionManager {
+
+    private static final Map<UUID, GuiSession> sessions =
+            new HashMap<>();
+
+    public static GuiSession getSession(
+            Player player
+    ) {
+
+        return sessions.computeIfAbsent(
+                player.getUniqueId(),
+                GuiSession::new
+        );
+
+    }
+
+    public static void removeSession(
+            Player player
+    ) {
+
+        sessions.remove(
+                player.getUniqueId()
+        );
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/listeners/RSAdminListener.java

@@ -0,0 +1,126 @@
+package com.rsscripting.rsauger.listeners;
+
+import com.rsscripting.rsauger.config.ConfigManager;
+import com.rsscripting.rsauger.gui.RSAdminMenu;
+import com.rsscripting.rsauger.gui.RSMenuHolder;
+import com.rsscripting.rsauger.utils.RSConstants;
+import com.rsscripting.rsauger.gui.RSMainMenu;
+import org.bukkit.block.Block;
+import com.rsscripting.rsauger.utils.RSMessageUtils;
+import org.bukkit.entity.Player;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+
+public class RSAdminListener
+        implements Listener {
+
+    private final RSConvertListener
+            conversionListener;
+
+    public RSAdminListener(
+            RSConvertListener conversionListener
+    ) {
+
+        this.conversionListener =
+                conversionListener;
+
+    }
+
+    @EventHandler
+    public void onInventoryClick(
+            InventoryClickEvent event
+    ) {
+
+        if (!(event.getWhoClicked()
+                instanceof Player player)) {
+            return;
+        }
+
+        if (!(event.getInventory()
+                .getHolder()
+                instanceof RSMenuHolder holder)) {
+            return;
+        }
+
+        if (!holder.getMenuId()
+                .equals(
+                        "ADMIN"
+                )) {
+            return;
+        }
+
+        event.setCancelled(true);
+
+        /*
+        |--------------------------------------------------------------------------
+        | SECURITY
+        |--------------------------------------------------------------------------
+        */
+
+        if (!player.isOp()
+                ||
+
+                !player.hasPermission(
+                        RSConstants.ADMIN_PERMISSION
+                )) {
+
+            player.closeInventory();
+
+            return;
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | BACK
+        |--------------------------------------------------------------------------
+        */
+
+        if (event.getRawSlot() == 4) {
+
+            Block block =
+                    conversionListener.getSelectedBlock(player);
+
+            if (block == null) {
+
+                player.closeInventory();
+
+                return;
+
+            }
+
+            RSMainMenu.open(
+                    player,
+                    block
+            );
+
+            return;
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | RELOAD
+        |--------------------------------------------------------------------------
+        */
+
+        if (event.getRawSlot() == 12) {
+
+            ConfigManager.reload();
+
+            RSMessageUtils.success(
+                    player,
+                    "Configuration reloaded."
+            );
+
+            RSAdminMenu.open(
+                    player
+            );
+
+        }
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/listeners/RSBlockBreakListener.java

@@ -0,0 +1,28 @@
+package com.rsscripting.rsauger.listeners;
+
+import com.rsscripting.rsauger.managers.MachineManager;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockBreakEvent;
+
+public class RSBlockBreakListener
+        implements Listener {
+
+    @EventHandler
+    public void onBlockBreak(
+            BlockBreakEvent event
+    ) {
+
+        if (MachineManager.machineExists(
+                event.getBlock()
+        )) {
+
+            event.setCancelled(
+                    true
+            );
+
+        }
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/listeners/RSConvertListener.java

@@ -0,0 +1,216 @@
+package com.rsscripting.rsauger.listeners;
+
+import com.rsscripting.rsauger.gui.RSConversionMenu;
+import com.rsscripting.rsauger.gui.RSMainMenu;
+import com.rsscripting.rsauger.managers.MachineManager;
+import com.rsscripting.rsauger.utils.RSConstants;
+import com.rsscripting.rsauger.gui.session.GuiSession;
+import com.rsscripting.rsauger.gui.session.GuiSessionManager;
+
+import com.rsscripting.rsauger.utils.RSMessageUtils;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.ItemStack;
+
+public class RSConvertListener
+        implements Listener {
+
+    @EventHandler
+    public void onPlayerInteractBlock(
+            PlayerInteractEvent event
+    ) {
+
+        Player player =
+                event.getPlayer();
+
+        Block block =
+                event.getClickedBlock();
+
+        if (block == null) {
+            return;
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | REQUIRE SNEAKING
+        |--------------------------------------------------------------------------
+        */
+
+        if (!player.isSneaking()) {
+            return;
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | VALIDATE TARGET ENTITY
+        |--------------------------------------------------------------------------
+        */
+
+        if (block.getType() !=
+                RSConstants.REQUIRED_TARGET_BLOCK) {
+            return;
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | VALIDATE HELD ITEM
+        |--------------------------------------------------------------------------
+        */
+
+        ItemStack heldItem =
+                player.getInventory()
+                        .getItemInMainHand();
+
+        if (heldItem.getType() !=
+                RSConstants.REQUIRED_HELD_ITEM) {
+            return;
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | CANCEL VANILLA ACTION
+        |--------------------------------------------------------------------------
+        */
+
+        event.setCancelled(true);
+
+        /*
+        |--------------------------------------------------------------------------
+        | STORE SELECTED ENTITY
+        |--------------------------------------------------------------------------
+        */
+
+        GuiSession session =
+                GuiSessionManager.getSession(
+                        player
+                );
+
+        session.setSelectedBlock(
+                block
+        );
+
+        /*
+|--------------------------------------------------------------------------
+| ALREADY CONVERTED
+|--------------------------------------------------------------------------
+*/
+
+        if (MachineManager.machineExists(
+                block
+        )) {
+
+    /*
+    |--------------------------------------------------------------------------
+    | OWNER CHECK
+    |--------------------------------------------------------------------------
+    */
+
+            if (!MachineManager.isOwner(
+                    block,
+                    player
+            )
+
+                    &&
+
+                    !player.hasPermission(
+                            RSConstants.BYPASS_PERMISSION
+                    )
+
+            ) {
+
+                RSMessageUtils.error(
+                        player,
+                        "You are not the owner."
+                );
+
+                return;
+
+            }
+
+    /*
+    |--------------------------------------------------------------------------
+    | OPEN MAIN MENU
+    |--------------------------------------------------------------------------
+    */
+
+            RSMainMenu.open(
+                    player,
+                    block
+            );
+
+            return;
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | OPEN CONVERSION MENU
+        |--------------------------------------------------------------------------
+        */
+
+        RSConversionMenu.open(player);
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | GET SELECTED ENTITY
+    |--------------------------------------------------------------------------
+    */
+
+    public Block getSelectedBlock(
+            Player player
+    ) {
+
+        GuiSession session =
+                GuiSessionManager.getSession(
+                        player
+                );
+
+        return session.getSelectedBlock();
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | Convert Back
+    |--------------------------------------------------------------------------
+    */
+
+    public void convertBack(
+            Player player
+    ) {
+
+        GuiSession session =
+                GuiSessionManager.getSession(
+                        player
+                );
+
+        Block block =
+                session.getSelectedBlock();
+
+        if (block == null) {
+
+            player.closeInventory();
+
+            return;
+
+        }
+
+        MachineManager.deleteMachine(
+                block
+        );
+
+        RSMessageUtils.success(
+                player,
+                "Machine removed."
+        );
+
+        player.closeInventory();
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/listeners/RSFilterListener.java

@@ -0,0 +1,295 @@
+package com.rsscripting.rsauger.listeners;
+
+import com.rsscripting.rsauger.gui.RSFilterMenu;
+import com.rsscripting.rsauger.gui.RSMainMenu;
+import com.rsscripting.rsauger.gui.RSMenuHolder;
+import com.rsscripting.rsauger.managers.MachineManager;
+import com.rsscripting.rsauger.managers.RSConversionManager;
+import com.rsscripting.rsauger.utils.RSKeys;
+import com.rsscripting.rsauger.utils.RSMessageUtils;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+
+public class RSFilterListener
+        implements Listener {
+
+
+
+
+
+    private final RSConvertListener
+            conversionListener;
+
+    public RSFilterListener(
+            RSConvertListener conversionListener
+    ) {
+
+        this.conversionListener =
+                conversionListener;
+
+    }
+
+    @EventHandler
+    public void onInventoryClick(
+            InventoryClickEvent event
+    ) {
+
+        if (!(event.getWhoClicked()
+                instanceof Player player)) {
+            return;
+        }
+
+        if (!(event.getInventory()
+                .getHolder()
+                instanceof RSMenuHolder holder)) {
+            return;
+        }
+
+        if (!holder.getMenuId()
+                .equals(
+                        "FILTER"
+                )) {
+            return;
+        }
+
+        Block block =
+                conversionListener.getSelectedBlock(player);
+
+        if (block == null) {
+
+            player.closeInventory();
+
+            return;
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | TOP ROW
+        |--------------------------------------------------------------------------
+        */
+
+        if (event.getRawSlot() < 9) {
+
+            event.setCancelled(true);
+
+            /*
+            |--------------------------------------------------------------------------
+            | FILTER MODE
+            |--------------------------------------------------------------------------
+            */
+
+            if (event.getRawSlot() == 3) {
+
+                String currentMode =
+                        MachineManager.getFilterMode(
+                                block
+                        );
+
+                String nextMode;
+
+                if (currentMode.equals(
+                        RSKeys.FILTER_ALLOW_ALL
+                )) {
+
+                    nextMode =
+                            RSKeys.FILTER_WHITELIST;
+
+                }
+
+                else if (currentMode.equals(
+                        RSKeys.FILTER_WHITELIST
+                )) {
+
+                    nextMode =
+                            RSKeys.FILTER_BLACKLIST;
+
+                }
+
+                else {
+
+                    nextMode =
+                            RSKeys.FILTER_ALLOW_ALL;
+
+                }
+
+                MachineManager.setFilterMode(
+                        block,
+                        nextMode
+                );
+
+                RSFilterMenu.open(
+                        player,
+                        block
+                );
+
+                return;
+
+            }
+
+             /*
+            |--------------------------------------------------------------------------
+            | PREVIOUS PAGE
+            |--------------------------------------------------------------------------
+            */
+
+            if (event.getRawSlot() == 0
+                    && event.getCurrentItem() != null
+                    && event.getCurrentItem().getType()
+                    == Material.ARROW) {
+
+                if (holder.getPage() > 1) {
+
+                    holder.setPage(
+                            holder.getPage() - 1
+                    );
+
+                    RSFilterMenu.open(
+                            player,
+                            block,
+                            holder.getPage()
+                    );
+
+                }
+
+                return;
+
+            }
+
+            /*
+            |--------------------------------------------------------------------------
+            | NEXT PAGE
+            |--------------------------------------------------------------------------
+            */
+
+            if (event.getRawSlot() == 8
+                    && event.getCurrentItem() != null
+                    && event.getCurrentItem().getType()
+                    == Material.ARROW) {
+
+                int highestPage =
+                        MachineManager.getHighestFilterPage(
+                                block
+                        );
+
+                if (holder.getPage()
+                        <= highestPage) {
+
+                    holder.setPage(
+                            holder.getPage() + 1
+                    );
+
+                    RSFilterMenu.open(
+                            player,
+                            block,
+                            holder.getPage()
+                    );
+
+                }
+
+                return;
+
+            }
+
+            /*
+            |--------------------------------------------------------------------------
+            | BACK
+            |--------------------------------------------------------------------------
+            */
+
+            if (event.getRawSlot() == 5) {
+
+                RSMainMenu.open(
+                        player,
+                        block
+                );
+
+                return;
+
+            }
+
+            return;
+
+        }
+
+        if (event.getRawSlot() >= event.getInventory().getSize()) {
+            return;
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | FILTER STORAGE
+        |--------------------------------------------------------------------------
+        */
+
+        event.setCancelled(true);
+
+        if (event.getCursor().getType()
+                != Material.AIR) {
+
+            ItemStack filterItem =
+                    event.getCursor().clone();
+
+            filterItem.setAmount(1);
+
+            if (RSConversionManager.containsFilterItem(
+                    block,
+                    filterItem
+            )) {
+
+                RSMessageUtils.info(
+                        player,
+                        "That item is already in the filter."
+                );
+
+                return;
+
+            }
+
+            event.getInventory().setItem(
+                    event.getRawSlot(),
+                    filterItem
+            );
+
+            MachineManager.saveFilterItem(
+                    block,
+                    holder.getPage(),
+                    event.getRawSlot(),
+                    filterItem
+            );
+
+            RSFilterMenu.open(
+                    player,
+                    block,
+                    holder.getPage()
+            );
+
+            return;
+
+        }
+
+        event.getInventory().setItem(
+                event.getRawSlot(),
+                null
+        );
+
+        MachineManager.removeFilterItem(
+                block,
+                holder.getPage(),
+                event.getRawSlot()
+        );
+
+        RSFilterMenu.open(
+                player,
+                block,
+                holder.getPage()
+        );
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/listeners/RSMenuListener.java

@@ -0,0 +1,275 @@
+package com.rsscripting.rsauger.listeners;
+
+import com.rsscripting.rsauger.config.ConfigManager;
+import com.rsscripting.rsauger.managers.MachineManager;
+import com.rsscripting.rsauger.gui.*;
+import com.rsscripting.rsauger.utils.RSConstants;
+import com.rsscripting.rsauger.utils.RSKeys;
+import com.rsscripting.rsauger.utils.RSMessageUtils;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+
+public class RSMenuListener
+        implements Listener {
+
+    private final RSConvertListener
+            conversionListener;
+
+    public RSMenuListener(
+            RSConvertListener conversionListener
+    ) {
+
+        this.conversionListener =
+                conversionListener;
+
+    }
+
+    @EventHandler
+    public void onInventoryClick(
+            InventoryClickEvent event
+    ) {
+
+        Player player =
+                (Player) event.getWhoClicked();
+
+        /*
+        |--------------------------------------------------------------------------
+        | CONVERSION MENU
+        |--------------------------------------------------------------------------
+        */
+
+        if (event.getInventory()
+                .getHolder()
+                instanceof RSMenuHolder holder
+                && holder.getMenuId()
+                .equals(
+                        "CONVERT"
+                )) {
+
+            event.setCancelled(true);
+
+            if (event.getCurrentItem() == null) {
+                return;
+            }
+
+            if (event.getRawSlot() == 4) {
+
+                Block block =
+                        conversionListener.getSelectedBlock(player);
+
+                if (block == null){
+
+                    player.closeInventory();
+
+                    return;
+
+                }
+
+                MachineManager.insertMachine(
+                        block
+                );
+
+                MachineManager.setOwner(
+                        block,
+                        player
+                );
+
+                MachineManager.setPaused(
+                        block,
+                        false
+                );
+
+                MachineManager.setRadius(
+                        block,
+
+                        (int) ConfigManager.get().getDouble(
+                                "default-radius"
+                        )
+                );
+
+                MachineManager.setFilterMode(
+                        block,
+                        RSKeys.FILTER_ALLOW_ALL
+                );
+
+/*
+|--------------------------------------------------------------------------
+| ENTITY DISPLAY NAME
+|--------------------------------------------------------------------------
+|
+| Intentionally disabled.
+|
+| Some future entity-based plugins (villager systems, escorts,
+| traders, guards, etc.) may want visible custom names.
+|
+*/
+
+/*
+                entity.customName(
+                        net.kyori.adventure.text.Component.text(
+                                RSConstants.ENTITY_DISPLAY_NAME
+                        )
+                );
+
+                entity.setCustomNameVisible(true);
+*/
+
+
+
+                RSMessageUtils.success(
+                        player,
+                        "Converted Successfully."
+                );
+
+                RSMainMenu.open(
+                        player,
+                        block
+                );
+
+            }
+
+            return;
+
+        }
+
+        /*
+        |--------------------------------------------------------------------------
+        | MAIN MENU
+        |--------------------------------------------------------------------------
+        */
+
+        if (event.getInventory()
+                .getHolder()
+                instanceof RSMenuHolder holder
+                && holder.getMenuId()
+                .equals(
+                        "MAIN"
+                )) {
+
+            event.setCancelled(true);
+
+            if (event.getCurrentItem() == null) {
+                return;
+            }
+
+            Block block =
+                    conversionListener.getSelectedBlock(player);
+
+            if (block == null) {
+
+                player.closeInventory();
+
+                return;
+
+            }
+
+            /*
+            |--------------------------------------------------------------------------
+            | CONVERT BACK
+            |--------------------------------------------------------------------------
+            */
+
+            if (event.getRawSlot() == 2) {
+
+                conversionListener.convertBack(
+                        player
+                );
+
+                return;
+
+            }
+
+            /*
+            |--------------------------------------------------------------------------
+            | PAUSE / RESUME
+            |--------------------------------------------------------------------------
+            */
+
+            if (event.getRawSlot() == 6) {
+
+                boolean paused =
+                        MachineManager.isPaused(
+                                block
+                        );
+
+                MachineManager.setPaused(
+                        block,
+                        !paused
+                );
+
+                RSMainMenu.open(
+                        player,
+                        block
+                );
+
+                return;
+
+            }
+
+            /*
+            |--------------------------------------------------------------------------
+            | RADIUS MENU
+            |--------------------------------------------------------------------------
+            */
+
+            if (event.getRawSlot() == 11) {
+
+                RSRadiusMenu.open(
+                        player,
+                        block
+                );
+
+                return;
+
+            }
+
+/*
+|--------------------------------------------------------------------------
+| FILTER
+|--------------------------------------------------------------------------
+*/
+
+            if (event.getRawSlot() == 15) {
+
+                RSFilterMenu.open(
+                        player,
+                        block
+                );
+
+                return;
+
+            }
+
+            /*
+            |--------------------------------------------------------------------------
+            | ADMIN MENU
+            |--------------------------------------------------------------------------
+            */
+
+            if (event.getRawSlot() == 4) {
+
+                if (!player.isOp()
+                        ||
+
+                        !player.hasPermission(
+                                RSConstants.ADMIN_PERMISSION
+                        )) {
+
+                    return;
+
+                }
+
+                RSAdminMenu.open(
+                        player
+                );
+
+            }
+
+        }
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/listeners/RSRadiusListener.java

@@ -0,0 +1,156 @@
+package com.rsscripting.rsauger.listeners;
+
+import com.rsscripting.rsauger.config.ConfigManager;
+import com.rsscripting.rsauger.gui.RSMainMenu;
+import com.rsscripting.rsauger.gui.RSMenuHolder;
+import com.rsscripting.rsauger.gui.RSRadiusMenu;
+import com.rsscripting.rsauger.managers.MachineManager;
+
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryClickEvent;
+
+public class RSRadiusListener
+        implements Listener {
+
+    private final RSConvertListener
+            conversionListener;
+
+    public RSRadiusListener(
+            RSConvertListener conversionListener
+    ) {
+
+        this.conversionListener =
+                conversionListener;
+
+    }
+
+    @EventHandler
+    public void onInventoryClick(
+            InventoryClickEvent event
+    ) {
+
+        if (!(event.getWhoClicked()
+                instanceof Player player)) {
+            return;
+        }
+
+        if (!(event.getInventory()
+                .getHolder()
+                instanceof RSMenuHolder holder)) {
+            return;
+        }
+
+        if (!holder.getMenuId()
+                .equals(
+                        "RADIUS"
+                )) {
+            return;
+        }
+
+        event.setCancelled(true);
+
+        if (event.getCurrentItem() == null) {
+            return;
+        }
+
+        Block block =
+                conversionListener.getSelectedBlock(player);
+
+        if (block == null) {
+
+            player.closeInventory();
+
+            return;
+
+        }
+
+                /*
+        |--------------------------------------------------------------------------
+        | BACK
+        |--------------------------------------------------------------------------
+        */
+
+        if (event.getRawSlot() == 4) {
+
+            RSMainMenu.open(
+                    player,
+                    block
+            );
+
+            return;
+
+        }
+
+        int radius =
+                MachineManager.getRadius(
+                        block
+                );
+
+        int change;
+
+        switch (event.getRawSlot()) {
+
+            case 10:
+                change = -10;
+                break;
+
+            case 11:
+                change = -5;
+                break;
+
+            case 12:
+                change = -1;
+                break;
+
+            case 14:
+                change = 1;
+                break;
+
+            case 15:
+                change = 5;
+                break;
+
+            case 16:
+                change = 10;
+                break;
+
+            default:
+                return;
+
+        }
+
+        radius += change;
+
+        if (radius < 1) {
+            radius = 1;
+        }
+
+        int maxRadius =
+                (int) ConfigManager.get()
+                        .getDouble(
+                                "max-radius"
+                        );
+        if (maxRadius > 0
+                && radius > maxRadius) {
+
+            radius = maxRadius;
+
+        }
+
+        MachineManager.setRadius(
+                block,
+                radius
+        );
+
+        RSRadiusMenu.open(
+                player,
+                block
+        );
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/machine/MachineError.java

@@ -0,0 +1,17 @@
+package com.rsscripting.rsauger.machine;
+
+public enum MachineError {
+
+    NONE,
+
+    MISSING_TARGET,
+
+    MISSING_SOURCE,
+
+    INVALID_TARGET,
+
+    INVALID_SOURCE,
+
+    INVALID_CONFIGURATION
+
+}

src/main/java/com/rsscripting/rsauger/machine/MachineState.java

@@ -0,0 +1,13 @@
+package com.rsscripting.rsauger.machine;
+
+public enum MachineState {
+
+    ACTIVE,
+
+    PAUSED,
+
+    ERROR,
+
+    WAITING_SETUP
+
+}

src/main/java/com/rsscripting/rsauger/managers/RSConversionManager.java

@@ -0,0 +1,41 @@
+package com.rsscripting.rsauger.managers;
+
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.block.Block;
+
+import java.util.Map;
+
+public class RSConversionManager {
+
+    public static boolean containsFilterItem(
+            Block block,
+            ItemStack item
+    ) {
+
+        Map<Integer, ItemStack> filterItems =
+                MachineManager.getAllFilterItems(
+                        block
+                );
+
+        for (ItemStack filterItem
+                : filterItems.values()) {
+
+            if (filterItem == null) {
+                continue;
+            }
+
+            if (filterItem.isSimilar(
+                    item
+            )) {
+
+                return true;
+
+            }
+
+        }
+
+        return false;
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/utils/GitHubUpdateChecker.java

@@ -0,0 +1,177 @@
+package com.rsscripting.rsauger.utils;
+
+import com.rsscripting.rsauger.RSAuger;
+import org.bukkit.Bukkit;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URI;
+
+public class GitHubUpdateChecker {
+
+    /*
+    |--------------------------------------------------------------------------
+    | UPDATE STATUS
+    |--------------------------------------------------------------------------
+    */
+
+    private static String latestVersion = null;
+
+    private static String updateStatus =
+            "Checking...";
+
+    /*
+    |--------------------------------------------------------------------------
+    | CHECK FOR UPDATES
+    |--------------------------------------------------------------------------
+    */
+
+    public static void checkForUpdates() {
+
+        Bukkit.getScheduler().runTaskAsynchronously(
+
+                RSAuger.getInstance(),
+
+                () -> {
+
+                    try {
+
+                        String apiURL =
+                                "https://api.github.com/repos/"
+                                        + RSConstants.GITHUB_USER
+                                        + "/"
+                                        + RSConstants.GITHUB_REPOSITORY
+                                        + "/releases/latest";
+
+                        HttpURLConnection connection =
+                                (HttpURLConnection)
+                                        URI.create(apiURL)
+                                                .toURL()
+                                                .openConnection();
+
+                        connection.setRequestMethod("GET");
+
+                        BufferedReader reader =
+                                new BufferedReader(
+                                        new InputStreamReader(
+                                                connection.getInputStream()
+                                        )
+                                );
+
+                        StringBuilder response =
+                                new StringBuilder();
+
+                        String line;
+
+                        while ((line = reader.readLine()) != null) {
+
+                            response.append(line);
+
+                        }
+
+                        reader.close();
+
+                        String json =
+                                response.toString();
+
+                        latestVersion =
+                                json.split("\"tag_name\":\"")[1]
+                                        .split("\"")[0];
+
+                        String currentVersion =
+                                VersionUtils.getVersion();
+
+                        /*
+                        |--------------------------------------------------------------------------
+                        | UPDATE AVAILABLE
+                        |--------------------------------------------------------------------------
+                        */
+
+                        if (!latestVersion.equalsIgnoreCase(
+                                currentVersion
+                        )) {
+
+                            updateStatus =
+                                    "Update Available";
+
+                            Bukkit.getConsoleSender().sendMessage(
+
+                                    RSConstants.PREFIX
+                                            + "Update available: "
+                                            + latestVersion
+                                            + " (Current: "
+                                            + currentVersion
+                                            + ")"
+
+                            );
+
+                        }
+
+                        /*
+                        |--------------------------------------------------------------------------
+                        | UP TO DATE
+                        |--------------------------------------------------------------------------
+                        */
+
+                        else {
+
+                            updateStatus =
+                                    "Up To Date";
+
+                            Bukkit.getConsoleSender().sendMessage(
+
+                                    RSConstants.PREFIX
+                                            + "Plugin is up to date."
+
+                            );
+
+                        }
+
+                    }
+
+                    catch (Exception exception) {
+
+                        updateStatus =
+                                "Unable To Check";
+
+                        Bukkit.getConsoleSender().sendMessage(
+
+                                RSConstants.PREFIX
+                                        + "Failed to check for updates."
+
+                        );
+
+                    }
+
+                }
+
+        );
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | GET LATEST VERSION
+    |--------------------------------------------------------------------------
+    */
+
+    public static String getLatestVersion() {
+
+        return latestVersion;
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | GET UPDATE STATUS
+    |--------------------------------------------------------------------------
+    */
+
+    public static String getUpdateStatus() {
+
+        return updateStatus;
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/utils/RSConstants.java

@@ -0,0 +1,83 @@
+package com.rsscripting.rsauger.utils;
+
+import org.bukkit.Material;
+
+public class RSConstants {
+
+    /*
+    |--------------------------------------------------------------------------
+    | PLUGIN INFO
+    |--------------------------------------------------------------------------
+    */
+
+    public static final String PLUGIN_NAME =
+            "RS-Auger";
+
+    public static final String PREFIX =
+            "§7[§cRS-RSAuger§7] §r";
+
+    public static final String COMMAND_ALIAS =
+            "rsauger";
+
+    /*
+    |--------------------------------------------------------------------------
+    | GITHUB
+    |--------------------------------------------------------------------------
+    */
+
+    public static final String GITHUB_USER =
+            "YourGitHubUsername";
+
+    public static final String GITHUB_REPOSITORY =
+            "RS-ItemMagnet";
+
+    /*
+    |--------------------------------------------------------------------------
+    | PERMISSIONS
+    |--------------------------------------------------------------------------
+    */
+
+    public static final String ADMIN_PERMISSION =
+            "rsauger.admin";
+
+    public static final String BYPASS_PERMISSION =
+            "rsauger.bypass";
+
+    /*
+    |--------------------------------------------------------------------------
+    | REQUIRED CONVERSION ITEMS
+    |--------------------------------------------------------------------------
+    */
+
+    public static final Material REQUIRED_HELD_ITEM =
+            Material.STICK;
+
+    /*
+    |--------------------------------------------------------------------------
+    | REQUIRED TARGET ENTITY
+    |--------------------------------------------------------------------------
+    */
+
+    public static final Material
+            REQUIRED_TARGET_BLOCK =
+            Material.LODESTONE;
+
+    /*
+    |--------------------------------------------------------------------------
+    | MENU SETTINGS
+    |--------------------------------------------------------------------------
+    */
+
+    public static final Material MENU_FILLER_MATERIAL =
+            Material.WHITE_STAINED_GLASS_PANE;
+
+    /*
+    |--------------------------------------------------------------------------
+    | Version
+    |--------------------------------------------------------------------------
+    */
+
+    public static final String VERSION =
+            "1.0.0";
+
+}

src/main/java/com/rsscripting/rsauger/utils/RSKeys.java

@@ -0,0 +1,20 @@
+package com.rsscripting.rsauger.utils;
+
+public class RSKeys {
+
+    /*
+    |--------------------------------------------------------------------------
+    | FILTER MODES
+    |--------------------------------------------------------------------------
+    */
+
+    public static final String FILTER_ALLOW_ALL =
+            "allow_all";
+
+    public static final String FILTER_WHITELIST =
+            "whitelist";
+
+    public static final String FILTER_BLACKLIST =
+            "blacklist";
+
+}

src/main/java/com/rsscripting/rsauger/utils/RSMenuUtils.java

@@ -0,0 +1,122 @@
+package com.rsscripting.rsauger.utils;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import net.kyori.adventure.text.Component;
+
+import java.util.List;
+
+public class RSMenuUtils {
+
+    /*
+    |--------------------------------------------------------------------------
+    | CREATE FILLER PANE
+    |--------------------------------------------------------------------------
+    */
+
+    public static ItemStack createFillerPane() {
+
+        ItemStack item =
+                new ItemStack(
+                        RSConstants.MENU_FILLER_MATERIAL
+                );
+
+        ItemMeta meta =
+                item.getItemMeta();
+
+        if (meta != null) {
+
+            meta.displayName(
+                    Component.empty()
+            );
+
+            item.setItemMeta(meta);
+
+        }
+
+        return item;
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | CREATE MENU ITEM
+    |--------------------------------------------------------------------------
+    */
+
+    public static ItemStack createMenuItem(
+
+            Material material,
+
+            String name
+
+    ) {
+
+        ItemStack item =
+                new ItemStack(material);
+
+        ItemMeta meta =
+                item.getItemMeta();
+
+        if (meta != null) {
+
+            meta.displayName(
+                    Component.text(
+                            name
+                    )
+            );
+
+            item.setItemMeta(meta);
+
+        }
+
+        return item;
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | CREATE MENU ITEM WITH LORE
+    |--------------------------------------------------------------------------
+    */
+
+    public static ItemStack createMenuItem(
+
+            Material material,
+
+            String name,
+
+            List<String> lore
+
+    ) {
+
+        ItemStack item =
+                new ItemStack(material);
+
+        ItemMeta meta =
+                item.getItemMeta();
+
+        if (meta != null) {
+
+            meta.displayName(
+                    Component.text(
+                            name
+                    )
+            );
+
+            meta.lore(
+                    lore.stream()
+                            .map(Component::text)
+                            .toList()
+            );
+
+            item.setItemMeta(meta);
+
+        }
+
+        return item;
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/utils/RSMessageUtils.java

@@ -0,0 +1,170 @@
+package com.rsscripting.rsauger.utils;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.entity.Player;
+
+public class RSMessageUtils {
+
+    /*
+    |--------------------------------------------------------------------------
+    | PREFIX
+    |--------------------------------------------------------------------------
+    */
+
+    private static final Component PREFIX =
+
+            Component.text("[")
+                    .color(NamedTextColor.GRAY)
+
+                    .append(
+                            Component.text(
+                                    "RS-Plugin"
+                            ).color(
+                                    NamedTextColor.RED
+                            )
+                    )
+
+                    .append(
+                            Component.text("] ")
+                                    .color(
+                                            NamedTextColor.GRAY
+                                    )
+                    );
+
+    /*
+    |--------------------------------------------------------------------------
+    | SUCCESS
+    |--------------------------------------------------------------------------
+    */
+
+    public static void success(
+            Player player,
+            String message
+    ) {
+
+        player.sendMessage(
+
+                PREFIX.append(
+
+                        Component.text(
+                                message
+                        ).color(
+                                NamedTextColor.GREEN
+                        )
+
+                )
+
+        );
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | WARNING
+    |--------------------------------------------------------------------------
+    */
+
+    public static void warning(
+            Player player,
+            String message
+    ) {
+
+        player.sendMessage(
+
+                PREFIX.append(
+
+                        Component.text(
+                                message
+                        ).color(
+                                NamedTextColor.YELLOW
+                        )
+
+                )
+
+        );
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | ERROR
+    |--------------------------------------------------------------------------
+    */
+
+    public static void error(
+            Player player,
+            String message
+    ) {
+
+        player.sendMessage(
+
+                PREFIX.append(
+
+                        Component.text(
+                                message
+                        ).color(
+                                NamedTextColor.RED
+                        )
+
+                )
+
+        );
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | INFO
+    |--------------------------------------------------------------------------
+    */
+
+    public static void info(
+            Player player,
+            String message
+    ) {
+
+        player.sendMessage(
+
+                PREFIX.append(
+
+                        Component.text(
+                                message
+                        ).color(
+                                NamedTextColor.AQUA
+                        )
+
+                )
+
+        );
+
+    }
+
+    /*
+    |--------------------------------------------------------------------------
+    | ADMIN
+    |--------------------------------------------------------------------------
+    */
+
+    public static void admin(
+            Player player,
+            String message
+    ) {
+
+        player.sendMessage(
+
+                PREFIX.append(
+
+                        Component.text(
+                                message
+                        ).color(
+                                NamedTextColor.GOLD
+                        )
+
+                )
+
+        );
+
+    }
+
+}

src/main/java/com/rsscripting/rsauger/utils/VersionUtils.java

@@ -0,0 +1,20 @@
+package com.rsscripting.rsauger.utils;
+
+import com.rsscripting.rsauger.RSAuger;
+
+public class VersionUtils {
+
+    /*
+    |--------------------------------------------------------------------------
+    | GET INSTALLED VERSION
+    |--------------------------------------------------------------------------
+    */
+
+    public static String getVersion() {
+
+        return RSAuger.getInstance()
+                .getDescription()
+                .getVersion();
+    }
+
+}