UTD

src/main/java/si/jernejtdo/LitePermissions/Spigot/LitePermissions.java

@@ -6,43 +6,92 @@ import org.bukkit.plugin.java.JavaPlugin;
 
 import eu.triler.BukkitColors.ApplyColors;
 import si.jernejtdo.LitePermissions.Spigot.Permissible.onPlayerLoginInject;
+import si.jernejtdo.LitePermissions.Spigot.data.GroupData;
+import si.jernejtdo.LitePermissions.Spigot.data.UserData;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
 
 public class LitePermissions extends JavaPlugin {
 
-	private static LitePermissions plugin;
+    private static LitePermissions plugin;
 
-	@Override
-	public void onEnable() {
-		plugin = this;
-		sendConsoleMessage("Plugin is starting.");
+    // Runtime user/group data storage
+    private final Map<UUID, UserData> userDataMap = new HashMap<>();
+    private final Map<String, GroupData> groupDataMap = new HashMap<>();
 
-		registerEvents(onPlayerLoginInject.class);
+    @Override
+    public void onEnable() {
+        plugin = this;
+        sendConsoleMessage("Plugin is starting...");
 
-		sendConsoleMessage("Plugin is enabled.");
-	}
+        // Register listeners
+        registerEvents(onPlayerLoginInject.class);
 
-	@Override
-	public void onDisable() {
-		sendConsoleMessage("Plugin is disabled.");
-	}
+        // TODO: Load groups and users from storage
+        sendConsoleMessage("Plugin is enabled.");
+    }
 
-	public static LitePermissions getPlugin() {
-		return plugin;
-	}
+    @Override
+    public void onDisable() {
+        // TODO: Save users/groups if needed
+        sendConsoleMessage("Plugin is disabled.");
+    }
 
-	public <T extends Listener> void registerEvents(Class<T> listenerClass) {
-		try {
-			T listener = listenerClass.getDeclaredConstructor().newInstance();
-			plugin.getServer().getPluginManager().registerEvents(listener, plugin);
-			sendConsoleMessage("Listener &a" + listenerClass.getSimpleName() + "&f is registered.");
-		} catch (Exception e) {
-			e.printStackTrace();
-		}
-	}
+    public static LitePermissions getPlugin() {
+        return plugin;
+    }
 
-	public void sendConsoleMessage(String message) {
-		ApplyColors ac = new ApplyColors();
-		String def = ac.applyColerCodes("&aLitePermissions &7| Message: &f" + message);
-		Bukkit.getConsoleSender().sendMessage(def);
-	}
+    public <T extends Listener> void registerEvents(Class<T> listenerClass) {
+        try {
+            T listener = listenerClass.getDeclaredConstructor().newInstance();
+            plugin.getServer().getPluginManager().registerEvents(listener, plugin);
+            sendConsoleMessage("Listener &a" + listenerClass.getSimpleName() + "&f is registered.");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void sendConsoleMessage(String message) {
+        ApplyColors ac = new ApplyColors();
+        String formatted = ac.applyColerCodes("&aLitePermissions &7| &f" + message);
+        Bukkit.getConsoleSender().sendMessage(formatted);
+    }
+
+    // --- USER DATA ---
+
+    public UserData getUserData(UUID uuid) {
+        return userDataMap.get(uuid);
+    }
+
+    public void setUserData(UUID uuid, UserData userData) {
+        userDataMap.put(uuid, userData);
+    }
+
+    public boolean hasUserData(UUID uuid) {
+        return userDataMap.containsKey(uuid);
+    }
+
+    // --- GROUP DATA ---
+
+    public GroupData getGroupData(String name) {
+        return groupDataMap.get(name.toLowerCase());
+    }
+
+    public void setGroupData(String name, GroupData groupData) {
+        groupDataMap.put(name.toLowerCase(), groupData);
+    }
+
+    public boolean hasGroupData(String name) {
+        return groupDataMap.containsKey(name.toLowerCase());
+    }
+
+    public Map<UUID, UserData> getAllUserData() {
+        return userDataMap;
+    }
+
+    public Map<String, GroupData> getAllGroupData() {
+        return groupDataMap;
+    }
 }

src/main/java/si/jernejtdo/LitePermissions/Spigot/Permissible/CustomPermissible.java

@@ -1,10 +1,15 @@
 package si.jernejtdo.LitePermissions.Spigot.Permissible;
 
+import java.util.Comparator;
+import java.util.Optional;
+
 import org.bukkit.entity.Player;
 import org.bukkit.permissions.PermissibleBase;
 import org.bukkit.permissions.ServerOperator;
 
 import si.jernejtdo.LitePermissions.Spigot.LitePermissions;
+import si.jernejtdo.LitePermissions.Spigot.data.GroupData;
+import si.jernejtdo.LitePermissions.Spigot.data.UserData;
 
 public class CustomPermissible extends PermissibleBase {
 
@@ -30,16 +35,38 @@ public class CustomPermissible extends PermissibleBase {
     }
 
     public boolean checkPermissions(String inName) {
-        // You now have access to the player object
-        LitePermissions lp = LitePermissions.getPlugin();
-        
-        // Example: Check RamData or other storage here
-        // return RamData.hasPermission(player.getUniqueId(), inName);
-        lp.sendConsoleMessage("&a"+player.getName()+"&f Permission(&a"+inName+"&f)");
-        
-        return false; // default deny
+        LitePermissions plugin = LitePermissions.getPlugin();
+        UserData user = plugin.getUserData(player.getUniqueId());
+
+        boolean result = false;
+        String source = "none";
+
+        if (user != null) {
+            // 1. User-defined permission ALWAYS overrides
+            if (user.getPermissions().containsKey(inName)) {
+                result = user.getPermissions().get(inName); // true or false
+                source = "user";
+            } else {
+                // 2. Find highest-weight group that defines it
+                Optional<GroupData> groupWithPermission = user.getGroups().stream()
+                    .filter(g -> g.getPermissions().containsKey(inName))
+                    .max(Comparator.comparingInt(GroupData::getWeight));
+
+                if (groupWithPermission.isPresent()) {
+                    result = groupWithPermission.get().getPermissions().get(inName);
+                    source = "group:" + groupWithPermission.get().getName();
+                }
+            }
+        }
+
+        plugin.sendConsoleMessage("&a" + player.getName() +
+            "&f permission (&e" + inName + "&f): &6" + result + " &7[source: " + source + "]");
+
+        return result;
     }
 
+
+
     public Player getPlayer() {
         return player;
     }

src/main/java/si/jernejtdo/LitePermissions/Spigot/data/GroupData.java

@@ -0,0 +1,58 @@
+package si.jernejtdo.LitePermissions.Spigot.data;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class GroupData {
+    private String name;
+    private String prefix;
+    private String suffix;
+    private int weight = 0; // Default weight
+    private Map<String, Boolean> permissions = new HashMap<>();
+
+    public GroupData(String name) {
+        this.name = name;
+    }
+
+    public boolean hasPermission(String permission) {
+        return permissions.getOrDefault(permission, false);
+    }
+
+    // --- Getters and setters ---
+
+    public int getWeight() {
+        return weight;
+    }
+
+    public void setWeight(int weight) {
+        this.weight = weight;
+    }
+
+    public Map<String, Boolean> getPermissions() {
+        return permissions;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getPrefix() {
+        return prefix;
+    }
+
+    public String getSuffix() {
+        return suffix;
+    }
+
+    public void setPrefix(String prefix) {
+        this.prefix = prefix;
+    }
+
+    public void setSuffix(String suffix) {
+        this.suffix = suffix;
+    }
+
+    public void setPermission(String perm, boolean value) {
+        permissions.put(perm, value);
+    }
+}

src/main/java/si/jernejtdo/LitePermissions/Spigot/data/UserData.java

@@ -0,0 +1,85 @@
+package si.jernejtdo.LitePermissions.Spigot.data;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import java.util.*;
+
+public class UserData {
+    private UUID uuid;
+    private String prefix;
+    private String suffix;
+    private final Map<String, Boolean> permissions = new HashMap<>();
+    private final Set<GroupData> groups = new HashSet<>();
+
+    public UserData(UUID uuid) {
+        this.uuid = uuid;
+    }
+
+    // --- Group Management ---
+
+    public void addGroup(GroupData group) {
+        groups.add(group);
+    }
+
+    public void removeGroup(GroupData group) {
+        groups.remove(group);
+    }
+
+    public Set<GroupData> getGroups() {
+        return groups;
+    }
+
+    public GroupData getPrimaryGroup() {
+        return groups.stream()
+            .max(Comparator.comparingInt(GroupData::getWeight))
+            .orElse(null);
+    }
+
+    // --- Permission Logic ---
+
+    public boolean hasPermission(String permission) {
+        // 1. User override
+        if (permissions.containsKey(permission)) {
+            return permissions.get(permission);
+        }
+
+        // 2. Highest-weight group that defines the permission
+        return groups.stream()
+            .filter(g -> g.getPermissions().containsKey(permission))
+            .max(Comparator.comparingInt(GroupData::getWeight))
+            .map(g -> g.getPermissions().get(permission))
+            .orElse(false); // default deny
+    }
+
+    // --- Prefix/Suffix from Primary Group ---
+
+    public String getPrefix() {
+        return prefix != null ? prefix : getPrimaryGroupPrefix();
+    }
+
+    public String getSuffix() {
+        return suffix != null ? suffix : getPrimaryGroupSuffix();
+    }
+
+    private String getPrimaryGroupPrefix() {
+        GroupData primary = getPrimaryGroup();
+        return primary != null ? primary.getPrefix() : "";
+    }
+
+    private String getPrimaryGroupSuffix() {
+        GroupData primary = getPrimaryGroup();
+        return primary != null ? primary.getSuffix() : "";
+    }
+
+    // --- Permission Map Access ---
+
+    public Map<String, Boolean> getPermissions() {
+        return permissions;
+    }
+
+    public void setPermission(String permission, boolean value) {
+        permissions.put(permission, value);
+    }
+}