Added per-group block change limits.

src/WorldEditListener.java

@@ -71,6 +71,11 @@ public class WorldEditListener extends PluginListener {
      */
     private HashMap<String,String> commands = new HashMap<String,String>();
 
+    /**
+     * Group restrictions manager.
+     */
+    private GroupRestrictionsManager restrictions = new GroupRestrictionsManager();
+
     /**
      * List of allowed blocks.
      */
@@ -174,7 +179,11 @@ public class WorldEditListener extends PluginListener {
             return sessions.get(player);
         } else {
             WorldEditSession session = new WorldEditSession();
-            session.setBlockChangeLimit(defaultChangeLimit);
+            int changeLimit = restrictions.getGreatestChangeLimit(player.getGroups());
+            if (changeLimit == -2) {
+                changeLimit = defaultChangeLimit;
+            }
+            session.setBlockChangeLimit(changeLimit);
             sessions.put(player, session);
             return session;
         }
@@ -446,8 +455,13 @@ public class WorldEditListener extends PluginListener {
         } else if (split[0].equalsIgnoreCase("//limit")) {
             checkArgs(split, 1, 1, split[0]);
             int limit = Math.max(-1, Integer.parseInt(split[1]));
-            session.setBlockChangeLimit(limit);
+            int allowableMax = restrictions.getGreatestChangeLimit(player.getGroups());
-            player.print("Block change limit set to " + limit + ".");
+            if (allowableMax >= 0 && (limit == -1 || limit > allowableMax)) {
+                player.printError("Your maximum allowable limit is " + allowableMax + ".");
+            } else {
+                session.setBlockChangeLimit(limit);
+                player.print("Block change limit set to " + limit + ".");
+            }
             return true;
 
         // Undo
@@ -1437,6 +1451,15 @@ public class WorldEditListener extends PluginListener {
                 logger.removeHandler(handler);
             }
         }
+
+        try {
+            restrictions.load("worldedit-restrictions.txt");
+            logger.log(Level.INFO, "WorldEdit group restrictions loaded");
+        } catch (FileNotFoundException e) {
+        } catch (IOException e) {
+            logger.log(Level.WARNING, "Could not load WorldEdit restrictions: "
+                    + e.getMessage());
+        }
     }
 
     /**

src/WorldEditPlayer.java

@@ -438,4 +438,13 @@ public class WorldEditPlayer {
         loc.rotY = (float) pitch;
         player.teleportTo(loc);
     }
+
+    /**
+     * Get a player's list of groups.
+     * 
+     * @return
+     */
+    public String[] getGroups() {
+        return player.getGroups();
+    }
 }

src/com/sk89q/worldedit/GroupRestrictionsManager.java

@@ -0,0 +1,128 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.sk89q.worldedit;
+
+import java.util.Map;
+import java.util.HashMap;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import java.io.*;
+
+/**
+ *
+ * @author sk89q
+ */
+public class GroupRestrictionsManager {
+    /**
+     * Logger.
+     */
+    private static final Logger logger = Logger.getLogger("Minecraft.WorldEdit");
+    
+    /**
+     * Store block change limits.
+     */
+    private Map<String,Integer> changeLimits
+            = new HashMap<String,Integer>();
+
+    /**
+     * Get a group's change limit. Returns -2 if there is no setting.
+     *
+     * @param group
+     * @return
+     */
+    public int getChangeLimit(String group) {
+        group = group.toLowerCase();
+        if (changeLimits.containsKey(group.toLowerCase())) {
+            return changeLimits.get(group);
+        } else {
+            return -2;
+        }
+    }
+
+    /**
+     * Get the highest change limit of a list of groups.
+     * Returns -2 if there is no setting.
+     *
+     * @param group
+     * @return
+     */
+    public int getGreatestChangeLimit(String[] groups) {
+        int highestLimit = -2;
+        
+        for (String group : groups) {
+            int changeLimit = getChangeLimit(group);
+            System.out.println("change limit for " + group + ": " + changeLimit);
+            if (changeLimit == -1) {
+                return -1;
+            } else if (changeLimit > highestLimit) {
+                highestLimit = changeLimit;
+            }
+        }
+
+        return highestLimit;
+    }
+
+    /**
+     * Load group restrictions from a file.
+     *
+     * @param file
+     * @throws IOException
+     */
+    public void load(String file) throws IOException {
+        load(new File(file));
+    }
+
+    /**
+     * Load group restrictions from a file.
+     * 
+     * @param file
+     * @throws IOException
+     */
+    public void load(File file) throws IOException {
+        FileReader input = null;
+        Map<String,Integer> changeLimits = new HashMap<String,Integer>();
+
+        try {
+            input = new FileReader(file);
+            BufferedReader buff = new BufferedReader(input);
+
+            String line;
+            while ((line = buff.readLine()) != null) {
+                line = line.trim();
+
+                // Blank line
+                if (line.length() == 0) {
+                    continue;
+                }
+
+                // Comment
+                if (line.charAt(0) == ';' || line.charAt(0) == '#' || line.equals("")) {
+                    continue;
+                }
+
+                String[] parts = line.split(":");
+
+                String groupID = parts[0].toLowerCase();
+                try {
+                    int changeLimit = parts.length > 1 ? Integer.parseInt(parts[1]) : -1;
+                    changeLimits.put(groupID, changeLimit);
+                } catch (NumberFormatException e) {
+                    logger.log(Level.ALL.WARNING, "Integer expected in"
+                            + "WorldEdit group permissions line: " + line);
+                }
+            }
+
+            this.changeLimits = changeLimits;
+        } finally {
+            try {
+                if (input != null) {
+                    input.close();
+                }
+            } catch (IOException e2) {
+            }
+        }
+    }
+}