v0.9.0 - Fixed ToolDamage not having an option in the settings menu and corrected gold edition name in the pom.xml. Began adding Prison Gangs to the plugin, which includes handling a SQLite Database etc... what an undertaking LOL.

.idea/misc.xml

@@ -8,7 +8,7 @@
       </list>
     </option>
   </component>
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" default="true" project-jdk-name="17" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_17" project-jdk-name="17" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
 </project>

pom.xml

@@ -5,8 +5,8 @@
   <modelVersion>4.0.0</modelVersion>
 
   <groupId>me.NVus</groupId>
-  <artifactId>NVus_Prison_Setup</artifactId>
+  <artifactId>NVus_Prison</artifactId>
-  <version>0.8.1</version>
+  <version>0.9.0</version>
   <packaging>jar</packaging>
 
   <name>NVus_PrisonSetup</name>
@@ -107,6 +107,12 @@
                 <scope>import</scope>
                 <type>pom</type>
             </dependency>
+            <!-- SQLite JDBC Driver -->
+            <dependency>
+                <groupId>org.xerial</groupId>
+                <artifactId>sqlite-jdbc</artifactId>
+                <version>3.36.0.3</version> <!-- Use the latest version -->
+            </dependency>
         </dependencies>
     </dependencyManagement>
 

src/main/java/me/nvus/nvus_prison_setup/Configs/SettingsMenu.java

@@ -31,14 +31,15 @@ public class SettingsMenu implements Listener {
     }
 
     public void openSettingsMenu(Player player) {
-        Inventory inv = Bukkit.createInventory(null, 9, ChatColor.DARK_GREEN + "Settings Menu");
+        Inventory inv = Bukkit.createInventory(null, 9, ChatColor.DARK_GREEN + "NVus Prison Settings");
         FileConfiguration config = configManager.getConfig("config.yml");
 
+        // Adjust the items to be spaced out and include ToolDamage toggle
         inv.setItem(0, createToggleItem(Material.LEATHER_CHESTPLATE, "Toggle PrisonerArmor", config.getBoolean("PrisonerArmor", false)));
-        inv.setItem(1, createToggleItem(Material.IRON_DOOR, "Toggle RestrictArmor", config.getBoolean("RestrictArmor", false)));
+        inv.setItem(2, createToggleItem(Material.IRON_DOOR, "Toggle RestrictArmor", config.getBoolean("RestrictArmor", false)));
-        inv.setItem(3, createToggleItem(Material.HOPPER, "Toggle AutoPickup", config.getBoolean("AutoPickup", false)));
+        inv.setItem(4, createToggleItem(Material.HOPPER, "Toggle AutoPickup", config.getBoolean("AutoPickup", false)));
-        inv.setItem(4, createToggleItem(Material.LEVER, "Toggle AutoSwitch", config.getBoolean("AutoSwitch", false)));
+        inv.setItem(6, createToggleItem(Material.LEVER, "Toggle AutoSwitch", config.getBoolean("AutoSwitch", false)));
-        inv.setItem(7, createItem(Material.BOOK, ChatColor.GREEN + "Reload Configs"));
+        inv.setItem(8, createToggleItem(Material.IRON_PICKAXE, "Toggle ToolDamage", config.getBoolean("ToolDamage", true)));
 
         player.openInventory(inv);
     }
@@ -51,17 +52,18 @@ public class SettingsMenu implements Listener {
         return item;
     }
 
