move src path and modify config file...

Signed-off-by: 502647092 <jtb1@163.com>

src/main/java/com/bekvon/bukkit/residence/protection/CuboidArea.java

@@ -0,0 +1,214 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.protection;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.ResidenceManager.ChunkRef;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.World;
+
+/**
+ * 
+ * @author Administrator
+ */
+public class CuboidArea {
+    protected Location highPoints;
+    protected Location lowPoints;
+
+    protected CuboidArea() {
+    }
+
+    public CuboidArea(Location startLoc, Location endLoc) {
+        int highx, highy, highz, lowx, lowy, lowz;
+        if (startLoc.getBlockX() > endLoc.getBlockX()) {
+            highx = startLoc.getBlockX();
+            lowx = endLoc.getBlockX();
+        } else {
+            highx = endLoc.getBlockX();
+            lowx = startLoc.getBlockX();
+        }
+        if (startLoc.getBlockY() > endLoc.getBlockY()) {
+            highy = startLoc.getBlockY();
+            lowy = endLoc.getBlockY();
+        } else {
+            highy = endLoc.getBlockY();
+            lowy = startLoc.getBlockY();
+        }
+        if (startLoc.getBlockZ() > endLoc.getBlockZ()) {
+            highz = startLoc.getBlockZ();
+            lowz = endLoc.getBlockZ();
+        } else {
+            highz = endLoc.getBlockZ();
+            lowz = startLoc.getBlockZ();
+        }
+        highPoints = new Location(startLoc.getWorld(), highx, highy, highz);
+        lowPoints = new Location(startLoc.getWorld(), lowx, lowy, lowz);
+    }
+
+    public boolean isAreaWithinArea(CuboidArea area) {
+        return (this.containsLoc(area.highPoints) && this.containsLoc(area.lowPoints));
+    }
+
+    public boolean containsLoc(Location loc) {
+        if (loc == null) {
+            return false;
+        }
+        if (!loc.getWorld().equals(highPoints.getWorld())) {
+            return false;
+        }
+        if (lowPoints.getBlockX() <= loc.getBlockX() && highPoints.getBlockX() >= loc.getBlockX()) {
+            if (lowPoints.getBlockZ() <= loc.getBlockZ() && highPoints.getBlockZ() >= loc.getBlockZ()) {
+                if (lowPoints.getBlockY() <= loc.getBlockY() && highPoints.getBlockY() >= loc.getBlockY()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public boolean checkCollision(CuboidArea area) {
+        if (!area.getWorld().equals(this.getWorld())) {
+            return false;
+        }
+        if (area.containsLoc(lowPoints) || area.containsLoc(highPoints) || this.containsLoc(area.highPoints) || this.containsLoc(area.lowPoints)) {
+            return true;
+        }
+        return advCuboidCheckCollision(highPoints, lowPoints, area.highPoints, area.lowPoints);
+    }
+
+    private boolean advCuboidCheckCollision(Location A1High, Location A1Low, Location A2High, Location A2Low) {
+        int A1HX = A1High.getBlockX();
+        int A1LX = A1Low.getBlockX();
+        int A1HY = A1High.getBlockY();
+        int A1LY = A1Low.getBlockY();
+        int A1HZ = A1High.getBlockZ();
+        int A1LZ = A1Low.getBlockZ();
+        int A2HX = A2High.getBlockX();
+        int A2LX = A2Low.getBlockX();
+        int A2HY = A2High.getBlockY();
+        int A2LY = A2Low.getBlockY();
+        int A2HZ = A2High.getBlockZ();
+        int A2LZ = A2Low.getBlockZ();
+        if ((A1HX >= A2LX && A1HX <= A2HX) || (A1LX >= A2LX && A1LX <= A2HX) || (A2HX >= A1LX && A2HX <= A1HX) || (A2LX >= A1LX && A2LX <= A1HX)) {
+            if ((A1HY >= A2LY && A1HY <= A2HY) || (A1LY >= A2LY && A1LY <= A2HY) || (A2HY >= A1LY && A2HY <= A1HY) || (A2LY >= A1LY && A2LY <= A1HY)) {
+                if ((A1HZ >= A2LZ && A1HZ <= A2HZ) || (A1LZ >= A2LZ && A1LZ <= A2HZ) || (A2HZ >= A1LZ && A2HZ <= A1HZ) || (A2LZ >= A1LZ && A2LZ <= A1HZ)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public long getSize() {
+        int xsize = (highPoints.getBlockX() - lowPoints.getBlockX()) + 1;
+        int ysize = (highPoints.getBlockY() - lowPoints.getBlockY()) + 1;
+        int zsize = (highPoints.getBlockZ() - lowPoints.getBlockZ()) + 1;
+        return xsize * ysize * zsize;
+    }
+
+    public int getXSize() {
+        return (highPoints.getBlockX() - lowPoints.getBlockX()) + 1;
+    }
+
+    public int getYSize() {
+        return (highPoints.getBlockY() - lowPoints.getBlockY()) + 1;
+    }
+
+    public int getZSize() {
+        return (highPoints.getBlockZ() - lowPoints.getBlockZ()) + 1;
+    }
+
+    public Location getHighLoc() {
+        return highPoints;
+    }
+
+    public Location getLowLoc() {
+        return lowPoints;
+    }
+
+    public World getWorld() {
+        return highPoints.getWorld();
+    }
+
+    public void save(DataOutputStream out, int version) throws IOException {
+        out.writeUTF(highPoints.getWorld().getName());
+        out.writeInt(highPoints.getBlockX());
+        out.writeInt(highPoints.getBlockY());
+        out.writeInt(highPoints.getBlockZ());
+        out.writeInt(lowPoints.getBlockX());
+        out.writeInt(lowPoints.getBlockY());
+        out.writeInt(lowPoints.getBlockZ());
+    }
+
+    public static CuboidArea load(DataInputStream in, int version) throws IOException {
+        CuboidArea newArea = new CuboidArea();
+        Server server = Residence.getServ();
+        World world = server.getWorld(in.readUTF());
+        int highx = in.readInt();
+        int highy = in.readInt();
+        int highz = in.readInt();
+        int lowx = in.readInt();
+        int lowy = in.readInt();
+        int lowz = in.readInt();
+        newArea.highPoints = new Location(world, highx, highy, highz);
+        newArea.lowPoints = new Location(world, lowx, lowy, lowz);
+        return newArea;
+    }
+
+    public Map<String, Object> save() {
+        Map<String, Object> root = new LinkedHashMap<String, Object>();
+        root.put("X1", this.highPoints.getBlockX());
+        root.put("Y1", this.highPoints.getBlockY());
+        root.put("Z1", this.highPoints.getBlockZ());
+        root.put("X2", this.lowPoints.getBlockX());
+        root.put("Y2", this.lowPoints.getBlockY());
+        root.put("Z2", this.lowPoints.getBlockZ());
+        return root;
+    }
+
+    public static CuboidArea load(Map<String, Object> root, World world) throws Exception {
+        if (root == null) {
+            throw new Exception("Invalid residence physical location...");
+        }
+        CuboidArea newArea = new CuboidArea();
+        int x1 = (Integer) root.get("X1");
+        int y1 = (Integer) root.get("Y1");
+        int z1 = (Integer) root.get("Z1");
+        int x2 = (Integer) root.get("X2");
+        int y2 = (Integer) root.get("Y2");
+        int z2 = (Integer) root.get("Z2");
+        newArea.highPoints = new Location(world, x1, y1, z1);
+        newArea.lowPoints = new Location(world, x2, y2, z2);
+        return newArea;
+    }
+
+    public List<ChunkRef> getChunks() {
+        List<ChunkRef> chunks = new ArrayList<ChunkRef>();
+        Location high = this.highPoints;
+        Location low = this.lowPoints;
+        int lowX = ChunkRef.getChunkCoord(low.getBlockX());
+        int lowZ = ChunkRef.getChunkCoord(low.getBlockZ());
+        int highX = ChunkRef.getChunkCoord(high.getBlockX());
+        int highZ = ChunkRef.getChunkCoord(high.getBlockZ());
+
+        for (int x = lowX; x <= highX; x++) {
+            for (int z = lowZ; z <= highZ; z++) {
+                chunks.add(new ChunkRef(x, z));
+            }
+        }
+        return chunks;
+    }
+}

src/main/java/com/bekvon/bukkit/residence/protection/FlagPermissions.java

@@ -0,0 +1,664 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.bekvon.bukkit.residence.protection;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.EnumMap;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.Player;
+
+import com.bekvon.bukkit.residence.Residence;
+
+/**
+ * 
+ * @author Administrator
+ */
+public class FlagPermissions {
+
+	protected static ArrayList<String> validFlags = new ArrayList<String>();
+	protected static ArrayList<String> validPlayerFlags = new ArrayList<String>();
+	protected static ArrayList<String> validAreaFlags = new ArrayList<String>();
+	final static Map<Material, String> matUseFlagList = new EnumMap<Material, String>(
+			Material.class);
+	protected Map<String, Map<String, Boolean>> playerFlags;
+	protected Map<String, Map<String, Boolean>> groupFlags;
+	protected Map<String, Boolean> cuboidFlags;
+	protected FlagPermissions parent;
+
+	public static void addMaterialToUseFlag(Material mat, String flag) {
+		matUseFlagList.put(mat, flag);
+	}
+
+	public static void removeMaterialFromUseFlag(Material mat) {
+		matUseFlagList.remove(mat);
+	}
+
+	public static EnumMap<Material, String> getMaterialUseFlagList() {
+		return (EnumMap<Material, String>) matUseFlagList;
+	}
+
+	public static void addFlag(String flag) {
+		flag = flag.toLowerCase();
+		if (!validFlags.contains(flag)) {
+			validFlags.add(flag);
+		}
+		if (validFlagGroups.containsKey(flag)) {
+			validFlagGroups.remove(flag);
+		}
+	}
+
+	public static void addPlayerOrGroupOnlyFlag(String flag) {
+		flag = flag.toLowerCase();
+		if (!validPlayerFlags.contains(flag)) {
+			validPlayerFlags.add(flag);
+		}
+		if (validFlagGroups.containsKey(flag)) {
+			validFlagGroups.remove(flag);
+		}
+	}
+
+	public static void addResidenceOnlyFlag(String flag) {
+		flag = flag.toLowerCase();
+		if (!validAreaFlags.contains(flag)) {
+			validAreaFlags.add(flag);
+		}
+		if (validFlagGroups.containsKey(flag)) {
+			validFlagGroups.remove(flag);
+		}
+	}
+
+	protected static HashMap<String, ArrayList<String>> validFlagGroups = new HashMap<String, ArrayList<String>>();
+
+	public static void addFlagToFlagGroup(String group, String flag) {
+		if (!FlagPermissions.validFlags.contains(group)
+				&& !FlagPermissions.validAreaFlags.contains(group)
+				&& !FlagPermissions.validPlayerFlags.contains(group)) {
+			if (!validFlagGroups.containsKey(group)) {
+				validFlagGroups.put(group, new ArrayList<String>());
+			}
+			ArrayList<String> flags = validFlagGroups.get(group);
+			flags.add(flag);
+		}
+	}
+
+	public static void removeFlagFromFlagGroup(String group, String flag) {
+		if (validFlagGroups.containsKey(group)) {
+			ArrayList<String> flags = validFlagGroups.get(group);
+			flags.remove(flag);
+			if (flags.isEmpty()) {
+				validFlagGroups.remove(group);
+			}
+		}
+	}
+
+	public static boolean flagGroupExists(String group) {
+		return validFlagGroups.containsKey(group);
+	}
+
+	public static void initValidFlags() {
+		validAreaFlags.clear();
+		validPlayerFlags.clear();
+		validFlags.clear();
+		validFlagGroups.clear();
+		addFlag("egg");
+		addFlag("note");
+		addFlag("pressure");
+		addFlag("cake");
+		addFlag("lever");
+		addFlag("door");
+		addFlag("button");
+		addFlag("table");
+		addFlag("brew");
+		addFlag("bed");
+		addFlag("commandblock");
+		addFlag("anvil");
+		addFlag("flowerpot");
+		addFlag("enchant");
+		addFlag("diode");
+		addFlag("use");
+		addFlag("move");
+		addFlag("build");
+		addFlag("tp");
+		addFlag("ignite");
+		addFlag("container");
+		addFlag("subzone");
+		addFlag("destroy");
+		addFlag("place");
+		addFlag("bucket");
+		addFlag("bank");
+		addFlag("beacon");
+
+		/* New flags */
+		addFlag("animalkilling");
+		addFlag("trade");
+
+		addResidenceOnlyFlag("trample");
+		addResidenceOnlyFlag("pvp");
+		addResidenceOnlyFlag("fireball");
+		addResidenceOnlyFlag("explode");
+		addResidenceOnlyFlag("damage");
+		addResidenceOnlyFlag("monsters");
+		addResidenceOnlyFlag("firespread");
+		addResidenceOnlyFlag("burn");
+		addResidenceOnlyFlag("tnt");
+		addResidenceOnlyFlag("creeper");
+		addResidenceOnlyFlag("wither");
+		addResidenceOnlyFlag("flow");
+		addResidenceOnlyFlag("healing");
+		addResidenceOnlyFlag("animals");
+		addResidenceOnlyFlag("lavaflow");
+		addResidenceOnlyFlag("waterflow");
+		addResidenceOnlyFlag("physics");
+		addResidenceOnlyFlag("piston");
+		addResidenceOnlyFlag("spread");
+		addResidenceOnlyFlag("hidden");
+		addResidenceOnlyFlag("witherdamage");
+		addPlayerOrGroupOnlyFlag("admin");
+		addFlagToFlagGroup("redstone", "note");
+		addFlagToFlagGroup("redstone", "pressure");
+		addFlagToFlagGroup("redstone", "lever");
+		addFlagToFlagGroup("redstone", "button");
+		addFlagToFlagGroup("redstone", "diode");
+		addFlagToFlagGroup("craft", "brew");
+		addFlagToFlagGroup("craft", "table");
+		addFlagToFlagGroup("craft", "enchant");
+		addFlagToFlagGroup("trusted", "use");
+		addFlagToFlagGroup("trusted", "tp");
+		addFlagToFlagGroup("trusted", "build");
+		addFlagToFlagGroup("trusted", "container");
+		addFlagToFlagGroup("trusted", "bucket");
+		addFlagToFlagGroup("trusted", "move");
+		addFlagToFlagGroup("fire", "ignite");
+		addFlagToFlagGroup("fire", "firespread");
+		addMaterialToUseFlag(Material.DIODE, "diode");
+		addMaterialToUseFlag(Material.DIODE_BLOCK_OFF, "diode");
+		addMaterialToUseFlag(Material.DIODE_BLOCK_ON, "diode");
+		addMaterialToUseFlag(Material.WORKBENCH, "table");
+		addMaterialToUseFlag(Material.WOODEN_DOOR, "door");
+		
+		/* 1.8 Doors */
+		addMaterialToUseFlag(Material.SPRUCE_DOOR, "door");
+		addMaterialToUseFlag(Material.BIRCH_DOOR, "door");
+		addMaterialToUseFlag(Material.JUNGLE_DOOR, "door");
+		addMaterialToUseFlag(Material.ACACIA_DOOR, "door");
+		addMaterialToUseFlag(Material.DARK_OAK_DOOR, "door");
+
+		/* 1.8 Fence Gates */
+		addMaterialToUseFlag(Material.SPRUCE_FENCE_GATE, "door");
+		addMaterialToUseFlag(Material.BIRCH_FENCE_GATE, "door");
+		addMaterialToUseFlag(Material.JUNGLE_FENCE_GATE, "door");
+		addMaterialToUseFlag(Material.ACACIA_FENCE_GATE, "door");
+		addMaterialToUseFlag(Material.DARK_OAK_FENCE_GATE, "door");
+
+		addMaterialToUseFlag(Material.FENCE_GATE, "door");
+		addMaterialToUseFlag(Material.NETHER_FENCE, "door");
+		addMaterialToUseFlag(Material.TRAP_DOOR, "door");
+		addMaterialToUseFlag(Material.ENCHANTMENT_TABLE, "enchant");
+		addMaterialToUseFlag(Material.STONE_BUTTON, "button");
+		addMaterialToUseFlag(Material.LEVER, "lever");
+		addMaterialToUseFlag(Material.BED_BLOCK, "bed");
+		addMaterialToUseFlag(Material.BREWING_STAND, "brew");
+		addMaterialToUseFlag(Material.CAKE, "cake");
+		addMaterialToUseFlag(Material.NOTE_BLOCK, "note");
+		addMaterialToUseFlag(Material.DRAGON_EGG, "egg");
+		addMaterialToUseFlag(Material.COMMAND, "commandblock");
+		addMaterialToUseFlag(Material.WOOD_BUTTON, "button");
+		addMaterialToUseFlag(Material.ANVIL, "anvil");
+		addMaterialToUseFlag(Material.FLOWER_POT, "flowerpot");
+		addMaterialToUseFlag(Material.BEACON, "beacon");
+		addMaterialToUseFlag(Material.JUKEBOX, "container");
+		addMaterialToUseFlag(Material.CHEST, "container");
+		addMaterialToUseFlag(Material.TRAPPED_CHEST, "container");
+		addMaterialToUseFlag(Material.HOPPER, "container");
+		addMaterialToUseFlag(Material.DROPPER, "container");
+		addMaterialToUseFlag(Material.FURNACE, "container");
+		addMaterialToUseFlag(Material.BURNING_FURNACE, "container");
+		addMaterialToUseFlag(Material.DISPENSER, "container");
+		addMaterialToUseFlag(Material.CAKE_BLOCK, "cake");
+	}
+
+	public static FlagPermissions parseFromConfigNode(String name,
+			ConfigurationSection node) {
+		FlagPermissions list = new FlagPermissions();
+		Set<String> keys = node.getConfigurationSection(name).getKeys(false);
+		if (keys != null) {
+			for (String key : keys) {
+				boolean state = node.getBoolean(name + "." + key, false);
+				key = key.toLowerCase();
+				if (state) {
+					list.setFlag(key, FlagState.TRUE);
+				} else {
+					list.setFlag(key, FlagState.FALSE);
+				}
+			}
+		}
+		return list;
+	}
+
+	public FlagPermissions() {
+		cuboidFlags = Collections
+				.synchronizedMap(new HashMap<String, Boolean>());
+		playerFlags = Collections
+				.synchronizedMap(new HashMap<String, Map<String, Boolean>>());
+		groupFlags = Collections
+				.synchronizedMap(new HashMap<String, Map<String, Boolean>>());
+	}
+
+	public boolean setPlayerFlag(String player, String flag, FlagState state) {
+		player = player.toLowerCase();
+		if (!playerFlags.containsKey(player)) {
+			playerFlags
+					.put(player, Collections
+							.synchronizedMap(new HashMap<String, Boolean>()));
+		}
+		Map<String, Boolean> map = playerFlags.get(player);
+		if (state == FlagState.FALSE) {
+			map.put(flag, false);
+		} else if (state == FlagState.TRUE) {
+			map.put(flag, true);
+		} else if (state == FlagState.NEITHER) {
+			if (map.containsKey(flag)) {
+				map.remove(flag);
+			}
+		}
+		if (map.isEmpty()) {
+			playerFlags.remove(player);
+		}
+		return true;
+	}
+
+	public void removeAllPlayerFlags(String player) {
+		playerFlags.remove(player);
+	}
+
+	public void removeAllGroupFlags(String group) {
+		groupFlags.remove(group);
+	}
+
+	public boolean setGroupFlag(String group, String flag, FlagState state) {
+		group = group.toLowerCase();
+		if (!groupFlags.containsKey(group)) {
+			groupFlags
+					.put(group, Collections
+							.synchronizedMap(new HashMap<String, Boolean>()));
+		}
+		Map<String, Boolean> map = groupFlags.get(group);
+		if (state == FlagState.FALSE) {
+			map.put(flag, false);
+		} else if (state == FlagState.TRUE) {
+			map.put(flag, true);
+		} else if (state == FlagState.NEITHER) {
+			if (map.containsKey(flag)) {
+				map.remove(flag);
+			}
+		}
+		if (map.isEmpty()) {
+			groupFlags.remove(group);
+		}
+		return true;
+	}
+
+	public boolean setFlag(String flag, FlagState state) {
+		if (state == FlagState.FALSE) {
+			cuboidFlags.put(flag, false);
+		} else if (state == FlagState.TRUE) {
+			cuboidFlags.put(flag, true);
+		} else if (state == FlagState.NEITHER) {
+			if (cuboidFlags.containsKey(flag)) {
+				cuboidFlags.remove(flag);
+			}
+		}
+		return true;
+	}
+
+	public static enum FlagState {
+
+		TRUE, FALSE, NEITHER, INVALID
+	}
+
+	public static FlagState stringToFlagState(String flagstate) {
+		if (flagstate.equalsIgnoreCase("true")
+				|| flagstate.equalsIgnoreCase("t")) {
+			return FlagState.TRUE;
+		} else if (flagstate.equalsIgnoreCase("false")
+				|| flagstate.equalsIgnoreCase("f")) {
+			return FlagState.FALSE;
+		} else if (flagstate.equalsIgnoreCase("remove")
+				|| flagstate.equalsIgnoreCase("r")) {
+			return FlagState.NEITHER;
+		} else {
+			return FlagState.INVALID;
+		}
+	}
+
+	public boolean playerHas(String player, String world, String flag,
+			boolean def) {
+		String group = Residence.getPermissionManager().getGroupNameByPlayer(
+				player, world);
+		return this.playerCheck(player, flag,
+				this.groupCheck(group, flag, this.has(flag, def)));
+	}
+
+	public boolean groupHas(String group, String flag, boolean def) {
+		return this.groupCheck(group, flag, this.has(flag, def));
+	}
+
+	private boolean playerCheck(String player, String flag, boolean def) {
+		player = player.toLowerCase();
+		if (playerFlags.containsKey(player)) {
+			Map<String, Boolean> pmap = playerFlags.get(player);
+			if (pmap.containsKey(flag)) {
+				return pmap.get(flag);
+			}
+		}
+		if (parent != null) {
+			return parent.playerCheck(player, flag, def);
+		}
+		return def;
+	}
+
+	private boolean groupCheck(String group, String flag, boolean def) {
+		if (groupFlags.containsKey(group)) {
+			Map<String, Boolean> gmap = groupFlags.get(group);
+			if (gmap.containsKey(flag)) {
+				return gmap.get(flag);
+			}
+		}
+		if (parent != null) {
+			return parent.groupCheck(group, flag, def);
+		}
+		return def;
+	}
+
+	public boolean has(String flag, boolean def) {
+		if (cuboidFlags.containsKey(flag)) {
+			return cuboidFlags.get(flag);
+		}
+		if (parent != null) {
+			return parent.has(flag, def);
+		}
+		return def;
+	}
+
+	public boolean isPlayerSet(String player, String flag) {
+		player = player.toLowerCase();
+		Map<String, Boolean> flags = playerFlags.get(player);
+		if (flags == null) {
+			return false;
+		}
+		return flags.containsKey(flag);
+	}
+
+	public boolean inheritanceIsPlayerSet(String player, String flag) {
+		player = player.toLowerCase();
+		Map<String, Boolean> flags = playerFlags.get(player);
+		if (flags == null) {
+			return parent == null ? false : parent.inheritanceIsPlayerSet(
+					player, flag);
+		}
+		return flags.containsKey(flag) ? true : parent == null ? false : parent
+				.inheritanceIsPlayerSet(player, flag);
+	}
+
+	public boolean isGroupSet(String group, String flag) {
+		group = group.toLowerCase();
+		Map<String, Boolean> flags = groupFlags.get(group);
+		if (flags == null) {
+			return false;
+		}
+		return flags.containsKey(flag);
+	}
+
+	public boolean inheritanceIsGroupSet(String group, String flag) {
+		group = group.toLowerCase();
+		Map<String, Boolean> flags = groupFlags.get(group);
+		if (flags == null) {
+			return parent == null ? false : parent.inheritanceIsGroupSet(group,
+					flag);
+		}
+		return flags.containsKey(flag) ? true : parent == null ? false : parent
+				.inheritanceIsGroupSet(group, flag);
+	}
+
+	public boolean isSet(String flag) {
+		return cuboidFlags.containsKey(flag);
+	}
+
+	public boolean inheritanceIsSet(String flag) {
+		return cuboidFlags.containsKey(flag) ? true : parent == null ? false
+				: parent.inheritanceIsSet(flag);
+	}
+
+	public boolean checkValidFlag(String flag, boolean globalflag) {
+		if (validFlags.contains(flag)) {
+			return true;
+		}
+		if (globalflag) {
+			if (validAreaFlags.contains(flag)) {
+				return true;
+			}
+		} else {
+			if (validPlayerFlags.contains(flag)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	public Map<String, Object> save() {
+		Map<String, Object> root = new LinkedHashMap<String, Object>();
+		root.put("PlayerFlags", playerFlags);
+		root.put("GroupFlags", groupFlags);
+		root.put("AreaFlags", cuboidFlags);
+		return root;
+	}
+
+	public static FlagPermissions load(Map<String, Object> root)
+			throws Exception {
+		FlagPermissions newperms = new FlagPermissions();
+		return FlagPermissions.load(root, newperms);
+	}
+
+	@SuppressWarnings("unchecked")
+	protected static FlagPermissions load(Map<String, Object> root,
+			FlagPermissions newperms) throws Exception {
+		newperms.playerFlags = (Map<String, Map<String, Boolean>>) root
+				.get("PlayerFlags");
+		newperms.groupFlags = (Map<String, Map<String, Boolean>>) root
+				.get("GroupFlags");
+		newperms.cuboidFlags = (Map<String, Boolean>) root.get("AreaFlags");
+		return newperms;
+	}
+
+	public String listFlags() {
+		StringBuilder sbuild = new StringBuilder();
+		Set<Entry<String, Boolean>> set = cuboidFlags.entrySet();
+		synchronized (cuboidFlags) {
+			Iterator<Entry<String, Boolean>> it = set.iterator();
+			while (it.hasNext()) {
+				Entry<String, Boolean> next = it.next();
+				if (next.getValue()) {
+					sbuild.append("+").append(next.getKey());
+					if (it.hasNext()) {
+						sbuild.append(" ");
+					}
+				} else {
+					sbuild.append("-").append(next.getKey());
+					if (it.hasNext()) {
+						sbuild.append(" ");
+					}
+				}
+			}
+		}
+		if (sbuild.length() == 0) {
+			sbuild.append("none");
+		}
+		return sbuild.toString();
+	}
+
+	public String listPlayerFlags(String player) {
+		player = player.toLowerCase();
+		if (playerFlags.containsKey(player)) {
+			StringBuilder sbuild = new StringBuilder();
+			Map<String, Boolean> get = playerFlags.get(player);
+			Set<Entry<String, Boolean>> set = get.entrySet();
+			synchronized (get) {
+				Iterator<Entry<String, Boolean>> it = set.iterator();
+				while (it.hasNext()) {
+					Entry<String, Boolean> next = it.next();
+					if (next.getValue()) {
+						sbuild.append("+").append(next.getKey());
+						if (it.hasNext()) {
+							sbuild.append(" ");
+						}
+					} else {
+						sbuild.append("-").append(next.getKey());
+						if (it.hasNext()) {
+							sbuild.append(" ");
+						}
+					}
+				}
+			}
+			if (sbuild.length() == 0) {
+				playerFlags.remove(player);
+				sbuild.append("none");
+			}
+			return sbuild.toString();
+		} else {
+			return "none";
+		}
+	}
+
+	public String listOtherPlayersFlags(String player) {
+		player = player.toLowerCase();
+		StringBuilder sbuild = new StringBuilder();
+		Set<String> set = playerFlags.keySet();
+		synchronized (playerFlags) {
+			Iterator<String> it = set.iterator();
+			while (it.hasNext()) {
+				String next = it.next();
+				if (!next.equals(player)) {
+					String perms = listPlayerFlags(next);
+					if (!perms.equals("none")) {
+						sbuild.append(next).append("[" + ChatColor.DARK_AQUA)
+								.append(perms).append(ChatColor.RED + "] ");
+					}
+				}
+			}
+		}
+		return sbuild.toString();
+	}
+
+	public String listGroupFlags() {
+		StringBuilder sbuild = new StringBuilder();
+		Set<String> set = groupFlags.keySet();
+		synchronized (groupFlags) {
+			Iterator<String> it = set.iterator();
+			while (it.hasNext()) {
+				String next = it.next();
+				String perms = listGroupFlags(next);
+				if (!perms.equals("none")) {
+					sbuild.append(next).append("[" + ChatColor.DARK_AQUA)
+							.append(perms).append(ChatColor.RED + "] ");
+				}
+			}
+		}
+		return sbuild.toString();
+	}
+
+	public String listGroupFlags(String group) {
+		group = group.toLowerCase();
+		if (groupFlags.containsKey(group)) {
+			StringBuilder sbuild = new StringBuilder();
+			Map<String, Boolean> get = groupFlags.get(group);
+			Set<Entry<String, Boolean>> set = get.entrySet();
+			synchronized (get) {
+				Iterator<Entry<String, Boolean>> it = set.iterator();
+				while (it.hasNext()) {
+					Entry<String, Boolean> next = it.next();
+					if (next.getValue()) {
+						sbuild.append("+").append(next.getKey());
+						if (it.hasNext()) {
+							sbuild.append(" ");
+						}
+					} else {
+						sbuild.append("-").append(next.getKey());
+						if (it.hasNext()) {
+							sbuild.append(" ");
+						}
+					}
+				}
+			}
+			if (sbuild.length() == 0) {
+				groupFlags.remove(group);
+				sbuild.append("none");
+			}
+			return sbuild.toString();
+		} else {
+			return "none";
+		}
+	}
+
+	public void clearFlags() {
+		groupFlags.clear();
+		playerFlags.clear();
+		cuboidFlags.clear();
+	}
+
+	public void printFlags(Player player) {
+		player.sendMessage(ChatColor.YELLOW
+				+ Residence.getLanguage().getPhrase("Flags") + ":"
+				+ ChatColor.BLUE + " " + listFlags());
+		player.sendMessage(ChatColor.YELLOW
+				+ Residence.getLanguage().getPhrase("Your.Flags") + ":"
+				+ ChatColor.GREEN + " " + listPlayerFlags(player.getName()));
+		player.sendMessage(ChatColor.YELLOW
+				+ Residence.getLanguage().getPhrase("Group.Flags") + ":"
+				+ ChatColor.RED + " " + listGroupFlags());
+		player.sendMessage(ChatColor.YELLOW
+				+ Residence.getLanguage().getPhrase("Others.Flags") + ":"
+				+ ChatColor.RED + " " + listOtherPlayersFlags(player.getName()));
+	}
+
+	public void copyUserPermissions(String fromUser, String toUser) {
+		fromUser = fromUser.toLowerCase();
+		toUser = toUser.toLowerCase();
+		Map<String, Boolean> get = playerFlags.get(fromUser);
+		if (get != null) {
+			Map<String, Boolean> targ = playerFlags.get(toUser);
+			if (targ == null) {
+				targ = new HashMap<String, Boolean>();
+				playerFlags.put(toUser, targ);
+			}
+			for (Entry<String, Boolean> entry : get.entrySet()) {
+				targ.put(entry.getKey(), entry.getValue());
+			}
+		}
+	}
+
+	public void clearPlayersFlags(String user) {
+		if (playerFlags.containsKey(user)) {
+			playerFlags.remove(user);
+		}
+	}
+
+	public void setParent(FlagPermissions p) {
+		parent = p;
+	}
+
+	public FlagPermissions getParent() {
+		return parent;
+	}
+}

src/main/java/com/bekvon/bukkit/residence/protection/LeaseManager.java

@@ -0,0 +1,280 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.protection;
+
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.economy.EconomyInterface;
+import com.bekvon.bukkit.residence.event.ResidenceDeleteEvent;
+import com.bekvon.bukkit.residence.event.ResidenceDeleteEvent.DeleteCause;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class LeaseManager {
+
+	private Map<String, Long> leaseExpireTime;
+
+	ResidenceManager manager;
+
+	public LeaseManager(ResidenceManager m) {
+		manager = m;
+		leaseExpireTime = Collections
+				.synchronizedMap(new HashMap<String, Long>());
+	}
+
+	public boolean leaseExpires(String area) {
+		return leaseExpireTime.containsKey(area);
+	}
+
+	public Date getExpireTime(String area) {
+		if (leaseExpireTime.containsKey(area)) {
+			return new Date(leaseExpireTime.get(area));
+		}
+		return null;
+	}
+
+	public void removeExpireTime(String area) {
+		leaseExpireTime.remove(area);
+	}
+
+	public void setExpireTime(String area, int days) {
+		this.setExpireTime(null, area, days);
+	}
+
+	public void setExpireTime(Player player, String area, int days) {
+		area = area.replace(".", "_");
+		if (manager.getByName(area) != null) {
+			leaseExpireTime.put(area,
+					daysToMs(days) + System.currentTimeMillis());
+			if (player != null)
+				player.sendMessage(ChatColor.GREEN
+						+ Residence.getLanguage().getPhrase("LeaseRenew",
+								getExpireTime(area).toString()));
+		} else {
+			if (player != null)
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("InvalidArea"));
+		}
+	}
+
+	public void renewArea(String area, Player player) {
+		if (!leaseExpires(area)) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("LeaseNotExpire"));
+			return;
+		}
+		PermissionGroup limits = Residence.getPermissionManager().getGroup(
+				player);
+		int max = limits.getMaxLeaseTime();
+		int add = limits.getLeaseGiveTime();
+		int rem = daysRemaining(area);
+		EconomyInterface econ = Residence.getEconomyManager();
+		if (econ != null) {
+			double cost = limits.getLeaseRenewCost();
+			ClaimedResidence res = manager.getByName(area);
+			int amount = (int) Math.ceil((double) res.getTotalSize() * cost);
+			if (cost != 0D) {
+				// Account account =
+				// iConomy.getBank().getAccount(player.getName());
+				if (econ.canAfford(player.getName(), amount)/*
+															 * account.hasEnough(
+															 * amount)
+															 */) {
+					econ.subtract(player.getName(), amount);
+					econ.add("Lease Money", amount);
+					player.sendMessage(ChatColor.GREEN
+							+ Residence.getLanguage().getPhrase(
+									"MoneyCharged",
+									ChatColor.YELLOW
+											+ String.format("%d", amount)
+											+ ChatColor.GREEN + "."
+											+ ChatColor.YELLOW + econ.getName()
+											+ ChatColor.GREEN));
+				} else {
+					player.sendMessage(ChatColor.RED
+							+ Residence.getLanguage().getPhrase(
+									"NotEnoughMoney"));
+					return;
+				}
+			}
+		}
+		if (rem + add > max) {
+			setExpireTime(player, area, max);
+			player.sendMessage(ChatColor.GOLD
+					+ Residence.getLanguage().getPhrase("LeaseRenewMax"));
+			player.sendMessage(ChatColor.YELLOW
+					+ Residence.getLanguage().getPhrase("LeaseRenew",
+							ChatColor.GREEN + "" + getExpireTime(area))
+					+ ChatColor.YELLOW);
+			return;
+		}
+		Long get = leaseExpireTime.get(area);
+		if (get != null) {
+			get = get + daysToMs(add);
+			leaseExpireTime.put(area, get);
+		} else
+			leaseExpireTime.put(area, daysToMs(add));
+		player.sendMessage(ChatColor.YELLOW
+				+ Residence.getLanguage().getPhrase("LeaseRenew",
+						ChatColor.GREEN + "" + getExpireTime(area)));
+	}
+
+	public int getRenewCost(ClaimedResidence res) {
+		PermissionGroup limits = Residence.getPermissionManager().getGroup(
+				res.getPermissions().getOwner(),
+				res.getPermissions().getWorld());
+		double cost = limits.getLeaseRenewCost();
+		int amount = (int) Math.ceil((double) res.getTotalSize() * cost);
+		return amount;
+	}
+
+	private long daysToMs(int days) {
+		return (((long) days) * 24L * 60L * 60L * 1000L);
+	}
+
+	private int msToDays(long ms) {
+		return (int) Math.ceil(((((double) ms / 1000D) / 60D) / 60D) / 24D);
+	}
+
+	private int daysRemaining(String area) {
+		Long get = leaseExpireTime.get(area);
+		if (get <= System.currentTimeMillis())
+			return 0;
+		return msToDays((int) (get - System.currentTimeMillis()));
+	}
+
+	public void doExpirations() {
+		Set<Entry<String, Long>> set = leaseExpireTime.entrySet();
+		Iterator<Entry<String, Long>> it = set.iterator();
+		while (it.hasNext()) {
+			Entry<String, Long> next = it.next();
+			if (next.getValue() <= System.currentTimeMillis()) {
+				String resname = next.getKey();
+				ClaimedResidence res = Residence.getResidenceManager()
+						.getByName(resname);
+				if (res == null) {
+					it.remove();
+				} else {
+					boolean renewed = false;
+					String owner = res.getPermissions().getOwner();
+					PermissionGroup limits = Residence.getPermissionManager()
+							.getGroup(owner, res.getPermissions().getWorld());
+					int cost = this.getRenewCost(res);
+					if (Residence.getConfigManager().enableEconomy()
+							&& Residence.getConfigManager().autoRenewLeases()) {
+						if (cost == 0) {
+							renewed = true;
+						} else if (res.getBank().hasEnough(cost)) {
+							res.getBank().subtract(cost);
+							renewed = true;
+							if (Residence.getConfigManager().debugEnabled())
+								System.out
+										.println("Lease Renewed From Residence Bank: "
+												+ resname);
+						} else if (Residence.getEconomyManager().canAfford(
+								owner, cost)) {
+							if (Residence.getEconomyManager().subtract(owner,
+									cost)) {
+								renewed = true;
+								if (Residence.getConfigManager().debugEnabled())
+									System.out
+											.println("Lease Renewed From Economy: "
+													+ resname);
+							}
+						}
+					}
+					if (!renewed) {
+						if (!Residence.getConfigManager().enabledRentSystem()
+								|| !Residence.getRentManager()
+										.isRented(resname)) {
+							ResidenceDeleteEvent resevent = new ResidenceDeleteEvent(
+									null, res, DeleteCause.LEASE_EXPIRE);
+							Residence.getServ().getPluginManager()
+									.callEvent(resevent);
+							if (!resevent.isCancelled()) {
+								manager.removeResidence(next.getKey());
+								it.remove();
+								if (Residence.getConfigManager().debugEnabled())
+									System.out
+											.println("Lease NOT removed, Removing: "
+													+ resname);
+							}
+						}
+					} else {
+						if (Residence.getConfigManager().enableEconomy()
+								&& Residence.getConfigManager()
+										.enableLeaseMoneyAccount()) {
+							Residence.getEconomyManager().add("Lease Money",
+									cost);
+						}
+						if (Residence.getConfigManager().debugEnabled())
+							System.out.println("Lease Renew Old: "
+									+ next.getValue());
+						next.setValue(System.currentTimeMillis()
+								+ daysToMs(limits.getLeaseGiveTime()));
+						if (Residence.getConfigManager().debugEnabled())
+							System.out.println("Lease Renew New: "
+									+ next.getValue());
+					}
+				}
+			}
+		}
+	}
+
+	public void resetLeases() {
+		leaseExpireTime.clear();
+		String[] list = manager.getResidenceList();
+		for (int i = 0; i < list.length; i++) {
+			if (list[i] != null) {
+				ClaimedResidence res = Residence.getResidenceManager()
+						.getByName(list[i]);
+				PermissionGroup group = Residence.getPermissionManager()
+						.getGroup(res.getPermissions().getOwner(),
+								res.getPermissions().getWorld());
+				this.setExpireTime(null, list[i], group.getLeaseGiveTime());
+			}
+		}
+		System.out.println("[Residence] - Set default leases.");
+	}
+
+	public Map<String, Long> save() {
+		return leaseExpireTime;
+	}
+
+	public void updateLeaseName(String oldName, String newName) {
+		if (leaseExpireTime.containsKey(oldName)) {
+			leaseExpireTime.put(newName, leaseExpireTime.get(oldName));
+			leaseExpireTime.remove(oldName);
+		}
+	}
+
+	public static LeaseManager load(Map<String, Long> root, ResidenceManager m) {
+		LeaseManager l = new LeaseManager(m);
+		if (root != null) {
+			for (Object val : root.values()) {
+				if (!(val instanceof Long)) {
+					root.remove(val);
+				}
+			}
+			l.leaseExpireTime = Collections.synchronizedMap(root);
+		}
+		return l;
+	}
+}

src/main/java/com/bekvon/bukkit/residence/protection/PermissionListManager.java

@@ -0,0 +1,162 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.protection;
+
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.Residence;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class PermissionListManager {
+
+	private Map<String, Map<String, FlagPermissions>> lists;
+
+	public PermissionListManager() {
+		lists = Collections
+				.synchronizedMap(new HashMap<String, Map<String, FlagPermissions>>());
+	}
+
+	public FlagPermissions getList(String player, String listname) {
+		Map<String, FlagPermissions> get = lists.get(player);
+		if (get == null) {
+			return null;
+		}
+		return get.get(listname);
+	}
+
+	public void makeList(Player player, String listname) {
+		Map<String, FlagPermissions> get = lists.get(player.getName());
+		if (get == null) {
+			get = new HashMap<String, FlagPermissions>();
+			lists.put(player.getName(), get);
+		}
+		FlagPermissions perms = get.get(listname);
+		if (perms == null) {
+			perms = new FlagPermissions();
+			get.put(listname, perms);
+			player.sendMessage(ChatColor.GREEN
+					+ Residence.getLanguage().getPhrase("ListCreate", listname));
+		} else {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("ListExists"));
+		}
+	}
+
+	public void removeList(Player player, String listname) {
+		Map<String, FlagPermissions> get = lists.get(player.getName());
+		if (get == null) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidList"));
+			return;
+		}
+		FlagPermissions list = get.get(listname);
+		if (list == null) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidList"));
+			return;
+		}
+		get.remove(listname);
+		player.sendMessage(ChatColor.RED
+				+ Residence.getLanguage().getPhrase("ListRemoved"));
+	}
+
+	public void applyListToResidence(Player player, String listname,
+			String areaname, boolean resadmin) {
+		FlagPermissions list = this.getList(player.getName(), listname);
+		if (list == null) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidList"));
+			return;
+		}
+		ClaimedResidence res = Residence.getResidenceManager().getByName(
+				areaname);
+		if (res == null) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidResidence"));
+			return;
+		}
+		res.getPermissions().applyTemplate(player, list, resadmin);
+	}
+
+	public void printList(Player player, String listname) {
+		FlagPermissions list = this.getList(player.getName(), listname);
+		if (list == null) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidList"));
+			return;
+		}
+		player.sendMessage(ChatColor.LIGHT_PURPLE
+				+ "------Permission Template------");
+		player.sendMessage(Residence.getLanguage().getPhrase("Name") + ": "
+				+ ChatColor.GREEN + listname);
+		list.printFlags(player);
+	}
+
+	public Map<String, Object> save() {
+		Map<String, Object> root = new LinkedHashMap<String, Object>();
+		for (Entry<String, Map<String, FlagPermissions>> players : lists
+				.entrySet()) {
+			Map<String, Object> saveMap = new LinkedHashMap<String, Object>();
+			Map<String, FlagPermissions> map = players.getValue();
+			for (Entry<String, FlagPermissions> list : map.entrySet()) {
+				saveMap.put(list.getKey(), list.getValue().save());
+			}
+			root.put(players.getKey(), saveMap);
+		}
+		return root;
+	}
+
+	@SuppressWarnings("unchecked")
+	public static PermissionListManager load(Map<String, Object> root) {
+
+		PermissionListManager p = new PermissionListManager();
+		if (root != null) {
+			for (Entry<String, Object> players : root.entrySet()) {
+				try {
+					Map<String, Object> value = (Map<String, Object>) players
+							.getValue();
+					Map<String, FlagPermissions> loadedMap = Collections
+							.synchronizedMap(new HashMap<String, FlagPermissions>());
+					for (Entry<String, Object> list : value.entrySet()) {
+						loadedMap.put(list.getKey(), FlagPermissions
+								.load((Map<String, Object>) list.getValue()));
+					}
+					p.lists.put(players.getKey(), loadedMap);
+				} catch (Exception ex) {
+					System.out
+							.println("[Residence] - Failed to load permission lists for player: "
+									+ players.getKey());
+				}
+			}
+		}
+		return p;
+	}
+
+	public void printLists(Player player) {
+		StringBuilder sbuild = new StringBuilder();
+		Map<String, FlagPermissions> get = lists.get(player.getName());
+		sbuild.append(ChatColor.YELLOW
+				+ Residence.getLanguage().getPhrase("Lists") + ":"
+				+ ChatColor.DARK_AQUA + " ");
+		if (get != null) {
+			for (Entry<String, FlagPermissions> thislist : get.entrySet()) {
+				sbuild.append(thislist.getKey()).append(" ");
+			}
+		}
+		player.sendMessage(sbuild.toString());
+	}
+}

src/main/java/com/bekvon/bukkit/residence/protection/ResidenceManager.java

@@ -0,0 +1,812 @@
+/*
+ * To change this template, choose Tools | Templates and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.protection;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.event.ResidenceCreationEvent;
+import com.bekvon.bukkit.residence.event.ResidenceDeleteEvent;
+import com.bekvon.bukkit.residence.event.ResidenceDeleteEvent.DeleteCause;
+import com.bekvon.bukkit.residence.event.ResidenceRenameEvent;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+import com.bekvon.bukkit.residence.selection.WECUI;
+import com.bekvon.bukkit.residence.text.help.InformationPager;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceManager {
+	public static final class ChunkRef {
+
+		public static int getChunkCoord(final int val) {
+			// For more info, see CraftBukkit.CraftWorld.getChunkAt( Location )
+			return val >> 4;
+		}
+
+		private final int z;
+		private final int x;
+
+		public ChunkRef(int x, int z) {
+			this.x = x;
+			this.z = z;
+		}
+
+		public ChunkRef(Location loc) {
+			this.x = getChunkCoord(loc.getBlockX());
+			this.z = getChunkCoord(loc.getBlockZ());
+		}
+
+		@Override
+		public boolean equals(final Object obj) {
+			if (this == obj)
+				return true;
+			if (obj == null)
+				return false;
+			if (getClass() != obj.getClass())
+				return false;
+			ChunkRef other = (ChunkRef) obj;
+			return this.x == other.x && this.z == other.z;
+		}
+
+		@Override
+		public int hashCode() {
+			return x ^ z;
+		}
+
+		/**
+		 * Useful for debug
+		 */
+		@Override
+		public String toString() {
+			StringBuilder sb = new StringBuilder();
+			sb.append("{ x: ").append(x).append(", z: ").append(z).append(" }");
+			return sb.toString();
+		}
+	}
+
+	private static List<ChunkRef> getChunks(ClaimedResidence res) {
+		List<ChunkRef> chunks = new ArrayList<ChunkRef>();
+		for (CuboidArea area : res.getAreaArray()) {
+			chunks.addAll(area.getChunks());
+		}
+		return chunks;
+	}
+
+	@SuppressWarnings("unchecked")
+	public static ResidenceManager load(Map<String, Object> root) throws Exception {
+		ResidenceManager resm = new ResidenceManager();
+		if (root == null)
+			return resm;
+		for (World world : Residence.getServ().getWorlds()) {
+			Map<String, Object> reslist = (Map<String, Object>) root.get(world.getName());
+			if (reslist != null) {
+				try {
+					resm.chunkResidences.put(world.getName(), loadMap(reslist, resm));
+				} catch (Exception ex) {
+					Residence.getLog().warning("载入世界: " + world.getName() + "的领地数据时发生错误!");
+					if (Residence.getConfigManager().stopOnSaveError())
+						throw (ex);
+				}
+			}
+		}
+		return resm;
+	}
+
+	@SuppressWarnings("unchecked")
+	public static Map<ChunkRef, List<String>> loadMap(Map<String, Object> root, ResidenceManager resm) throws Exception {
+		Map<ChunkRef, List<String>> retRes = new HashMap<ChunkRef, List<String>>();
+		if (root != null) {
+			for (Entry<String, Object> res : root.entrySet()) {
+				try {
+					ClaimedResidence residence = ClaimedResidence.load(
+							(Map<String, Object>) res.getValue(), null);
+					for (ChunkRef chunk : getChunks(residence)) {
+						List<String> ress = new ArrayList<String>();
+						if (retRes.containsKey(chunk)) {
+							ress.addAll(retRes.get(chunk));
+						}
+						ress.add(res.getKey());
+						retRes.put(chunk, ress);
+					}
+					resm.residences.put(res.getKey(), residence);
+				} catch (Exception ex) {
+					System.out.print("[Residence] Failed to load residence (" + res.getKey()
+							+ ")! Reason:" + ex.getMessage() + " Error Log:");
+					Logger.getLogger(ResidenceManager.class.getName()).log(Level.SEVERE, null, ex);
+					if (Residence.getConfigManager().stopOnSaveError())
+						throw (ex);
+				}
+			}
+		}
+		return retRes;
+	}
+
+	protected Map<String, ClaimedResidence> residences;
+
+	protected Map<String, Map<ChunkRef, List<String>>> chunkResidences;
+
+	public ResidenceManager() {
+		residences = new HashMap<String, ClaimedResidence>();
+		chunkResidences = new HashMap<String, Map<ChunkRef, List<String>>>();
+	}
+
+	public boolean addResidence(Player player, String name, Location loc1, Location loc2, boolean resadmin) {
+		return this.addResidence(player, player.getName(), name, loc1, loc2, resadmin);
+	}
+
+	public boolean addResidence(Player player, String owner, String name, Location loc1, Location loc2, boolean resadmin) {
+		if (!Residence.validName(name)) {
+			if (player != null) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("InvalidNameCharacters"));
+			}
+			return false;
+		}
+		if (loc1 == null || loc2 == null
+				|| !loc1.getWorld().getName().equals(loc2.getWorld().getName())) {
+			if (player != null) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("SelectPoints"));
+			}
+			return false;
+		}
+		PermissionGroup group = Residence.getPermissionManager().getGroup(owner,
+				loc1.getWorld().getName());
+		boolean createpermission = group.canCreateResidences()
+				|| (player == null ? true : player.hasPermission("residence.create"));
+		if (!createpermission && !resadmin) {
+			if (player != null) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("NoPermission"));
+			}
+			return false;
+		}
+		if (player != null) {
+			if (getOwnedZoneCount(player.getName()) >= group.getMaxZones() && !resadmin) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("ResidenceTooMany"));
+				return false;
+			}
+		}
+		CuboidArea newArea = new CuboidArea(loc1, loc2);
+		ClaimedResidence newRes = new ClaimedResidence(owner, loc1.getWorld().getName());
+		newRes.getPermissions().applyDefaultFlags();
+		newRes.setEnterMessage(group.getDefaultEnterMessage());
+		newRes.setLeaveMessage(group.getDefaultLeaveMessage());
+
+		ResidenceCreationEvent resevent = new ResidenceCreationEvent(player, name, newRes, newArea);
+		Residence.getServ().getPluginManager().callEvent(resevent);
+		if (resevent.isCancelled())
+			return false;
+		newArea = resevent.getPhysicalArea();
+		name = resevent.getResidenceName();
+		if (residences.containsKey(name)) {
+			if (player != null) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("ResidenceAlreadyExists",
+								ChatColor.YELLOW + name + ChatColor.RED));
+			}
+			return false;
+		}
+		if (player != null) {
+			newRes.addArea(player, newArea, "main", resadmin);
+		} else {
+			newRes.addArea(newArea, "main");
+		}
+		if (newRes.getAreaCount() != 0) {
+			residences.put(name, newRes);
+			calculateChunks(name);
+			Residence.getLeaseManager().removeExpireTime(name);
+			if (player != null) {
+				player.sendMessage(ChatColor.GREEN
+						+ Residence.getLanguage().getPhrase("ResidenceCreate",
+								ChatColor.YELLOW + name + ChatColor.GREEN));
+			}
+			if (Residence.getConfigManager().useLeases()) {
+				if (player != null) {
+					Residence.getLeaseManager().setExpireTime(player, name,
+							group.getLeaseGiveTime());
+				} else {
+					Residence.getLeaseManager().setExpireTime(name, group.getLeaseGiveTime());
+				}
+			}
+			return true;
+		}
+		return false;
+	}
+
+	public boolean addResidence(String name, Location loc1, Location loc2) {
+		return this.addResidence(name, "Server Land", loc1, loc2);
+	}
+
+	public boolean addResidence(String name, String owner, Location loc1, Location loc2) {
+		return this.addResidence(null, owner, name, loc1, loc2, true);
+	}
+
+	public void calculateChunks(String name) {
+		ClaimedResidence res = residences.get(name);
+		if (res != null) {
+			String world = res.getWorld();
+			if (chunkResidences.get(world) == null) {
+				chunkResidences.put(world, new HashMap<ChunkRef, List<String>>());
+			}
+			for (ChunkRef chunk : getChunks(res)) {
+				List<String> ress = new ArrayList<String>();
+				if (chunkResidences.get(world).containsKey(chunk)) {
+					ress.addAll(chunkResidences.get(world).get(chunk));
+				}
+				ress.add(name);
+				chunkResidences.get(world).put(chunk, ress);
+			}
+		}
+	}
+
+	public String checkAreaCollision(CuboidArea newarea, ClaimedResidence parentResidence) {
+		Set<Entry<String, ClaimedResidence>> set = residences.entrySet();
+		for (Entry<String, ClaimedResidence> entry : set) {
+			ClaimedResidence check = entry.getValue();
+			if (check != parentResidence && check.checkCollision(newarea))
+				return entry.getKey();
+		}
+		return null;
+	}
+
+	public ClaimedResidence getByLoc(Location loc) {
+		if (loc == null)
+			return null;
+		ClaimedResidence res = null;
+		boolean found = false;
+		String world = loc.getWorld().getName();
+		ChunkRef chunk = new ChunkRef(loc);
+		if (chunkResidences.get(world) != null) {
+			if (chunkResidences.get(world).get(chunk) != null) {
+				for (String key : chunkResidences.get(world).get(chunk)) {
+					ClaimedResidence entry = residences.get(key);
+					if (entry.containsLoc(loc)) {
+						res = entry;
+						found = true;
+						break;
+					}
+				}
+			}
+		}
+		if (!found)
+			return null;
+		ClaimedResidence subres = res.getSubzoneByLoc(loc);
+		if (subres == null)
+			return res;
+		return subres;
+	}
+
+	public ClaimedResidence getByName(String name) {
+		if (name == null)
+			return null;
+		String[] split = name.split("\\.");
+		if (split.length == 1)
+			return residences.get(name);
+		ClaimedResidence res = residences.get(split[0]);
+		for (int i = 1; i < split.length; i++) {
+			if (res != null) {
+				res = res.getSubzone(split[i]);
+			} else
+				return null;
+		}
+		return res;
+	}
+
+	public String getNameByLoc(Location loc) {
+		if (loc == null)
+			return null;
+		ClaimedResidence res = null;
+		String name = null;
+		boolean found = false;
+		String world = loc.getWorld().getName();
+		ChunkRef chunk = new ChunkRef(loc);
+		if (chunkResidences.get(world) != null) {
+			if (chunkResidences.get(world).get(chunk) != null) {
+				for (String key : chunkResidences.get(world).get(chunk)) {
+					ClaimedResidence entry = residences.get(key);
+					if (entry.containsLoc(loc)) {
+						res = entry;
+						found = true;
+						break;
+					}
+				}
+			}
+		}
+		if (!found)
+			return null;
+		name = res.getName();
+		if (name == null)
+			return null;
+		String szname = res.getSubzoneNameByLoc(loc);
+		if (szname != null)
+			return name + "." + szname;
+		return name;
+	}
+
+	public String getNameByRes(ClaimedResidence res) {
+		Set<Entry<String, ClaimedResidence>> set = residences.entrySet();
+		for (Entry<String, ClaimedResidence> check : set) {
+			if (check.getValue() == res)
+				return check.getKey();
+			String n = check.getValue().getSubzoneNameByRes(res);
+			if (n != null)
+				return check.getKey() + "." + n;
+		}
+		return null;
+	}
+
+	public int getOwnedZoneCount(String player) {
+		Collection<ClaimedResidence> set = residences.values();
+		int count = 0;
+		for (ClaimedResidence res : set) {
+			if (res.getPermissions().getOwner().equalsIgnoreCase(player)) {
+				count++;
+			}
+		}
+		return count;
+	}
+
+	public int getResidenceCount() {
+		return residences.size();
+	}
+
+	public String[] getResidenceList() {
+		return this.getResidenceList(true, true).toArray(new String[0]);
+	}
+
+	public ArrayList<String> getResidenceList(boolean showhidden, boolean showsubzones) {
+		return this.getResidenceList(null, showhidden, showsubzones, false);
+	}
+
+	public ArrayList<String> getResidenceList(String targetplayer, boolean showhidden, boolean showsubzones) {
+		return this.getResidenceList(targetplayer, showhidden, showsubzones, false);
+	}
+
+	public ArrayList<String> getResidenceList(String targetplayer, boolean showhidden, boolean showsubzones, boolean formattedOutput) {
+		ArrayList<String> list = new ArrayList<String>();
+		for (Entry<String, ClaimedResidence> res : residences.entrySet()) {
+			this.getResidenceList(targetplayer, showhidden, showsubzones, "", res.getKey(),
+					res.getValue(), list, formattedOutput);
+		}
+		return list;
+	}
+
+	private void getResidenceList(String targetplayer, boolean showhidden, boolean showsubzones, String parentzone, String resname, ClaimedResidence res, ArrayList<String> list, boolean formattedOutput) {
+		boolean hidden = res.getPermissions().has("hidden", false);
+		if ((showhidden) || (!showhidden && !hidden)) {
+			if (targetplayer == null
+					|| res.getPermissions().getOwner().equalsIgnoreCase(targetplayer)) {
+				if (formattedOutput) {
+					list.add(ChatColor.GREEN + parentzone + resname + ChatColor.YELLOW + " - "
+							+ Residence.getLanguage().getPhrase("World") + ": " + res.getWorld());
+				} else {
+					list.add(parentzone + resname);
+				}
+			}
+			if (showsubzones) {
+				for (Entry<String, ClaimedResidence> sz : res.subzones.entrySet()) {
+					this.getResidenceList(targetplayer, showhidden, showsubzones, parentzone
+							+ resname + ".", sz.getKey(), sz.getValue(), list, formattedOutput);
+				}
+			}
+		}
+	}
+
+	public void giveResidence(Player reqPlayer, String targPlayer, String residence, boolean resadmin) {
+		ClaimedResidence res = getByName(residence);
+		if (res == null) {
+			reqPlayer.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidResidence"));
+			return;
+		}
+		if (!res.getPermissions().hasResidencePermission(reqPlayer, true) && !resadmin) {
+			reqPlayer
+					.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+			return;
+		}
+		Player giveplayer = Residence.getServ().getPlayer(targPlayer);
+		if (giveplayer == null || !giveplayer.isOnline()) {
+			reqPlayer.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NotOnline"));
+			return;
+		}
+		CuboidArea[] areas = res.getAreaArray();
+		PermissionGroup g = Residence.getPermissionManager().getGroup(giveplayer);
+		if (areas.length > g.getMaxPhysicalPerResidence() && !resadmin) {
+			reqPlayer.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("ResidenceGiveLimits"));
+			return;
+		}
+		if (getOwnedZoneCount(giveplayer.getName()) >= g.getMaxZones() && !resadmin) {
+			reqPlayer.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("ResidenceGiveLimits"));
+			return;
+		}
+		if (!resadmin) {
+			for (CuboidArea area : areas) {
+				if (!g.inLimits(area)) {
+					reqPlayer.sendMessage(ChatColor.RED
+							+ Residence.getLanguage().getPhrase("ResidenceGiveLimits"));
+					return;
+				}
+			}
+		}
+		res.getPermissions().setOwner(giveplayer.getName(), true);
+		// Fix phrases here
+		reqPlayer.sendMessage(ChatColor.GREEN
+				+ Residence.getLanguage().getPhrase(
+						"ResidenceGive",
+						ChatColor.YELLOW + residence + ChatColor.GREEN + "." + ChatColor.YELLOW
+								+ giveplayer.getName() + ChatColor.GREEN));
+		giveplayer.sendMessage(Residence.getLanguage().getPhrase(
+				"ResidenceRecieve",
+				ChatColor.GREEN + residence + ChatColor.YELLOW + "." + ChatColor.GREEN
+						+ reqPlayer.getName() + ChatColor.YELLOW));
+	}
+
+	public void listAllResidences(Player player, int page) {
+		this.listAllResidences(player, page, false);
+	}
+
+	public void listAllResidences(Player player, int page, boolean showhidden) {
+		this.listAllResidences(player, page, showhidden, false);
+	}
+
+	public void listAllResidences(Player player, int page, boolean showhidden, boolean showsubzones) {
+		if (showhidden && !Residence.isResAdminOn(player)) {
+			showhidden = false;
+		}
+		InformationPager.printInfo(player, Residence.getLanguage().getPhrase("Residences"),
+				this.getResidenceList(null, showhidden, showsubzones, true), page);
+	}
+
+	public void listResidences(Player player) {
+		this.listResidences(player, player.getName(), 1);
+	}
+
+	public void listResidences(Player player, int page) {
+		this.listResidences(player, player.getName(), page);
+	}
+
+	public void listResidences(Player player, int page, boolean showhidden) {
+		this.listResidences(player, player.getName(), page, showhidden);
+	}
+
+	public void listResidences(Player player, String targetplayer) {
+		this.listResidences(player, targetplayer, 1);
+	}
+
+	public void listResidences(Player player, String targetplayer, int page) {
+		this.listResidences(player, targetplayer, page, false);
+	}
+
+	public void listResidences(Player player, String targetplayer, int page, boolean showhidden) {
+		this.listResidences(player, targetplayer, page, showhidden, false);
+	}
+
+	public void listResidences(Player player, String targetplayer, int page, boolean showhidden, boolean showsubzones) {
+		if (showhidden && !Residence.isResAdminOn(player) && !player.getName().equals(targetplayer)) {
+			showhidden = false;
+		}
+		InformationPager.printInfo(player, Residence.getLanguage().getPhrase("Residences") + " - "
+				+ targetplayer,
+				this.getResidenceList(targetplayer, showhidden, showsubzones, true), page);
+	}
+
+	public void mirrorPerms(Player reqPlayer, String targetArea, String sourceArea, boolean resadmin) {
+		ClaimedResidence reciever = this.getByName(targetArea);
+		ClaimedResidence source = this.getByName(sourceArea);
+		if (source == null || reciever == null) {
+			reqPlayer.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidResidence"));
+			return;
+		}
+		if (!resadmin) {
+			if (!reciever.getPermissions().hasResidencePermission(reqPlayer, true)
+					|| !source.getPermissions().hasResidencePermission(reqPlayer, true)) {
+				reqPlayer.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("NoPermission"));
+				return;
+			}
+		}
+		reciever.getPermissions().applyTemplate(reqPlayer, source.getPermissions(), resadmin);
+	}
+
+	public void printAreaInfo(String areaname, Player player) {
+		ClaimedResidence res = this.getByName(areaname);
+		if (res == null) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidResidence"));
+			return;
+		}
+		ResidencePermissions perms = res.getPermissions();
+		if (Residence.getConfigManager().enableEconomy()) {
+			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Residence")
+					+ ":" + ChatColor.DARK_GREEN + " " + areaname + " " + ChatColor.YELLOW
+					+ "Bank: " + ChatColor.GOLD + res.getBank().getStoredMoney());
+		} else {
+			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Residence")
+					+ ":" + ChatColor.DARK_GREEN + " " + areaname);
+		}
+		if (Residence.getConfigManager().enabledRentSystem()
+				&& Residence.getRentManager().isRented(areaname)) {
+			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Owner") + ":"
+					+ ChatColor.RED + " " + perms.getOwner() + ChatColor.YELLOW + " Rented by: "
+					+ ChatColor.RED + Residence.getRentManager().getRentingPlayer(areaname));
+		} else {
+			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Owner") + ":"
+					+ ChatColor.RED + " " + perms.getOwner() + ChatColor.YELLOW + " - "
+					+ Residence.getLanguage().getPhrase("World") + ": " + ChatColor.RED
+					+ perms.getWorld());
+		}
+		player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Flags") + ":"
+				+ ChatColor.BLUE + " " + perms.listFlags());
+		player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Your.Flags")
+				+ ": " + ChatColor.GREEN + perms.listPlayerFlags(player.getName()));
+		player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Group.Flags")
+				+ ":" + ChatColor.RED + " " + perms.listGroupFlags());
+		player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Others.Flags")
+				+ ":" + ChatColor.RED + " " + perms.listOtherPlayersFlags(player.getName()));
+		String aid = res.getAreaIDbyLoc(player.getLocation());
+		if (aid != null) {
+			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("CurrentArea")
+					+ ": " + ChatColor.GOLD + aid);
+		}
+		player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Total.Size") + ":"
+				+ ChatColor.LIGHT_PURPLE + " " + res.getTotalSize());
+		if (aid != null) {
+			player.sendMessage(ChatColor.YELLOW
+					+ Residence.getLanguage().getPhrase("CoordsT")
+					+ ": "
+					+ ChatColor.LIGHT_PURPLE
+					+ Residence.getLanguage().getPhrase(
+							"CoordsTop",
+							res.getAreaByLoc(player.getLocation()).getHighLoc().getBlockX()
+									+ "."
+									+ res.getAreaByLoc(player.getLocation()).getHighLoc()
+											.getBlockY()
+									+ "."
+									+ res.getAreaByLoc(player.getLocation()).getHighLoc()
+											.getBlockZ()));
+			player.sendMessage(ChatColor.YELLOW
+					+ Residence.getLanguage().getPhrase("CoordsB")
+					+ ": "
+					+ ChatColor.LIGHT_PURPLE
+					+ Residence.getLanguage().getPhrase(
+							"CoordsBottom",
+							res.getAreaByLoc(player.getLocation()).getLowLoc().getBlockX()
+									+ "."
+									+ res.getAreaByLoc(player.getLocation()).getLowLoc()
+											.getBlockY()
+									+ "."
+									+ res.getAreaByLoc(player.getLocation()).getLowLoc()
+											.getBlockZ()));
+			if (Residence.isUseWorldEdit()) {
+				WECUI.UPDATESELECT(res, player);
+			}
+		}
+		if (Residence.getConfigManager().useLeases()
+				&& Residence.getLeaseManager().leaseExpires(areaname)) {
+			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("LeaseExpire")
+					+ ":" + ChatColor.GREEN + " "
+					+ Residence.getLeaseManager().getExpireTime(areaname));
+		}
+	}
+
+	public void removeAllByOwner(Player player, String owner) {
+		this.removeAllByOwner(player, owner, residences);
+	}
+
+	private void removeAllByOwner(Player player, String owner, Map<String, ClaimedResidence> resholder) {
+		Iterator<ClaimedResidence> it = resholder.values().iterator();
+		while (it.hasNext()) {
+			ClaimedResidence res = it.next();
+			if (res.getOwner().equalsIgnoreCase(owner)) {
+				ResidenceDeleteEvent resevent = new ResidenceDeleteEvent(player, res,
+						player == null ? DeleteCause.OTHER : DeleteCause.PLAYER_DELETE);
+				Residence.getServ().getPluginManager().callEvent(resevent);
+				if (resevent.isCancelled())
+					return;
+				removeChunkList(res.getName());
+				it.remove();
+			} else {
+				this.removeAllByOwner(player, owner, res.subzones);
+			}
+		}
+	}
+
+	public void removeAllByOwner(String owner) {
+		this.removeAllByOwner(null, owner, residences);
+	}
+
+	public void removeAllFromWorld(CommandSender sender, String world) {
+		int count = 0;
+		Iterator<ClaimedResidence> it = residences.values().iterator();
+		while (it.hasNext()) {
+			ClaimedResidence next = it.next();
+			if (next.getWorld().equals(world)) {
+				it.remove();
+				count++;
+			}
+		}
+		chunkResidences.remove(world);
+		chunkResidences.put(world, new HashMap<ChunkRef, List<String>>());
+		if (count == 0) {
+			sender.sendMessage(ChatColor.RED + "No residences found in world: " + ChatColor.YELLOW
+					+ world);
+		} else {
+			sender.sendMessage(ChatColor.RED + "Removed " + ChatColor.YELLOW + count
+					+ ChatColor.RED + " residences in world: " + ChatColor.YELLOW + world);
+		}
+	}
+
+	public void removeChunkList(String name) {
+		ClaimedResidence res = residences.get(name);
+		if (res != null) {
+			String world = res.getWorld();
+			if (chunkResidences.get(world) != null) {
+				for (ChunkRef chunk : getChunks(res)) {
+					List<String> ress = new ArrayList<String>();
+					if (chunkResidences.get(world).containsKey(chunk)) {
+						ress.addAll(chunkResidences.get(world).get(chunk));
+					}
+					ress.remove(name);
+					chunkResidences.get(world).put(chunk, ress);
+				}
+			}
+		}
+	}
+
+	public void removeResidence(Player player, String name, boolean resadmin) {
+		ClaimedResidence res = this.getByName(name);
+		if (res != null) {
+			if (player != null && !resadmin) {
+				if (!res.getPermissions().hasResidencePermission(player, true) && !resadmin) {
+					player.sendMessage(ChatColor.RED
+							+ Residence.getLanguage().getPhrase("NoPermission"));
+					return;
+				}
+			}
+			ResidenceDeleteEvent resevent = new ResidenceDeleteEvent(player, res,
+					player == null ? DeleteCause.OTHER : DeleteCause.PLAYER_DELETE);
+			Residence.getServ().getPluginManager().callEvent(resevent);
+			if (resevent.isCancelled())
+				return;
+			ClaimedResidence parent = res.getParent();
+			if (parent == null) {
+				removeChunkList(name);
+				residences.remove(name);
+				if (player != null) {
+					player.sendMessage(ChatColor.GREEN
+							+ Residence.getLanguage().getPhrase("ResidenceRemove",
+									ChatColor.YELLOW + name + ChatColor.GREEN));
+				}
+			} else {
+				String[] split = name.split("\\.");
+				if (player != null) {
+					parent.removeSubzone(player, split[split.length - 1], true);
+				} else {
+					parent.removeSubzone(split[split.length - 1]);
+				}
+			}
+			// Residence.getLeaseManager().removeExpireTime(name); - causing
+			// concurrent modification exception in lease manager... worked
+			// around for now
+			Residence.getRentManager().removeRentable(name);
+
+		} else {
+			if (player != null) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("InvalidResidence"));
+			}
+		}
+	}
+
+	public void removeResidence(String name) {
+		this.removeResidence(null, name, true);
+	}
+
+	public boolean renameResidence(Player player, String oldName, String newName, boolean resadmin) {
+		if (!Residence.validName(newName)) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidNameCharacters"));
+			return false;
+		}
+		ClaimedResidence res = this.getByName(oldName);
+		if (res == null) {
+			if (player != null) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("InvalidResidence"));
+			}
+			return false;
+		}
+		if (res.getPermissions().hasResidencePermission(player, true) || resadmin) {
+			if (res.getParent() == null) {
+				if (residences.containsKey(newName)) {
+					if (player != null) {
+						player.sendMessage(ChatColor.RED
+								+ Residence.getLanguage().getPhrase("ResidenceAlreadyExists",
+										ChatColor.YELLOW + newName + ChatColor.RED));
+					}
+					return false;
+				}
+				ResidenceRenameEvent resevent = new ResidenceRenameEvent(res, newName, oldName);
+				Residence.getServ().getPluginManager().callEvent(resevent);
+				removeChunkList(oldName);
+				residences.put(newName, res);
+				residences.remove(oldName);
+				calculateChunks(newName);
+				if (Residence.getConfigManager().useLeases()) {
+					Residence.getLeaseManager().updateLeaseName(oldName, newName);
+				}
+				if (Residence.getConfigManager().enabledRentSystem()) {
+					Residence.getRentManager().updateRentableName(oldName, newName);
+				}
+				if (player != null) {
+					player.sendMessage(ChatColor.GREEN
+							+ Residence.getLanguage().getPhrase(
+									"ResidenceRename",
+									ChatColor.YELLOW + oldName + ChatColor.GREEN + "."
+											+ ChatColor.YELLOW + newName + ChatColor.GREEN));
+				}
+				return true;
+			} else {
+				String[] oldname = oldName.split("\\.");
+				ClaimedResidence parent = res.getParent();
+				return parent.renameSubzone(player, oldname[oldname.length - 1], newName, resadmin);
+			}
+		} else {
+			if (player != null) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("NoPermission"));
+			}
+			return false;
+		}
+	}
+
+	public boolean renameResidence(String oldName, String newName) {
+		return this.renameResidence(null, oldName, newName, true);
+	}
+
+	public Map<String, Object> save() {
+		Map<String, Object> worldmap = new LinkedHashMap<String, Object>();
+		for (World world : Residence.getServ().getWorlds()) {
+			Map<String, Object> resmap = new LinkedHashMap<String, Object>();
+			for (Entry<String, ClaimedResidence> res : residences.entrySet()) {
+				if (res.getValue().getWorld().equals(world.getName())) {
+					try {
+						resmap.put(res.getKey(), res.getValue().save());
+					} catch (Exception ex) {
+						System.out.println("[Residence] Failed to save residence (" + res.getKey()
+								+ ")!");
+						Logger.getLogger(ResidenceManager.class.getName()).log(Level.SEVERE, null,
+								ex);
+					}
+				}
+			}
+			worldmap.put(world.getName(), resmap);
+		}
+		return worldmap;
+	}
+}