-    private ItemStack createItem(Material material, String name) {
+//    private ItemStack createItem(Material material, String name) {
-        ItemStack item = new ItemStack(material);
+//        ItemStack item = new ItemStack(material);
-        ItemMeta meta = item.getItemMeta();
+//        ItemMeta meta = item.getItemMeta();
-        meta.setDisplayName(name);
+//        meta.setDisplayName(name);
-        item.setItemMeta(meta);
+//        item.setItemMeta(meta);
-        return item;
+//        return item;
-    }
+//    }
+
 
     @EventHandler
     public void onInventoryClick(InventoryClickEvent event) {
-        if (!event.getView().getTitle().equals(ChatColor.DARK_GREEN + "Settings Menu")) return;
+        if (!event.getView().getTitle().equals(ChatColor.DARK_GREEN + "NVus Prison Settings")) return;
         event.setCancelled(true);
 
         Player player = (Player) event.getWhoClicked();

src/main/java/me/nvus/nvus_prison_setup/Database/DatabaseManager.java

@@ -0,0 +1,210 @@
+package me.nvus.nvus_prison_setup.Database;
+
+import java.sql.Connection;
+import java.sql.DriverManager;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.sql.SQLException;
+import java.sql.Statement;
+import java.util.UUID;
+
+public class DatabaseManager {
+
+    private String url = "jdbc:sqlite:/plugins/NVus_Prison/nvus_prison.db";
+
+    public DatabaseManager() {
+        initializeDatabase();
+    }
+
+    private Connection connect() {
+        Connection conn = null;
+        try {
+            conn = DriverManager.getConnection(url);
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+        }
+        return conn;
+    }
+
+    private void initializeDatabase() {
+        // SQL statement for creating gangs table
+        String sqlGangs = "CREATE TABLE IF NOT EXISTS gangs ("
+                + " id INTEGER PRIMARY KEY,"
+                + " name TEXT NOT NULL,"
+                + " owner_uuid TEXT NOT NULL"
+                + ");";
+
+        // SQL statement for creating members table
+        String sqlMembers = "CREATE TABLE IF NOT EXISTS members ("
+                + " uuid TEXT PRIMARY KEY,"
+                + " username TEXT NOT NULL,"
+                + " gang_id INTEGER NOT NULL,"
+                + " rank TEXT NOT NULL,"
+                + " FOREIGN KEY (gang_id) REFERENCES gangs(id)"
+                + ");";
+
+        try (Connection conn = connect();
+             Statement stmt = conn.createStatement()) {
+            // Create the gangs and members tables
+            stmt.execute(sqlGangs);
+            stmt.execute(sqlMembers);
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    public void createGang(String name, String ownerUuid) {
+        String sql = "INSERT INTO gangs(name, owner_uuid) VALUES(?,?)";
+
+        try (Connection conn = this.connect();
+             PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setString(1, name);
+            pstmt.setString(2, ownerUuid);
+            pstmt.executeUpdate();
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+        }
+    }
+
+    public boolean addMember(String uuid, String username, int gangId, String rank) {
+        String sql = "INSERT INTO members(uuid, username, gang_id, rank) VALUES(?,?,?,?)";
+        try (Connection conn = this.connect();
+             PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setString(1, uuid);
+            pstmt.setString(2, username);
+            pstmt.setInt(3, gangId);
+            pstmt.setString(4, rank);
+            int affectedRows = pstmt.executeUpdate();
+            return affectedRows > 0; // Return true if the row was added successfully
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+            return false; // Return false if an error occurs
+        }
+    }
+
+    public Integer getGangIdByName(String name) {
+        String sql = "SELECT id FROM gangs WHERE name = ?";
+
+        try (Connection conn = this.connect();
+             PreparedStatement pstmt  = conn.prepareStatement(sql)){
+
+            pstmt.setString(1,name);
+            ResultSet rs  = pstmt.executeQuery();
+
+            // Only return the first id
+            if (rs.next()) {
+                return rs.getInt("id");
+            }
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+        }
+        return null; // Gang not found
+    }
+
+    public Integer getGangIdByOwnerUuid(String ownerUuid) {
+        String sql = "SELECT id FROM gangs WHERE owner_uuid = ?";
+
+        try (Connection conn = this.connect();
+             PreparedStatement pstmt  = conn.prepareStatement(sql)){
+
+            pstmt.setString(1,ownerUuid);
+            ResultSet rs  = pstmt.executeQuery();
+
+            // Only return the first id
+            if (rs.next()) {
+                return rs.getInt("id");
+            }
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+        }
+        return null; // Gang not found
+    }
+
+    public String getCurrentGangByPlayerUuid(UUID playerUuid) {
+        String sql = "SELECT g.name FROM gangs g INNER JOIN members m ON g.id = m.gang_id WHERE m.uuid = ?";
+        try (Connection conn = this.connect();
+             PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setString(1, playerUuid.toString());
+            try (ResultSet rs = pstmt.executeQuery()) {
+                if (rs.next()) {
+                    return rs.getString("name");
+                }
+            }
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+        }
+        return null; // Return null if the player is not part of any gang or an error occurs
+    }
+
+    // GANG INVITES
+
+    // Method to invite a player to a gang, limited to Gang Owner and Capo
+    public boolean canInvite(String playerUuid) {
+        // Example implementation
+        String sql = "SELECT rank FROM members WHERE uuid = ?";
+        try (Connection conn = this.connect();
+             PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setString(1, playerUuid);
+            ResultSet rs = pstmt.executeQuery();
+            if (rs.next()) {
+                String rank = rs.getString("rank");
+                return "Owner".equalsIgnoreCase(rank) || "Capo".equalsIgnoreCase(rank);
+            }
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+        }
+        return false; // Player cannot invite or an error occurred
+    }
+
+
+    // Add Gang Invite
+    public boolean addInvitation(String playerUuid, String gangName) {
+        // This method would implement the logic to add an invitation.
+        // For demonstration, let's assume we're directly adding them to the gang with a "Pending" rank.
+        // You'll need to adjust this based on how you decide to manage invitations.
+        Integer gangId = getGangIdByName(gangName);
+        if (gangId == null) {
+            return false; // Gang not found
+        }
+        // Assuming a "Pending" status for new invites
+        addMember(playerUuid, "Pending", gangId, "Pending");
+        return true;
+    }
+
+    public boolean updateMemberRank(UUID playerUuid, String gangName, String newRank) {
+        String sql = "UPDATE members SET rank = ? WHERE uuid = ? AND gang_id = (SELECT id FROM gangs WHERE name = ?)";
+
+        try (Connection conn = this.connect();
+             PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setString(1, newRank);
+            pstmt.setString(2, playerUuid.toString());
+            pstmt.setString(3, gangName);
+
+            int affectedRows = pstmt.executeUpdate();
+            return affectedRows > 0;
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+            return false;
+        }
+    }
+
+    public boolean removeMember(UUID playerUuid, String gangName) {
+        String sql = "DELETE FROM members WHERE uuid = ? AND gang_id = (SELECT id FROM gangs WHERE name = ?)";
+
+        try (Connection conn = this.connect();
+             PreparedStatement pstmt = conn.prepareStatement(sql)) {
+            pstmt.setString(1, playerUuid.toString());
+            pstmt.setString(2, gangName);
+
+            int affectedRows = pstmt.executeUpdate();
+            return affectedRows > 0;
+        } catch (SQLException e) {
+            System.out.println(e.getMessage());
+            return false;
+        }
+    }
+
+
+
+
+}

src/main/java/me/nvus/nvus_prison_setup/Gangs/GangCommands.java

@@ -0,0 +1,115 @@
+package me.nvus.nvus_prison_setup.Gangs;
+
+import me.nvus.nvus_prison_setup.Database.DatabaseManager;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import java.util.UUID;
+
+public class GangCommands implements CommandExecutor {
+
+    private final GangManager gangManager;
+
+    public GangCommands(DatabaseManager dbManager) {
+        this.gangManager = new GangManager(dbManager);
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        if (!(sender instanceof Player)) {
+            sender.sendMessage("Only players can execute this command.");
+            return true;
+        }
+
+        Player player = (Player) sender;
+        UUID playerUuid = player.getUniqueId();
+
+        if (args.length >= 2 && args[0].equalsIgnoreCase("gang")) {
+            switch (args[1].toLowerCase()) {
+                case "invite":
+                    return handleGangInvite(sender, args);
+                case "accept":
+                    // Dynamically determine the gangName the player is invited to join
+                    return handleGangAccept(player, playerUuid);
+                case "deny":
+                    // Dynamically determine the gangName the player wants to deny
+                    return handleGangDeny(player, playerUuid);
+                case "leave":
+                    return handleGangLeave(player, playerUuid);
+                default:
+                    player.sendMessage("Invalid gang command.");
+                    return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean handleGangInvite(CommandSender sender, String[] args) {
+        if (args.length != 3) {
+            sender.sendMessage("Usage: /nvus gang invite <playerName> <gangName>");
+            return true;
+        }
+
+        Player player = (Player) sender;
+        String targetPlayerName = args[1];
+        String gangName = args[2];
+        Player targetPlayer = sender.getServer().getPlayer(targetPlayerName);
+        if (targetPlayer == null) {
+            sender.sendMessage("Could not find player: " + targetPlayerName);
+            return true;
+        }
+
+        UUID targetPlayerUuid = targetPlayer.getUniqueId();
+        if (!gangManager.canInvite(player.getUniqueId())) {
+            sender.sendMessage("You do not have permission to invite players to this gang.");
+            return true;
+        }
+
+        boolean invited = gangManager.addInvitation(targetPlayerUuid, gangName);
+        sender.sendMessage(invited ? "Player invited to gang successfully." : "Failed to invite player to gang.");
+        return true;
+    }
+
+    private boolean handleGangAccept(Player player, UUID playerUuid) {
+        String gangName = gangManager.getCurrentGangName(playerUuid); // Method in GangManager to determine the gangName
+        if (gangName == null) {
+            player.sendMessage("You don't have any pending invitations.");
+            return true;
+        }
+        if (gangManager.acceptInvitation(playerUuid, gangName)) {
+            player.sendMessage("You have successfully joined the gang: " + gangName + "!");
+        } else {
+            player.sendMessage("Failed to join the gang.");
+        }
+        return true;
+    }
+
+    private boolean handleGangDeny(Player player, UUID playerUuid) {
+        String gangName = gangManager.getCurrentGangName(playerUuid); // Similar method as accept to find the gangName
+        if (gangName == null) {
+            player.sendMessage("You don't have any pending invitations to deny.");
+            return true;
+        }
+        if (gangManager.denyInvitation(playerUuid, gangName)) {
+            player.sendMessage("You have successfully denied the gang invitation from: " + gangName + ".");
+        } else {
+            player.sendMessage("Failed to deny the gang invitation.");
+        }
+        return true;
+    }
+
+    private boolean handleGangLeave(Player player, UUID playerUuid) {
+        String gangName = gangManager.getCurrentGangName(playerUuid); // Method to get current gang of the player
+        if (gangName == null) {
+            player.sendMessage("You are not part of any gang!");
+            return true;
+        }
+        if (gangManager.leaveGang(playerUuid, gangName)) {
+            player.sendMessage("You have successfully left the gang: " + gangName + ".");
+        } else {
+            player.sendMessage("Failed to leave the gang.");
+        }
+        return true;
+    }
+}

src/main/java/me/nvus/nvus_prison_setup/Gangs/GangManager.java

@@ -0,0 +1,99 @@
+package me.nvus.nvus_prison_setup.Gangs;
+
+import java.util.UUID;
+import me.nvus.nvus_prison_setup.Database.DatabaseManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+public class GangManager {
+
+    private final DatabaseManager dbManager;
+
+    public GangManager(DatabaseManager dbManager) {
+        this.dbManager = dbManager;
+    }
+
+    public boolean createGang(String gangName, UUID ownerUuid) {
+        if (dbManager.getGangIdByName(gangName) != null) {
+            return false;
+        }
+        dbManager.createGang(gangName, ownerUuid.toString());
+        return true;
+    }
+
+    // Method to add a member to a gang
+    public boolean addMemberToGang(String username, UUID uuid, String gangName, String rank) {
+        Integer gangId = dbManager.getGangIdByName(gangName);
+        if (gangId == null) {
+            // Gang does not exist
+            return false;
+        }
+        // Add the member to the gang with the specified rank
+        dbManager.addMember(uuid.toString(), username, gangId, rank);
+        return true;
+    }
+
+    // Check if a player can invite others to the gang
+    public boolean canInvite(UUID playerUuid) {
+        // Implement logic to check if the player has the rank of Owner or Capo
+        // This requires a method in DatabaseManager to check the player's rank in their gang
+        return dbManager.canInvite(playerUuid.toString());
+    }
+
+    // Add an invitation to the gang
+    public boolean addInvitation(UUID playerUuid, String gangName) {
+        // For simplicity, this example directly adds the player to the gang
+        // You might want to implement a more complex invitation system
+        Integer gangId = dbManager.getGangIdByName(gangName);
+        if (gangId == null) {
+            // Gang does not exist
+            return false;
+        }
+        // Assume a default rank for new invites, e.g., "Pending" or "Member"
+        String username = resolveUsername(playerUuid); // You need to implement this method
+        return dbManager.addMember(playerUuid.toString(), username, gangId, "Pending");
+    }
+
+    // Method for a player to accept a gang invitation
+    public boolean acceptInvitation(UUID playerUuid, String gangName) {
+        return dbManager.updateMemberRank(playerUuid, gangName, "Member");
+    }
+
+    // Method for a player to deny a gang invitation or to be removed from the gang
+    public boolean denyInvitation(UUID playerUuid, String gangName) {
+        return dbManager.removeMember(playerUuid, gangName);
+    }
+
+
+
+
+
+    private String resolveUsername(UUID uuid) {
+        Player player = Bukkit.getPlayer(uuid);
+        if (player != null) {
+            return player.getName();
+        } else {
+            // The player might be offline or the UUID might not correspond to a known player.
+            // Decide how you want to handle this case. For now, returning null or a placeholder.
+            return null; // Consider an alternative approach based on your plugin's requirements.
+        }
+    }
+
+    public String getCurrentGangName(UUID playerUuid) {
+        // Call the DatabaseManager method to get the current gang name by player's UUID
+        return dbManager.getCurrentGangByPlayerUuid(playerUuid);
+    }
+
+    public boolean leaveGang(UUID playerUuid, String gangName) {
+        // Before removing a member, you may need to get the gang's ID based on its name
+        Integer gangId = dbManager.getGangIdByName(gangName);
+        if (gangId == null) {
+            // This means the gang doesn't exist, which could indicate an issue with the provided gangName
+            return false;
+        }
+        // Proceed to remove the player from the gang
+        return dbManager.removeMember(playerUuid, gangName);
+    }
+
+
+}

src/main/java/me/nvus/nvus_prison_setup/Listeners/CommandListener.java

@@ -109,4 +109,5 @@ public class CommandListener implements CommandExecutor {
         configManager.saveConfig("config.yml");
         sender.sendMessage(ChatColor.GREEN + key + " set to " + boolValue + ".");
     }
+
 }

src/main/java/me/nvus/nvus_prison_setup/PrisonSetup.java

@@ -3,6 +3,7 @@ package me.nvus.nvus_prison_setup;
 import me.nvus.nvus_prison_setup.Configs.ConfigManager;
 import me.nvus.nvus_prison_setup.Listeners.CommandListener;
 import me.nvus.nvus_prison_setup.Configs.SettingsMenu;
+// Listeners
 import me.nvus.nvus_prison_setup.Listeners.PlayerArmor;
 import me.nvus.nvus_prison_setup.Listeners.PlayerItems;
 import me.nvus.nvus_prison_setup.Listeners.PlayerSpawn;
@@ -10,6 +11,11 @@ import me.nvus.nvus_prison_setup.Listeners.BlockListener;
 import me.nvus.nvus_prison_setup.Listeners.ToolSwitchListener;
 import me.nvus.nvus_prison_setup.Updater.UpdateChecker;
 import me.nvus.nvus_prison_setup.Listeners.ToolDamageListener;
+// Database
+import me.nvus.nvus_prison_setup.Database.DatabaseManager;
+// Gangs
+import me.nvus.nvus_prison_setup.Gangs.GangCommands;
+import me.nvus.nvus_prison_setup.Gangs.GangManager;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.ChatColor;
@@ -18,32 +24,50 @@ import org.bukkit.plugin.java.JavaPlugin;
 public final class PrisonSetup extends JavaPlugin {
 
     private ConfigManager configManager;
+    private DatabaseManager dbManager; // Adjusted for clarity
+    private GangManager gangManager; // Added reference to GangManager
+    // Initialize the DatabaseManager
 
     @Override
     public void onEnable() {
         // Initialize the ConfigManager
         configManager = new ConfigManager(this);
 
+        // Gangs & Database
+        dbManager = new DatabaseManager(); // Initialize the DatabaseManager
+        gangManager = new GangManager(dbManager); // Initialize GangManager with DatabaseManager
+
+
+
         // Save the default configs, if they doesn't exist
         configManager.saveDefaultConfig("config.yml");
         configManager.saveDefaultConfig("banned_items.yml");
         configManager.saveDefaultConfig("auto_switch.yml");
 
-        // Register event listeners
+        // Register Event Listeners
         getServer().getPluginManager().registerEvents(new PlayerSpawn(configManager), this);
         getServer().getPluginManager().registerEvents(new PlayerArmor(configManager), this);
         getServer().getPluginManager().registerEvents(new PlayerItems(configManager), this);
         getServer().getPluginManager().registerEvents(new BlockListener(this), this);
         getServer().getPluginManager().registerEvents(new ToolSwitchListener(configManager), this);
         this.getCommand("nvus").setExecutor(new CommandListener(this, configManager));
-        //new SettingsMenu(this, configManager);
+
+        // Gang Related
+        // Register the Gang Commands
+        this.getCommand("gang create").setExecutor(new GangCommands(dbManager));
+        this.getCommand("gang invite").setExecutor(new GangCommands(dbManager));
+
+        // Settings Menu
         getServer().getPluginManager().registerEvents(new SettingsMenu(this, configManager), this);
 
+        // Tool Damage
         ToolDamageListener toolDamageListener = new ToolDamageListener(configManager);
         getServer().getPluginManager().registerEvents(toolDamageListener, this);
 
+        // Successful Startup/Enable
         getLogger().info(ChatColor.translateAlternateColorCodes('&',"&a&lNVus Prison Setup has been successfully enabled!"));
 
+        // UPDATE CHECKER
         new UpdateChecker(this, 12345).getVersion(version -> {
             if (!this.getDescription().getVersion().equals(version)) {
                 getLogger().info("There is a new update available for NVus Prison Setup! Grab it from SpigotMC here: https://www.spigotmc.org/resources/nvus-prison-setup.115441/");
@@ -77,4 +101,13 @@ public final class PrisonSetup extends JavaPlugin {
     public ConfigManager getConfigManager() {
         return configManager;
     }
+
+    // Optionally, if other parts of your plugin need to access the DatabaseManager or GangManager
+    public DatabaseManager getDatabaseManager() {
+        return dbManager;
+    }
+
+    public GangManager getGangManager() {
+        return gangManager;
+    }
 }