src/main/java/com/bekvon/bukkit/residence/protection/ResidencePermissions.java

@@ -0,0 +1,497 @@
+/*
+ * To change this template, choose Tools | Templates and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.protection;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.event.ResidenceFlagChangeEvent;
+import com.bekvon.bukkit.residence.event.ResidenceFlagCheckEvent;
+import com.bekvon.bukkit.residence.event.ResidenceFlagEvent.FlagType;
+import com.bekvon.bukkit.residence.event.ResidenceOwnerChangeEvent;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+import com.bekvon.bukkit.residence.permissions.PermissionManager;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidencePermissions extends FlagPermissions {
+
+	public static ResidencePermissions load(ClaimedResidence res, Map<String, Object> root) throws Exception {
+		ResidencePermissions newperms = new ResidencePermissions(res);
+		newperms.owner = (String) root.get("Owner");
+		if (newperms.owner == null) {
+			newperms.owner = (String) root.get("OwnerLastKnownName");
+		}
+		if (newperms.owner == null) {
+			Residence.getLog().warning("发现未知所有者的领地,转换为Server Land...");
+			newperms.owner = "Server Land";
+		}
+		newperms.world = (String) root.get("World");
+		FlagPermissions.load(root, newperms);
+		if (newperms.owner == null)
+			throw new Exception("错误的Owner数据...");
+		if (newperms.world == null)
+			throw new Exception("错误的World数据...");
+		if (newperms.playerFlags == null)
+			throw new Exception("错误的PlayerFlags数据...");
+		if (newperms.groupFlags == null)
+			throw new Exception("错误的GroupFlags数据...");
+		if (newperms.cuboidFlags == null)
+			throw new Exception("错误的CuboidFlags数据...");
+		newperms.fixNames();
+		return newperms;
+	}
+
+	protected String owner;
+	protected String world;
+
+	protected ClaimedResidence residence;
+
+	private ResidencePermissions(ClaimedResidence res) {
+		residence = res;
+	}
+
+	public ResidencePermissions(ClaimedResidence res, String creator, String inworld) {
+		this(res);
+		owner = creator;
+		world = inworld;
+	}
+
+	public void applyDefaultFlags() {
+		PermissionManager gm = Residence.getPermissionManager();
+		PermissionGroup group = gm.getGroup(owner, world);
+		Set<Entry<String, Boolean>> dflags = group.getDefaultResidenceFlags();
+		Set<Entry<String, Boolean>> dcflags = group.getDefaultCreatorFlags();
+		Set<Entry<String, Map<String, Boolean>>> dgflags = group.getDefaultGroupFlags();
+		this.applyGlobalDefaults();
+		for (Entry<String, Boolean> next : dflags) {
+			if (this.checkValidFlag(next.getKey(), true)) {
+				if (next.getValue()) {
+					this.setFlag(next.getKey(), FlagState.TRUE);
+				} else {
+					this.setFlag(next.getKey(), FlagState.FALSE);
+				}
+			}
+		}
+		for (Entry<String, Boolean> next : dcflags) {
+			if (this.checkValidFlag(next.getKey(), false)) {
+				if (next.getValue()) {
+					this.setPlayerFlag(owner, next.getKey(), FlagState.TRUE);
+				} else {
+					this.setPlayerFlag(owner, next.getKey(), FlagState.FALSE);
+				}
+			}
+		}
+		for (Entry<String, Map<String, Boolean>> entry : dgflags) {
+			Map<String, Boolean> value = entry.getValue();
+			for (Entry<String, Boolean> flag : value.entrySet()) {
+				if (flag.getValue()) {
+					this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.TRUE);
+				} else {
+					this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.FALSE);
+				}
+			}
+		}
+	}
+
+	public void applyDefaultFlags(Player player, boolean resadmin) {
+		if (this.hasResidencePermission(player, true) || resadmin) {
+			this.applyDefaultFlags();
+			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("FlagsDefault"));
+		} else {
+			player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("NoPermission"));
+		}
+	}
+
+	public void applyGlobalDefaults() {
+		this.clearFlags();
+		FlagPermissions gRD = Residence.getConfigManager().getGlobalResidenceDefaultFlags();
+		FlagPermissions gCD = Residence.getConfigManager().getGlobalCreatorDefaultFlags();
+		Map<String, FlagPermissions> gGD = Residence.getConfigManager()
+				.getGlobalGroupDefaultFlags();
+		for (Entry<String, Boolean> entry : gRD.cuboidFlags.entrySet()) {
+			if (entry.getValue()) {
+				this.setFlag(entry.getKey(), FlagState.TRUE);
+			} else {
+				this.setFlag(entry.getKey(), FlagState.FALSE);
+			}
+		}
+		for (Entry<String, Boolean> entry : gCD.cuboidFlags.entrySet()) {
+			if (entry.getValue()) {
+				this.setPlayerFlag(owner, entry.getKey(), FlagState.TRUE);
+			} else {
+				this.setPlayerFlag(owner, entry.getKey(), FlagState.FALSE);
+			}
+		}
+		for (Entry<String, FlagPermissions> entry : gGD.entrySet()) {
+			for (Entry<String, Boolean> flag : entry.getValue().cuboidFlags.entrySet()) {
+				if (flag.getValue()) {
+					this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.TRUE);
+				} else {
+					this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.FALSE);
+				}
+			}
+		}
+	}
+
+	public void applyTemplate(Player player, FlagPermissions list, boolean resadmin) {
+		if (player != null) {
+			if (!player.getName().equals(owner) && !resadmin) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("NoPermission"));
+				return;
+			}
+		} else {
+			resadmin = true;
+		}
+		PermissionGroup group = Residence.getPermissionManager().getGroup(owner, world);
+		for (Entry<String, Boolean> flag : list.cuboidFlags.entrySet()) {
+			if (group.hasFlagAccess(flag.getKey()) || resadmin) {
+				this.cuboidFlags.put(flag.getKey(), flag.getValue());
+			} else {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("FlagSetDeny",
+								ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
+			}
+		}
+		for (Entry<String, Map<String, Boolean>> plists : list.playerFlags.entrySet()) {
+			for (Entry<String, Boolean> flag : plists.getValue().entrySet()) {
+				if (group.hasFlagAccess(flag.getKey()) || resadmin) {
+					if (!this.playerFlags.containsKey(plists.getKey())) {
+						this.playerFlags.put(plists.getKey(),
+								Collections.synchronizedMap(new HashMap<String, Boolean>()));
+					}
+					this.playerFlags.get(plists.getKey()).put(flag.getKey(), flag.getValue());
+				} else {
+					player.sendMessage(ChatColor.RED
+							+ Residence.getLanguage().getPhrase("FlagSetDeny",
+									ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
+				}
+			}
+		}
+		for (Entry<String, Map<String, Boolean>> glists : list.groupFlags.entrySet()) {
+			for (Entry<String, Boolean> flag : glists.getValue().entrySet()) {
+				if (group.hasFlagAccess(flag.getKey()) || resadmin) {
+					if (!this.groupFlags.containsKey(glists.getKey())) {
+						this.groupFlags.put(glists.getKey(),
+								Collections.synchronizedMap(new HashMap<String, Boolean>()));
+					}
+					this.groupFlags.get(glists.getKey()).put(flag.getKey(), flag.getValue());
+				} else {
+					player.sendMessage(ChatColor.RED
+							+ Residence.getLanguage().getPhrase("FlagSetDeny",
+									ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
+				}
+			}
+		}
+		if (player != null) {
+			player.sendMessage(ChatColor.GREEN
+					+ Residence.getLanguage().getPhrase("PermissionsApply"));
+		}
+	}
+
+	private boolean checkCanSetFlag(Player player, String flag, FlagState state, boolean globalflag, boolean resadmin) {
+		if (!checkValidFlag(flag, globalflag)) {
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidFlag"));
+			return false;
+		}
+		if (state == FlagState.INVALID) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidFlagState"));
+			return false;
+		}
+		if (!resadmin) {
+			if (!this.hasResidencePermission(player, false)) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("NoPermission"));
+				return false;
+			}
+			if (!hasFlagAccess(owner, flag)) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("OwnerNoPermission"));
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public void fixNames() {
+		ArrayList<String> fixNames = new ArrayList<String>();
+		Iterator<Entry<String, Map<String, Boolean>>> it = playerFlags.entrySet().iterator();
+		while (it.hasNext()) {
+			String name = it.next().getKey();
+			if (!name.equals(name.toLowerCase())) {
+				fixNames.add(name);
+			}
+		}
+		for (String name : fixNames) {
+			Map<String, Boolean> get = playerFlags.get(name);
+			playerFlags.remove(name);
+			playerFlags.put(name.toLowerCase(), get);
+		}
+	}
+
+	public String getOwner() {
+		return owner;
+	}
+
+	public String getWorld() {
+		return world;
+	}
+
+	@Override
+	public boolean groupHas(String group, String flag, boolean def) {
+		ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag, FlagType.GROUP,
+				group, def);
+		Residence.getServ().getPluginManager().callEvent(fc);
+		if (fc.isOverriden())
+			return fc.getOverrideValue();
+		return super.groupHas(group, flag, def);
+	}
+
+	@Override
+	public boolean has(String flag, boolean def) {
+		ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag,
+				FlagType.RESIDENCE, null, def);
+		Residence.getServ().getPluginManager().callEvent(fc);
+		if (fc.isOverriden())
+			return fc.getOverrideValue();
+		return super.has(flag, def);
+	}
+
+	public boolean hasApplicableFlag(String player, String flag) {
+		return super.inheritanceIsPlayerSet(player, flag)
+				|| super.inheritanceIsGroupSet(Residence.getPermissionManager()
+						.getGroupNameByPlayer(player, world), flag) || super.inheritanceIsSet(flag);
+	}
+
+	private boolean hasFlagAccess(String player, String flag) {
+		PermissionGroup group = Residence.getPermissionManager().getGroup(player, world);
+		return group.hasFlagAccess(flag);
+	}
+
+	public boolean hasResidencePermission(Player player, boolean requireOwner) {
+		if (Residence.getConfigManager().enabledRentSystem()) {
+			String resname = residence.getName();
+			if (Residence.getRentManager().isRented(resname)) {
+				if (requireOwner)
+					return false;
+				String renter = Residence.getRentManager().getRentingPlayer(resname);
+				if (player.getName().equalsIgnoreCase(renter))
+					return true;
+				else
+					return (playerHas(player.getName(), "admin", false));
+			}
+		}
+		if (requireOwner)
+			return (owner.equalsIgnoreCase(player.getName()));
+		return (playerHas(player.getName(), "admin", false) || owner.equalsIgnoreCase(player
+				.getName()));
+	}
+
+	public boolean playerHas(String player, String flag, boolean def) {
+		return this.playerHas(player, world, flag, def);
+	}
+
+	@Override
+	public boolean playerHas(String player, String world, String flag, boolean def) {
+		ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag, FlagType.PLAYER,
+				player, def);
+		Residence.getServ().getPluginManager().callEvent(fc);
+		if (fc.isOverriden())
+			return fc.getOverrideValue();
+		return super.playerHas(player, world, flag, def);
+	}
+
+	public boolean removeAllGroupFlags(Player player, String group, boolean resadmin) {
+		if (this.hasResidencePermission(player, false) || resadmin) {
+			ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL",
+					ResidenceFlagChangeEvent.FlagType.GROUP, FlagState.NEITHER, null);
+			Residence.getServ().getPluginManager().callEvent(fc);
+			if (fc.isCancelled())
+				return false;
+			super.removeAllGroupFlags(group);
+			player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("FlagSet"));
+			return true;
+		}
+		return false;
+	}
+
+	public boolean removeAllPlayerFlags(Player player, String targetPlayer, boolean resadmin) {
+		if (this.hasResidencePermission(player, false) || resadmin) {
+			ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL",
+					ResidenceFlagChangeEvent.FlagType.RESIDENCE, FlagState.NEITHER, null);
+			Residence.getServ().getPluginManager().callEvent(fc);
+			if (fc.isCancelled())
+				return false;
+			super.removeAllPlayerFlags(targetPlayer);
+			player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("FlagSet"));
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public Map<String, Object> save() {
+		Map<String, Object> root = super.save();
+		root.put("Owner", owner);
+		root.put("World", world);
+		return root;
+	}
+
+	public boolean setFlag(Player player, String flag, String flagstate, boolean resadmin) {
+		if (validFlagGroups.containsKey(flag))
+			return this.setFlagGroup(player, flag, flagstate, resadmin);
+		FlagState state = FlagPermissions.stringToFlagState(flagstate);
+		if (checkCanSetFlag(player, flag, state, true, resadmin)) {
+			ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag,
+					ResidenceFlagChangeEvent.FlagType.RESIDENCE, state, null);
+			Residence.getServ().getPluginManager().callEvent(fc);
+			if (fc.isCancelled())
+				return false;
+			if (super.setFlag(flag, state)) {
+				player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("FlagSet"));
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean setFlag(String flag, FlagState state) {
+		ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag,
+				ResidenceFlagChangeEvent.FlagType.RESIDENCE, state, null);
+		Residence.getServ().getPluginManager().callEvent(fc);
+		if (fc.isCancelled())
+			return false;
+		return super.setFlag(flag, state);
+	}
+
+	public boolean setFlagGroup(Player player, String flaggroup, String state, boolean resadmin) {
+		if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
+			ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
+			boolean changed = false;
+			for (String flag : flags) {
+				if (this.setFlag(player, flag, state, resadmin)) {
+					changed = true;
+				}
+			}
+			return changed;
+		}
+		return false;
+	}
+
+	public boolean setFlagGroupOnGroup(Player player, String flaggroup, String group, String state, boolean resadmin) {
+		if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
+			ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
+			boolean changed = false;
+			for (String flag : flags) {
+				if (this.setGroupFlag(player, group, flag, state, resadmin)) {
+					changed = true;
+				}
+			}
+			return changed;
+		}
+		return false;
+	}
+
+	public boolean setFlagGroupOnPlayer(Player player, String target, String flaggroup, String state, boolean resadmin) {
+		if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
+			ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
+			boolean changed = false;
+			for (String flag : flags) {
+				if (this.setPlayerFlag(player, target, flag, state, resadmin)) {
+					changed = true;
+				}
+			}
+			return changed;
+		}
+		return false;
+	}
+
+	public boolean setGroupFlag(Player player, String group, String flag, String flagstate, boolean resadmin) {
+		group = group.toLowerCase();
+		if (validFlagGroups.containsKey(flag))
+			return this.setFlagGroupOnGroup(player, flag, group, flagstate, resadmin);
+		FlagState state = FlagPermissions.stringToFlagState(flagstate);
+		if (checkCanSetFlag(player, flag, state, false, resadmin)) {
+			if (Residence.getPermissionManager().hasGroup(group)) {
+				ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag,
+						ResidenceFlagChangeEvent.FlagType.GROUP, state, group);
+				Residence.getServ().getPluginManager().callEvent(fc);
+				if (fc.isCancelled())
+					return false;
+				if (super.setGroupFlag(group, flag, state)) {
+					player.sendMessage(ChatColor.GREEN
+							+ Residence.getLanguage().getPhrase("FlagSet"));
+					return true;
+				}
+			} else {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("InvalidGroup"));
+				return false;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean setGroupFlag(String group, String flag, FlagState state) {
+		ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag,
+				ResidenceFlagChangeEvent.FlagType.GROUP, state, group);
+		Residence.getServ().getPluginManager().callEvent(fc);
+		if (fc.isCancelled())
+			return false;
+		return super.setGroupFlag(group, flag, state);
+	}
+
+	public void setOwner(String newOwner, boolean resetFlags) {
+		ResidenceOwnerChangeEvent ownerchange = new ResidenceOwnerChangeEvent(residence, newOwner);
+		Residence.getServ().getPluginManager().callEvent(ownerchange);
+		owner = newOwner;
+		if (resetFlags) {
+			this.applyDefaultFlags();
+		}
+	}
+
+	public boolean setPlayerFlag(Player player, String targetPlayer, String flag, String flagstate, boolean resadmin) {
+		if (validFlagGroups.containsKey(flag))
+			return this.setFlagGroupOnPlayer(player, targetPlayer, flag, flagstate, resadmin);
+		FlagState state = FlagPermissions.stringToFlagState(flagstate);
+		if (checkCanSetFlag(player, flag, state, false, resadmin)) {
+			ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag,
+					ResidenceFlagChangeEvent.FlagType.PLAYER, state, targetPlayer);
+			Residence.getServ().getPluginManager().callEvent(fc);
+			if (fc.isCancelled())
+				return false;
+			if (super.setPlayerFlag(targetPlayer, flag, state)) {
+				player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("FlagSet"));
+				return true;
+			}
+		}
+		return false;
+	}
+
+	@Override
+	public boolean setPlayerFlag(String player, String flag, FlagState state) {
+		ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag,
+				ResidenceFlagChangeEvent.FlagType.PLAYER, state, player);
+		Residence.getServ().getPluginManager().callEvent(fc);
+		if (fc.isCancelled())
+			return false;
+		return super.setPlayerFlag(player, flag, state);
+	}
+}

src/main/java/com/bekvon/bukkit/residence/protection/WorldFlagManager.java

@@ -0,0 +1,149 @@
+/*
+ * To change this template, choose Tools | Templates and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.protection;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+
+import com.bekvon.bukkit.residence.Residence;
+
+/**
+ *
+ * @author Administrator
+ */
+public class WorldFlagManager {
+	protected Map<String, Map<String, FlagPermissions>> groupperms;
+	protected Map<String, FlagPermissions> worldperms;
+	protected FlagPermissions globaldefaults;
+
+	public WorldFlagManager() {
+		globaldefaults = new FlagPermissions();
+		worldperms = new HashMap<String, FlagPermissions>();
+		groupperms = new HashMap<String, Map<String, FlagPermissions>>();
+	}
+
+	public WorldFlagManager(FileConfiguration config) {
+		this();
+		this.parsePerms(config);
+	}
+
+	public FlagPermissions getPerms(Player player) {
+		return this.getPerms(player.getWorld().getName(), Residence.getPermissionManager()
+				.getGroupNameByPlayer(player));
+	}
+
+	public FlagPermissions getPerms(String world) {
+		world = world.toLowerCase();
+		FlagPermissions list = worldperms.get(world);
+		if (list == null) {
+			if (globaldefaults == null)
+				return new FlagPermissions();
+			else
+				return globaldefaults;
+		}
+		return list;
+	}
+
+	public FlagPermissions getPerms(String world, String group) {
+		world = world.toLowerCase();
+		group = group.toLowerCase();
+		Map<String, FlagPermissions> groupworldperms = groupperms.get(group);
+		if (groupworldperms == null)
+			return this.getPerms(world);
+		FlagPermissions list = groupworldperms.get(world);
+		if (list == null) {
+			list = groupworldperms.get("global." + world);
+			if (list == null) {
+				list = groupworldperms.get("global");
+			}
+			if (list == null)
+				return this.getPerms(world);
+		}
+		return list;
+	}
+
+	public void parsePerms(FileConfiguration config) {
+		try {
+
+			Set<String> keys = config.getConfigurationSection("Global.Flags").getKeys(false);
+			if (keys != null) {
+				for (String key : keys) {
+					if (key.equalsIgnoreCase("Global")) {
+						globaldefaults = FlagPermissions.parseFromConfigNode(key,
+								config.getConfigurationSection("Global.Flags"));
+					} else {
+						worldperms.put(
+								key.toLowerCase(),
+								FlagPermissions.parseFromConfigNode(key,
+										config.getConfigurationSection("Global.Flags")));
+					}
+				}
+			}
+			for (Entry<String, FlagPermissions> entry : worldperms.entrySet()) {
+				entry.getValue().setParent(globaldefaults);
+			}
+			keys = config.getConfigurationSection("Groups").getKeys(false);
+			if (keys != null) {
+				for (String key : keys) {
+					ConfigurationSection worldkeylist = config.getConfigurationSection("Groups."
+							+ key + ".Flags.World");
+					if (worldkeylist != null) {
+						Set<String> worldkeys = config.getConfigurationSection(
+								"Groups." + key + ".Flags.World").getKeys(false);
+						if (worldkeys != null) {
+							Map<String, FlagPermissions> perms = new HashMap<String, FlagPermissions>();
+							for (String wkey : worldkeys) {
+								FlagPermissions list = FlagPermissions.parseFromConfigNode(
+										wkey,
+										config.getConfigurationSection("Groups." + key
+												+ ".Flags.World"));
+								if (wkey.equalsIgnoreCase("global")) {
+									list.setParent(globaldefaults);
+									perms.put(wkey.toLowerCase(), list);
+									for (Entry<String, FlagPermissions> worldperm : worldperms
+											.entrySet()) {
+										list = FlagPermissions.parseFromConfigNode(
+												wkey,
+												config.getConfigurationSection("Groups." + key
+														+ ".Flags.World"));
+										list.setParent(worldperm.getValue());
+										perms.put("global." + worldperm.getKey().toLowerCase(),
+												list);
+									}
+								} else {
+									perms.put(wkey.toLowerCase(), list);
+								}
+							}
+							for (Entry<String, FlagPermissions> entry : perms.entrySet()) {
+								String wkey = entry.getKey();
+								FlagPermissions list = entry.getValue();
+								if (!wkey.startsWith("global.")) {
+									list.setParent(perms.get("global." + wkey));
+									if (list.getParent() == null) {
+										list.setParent(worldperms.get(wkey));
+									}
+									if (list.getParent() == null) {
+										list.setParent(globaldefaults);
+									}
+								}
+							}
+							groupperms.put(key.toLowerCase(), perms);
+						}
+					}
+				}
+			}
+		} catch (Exception ex) {
+			Logger.getLogger(WorldFlagManager.class.getName()).log(Level.SEVERE, null, ex);
+		}
+	}
+}