init project...

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

src/com/bekvon/bukkit/residence/ConfigManager.java

@@ -0,0 +1,289 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.bekvon.bukkit.residence;
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.protection.FlagPermissions;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+import org.bukkit.Material;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ConfigManager {
+    protected String defaultGroup;
+    protected boolean useLeases;
+    protected boolean enableEconomy;
+    protected String economySystem;
+    protected boolean adminsOnly;
+    protected boolean allowEmptyResidences;
+    protected int infoToolId;
+    protected int selectionToolId;
+    protected boolean adminOps;
+    protected String multiworldPlugin;
+    protected boolean enableRentSystem;
+    protected boolean leaseAutoRenew;
+    protected int rentCheckInterval;
+    protected int leaseCheckInterval;
+    protected int autoSaveInt;
+    protected boolean flagsInherit;
+    protected ChatColor chatColor;
+    protected boolean chatEnable;
+    protected boolean actionBar;
+    protected int minMoveUpdate;
+    protected FlagPermissions globalCreatorDefaults;
+    protected FlagPermissions globalResidenceDefaults;
+    protected Map<String,FlagPermissions> globalGroupDefaults;
+    protected String language;
+    protected boolean preventBuildInRent;
+    protected boolean stopOnSaveError;
+    protected boolean legacyperms;
+    protected String namefix;
+    protected boolean showIntervalMessages;
+    protected boolean spoutEnable;
+    protected boolean enableLeaseMoneyAccount;
+    protected boolean enableDebug;
+    protected List<Integer> customContainers;
+    protected List<Integer> customBothClick;
+    protected List<Integer> customRightClick;
+    private boolean enforceAreaInsideArea;
+
+    public ConfigManager(FileConfiguration config)
+    {
+        globalCreatorDefaults = new FlagPermissions();
+        globalResidenceDefaults = new FlagPermissions();
+        globalGroupDefaults = new HashMap<String,FlagPermissions>();
+        this.load(config);
+    }
+
+    @SuppressWarnings("deprecation")
+	private void load(FileConfiguration config) {
+        defaultGroup = config.getString("Global.DefaultGroup", "default").toLowerCase();
+        adminsOnly = config.getBoolean("Global.AdminOnlyCommands", false);
+        useLeases = config.getBoolean("Global.UseLeaseSystem", false);
+        leaseAutoRenew = config.getBoolean("Global.LeaseAutoRenew", true);
+        enableEconomy = config.getBoolean("Global.EnableEconomy", false);
+        economySystem = config.getString("Global.EconomySystem", "iConomy");
+        infoToolId = config.getInt("Global.InfoToolId", Material.STRING.getId());
+        selectionToolId = config.getInt("Global.SelectionToolId", Material.WOOD_AXE.getId());
+        adminOps = config.getBoolean("Global.AdminOPs", true);
+        multiworldPlugin = config.getString("Global.MultiWorldPlugin");
+        enableRentSystem = config.getBoolean("Global.EnableRentSystem", false);
+        rentCheckInterval = config.getInt("Global.RentCheckInterval", 10);
+        leaseCheckInterval = config.getInt("Global.LeaseCheckInterval", 10);
+        autoSaveInt = config.getInt("Global.SaveInterval", 10);
+        flagsInherit = config.getBoolean("Global.ResidenceFlagsInherit", false);
+        minMoveUpdate = config.getInt("Global.MoveCheckInterval", 500);
+        chatEnable = config.getBoolean("Global.ResidenceChatEnable", true);
+        actionBar = config.getBoolean("Global.UseActionBar", true);
+        enforceAreaInsideArea = config.getBoolean("Global.EnforceAreaInsideArea", false);
+        language = config.getString("Global.Language","English");
+        globalCreatorDefaults = FlagPermissions.parseFromConfigNode("CreatorDefault", config.getConfigurationSection("Global"));
+        globalResidenceDefaults = FlagPermissions.parseFromConfigNode("ResidenceDefault", config.getConfigurationSection("Global"));
+        preventBuildInRent = config.getBoolean("Global.PreventRentModify", true);
+        stopOnSaveError = config.getBoolean("Global.StopOnSaveFault",true);
+        legacyperms = config.getBoolean("Global.LegacyPermissions",false);
+        namefix = config.getString("Global.ResidenceNameRegex",null);//"[^a-zA-Z0-9\\-\\_]"
+        showIntervalMessages = config.getBoolean("Global.ShowIntervalMessages", false);
+        spoutEnable = config.getBoolean("Global.EnableSpout", false);
+        enableLeaseMoneyAccount = config.getBoolean("Global.EnableLeaseMoneyAccount", true);
+        enableDebug = config.getBoolean("Global.EnableDebug", false);
+        customContainers = config.getIntegerList("Global.CustomContainers");
+        customBothClick = config.getIntegerList("Global.CustomBothClick");
+        customRightClick = config.getIntegerList("Global.CustomRightClick");
+        ConfigurationSection node = config.getConfigurationSection("Global.GroupDefault");
+        if(node!=null)
+        {
+            Set<String> keys = node.getConfigurationSection(defaultGroup).getKeys(false);
+            if(keys!=null)
+            {
+                for(String key: keys)
+                {
+                    globalGroupDefaults.put(key, FlagPermissions.parseFromConfigNode(key, config.getConfigurationSection("Global.GroupDefault")));
+                }
+            }
+        }
+        try {
+            chatColor = ChatColor.valueOf(config.getString("Global.ResidenceChatColor", "DARK_PURPLE"));
+        } catch (Exception ex) {
+            chatColor = ChatColor.DARK_PURPLE;
+        }
+    }
+
+    public boolean useLegacyPermissions()
+    {
+        return legacyperms;
+    }
+
+    public String getDefaultGroup() {
+        return defaultGroup;
+    }
+
+    public String getResidenceNameRegex()
+    {
+        return namefix;
+    }
+
+    public boolean enableEconomy() {
+        return enableEconomy && Residence.getEconomyManager()!=null;
+    }
+
+    public boolean enabledRentSystem()
+    {
+        return enableRentSystem && enableEconomy();
+    }
+
+    public boolean useLeases() {
+        return useLeases;
+    }
+
+    public boolean allowAdminsOnly() {
+        return adminsOnly;
+    }
+    public boolean allowEmptyResidences()
+    {
+        return allowEmptyResidences;
+    }
+    public int getInfoToolID()
+    {
+        return infoToolId;
+    }
+    public int getSelectionTooldID()
+    {
+        return selectionToolId;
+    }
+
+    public boolean getOpsAreAdmins()
+    {
+        return adminOps;
+    }
+
+    public String getMultiworldPlugin()
+    {
+        return multiworldPlugin;
+    }
+
+    public boolean autoRenewLeases()
+    {
+        return leaseAutoRenew;
+    }
+
+    public String getEconomySystem()
+    {
+        return economySystem;
+    }
+
+    public int getRentCheckInterval()
+    {
+        return rentCheckInterval;
+    }
+
+    public int getLeaseCheckInterval()
+    {
+        return leaseCheckInterval;
+    }
+
+    public int getAutoSaveInterval()
+    {
+        return autoSaveInt;
+    }
+
+    public boolean flagsInherit()
+    {
+        return flagsInherit;
+    }
+
+    public boolean chatEnabled()
+    {
+        return chatEnable;
+    }
+
+    public boolean useActionBar()
+    {
+        return actionBar;
+    }
+    
+    public ChatColor getChatColor()
+    {
+        return chatColor;
+    }
+
+    public int getMinMoveUpdateInterval()
+    {
+        return minMoveUpdate;
+    }
+
+    public FlagPermissions getGlobalCreatorDefaultFlags()
+    {
+        return globalCreatorDefaults;
+    }
+
+    public FlagPermissions getGlobalResidenceDefaultFlags()
+    {
+        return globalResidenceDefaults;
+    }
+
+    public Map<String,FlagPermissions> getGlobalGroupDefaultFlags()
+    {
+        return globalGroupDefaults;
+    }
+
+    public String getLanguage()
+    {
+        return language;
+    }
+
+    public boolean preventRentModify()
+    {
+        return preventBuildInRent;
+    }
+    public boolean stopOnSaveError()
+    {
+        return stopOnSaveError;
+    }
+    public boolean showIntervalMessages()
+    {
+        return showIntervalMessages;
+    }
+    public boolean enableSpout()
+    {
+        return spoutEnable;
+    }
+    public boolean enableLeaseMoneyAccount()
+    {
+        return enableLeaseMoneyAccount;
+    }
+    public boolean debugEnabled()
+    {
+        return enableDebug;
+    }
+    
+    public List<Integer> getCustomContainers()
+    {
+    	return customContainers;
+    }
+    
+    public List<Integer> getCustomBothClick()
+    {
+    	return customBothClick;
+    }
+    
+    public List<Integer> getCustomRightClick()
+    {
+    	return customRightClick;
+    }
+
+    public boolean getEnforceAreaInsideArea() {
+        return enforceAreaInsideArea;
+    }
+}

src/com/bekvon/bukkit/residence/Residence.java

@@ -0,0 +1,816 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.bekvon.bukkit.residence;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import com.bekvon.bukkit.residence.chat.ChatManager;
+import com.bekvon.bukkit.residence.config.Config;
+import com.bekvon.bukkit.residence.economy.EconomyInterface;
+import com.bekvon.bukkit.residence.economy.EssentialsEcoAdapter;
+import com.bekvon.bukkit.residence.economy.TransactionManager;
+import com.bekvon.bukkit.residence.economy.rent.RentManager;
+import com.bekvon.bukkit.residence.itemlist.WorldItemManager;
+import com.bekvon.bukkit.residence.listeners.ResidenceBlockListener;
+import com.bekvon.bukkit.residence.listeners.ResidenceEntityListener;
+import com.bekvon.bukkit.residence.listeners.ResidencePlayerListener;
+import com.bekvon.bukkit.residence.permissions.PermissionManager;
+import com.bekvon.bukkit.residence.persistance.YMLSaveHelper;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import com.bekvon.bukkit.residence.protection.FlagPermissions;
+import com.bekvon.bukkit.residence.protection.LeaseManager;
+import com.bekvon.bukkit.residence.protection.PermissionListManager;
+import com.bekvon.bukkit.residence.protection.ResidenceManager;
+import com.bekvon.bukkit.residence.protection.WorldFlagManager;
+import com.bekvon.bukkit.residence.selection.SelectionManager;
+import com.bekvon.bukkit.residence.selection.WorldEditSelectionManager;
+import com.bekvon.bukkit.residence.text.Language;
+import com.bekvon.bukkit.residence.text.help.HelpEntry;
+import com.bekvon.bukkit.residence.text.help.InformationPager;
+import com.bekvon.bukkit.residence.vaultinterface.ResidenceVaultAdapter;
+import com.earth2me.essentials.Essentials;
+import com.residence.mcstats.Metrics;
+import com.residence.zip.ZipLibrary;
+
+/**
+ * 
+ * @author Gary Smoak - bekvon
+ * 
+ */
+public class Residence extends JavaPlugin {
+
+	protected static ResidenceManager rmanager;
+	protected static SelectionManager smanager;
+	protected static PermissionManager gmanager;
+	protected static ConfigManager cmanager;
+	protected static ResidenceBlockListener blistener;
+	protected static ResidencePlayerListener plistener;
+	protected static ResidenceEntityListener elistener;
+	protected static TransactionManager tmanager;
+	protected static PermissionListManager pmanager;
+	protected static LeaseManager leasemanager;
+	protected static WorldItemManager imanager;
+	protected static WorldFlagManager wmanager;
+	protected static RentManager rentmanager;
+	protected static ChatManager chatmanager;
+	protected static Server server;
+	protected static HelpEntry helppages;
+	protected static Language language;
+	protected boolean firstenable = true;
+	protected static EconomyInterface economy;
+	public final static int saveVersion = 1;
+	protected static File dataFolder;
+	protected static int leaseBukkitId = -1;
+	protected static int rentBukkitId = -1;
+	protected static int healBukkitId = -1;
+	protected static int autosaveBukkitId = -1;
+	protected static boolean initsuccess = false;
+	protected Map<String, String> deleteConfirm;
+	protected static List<String> resadminToggle;
+	private final static String[] validLanguages = { "English", "German",
+			"French", "Hungarian", "Spanish", "Chinese", "Czech", "Brazilian",
+			"Polish" };
+	private Runnable doHeals = new Runnable() {
+		public void run() {
+			plistener.doHeals();
+		}
+	};
+	private Runnable rentExpire = new Runnable() {
+		public void run() {
+			rentmanager.checkCurrentRents();
+			if (cmanager.showIntervalMessages()) {
+				System.out.println("[Residence] - Rent Expirations checked!");
+			}
+		}
+	};
+	private Runnable leaseExpire = new Runnable() {
+		public void run() {
+			leasemanager.doExpirations();
+			if (cmanager.showIntervalMessages()) {
+				System.out.println("[Residence] - Lease Expirations checked!");
+			}
+		}
+	};
+	private Runnable autoSave = new Runnable() {
+		public void run() {
+			try {
+				if (initsuccess) {
+					saveYml();
+				}
+			} catch (Exception ex) {
+				Logger.getLogger("Minecraft").log(Level.SEVERE,
+						"[Residence] SEVERE SAVE ERROR", ex);
+			}
+		}
+	};
+
+	public Residence() {
+	}
+
+	public void reloadPlugin() {
+		this.onDisable();
+		this.reloadConfig();
+		this.onEnable();
+
+	}
+
+	@Override
+	public FileConfiguration getConfig() {
+		if(Config.getInstance()==null){
+			Config.load(this);
+		}
+		return Config.getInstance();
+	}
+	
+	@Override
+	public void saveConfig() {
+		Config.save();
+	}
+
+	@Override
+	public void reloadConfig() {
+		Config.load(this);
+	}
+	
+	@Override
+	public void onDisable() {
+		server.getScheduler().cancelTask(autosaveBukkitId);
+		server.getScheduler().cancelTask(healBukkitId);
+		if (cmanager.useLeases()) {
+			server.getScheduler().cancelTask(leaseBukkitId);
+		}
+		if (cmanager.enabledRentSystem()) {
+			server.getScheduler().cancelTask(rentBukkitId);
+		}
+		if (initsuccess) {
+			try {
+				saveYml();
+				ZipLibrary.backup();
+			} catch (Exception ex) {
+				Logger.getLogger("Minecraft").log(Level.SEVERE,
+						"[Residence] 插件数据保存失败", ex);
+			}
+			Logger.getLogger("Minecraft").log(Level.INFO,
+					"[Residence] Disabled!");
+		}
+	}
+
+	@Override
+	public void onEnable() {
+		try {
+			initsuccess = false;
+			deleteConfirm = new HashMap<String, String>();
+			resadminToggle = new ArrayList<String>();
+			server = this.getServer();
+			dataFolder = this.getDataFolder();
+			if (!dataFolder.isDirectory()) {
+				dataFolder.mkdirs();
+			}
+
+			if (!new File(dataFolder, "config.yml").isFile()) {
+				this.writeDefaultConfigFromJar();
+			}
+			if (this.getConfig().getInt("ResidenceVersion", 0) == 0) {
+				this.writeDefaultConfigFromJar();
+				this.getConfig().load("config.yml");
+				System.out
+						.println("[Residence] Config Invalid, wrote default...");
+			}
+			cmanager = new ConfigManager(this.getConfig());
+			String multiworld = cmanager.getMultiworldPlugin();
+			if (multiworld != null) {
+				Plugin plugin = server.getPluginManager().getPlugin(multiworld);
+				if (plugin != null) {
+					if (!plugin.isEnabled()) {
+						System.out
+								.println("[Residence] - Enabling multiworld plugin: "
+										+ multiworld);
+						server.getPluginManager().enablePlugin(plugin);
+					}
+				}
+			}
+			gmanager = new PermissionManager(this.getConfig());
+			imanager = new WorldItemManager(this.getConfig());
+			wmanager = new WorldFlagManager(this.getConfig());
+			chatmanager = new ChatManager();
+			rentmanager = new RentManager();
+			for (String lang : validLanguages) {
+				try {
+					if (this.checkNewLanguageVersion(lang)) {
+						this.writeDefaultLanguageFile(lang);
+					}
+				} catch (Exception ex) {
+					System.out
+							.println("[Residence] 语言文件升级失败: "
+									+ lang + ".yml");
+					helppages = new HelpEntry("");
+					language = new Language();
+				}
+			}
+			try {
+				File langFile = new File(new File(dataFolder, "Language"),
+						cmanager.getLanguage() + ".yml");
+				if (langFile.isFile()) {
+					FileConfiguration langconfig = new YamlConfiguration();
+					langconfig.load(langFile);
+					helppages = HelpEntry.parseHelp(langconfig, "CommandHelp");
+					HelpEntry.setLinesPerPage(langconfig.getInt(
+							"HelpLinesPerPage", 7));
+					InformationPager.setLinesPerPage(langconfig.getInt(
+							"HelpLinesPerPage", 7));
+					language = Language.parseText(langconfig, "Language");
+				} else {
+					System.out
+							.println("[Residence] 语言文件不存在...");
+				}
+			} catch (Exception ex) {
+				System.out.println("[Residence] 语言文件载入失败: "
+						+ cmanager.getLanguage() + ".yml, 错误: "
+						+ ex.getMessage());
+				Logger.getLogger(Residence.class.getName()).log(Level.SEVERE,
+						null, ex);
+				helppages = new HelpEntry("");
+				language = new Language();
+			}
+			economy = null;
+			if (this.getConfig().getBoolean("Global.EnableEconomy", false)) {
+				System.out
+						.println("[Residence] 扫描经济系统...");
+				if (gmanager.getPermissionsPlugin() instanceof ResidenceVaultAdapter) {
+					ResidenceVaultAdapter vault = (ResidenceVaultAdapter) gmanager
+							.getPermissionsPlugin();
+					if (vault.economyOK()) {
+						economy = vault;
+						System.out
+								.println("[Residence] 发现 Vault 使用经济系统: "
+										+ vault.getEconomyName());
+					}
+				}
+				if (economy == null) {
+					this.loadVaultEconomy();
+				}
+				if (economy == null) {
+					this.loadEssentialsEconomy();
+				}
+				if (economy == null) {
+					System.out
+							.println("[Residence] 未找到经济系统...");
+				}
+			}
+			try {
+				this.loadYml();
+			} catch (Exception e) {
+				this.getLogger().log(Level.SEVERE, "不能载入保存的文件",
+						e);
+				throw e;
+			}
+			if (rmanager == null) {
+				rmanager = new ResidenceManager();
+			}
+			if (leasemanager == null) {
+				leasemanager = new LeaseManager(rmanager);
+			}
+			if (tmanager == null) {
+				tmanager = new TransactionManager(rmanager, gmanager);
+			}
+			if (pmanager == null) {
+				pmanager = new PermissionListManager();
+			}
+			if (firstenable) {
+				if (!this.isEnabled()) {
+					return;
+				}
+				FlagPermissions.initValidFlags();
+				Plugin p = server.getPluginManager().getPlugin("WorldEdit");
+				if (p != null) {
+					smanager = new WorldEditSelectionManager(server);
+					Logger.getLogger("Minecraft").log(Level.INFO,
+							"[Residence] 发现 WorldEdit");
+				} else {
+					smanager = new SelectionManager(server);
+					Logger.getLogger("Minecraft").log(Level.INFO,
+							"[Residence] WorldEdit 未找到!");
+				}
+
+				blistener = new ResidenceBlockListener();
+				plistener = new ResidencePlayerListener();
+				elistener = new ResidenceEntityListener();
+				PluginManager pm = getServer().getPluginManager();
+				pm.registerEvents(blistener, this);
+				pm.registerEvents(plistener, this);
+				pm.registerEvents(elistener, this);
+
+				firstenable = false;
+			} else {
+				plistener.reload();
+			}
+			int autosaveInt = cmanager.getAutoSaveInterval();
+			if (autosaveInt < 1) {
+				autosaveInt = 1;
+			}
+			autosaveInt = autosaveInt * 60 * 20;
+			autosaveBukkitId = server.getScheduler().scheduleSyncRepeatingTask(
+					this, autoSave, autosaveInt, autosaveInt);
+			healBukkitId = server.getScheduler().scheduleSyncRepeatingTask(
+					this, doHeals, 20, 20);
+			if (cmanager.useLeases()) {
+				int leaseInterval = cmanager.getLeaseCheckInterval();
+				if (leaseInterval < 1) {
+					leaseInterval = 1;
+				}
+				leaseInterval = leaseInterval * 60 * 20;
+				leaseBukkitId = server.getScheduler()
+						.scheduleSyncRepeatingTask(this, leaseExpire,
+								leaseInterval, leaseInterval);
+			}
+			if (cmanager.enabledRentSystem()) {
+				int rentint = cmanager.getRentCheckInterval();
+				if (rentint < 1) {
+					rentint = 1;
+				}
+				rentint = rentint * 60 * 20;
+				rentBukkitId = server.getScheduler().scheduleSyncRepeatingTask(
+						this, rentExpire, rentint, rentint);
+			}
+			for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+				if (Residence.getPermissionManager().isResidenceAdmin(player)) {
+					turnResAdminOn(player);
+				}
+			}
+			try {
+				Metrics metrics = new Metrics(this);
+				metrics.start();
+			} catch (IOException e) {
+				// Failed to submit the stats :-(
+			}
+			Logger.getLogger("Minecraft")
+					.log(Level.INFO,
+							"[Residence] 载入完成! 版本: "
+									+ this.getDescription().getVersion()
+									+ " 重制 by 喵♂呜");
+			initsuccess = true;
+		} catch (Exception ex) {
+			initsuccess = false;
+			getServer().getPluginManager().disablePlugin(this);
+			System.out
+					.println("[Residence] - 初始化失败! 卸载插件! 错误:");
+			Logger.getLogger(Residence.class.getName()).log(Level.SEVERE, null,
+					ex);
+		}
+	}
+
+	public void consoleMessage(String message) {
+		ConsoleCommandSender console = Bukkit.getConsoleSender();
+		console.sendMessage("[Residence] " + message);
+	}
+
+	public static boolean validName(String name) {
+		if (name.contains(":") || name.contains(".")) {
+			return false;
+		}
+		if (cmanager.getResidenceNameRegex() == null) {
+			return true;
+		} else {
+			String namecheck = name.replaceAll(
+					cmanager.getResidenceNameRegex(), "");
+			if (!name.equals(namecheck)) {
+				return false;
+			}
+			return true;
+		}
+	}
+
+	public static File getDataLocation() {
+		return dataFolder;
+	}
+
+	public static ResidenceManager getResidenceManager() {
+		return rmanager;
+	}
+
+	public static SelectionManager getSelectionManager() {
+		return smanager;
+	}
+
+	public static PermissionManager getPermissionManager() {
+		return gmanager;
+	}
+
+	public static EconomyInterface getEconomyManager() {
+		return economy;
+	}
+
+	public static Server getServ() {
+		return server;
+	}
+
+	public static LeaseManager getLeaseManager() {
+		return leasemanager;
+	}
+
+	public static ConfigManager getConfigManager() {
+		return cmanager;
+	}
+
+	public static TransactionManager getTransactionManager() {
+		return tmanager;
+	}
+
+	public static WorldItemManager getItemManager() {
+		return imanager;
+	}
+
+	public static WorldFlagManager getWorldFlags() {
+		return wmanager;
+	}
+
+	public static RentManager getRentManager() {
+		return rentmanager;
+	}
+
+	public static ResidencePlayerListener getPlayerListener() {
+		return plistener;
+	}
+
+	public static ResidenceBlockListener getBlockListener() {
+		return blistener;
+	}
+
+	public static ResidenceEntityListener getEntityListener() {
+		return elistener;
+	}
+
+	public static ChatManager getChatManager() {
+		return chatmanager;
+	}
+
+	public static Language getLanguage() {
+		if (language == null) {
+			language = new Language();
+		}
+		return language;
+	}
+
+	public static FlagPermissions getPermsByLoc(Location loc) {
+		ClaimedResidence res = rmanager.getByLoc(loc);
+		if (res != null) {
+			return res.getPermissions();
+		} else {
+			return wmanager.getPerms(loc.getWorld().getName());
+		}
+	}
+
+	public static FlagPermissions getPermsByLocForPlayer(Location loc,
+			Player player) {
+		ClaimedResidence res = rmanager.getByLoc(loc);
+		if (res != null) {
+			return res.getPermissions();
+		} else {
+			if (player != null)
+				return wmanager.getPerms(player);
+			else
+				return wmanager.getPerms(loc.getWorld().getName());
+		}
+	}
+
+	private void loadEssentialsEconomy() {
+		Plugin p = getServer().getPluginManager().getPlugin("Essentials");
+		if (p != null) {
+			economy = new EssentialsEcoAdapter((Essentials) p);
+			Logger.getLogger("Minecraft").log(Level.INFO,
+					"[Residence] 成功关联Essentials Economy!");
+		} else {
+			Logger.getLogger("Minecraft").log(Level.INFO,
+					"[Residence] Essentials Economy 未找到!");
+		}
+	}
+
+	private void loadVaultEconomy() {
+		Plugin p = getServer().getPluginManager().getPlugin("Vault");
+		if (p != null) {
+			ResidenceVaultAdapter vault = new ResidenceVaultAdapter(getServer());
+			if (vault.economyOK()) {
+				Logger.getLogger("Minecraft").log(
+						Level.INFO,
+						"[Residence] 发现 Vault 使用经济系统: "
+								+ vault.getEconomyName());
+				economy = vault;
+			} else {
+				Logger.getLogger("Minecraft")
+						.log(Level.INFO,
+								"[Residence] 发现 Vault, 但是 Vault 无法使用经济系统...");
+			}
+		} else {
+			Logger.getLogger("Minecraft").log(Level.INFO,
+					"[Residence] Vault 未找到!");
+		}
+	}
+
+	public static boolean isResAdminOn(Player player) {
+		if (resadminToggle.contains(player.getName())) {
+			return true;
+		}
+		return false;
+	}
+
+	public static void turnResAdminOn(Player player) {
+		resadminToggle.add(player.getName());
+	}
+
+	public static boolean isResAdminOn(String player) {
+		if (resadminToggle.contains(player.toLowerCase())) {
+			return true;
+		}
+		return false;
+	}
+
+	private void saveYml() throws IOException {
+		File saveFolder = new File(dataFolder, "Save");
+		File worldFolder = new File(saveFolder, "Worlds");
+		worldFolder.mkdirs();
+		YMLSaveHelper yml;
+		Map<String, Object> save = rmanager.save();
+		for (Entry<String, Object> entry : save.entrySet()) {
+			File ymlSaveLoc = new File(worldFolder, "res_" + entry.getKey()
+					+ ".yml");
+			File tmpFile = new File(worldFolder, "tmp_res_" + entry.getKey()
+					+ ".yml");
+			yml = new YMLSaveHelper(tmpFile);
+			yml.getRoot().put("Version", saveVersion);
+			World world = server.getWorld(entry.getKey());
+			if (world != null)
+				yml.getRoot().put("Seed", world.getSeed());
+			yml.getRoot().put("Residences", (Map<?, ?>) entry.getValue());
+			yml.save();
+			if (ymlSaveLoc.isFile()) {
+				File backupFolder = new File(worldFolder, "Backup");
+				backupFolder.mkdirs();
+				File backupFile = new File(backupFolder, "res_"
+						+ entry.getKey() + ".yml");
+				if (backupFile.isFile()) {
+					backupFile.delete();
+				}
+				ymlSaveLoc.renameTo(backupFile);
+			}
+			tmpFile.renameTo(ymlSaveLoc);
+		}
+
+		// For Sale save
+		File ymlSaveLoc = new File(saveFolder, "forsale.yml");
+		File tmpFile = new File(saveFolder, "tmp_forsale.yml");
+		yml = new YMLSaveHelper(tmpFile);
+		yml.save();
+		yml.getRoot().put("Version", saveVersion);
+		yml.getRoot().put("Economy", tmanager.save());
+		yml.save();
+		if (ymlSaveLoc.isFile()) {
+			File backupFolder = new File(saveFolder, "Backup");
+			backupFolder.mkdirs();
+			File backupFile = new File(backupFolder, "forsale.yml");
+			if (backupFile.isFile()) {
+				backupFile.delete();
+			}
+			ymlSaveLoc.renameTo(backupFile);
+		}
+		tmpFile.renameTo(ymlSaveLoc);
+
+		// Leases save
+		ymlSaveLoc = new File(saveFolder, "leases.yml");
+		tmpFile = new File(saveFolder, "tmp_leases.yml");
+		yml = new YMLSaveHelper(tmpFile);
+		yml.getRoot().put("Version", saveVersion);
+		yml.getRoot().put("Leases", leasemanager.save());
+		yml.save();
+		if (ymlSaveLoc.isFile()) {
+			File backupFolder = new File(saveFolder, "Backup");
+			backupFolder.mkdirs();
+			File backupFile = new File(backupFolder, "leases.yml");
+			if (backupFile.isFile()) {
+				backupFile.delete();
+			}
+			ymlSaveLoc.renameTo(backupFile);
+		}
+		tmpFile.renameTo(ymlSaveLoc);
+
+		// permlist save
+		ymlSaveLoc = new File(saveFolder, "permlists.yml");
+		tmpFile = new File(saveFolder, "tmp_permlists.yml");
+		yml = new YMLSaveHelper(tmpFile);
+		yml.getRoot().put("Version", saveVersion);
+		yml.getRoot().put("PermissionLists", pmanager.save());
+		yml.save();
+		if (ymlSaveLoc.isFile()) {
+			File backupFolder = new File(saveFolder, "Backup");
+			backupFolder.mkdirs();
+			File backupFile = new File(backupFolder, "permlists.yml");
+			if (backupFile.isFile()) {
+				backupFile.delete();
+			}
+			ymlSaveLoc.renameTo(backupFile);
+		}
+		tmpFile.renameTo(ymlSaveLoc);
+
+		// rent save
+		ymlSaveLoc = new File(saveFolder, "rent.yml");
+		tmpFile = new File(saveFolder, "tmp_rent.yml");
+		yml = new YMLSaveHelper(tmpFile);
+		yml.getRoot().put("Version", saveVersion);
+		yml.getRoot().put("RentSystem", rentmanager.save());
+		yml.save();
+		if (ymlSaveLoc.isFile()) {
+			File backupFolder = new File(saveFolder, "Backup");
+			backupFolder.mkdirs();
+			File backupFile = new File(backupFolder, "rent.yml");
+			if (backupFile.isFile()) {
+				backupFile.delete();
+			}
+			ymlSaveLoc.renameTo(backupFile);
+		}
+		tmpFile.renameTo(ymlSaveLoc);
+
+		if (cmanager.showIntervalMessages()) {
+			System.out.println("[Residence] - 保存插件数据...");
+		}
+	}
+
+	@SuppressWarnings("unchecked")
+	protected boolean loadYml() throws Exception {
+		File saveFolder = new File(dataFolder, "Save");
+		try {
+			File worldFolder = new File(saveFolder, "Worlds");
+			if (!saveFolder.isDirectory()) {
+				this.getLogger().warning("保存目录不存在...");
+				this.getLogger().warning("请重新启动服务器");
+				return true;
+			}
+			YMLSaveHelper yml;
+			File loadFile;
+			HashMap<String, Object> worlds = new HashMap<String, Object>();
+			for (World world : server.getWorlds()) {
+				loadFile = new File(worldFolder, "res_" + world.getName()
+						+ ".yml");
+				if (loadFile.isFile()) {
+					yml = new YMLSaveHelper(loadFile);
+					yml.load();
+					worlds.put(world.getName(), yml.getRoot().get("Residences"));
+				}
+			}
+			rmanager = ResidenceManager.load(worlds);
+			loadFile = new File(saveFolder, "forsale.yml");
+			if (loadFile.isFile()) {
+				yml = new YMLSaveHelper(loadFile);
+				yml.load();
+				tmanager = TransactionManager.load((Map<?, ?>) yml.getRoot()
+						.get("Economy"), gmanager, rmanager);
+			}
+			loadFile = new File(saveFolder, "leases.yml");
+			if (loadFile.isFile()) {
+				yml = new YMLSaveHelper(loadFile);
+				yml.load();
+				leasemanager = LeaseManager.load((Map<String, Long>) yml
+						.getRoot().get("Leases"), rmanager);
+			}
+			loadFile = new File(saveFolder, "permlists.yml");
+			if (loadFile.isFile()) {
+				yml = new YMLSaveHelper(loadFile);
+				yml.load();
+				pmanager = PermissionListManager.load((Map<String, Object>) yml
+						.getRoot().get("PermissionLists"));
+			}
+			loadFile = new File(saveFolder, "rent.yml");
+			if (loadFile.isFile()) {
+				yml = new YMLSaveHelper(loadFile);
+				yml.load();
+				rentmanager = RentManager.load((Map<String, Object>) yml
+						.getRoot().get("RentSystem"));
+			}
+			// System.out.print("[Residence] Loaded...");
+			return true;
+		} catch (Exception ex) {
+			Logger.getLogger(Residence.class.getName()).log(Level.SEVERE, null,
+					ex);
+			throw ex;
+		}
+	}
+
+	private void writeDefaultConfigFromJar() {
+		if (this.writeDefaultFileFromJar(new File(this.getDataFolder(),
+				"config.yml"), "config.yml", true)) {
+			System.out.println("[Residence] 保存默认配置文件...");
+		}
+	}
+
+	private void writeDefaultLanguageFile(String lang) {
+		File outFile = new File(new File(this.getDataFolder(), "Language"),
+				lang + ".yml");
+		outFile.getParentFile().mkdirs();
+		if (this.writeDefaultFileFromJar(outFile, "languagefiles/" + lang
+				+ ".yml", true)) {
+			System.out.println("[Residence] 保存默认 " + lang
+					+ " 语言文件...");
+		}
+	}
+
+	private boolean checkNewLanguageVersion(String lang) throws IOException,
+			FileNotFoundException, InvalidConfigurationException {
+		File outFile = new File(new File(this.getDataFolder(), "Language"),
+				lang + ".yml");
+		File checkFile = new File(new File(this.getDataFolder(), "Language"),
+				"temp-" + lang + ".yml");
+		if (outFile.isFile()) {
+			FileConfiguration testconfig = new YamlConfiguration();
+			testconfig.load(outFile);
+			int oldversion = testconfig.getInt("FieldsVersion", 0);
+			if (!this.writeDefaultFileFromJar(checkFile, "languagefiles/"
+					+ lang + ".yml", false)) {
+				return false;
+			}
+			FileConfiguration testconfig2 = new YamlConfiguration();
+			testconfig2.load(checkFile);
+			int newversion = testconfig2.getInt("FieldsVersion", oldversion);
+			if (checkFile.isFile()) {
+				checkFile.delete();
+			}
+			if (newversion > oldversion) {
+				return true;
+			}
+			return false;
+		}
+		return true;
+	}
+
+	@SuppressWarnings("resource")
+	private boolean writeDefaultFileFromJar(File writeName, String jarPath,
+			boolean backupOld) {
+		try {
+			File fileBackup = new File(this.getDataFolder(), "backup-"
+					+ writeName);
+			File jarloc = new File(getClass().getProtectionDomain()
+					.getCodeSource().getLocation().toURI()).getCanonicalFile();
+			if (jarloc.isFile()) {
+				JarFile jar = new JarFile(jarloc);
+				JarEntry entry = jar.getJarEntry(jarPath);
+				if (entry != null && !entry.isDirectory()) {
+					InputStream in = jar.getInputStream(entry);
+					InputStreamReader isr = new InputStreamReader(in, "UTF8");
+					if (writeName.isFile()) {
+						if (backupOld) {
+							if (fileBackup.isFile()) {
+								fileBackup.delete();
+							}
+							writeName.renameTo(fileBackup);
+						} else {
+							writeName.delete();
+						}
+					}
+					FileOutputStream out = new FileOutputStream(writeName);
+					OutputStreamWriter osw = new OutputStreamWriter(out, "UTF8");
+					char[] tempbytes = new char[512];
+					int readbytes = isr.read(tempbytes, 0, 512);
+					while (readbytes > -1) {
+						osw.write(tempbytes, 0, readbytes);
+						readbytes = isr.read(tempbytes, 0, 512);
+					}
+					osw.close();
+					isr.close();
+					return true;
+				}
+			}
+			return false;
+		} catch (Exception ex) {
+			System.out
+					.println("[Residence] 文件写入失败: " + writeName);
+			return false;
+		}
+	}
+}

src/com/bekvon/bukkit/residence/chat/ChatChannel.java

@@ -0,0 +1,68 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.chat;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.event.ResidenceChatEvent;
+import java.util.ArrayList;
+import java.util.List;
+import org.bukkit.ChatColor;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ChatChannel {
+
+    protected String name;
+    protected List<String> members;
+
+    public ChatChannel(String channelName)
+    {
+        name = channelName;
+        members = new ArrayList<String>();
+    }
+
+    public void chat(String sourcePlayer, String message)
+    {
+        Server serv = Residence.getServ();
+        ChatColor color = Residence.getConfigManager().getChatColor();
+        ResidenceChatEvent cevent = new ResidenceChatEvent(Residence.getResidenceManager().getByName(name),serv.getPlayer(sourcePlayer),message,color);
+        Residence.getServ().getPluginManager().callEvent(cevent);
+        if(cevent.isCancelled())
+            return;
+        for(String member : members)
+        {
+            Player player = serv.getPlayer(member);
+            if(player!=null)
+                player.sendMessage(cevent.getColor() + sourcePlayer + ": " + cevent.getChatMessage());
+        }
+        System.out.println("ResidentialChat[" + name + "] - " + sourcePlayer + ": " + cevent.getChatMessage());
+    }
+    
+    public void join(String player)
+    {
+        if(!members.contains(player))
+            members.add(player);
+    }
+    
+    public void leave(String player)
+    {
+        members.remove(player);
+    }
+
+    public boolean hasMember(String player)
+    {
+        return members.contains(player);
+    }
+
+    public int memberCount()
+    {
+        return members.size();
+    }
+}

src/com/bekvon/bukkit/residence/chat/ChatManager.java

@@ -0,0 +1,60 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.chat;
+
+import com.bekvon.bukkit.residence.Residence;
+import java.util.HashMap;
+import java.util.Map;
+import org.bukkit.Server;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ChatManager {
+
+    protected Map<String,ChatChannel> channelmap;
+    protected Server server;
+
+    public ChatManager()
+    {
+        server = Residence.getServ();
+        channelmap = new HashMap<String,ChatChannel>();
+    }
+
+    public void setChannel(String player, String channel)
+    {
+        this.removeFromChannel(player);
+        if(!channelmap.containsKey(channel))
+            channelmap.put(channel, new ChatChannel(channel));
+        channelmap.get(channel).join(player);
+    }
+
+    public void removeFromChannel(String player)
+    {
+        for(ChatChannel chan : channelmap.values())
+        {
+            if(chan.hasMember(player))
+                chan.leave(player);
+        }
+    }
+    
+    public ChatChannel getChannel(String channel)
+    {
+        return channelmap.get(channel);
+    }
+
+    public ChatChannel getPlayerChannel(String player)
+    {
+        for(ChatChannel chan : channelmap.values())
+        {
+            if(chan.hasMember(player))
+                return chan;
+        }
+        return null;
+    }
+
+}

src/com/bekvon/bukkit/residence/config/Config.java

@@ -0,0 +1,55 @@
+package com.bekvon.bukkit.residence.config;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.bukkit.plugin.Plugin;
+
+public class Config extends ConfigLoader {
+	private static String CONFIG_NAME = "config.yml";
+	private static FileConfig instance;
+	private static File file;
+	
+	public Config(Plugin p) {
+		super(p, CONFIG_NAME);
+		file = new File(p.getDataFolder(), CONFIG_NAME);
+		instance = super.getInstance();
+	}
+
+	public Config(Plugin p, String ver) {
+		super(p, CONFIG_NAME, ver);
+		instance = super.getInstance();
+	}
+	
+	public static void load(Plugin p) {
+		new Config(p);
+	}
+
+	public static void load(Plugin p, String ver) {
+		new Config(p, ver);
+	}
+	
+	public static FileConfig getInstance() {
+		return instance;
+	}
+
+	public static String getMessage(String path) {
+		String message = instance.getString(path);
+		if (message != null)
+			message = message.replaceAll("&", "§");
+		return message;
+	}
+
+	public static String[] getStringArray(String path) {
+		return instance.getStringList(path).toArray(new String[0]);
+	}
+	
+	public static void save(){
+		try {
+			instance.save(file);
+		} catch (IOException e) {
+			saveError(file);
+			e.printStackTrace();
+		}
+	}
+}

src/com/bekvon/bukkit/residence/config/ConfigLoader.java

@@ -0,0 +1,102 @@
+package com.bekvon.bukkit.residence.config;
+
+import java.io.File;
+import java.io.IOException;
+
+import org.bukkit.plugin.Plugin;
+
+public class ConfigLoader extends FileConfig {
+	protected static FileConfig config;
+	protected static boolean tip = true;
+	protected static Plugin plugin;
+
+	public ConfigLoader(Plugin p, File file) {
+		ConfigLoader.plugin = p;
+		config = loadConfig(p, file, null, true);
+	}
+
+	public ConfigLoader(Plugin p, File file, boolean res) {
+		ConfigLoader.plugin = p;
+		config = loadConfig(p, file, null, res);
+	}
+
+	public ConfigLoader(Plugin p, File file, String ver) {
+		ConfigLoader.plugin = p;
+		config = loadConfig(p, file, ver, true);
+	}
+
+	public ConfigLoader(Plugin p, File file, String ver, boolean res) {
+		ConfigLoader.plugin = p;
+		config = loadConfig(p, file, ver, res);
+	}
+
+	public ConfigLoader(Plugin p, String filename) {
+		ConfigLoader.plugin = p;
+		config = loadConfig(p, new File(p.getDataFolder(), filename), null,
+				true);
+	}
+
+	public ConfigLoader(Plugin p, String filename, boolean res) {
+		ConfigLoader.plugin = p;
+		config = loadConfig(p, new File(p.getDataFolder(), filename), null, res);
+	}
+
+	public ConfigLoader(Plugin p, String filename, String ver) {
+		ConfigLoader.plugin = p;
+		config = loadConfig(p, new File(p.getDataFolder(), filename), ver, true);
+	}
+
+	public ConfigLoader(Plugin p, String filename, String ver, boolean res) {
+		ConfigLoader.plugin = p;
+		config = loadConfig(p, new File(p.getDataFolder(), filename), ver, true);
+	}
+
+	public static FileConfig getInstance() {
+		return config;
+	}
+
+	public FileConfig loadConfig(Plugin p, File file, String ver, boolean res) {
+		tip = res ;
+		if (!file.getParentFile().exists()) {
+			file.getParentFile().mkdirs();
+			p.getLogger().info("创建新的文件夹" + file.getParentFile().getAbsolutePath() + "...");
+		}
+		if (!file.exists()) {
+			fileCreate(p, file, res);
+		} else {
+			if (ver != null) {
+				FileConfig configcheck = init(file);
+				String version = configcheck.getString("version");
+				if (version == null || !version.equals(ver)) {
+					p.saveResource(file.getName(), true);
+					p.getLogger().warning(
+								"配置文件: " + file.getName() + " 版本过低 正在升级...");
+				}
+			}
+		}
+		if (tip)
+			p.getLogger().info(
+					"载入配置文件: " + file.getName()
+							+ (ver != null ? " 版本: " + ver : ""));
+		return init(file);
+	}
+
+	private void fileCreate(Plugin p, File file, boolean res) {
+		if (res) {
+			p.saveResource(file.getName(), false);
+		} else {
+			try {
+				p.getLogger().info("创建新的配置文件" + file.getAbsolutePath() + "...");
+				file.createNewFile();
+			} catch (IOException e) {
+				p.getLogger().info("配置文件" + file.getName() + "创建失败...");
+				e.printStackTrace();
+			}
+		}
+	}
+
+	public static void saveError(File file) {
+		plugin.getLogger().info("配置文件" + file.getName() + "保存错误...");
+	}
+
+}

src/com/bekvon/bukkit/residence/config/FileConfig.java

@@ -0,0 +1,88 @@
+package com.bekvon.bukkit.residence.config;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.Writer;
+import java.util.logging.Level;
+
+import org.apache.commons.lang.Validate;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.Configuration;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.configuration.file.YamlConstructor;
+import org.bukkit.configuration.file.YamlRepresenter;
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.Yaml;
+import org.yaml.snakeyaml.representer.Representer;
+
+import com.google.common.base.Charsets;
+import com.google.common.io.Files;
+
+/**
+ * An implementation of {@link Configuration} which saves all files in Yaml.
+ * Note that this implementation is not synchronized.
+ */
+public class FileConfig extends YamlConfiguration {
+
+	protected final DumperOptions yamlOptions = new DumperOptions();
+	protected final Representer yamlRepresenter = new YamlRepresenter();
+	protected final Yaml yaml = new Yaml(new YamlConstructor(),
+			yamlRepresenter, yamlOptions);
+
+	public static FileConfig init(File file) {
+		return FileConfig.loadConfiguration(file);
+	}
+
+	public static FileConfig loadConfiguration(File file) {
+		Validate.notNull(file, "File cannot be null");
+		FileConfig config = new FileConfig();
+		try {
+			config.load(file);
+		} catch (FileNotFoundException ex) {
+		} catch (IOException ex) {
+			Bukkit.getLogger().log(Level.SEVERE, "Cannot load " + file, ex);
+		} catch (InvalidConfigurationException ex) {
+			Bukkit.getLogger().log(Level.SEVERE, "Cannot load " + file, ex);
+		}
+		return config;
+	}
+
+	@Override
+	public String saveToString() {
+		yamlOptions.setIndent(options().indent());
+		yamlOptions.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+		yamlRepresenter.setDefaultFlowStyle(DumperOptions.FlowStyle.BLOCK);
+		String header = buildHeader();
+		String dump = yaml.dump(getValues(false));
+		if (dump.equals(BLANK_CONFIG)) {
+			dump = "";
+		}
+		return header + dump;
+	}
+
+	public void load(File file) throws FileNotFoundException, IOException,
+			InvalidConfigurationException {
+		Validate.notNull(file, "File cannot be null");
+		final FileInputStream stream = new FileInputStream(file);
+		load(new InputStreamReader(stream, Charsets.UTF_8));
+	}
+
+	public void save(File file) throws IOException {
+		Validate.notNull(file, "File cannot be null");
+		Files.createParentDirs(file);
+		String data = saveToString();
+		Writer writer = new OutputStreamWriter(new FileOutputStream(file),
+				Charsets.UTF_8);
+		try {
+			writer.write(data);
+		} finally {
+			writer.close();
+		}
+	}
+}

src/com/bekvon/bukkit/residence/economy/EconomyInterface.java

@@ -0,0 +1,10 @@
+package com.bekvon.bukkit.residence.economy;
+
+public interface EconomyInterface {
+    public double getBalance(String playerName);
+    public boolean canAfford(String playerName, double amount);
+    public boolean add(String playerName, double amount);
+    public boolean subtract(String playerName, double amount);
+    public boolean transfer(String playerFrom, String playerTo, double amount);
+    public String getName();
+}

src/com/bekvon/bukkit/residence/economy/EssentialsEcoAdapter.java

@@ -0,0 +1,109 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.economy;
+
+import com.earth2me.essentials.Essentials;
+import com.earth2me.essentials.api.Economy;
+import com.earth2me.essentials.api.NoLoanPermittedException;
+import com.earth2me.essentials.api.UserDoesNotExistException;
+
+/**
+ * 
+ * @author Administrator
+ */
+public class EssentialsEcoAdapter implements EconomyInterface {
+
+    Essentials plugin;
+
+    public EssentialsEcoAdapter(Essentials p) {
+        plugin = p;
+        String serverland = "Server Land";
+        if (!Economy.playerExists(serverland)) {
+            Economy.createNPC(serverland);
+        }
+    }
+
+    @Override
+    public double getBalance(String playerName) {
+        try {
+            if (Economy.playerExists(playerName)) {
+                return Economy.getMoney(playerName);
+            } else {
+                return 0;
+            }
+        } catch (UserDoesNotExistException ex) {
+            return 0;
+        }
+    }
+
+    @Override
+    public boolean canAfford(String playerName, double amount) {
+        try {
+            if (Economy.playerExists(playerName)) {
+                return Economy.hasEnough(playerName, amount);
+            }
+            return false;
+        } catch (UserDoesNotExistException ex) {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean add(String playerName, double amount) {
+        if (Economy.playerExists(playerName)) {
+            try {
+                Economy.add(playerName, amount);
+                return true;
+            } catch (UserDoesNotExistException ex) {
+                return false;
+            } catch (NoLoanPermittedException ex) {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean subtract(String playerName, double amount) {
+        if (Economy.playerExists(playerName)) {
+            try {
+                Economy.subtract(playerName, amount);
+                return true;
+            } catch (UserDoesNotExistException ex) {
+                return false;
+            } catch (NoLoanPermittedException ex) {
+                return false;
+            }
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean transfer(String playerFrom, String playerTo, double amount) {
+        try {
+            if (Economy.playerExists(playerFrom) && Economy.playerExists(playerTo) && Economy.hasEnough(playerFrom, amount)) {
+                if (!subtract(playerFrom, amount))
+                    return false;
+                if (!add(playerTo, amount)) {
+                    add(playerFrom, amount);
+                    return false;
+                }
+                return true;
+            }
+        } catch (UserDoesNotExistException ex) {
+            return false;
+        }
+        return false;
+    }
+
+    @Override
+    public String getName() {
+        return "EssentialsEconomy";
+    }
+
+}

src/com/bekvon/bukkit/residence/economy/ResidenceBank.java

@@ -0,0 +1,101 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.economy;
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceBank {
+    int storedMoney;
+    ClaimedResidence res;
+
+    public ResidenceBank(ClaimedResidence parent)
+    {
+        storedMoney = 0;
+        res = parent;
+    }
+
+    public int getStoredMoney()
+    {
+        return storedMoney;
+    }
+
+    public void setStoredMoney(int amount)
+    {
+        storedMoney = amount;
+    }
+
+    public void add(int amount)
+    {
+        storedMoney = storedMoney + amount;
+    }
+
+    public boolean hasEnough(int amount)
+    {
+        if(storedMoney >= amount)
+            return true;
+        return false;
+    }
+
+    public void subtract(int amount)
+    {
+        storedMoney = storedMoney - amount;
+        if(storedMoney<0)
+            storedMoney = 0;
+    }
+
+    public void withdraw(Player player, int amount, boolean resadmin)
+    {
+        if(!Residence.getConfigManager().enableEconomy())
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("MarketDisabled"));
+        }
+        if(!resadmin && !res.getPermissions().playerHas(player.getName(), "bank", false))
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoBankAccess"));
+            return;
+        }
+        if(!hasEnough(amount))
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("BankNoMoney"));
+            return;
+        }
+        if(Residence.getEconomyManager().add(player.getName(), amount))
+        {
+            this.subtract(amount);
+            player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("BankWithdraw",ChatColor.YELLOW + String.format("%d",amount) + ChatColor.GREEN));
+        }
+    }
+
+    public void deposit(Player player, int amount, boolean resadmin)
+    {
+        if(!Residence.getConfigManager().enableEconomy())
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("MarketDisabled"));
+        }
+        if(!resadmin && !res.getPermissions().playerHas(player.getName(), "bank", false))
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoBankAccess"));
+            return;
+        }
+        if(!Residence.getEconomyManager().canAfford(player.getName(), amount))
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NotEnoughMoney"));
+            return;
+        }
+        if(Residence.getEconomyManager().subtract(player.getName(), amount))
+        {
+            this.add(amount);
+            player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("BankDeposit",ChatColor.YELLOW + String.format("%d",amount) + ChatColor.GREEN));
+        }
+    }
+}

src/com/bekvon/bukkit/residence/economy/TransactionManager.java

@@ -0,0 +1,266 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.economy;
+
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.protection.CuboidArea;
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.ResidenceManager;
+import com.bekvon.bukkit.residence.permissions.PermissionManager;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+/**
+ * 
+ * @author Administrator
+ */
+public class TransactionManager {
+    ResidenceManager manager;
+    private Map<String, Integer> sellAmount;
+    PermissionManager gm;
+
+    public static boolean chargeEconomyMoney(Player player, int amount) {
+        EconomyInterface econ = Residence.getEconomyManager();
+        if (econ == null) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("MarketDisabled"));
+            return false;
+        }
+        if (!econ.canAfford(player.getName(), amount)) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NotEnoughMoney"));
+            return false;
+        }
+        econ.subtract(player.getName(), amount);
+        player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("MoneyCharged", ChatColor.YELLOW + String.format("%d", amount) + ChatColor.GREEN + "." + ChatColor.YELLOW + econ.getName() + ChatColor.GREEN));
+        return true;
+    }
+
+    public TransactionManager(ResidenceManager m, PermissionManager g) {
+        gm = g;
+        manager = m;
+        sellAmount = Collections.synchronizedMap(new HashMap<String, Integer>());
+    }
+
+    public void putForSale(String areaname, Player player, int amount, boolean resadmin) {
+        if (Residence.getConfigManager().enabledRentSystem()) {
+            if (Residence.getRentManager().isForRent(areaname)) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("RentSellFail"));
+                return;
+            }
+        }
+        if (!resadmin) {
+            if (!Residence.getConfigManager().enableEconomy() || Residence.getEconomyManager() == null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("MarketDisabled"));
+                return;
+            }
+            boolean cansell = Residence.getPermissionManager().getGroup(player).canSellLand() || player.hasPermission("residence.sell");
+            if (!cansell && !resadmin) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+                return;
+            }
+            if (amount <= 0) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidAmount"));
+                return;
+            }
+        }
+        String pname = player.getName();
+        ClaimedResidence area = manager.getByName(areaname);
+        if (area == null) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidResidence"));
+            return;
+        }
+        if (!area.getPermissions().getOwner().equals(pname) && !resadmin) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+            return;
+        }
+        if (sellAmount.containsKey(areaname)) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AlreadySellFail"));
+            return;
+        }
+        sellAmount.put(areaname, amount);
+        player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("ResidenceForSale", ChatColor.YELLOW + areaname + ChatColor.GREEN + "." + ChatColor.YELLOW + amount + ChatColor.GREEN));
+    }
+
+    public boolean putForSale(String areaname, int amount) {
+        if (Residence.getConfigManager().enabledRentSystem()) {
+            if (Residence.getRentManager().isForRent(areaname)) {
+                return false;
+            }
+        }
+        ClaimedResidence area = manager.getByName(areaname);
+        if (area == null) {
+            return false;
+        }
+        if (sellAmount.containsKey(areaname)) {
+            return false;
+        }
+        sellAmount.put(areaname, amount);
+        return true;
+    }
+
+    public void buyPlot(String areaname, Player player, boolean resadmin) {
+        PermissionGroup group = gm.getGroup(player);
+        if (!resadmin) {
+            if (!Residence.getConfigManager().enableEconomy() || Residence.getEconomyManager() == null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("MarketDisabled"));
+                return;
+            }
+            boolean canbuy = group.canBuyLand() || player.hasPermission("residence.buy");
+            if (!canbuy && !resadmin) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+                return;
+            }
+        }
+        if (isForSale(areaname)) {
+            ClaimedResidence res = manager.getByName(areaname);
+            if (res == null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidArea"));
+                sellAmount.remove(areaname);
+                return;
+            }
+            if (res.getPermissions().getOwner().equals(player.getName())) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("OwnerBuyFail"));
+                return;
+            }
+            if (Residence.getResidenceManager().getOwnedZoneCount(player.getName()) >= group.getMaxZones() && !resadmin) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ResidenceTooMany"));
+                return;
+            }
+            Server serv = Residence.getServ();
+            int amount = sellAmount.get(areaname);
+            if (!resadmin) {
+                if (!group.buyLandIgnoreLimits()) {
+                    CuboidArea[] areas = res.getAreaArray();
+                    for (CuboidArea thisarea : areas) {
+                        if (!group.inLimits(thisarea)) {
+                            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ResidenceBuyTooBig"));
+                            return;
+                        }
+                    }
+                }
+            }
+            EconomyInterface econ = Residence.getEconomyManager();
+            if (econ == null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("MarketDisabled"));
+                return;
+            }
+            String buyerName = player.getName();
+            String sellerName = res.getPermissions().getOwner();
+            Player sellerNameFix = Residence.getServ().getPlayer(sellerName);
+            if (sellerNameFix != null) {
+                sellerName = sellerNameFix.getName();
+            }
+            if (econ.canAfford(buyerName, amount)) {
+                if (!econ.transfer(buyerName, sellerName, amount)) {
+                    player.sendMessage(ChatColor.RED + "Error, could not transfer " + amount + " from " + buyerName + " to " + sellerName);
+                    return;
+                }
+                res.getPermissions().setOwner(player.getName(), true);
+                res.getPermissions().applyDefaultFlags();
+                this.removeFromSale(areaname);
+                player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("MoneyCharged", ChatColor.YELLOW + String.format("%d", amount) + ChatColor.GREEN + "." + ChatColor.YELLOW + econ.getName() + ChatColor.GREEN));
+                player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("ResidenceBought", ChatColor.GREEN + areaname + ChatColor.YELLOW));
+                Player seller = serv.getPlayer(sellerName);
+                if (seller != null && seller.isOnline()) {
+                    seller.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("ResidenceBuy", ChatColor.YELLOW + player.getName() + ChatColor.GREEN + "." + ChatColor.YELLOW + areaname + ChatColor.GREEN));
+                    seller.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("MoneyCredit", ChatColor.YELLOW + String.format("%d", amount) + ChatColor.GREEN + "." + ChatColor.YELLOW + econ.getName() + ChatColor.GREEN));
+                }
+            } else {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NotEnoughMoney"));
+            }
+        } else {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidResidence"));
+        }
+    }
+
+    public void removeFromSale(Player player, String areaname, boolean resadmin) {
+        ClaimedResidence area = manager.getByName(areaname);
+        if (area != null) {
+            if (!isForSale(areaname)) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ResidenceNotForSale"));
+                return;
+            }
+            if (area.getPermissions().getOwner().equals(player.getName()) || resadmin) {
+                removeFromSale(areaname);
+                player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("ResidenceStopSelling"));
+            } else {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+            }
+        } else {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidArea"));
+        }
+    }
+
+    public void removeFromSale(String areaname) {
+        sellAmount.remove(areaname);
+    }
+
+    public boolean isForSale(String areaname) {
+        return sellAmount.containsKey(areaname);
+    }
+
+    public void viewSaleInfo(String areaname, Player player) {
+        if (sellAmount.containsKey(areaname)) {
+            player.sendMessage("------------------------");
+            player.sendMessage(ChatColor.YELLOW + "Name:" + ChatColor.DARK_GREEN + " " + areaname);
+            player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("SellAmount") + ":" + ChatColor.RED + " " + sellAmount.get(areaname));
+            if (Residence.getConfigManager().useLeases()) {
+                Date etime = Residence.getLeaseManager().getExpireTime(areaname);
+                if (etime != null) {
+                    player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("LeaseExpire") + ":" + ChatColor.GREEN + " " + etime.toString());
+                }
+            }
+            player.sendMessage("------------------------");
+        }
+    }
+
+    public void printForSaleResidences(Player player) {
+        Set<Entry<String, Integer>> set = sellAmount.entrySet();
+        player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("LandForSale") + ":");
+        StringBuilder sbuild = new StringBuilder();
+        sbuild.append(ChatColor.GREEN);
+        boolean firstadd = true;
+        for (Entry<String, Integer> land : set) {
+            if (!firstadd) {
+                sbuild.append(", ");
+            } else {
+                firstadd = false;
+            }
+            sbuild.append(land.getKey());
+        }
+        player.sendMessage(sbuild.toString());
+    }
+
+    public void clearSales() {
+        sellAmount.clear();
+        System.out.println("[Residence] - ReInit land selling.");
+    }
+
+    public int getSaleAmount(String name) {
+        return sellAmount.get(name);
+    }
+
+    public Map<String, Integer> save() {
+        return sellAmount;
+    }
+
+    @SuppressWarnings({ "unchecked", "rawtypes" })
+    public static TransactionManager load(Map root, PermissionManager p, ResidenceManager r) {
+        TransactionManager tman = new TransactionManager(r, p);
+        if (root != null) {
+            tman.sellAmount = root;
+        }
+        return tman;
+    }
+}

src/com/bekvon/bukkit/residence/economy/rent/RentManager.java

@@ -0,0 +1,499 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.economy.rent;
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.event.ResidenceRentEvent;
+import com.bekvon.bukkit.residence.event.ResidenceRentEvent.RentEventType;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import com.bekvon.bukkit.residence.protection.FlagPermissions.FlagState;
+
+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 RentManager {
+    protected Map<String,RentedLand> rentedLand;
+    protected Map<String,RentableLand> rentableLand;
+
+    public RentManager()
+    {
+        rentedLand = new HashMap<String,RentedLand>();
+        rentableLand = new HashMap<String,RentableLand>();
+    }
+
+    public void setForRent(Player player, String landName, int amount, int days, boolean repeatable, boolean resadmin)
+    {
+        if(!Residence.getConfigManager().enabledRentSystem())
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("MarketDisabled"));
+            return;
+        }
+        if(Residence.getTransactionManager().isForSale(landName))
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("SellRentFail"));
+            return;
+        }
+        ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
+        if(res == null)
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidResidence"));
+            return;
+        }
+        if(!resadmin)
+        {
+            if(!res.getPermissions().hasResidencePermission(player, true))
+            {
+                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoPermission"));
+                return;
+            }
+            PermissionGroup group = Residence.getPermissionManager().getGroup(player);
+            if(this.getRentableCount(player.getName()) >= group.getMaxRentables())
+            {
+                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceMaxRent"));
+                return;
+            }
+        }
+        if(!rentableLand.containsKey(landName))
+        {
+            ResidenceRentEvent revent = new ResidenceRentEvent(res,player,RentEventType.RENTABLE);
+            Residence.getServ().getPluginManager().callEvent(revent);
+            if(revent.isCancelled())
+                return;
+            RentableLand newrent = new RentableLand();
+            newrent.days = days;
+            newrent.cost = amount;
+            newrent.repeatable = repeatable;
+            rentableLand.put(landName,newrent);
+            String[] split = landName.split("\\.");
+            if(split.length!=0)
+                player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("ResidenceForRentSuccess",ChatColor.YELLOW+split[split.length-1] + ChatColor.GREEN+"."+ChatColor.YELLOW+amount+ChatColor.GREEN+"."+ChatColor.YELLOW+days+ChatColor.GREEN));
+        }
+        else
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceAlreadyRent"));
+        }
+    }
+
+    public void rent(Player player, String landName, boolean repeat, boolean resadmin)
+    {
+        if(!Residence.getConfigManager().enabledRentSystem())
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("RentDisabled"));
+            return;
+        }
+        ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
+        if(res!=null)
+        {
+            if(res.getPermissions().getOwner().equalsIgnoreCase(player.getName()))
+            {
+                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("OwnerRentFail"));
+                return;
+            }
+        }
+        else
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidResidence"));
+            return;
+        }
+        PermissionGroup group = Residence.getPermissionManager().getGroup(player);
+        if(!resadmin && this.getRentCount(player.getName()) >= group.getMaxRents())
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceMaxRent"));
+            return;
+        }
+        if(!this.isForRent(landName))
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceNotForRent"));
+            return;
+        }
+        if(this.isRented(landName))
+        {
+            String[] split = landName.split("\\.");
+            if(split.length!=0)
+                player.sendMessage(Residence.getLanguage().getPhrase("ResidenceAlreadyRented",ChatColor.YELLOW+split[split.length-1] + ChatColor.RED+"."+ChatColor.YELLOW + this.getRentingPlayer(landName)));
+            return;
+        }
+        RentableLand land = rentableLand.get(landName);
+        if(Residence.getEconomyManager().canAfford(player.getName(), land.cost))
+        {
+            ResidenceRentEvent revent = new ResidenceRentEvent(res,player,RentEventType.RENT);
+            Residence.getServ().getPluginManager().callEvent(revent);
+            if(revent.isCancelled())
+                return;
+            if(Residence.getEconomyManager().transfer(player.getName(), res.getPermissions().getOwner(), land.cost))
+            {
+                RentedLand newrent = new RentedLand();
+                newrent.player = player.getName();
+                newrent.startTime = System.currentTimeMillis();
+                newrent.endTime = System.currentTimeMillis() + daysToMs(land.days);
+                newrent.autoRefresh = repeat;
+                rentedLand.put(landName, newrent);
+                res.getPermissions().copyUserPermissions(res.getPermissions().getOwner(), player.getName());
+                res.getPermissions().clearPlayersFlags(res.getPermissions().getOwner());
+                res.getPermissions().setPlayerFlag(player.getName(), "admin", FlagState.TRUE);
+                String[] split = landName.split("\\.");
+                if(split.length!=0)
+                    player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("ResidenceRentSuccess",ChatColor.YELLOW + split[split.length-1] + ChatColor.GREEN+"."+ChatColor.YELLOW + land.days + ChatColor.GREEN));
+            }
+            else
+            {
+                player.sendMessage(ChatColor.RED+"Error, unable to transfer money...");
+            }
+        }
+        else
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NotEnoughMoney"));
+        }
+    }
+
+    public void removeFromForRent(Player player, String landName, boolean resadmin)
+    {
+        RentedLand rent = rentedLand.get(landName);
+        if(rent == null)
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceNotRented"));
+            return;
+        }
+        if(resadmin || rent.player.equalsIgnoreCase(player.getName()))
+        {
+            ResidenceRentEvent revent = new ResidenceRentEvent(Residence.getResidenceManager().getByName(landName),player,RentEventType.UNRENTABLE);
+            Residence.getServ().getPluginManager().callEvent(revent);
+            if(revent.isCancelled())
+                return;
+            rentedLand.remove(landName);
+            if(!rentableLand.get(landName).repeatable)
+            {
+                rentableLand.remove(landName);
+            }
+            ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
+            if(res!=null)
+                res.getPermissions().applyDefaultFlags();
+            player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("ResidenceUnrent",ChatColor.YELLOW+landName + ChatColor.GREEN));
+        }
+        else
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoPermission"));
+        }
+    }
+
+    private long daysToMs(int days)
+    {
+        return (((long)days) * 24L * 60L * 60L * 1000L);
+    }
+
+    @SuppressWarnings("unused")
+	private int msToDays(long ms)
+    {
+        return (int) Math.ceil(((((double)ms/1000D)/60D)/60D)/24D);
+    }
+
+    public void unrent(Player player, String landName, boolean resadmin)
+    {
+        String[] split = landName.split("\\.");
+        ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
+        if(res == null)
+        {
+            player.sendMessage(ChatColor.YELLOW+Residence.getLanguage().getPhrase("InvalidResidence"));
+            return;
+        }
+        if(!res.getPermissions().hasResidencePermission(player, true) && !resadmin)
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoPermission"));
+            return;
+        }
+        if(rentedLand.containsKey(landName) && !resadmin)
+        {
+            if(split.length!=0)
+                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceAlreadyRented",ChatColor.YELLOW+split[split.length-1] + ChatColor.RED+"."+ChatColor.YELLOW + rentedLand.get(landName).player)+ChatColor.YELLOW);
+            return;
+        }
+        if(rentableLand.containsKey(landName))
+        {
+            ResidenceRentEvent revent = new ResidenceRentEvent(res,player,RentEventType.UNRENT);
+            Residence.getServ().getPluginManager().callEvent(revent);
+            if(revent.isCancelled())
+                return;
+            rentableLand.remove(landName);
+            if(rentedLand.containsKey(landName))
+            {
+                rentedLand.remove(landName);
+                if(res!=null)
+                    res.getPermissions().applyDefaultFlags();
+            }
+            if(split.length!=0)
+                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceRemoveRentable",ChatColor.YELLOW+split[split.length-1] + ChatColor.RED));
+
+        }
+        else
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceNotForRent"));
+        }
+    }
+
+    public void removeFromRent(String landName)
+    {
+        rentedLand.remove(landName);
+    }
+
+    public void removeRentable(String landName)
+    {
+        removeFromRent(landName);
+        rentableLand.remove(landName);
+    }
+
+    public boolean isForRent(String landName)
+    {
+        return rentableLand.containsKey(landName);
+    }
+
+    public boolean isRented(String landName)
+    {
+        return rentedLand.containsKey(landName);
+    }
+
+    public String getRentingPlayer(String landName)
+    {
+        return rentedLand.containsKey(landName) ? rentedLand.get(landName).player : null;
+    }
+
+    public int getCostOfRent(String landName)
+    {
+        return rentableLand.containsKey(landName) ? rentableLand.get(landName).cost : 0;
+    }
+
+    public boolean getRentableRepeatable(String landName)
+    {
+        return rentableLand.containsKey(landName) ? rentableLand.get(landName).repeatable : false;
+    }
+
+    public boolean getRentedAutoRepeats(String landName)
+    {
+        return getRentableRepeatable(landName) ? (rentedLand.containsKey(landName) ? rentedLand.get(landName).autoRefresh : false) : false;
+    }
+
+    public int getRentDays(String landName)
+    {
+        return rentableLand.containsKey(landName) ? rentableLand.get(landName).days : 0;
+    }
+
+    public void checkCurrentRents()
+    {
+        Iterator<Entry<String, RentedLand>> it = rentedLand.entrySet().iterator();
+        while(it.hasNext())
+        {
+            Entry<String, RentedLand> next = it.next();
+            RentedLand land = next.getValue();
+            if(land.endTime<=System.currentTimeMillis())
+            {
+                ClaimedResidence res = Residence.getResidenceManager().getByName(next.getKey());
+                if(Residence.getConfigManager().debugEnabled())
+                    System.out.println("Rent Check: "+next.getKey());
+                if (res != null) {
+                    ResidenceRentEvent revent = new ResidenceRentEvent(res, null, RentEventType.RENT_EXPIRE);
+                    Residence.getServ().getPluginManager().callEvent(revent);
+                    if (!revent.isCancelled()) {
+                        RentableLand rentable = rentableLand.get(next.getKey());
+                        if (!rentable.repeatable) {
+                            rentableLand.remove(next.getKey());
+                            it.remove();
+                            res.getPermissions().applyDefaultFlags();
+                        } else if (land.autoRefresh) {
+                            if (!Residence.getEconomyManager().canAfford(land.player, rentable.cost)) {
+                                it.remove();
+                                res.getPermissions().applyDefaultFlags();
+                            } else {
+                                if (!Residence.getEconomyManager().transfer(land.player, res.getPermissions().getOwner(), rentable.cost)) {
+                                    it.remove();
+                                    res.getPermissions().applyDefaultFlags();
+                                }
+                                else
+                                {
+                                    land.endTime = System.currentTimeMillis() + this.daysToMs(rentable.days);
+                                }
+                            }
+                        } else {
+                            res.getPermissions().applyDefaultFlags();
+                            it.remove();
+                        }
+                    }
+                }
+                else
+                {
+                    rentableLand.remove(next.getKey());
+                    it.remove();
+                }
+            }
+        }
+    }
+
+    public void setRentRepeatable(Player player, String landName, boolean value, boolean resadmin)
+    {
+        String[] split = landName.split("\\.");
+        RentableLand land = rentableLand.get(landName);
+        ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
+        if(land!=null && res!=null && (res.getPermissions().getOwner().equalsIgnoreCase(player.getName()) || resadmin))
+        {
+            land.repeatable = value;
+            if(!value && this.isRented(landName))
+                rentedLand.get(landName).autoRefresh = false;
+            if(value && split.length!=0)
+                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("RentableEnableRenew",ChatColor.YELLOW+split[split.length-1] + ChatColor.RED));
+            else if(split.length!=0)
+                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("RentableDisableRenew",ChatColor.YELLOW+split[split.length-1] + ChatColor.RED));
+        }
+    }
+
+    public void setRentedRepeatable(Player player, String landName, boolean value, boolean resadmin)
+    {
+        String[] split = landName.split("\\.");
+        RentedLand land = rentedLand.get(landName);
+        if(land!=null && (land.player.equals(player.getName()) || resadmin))
+        {
+            land.autoRefresh = value;
+            if(value && split.length!=0)
+                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("RentEnableRenew",ChatColor.YELLOW+split[split.length-1] + ChatColor.RED));
+            else if(split.length!=0)
+                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("RentDisableRenew",ChatColor.YELLOW+split[split.length-1] + ChatColor.RED));
+        }
+    }
+
+    public void printRentInfo(Player player, String landName)
+    {
+        RentableLand rentable = rentableLand.get(landName);
+        RentedLand rented = rentedLand.get(landName);
+        if(rentable!=null)
+        {
+            player.sendMessage(ChatColor.GOLD+Residence.getLanguage().getPhrase("Land")+":"+ChatColor.DARK_GREEN + landName);
+            player.sendMessage(ChatColor.YELLOW+Residence.getLanguage().getPhrase("Cost")+": "+ChatColor.DARK_AQUA + rentable.cost + " per " + rentable.days + " days");
+            player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("RentableAutoRenew")+":"+ChatColor.DARK_AQUA + rentable.repeatable);
+            if(rented!=null)
+            {
+                player.sendMessage(ChatColor.GOLD+Residence.getLanguage().getPhrase("Status")+":"+ChatColor.YELLOW+" "+Residence.getLanguage().getPhrase("ResidenceRentedBy",ChatColor.RED + rented.player+ChatColor.YELLOW));
+                player.sendMessage(ChatColor.YELLOW+Residence.getLanguage().getPhrase("RentExpire")+":"+ChatColor.GREEN + new Date(rented.endTime));
+                player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("RentAutoRenew")+":"+ChatColor.DARK_AQUA + rented.autoRefresh);
+            }
+            else
+            {
+                player.sendMessage(ChatColor.GOLD+Residence.getLanguage().getPhrase("Status")+":"+ChatColor.GREEN+" "+Residence.getLanguage().getPhrase("Available"));
+            }
+        }
+        else
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceNotForRent"));
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+	public static RentManager load(Map<String,Object> root)
+    {
+        RentManager rentManager = new RentManager();
+        if(root!=null)
+        {
+            Map<String,Object> rentables = (Map<String, Object>) root.get("Rentables");
+            for(Entry<String, Object> rent : rentables.entrySet())
+            {
+                rentManager.rentableLand.put(rent.getKey(), RentableLand.load((Map<String, Object>) rent.getValue()));
+            }
+            Map<String,Object> rented = (Map<String, Object>) root.get("Rented");
+            for(Entry<String, Object> rent : rented.entrySet())
+            {
+                rentManager.rentedLand.put(rent.getKey(), RentedLand.load((Map<String, Object>) rent.getValue()));
+            }
+        }
+        return rentManager;
+    }
+
+    public Map<String,Object> save()
+    {
+        Map<String,Object> root = new HashMap<String,Object>();
+        Map<String,Object> rentables = new HashMap<String,Object>();
+        for(Entry<String, RentableLand> rent : rentableLand.entrySet())
+        {
+            rentables.put(rent.getKey(), rent.getValue().save());
+        }
+        Map<String,Object> rented = new HashMap<String,Object>();
+        for(Entry<String, RentedLand> rent : rentedLand.entrySet())
+        {
+            rented.put(rent.getKey(), rent.getValue().save());
+        }
+        root.put("Rentables", rentables);
+        root.put("Rented", rented);
+        return root;
+    }
+
+    public void updateRentableName(String oldName, String newName)
+    {
+        if(rentableLand.containsKey(oldName))
+        {
+            rentableLand.put(newName, rentableLand.get(oldName));
+            rentableLand.remove(oldName);
+        }
+        if(rentedLand.containsKey(oldName))
+        {
+            rentedLand.put(newName, rentedLand.get(oldName));
+            rentedLand.remove(oldName);
+        }
+    }
+
+    public void printRentableResidences(Player player)
+    {
+        Set<Entry<String, RentableLand>> set = rentableLand.entrySet();
+        player.sendMessage(ChatColor.YELLOW+Residence.getLanguage().getPhrase("RentableLand")+":");
+        StringBuilder sbuild = new StringBuilder();
+        sbuild.append(ChatColor.GREEN);
+        boolean firstadd = true;
+        for(Entry<String, RentableLand> land : set)
+        {
+            if(!this.isRented(land.getKey()))
+            {
+                if(!firstadd)
+                    sbuild.append(", ");
+                else
+                    firstadd = false;
+                sbuild.append(land.getKey());
+            }
+        }
+        player.sendMessage(sbuild.toString());
+    }
+
+    public int getRentCount(String player)
+    {
+        Set<Entry<String, RentedLand>> set = rentedLand.entrySet();
+        int count = 0;
+        for(Entry<String, RentedLand> land : set)
+        {
+            if(land.getValue().player.equalsIgnoreCase(player))
+                count++;
+        }
+        return count;
+    }
+
+    public int getRentableCount(String player)
+    {
+        Set<String> set = rentableLand.keySet();
+        int count = 0;
+        for(String land : set)
+        {
+            ClaimedResidence res = Residence.getResidenceManager().getByName(land);
+            if(res!=null)
+                if(res.getPermissions().getOwner().equalsIgnoreCase(player))
+                    count++;
+        }
+        return count;
+    }
+}

src/com/bekvon/bukkit/residence/economy/rent/RentableLand.java

@@ -0,0 +1,36 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.economy.rent;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ *
+ * @author Administrator
+ */
+public class RentableLand {
+
+    public int days;
+    public int cost;
+    public boolean repeatable;
+
+    public Map<String, Object> save() {
+        Map<String, Object> rented = new HashMap<String, Object>();
+        rented.put("Days", days);
+        rented.put("Cost", cost);
+        rented.put("Repeatable", repeatable);
+        return rented;
+    }
+
+    public static RentableLand load(Map<String, Object> map) {
+        RentableLand newland = new RentableLand();
+        newland.cost = (Integer)map.get("Cost");
+        newland.days = (Integer)map.get("Days");
+        newland.repeatable = (Boolean)map.get("Repeatable");
+        return newland;
+    }
+}

src/com/bekvon/bukkit/residence/economy/rent/RentedLand.java

@@ -0,0 +1,39 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.economy.rent;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ *
+ * @author Administrator
+ */
+public class RentedLand {
+
+    public String player;
+    public long startTime;
+    public long endTime;
+    public boolean autoRefresh;
+
+    public Map<String, Object> save() {
+        Map<String, Object> rentables = new HashMap<String, Object>();
+        rentables.put("Player", player);
+        rentables.put("StartTime", startTime);
+        rentables.put("EndTime", endTime);
+        rentables.put("AutoRefresh", autoRefresh);
+        return rentables;
+    }
+    public static RentedLand load(Map<String,Object> map)
+    {
+        RentedLand newland = new RentedLand();
+        newland.player = (String) map.get("Player");
+        newland.startTime = (Long)map.get("StartTime");
+        newland.endTime = (Long)map.get("EndTime");
+        newland.autoRefresh = (Boolean)map.get("AutoRefresh");
+        return newland;
+    }
+}

src/com/bekvon/bukkit/residence/event/CancellableResidenceEvent.java

@@ -0,0 +1,32 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.event.Cancellable;
+
+/**
+ *
+ * @author Administrator
+ */
+public class CancellableResidenceEvent extends ResidenceEvent implements Cancellable {
+
+    protected boolean cancelled;
+
+    public CancellableResidenceEvent(String eventName, ClaimedResidence resref)
+    {
+        super(eventName,resref);
+    }
+    
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean bln) {
+        cancelled = bln;
+    }
+
+}

src/com/bekvon/bukkit/residence/event/CancellableResidencePlayerEvent.java

@@ -0,0 +1,34 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+
+/**
+ *
+ * @author Administrator
+ */
+public class CancellableResidencePlayerEvent extends ResidencePlayerEvent implements Cancellable {
+
+    protected boolean cancelled;
+
+    public CancellableResidencePlayerEvent(String eventName, ClaimedResidence resref, Player player)
+    {
+        super(eventName, resref, player);
+        cancelled = false;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean bln) {
+        cancelled = bln;
+    }
+
+}

src/com/bekvon/bukkit/residence/event/CancellableResidencePlayerFlagEvent.java

@@ -0,0 +1,33 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Cancellable;
+
+/**
+ *
+ * @author Administrator
+ */
+public class CancellableResidencePlayerFlagEvent extends ResidencePlayerFlagEvent implements Cancellable {
+
+    protected boolean cancelled;
+
+    public CancellableResidencePlayerFlagEvent(String eventName, ClaimedResidence resref, Player player, String flag, FlagType type, String target)
+    {
+        super(eventName, resref, player, flag, type, target);
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean bln) {
+        cancelled = bln;
+    }
+
+}

src/com/bekvon/bukkit/residence/event/ResidenceChangedEvent.java

@@ -0,0 +1,80 @@
+package com.bekvon.bukkit.residence.event;
+
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+
+/**
+ * The {@link ResidenceChangedEvent} is fired when a player transitions between residences and/or
+ * residence subzones. Possible transitions include:
+ * <ul>
+ * <li>Moving from no residence into a residence/subzone;</li>
+ * <li>Moving from a residence/subzone to no residence; or</li>
+ * <li>Moving between residences/subzones</li>
+ * </ul>
+ * <p>
+ * {@link ResidenceChangedEvent} is a replacement for {@link ResidenceEnterEvent} and
+ * {@link ResidenceLeaveEvent}, which have been marked as deprecated and will be removed in future
+ * releases. Using this event benefits developers as it encapsulates enter/leave conditions in a
+ * single event and doesn't require additional correlation to detect and residence-to-residence
+ * transition.
+ * <p/>
+ * <p>
+ * This event is fired whenever conditions are met when a player moves or teleports to a new
+ * location. The event is also triggered when players appear in a residence upon logging in.
+ * 
+ * @author frelling
+ *
+ */
+public class ResidenceChangedEvent extends ResidencePlayerEvent {
+    private static final HandlerList handlers = new HandlerList();
+    
+    private ClaimedResidence from = null;
+    private ClaimedResidence to = null;
+
+    /**
+     * Constructs a {@link ResidenceChangedEvent} to identify a residence transition for the
+     * given player
+     * 
+     * @param from the residence that the player left or {@code null} if coming from an
+     * unprotected area.
+     * @param to the residence that the player entered or {@code null} if entering an
+     * unprotected area.
+     * @param player player involved in the transition
+     */
+    public ResidenceChangedEvent(ClaimedResidence from, ClaimedResidence to, Player player) {
+        super("RESIDENCE_CHANGE", null, player);
+        this.from = from;
+        this.to = to;
+    }
+    
+    /**
+     * Returns the residence from which player came.
+     * 
+     * @return the residence from which player came or {@code null} if player came from an
+     * unprotected area
+     */
+    public ClaimedResidence getFrom() {
+    	return from;
+    }
+    
+    /**
+     * Returns the residence that player has entered.
+     * 
+     * @return the residence that player has entered or {@code null} if player enters an
+     * unprotected area
+     */
+    public ClaimedResidence getTo() {
+    	return to;
+    }
+    
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidenceChatEvent.java

@@ -0,0 +1,56 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceChatEvent extends CancellableResidencePlayerEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    protected String message;
+    ChatColor color;
+    
+    public ResidenceChatEvent(ClaimedResidence resref, Player player, String message, ChatColor color) {
+        super("RESIDENCE_CHAT_EVENT", resref, player);
+        this.message = message;
+        this.color = color;
+    }
+    
+    public String getChatMessage()
+    {
+        return message;
+    }
+    
+    public void setChatMessage(String newmessage)
+    {
+        message = newmessage;
+    }
+    
+    public ChatColor getColor()
+    {
+        return color;
+    }
+    
+    public void setColor(ChatColor c)
+    {
+        color = c;
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidenceCommandEvent.java

@@ -0,0 +1,66 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.Cancellable;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceCommandEvent extends Event implements Cancellable {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    protected boolean cancelled;
+    protected String cmd;
+    protected String arglist[];
+    CommandSender commandsender;
+
+    public ResidenceCommandEvent(String command, String args[], CommandSender sender)
+    {
+        super();
+        cancelled = false;
+        arglist = args;
+        cmd = command;
+        commandsender = sender;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    public void setCancelled(boolean bln) {
+        cancelled = bln;
+    }
+
+    public String getCommand()
+    {
+        return cmd;
+    }
+
+    public String[] getArgs()
+    {
+        return arglist;
+    }
+
+    public CommandSender getSender()
+    {
+        return commandsender;
+    }
+
+}

src/com/bekvon/bukkit/residence/event/ResidenceCreationEvent.java

@@ -0,0 +1,58 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import com.bekvon.bukkit.residence.protection.CuboidArea;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceCreationEvent extends CancellableResidencePlayerEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    protected String resname;
+    CuboidArea area;
+
+    public ResidenceCreationEvent(Player player, String newname, ClaimedResidence resref, CuboidArea resarea)
+    {
+        super("RESIDENCE_CREATE",resref,player);
+        resname = newname;
+        area = resarea;
+    }
+
+    public String getResidenceName()
+    {
+        return resname;
+    }
+
+    public void setResidenceName(String name)
+    {
+        resname = name;
+    }
+
+    public CuboidArea getPhysicalArea()
+    {
+        return area;
+    }
+
+    public void setPhysicalArea(CuboidArea newarea)
+    {
+        area = newarea;
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidenceDeleteEvent.java

@@ -0,0 +1,46 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceDeleteEvent extends CancellableResidencePlayerEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    public enum DeleteCause {
+        LEASE_EXPIRE,PLAYER_DELETE,OTHER
+    }
+    
+    DeleteCause cause;
+
+    public ResidenceDeleteEvent(Player player, ClaimedResidence resref, DeleteCause delcause)
+    {
+        super("RESIDENCE_DELETE", resref, player);
+        cause = delcause;
+    }
+
+    public DeleteCause getCause()
+    {
+        return cause;
+    }
+
+}

src/com/bekvon/bukkit/residence/event/ResidenceEnterEvent.java

@@ -0,0 +1,38 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Note: This event has been replaced with {@link ResidenceChangedEvent} and is marked as
+ * deprecated as of 21-MAY-2013. It will be removed in future releases. Please see
+ * {@link ResidenceChangedEvent} comments for further information.
+ * 
+ * TODO - Remove this class at a suitable time in the future.
+ * 
+ * @author Administrator
+ */
+@Deprecated
+public class ResidenceEnterEvent extends ResidencePlayerEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    public ResidenceEnterEvent(ClaimedResidence resref, Player player)
+    {
+        super("RESIDENCE_ENTER", resref, player);
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidenceEvent.java

@@ -0,0 +1,45 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceEvent extends Event {
+
+	private static final HandlerList handlers = new HandlerList();
+    private String message;
+	 
+	public HandlerList getHandlers() {
+	    return handlers;
+	}
+	 
+	public static HandlerList getHandlerList() {
+	    return handlers;
+	}
+
+    ClaimedResidence res;
+
+    public ResidenceEvent(String eventName, ClaimedResidence resref)
+    {
+    	message = eventName;
+        res = resref;
+    }
+ 
+    public String getMessage() {
+        return message;
+    }
+
+    public ClaimedResidence getResidence()
+    {
+        return res;
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidenceFlagChangeEvent.java

@@ -0,0 +1,42 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import com.bekvon.bukkit.residence.protection.FlagPermissions.FlagState;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceFlagChangeEvent extends CancellableResidencePlayerFlagEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    FlagState newstate;
+
+    public ResidenceFlagChangeEvent(ClaimedResidence resref, Player player, String flag, FlagType type,FlagState newState, String target)
+    {
+        super("RESIDENCE_FLAG_CHANGE", resref, player, flag, type, target);
+        newstate = newState;
+    }
+
+    public FlagState getNewState()
+    {
+        return newstate;
+    }
+
+}

src/com/bekvon/bukkit/residence/event/ResidenceFlagCheckEvent.java

@@ -0,0 +1,57 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceFlagCheckEvent extends ResidenceFlagEvent {
+private static final HandlerList handlers = new HandlerList();
+
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    private boolean override;
+    private boolean overridevalue;
+    boolean defaultvalue;
+
+    public ResidenceFlagCheckEvent(ClaimedResidence resref, String flag, FlagType type, String target, boolean defaultValue)
+    {
+        super("RESIDENCE_FLAG_CHECK", resref, flag, type, target);
+        defaultvalue = defaultValue;
+        override = false;
+    }
+
+    public boolean isOverriden()
+    {
+        return override;
+    }
+
+    public void overrideCheck(boolean flagval)
+    {
+        overridevalue = flagval;
+        override=true;
+    }
+
+    public boolean getOverrideValue()
+    {
+        return overridevalue;
+    }
+
+    public boolean getDefaultValue()
+    {
+        return defaultvalue;
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidenceFlagEvent.java

@@ -0,0 +1,60 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import com.bekvon.bukkit.residence.protection.FlagPermissions.FlagState;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceFlagEvent extends ResidenceEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+    
+    public enum FlagType
+    {
+        RESIDENCE,GROUP,PLAYER
+    }
+
+    String flagname;
+    FlagType flagtype;
+    FlagState flagstate;
+    String flagtarget;
+
+    public ResidenceFlagEvent(String eventName, ClaimedResidence resref, String flag, FlagType type, String target)
+    {
+        super(eventName, resref);
+        flagname = flag;
+        flagtype = type;
+        flagtarget = target;
+    }
+
+    public String getFlag()
+    {
+        return flagname;
+    }
+
+    public FlagType getFlagType()
+    {
+        return flagtype;
+    }
+
+    public String getFlagTargetPlayerOrGroup()
+    {
+        return flagtarget;
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidenceLeaveEvent.java

@@ -0,0 +1,38 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+/**
+ * Note: This event has been replaced with {@link ResidenceChangedEvent} and is marked as
+ * deprecated as of 21-MAY-2013. It will be removed in future releases. Please see
+ * {@link ResidenceChangedEvent} comments for further information.
+ * 
+ * TODO - Remove this class at a suitable time in the future.
+ * 
+ * @author Administrator
+ */
+@Deprecated
+public class ResidenceLeaveEvent extends ResidencePlayerEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    public ResidenceLeaveEvent(ClaimedResidence resref, Player player)
+    {
+        super("RESIDENCE_LEAVE", resref, player);
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidenceOwnerChangeEvent.java

@@ -0,0 +1,38 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceOwnerChangeEvent extends ResidenceEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    protected String newowner;
+
+    public ResidenceOwnerChangeEvent(ClaimedResidence resref, String newOwner)
+    {
+        super("RESIDENCE_OWNER_CHANGE",resref);
+        newowner = newOwner;
+    }
+
+    public String getNewOwner()
+    {
+        return newowner;
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidencePlayerEvent.java

@@ -0,0 +1,44 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidencePlayerEvent extends ResidenceEvent implements ResidencePlayerEventInterface {
+
+    Player p;
+
+    public ResidencePlayerEvent(String eventName, ClaimedResidence resref, Player player)
+    {
+        super(eventName, resref);
+        res = resref;
+        p = player;
+    }
+
+    public boolean isPlayer()
+    {
+        return p!=null;
+    }
+
+    public boolean isAdmin()
+    {
+        if(isPlayer())
+        {
+            return Residence.getPermissionManager().isResidenceAdmin(p);
+        }
+        return true;
+    }
+    public Player getPlayer()
+    {
+        return p;
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidencePlayerEventInterface.java

@@ -0,0 +1,18 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public interface ResidencePlayerEventInterface {
+    public boolean isAdmin();
+    public boolean isPlayer();
+    public Player getPlayer();
+}

src/com/bekvon/bukkit/residence/event/ResidencePlayerFlagEvent.java

@@ -0,0 +1,42 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidencePlayerFlagEvent extends ResidenceFlagEvent implements ResidencePlayerEventInterface {
+    Player p;
+
+    public ResidencePlayerFlagEvent(String eventName,ClaimedResidence resref, Player player, String flag, FlagType type, String target)
+    {
+        super(eventName, resref, flag, type, target);
+        p = player;
+    }
+
+    public boolean isPlayer()
+    {
+        return p!=null;
+    }
+
+    public boolean isAdmin()
+    {
+        if(isPlayer())
+        {
+            return Residence.getPermissionManager().isResidenceAdmin(p);
+        }
+        return true;
+    }
+
+    public Player getPlayer() {
+        return p;
+    }
+}

src/com/bekvon/bukkit/residence/event/ResidenceRenameEvent.java

@@ -0,0 +1,24 @@
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+
+public class ResidenceRenameEvent extends ResidenceEvent {
+	protected String NewResName;
+	protected String OldResName;
+	protected ClaimedResidence res;
+	public ResidenceRenameEvent(ClaimedResidence resref, String NewName, String OldName) {
+		super("RESIDENCE_RENAME", resref);
+		NewResName = NewName;
+		OldResName = OldName;
+		res = resref;
+	}
+	public String getNewResidenceName() {
+		return NewResName;
+	}
+	public String getOldResidenceName() {
+		return OldResName;
+	}
+	public ClaimedResidence getResidence() {
+		return res;
+	}
+}

src/com/bekvon/bukkit/residence/event/ResidenceRentEvent.java

@@ -0,0 +1,46 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceRentEvent extends CancellableResidencePlayerEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    RentEventType eventtype;
+
+    public enum RentEventType
+    {
+        RENT, UNRENT, RENTABLE, UNRENTABLE, RENT_EXPIRE
+    }
+
+    public ResidenceRentEvent(ClaimedResidence resref, Player player, RentEventType type)
+    {
+        super("RESIDENCE_RENT_EVENT", resref, player);
+        eventtype = type;
+    }
+
+    public RentEventType getCause()
+    {
+        return eventtype;
+    }
+
+}

src/com/bekvon/bukkit/residence/event/ResidenceTPEvent.java

@@ -0,0 +1,47 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.event;
+
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceTPEvent extends CancellableResidencePlayerEvent {
+
+    private static final HandlerList handlers = new HandlerList();
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    Player reqPlayer;
+    Location loc;
+    public ResidenceTPEvent(ClaimedResidence resref, Location teleloc, Player player, Player reqplayer)
+    {
+        super("RESIDENCE_TP",resref,player);
+        reqPlayer = reqplayer;
+        loc = teleloc;
+    }
+
+    public Player getRequestingPlayer()
+    {
+        return reqPlayer;
+    }
+
+    public Location getTeleportLocation()
+    {
+        return loc;
+    }
+}

src/com/bekvon/bukkit/residence/itemlist/ItemList.java

@@ -0,0 +1,218 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.itemlist;
+import org.bukkit.ChatColor;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.bukkit.Material;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ItemList {
+
+    protected List<Material> list;
+    protected ListType type;
+
+    public ItemList(ListType listType)
+    {
+        this();
+        type = listType;
+    }
+
+    protected ItemList()
+    {
+        list = new ArrayList<Material>();
+    }
+
+    public static enum ListType
+    {
+        BLACKLIST,WHITELIST,IGNORELIST,OTHER
+    }
+
+     public ListType getType()
+    {
+        return type;
+    }
+
+    public boolean contains(Material mat)
+    {
+        return list.contains(mat);
+    }
+
+    public void add(Material mat)
+    {
+        if(!list.contains(mat))
+            list.add(mat);
+    }
+
+    public boolean toggle(Material mat)
+    {
+        if(list.contains(mat))
+        {
+            list.remove(mat);
+            return false;
+        }
+        else
+        {
+            list.add(mat);
+            return true;
+        }
+    }
+
+    public void remove(Material mat)
+    {
+        list.remove(mat);
+    }
+
+    public boolean isAllowed(Material mat)
+    {
+        if(type == ListType.BLACKLIST)
+        {
+            if(list.contains(mat))
+            {
+                return false;
+            }
+            return true;
+        }
+        else if(type == ListType.WHITELIST)
+        {
+            if(list.contains(mat))
+            {
+                return true;
+            }
+            return false;
+        }
+        return true;
+    }
+
+    public boolean isIgnored(Material mat)
+    {
+        if(type == ListType.IGNORELIST)
+        {
+            if(list.contains(mat))
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public boolean isListed(Material mat)
+    {
+        return this.contains(mat);
+    }
+
+    public int getListSize()
+    {
+        return list.size();
+    }
+
+    public static ItemList readList(ConfigurationSection node)
+    {
+        return ItemList.readList(node, new ItemList());
+    }
+
+    @SuppressWarnings("deprecation")
+	protected static ItemList readList(ConfigurationSection node, ItemList list)
+    {
+        ListType type = ListType.valueOf(node.getString("Type","").toUpperCase());
+        list.type = type;
+        List<String> items = node.getStringList("Items");
+        if (items != null) {
+            for (String item : items) {
+                int parse = -1;
+                try {
+                    parse = Integer.parseInt(item);
+                } catch (Exception ex) {
+                }
+                if (parse == -1) {
+                    try {
+                        list.add(Material.valueOf(item.toUpperCase()));
+                    } catch (Exception ex) {
+                    }
+                } else {
+                    try {
+                        list.add(Material.getMaterial(parse));
+                    } catch (Exception ex) {
+                    }
+                }
+            }
+        }
+        return list;
+    }
+
+    public void printList(Player player)
+    {
+        StringBuilder builder = new StringBuilder();
+        boolean first = true;
+        for(Material mat : list)
+        {
+            if(!first)
+                builder.append(", ");
+            else
+                builder.append(ChatColor.YELLOW);
+            builder.append(mat);
+            first = false;
+        }
+        player.sendMessage(builder.toString());
+    }
+
+    public Material[] toArray()
+    {
+        Material mats[] = new Material[list.size()];
+        int i = 0;
+        for(Material mat : list)
+        {
+            mats[i] = mat;
+            i++;
+        }
+        return mats;
+    }
+
+    public Map<String,Object> save()
+    {
+        Map<String, Object> saveMap = new LinkedHashMap<String,Object>();
+        saveMap.put("Type", type.toString());
+        List<String> saveList = new ArrayList<String>();
+        for(Material mat : list)
+        {
+            saveList.add(mat.toString());
+        }
+        saveMap.put("ItemList", saveList);
+        return saveMap;
+    }
+
+    public static ItemList load(Map<String,Object> map)
+    {
+        ItemList newlist = new ItemList();
+        return load(map,newlist);
+    }
+
+    @SuppressWarnings("unchecked")
+	protected static ItemList load(Map<String,Object> map, ItemList newlist)
+    {
+        try
+        {
+            newlist.type = ListType.valueOf((String) map.get("Type"));
+			List<String> list = (List<String>) map.get("ItemList");
+            for(String item : list)
+            {
+                newlist.add(Material.valueOf(item));
+            }
+        }
+        catch (Exception ex)
+        {}
+        return newlist;
+    }
+}

src/com/bekvon/bukkit/residence/itemlist/ResidenceItemList.java

@@ -0,0 +1,55 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.itemlist;
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import java.util.Map;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceItemList extends ItemList {
+    ClaimedResidence res;
+
+    public ResidenceItemList(ClaimedResidence parent, ListType type)
+    {
+        super(type);
+        res = parent;
+    }
+
+    private ResidenceItemList()
+    {
+        
+    }
+
+    public void playerListChange(Player player, Material mat, boolean resadmin) {
+        PermissionGroup group = Residence.getPermissionManager().getGroup(player);
+        if(resadmin || (res.getPermissions().hasResidencePermission(player, true) && group.itemListAccess()))
+        {
+            if(super.toggle(mat))
+                player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("ListMaterialAdd",ChatColor.GREEN + mat.toString() + ChatColor.YELLOW+"."+ChatColor.GREEN + type.toString().toLowerCase() + ChatColor.YELLOW));
+            else
+                player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("ListMaterialRemove",ChatColor.GREEN + mat.toString() + ChatColor.YELLOW+"."+ChatColor.GREEN + type.toString().toLowerCase() + ChatColor.YELLOW));
+        }
+        else
+        {
+            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoPermission"));
+        }
+    }
+
+    public static ResidenceItemList load(ClaimedResidence parent, Map<String,Object> map)
+    {
+        ResidenceItemList newlist = new ResidenceItemList();
+        newlist.res = parent;
+        return (ResidenceItemList) ItemList.load(map, newlist);
+    }
+}

src/com/bekvon/bukkit/residence/itemlist/WorldItemList.java

@@ -0,0 +1,83 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.itemlist;
+
+import org.bukkit.Material;
+import org.bukkit.configuration.ConfigurationSection;
+
+/**
+ *
+ * @author Administrator
+ */
+public class WorldItemList extends ItemList {
+
+    protected String world;
+    protected String group; 
+
+    public WorldItemList(ListType listType)
+    {
+        super(listType);
+    }
+
+    protected WorldItemList()
+    {
+        
+    }
+
+    public String getWorld()
+    {
+        return world;
+    }
+
+    public String getGroup()
+    {
+        return group;
+    }
+
+    public boolean isAllowed(Material mat, String inworld, String ingroup) {
+        if(!listApplicable(inworld,ingroup))
+            return true;
+        return super.isAllowed(mat);
+    }
+
+    public boolean isIgnored(Material mat, String inworld, String ingroup)
+    {
+        if(!listApplicable(inworld,ingroup))
+            return false;
+        return super.isIgnored(mat);
+    }
+
+    public boolean isListed(Material mat, String inworld, String ingroup)
+    {
+        if(!listApplicable(inworld,ingroup))
+            return false;
+        return super.isListed(mat);
+    }
+
+    public boolean listApplicable(String inworld, String ingroup)
+    {
+        if (world != null) {
+            if (!world.equalsIgnoreCase(inworld)) {
+                return false;
+            }
+        }
+        if (group != null) {
+            if (!group.equals(ingroup)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static WorldItemList readList(ConfigurationSection node)
+    {
+        WorldItemList list = new WorldItemList();
+        ItemList.readList(node, list);
+        list.world = node.getString("World",null);
+        list.group = node.getString("Group",null);
+        return list;
+    }
+}

src/com/bekvon/bukkit/residence/itemlist/WorldItemManager.java

@@ -0,0 +1,60 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.itemlist;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import org.bukkit.Material;
+import org.bukkit.configuration.file.FileConfiguration;
+
+/**
+ *
+ * @author Administrator
+ */
+public class WorldItemManager {
+    protected List<WorldItemList> lists;
+
+    public WorldItemManager(FileConfiguration config)
+    {
+        lists = new ArrayList<WorldItemList>();
+        this.readLists(config);
+    }
+
+    public boolean isAllowed(Material mat, String group, String world) {
+        for (WorldItemList list : lists) {
+            if (!list.isAllowed(mat, world, group)) {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public boolean isIgnored(Material mat, String group, String world)
+    {
+        for (WorldItemList list : lists) {
+            if (list.isIgnored(mat, world, group)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void readLists(FileConfiguration config) {
+        Set<String> keys = config.getConfigurationSection("ItemList").getKeys(false);
+        if (keys != null) {
+            for (String key : keys) {
+                try {
+                    WorldItemList list = WorldItemList.readList(config.getConfigurationSection("ItemList." + key));
+                    lists.add(list);
+                    //System.out.println("Debug: read list " + key + " world: " + list.getWorld() + " group: " + list.getGroup() + " itemcount:" + list.getListSize());
+                } catch (Exception ex) {
+                    System.out.println("Failed to load item list:" + key);
+                }
+            }
+        }
+    }
+}

src/com/bekvon/bukkit/residence/listeners/ResidenceBlockListener.java

@@ -0,0 +1,215 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.listeners;
+
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.protection.FlagPermissions;
+
+import org.bukkit.entity.Player;
+import org.bukkit.block.Block;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockBurnEvent;
+import org.bukkit.event.block.BlockFromToEvent;
+import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.block.BlockIgniteEvent.IgniteCause;
+import org.bukkit.event.block.BlockPistonExtendEvent;
+import org.bukkit.event.block.BlockPistonRetractEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.BlockSpreadEvent;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceBlockListener implements Listener {
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onBlockBreak(BlockBreakEvent event) {
+        Player player = event.getPlayer();
+        if (Residence.isResAdminOn(player)) {
+            return;
+        }
+        Material mat = event.getBlock().getType();
+        String world = event.getBlock().getWorld().getName();
+        String group = Residence.getPermissionManager().getGroupNameByPlayer(player);
+        if (Residence.getItemManager().isIgnored(mat, group, world)) {
+            return;
+        }
+        ClaimedResidence res = Residence.getResidenceManager().getByLoc(event.getBlock().getLocation());
+        if (Residence.getConfigManager().enabledRentSystem()) {
+            if (res != null) {
+                String resname = res.getName();
+                if (Residence.getConfigManager().preventRentModify() && Residence.getRentManager().isRented(resname)) {
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("RentedModifyDeny"));
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+        }
+        FlagPermissions perms = Residence.getPermsByLocForPlayer(event.getBlock().getLocation(), player);
+        String pname = player.getName();
+        if (res != null) {
+            if (res.getItemIgnoreList().isListed(mat)) {
+                return;
+            }
+        }
+        boolean hasdestroy = perms.playerHas(pname, player.getWorld().getName(), "destroy", perms.playerHas(pname, player.getWorld().getName(), "build", true));
+        boolean hasContainer = perms.playerHas(pname, player.getWorld().getName(), "container", true);
+        if (!hasdestroy || (!hasContainer && mat == Material.CHEST)) {
+            event.setCancelled(true);
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+            return;
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onBlockPlace(BlockPlaceEvent event) {
+        Player player = event.getPlayer();
+        if (Residence.isResAdminOn(player)) {
+            return;
+        }
+        Material mat = event.getBlock().getType();
+        String world = event.getBlock().getWorld().getName();
+        String group = Residence.getPermissionManager().getGroupNameByPlayer(player);
+        if (Residence.getItemManager().isIgnored(mat, group, world)) {
+            return;
+        }
+        ClaimedResidence res = Residence.getResidenceManager().getByLoc(event.getBlock().getLocation());
+        if (Residence.getConfigManager().enabledRentSystem()) {
+            if (res != null) {
+                String resname = res.getName();
+                if (Residence.getConfigManager().preventRentModify() && Residence.getRentManager().isRented(resname)) {
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("RentedModifyDeny"));
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+        }
+        String pname = player.getName();
+        if (res != null) {
+            if (!res.getItemBlacklist().isAllowed(mat)) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ItemBlacklisted"));
+                event.setCancelled(true);
+                return;
+            }
+        }
+        FlagPermissions perms = Residence.getPermsByLocForPlayer(event.getBlock().getLocation(), player);
+        boolean hasplace = perms.playerHas(pname, player.getWorld().getName(), "place", perms.playerHas(pname, player.getWorld().getName(), "build", true));
+        if (!hasplace) {
+            event.setCancelled(true);
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+            return;
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onBlockSpread(BlockSpreadEvent event) {
+        Location loc = event.getBlock().getLocation();
+        FlagPermissions perms = Residence.getPermsByLoc(loc);
+        if (!perms.has("spread", true)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onBlockPistonRetract(BlockPistonRetractEvent event) {
+        FlagPermissions perms = Residence.getPermsByLoc(event.getBlock().getLocation());
+        if (!perms.has("piston", true)){
+            event.setCancelled(true);
+        	return;
+    	}
+        if (event.isSticky()){
+			Location location = event.getRetractLocation();
+            FlagPermissions blockperms = Residence.getPermsByLoc(location);
+            if (!blockperms.has("piston", true)) {
+            	event.setCancelled(true);
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onBlockPistonExtend(BlockPistonExtendEvent event) {
+        FlagPermissions perms = Residence.getPermsByLoc(event.getBlock().getLocation());
+        if (!perms.has("piston", true)) {
+            event.setCancelled(true);
+        }
+        for (Block block : event.getBlocks()) {
+        	FlagPermissions blockpermsfrom = Residence.getPermsByLoc(block.getLocation());
+        	Location blockto = block.getLocation();
+        	blockto.setX(blockto.getX()+event.getDirection().getModX());
+        	blockto.setY(blockto.getY()+event.getDirection().getModY());
+        	blockto.setZ(blockto.getZ()+event.getDirection().getModZ());
+        	FlagPermissions blockpermsto = Residence.getPermsByLoc(blockto);
+            if (!blockpermsfrom.has("piston", true) || !blockpermsto.has("piston", true)) {
+            	event.setCancelled(true);
+            	return;
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onBlockFromTo(BlockFromToEvent event) {
+        FlagPermissions perms = Residence.getPermsByLoc(event.getToBlock().getLocation());
+        boolean hasflow = perms.has("flow", true);
+        Material mat = event.getBlock().getType();
+        if (!hasflow) {
+            event.setCancelled(true);
+            return;
+        }
+        if (mat == Material.LAVA || mat == Material.STATIONARY_LAVA) {
+            if (!perms.has("lavaflow", hasflow)) {
+        		event.setCancelled(true);
+        	}
+            return;
+        }
+        if (mat == Material.WATER || mat == Material.STATIONARY_WATER) {
+        	if (!perms.has("waterflow", hasflow)) {
+        		event.setCancelled(true);
+        	}
+            return;
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onBlockBurn(BlockBurnEvent event) {
+        FlagPermissions perms = Residence.getPermsByLoc(event.getBlock().getLocation());
+        if (!perms.has("firespread", true)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onBlockIgnite(BlockIgniteEvent event) {
+        FlagPermissions perms = Residence.getPermsByLocForPlayer(event.getBlock().getLocation(), event.getPlayer());
+        IgniteCause cause = event.getCause();
+        if (cause == IgniteCause.SPREAD) {
+            if (!perms.has("firespread", true)) {
+        		event.setCancelled(true);
+        	}
+        } else if (cause == IgniteCause.FLINT_AND_STEEL) {
+        	Player player = event.getPlayer();
+        	if (player != null && !perms.playerHas(player.getName(), player.getWorld().getName(), "ignite", true) && !Residence.isResAdminOn(player)) {
+        		event.setCancelled(true);
+        		player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoPermission"));
+        	}
+        } else {
+        	if(!perms.has("ignite", true)){
+        	    event.setCancelled(true);
+        	}
+        }
+    }
+}

src/com/bekvon/bukkit/residence/listeners/ResidenceEntityListener.java

@@ -0,0 +1,405 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.listeners;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import com.bekvon.bukkit.residence.protection.FlagPermissions;
+
+import org.bukkit.block.Block;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.EntityChangeBlockEvent;
+import org.bukkit.event.entity.EntityCombustEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.entity.EntityInteractEvent;
+import org.bukkit.event.entity.PotionSplashEvent;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+
+import org.bukkit.Material;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Bat;
+import org.bukkit.entity.Chicken;
+import org.bukkit.entity.Cow;
+import org.bukkit.entity.Creeper;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Horse;
+import org.bukkit.entity.IronGolem;
+import org.bukkit.entity.Monster;
+import org.bukkit.entity.Ocelot;
+import org.bukkit.entity.Pig;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Rabbit;
+import org.bukkit.entity.Sheep;
+import org.bukkit.entity.Snowman;
+import org.bukkit.entity.Squid;
+import org.bukkit.entity.Villager;
+import org.bukkit.entity.Wolf;
+import org.bukkit.entity.Slime;
+import org.bukkit.entity.Ghast;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.ExplosionPrimeEvent;
+import org.bukkit.event.hanging.HangingBreakByEntityEvent;
+import org.bukkit.event.hanging.HangingBreakEvent;
+import org.bukkit.event.hanging.HangingPlaceEvent;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidenceEntityListener implements Listener {
+    
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onEndermanChangeBlock(EntityChangeBlockEvent event) {
+        if (event.getEntityType() != EntityType.ENDERMAN && event.getEntityType() != EntityType.WITHER) {
+            return;
+        }
+        FlagPermissions perms = Residence.getPermsByLoc(event.getBlock().getLocation());
+        FlagPermissions world = Residence.getWorldFlags().getPerms(event.getBlock().getWorld().getName());
+        if (event.getEntityType() == EntityType.WITHER) {
+            if (!perms.has("wither", perms.has("explode", world.has("wither", world.has("explode", true))))) {
+                event.setCancelled(true);
+            }
+        } else if (!perms.has("build", true)) {
+            event.setCancelled(true);
+        }
+    }
+    
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onEntityInteract(EntityInteractEvent event){
+    	Block block = event.getBlock();
+    	Material mat = block.getType();
+    	Entity entity = event.getEntity();    	
+    	FlagPermissions perms = Residence.getPermsByLoc(block.getLocation());
+    	boolean hastrample = perms.has("trample", perms.has("hasbuild", true));     			
+    	if(!hastrample && !(entity.getType() == EntityType.FALLING_BLOCK) && (mat == Material.SOIL || mat == Material.SOUL_SAND)){
+    		event.setCancelled(true);
+    	}
+    }
+
+    private boolean isMonster(Entity ent) {
+    	return (ent instanceof Monster || ent instanceof Slime || ent instanceof Ghast);
+    }
+    
+    private boolean isAnimal(Entity ent) {
+    	return (ent instanceof Horse || ent instanceof Bat || ent instanceof Snowman || ent instanceof IronGolem || ent instanceof Ocelot || ent instanceof Pig || ent instanceof Sheep || ent instanceof Chicken || ent instanceof Wolf || ent instanceof Cow || ent instanceof Squid || ent instanceof Villager || ent instanceof Rabbit);
+    }
+    
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void AnimalKilling (EntityDamageByEntityEvent event){
+		Entity damager = event.getDamager();
+		
+		if ((!(damager instanceof Arrow)) && (!(damager instanceof Player))) {
+			return;
+		}
+		
+		Player cause;
+		if ((damager instanceof Arrow) && (!(((Arrow) damager).getShooter() instanceof Player))) {
+			return;
+			
+		} else if (damager instanceof Player) {
+			cause = (Player) damager;
+		} else {
+			cause = (Player) ((Arrow) damager).getShooter();
+		}
+		
+		if (Residence.isResAdminOn(cause)) {
+			return;
+		}
+		
+		Entity entity = event.getEntity();
+		ClaimedResidence res = Residence.getResidenceManager().getByLoc(entity.getLocation());
+
+		if (res != null && !res.getPermissions().playerHas(cause.getName(), "animalkilling", true)) {
+			if (isAnimal(entity)) {
+				cause.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+				event.setCancelled(true);
+			}
+		}
+	}
+    
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onCreatureSpawn(CreatureSpawnEvent event) {
+        FlagPermissions perms = Residence.getPermsByLoc(event.getLocation());
+        Entity ent = event.getEntity();
+        if(isAnimal(ent)){
+        	if(!perms.has("animals", true)){
+        		event.setCancelled(true);
+        	}
+        } else {
+        	if (!perms.has("monsters", true) && isMonster(ent)) {
+        		event.setCancelled(true);
+        	}
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onHangingPlace(HangingPlaceEvent event) {
+        Player player = event.getPlayer();
+        if (Residence.isResAdminOn(player)) {
+            return;
+        }
+        FlagPermissions perms = Residence.getPermsByLocForPlayer(event.getEntity().getLocation(), player);
+        String pname = player.getName();
+        String world = player.getWorld().getName();
+        if (!perms.playerHas(pname, world, "place", perms.playerHas(pname, world, "build", true))) {
+            event.setCancelled(true);
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onHangingBreak(HangingBreakEvent event) {
+        if (event instanceof HangingBreakByEntityEvent) {
+            HangingBreakByEntityEvent evt = (HangingBreakByEntityEvent) event;
+            if (evt.getRemover() instanceof Player) {
+                Player player = (Player) evt.getRemover();
+                if (Residence.isResAdminOn(player)) {
+                    return;
+                }
+                String pname = player.getName();
+                FlagPermissions perms = Residence.getPermsByLocForPlayer(event.getEntity().getLocation(), player);
+                String world = event.getEntity().getWorld().getName();
+                if (!perms.playerHas(pname, world, "destroy", perms.playerHas(pname, world, "build", true))) {
+                    event.setCancelled(true);
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+                }
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onEntityCombust(EntityCombustEvent event) {
+        FlagPermissions perms = Residence.getPermsByLoc(event.getEntity().getLocation());
+        if (!perms.has("burn", true)) {
+            event.setCancelled(true);
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onExplosionPrime(ExplosionPrimeEvent event) {
+        EntityType entity = event.getEntityType();
+        FlagPermissions perms = Residence.getPermsByLoc(event.getEntity().getLocation());
+        if (entity == EntityType.CREEPER) {
+            if (!perms.has("creeper", perms.has("explode", true))) {
+                event.setCancelled(true);
+                event.getEntity().remove();
+            }
+        }
+        if (entity == EntityType.PRIMED_TNT || entity == EntityType.MINECART_TNT) {
+            if (!perms.has("tnt", perms.has("explode", true))) {
+                event.setCancelled(true);
+                event.getEntity().remove();
+            }
+        }
+        if (entity == EntityType.FIREBALL) {
+            if (!perms.has("fireball", perms.has("explode", true))) {
+                event.setCancelled(true);
+                event.getEntity().remove();
+            }
+        }
+        if (entity == EntityType.SMALL_FIREBALL) {
+            if (!perms.has("fireball", perms.has("explode", true))) {
+                event.setCancelled(true);
+                event.getEntity().remove();
+            }
+        }
+        if (entity == EntityType.WITHER_SKULL) {
+            if (!perms.has("witherdamage", perms.has("damage", true))) {
+                event.setCancelled(true);
+                event.getEntity().remove();
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onEntityExplode(EntityExplodeEvent event) {
+        if (event.isCancelled() || event.getEntity() == null)
+            return;
+        Boolean cancel = false;
+        EntityType entity = event.getEntityType();
+        FlagPermissions perms = Residence.getPermsByLoc(event.getEntity().getLocation());
+        FlagPermissions world = Residence.getWorldFlags().getPerms(event.getEntity().getWorld().getName());
+        if (entity == EntityType.CREEPER) {
+            if (!perms.has("creeper", perms.has("explode", true))) {
+                cancel = true;
+            }
+        }
+        if (entity == EntityType.PRIMED_TNT || entity == EntityType.MINECART_TNT) {
+            if (!perms.has("tnt", perms.has("explode", true))) {
+                cancel = true;
+            }
+        }
+        if (entity == EntityType.FIREBALL) {
+            if (!perms.has("fireball", perms.has("explode", true))) {
+                cancel = true;
+            }
+        }
+        if (entity == EntityType.SMALL_FIREBALL) {
+            if (!perms.has("fireball", perms.has("explode", true))) {
+                cancel = true;
+            }
+        }
+        if (entity == EntityType.WITHER_SKULL || entity == EntityType.WITHER) {
+            if (!perms.has("wither", perms.has("explode", world.has("wither", world.has("explode", true))))) {
+                cancel = true;
+            }
+        }
+        if (cancel) {
+            event.setCancelled(true);
+            event.getEntity().remove();
+        } else {
+            List<Block> preserve = new ArrayList<Block>();
+            for (Block block : event.blockList()) {
+                FlagPermissions blockperms = Residence.getPermsByLoc(block.getLocation());
+                if ((!blockperms.has("wither", blockperms.has("explode", world.has("wither", world.has("explode", true)))) && (entity == EntityType.WITHER || entity == EntityType.WITHER_SKULL) || (!blockperms.has("fireball", blockperms.has("explode", true)) && (entity == EntityType.FIREBALL || entity == EntityType.SMALL_FIREBALL)) || (!blockperms.has("tnt", blockperms.has("explode", true)) && (entity == EntityType.PRIMED_TNT || entity == EntityType.MINECART_TNT)) || (!blockperms.has("creeper", blockperms.has("explode", true)) && entity == EntityType.CREEPER))) {
+                    if (block != null) {
+                        preserve.add(block);
+                    }
+                }
+            }
+            for (Block block : preserve) {
+                event.blockList().remove(block);
+            }
+        }
+    }
+    
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onSplashPotion(PotionSplashEvent event) {
+    	if(event.isCancelled())
+    		return;
+    	Entity ent = event.getEntity();
+    	boolean srcpvp = Residence.getPermsByLoc(ent.getLocation()).has("pvp", true);
+    	Iterator<LivingEntity> it = event.getAffectedEntities().iterator();
+    	while(it.hasNext()){
+    		LivingEntity target = it.next();
+    		if(target.getType()==EntityType.PLAYER){
+    			Boolean tgtpvp = Residence.getPermsByLoc(target.getLocation()).has("pvp", true);
+    			if(!srcpvp || !tgtpvp){
+    				event.setIntensity(target, 0);
+    			}
+    		}
+    	}
+    }
+    
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
+    	if (event.getEntityType() == EntityType.ITEM_FRAME || event.getEntityType() == EntityType.ARMOR_STAND) {
+    		Entity dmgr = event.getDamager();
+    		Player player;
+    		if (event.getDamager() instanceof Player) {
+    			player = (Player) event.getDamager();
+    		} else {		
+    			if (dmgr instanceof Projectile && ((Projectile) dmgr).getShooter() instanceof Player) {
+    				player = (Player) ((Projectile) dmgr).getShooter();
+    			} else
+    				return;
+    		}
+    		
+    		if (Residence.isResAdminOn(player))
+    			return;
+    		
+    		// Note: Location of entity, not player; otherwise player could stand outside of res and still damage
+    		Location loc = event.getEntity().getLocation();
+    		ClaimedResidence res = Residence.getResidenceManager().getByLoc(loc);
+    		if (res != null && !res.getPermissions().playerHas(player.getName(), "container", false)) {
+    			event.setCancelled(true);
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("FlagDeny", "container"));
+    		}
+    	}
+    }
+    
+    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+    public void onEntityDamage(EntityDamageEvent event) {
+        Entity ent = event.getEntity();
+        if(ent.hasMetadata("NPC")) {
+            return;
+        }
+        boolean tamedWolf = ent instanceof Wolf ? ((Wolf)ent).isTamed() : false;
+        ClaimedResidence area = Residence.getResidenceManager().getByLoc(ent.getLocation());
+        /* Living Entities */
+        if (event instanceof EntityDamageByEntityEvent) {
+            EntityDamageByEntityEvent attackevent = (EntityDamageByEntityEvent) event;
+            Entity damager = attackevent.getDamager();
+            ClaimedResidence srcarea = null;
+            if (damager != null) {
+                srcarea = Residence.getResidenceManager().getByLoc(damager.getLocation());
+            }
+            boolean srcpvp = true;
+            if (srcarea != null) {
+                srcpvp = srcarea.getPermissions().has("pvp", true);
+            }
+            ent = attackevent.getEntity();
+            if ((ent instanceof Player || tamedWolf) && (damager instanceof Player || (damager instanceof Arrow && (((Arrow)damager).getShooter() instanceof Player)))) {
+                Player attacker = null;
+                if (damager instanceof Player) {
+                    attacker = (Player) damager;
+                } else if (damager instanceof Arrow) {
+                    attacker = (Player)((Arrow)damager).getShooter();
+                }
+                if(!srcpvp) {
+                    attacker.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoPVPZone"));
+                    event.setCancelled(true);
+                    return;
+                }
+                /* Check for Player vs Player */
+                if (area == null) {
+                    /* World PvP */
+                    if (!Residence.getWorldFlags().getPerms(damager.getWorld().getName()).has("pvp", true)) {
+                        attacker.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("WorldPVPDisabled"));
+                        event.setCancelled(true);
+                    }
+                } else {
+                    /* Normal PvP */
+                    if (!area.getPermissions().has("pvp", true)) {
+                        attacker.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("NoPVPZone"));
+                        event.setCancelled(true);
+                    }
+                }
+                return;
+            } else if ((ent instanceof Player || tamedWolf) && (damager instanceof Creeper)) {
+                if (area == null) {
+                    if (!Residence.getWorldFlags().getPerms(damager.getWorld().getName()).has("creeper", true)) {
+                        event.setCancelled(true);
+                    }
+                } else {
+                    if (!area.getPermissions().has("creeper", true)) {
+                        event.setCancelled(true);
+                    }
+                }
+            }
+        }
+        if (area == null) {
+            if (!Residence.getWorldFlags().getPerms(ent.getWorld().getName()).has("damage", true) && (ent instanceof Player || tamedWolf)) {
+                event.setCancelled(true);
+            }
+        } else {
+            if (!area.getPermissions().has("damage", true) && (ent instanceof Player || tamedWolf)) {
+                event.setCancelled(true);
+            }
+        }
+        if (event.isCancelled()) {
+            /* Put out a fire on a player */
+            if ((ent instanceof Player || tamedWolf)
+                    && (event.getCause() == EntityDamageEvent.DamageCause.FIRE
+                    || event.getCause() == EntityDamageEvent.DamageCause.FIRE_TICK)) {
+                ent.setFireTicks(0);
+            }
+        }
+    }
+}

src/com/bekvon/bukkit/residence/listeners/ResidencePlayerListener.java

@@ -0,0 +1,847 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.listeners;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Damageable;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Hanging;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+import org.bukkit.event.player.PlayerBucketEmptyEvent;
+import org.bukkit.event.player.PlayerBucketFillEvent;
+import org.bukkit.event.player.PlayerInteractAtEntityEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
+import org.bukkit.plugin.Plugin;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.chat.ChatChannel;
+import com.bekvon.bukkit.residence.event.ResidenceChangedEvent;
+import com.bekvon.bukkit.residence.event.ResidenceEnterEvent;
+import com.bekvon.bukkit.residence.event.ResidenceLeaveEvent;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import com.bekvon.bukkit.residence.protection.FlagPermissions;
+import com.bekvon.bukkit.residence.utils.ActionBar;
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+
+/**
+ * 
+ * @author Administrator
+ */
+@SuppressWarnings("deprecation")
+public class ResidencePlayerListener implements Listener {
+
+	protected Map<String, String> currentRes;
+	protected Map<String, Long> lastUpdate;
+	protected Map<String, Location> lastOutsideLoc;
+	protected int minUpdateTime;
+	protected boolean chatenabled;
+	protected List<String> playerToggleChat;
+
+	public ResidencePlayerListener() {
+		currentRes = new HashMap<String, String>();
+		lastUpdate = new HashMap<String, Long>();
+		lastOutsideLoc = new HashMap<String, Location>();
+		playerToggleChat = new ArrayList<String>();
+		minUpdateTime = Residence.getConfigManager().getMinMoveUpdateInterval();
+		chatenabled = Residence.getConfigManager().chatEnabled();
+		for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+			lastUpdate.put(player.getName(), System.currentTimeMillis());
+		}
+	}
+
+	public void reload() {
+		currentRes = new HashMap<String, String>();
+		lastUpdate = new HashMap<String, Long>();
+		lastOutsideLoc = new HashMap<String, Location>();
+		playerToggleChat = new ArrayList<String>();
+		minUpdateTime = Residence.getConfigManager().getMinMoveUpdateInterval();
+		chatenabled = Residence.getConfigManager().chatEnabled();
+		for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+			lastUpdate.put(player.getName(), System.currentTimeMillis());
+		}
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR)
+	public void onPlayerQuit(PlayerQuitEvent event) {
+		String pname = event.getPlayer().getName();
+		currentRes.remove(pname);
+		lastUpdate.remove(pname);
+		lastOutsideLoc.remove(pname);
+		Residence.getChatManager().removeFromChannel(pname);
+	}
+
+	@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+	public void onPlayerJoin(PlayerJoinEvent event) {
+		Player player = event.getPlayer();
+		lastUpdate.put(player.getName(), 0L);
+		if (Residence.getPermissionManager().isResidenceAdmin(player)) {
+			Residence.turnResAdminOn(player);
+		}
+		handleNewLocation(player, player.getLocation(), false);
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerSpawn(PlayerRespawnEvent event) {
+		Location loc = event.getRespawnLocation();
+		Boolean bed = event.isBedSpawn();
+		Player player = event.getPlayer();
+		ClaimedResidence res = Residence.getResidenceManager().getByLoc(loc);
+		if (res == null) {
+			return;
+		}
+		if (res.getPermissions().playerHas(player.getName(), "move", true)) {
+			return;
+		}
+		if (bed) {
+			loc = player.getWorld().getSpawnLocation();
+		}
+		res = Residence.getResidenceManager().getByLoc(loc);
+		if (res != null) {
+			if (!res.getPermissions().playerHas(player.getName(), "move", true)) {
+				loc = res.getOutsideFreeLoc(loc);
+			}
+		}
+		player.sendMessage(ChatColor.RED
+				+ Residence.getLanguage().getPhrase("NoSpawn"));
+		event.setRespawnLocation(loc);
+	}
+
+	private boolean isContainer(Material mat, Block block) {
+		return FlagPermissions.getMaterialUseFlagList().containsKey(mat)
+				&& FlagPermissions.getMaterialUseFlagList().get(mat)
+						.equals("container")
+				|| Residence.getConfigManager().getCustomContainers()
+						.contains(Integer.valueOf(block.getTypeId()));
+	}
+
+	private boolean isCanUseEntity_BothClick(Material mat, Block block) {
+		return mat == Material.LEVER
+				|| mat == Material.STONE_BUTTON
+				|| mat == Material.WOOD_BUTTON
+				|| mat == Material.WOODEN_DOOR
+				|| mat == Material.SPRUCE_DOOR
+				|| mat == Material.BIRCH_DOOR
+				|| mat == Material.JUNGLE_DOOR
+				|| mat == Material.ACACIA_DOOR
+				|| mat == Material.DARK_OAK_DOOR
+				|| mat == Material.SPRUCE_FENCE_GATE
+				|| mat == Material.BIRCH_FENCE_GATE
+				|| mat == Material.JUNGLE_FENCE_GATE
+				|| mat == Material.ACACIA_FENCE_GATE
+				|| mat == Material.DARK_OAK_FENCE_GATE
+				|| mat == Material.TRAP_DOOR
+				|| mat == Material.FENCE_GATE
+				|| mat == Material.PISTON_BASE
+				|| mat == Material.PISTON_STICKY_BASE
+				|| mat == Material.DRAGON_EGG
+				|| Residence.getConfigManager().getCustomBothClick()
+						.contains(Integer.valueOf(block.getTypeId()));
+	}
+
+	private boolean isCanUseEntity_RClickOnly(Material mat, Block block) {
+		return mat == Material.ITEM_FRAME
+				|| mat == Material.BEACON
+				|| mat == Material.FLOWER_POT
+				|| mat == Material.COMMAND
+				|| mat == Material.ANVIL
+				|| mat == Material.CAKE_BLOCK
+				|| mat == Material.NOTE_BLOCK
+				|| mat == Material.DIODE
+				|| mat == Material.DIODE_BLOCK_OFF
+				|| mat == Material.DIODE_BLOCK_ON
+				|| mat == Material.BED_BLOCK
+				|| mat == Material.WORKBENCH
+				|| mat == Material.BREWING_STAND
+				|| mat == Material.ENCHANTMENT_TABLE
+				|| Residence.getConfigManager().getCustomRightClick()
+						.contains(Integer.valueOf(block.getTypeId()));
+	}
+
+	private boolean isCanUseEntity(Material mat, Block block) {
+		return isCanUseEntity_BothClick(mat, block)
+				|| isCanUseEntity_RClickOnly(mat, block);
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerInteract(PlayerInteractEvent event) {
+		Player player = event.getPlayer();
+		Material heldItem = player.getItemInHand().getType();
+		Block block = event.getClickedBlock();
+		if (block == null) {
+			return;
+		}
+		Material mat = block.getType();
+		if (!((isContainer(mat, block) || isCanUseEntity_RClickOnly(mat, block))
+				&& event.getAction() == Action.RIGHT_CLICK_BLOCK
+				|| isCanUseEntity_BothClick(mat, block) || event.getAction() == Action.PHYSICAL)) {
+			int typeId = player.getItemInHand().getTypeId();
+			if (typeId != Residence.getConfigManager().getSelectionTooldID()
+					&& typeId != Residence.getConfigManager().getInfoToolID()
+					&& typeId != 351 && typeId != 416) {
+				return;
+			}
+		}
+		FlagPermissions perms = Residence.getPermsByLocForPlayer(
+				block.getLocation(), player);
+		String world = player.getWorld().getName();
+		String permgroup = Residence.getPermissionManager()
+				.getGroupNameByPlayer(player);
+		boolean resadmin = Residence.isResAdminOn(player);
+		if (event.getAction() == Action.PHYSICAL) {
+			if (!resadmin) {
+				boolean hasuse = perms.playerHas(player.getName(), world,
+						"use", true);
+				boolean haspressure = perms.playerHas(player.getName(), world,
+						"pressure", hasuse);
+				if ((!hasuse && !haspressure || !haspressure)
+						&& (mat == Material.STONE_PLATE || mat == Material.WOOD_PLATE)) {
+					event.setCancelled(true);
+					return;
+				}
+			}
+			if (!perms.playerHas(player.getName(), world, "trample",
+					perms.playerHas(player.getName(), world, "build", true))
+					&& (mat == Material.SOIL || mat == Material.SOUL_SAND)) {
+				event.setCancelled(true);
+				return;
+			}
+			return;
+		}
+		if (!resadmin
+				&& !Residence.getItemManager().isAllowed(heldItem, permgroup,
+						world)) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("ItemBlacklisted"));
+			event.setCancelled(true);
+			return;
+		}
+		if (event.getAction() == Action.LEFT_CLICK_BLOCK
+				|| event.getAction() == Action.RIGHT_CLICK_BLOCK) {
+			if (player.getItemInHand().getTypeId() == Residence
+					.getConfigManager().getSelectionTooldID()) {
+				Plugin wep = Bukkit.getPluginManager().getPlugin("WorldEdit");
+				if (wep != null) {
+					if (((WorldEditPlugin) wep).getConfig().getInt("wand-item") == Residence
+							.getConfigManager().getSelectionTooldID()) {
+						return;
+					}
+				}
+				PermissionGroup group = Residence.getPermissionManager()
+						.getGroup(player);
+				if (player.hasPermission("residence.select")
+						|| player.hasPermission("residence.create")
+						&& !player.isPermissionSet("residence.select")
+						|| group.canCreateResidences()
+						&& !player.isPermissionSet("residence.create")
+						&& !player.isPermissionSet("residence.select")
+						|| resadmin) {
+					if (event.getAction() == Action.LEFT_CLICK_BLOCK) {
+						Location loc = block.getLocation();
+						Residence.getSelectionManager().placeLoc1(player, loc);
+						player.sendMessage(ChatColor.GREEN
+								+ Residence.getLanguage().getPhrase(
+										"SelectPoint",
+										Residence.getLanguage().getPhrase(
+												"Primary")) + ChatColor.RED
+								+ "(" + loc.getBlockX() + "," + loc.getBlockY()
+								+ "," + loc.getBlockZ() + ")" + ChatColor.GREEN
+								+ "!");
+					} else if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
+						Location loc = block.getLocation();
+						Residence.getSelectionManager().placeLoc2(player, loc);
+						player.sendMessage(ChatColor.GREEN
+								+ Residence.getLanguage().getPhrase(
+										"SelectPoint",
+										Residence.getLanguage().getPhrase(
+												"Secondary")) + ChatColor.RED
+								+ "(" + loc.getBlockX() + "," + loc.getBlockY()
+								+ "," + loc.getBlockZ() + ")" + ChatColor.GREEN
+								+ "!");
+					}
+				}
+			}
+			if (player.getItemInHand().getTypeId() == Residence
+					.getConfigManager().getInfoToolID()) {
+				if (event.getAction() == Action.LEFT_CLICK_BLOCK) {
+					Location loc = block.getLocation();
+					String res = Residence.getResidenceManager().getNameByLoc(
+							loc);
+					if (res != null) {
+						Residence.getResidenceManager().printAreaInfo(res,
+								player);
+						event.setCancelled(true);
+					}
+					if (res == null) {
+						event.setCancelled(true);
+						player.sendMessage(Residence.getLanguage().getPhrase(
+								"NoResHere"));
+					}
+				}
+			}
+			if (!resadmin) {
+				if (heldItem != null) {
+					if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
+						if (player.getItemInHand().getTypeId() == 351) {
+							if (player.getItemInHand().getData().getData() == 15
+									&& block.getType() == Material.GRASS
+									|| player.getItemInHand().getData()
+											.getData() == 3
+									&& block.getTypeId() == 17
+									&& (block.getData() == 3
+											|| block.getData() == 7
+											|| block.getData() == 11 || block
+											.getData() == 15)) {
+								perms = Residence.getPermsByLocForPlayer(block
+										.getRelative(event.getBlockFace())
+										.getLocation(), player);
+								if (!perms.playerHas(player.getName(), world,
+										"build", true)) {
+									event.setCancelled(true);
+									return;
+								}
+							}
+						}
+						if (heldItem == Material.ARMOR_STAND) {
+							perms = Residence.getPermsByLocForPlayer(block
+									.getRelative(event.getBlockFace())
+									.getLocation(), player);
+							if (!perms.playerHas(player.getName(), world,
+									"build", true)) {
+								player.sendMessage(ChatColor.RED
+										+ Residence.getLanguage().getPhrase(
+												"NoPermission"));
+								event.setCancelled(true);
+								return;
+							}
+						}
+					}
+				}
+				if (isContainer(mat, block) || isCanUseEntity(mat, block)) {
+					boolean hasuse = perms.playerHas(player.getName(), world,
+							"use", true);
+					for (Entry<Material, String> checkMat : FlagPermissions
+							.getMaterialUseFlagList().entrySet()) {
+						if (mat == checkMat.getKey()) {
+							if (!perms.playerHas(player.getName(), world,
+									checkMat.getValue(), hasuse)) {
+								if (hasuse
+										|| checkMat.getValue().equals(
+												"container")) {
+									event.setCancelled(true);
+									player.sendMessage(ChatColor.RED
+											+ Residence
+													.getLanguage()
+													.getPhrase("FlagDeny",
+															checkMat.getValue()));
+									return;
+								} else {
+									event.setCancelled(true);
+									player.sendMessage(ChatColor.RED
+											+ Residence.getLanguage()
+													.getPhrase("FlagDeny",
+															"use"));
+									return;
+								}
+							}
+						}
+					}
+					if (Residence.getConfigManager().getCustomContainers()
+							.contains(Integer.valueOf(block.getTypeId()))) {
+						if (!perms.playerHas(player.getName(), world,
+								"container", hasuse)) {
+							event.setCancelled(true);
+							player.sendMessage(ChatColor.RED
+									+ Residence.getLanguage().getPhrase(
+											"FlagDeny", "container"));
+							return;
+						}
+					}
+					if (Residence.getConfigManager().getCustomBothClick()
+							.contains(Integer.valueOf(block.getTypeId()))) {
+						if (!hasuse) {
+							event.setCancelled(true);
+							player.sendMessage(ChatColor.RED
+									+ Residence.getLanguage().getPhrase(
+											"FlagDeny", "use"));
+							return;
+						}
+					}
+					if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
+						if (Residence.getConfigManager().getCustomRightClick()
+								.contains(Integer.valueOf(block.getTypeId()))) {
+							if (!hasuse) {
+								event.setCancelled(true);
+								player.sendMessage(ChatColor.RED
+										+ Residence.getLanguage().getPhrase(
+												"FlagDeny", "use"));
+								return;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
+		Player player = event.getPlayer();
+		if (Residence.isResAdminOn(player)) {
+			return;
+		}
+		Entity ent = event.getRightClicked();
+		/* Trade */
+		if (ent.getType() == EntityType.VILLAGER) {
+			ClaimedResidence res = Residence.getResidenceManager().getByLoc(
+					event.getPlayer().getLocation());
+
+			if (res != null
+					&& !res.getPermissions().playerHas(player.getName(),
+							"trade", true)) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("NoPermission"));
+				event.setCancelled(true);
+			}
+		}
+
+		/* Container - ItemFrame protection */
+		Material heldItem = player.getItemInHand().getType();
+		if (!(ent instanceof Hanging)) {
+			return;
+		}
+		Hanging hanging = (Hanging) ent;
+		if (hanging.getType() != EntityType.ITEM_FRAME) {
+			return;
+		}
+		FlagPermissions perms = Residence.getPermsByLocForPlayer(
+				ent.getLocation(), player);
+		String world = player.getWorld().getName();
+		String permgroup = Residence.getPermissionManager()
+				.getGroupNameByPlayer(player);
+		if (!Residence.getItemManager().isAllowed(heldItem, permgroup, world)) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("ItemBlacklisted"));
+			event.setCancelled(true);
+			return;
+		}
+		if (!perms.playerHas(player.getName(), world, "container",
+				perms.playerHas(player.getName(), world, "use", true))) {
+			event.setCancelled(true);
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage()
+							.getPhrase("FlagDeny", "container"));
+		}
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerInteractAtEntity(PlayerInteractAtEntityEvent event) {
+		Player player = event.getPlayer();
+		if (Residence.isResAdminOn(player)) {
+			return;
+		}
+
+		Entity ent = event.getRightClicked();
+		if (ent.getType() != EntityType.ARMOR_STAND) {
+			return;
+		}
+
+		FlagPermissions perms = Residence.getPermsByLocForPlayer(
+				ent.getLocation(), player);
+		String world = player.getWorld().getName();
+
+		if (!perms.playerHas(player.getName(), world, "container",
+				perms.playerHas(player.getName(), world, "use", true))) {
+			event.setCancelled(true);
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage()
+							.getPhrase("FlagDeny", "container"));
+		}
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event) {
+		Player player = event.getPlayer();
+		if (Residence.isResAdminOn(player)) {
+			return;
+		}
+		String pname = player.getName();
+		ClaimedResidence res = Residence.getResidenceManager().getByLoc(
+				event.getBlockClicked().getLocation());
+		if (res != null) {
+			if (Residence.getConfigManager().preventRentModify()
+					&& Residence.getConfigManager().enabledRentSystem()) {
+				if (Residence.getRentManager().isRented(res.getName())) {
+					player.sendMessage(ChatColor.RED
+							+ Residence.getLanguage().getPhrase(
+									"RentedModifyDeny"));
+					event.setCancelled(true);
+					return;
+				}
+			}
+		}
+		FlagPermissions perms = Residence.getPermsByLocForPlayer(event
+				.getBlockClicked().getLocation(), player);
+		if (!perms.playerHas(pname, player.getWorld().getName(), "bucket",
+				perms.playerHas(pname, player.getWorld().getName(), "build",
+						true))) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("FlagDeny", "bucket"));
+			event.setCancelled(true);
+		}
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerBucketFill(PlayerBucketFillEvent event) {
+		Player player = event.getPlayer();
+		String pname = player.getName();
+		if (Residence.isResAdminOn(player)) {
+			return;
+		}
+		ClaimedResidence res = Residence.getResidenceManager().getByLoc(
+				event.getBlockClicked().getLocation());
+		if (res != null) {
+			if (Residence.getConfigManager().preventRentModify()
+					&& Residence.getConfigManager().enabledRentSystem()) {
+				if (Residence.getRentManager().isRented(res.getName())) {
+					player.sendMessage(ChatColor.RED
+							+ Residence.getLanguage().getPhrase(
+									"RentedModifyDeny"));
+					event.setCancelled(true);
+					return;
+				}
+			}
+		}
+		FlagPermissions perms = Residence.getPermsByLocForPlayer(event
+				.getBlockClicked().getLocation(), player);
+		boolean hasbucket = perms.playerHas(pname, player.getWorld().getName(),
+				"bucket", perms.playerHas(pname, player.getWorld().getName(),
+						"build", true));
+		if (!hasbucket) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("FlagDeny", "bucket"));
+			event.setCancelled(true);
+		}
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerTeleport(PlayerTeleportEvent event) {
+		Location loc = event.getTo();
+		Player player = event.getPlayer();
+
+		if (Residence.isResAdminOn(player)) {
+			handleNewLocation(player, loc, false);
+			return;
+		}
+
+		ClaimedResidence res = Residence.getResidenceManager().getByLoc(loc);
+		if (event.getCause() == TeleportCause.ENDER_PEARL
+				|| event.getCause() == TeleportCause.COMMAND
+				|| event.getCause() == TeleportCause.NETHER_PORTAL) {
+			if (res != null) {
+				String areaname = Residence.getResidenceManager().getNameByLoc(
+						loc);
+				if (!res.getPermissions().playerHas(player.getName(), "move",
+						true)) {
+					event.setCancelled(true);
+					player.sendMessage(ChatColor.RED
+							+ Residence.getLanguage().getPhrase(
+									"ResidenceMoveDeny", areaname));
+					return;
+				}
+			}
+		}
+		if (event.getCause() == TeleportCause.PLUGIN) {
+			if (res != null) {
+				String areaname = Residence.getResidenceManager().getNameByLoc(
+						loc);
+				if (!res.getPermissions().playerHas(player.getName(), "tp",
+						true)
+						&& !player.hasPermission("residence.admin.tp")) {
+					event.setCancelled(true);
+					player.sendMessage(ChatColor.RED
+							+ Residence.getLanguage().getPhrase("TeleportDeny",
+									areaname));
+					return;
+				}
+			}
+		}
+		handleNewLocation(player, loc, false);
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerMove(PlayerMoveEvent event) {
+		Player player = event.getPlayer();
+		if (player == null) {
+			return;
+		}
+		long last = lastUpdate.get(player.getName());
+		long now = System.currentTimeMillis();
+		if (now - last < Residence.getConfigManager()
+				.getMinMoveUpdateInterval()) {
+			return;
+		}
+		lastUpdate.put(player.getName(), now);
+		if (event.getFrom().getWorld() == event.getTo().getWorld()) {
+			if (event.getFrom().distance(event.getTo()) == 0) {
+				return;
+			}
+		}
+		handleNewLocation(player, event.getTo(), true);
+	}
+
+	public void handleNewLocation(Player player, Location loc, boolean move) {
+		String pname = player.getName();
+
+		ClaimedResidence res = Residence.getResidenceManager().getByLoc(loc);
+		String areaname = null;
+		boolean chatchange = false;
+		String subzone = null;
+		if (res != null) {
+			areaname = Residence.getResidenceManager().getNameByLoc(loc);
+			while (res.getSubzoneByLoc(player.getLocation()) != null) {
+				subzone = res.getSubzoneNameByLoc(player.getLocation());
+				res = res.getSubzoneByLoc(player.getLocation());
+				areaname = areaname + "." + subzone;
+			}
+		}
+		ClaimedResidence ResOld = null;
+		if (currentRes.containsKey(pname)) {
+			ResOld = Residence.getResidenceManager().getByName(
+					currentRes.get(pname));
+			if (ResOld == null) {
+				currentRes.remove(pname);
+			}
+		}
+		if (res == null) {
+			lastOutsideLoc.put(pname, loc);
+			if (ResOld != null) {
+				String leave = ResOld.getLeaveMessage();
+				/*
+				 * TODO - ResidenceLeaveEvent is deprecated as of 21-MAY-2013.
+				 * Its functionality is replaced by ResidenceChangedEvent. For
+				 * now, this event is still supported until it is removed at a
+				 * suitable time in the future.
+				 */
+				ResidenceLeaveEvent leaveevent = new ResidenceLeaveEvent(
+						ResOld, player);
+				Residence.getServ().getPluginManager().callEvent(leaveevent);
+
+				// New ResidenceChangeEvent
+				ResidenceChangedEvent chgEvent = new ResidenceChangedEvent(
+						ResOld, null, player);
+				Residence.getServ().getPluginManager().callEvent(chgEvent);
+
+				if (leave != null && !leave.equals("")) {
+					if (Residence.getConfigManager().useActionBar()) {
+						ActionBar
+								.send(player,
+										(new StringBuilder())
+												.append(ChatColor.YELLOW)
+												.append(insertMessages(player,
+														ResOld.getName(),
+														ResOld, leave))
+												.toString());
+					} else {
+						player.sendMessage(ChatColor.YELLOW
+								+ this.insertMessages(player, ResOld.getName(),
+										ResOld, leave));
+					}
+				}
+				currentRes.remove(pname);
+				Residence.getChatManager().removeFromChannel(pname);
+			}
+			return;
+		}
+		if (move) {
+			if (!res.getPermissions().playerHas(pname, "move", true)
+					&& !Residence.isResAdminOn(player)
+					&& !player.hasPermission("residence.admin.move")) {
+				Location lastLoc = lastOutsideLoc.get(pname);
+				if (lastLoc != null) {
+					player.teleport(lastLoc);
+				} else {
+					player.teleport(res.getOutsideFreeLoc(loc));
+				}
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase(
+								"ResidenceMoveDeny",
+								res.getName().split("\\.")[res.getName().split(
+										"\\.").length - 1]));
+				return;
+			}
+		}
+		lastOutsideLoc.put(pname, loc);
+		if (!currentRes.containsKey(pname) || ResOld != res) {
+			currentRes.put(pname, areaname);
+			if (subzone == null) {
+				chatchange = true;
+			}
+
+			// "from" residence for ResidenceChangedEvent
+			ClaimedResidence chgFrom = null;
+			if (ResOld != res && ResOld != null) {
+				String leave = ResOld.getLeaveMessage();
+				chgFrom = ResOld;
+
+				/*
+				 * TODO - ResidenceLeaveEvent is deprecated as of 21-MAY-2013.
+				 * Its functionality is replaced by ResidenceChangedEvent. For
+				 * now, this event is still supported until it is removed at a
+				 * suitable time in the future.
+				 */
+				ResidenceLeaveEvent leaveevent = new ResidenceLeaveEvent(
+						ResOld, player);
+				Residence.getServ().getPluginManager().callEvent(leaveevent);
+
+				if (leave != null && !leave.equals("")
+						&& ResOld != res.getParent()) {
+					if (Residence.getConfigManager().useActionBar()) {
+						ActionBar
+								.send(player,
+										(new StringBuilder())
+												.append(ChatColor.YELLOW)
+												.append(insertMessages(player,
+														ResOld.getName(),
+														ResOld, leave))
+												.toString());
+					} else {
+						player.sendMessage(ChatColor.YELLOW
+								+ this.insertMessages(player, ResOld.getName(),
+										ResOld, leave));
+					}
+				}
+			}
+			String enterMessage = res.getEnterMessage();
+
+			/*
+			 * TODO - ResidenceEnterEvent is deprecated as of 21-MAY-2013. Its
+			 * functionality is replaced by ResidenceChangedEvent. For now, this
+			 * event is still supported until it is removed at a suitable time
+			 * in the future.
+			 */
+			ResidenceEnterEvent enterevent = new ResidenceEnterEvent(res,
+					player);
+			Residence.getServ().getPluginManager().callEvent(enterevent);
+
+			// New ResidenceChangedEvent
+			ResidenceChangedEvent chgEvent = new ResidenceChangedEvent(chgFrom,
+					res, player);
+			Residence.getServ().getPluginManager().callEvent(chgEvent);
+
+			if (enterMessage != null && !enterMessage.equals("")
+					&& !(ResOld != null && res == ResOld.getParent())) {
+				if (Residence.getConfigManager().useActionBar()) {
+					ActionBar.send(
+							player,
+							(new StringBuilder())
+									.append(ChatColor.YELLOW)
+									.append(insertMessages(player, areaname,
+											res, enterMessage)).toString());
+				} else {
+					player.sendMessage(ChatColor.YELLOW
+							+ this.insertMessages(player, areaname, res,
+									enterMessage));
+				}
+			}
+		}
+		if (chatchange && chatenabled) {
+			Residence.getChatManager().setChannel(pname, areaname);
+		}
+	}
+
+	public String insertMessages(Player player, String areaname,
+			ClaimedResidence res, String message) {
+		try {
+			message = message.replaceAll("%player", player.getName());
+			message = message.replaceAll("%owner", res.getPermissions()
+					.getOwner());
+			message = message.replaceAll("%residence", areaname);
+		} catch (Exception ex) {
+			return "";
+		}
+		return message;
+	}
+
+	public void doHeals() {
+		try {
+			for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+				String resname = Residence.getPlayerListener()
+						.getCurrentResidenceName(player.getName());
+				ClaimedResidence res = null;
+				if (resname != null) {
+					res = Residence.getResidenceManager().getByName(resname);
+				}
+				if (res != null && res.getPermissions().has("healing", false)) {
+					Damageable damage = player;
+					double health = damage.getHealth();
+					if (health < 20 && !player.isDead()) {
+						player.setHealth(health + 1);
+					}
+				}
+			}
+		} catch (Exception ex) {
+		}
+	}
+
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	public void onPlayerChat(AsyncPlayerChatEvent event) {
+		String pname = event.getPlayer().getName();
+		if (chatenabled && playerToggleChat.contains(pname)) {
+			String area = currentRes.get(pname);
+			if (area != null) {
+				ChatChannel channel = Residence.getChatManager().getChannel(
+						area);
+				if (channel != null) {
+					channel.chat(pname, event.getMessage());
+				}
+				event.setCancelled(true);
+			}
+		}
+	}
+
+	public void tooglePlayerResidenceChat(Player player) {
+		String pname = player.getName();
+		if (playerToggleChat.contains(pname)) {
+			playerToggleChat.remove(pname);
+			player.sendMessage(ChatColor.YELLOW
+					+ Residence.getLanguage().getPhrase("ResidenceChat",
+							ChatColor.RED + "OFF" + ChatColor.YELLOW + "!"));
+		} else {
+			playerToggleChat.add(pname);
+			player.sendMessage(ChatColor.YELLOW
+					+ Residence.getLanguage().getPhrase("ResidenceChat",
+							ChatColor.RED + "ON" + ChatColor.YELLOW + "!"));
+		}
+	}
+
+	public String getCurrentResidenceName(String player) {
+		return currentRes.get(player);
+	}
+}

src/com/bekvon/bukkit/residence/permissions/PermissionGroup.java

@@ -0,0 +1,320 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.permissions;
+
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.CuboidArea;
+import com.bekvon.bukkit.residence.protection.FlagPermissions;
+import com.bekvon.bukkit.residence.protection.FlagPermissions.FlagState;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.entity.Player;
+
+/**
+ * 
+ * @author Administrator
+ * 
+ *         changed by inori 03/17/2012 line 91:limits MaxHeight changed to 255
+ */
+public class PermissionGroup {
+    protected int xmax;
+    protected int ymax;
+    protected int zmax;
+    protected int resmax;
+    protected double costperarea;
+    protected boolean tpaccess;
+    protected int subzonedepth;
+    protected FlagPermissions flagPerms;
+    protected Map<String, Boolean> creatorDefaultFlags;
+    protected Map<String, Map<String, Boolean>> groupDefaultFlags;
+    protected Map<String, Boolean> residenceDefaultFlags;
+    protected boolean messageperms;
+    protected String defaultEnterMessage;
+    protected String defaultLeaveMessage;
+    protected int maxLeaseTime;
+    protected int leaseGiveTime;
+    protected double renewcostperarea;
+    protected boolean canBuy;
+    protected boolean canSell;
+    protected boolean buyIgnoreLimits;
+    protected boolean cancreate;
+    protected String groupname;
+    protected int maxPhysical;
+    protected boolean unstuck;
+    protected boolean kick;
+    protected int minHeight;
+    protected int maxHeight;
+    protected int maxRents;
+    protected int maxRentables;
+    protected boolean selectCommandAccess;
+    protected boolean itemListAccess;
+
+    public PermissionGroup(String name) {
+        flagPerms = new FlagPermissions();
+        creatorDefaultFlags = new HashMap<String, Boolean>();
+        residenceDefaultFlags = new HashMap<String, Boolean>();
+        groupDefaultFlags = new HashMap<String, Map<String, Boolean>>();
+        groupname = name;
+    }
+
+    public PermissionGroup(String name, ConfigurationSection node) {
+        this(name);
+        this.parseGroup(node);
+    }
+
+    public PermissionGroup(String name, ConfigurationSection node, FlagPermissions parentFlagPerms) {
+        this(name, node);
+        flagPerms.setParent(parentFlagPerms);
+    }
+
+    private void parseGroup(ConfigurationSection limits) {
+        if (limits == null) {
+            return;
+        }
+        cancreate = limits.getBoolean("Residence.CanCreate", false);
+        resmax = limits.getInt("Residence.MaxResidences", 0);
+        maxPhysical = limits.getInt("Residence.MaxAreasPerResidence", 2);
+        xmax = limits.getInt("Residence.MaxEastWest", 0);
+        ymax = limits.getInt("Residence.MaxUpDown", 0);
+        zmax = limits.getInt("Residence.MaxNorthSouth", 0);
+        minHeight = limits.getInt("Residence.MinHeight", 0);
+        maxHeight = limits.getInt("Residence.MaxHeight", 255);
+        tpaccess = limits.getBoolean("Residence.CanTeleport", false);
+        subzonedepth = limits.getInt("Residence.SubzoneDepth", 0);
+        messageperms = limits.getBoolean("Messaging.CanChange", false);
+        defaultEnterMessage = limits.getString("Messaging.DefaultEnter", null);
+        defaultLeaveMessage = limits.getString("Messaging.DefaultLeave", null);
+        maxLeaseTime = limits.getInt("Lease.MaxDays", 16);
+        leaseGiveTime = limits.getInt("Lease.RenewIncrement", 14);
+        maxRents = limits.getInt("Rent.MaxRents", 0);
+        maxRentables = limits.getInt("Rent.MaxRentables", 0);
+        renewcostperarea = limits.getDouble("Economy.RenewCost", 0.02D);
+        canBuy = limits.getBoolean("Economy.CanBuy", false);
+        canSell = limits.getBoolean("Economy.CanSell", false);
+        buyIgnoreLimits = limits.getBoolean("Economy.IgnoreLimits", false);
+        costperarea = limits.getDouble("Economy.BuyCost", 0);
+        unstuck = limits.getBoolean("Residence.Unstuck", false);
+        kick = limits.getBoolean("Residence.Kick", false);
+        selectCommandAccess = limits.getBoolean("Residence.SelectCommandAccess", true);
+        itemListAccess = limits.getBoolean("Residence.ItemListAccess", true);
+        ConfigurationSection node = limits.getConfigurationSection("Flags.Permission");
+        Set<String> flags = null;
+        if (node != null) {
+            flags = node.getKeys(false);
+        }
+        if (flags != null) {
+            Iterator<String> flagit = flags.iterator();
+            while (flagit.hasNext()) {
+                String flagname = flagit.next();
+                boolean access = limits.getBoolean("Flags.Permission." + flagname, false);
+                flagPerms.setFlag(flagname, access ? FlagState.TRUE : FlagState.FALSE);
+            }
+        }
+        node = limits.getConfigurationSection("Flags.CreatorDefault");
+        if (node != null) {
+            flags = node.getKeys(false);
+        }
+        if (flags != null) {
+            Iterator<String> flagit = flags.iterator();
+            while (flagit.hasNext()) {
+                String flagname = flagit.next();
+                boolean access = limits.getBoolean("Flags.CreatorDefault." + flagname, false);
+                creatorDefaultFlags.put(flagname, access);
+            }
+
+        }
+        node = limits.getConfigurationSection("Flags.Default");
+        if (node != null) {
+            flags = node.getKeys(false);
+        }
+        if (flags != null) {
+            Iterator<String> flagit = flags.iterator();
+            while (flagit.hasNext()) {
+                String flagname = flagit.next();
+                boolean access = limits.getBoolean("Flags.Default." + flagname, false);
+                residenceDefaultFlags.put(flagname, access);
+            }
+        }
+        node = limits.getConfigurationSection("Flags.GroupDefault");
+        Set<String> groupDef = null;
+        if (node != null) {
+            groupDef = node.getKeys(false);
+        }
+        if (groupDef != null) {
+            Iterator<String> groupit = groupDef.iterator();
+            while (groupit.hasNext()) {
+                String name = groupit.next();
+                Map<String, Boolean> gflags = new HashMap<String, Boolean>();
+                flags = limits.getConfigurationSection("Flags.GroupDefault." + name).getKeys(false);
+                Iterator<String> flagit = flags.iterator();
+                while (flagit.hasNext()) {
+                    String flagname = flagit.next();
+                    boolean access = limits.getBoolean("Flags.GroupDefault." + name + "." + flagname, false);
+                    gflags.put(flagname, access);
+                }
+                groupDefaultFlags.put(name, gflags);
+            }
+        }
+    }
+
+    public int getMaxX() {
+        return xmax;
+    }
+
+    public int getMaxY() {
+        return ymax;
+    }
+
+    public int getMaxZ() {
+        return zmax;
+    }
+
+    public int getMinHeight() {
+        return minHeight;
+    }
+
+    public int getMaxHeight() {
+        return maxHeight;
+    }
+
+    public int getMaxZones() {
+        return resmax;
+    }
+
+    public double getCostPerBlock() {
+        return costperarea;
+    }
+
+    public boolean hasTpAccess() {
+        return tpaccess;
+    }
+
+    public int getMaxSubzoneDepth() {
+        return subzonedepth;
+    }
+
+    public boolean canSetEnterLeaveMessages() {
+        return messageperms;
+    }
+
+    public String getDefaultEnterMessage() {
+        return defaultEnterMessage;
+    }
+
+    public String getDefaultLeaveMessage() {
+        return defaultLeaveMessage;
+    }
+
+    public int getMaxLeaseTime() {
+        return maxLeaseTime;
+    }
+
+    public int getLeaseGiveTime() {
+        return leaseGiveTime;
+    }
+
+    public double getLeaseRenewCost() {
+        return renewcostperarea;
+    }
+
+    public boolean canBuyLand() {
+        return canBuy;
+    }
+
+    public boolean canSellLand() {
+        return canSell;
+    }
+
+    public int getMaxRents() {
+        return maxRents;
+    }
+
+    public int getMaxRentables() {
+        return maxRentables;
+    }
+
+    public boolean buyLandIgnoreLimits() {
+        return buyIgnoreLimits;
+    }
+
+    public boolean hasUnstuckAccess() {
+        return unstuck;
+    }
+    public boolean hasKickAccess() {
+	return kick;
+    }
+    public int getMaxPhysicalPerResidence() {
+        return maxPhysical;
+    }
+
+    public Set<Entry<String, Boolean>> getDefaultResidenceFlags() {
+        return residenceDefaultFlags.entrySet();
+    }
+
+    public Set<Entry<String, Boolean>> getDefaultCreatorFlags() {
+        return creatorDefaultFlags.entrySet();
+    }
+
+    public Set<Entry<String, Map<String, Boolean>>> getDefaultGroupFlags() {
+        return groupDefaultFlags.entrySet();
+    }
+
+    public boolean canCreateResidences() {
+        return cancreate;
+    }
+
+    public boolean hasFlagAccess(String flag) {
+        return flagPerms.has(flag, false);
+    }
+
+    public boolean inLimits(CuboidArea area) {
+        if (area.getXSize() > xmax || area.getYSize() > ymax || area.getZSize() > zmax) {
+            return false;
+        }
+        return true;
+    }
+
+    public boolean selectCommandAccess() {
+        return selectCommandAccess;
+    }
+
+    public boolean itemListAccess() {
+        return itemListAccess;
+    }
+
+    public void printLimits(Player player) {
+        player.sendMessage(ChatColor.GRAY + "---------------------------");
+        player.sendMessage(ChatColor.YELLOW + "Permissions Group:" + ChatColor.DARK_AQUA + " " + Residence.getPermissionManager().getPermissionsGroup(player));
+        player.sendMessage(ChatColor.YELLOW + "Residence Group:" + ChatColor.DARK_AQUA + " " + groupname);
+        player.sendMessage(ChatColor.YELLOW + "Residence Admin:" + ChatColor.DARK_AQUA + " " + Residence.getPermissionManager().isResidenceAdmin(player));
+        player.sendMessage(ChatColor.YELLOW + "Can Create Residences:" + ChatColor.DARK_AQUA + " " + cancreate);
+        player.sendMessage(ChatColor.YELLOW + "Max Residences:" + ChatColor.DARK_AQUA + " " + resmax);
+        player.sendMessage(ChatColor.YELLOW + "Max East/West Size:" + ChatColor.DARK_AQUA + " " + xmax);
+        player.sendMessage(ChatColor.YELLOW + "Max North/South Size:" + ChatColor.DARK_AQUA + " " + zmax);
+        player.sendMessage(ChatColor.YELLOW + "Max Up/Down Size:" + ChatColor.DARK_AQUA + " " + ymax);
+        player.sendMessage(ChatColor.YELLOW + "Min/Max Protection Height:" + ChatColor.DARK_AQUA + " " + minHeight + " to " + maxHeight);
+        player.sendMessage(ChatColor.YELLOW + "Max Subzone Depth:" + ChatColor.DARK_AQUA + " " + subzonedepth);
+        player.sendMessage(ChatColor.YELLOW + "Can Set Enter/Leave Messages:" + ChatColor.DARK_AQUA + " " + messageperms);
+        player.sendMessage(ChatColor.YELLOW + "Number of Residences you own:" + ChatColor.DARK_AQUA + " " + Residence.getResidenceManager().getOwnedZoneCount(player.getName()));
+        if (Residence.getEconomyManager() != null) {
+            player.sendMessage(ChatColor.YELLOW + "Residence Cost Per Block:" + ChatColor.DARK_AQUA + " " + costperarea);
+        }
+        player.sendMessage(ChatColor.YELLOW + "Flag Permissions:" + ChatColor.DARK_AQUA + " " + flagPerms.listFlags());
+        if (Residence.getConfigManager().useLeases()) {
+            player.sendMessage(ChatColor.YELLOW + "Max Lease Days:" + ChatColor.DARK_AQUA + " " + maxLeaseTime);
+            player.sendMessage(ChatColor.YELLOW + "Lease Time Given on Renew:" + ChatColor.DARK_AQUA + " " + leaseGiveTime);
+            player.sendMessage(ChatColor.YELLOW + "Renew Cost Per Block:" + ChatColor.DARK_AQUA + " " + renewcostperarea);
+        }
+        player.sendMessage(ChatColor.GRAY + "---------------------------");
+    }
+
+}

src/com/bekvon/bukkit/residence/permissions/PermissionManager.java

@@ -0,0 +1,180 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.permissions;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.FlagPermissions;
+import com.bekvon.bukkit.residence.vaultinterface.ResidenceVaultAdapter;
+import java.util.*;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import org.bukkit.Server;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+/**
+ * 
+ * @author Administrator
+ */
+public class PermissionManager {
+	protected static PermissionsInterface perms;
+	protected Map<String, PermissionGroup> groups;
+	protected Map<String, String> playersGroup;
+	protected FlagPermissions globalFlagPerms;
+
+	public PermissionManager(FileConfiguration config) {
+		try {
+			groups = Collections
+					.synchronizedMap(new HashMap<String, PermissionGroup>());
+			playersGroup = Collections
+					.synchronizedMap(new HashMap<String, String>());
+			globalFlagPerms = new FlagPermissions();
+			this.readConfig(config);
+			boolean enable = config
+					.getBoolean("Global.EnablePermissions", true);
+			if (enable) {
+				this.checkPermissions();
+			}
+		} catch (Exception ex) {
+			Logger.getLogger(PermissionManager.class.getName()).log(
+					Level.SEVERE, null, ex);
+		}
+	}
+
+	public PermissionGroup getGroup(Player player) {
+		return groups.get(this.getGroupNameByPlayer(player));
+	}
+
+	public PermissionGroup getGroup(String player, String world) {
+		return groups.get(this.getGroupNameByPlayer(player, world));
+	}
+
+	public PermissionGroup getGroupByName(String group) {
+		group = group.toLowerCase();
+		if (!groups.containsKey(group)) {
+			return groups.get(Residence.getConfigManager().getDefaultGroup());
+		}
+		return groups.get(group);
+	}
+
+	public String getGroupNameByPlayer(Player player) {
+		return this.getGroupNameByPlayer(player.getName(), player.getWorld()
+				.getName());
+	}
+
+	public String getGroupNameByPlayer(String player, String world) {
+		player = player.toLowerCase();
+		if (playersGroup.containsKey(player)) {
+			String group = playersGroup.get(player);
+			if (group != null) {
+				group = group.toLowerCase();
+				if (group != null && groups.containsKey(group)) {
+					return group;
+				}
+			}
+		}
+		String group = this.getPermissionsGroup(player, world);
+		if (group == null || !groups.containsKey(group)) {
+			return Residence.getConfigManager().getDefaultGroup().toLowerCase();
+		} else {
+			return group;
+		}
+	}
+
+	public String getPermissionsGroup(Player player) {
+		return this.getPermissionsGroup(player.getName(), player.getWorld()
+				.getName());
+	}
+
+	public String getPermissionsGroup(String player, String world) {
+		if (perms == null)
+			return Residence.getConfigManager().getDefaultGroup();
+		return perms.getPlayerGroup(player, world);
+	}
+
+	public boolean isResidenceAdmin(Player player) {
+		return (player.hasPermission("residence.admin") || (player.isOp() && Residence
+				.getConfigManager().getOpsAreAdmins()));
+	}
+
+	private void checkPermissions() {
+		Server server = Residence.getServ();
+		Plugin p = server.getPluginManager().getPlugin("Vault");
+		if (p != null) {
+			ResidenceVaultAdapter vault = new ResidenceVaultAdapter(server);
+			if (vault.permissionsOK()) {
+				perms = vault;
+				Logger.getLogger("Minecraft").log(
+						Level.INFO,
+						"[Residence] Found Vault using permissions plugin:"
+								+ vault.getPermissionsName());
+				return;
+			} else {
+				Logger.getLogger("Minecraft")
+						.log(Level.INFO,
+								"[Residence] Found Vault, but Vault reported no usable permissions system...");
+			}
+		}
+		Logger.getLogger("Minecraft").log(Level.INFO,
+				"[Residence] Permissions plugin NOT FOUND!");
+	}
+
+	private void readConfig(FileConfiguration config) {
+		String defaultGroup = Residence.getConfigManager().getDefaultGroup();
+		globalFlagPerms = FlagPermissions.parseFromConfigNode("FlagPermission",
+				config.getConfigurationSection("Global"));
+		ConfigurationSection nodes = config.getConfigurationSection("Groups");
+		if (nodes != null) {
+			Set<String> entrys = nodes.getKeys(false);
+			for (String key : entrys) {
+				try {
+					groups.put(
+							key.toLowerCase(),
+							new PermissionGroup(key.toLowerCase(), nodes
+									.getConfigurationSection(key),
+									globalFlagPerms));
+					List<String> mirrors = nodes.getConfigurationSection(key)
+							.getStringList("Mirror");
+					for (String group : mirrors) {
+						groups.put(
+								group.toLowerCase(),
+								new PermissionGroup(key.toLowerCase(), nodes
+										.getConfigurationSection(key),
+										globalFlagPerms));
+					}
+				} catch (Exception ex) {
+					System.out
+							.println("[Residence] Error parsing group from config:"
+									+ key + " Exception:" + ex);
+				}
+			}
+		}
+		if (!groups.containsKey(defaultGroup)) {
+			groups.put(defaultGroup, new PermissionGroup(defaultGroup));
+		}
+		Set<String> keys = config.getConfigurationSection("GroupAssignments")
+				.getKeys(false);
+		if (keys != null) {
+			for (String key : keys) {
+				playersGroup.put(
+						key.toLowerCase(),
+						config.getString("GroupAssignments." + key,
+								defaultGroup).toLowerCase());
+			}
+		}
+	}
+
+	public boolean hasGroup(String group) {
+		group = group.toLowerCase();
+		return groups.containsKey(group);
+	}
+
+	public PermissionsInterface getPermissionsPlugin() {
+		return perms;
+	}
+}

src/com/bekvon/bukkit/residence/permissions/PermissionsInterface.java

@@ -0,0 +1,17 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.permissions;
+
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public interface PermissionsInterface {
+    public String getPlayerGroup(Player player);
+    public String getPlayerGroup(String player, String world);
+}

src/com/bekvon/bukkit/residence/persistance/YMLSaveHelper.java

@@ -0,0 +1,67 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.persistance;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.yaml.snakeyaml.DumperOptions;
+import org.yaml.snakeyaml.DumperOptions.FlowStyle;
+import org.yaml.snakeyaml.Yaml;
+
+/**
+ *
+ * @author Administrator
+ */
+public class YMLSaveHelper {
+
+    File f;
+    Yaml yml;
+    Map<String,Object> root;
+
+    public YMLSaveHelper(File ymlfile) throws IOException
+    {
+        DumperOptions options = new DumperOptions();
+        options.setDefaultFlowStyle(FlowStyle.BLOCK);
+        yml = new Yaml(options);
+        
+        root = new LinkedHashMap<String,Object>();
+        if(ymlfile == null)
+            throw new IOException("YMLSaveHelper: null file...");
+        f = ymlfile;
+    }
+
+    public void save() throws IOException
+    {
+        if(f.isFile())
+            f.delete();
+        FileOutputStream fout = new FileOutputStream(f);
+        OutputStreamWriter osw = new OutputStreamWriter(fout, "UTF8");
+        yml.dump(root, osw);
+        osw.close();
+    }
+
+    @SuppressWarnings("unchecked")
+	public void load() throws IOException
+    {
+        FileInputStream fis = new FileInputStream(f);
+        InputStreamReader isr = new InputStreamReader(fis, "UTF8");
+		root = (Map<String, Object>) yml.load(isr);
+        isr.close();
+    }
+
+    public Map<String,Object> getRoot()
+    {
+        return root;
+    }
+
+}

src/com/bekvon/bukkit/residence/protection/ClaimedResidence.java

@@ -0,0 +1,966 @@
+/*
+ * 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.ResidenceBank;
+import com.bekvon.bukkit.residence.economy.TransactionManager;
+import com.bekvon.bukkit.residence.event.ResidenceTPEvent;
+import com.bekvon.bukkit.residence.itemlist.ItemList.ListType;
+import com.bekvon.bukkit.residence.itemlist.ResidenceItemList;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+import com.bekvon.bukkit.residence.text.help.InformationPager;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+/**
+ * 
+ * @author Administrator
+ * 
+ */
+public class ClaimedResidence {
+
+    protected ClaimedResidence parent;
+    protected Map<String, CuboidArea> areas;
+    protected Map<String, ClaimedResidence> subzones;
+    protected ResidencePermissions perms;
+    protected ResidenceBank bank;
+    protected Location tpLoc;
+    protected String enterMessage;
+    protected String leaveMessage;
+    protected ResidenceItemList ignorelist;
+    protected ResidenceItemList blacklist;
+
+    private ClaimedResidence() {
+        subzones = new HashMap<String, ClaimedResidence>();
+        areas = new HashMap<String, CuboidArea>();
+        bank = new ResidenceBank(this);
+        blacklist = new ResidenceItemList(this, ListType.BLACKLIST);
+        ignorelist = new ResidenceItemList(this, ListType.IGNORELIST);
+    }
+
+    public ClaimedResidence(String creationWorld) {
+        this("Server Land", creationWorld);
+    }
+
+    public ClaimedResidence(String creator, String creationWorld) {
+        this();
+        perms = new ResidencePermissions(this, creator, creationWorld);
+    }
+
+    public ClaimedResidence(String creator, String creationWorld, ClaimedResidence parentResidence) {
+        this(creator, creationWorld);
+        parent = parentResidence;
+    }
+
+    public boolean addArea(CuboidArea area, String name) {
+        return addArea(null, area, name, true);
+    }
+
+    public boolean addArea(Player player, CuboidArea area, String name, boolean resadmin) {
+        if (!Residence.validName(name)) {
+            if (player != null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidNameCharacters"));
+            }
+            return false;
+        }
+        if (areas.containsKey(name)) {
+            if (player != null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaExists"));
+            }
+            return false;
+        }
+        if (!resadmin && Residence.getConfigManager().getEnforceAreaInsideArea() && this.getParent() == null) {
+            boolean inside = false;
+            for (CuboidArea are: areas.values()) {
+                if (are.isAreaWithinArea(area)) {
+                    inside = true;
+                }
+            }
+            if (!inside) {
+                return false;
+            }
+        }
+        if (!area.getWorld().getName().equalsIgnoreCase(perms.getWorld())) {
+            if (player != null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaDiffWorld"));
+            }
+            return false;
+        }
+        if (parent == null) {
+            String collideResidence = Residence.getResidenceManager().checkAreaCollision(area, this);
+            if (collideResidence != null) {
+                if (player != null) {
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaCollision", ChatColor.YELLOW + collideResidence));
+                }
+                return false;
+            }
+        } else {
+            String[] szs = parent.listSubzones();
+            for (String sz : szs) {
+                ClaimedResidence res = parent.getSubzone(sz);
+                if (res != null && res != this) {
+                    if (res.checkCollision(area)) {
+                        if (player != null) {
+                            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaSubzoneCollision", ChatColor.YELLOW + sz));
+                        }
+                        return false;
+                    }
+                }
+            }
+        }
+        if (!resadmin && player != null) {
+            if (!this.perms.hasResidencePermission(player, true)) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+                return false;
+            }
+            if (parent != null) {
+                if (!parent.containsLoc(area.getHighLoc()) || !parent.containsLoc(area.getLowLoc())) {
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaNotWithinParent"));
+                    return false;
+                }
+                if (!parent.getPermissions().hasResidencePermission(player, true) && !parent.getPermissions().playerHas(player.getName(), "subzone", true)) {
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ParentNoPermission"));
+                    return false;
+                }
+            }
+            PermissionGroup group = Residence.getPermissionManager().getGroup(player);
+            if (!group.canCreateResidences() && !player.hasPermission("residence.create")) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+                return false;
+            }
+            if (areas.size() >= group.getMaxPhysicalPerResidence()) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaMaxPhysical"));
+                return false;
+            }
+            if (!group.inLimits(area)) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaSizeLimit"));
+                return false;
+            }
+            if (group.getMinHeight() > area.getLowLoc().getBlockY()) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaLowLimit", ChatColor.YELLOW + String.format("%d", group.getMinHeight())));
+                return false;
+            }
+            if (group.getMaxHeight() < area.getHighLoc().getBlockY()) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaHighLimit", ChatColor.YELLOW + String.format("%d", group.getMaxHeight())));
+                return false;
+            }
+            if (parent == null && Residence.getConfigManager().enableEconomy()) {
+                int chargeamount = (int) Math.ceil((double) area.getSize() * group.getCostPerBlock());
+                if (!TransactionManager.chargeEconomyMoney(player, chargeamount)) {
+                    return false;
+                }
+            }
+        }
+        Residence.getResidenceManager().removeChunkList(getName());
+        areas.put(name, area);
+        Residence.getResidenceManager().calculateChunks(getName());
+        if (player != null) {
+            player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("AreaCreate", ChatColor.YELLOW + name));
+        }
+        return true;
+    }
+
+    public boolean replaceArea(CuboidArea neware, String name) {
+        return this.replaceArea(null, neware, name, true);
+    }
+
+    public boolean replaceArea(Player player, CuboidArea newarea, String name, boolean resadmin) {
+        if (!areas.containsKey(name)) {
+            if (player != null)
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaNonExist"));
+            return false;
+        }
+        CuboidArea oldarea = areas.get(name);
+        if (!newarea.getWorld().getName().equalsIgnoreCase(perms.getWorld())) {
+            if (player != null)
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaDiffWorld"));
+            return false;
+        }
+        if (parent == null) {
+            String collideResidence = Residence.getResidenceManager().checkAreaCollision(newarea, this);
+            if (collideResidence != null) {
+                if (player != null)
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaCollision", ChatColor.YELLOW + collideResidence));
+                return false;
+            }
+        } else {
+            String[] szs = parent.listSubzones();
+            for (String sz : szs) {
+                ClaimedResidence res = parent.getSubzone(sz);
+                if (res != null && res != this) {
+                    if (res.checkCollision(newarea)) {
+                        if (player != null)
+                            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaSubzoneCollision", ChatColor.YELLOW + sz));
+                        return false;
+                    }
+                }
+            }
+        }
+        //Remove subzones that are not in the area anymore
+        String[] szs = listSubzones();
+        for (String sz : szs) {
+            ClaimedResidence res = getSubzone(sz);
+            if (res != null && res != this) {
+                String[] areas = res.getAreaList();
+                for (String area: areas) {
+                    if (!newarea.isAreaWithinArea(res.getArea(area))) {
+                        boolean good = false;
+                        for (CuboidArea arae: getAreaArray()) {
+                            if (arae != oldarea && arae.isAreaWithinArea(res.getArea(area))) {
+                                good = true;
+                            }
+                        }
+                        if (!good) {
+                            res.removeArea(area);
+                        }
+                    }
+                }
+                if (res.getAreaArray().length == 0) {
+                    removeSubzone(sz);
+                }
+            }
+        }
+        if (!resadmin && player != null) {
+            if (!this.perms.hasResidencePermission(player, true)) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+                return false;
+            }
+            if (parent != null) {
+                if (!parent.containsLoc(newarea.getHighLoc()) || !parent.containsLoc(newarea.getLowLoc())) {
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaNotWithinParent"));
+                    return false;
+                }
+                if (!parent.getPermissions().hasResidencePermission(player, true) && !parent.getPermissions().playerHas(player.getName(), "subzone", true)) {
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ParentNoPermission"));
+                    return false;
+                }
+            }
+            PermissionGroup group = Residence.getPermissionManager().getGroup(player);
+            if (!group.canCreateResidences() && !player.hasPermission("residence.create")) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+                return false;
+            }
+            if (!group.inLimits(newarea)) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaSizeLimit"));
+                return false;
+            }
+            if (group.getMinHeight() > newarea.getLowLoc().getBlockY()) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaLowLimit", ChatColor.YELLOW + String.format("%d", group.getMinHeight())));
+                return false;
+            }
+            if (group.getMaxHeight() < newarea.getHighLoc().getBlockY()) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaHighLimit", ChatColor.YELLOW + String.format("%d", group.getMaxHeight())));
+                return false;
+            }
+            if (parent == null && Residence.getConfigManager().enableEconomy()) {
+                int chargeamount = (int) Math.ceil((double) (newarea.getSize() - oldarea.getSize()) * group.getCostPerBlock());
+                if (chargeamount > 0) {
+                    if (!TransactionManager.chargeEconomyMoney(player, chargeamount)) {
+                        return false;
+                    }
+                }
+            }
+
+        }
+        Residence.getResidenceManager().removeChunkList(getName());
+        areas.remove(name);
+        areas.put(name, newarea);
+        Residence.getResidenceManager().calculateChunks(getName());
+        player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("AreaUpdate"));
+        return true;
+    }
+
+    public boolean addSubzone(String name, Location loc1, Location loc2) {
+        return this.addSubzone(null, loc1, loc2, name, true);
+    }
+
+    public boolean addSubzone(Player player, Location loc1, Location loc2, String name, boolean resadmin) {
+        if (player == null) {
+            return this.addSubzone(null, "Server Land", loc1, loc2, name, resadmin);
+        } else {
+            return this.addSubzone(player, player.getName(), loc1, loc2, name, resadmin);
+        }
+    }
+
+    public boolean addSubzone(Player player, String owner, Location loc1, Location loc2, String name, boolean resadmin) {
+        if (!Residence.validName(name)) {
+            if (player != null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidNameCharacters"));
+            }
+            return false;
+        }
+        if (!(this.containsLoc(loc1) && this.containsLoc(loc2))) {
+            if (player != null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneSelectInside"));
+            }
+            return false;
+        }
+        if (subzones.containsKey(name)) {
+            if (player != null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneExists", ChatColor.YELLOW + name));
+            }
+            return false;
+        }
+        if (!resadmin && player != null) {
+            if (!this.perms.hasResidencePermission(player, true)) {
+                if (!this.perms.playerHas(player.getName(), "subzone", this.perms.playerHas(player.getName(), "admin", false))) {
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+                    return false;
+                }
+            }
+            PermissionGroup group = Residence.getPermissionManager().getGroup(player);
+            if (this.getZoneDepth() >= group.getMaxSubzoneDepth()) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneMaxDepth"));
+                return false;
+            }
+        }
+        CuboidArea newArea = new CuboidArea(loc1, loc2);
+        Set<Entry<String, ClaimedResidence>> set = subzones.entrySet();
+        for (Entry<String, ClaimedResidence> resEntry : set) {
+            ClaimedResidence res = resEntry.getValue();
+            if (res.checkCollision(newArea)) {
+                if (player != null) {
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneCollide", ChatColor.YELLOW + resEntry.getKey()));
+                }
+                return false;
+            }
+        }
+        ClaimedResidence newres;
+        if (player != null) {
+            newres = new ClaimedResidence(owner, perms.getWorld(), this);
+            newres.addArea(player, newArea, name, resadmin);
+        } else {
+            newres = new ClaimedResidence(owner, perms.getWorld(), this);
+            newres.addArea(newArea, name);
+        }
+        if (newres.getAreaCount() != 0) {
+            newres.getPermissions().applyDefaultFlags();
+            if (player != null) {
+                PermissionGroup group = Residence.getPermissionManager().getGroup(player);
+                newres.setEnterMessage(group.getDefaultEnterMessage());
+                newres.setLeaveMessage(group.getDefaultLeaveMessage());
+            }
+            if (Residence.getConfigManager().flagsInherit()) {
+                newres.getPermissions().setParent(perms);
+            }
+            subzones.put(name, newres);
+            if (player != null)
+                player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SubzoneCreate", ChatColor.YELLOW + name));
+            return true;
+        } else {
+            if (player != null) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneCreateFail", ChatColor.YELLOW + name));
+            }
+            return false;
+        }
+    }
+
+    public String getSubzoneNameByLoc(Location loc) {
+        Set<Entry<String, ClaimedResidence>> set = subzones.entrySet();
+        ClaimedResidence res = null;
+        String key = null;
+        for (Entry<String, ClaimedResidence> entry : set) {
+            res = entry.getValue();
+            if (res.containsLoc(loc)) {
+                key = entry.getKey();
+                break;
+            }
+        }
+        if (key == null) {
+            return null;
+        }
+        String subname = res.getSubzoneNameByLoc(loc);
+        if (subname != null) {
+            return key + "." + subname;
+        }
+        return key;
+    }
+
+    public ClaimedResidence getSubzoneByLoc(Location loc) {
+        Set<Entry<String, ClaimedResidence>> set = subzones.entrySet();
+        boolean found = false;
+        ClaimedResidence res = null;
+        for (Entry<String, ClaimedResidence> entry : set) {
+            res = entry.getValue();
+            if (res.containsLoc(loc)) {
+                found = true;
+                break;
+            }
+        }
+        if (!found) {
+            return null;
+        }
+        ClaimedResidence subrez = res.getSubzoneByLoc(loc);
+        if (subrez == null) {
+            return res;
+        }
+        return subrez;
+    }
+
+    public ClaimedResidence getSubzone(String subzonename) {
+        if (!subzonename.contains(".")) {
+            return subzones.get(subzonename);
+        }
+        String split[] = subzonename.split("\\.");
+        ClaimedResidence get = subzones.get(split[0]);
+        for (int i = 1; i < split.length; i++) {
+            if (get == null) {
+                return null;
+            }
+            get = get.getSubzone(split[i]);
+        }
+        return get;
+    }
+
+    public String getSubzoneNameByRes(ClaimedResidence res) {
+        Set<Entry<String, ClaimedResidence>> set = subzones.entrySet();
+        for (Entry<String, ClaimedResidence> entry : set) {
+            if (entry.getValue() == res) {
+                return entry.getKey();
+            }
+            String n = entry.getValue().getSubzoneNameByRes(res);
+            if (n != null) {
+                return entry.getKey() + "." + n;
+            }
+        }
+        return null;
+    }
+
+    public String[] getSubzoneList() {
+        ArrayList<String> zones = new ArrayList<String>();
+        Set<String> set = subzones.keySet();
+        for (String key : set) {
+            if (key != null) {
+                zones.add(key);
+            }
+        }
+        return zones.toArray(new String[zones.size()]);
+    }
+
+    public boolean checkCollision(CuboidArea area) {
+        Set<String> set = areas.keySet();
+        for (String key : set) {
+            CuboidArea checkarea = areas.get(key);
+            if (checkarea != null) {
+                if (checkarea.checkCollision(area)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    public boolean containsLoc(Location loc) {
+        Collection<CuboidArea> keys = areas.values();
+        for (CuboidArea key : keys) {
+            if (key.containsLoc(loc)) {
+                if (parent != null)
+                    return parent.containsLoc(loc);
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public ClaimedResidence getParent() {
+        return parent;
+    }
+
+    public ClaimedResidence getTopParent() {
+        if (parent == null)
+            return this;
+        return parent.getTopParent();
+    }
+
+    public boolean removeSubzone(String name) {
+        return this.removeSubzone(null, name, true);
+    }
+
+    public boolean removeSubzone(Player player, String name, boolean resadmin) {
+        ClaimedResidence res = subzones.get(name);
+        if (player != null && !res.perms.hasResidencePermission(player, true) && !resadmin) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+            return false;
+        }
+        subzones.remove(name);
+        if (player != null) {
+            player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SubzoneRemove", ChatColor.YELLOW + name + ChatColor.GREEN));
+        }
+        return true;
+    }
+
+    public long getTotalSize() {
+        Collection<CuboidArea> set = areas.values();
+        long size = 0;
+        for (CuboidArea entry : set) {
+            size = size + entry.getSize();
+        }
+        return size;
+    }
+
+    public CuboidArea[] getAreaArray() {
+        CuboidArea[] temp = new CuboidArea[areas.size()];
+        int i = 0;
+        for (CuboidArea area : areas.values()) {
+            temp[i] = area;
+            i++;
+        }
+        return temp;
+    }
+
+    public ResidencePermissions getPermissions() {
+        return perms;
+    }
+
+    public String getEnterMessage() {
+        return enterMessage;
+    }
+
+    public String getLeaveMessage() {
+        return leaveMessage;
+    }
+
+    public void setEnterMessage(String message) {
+        enterMessage = message;
+    }
+
+    public void setLeaveMessage(String message) {
+        leaveMessage = message;
+    }
+
+    public void setEnterLeaveMessage(Player player, String message, boolean enter, boolean resadmin) {
+        // if(message!=null &&
+        // Residence.getConfigManager().getResidenceNameRegex() != null) {
+        // Removed pending further action
+        // player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidCharacters"));
+        // return;
+        // }
+        if (message != null) {
+            if (message.equals("")) {
+                message = null;
+            }
+        }
+        PermissionGroup group = Residence.getPermissionManager().getGroup(perms.getOwner(), perms.getWorld());
+        if (!group.canSetEnterLeaveMessages() && !resadmin) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("OwnerNoPermission"));
+            return;
+        }
+        if (!perms.hasResidencePermission(player, false) && !resadmin) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+            return;
+        }
+        if (enter) {
+            this.setEnterMessage(message);
+        } else {
+            this.setLeaveMessage(message);
+        }
+        player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("MessageChange"));
+    }
+
+    @SuppressWarnings("deprecation")
+	public Location getOutsideFreeLoc(Location insideLoc) {
+        int maxIt = 100;
+        CuboidArea area = this.getAreaByLoc(insideLoc);
+        if (area == null) {
+            return insideLoc;
+        }
+        Location highLoc = area.getHighLoc();
+        Location newLoc = new Location(highLoc.getWorld(), highLoc.getBlockX(), highLoc.getBlockY(), highLoc.getBlockZ());
+        boolean found = false;
+        int it = 0;
+        while (!found && it < maxIt) {
+            it++;
+            Location lowLoc;
+            newLoc.setX(newLoc.getBlockX() + 1);
+            newLoc.setZ(newLoc.getBlockZ() + 1);
+            lowLoc = new Location(newLoc.getWorld(), newLoc.getBlockX(), 254, newLoc.getBlockZ());
+            newLoc.setY(255);
+            while ((newLoc.getBlock().getTypeId() != 0 || lowLoc.getBlock().getTypeId() == 0) && lowLoc.getBlockY() > -126) {
+                newLoc.setY(newLoc.getY() - 1);
+                lowLoc.setY(lowLoc.getY() - 1);
+            }
+			if (newLoc.getBlock().getTypeId() == 0
+					&& lowLoc.getBlock().getTypeId() != 0) {
+                found = true;
+            }
+        }
+        if (found) {
+            return newLoc;
+        } else {
+            World world = Residence.getServ().getWorld(perms.getWorld());
+            if (world != null) {
+                return world.getSpawnLocation();
+            }
+            return insideLoc;
+        }
+    }
+
+    protected CuboidArea getAreaByLoc(Location loc) {
+        for (CuboidArea thisarea : areas.values()) {
+            if (thisarea.containsLoc(loc)) {
+                return thisarea;
+            }
+        }
+        return null;
+    }
+
+    public String[] listSubzones() {
+        String list[] = new String[subzones.size()];
+        int i = 0;
+        for (String res : subzones.keySet()) {
+            list[i] = res;
+            i++;
+        }
+        return list;
+    }
+
+    public void printSubzoneList(Player player, int page) {
+        ArrayList<String> temp = new ArrayList<String>();
+        for (Entry<String, ClaimedResidence> sz : subzones.entrySet()) {
+            temp.add(ChatColor.GREEN + sz.getKey() + ChatColor.YELLOW + " - " + Residence.getLanguage().getPhrase("Owner") + ": " + sz.getValue().getOwner());
+        }
+        InformationPager.printInfo(player, Residence.getLanguage().getPhrase("Subzones"), temp, page);
+    }
+
+    public void printAreaList(Player player, int page) {
+        ArrayList<String> temp = new ArrayList<String>();
+        for (String area : areas.keySet()) {
+            temp.add(area);
+        }
+        InformationPager.printInfo(player, Residence.getLanguage().getPhrase("PhysicalAreas"), temp, page);
+    }
+
+    public void printAdvancedAreaList(Player player, int page) {
+        ArrayList<String> temp = new ArrayList<String>();
+        for (Entry<String, CuboidArea> entry : areas.entrySet()) {
+            CuboidArea a = entry.getValue();
+            Location h = a.getHighLoc();
+            Location l = a.getLowLoc();
+            temp.add(ChatColor.GREEN + "{" + ChatColor.YELLOW + "ID:" + ChatColor.RED + entry.getKey() + " " + ChatColor.YELLOW + "P1:" + ChatColor.RED + "(" + h.getBlockX() + "," + h.getBlockY() + "," + h.getBlockZ() + ") " + ChatColor.YELLOW + "P2:" + ChatColor.RED + "(" + l.getBlockX() + "," + l.getBlockY() + "," + l.getBlockZ() + ") " + ChatColor.YELLOW + "(Size:" + ChatColor.RED + a.getSize() + ChatColor.YELLOW + ")" + ChatColor.GREEN + "} ");
+        }
+        InformationPager.printInfo(player, Residence.getLanguage().getPhrase("PhysicalAreas"), temp, page);
+    }
+
+    public String[] getAreaList() {
+        String arealist[] = new String[areas.size()];
+        int i = 0;
+        for (Entry<String, CuboidArea> entry : areas.entrySet()) {
+            arealist[i] = entry.getKey();
+            i++;
+        }
+        return arealist;
+    }
+
+    public int getZoneDepth() {
+        int count = 0;
+        ClaimedResidence res = parent;
+        while (res != null) {
+            count++;
+            res = res.getParent();
+        }
+        return count;
+    }
+
+    public void setTpLoc(Player player, boolean resadmin) {
+        if (!this.perms.hasResidencePermission(player, false) && !resadmin) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+            return;
+        }
+        if (!this.containsLoc(player.getLocation())) {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NotInResidence"));
+            return;
+        }
+        tpLoc = player.getLocation();
+        player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SetTeleportLocation"));
+    }
+
+    public void tpToResidence(Player reqPlayer, Player targetPlayer, boolean resadmin) {
+        if (!resadmin) {
+            PermissionGroup group = Residence.getPermissionManager().getGroup(reqPlayer);
+            if (!group.hasTpAccess()) {
+                reqPlayer.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("TeleportDeny"));
+                return;
+            }
+            if (!reqPlayer.equals(targetPlayer)) {
+                reqPlayer.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+                return;
+            }
+            if (!this.perms.playerHas(reqPlayer.getName(), "tp", true)) {
+                reqPlayer.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("TeleportNoFlag"));
+                return;
+            }
+        }
+        if (tpLoc != null) {
+            ResidenceTPEvent tpevent = new ResidenceTPEvent(this, tpLoc, targetPlayer, reqPlayer);
+            Residence.getServ().getPluginManager().callEvent(tpevent);
+            if (!tpevent.isCancelled()) {
+                targetPlayer.teleport(tpLoc);
+                targetPlayer.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("TeleportSuccess"));
+            }
+        } else {
+            CuboidArea area = areas.values().iterator().next();
+            if (area == null) {
+                reqPlayer.sendMessage(ChatColor.RED + "Could not find area to teleport to...");
+                return;
+            }
+            Location targloc = this.getOutsideFreeLoc(area.getHighLoc());
+            ResidenceTPEvent tpevent = new ResidenceTPEvent(this, targloc, targetPlayer, reqPlayer);
+            Residence.getServ().getPluginManager().callEvent(tpevent);
+            if (!tpevent.isCancelled()) {
+                targetPlayer.teleport(targloc);
+                targetPlayer.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("TeleportNear"));
+            }
+        }
+    }
+
+    public String getAreaIDbyLoc(Location loc) {
+        for (Entry<String, CuboidArea> area : areas.entrySet()) {
+            if (area.getValue().containsLoc(loc))
+                return area.getKey();
+        }
+        return null;
+    }
+
+    public void removeArea(String id) {
+        Residence.getResidenceManager().removeChunkList(getName());
+        areas.remove(id);
+        Residence.getResidenceManager().calculateChunks(getName());
+    }
+
+    public void removeArea(Player player, String id, boolean resadmin) {
+
+        if (this.getPermissions().hasResidencePermission(player, true) || resadmin) {
+            if (!areas.containsKey(id)) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaNonExist"));
+                return;
+            }
+            if (areas.size() == 1 && !Residence.getConfigManager().allowEmptyResidences()) {
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaRemoveLast"));
+                return;
+            }
+            removeArea(id);
+            player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("AreaRemove"));
+        } else {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+        }
+    }
+
+    public Map<String, Object> save() {
+        Map<String, Object> root = new HashMap<String, Object>();
+        Map<String, Object> areamap = new HashMap<String, Object>();
+        root.put("EnterMessage", enterMessage);
+        root.put("LeaveMessage", leaveMessage);
+        root.put("StoredMoney", bank.getStoredMoney());
+        root.put("BlackList", blacklist.save());
+        root.put("IgnoreList", ignorelist.save());
+        for (Entry<String, CuboidArea> entry : areas.entrySet())
+        {
+            areamap.put(entry.getKey(), entry.getValue().save());
+        }
+        root.put("Areas", areamap);
+        Map<String, Object> subzonemap = new HashMap<String, Object>();
+        for (Entry<String, ClaimedResidence> sz : subzones.entrySet())
+        {
+            subzonemap.put(sz.getKey(), sz.getValue().save());
+        }
+        root.put("Subzones", subzonemap);
+        root.put("Permissions", perms.save());
+        if (tpLoc != null)
+        {
+            Map<String, Object> tpmap = new HashMap<String, Object>();
+            tpmap.put("X", tpLoc.getBlockX());
+            tpmap.put("Y", tpLoc.getBlockY());
+            tpmap.put("Z", tpLoc.getBlockZ());
+            root.put("TPLoc", tpmap);
+        }
+        return root;
+    }
+
+    @SuppressWarnings("unchecked")
+	public static ClaimedResidence load(Map<String, Object> root, ClaimedResidence parent) throws Exception {
+        ClaimedResidence res = new ClaimedResidence();
+        if (root == null)
+            throw new Exception("Null residence!");
+        res.enterMessage = (String) root.get("EnterMessage");
+        res.leaveMessage = (String) root.get("LeaveMessage");
+        if (root.containsKey("StoredMoney"))
+            res.bank.setStoredMoney((Integer) root.get("StoredMoney"));
+        if (root.containsKey("BlackList"))
+            res.blacklist = ResidenceItemList.load(res, (Map<String, Object>) root.get("BlackList"));
+        if (root.containsKey("IgnoreList"))
+            res.ignorelist = ResidenceItemList.load(res, (Map<String, Object>) root.get("IgnoreList"));
+        Map<String, Object> areamap = (Map<String, Object>) root.get("Areas");
+		res.perms = ResidencePermissions.load(res,
+				(Map<String, Object>) root.get("Permissions"));
+        World world = Residence.getServ().getWorld(res.perms.getWorld());
+        if (world == null)
+            throw new Exception("Cant Find World: " + res.perms.getWorld());
+        for (Entry<String, Object> map : areamap.entrySet()) {
+            res.areas.put(map.getKey(), CuboidArea.load((Map<String, Object>) map.getValue(), world));
+        }
+        Map<String, Object> subzonemap = (Map<String, Object>) root.get("Subzones");
+        for (Entry<String, Object> map : subzonemap.entrySet()) {
+            ClaimedResidence subres = ClaimedResidence.load((Map<String, Object>) map.getValue(), res);
+            if (Residence.getConfigManager().flagsInherit())
+                subres.getPermissions().setParent(res.getPermissions());
+            res.subzones.put(map.getKey(), subres);
+        }
+        res.parent = parent;
+        Map<String, Object> tploc = (Map<String, Object>) root.get("TPLoc");
+        if (tploc != null) {
+            res.tpLoc = new Location(world, (Integer) tploc.get("X"), (Integer) tploc.get("Y"), (Integer) tploc.get("Z"));
+        }
+        return res;
+    }
+
+    public int getAreaCount()
+    {
+        return areas.size();
+    }
+
+    public boolean renameSubzone(String oldName, String newName)
+    {
+        return this.renameSubzone(null, oldName, newName, true);
+    }
+
+    public boolean renameSubzone(Player player, String oldName, String newName, boolean resadmin)
+    {
+        if (!Residence.validName(newName))
+        {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidNameCharacters"));
+            return false;
+        }
+        ClaimedResidence res = subzones.get(oldName);
+        if (res == null)
+        {
+            if (player != null)
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidSubzone"));
+            return false;
+        }
+        if (player != null && !res.getPermissions().hasResidencePermission(player, true) && !resadmin)
+        {
+            if (player != null)
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+            return false;
+        }
+        if (subzones.containsKey(newName))
+        {
+            if (player != null)
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneExists", ChatColor.YELLOW + newName));
+            return false;
+        }
+        subzones.put(newName, res);
+        subzones.remove(oldName);
+        if (player != null)
+            player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SubzoneRename", oldName + "." + newName));
+        return true;
+    }
+
+    public boolean renameArea(String oldName, String newName)
+    {
+        return this.renameArea(null, oldName, newName, true);
+    }
+
+    public boolean renameArea(Player player, String oldName, String newName, boolean resadmin)
+    {
+        if (!Residence.validName(newName))
+        {
+            player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidNameCharacters"));
+            return false;
+        }
+        if (player == null || perms.hasResidencePermission(player, true) || resadmin)
+        {
+            if (areas.containsKey(newName))
+            {
+                if (player != null)
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaExists"));
+                return false;
+            }
+            CuboidArea area = areas.get(oldName);
+            if (area == null)
+            {
+                if (player != null)
+                    player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaInvalidName"));
+                return false;
+            }
+            areas.put(newName, area);
+            areas.remove(oldName);
+            if (player != null)
+                player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("AreaRename", oldName + "." + newName));
+            return true;
+        }
+        else
+        {
+            if (player != null)
+                player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+            return false;
+        }
+    }
+
+    public CuboidArea getArea(String name)
+    {
+        return areas.get(name);
+    }
+
+    public String getName() {
+        return Residence.getResidenceManager().getNameByRes(this);
+    }
+
+    public void remove() {
+        String name = getName();
+        if (name != null) {
+            Residence.getResidenceManager().removeResidence(name);
+            Residence.getResidenceManager().removeChunkList(name);
+        }
+    }
+
+    public ResidenceBank getBank()
+    {
+        return bank;
+    }
+
+    public String getWorld()
+    {
+        return perms.getWorld();
+    }
+
+    public String getOwner()
+    {
+        return perms.getOwner();
+    }
+
+    public ResidenceItemList getItemBlacklist()
+    {
+        return blacklist;
+    }
+
+    public ResidenceItemList getItemIgnoreList()
+    {
+        return ignorelist;
+    }
+
+    public ArrayList<Player> getPlayersInResidence() {
+        ArrayList<Player> within = new ArrayList<Player>();
+        for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+            if (this.containsLoc(player.getLocation())) {
+                within.add(player);
+            }
+        }
+        return within;
+    }
+}

src/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/com/bekvon/bukkit/residence/protection/FlagPermissions.java

@@ -0,0 +1,663 @@
+/*
+ * 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/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/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/com/bekvon/bukkit/residence/protection/ResidenceManager.java

@@ -0,0 +1,726 @@
+/*
+ * 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.text.help.InformationPager;
+
+/**
+ * 
+ * @author Administrator
+ */
+public class ResidenceManager {
+    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 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 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 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 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, 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, int page, boolean showhidden) {
+        this.listResidences(player, player.getName(), page, showhidden);
+    }
+
+    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 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 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 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 void removeResidence(String name) {
+        this.removeResidence(null, name, true);
+    }
+
+    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 removeAllByOwner(String owner) {
+        this.removeAllByOwner(null, owner, residences);
+    }
+
+    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 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 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.getConfigManager().useLeases() && Residence.getLeaseManager().leaseExpires(areaname)) {
+            player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("LeaseExpire") + ":" + ChatColor.GREEN + " " + Residence.getLeaseManager().getExpireTime(areaname));
+        }
+    }
+
+    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 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;
+    }
+
+    @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) {
+                    System.out.println("Error in loading save file for world: " + 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;
+    }
+
+    private static List<ChunkRef> getChunks(ClaimedResidence res) {
+        List<ChunkRef> chunks = new ArrayList<ChunkRef>();
+        for (CuboidArea area : res.getAreaArray()) {
+            chunks.addAll(area.getChunks());
+        }
+        return chunks;
+    }
+
+    public boolean renameResidence(String oldName, String newName) {
+        return this.renameResidence(null, oldName, newName, 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 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 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 int getResidenceCount() {
+        return residences.size();
+    }
+
+    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 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 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(Location loc) {
+            this.x = getChunkCoord(loc.getBlockX());
+            this.z = getChunkCoord(loc.getBlockZ());
+        }
+        public ChunkRef(int x, int z) {
+            this.x = x;
+            this.z = z;
+        }
+
+        @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;
+        } 
+
+        public int hashCode() {
+            return x ^ z;
+        }
+        
+        /**
+         * Useful for debug
+         */
+        public String toString() {
+        	StringBuilder sb = new StringBuilder();
+        	sb.append( "{ x: " ).append(x).append( ", z: " ).append( z ).append( " }" );
+        	return sb.toString();
+        }
+    }
+}

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

@@ -0,0 +1,503 @@
+/*
+ * 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.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.PermissionManager;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+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.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidencePermissions extends FlagPermissions {
+
+    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 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);
+    }
+
+    @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);
+    }
+
+    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"));
+    }
+
+    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()));
+    }
+
+    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;
+    }
+
+    private boolean hasFlagAccess(String player, String flag)
+    {
+        PermissionGroup group = Residence.getPermissionManager().getGroup(player,world);
+        return group.hasFlagAccess(flag);
+    }
+
+    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;
+    }
+
+    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;
+    }
+
+    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;
+    }
+    
+    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;
+    }
+
+    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;
+    }
+
+
+    @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);
+    }
+
+    @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);
+    }
+
+    @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);
+    }
+
+    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 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 setOwner(String newOwner, boolean resetFlags)
+    {
+        ResidenceOwnerChangeEvent ownerchange = new ResidenceOwnerChangeEvent(residence,newOwner);
+        Residence.getServ().getPluginManager().callEvent(ownerchange);
+        owner = newOwner;
+        if(resetFlags)
+            this.applyDefaultFlags();
+    }
+
+    public String getOwner()
+    {
+        return owner;
+    }
+
+    public String getWorld()
+    {
+        return world;
+    }
+
+    @Override
+    public Map<String, Object> save() {
+        Map<String, Object> root = super.save();
+        root.put("Owner", owner);
+        root.put("World", world);
+        return root;
+    }
+
+    public static ResidencePermissions load(ClaimedResidence res, Map<String, Object> root) throws Exception {
+        ResidencePermissions newperms = new ResidencePermissions(res);
+        newperms.owner = (String) root.get("Owner");
+        newperms.world = (String) root.get("World");
+        FlagPermissions.load(root, newperms);
+        if(newperms.owner==null||newperms.world==null||newperms.playerFlags==null||newperms.groupFlags==null||newperms.cuboidFlags==null)
+            throw new Exception("Invalid Residence Permissions...");
+        newperms.fixNames();
+        return newperms;
+    }
+
+    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 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 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;
+    }
+}

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

@@ -0,0 +1,141 @@
+/*
+ * 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 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.file.FileConfiguration;
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @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, 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 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 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) {
+                    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);
+        }
+    }
+}

src/com/bekvon/bukkit/residence/selection/SelectionManager.java

@@ -0,0 +1,357 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.selection;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.permissions.PermissionGroup;
+import com.bekvon.bukkit.residence.protection.CuboidArea;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import org.bukkit.ChatColor;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class SelectionManager {
+	protected Map<String, Location> playerLoc1;
+	protected Map<String, Location> playerLoc2;
+	protected Server server;
+
+	public static final int MAX_HEIGHT = 255, MIN_HEIGHT = 0;
+
+	public enum Direction {
+		UP, DOWN, PLUSX, PLUSZ, MINUSX, MINUSZ
+	}
+
+	public SelectionManager(Server server) {
+		this.server = server;
+		playerLoc1 = Collections
+				.synchronizedMap(new HashMap<String, Location>());
+		playerLoc2 = Collections
+				.synchronizedMap(new HashMap<String, Location>());
+	}
+
+	public void placeLoc1(Player player, Location loc) {
+		if (loc != null) {
+			playerLoc1.put(player.getName(), loc);
+		}
+	}
+
+	public void placeLoc2(Player player, Location loc) {
+		if (loc != null) {
+			playerLoc2.put(player.getName(), loc);
+		}
+	}
+
+	public Location getPlayerLoc1(String player) {
+		return playerLoc1.get(player);
+	}
+
+	public Location getPlayerLoc2(String player) {
+		return playerLoc2.get(player);
+	}
+
+	public boolean hasPlacedBoth(String player) {
+		return (playerLoc1.containsKey(player) && playerLoc2
+				.containsKey(player));
+	}
+
+	public void showSelectionInfo(Player player) {
+		String pname = player.getName();
+		if (this.hasPlacedBoth(pname)) {
+			CuboidArea cuboidArea = new CuboidArea(getPlayerLoc1(pname),
+					getPlayerLoc2(pname));
+			player.sendMessage(ChatColor.YELLOW
+					+ Residence.getLanguage().getPhrase("Selection.Total.Size")
+					+ ":" + ChatColor.DARK_AQUA + " " + cuboidArea.getSize());
+			PermissionGroup group = Residence.getPermissionManager().getGroup(
+					player);
+			if (Residence.getConfigManager().enableEconomy())
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Land.Cost")
+						+ ":"
+						+ ChatColor.DARK_AQUA
+						+ " "
+						+ ((int) Math.ceil((double) cuboidArea.getSize()
+								* group.getCostPerBlock())));
+			player.sendMessage(ChatColor.YELLOW + "X"
+					+ Residence.getLanguage().getPhrase("Size") + ":"
+					+ ChatColor.DARK_AQUA + " " + cuboidArea.getXSize());
+			player.sendMessage(ChatColor.YELLOW + "Y"
+					+ Residence.getLanguage().getPhrase("Size") + ":"
+					+ ChatColor.DARK_AQUA + " " + cuboidArea.getYSize());
+			player.sendMessage(ChatColor.YELLOW + "Z"
+					+ Residence.getLanguage().getPhrase("Size") + ":"
+					+ ChatColor.DARK_AQUA + " " + cuboidArea.getZSize());
+		} else
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("SelectPoints"));
+	}
+
+	public void vert(Player player, boolean resadmin) {
+		if (hasPlacedBoth(player.getName())) {
+			this.sky(player, resadmin);
+			this.bedrock(player, resadmin);
+		} else {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("SelectPoints"));
+		}
+	}
+
+	public void sky(Player player, boolean resadmin) {
+		if (hasPlacedBoth(player.getName())) {
+			PermissionGroup group = Residence.getPermissionManager().getGroup(
+					player);
+			int y1 = playerLoc1.get(player.getName()).getBlockY();
+			int y2 = playerLoc2.get(player.getName()).getBlockY();
+			if (y1 > y2) {
+				int newy = MAX_HEIGHT;
+				if (!resadmin) {
+					if (group.getMaxHeight() < newy)
+						newy = group.getMaxHeight();
+					if (newy - y2 > (group.getMaxY() - 1))
+						newy = y2 + (group.getMaxY() - 1);
+				}
+				playerLoc1.get(player.getName()).setY(newy);
+			} else {
+				int newy = MAX_HEIGHT;
+				if (!resadmin) {
+					if (group.getMaxHeight() < newy)
+						newy = group.getMaxHeight();
+					if (newy - y1 > (group.getMaxY() - 1))
+						newy = y1 + (group.getMaxY() - 1);
+				}
+				playerLoc2.get(player.getName()).setY(newy);
+			}
+			player.sendMessage(ChatColor.GREEN
+					+ Residence.getLanguage().getPhrase("SelectionSky"));
+		} else {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("SelectPoints"));
+		}
+	}
+
+	public void bedrock(Player player, boolean resadmin) {
+		if (hasPlacedBoth(player.getName())) {
+			PermissionGroup group = Residence.getPermissionManager().getGroup(
+					player);
+			int y1 = playerLoc1.get(player.getName()).getBlockY();
+			int y2 = playerLoc2.get(player.getName()).getBlockY();
+			if (y1 < y2) {
+				int newy = MIN_HEIGHT;
+				if (!resadmin) {
+					if (newy < group.getMinHeight())
+						newy = group.getMinHeight();
+					if (y2 - newy > (group.getMaxY() - 1))
+						newy = y2 - (group.getMaxY() - 1);
+				}
+				playerLoc1.get(player.getName()).setY(newy);
+			} else {
+				int newy = MIN_HEIGHT;
+				if (!resadmin) {
+					if (newy < group.getMinHeight())
+						newy = group.getMinHeight();
+					if (y1 - newy > (group.getMaxY() - 1))
+						newy = y1 - (group.getMaxY() - 1);
+				}
+				playerLoc2.get(player.getName()).setY(newy);
+			}
+			player.sendMessage(ChatColor.GREEN
+					+ Residence.getLanguage().getPhrase("SelectionBedrock"));
+		} else {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("SelectPoints"));
+		}
+	}
+
+	public void clearSelection(Player player) {
+		playerLoc1.remove(player.getName());
+		playerLoc2.remove(player.getName());
+	}
+
+	public void selectChunk(Player player) {
+		Chunk chunk = player.getWorld().getChunkAt(player.getLocation());
+		int xcoord = chunk.getX() * 16;
+		int zcoord = chunk.getZ() * 16;
+		int ycoord = MIN_HEIGHT;
+		int xmax = xcoord + 15;
+		int zmax = zcoord + 15;
+		int ymax = MAX_HEIGHT;
+		this.playerLoc1.put(player.getName(), new Location(player.getWorld(),
+				xcoord, ycoord, zcoord));
+		this.playerLoc2.put(player.getName(), new Location(player.getWorld(),
+				xmax, ymax, zmax));
+		player.sendMessage(ChatColor.GREEN
+				+ Residence.getLanguage().getPhrase("SelectionSuccess"));
+	}
+
+	public boolean worldEdit(Player player) {
+		player.sendMessage(ChatColor.RED
+				+ Residence.getLanguage().getPhrase("WorldEditNotFound"));
+		return false;
+	}
+
+	public void selectBySize(Player player, int xsize, int ysize, int zsize) {
+		Location myloc = player.getLocation();
+		Location loc1 = new Location(myloc.getWorld(), myloc.getBlockX()
+				+ xsize, myloc.getBlockY() + ysize, myloc.getBlockZ() + zsize);
+		Location loc2 = new Location(myloc.getWorld(), myloc.getBlockX()
+				- xsize, myloc.getBlockY() - ysize, myloc.getBlockZ() - zsize);
+		placeLoc1(player, loc1);
+		placeLoc2(player, loc2);
+		player.sendMessage(ChatColor.GREEN
+				+ Residence.getLanguage().getPhrase("SelectionSuccess"));
+		showSelectionInfo(player);
+	}
+
+	public void modify(Player player, boolean shift, int amount) {
+		if (!this.hasPlacedBoth(player.getName())) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("SelectPoints"));
+			return;
+		}
+		Direction d = this.getDirection(player);
+		if (d == null) {
+			player.sendMessage(ChatColor.RED
+					+ Residence.getLanguage().getPhrase("InvalidDirection"));
+		}
+		CuboidArea area = new CuboidArea(playerLoc1.get(player.getName()),
+				playerLoc2.get(player.getName()));
+		if (d == Direction.UP) {
+			int oldy = area.getHighLoc().getBlockY();
+			oldy = oldy + amount;
+			if (oldy > MAX_HEIGHT) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("SelectTooHigh"));
+				oldy = MAX_HEIGHT;
+			}
+			area.getHighLoc().setY(oldy);
+			if (shift) {
+				int oldy2 = area.getLowLoc().getBlockY();
+				oldy2 = oldy2 + amount;
+				area.getLowLoc().setY(oldy2);
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Shifting.Up")
+						+ "...");
+			} else
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Expanding.Up")
+						+ "...");
+		}
+		if (d == Direction.DOWN) {
+			int oldy = area.getLowLoc().getBlockY();
+			oldy = oldy - amount;
+			if (oldy < MIN_HEIGHT) {
+				player.sendMessage(ChatColor.RED
+						+ Residence.getLanguage().getPhrase("SelectTooLow"));
+				oldy = MIN_HEIGHT;
+			}
+			area.getLowLoc().setY(oldy);
+			if (shift) {
+				int oldy2 = area.getHighLoc().getBlockY();
+				oldy2 = oldy2 - amount;
+				area.getHighLoc().setY(oldy2);
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Shifting.Down")
+						+ "...");
+			} else
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Expanding.Down")
+						+ "...");
+		}
+		if (d == Direction.MINUSX) {
+			int oldx = area.getLowLoc().getBlockX();
+			oldx = oldx - amount;
+			area.getLowLoc().setX(oldx);
+			if (shift) {
+				int oldx2 = area.getHighLoc().getBlockX();
+				oldx2 = oldx2 - amount;
+				area.getHighLoc().setX(oldx2);
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Shifting")
+						+ " -X...");
+			} else
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Expanding")
+						+ " -X...");
+		}
+		if (d == Direction.PLUSX) {
+			int oldx = area.getHighLoc().getBlockX();
+			oldx = oldx + amount;
+			area.getHighLoc().setX(oldx);
+			if (shift) {
+				int oldx2 = area.getLowLoc().getBlockX();
+				oldx2 = oldx2 + amount;
+				area.getLowLoc().setX(oldx2);
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Shifting")
+						+ " +X...");
+			} else
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Expanding")
+						+ " +X...");
+		}
+		if (d == Direction.MINUSZ) {
+			int oldz = area.getLowLoc().getBlockZ();
+			oldz = oldz - amount;
+			area.getLowLoc().setZ(oldz);
+			if (shift) {
+				int oldz2 = area.getHighLoc().getBlockZ();
+				oldz2 = oldz2 - amount;
+				area.getHighLoc().setZ(oldz2);
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Shifting")
+						+ " -Z...");
+			} else
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Expanding")
+						+ " -Z...");
+		}
+		if (d == Direction.PLUSZ) {
+			int oldz = area.getHighLoc().getBlockZ();
+			oldz = oldz + amount;
+			area.getHighLoc().setZ(oldz);
+			if (shift) {
+				int oldz2 = area.getLowLoc().getBlockZ();
+				oldz2 = oldz2 + amount;
+				area.getLowLoc().setZ(oldz2);
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Shifting")
+						+ " +Z...");
+			} else
+				player.sendMessage(ChatColor.YELLOW
+						+ Residence.getLanguage().getPhrase("Expanding")
+						+ " +Z...");
+		}
+		playerLoc1.put(player.getName(), area.getHighLoc());
+		playerLoc2.put(player.getName(), area.getLowLoc());
+	}
+
+	private Direction getDirection(Player player) {
+		float pitch = player.getLocation().getPitch();
+		float yaw = player.getLocation().getYaw();
+		if (pitch < -50)
+			return Direction.UP;
+		if (pitch > 50)
+			return Direction.DOWN;
+		if ((yaw > 45 && yaw < 135) || (yaw < -45 && yaw > -135))
+			return Direction.MINUSX;
+		if ((yaw > 225 && yaw < 315) || (yaw < -225 && yaw > -315))
+			return Direction.PLUSX;
+		if ((yaw > 135 && yaw < 225) || (yaw < -135 && yaw > -225))
+			return Direction.MINUSZ;
+		if ((yaw < 45 || yaw > 315) || (yaw > -45 || yaw < -315))
+			return Direction.PLUSZ;
+		return null;
+	}
+
+}

src/com/bekvon/bukkit/residence/selection/WorldEditSelectionManager.java

@@ -0,0 +1,107 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package com.bekvon.bukkit.residence.selection;
+
+import com.sk89q.worldedit.bukkit.WorldEditPlugin;
+import com.sk89q.worldedit.bukkit.selections.CuboidSelection;
+import com.sk89q.worldedit.bukkit.selections.Selection;
+import com.sk89q.worldedit.regions.CuboidRegion;
+
+import org.bukkit.Location;
+import org.bukkit.Server;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+/**
+ *
+ * @author Administrator
+ */
+public class WorldEditSelectionManager extends SelectionManager {
+    
+    public WorldEditSelectionManager(Server serv)
+    {
+        super(serv);
+    }
+
+    @Override
+    public boolean worldEdit(Player player) {
+        WorldEditPlugin wep = (WorldEditPlugin) server.getPluginManager().getPlugin("WorldEdit");
+        Selection sel = wep.getSelection(player);
+        if(sel!=null)
+        {
+            Location pos1 = sel.getMinimumPoint();
+            Location pos2 = sel.getMaximumPoint();    
+            try{
+    			CuboidRegion region = (CuboidRegion) sel.getRegionSelector().getRegion();
+    			pos1 = new Location(player.getWorld(), region.getPos1().getX(), region.getPos1().getY(), region.getPos1().getZ());
+    			pos2 = new Location(player.getWorld(), region.getPos2().getX(), region.getPos2().getY(), region.getPos2().getZ());
+            }catch(Exception e){
+            }
+            this.playerLoc1.put(player.getName(), pos1);
+            this.playerLoc2.put(player.getName(), pos2);
+            return true;
+        }
+        return false;
+    }
+    
+    private void afterSelectionUpdate(Player player)
+    {
+    	if (hasPlacedBoth(player.getName()))
+    	{
+            WorldEditPlugin wep = (WorldEditPlugin) server.getPluginManager().getPlugin("WorldEdit");
+            World world = playerLoc1.get(player.getName()).getWorld();
+            Selection selection = new CuboidSelection(world, playerLoc1.get(player.getName()), playerLoc2.get(player.getName()));
+            wep.setSelection(player, selection);
+    	}
+    }
+
+    @Override
+    public void placeLoc1(Player player, Location loc) {
+        this.worldEdit(player);
+        super.placeLoc1(player, loc);
+        this.afterSelectionUpdate(player);
+    }
+
+    @Override
+    public void placeLoc2(Player player, Location loc) {
+        this.worldEdit(player);
+        super.placeLoc2(player, loc);
+        this.afterSelectionUpdate(player);
+    }
+
+    @Override
+    public void sky(Player player, boolean resadmin) {
+        this.worldEdit(player);
+        super.sky(player, resadmin);
+        afterSelectionUpdate(player);
+    }
+
+    @Override
+    public void bedrock(Player player, boolean resadmin) {
+        this.worldEdit(player);
+        super.bedrock(player, resadmin);
+        afterSelectionUpdate(player);
+    }
+
+    @Override
+    public void modify(Player player, boolean shift, int amount) {
+        this.worldEdit(player);
+        super.modify(player, shift, amount);
+        afterSelectionUpdate(player);
+    }
+
+    @Override
+    public void selectChunk(Player player) {
+        this.worldEdit(player);
+        super.selectChunk(player);
+        afterSelectionUpdate(player);
+    }
+
+    @Override
+    public void showSelectionInfo(Player player) {
+        this.worldEdit(player);
+        super.showSelectionInfo(player);
+    }
+}

src/com/bekvon/bukkit/residence/text/Language.java

@@ -0,0 +1,82 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.text;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import org.bukkit.configuration.file.FileConfiguration;
+
+/**
+ * 
+ * @author Administrator
+ */
+public class Language {
+    public Map<String, String> text;
+
+    public Language() {
+        text = new HashMap<String, String>();
+    }
+
+    public void setText(String key, String intext) {
+        text.put(key, intext);
+    }
+
+    private String getText(String key) {
+        String t = text.get(key);
+        if (t == null) {
+            t = "<missing language key: " + key + ">";
+        }
+        return t;
+    }
+
+    public String getPhrase(String key) {
+        String[] split = key.split("\\.");
+        return getPhrase(split);
+    }
+
+    public String getPhrase(String[] keys) {
+        return this.getPhrase(keys, (String[]) null);
+    }
+
+    public String getPhrase(String key, String words) {
+        return this.getPhrase(key.split("\\."), words);
+    }
+
+    public String getPhrase(String[] keys, String words) {
+        if (words == null) {
+            return this.getPhrase(keys, (String[]) null);
+        } else {
+            return this.getPhrase(keys, words.split("\\."));
+        }
+    }
+
+    public String getPhrase(String[] keys, String[] words) {
+        String sentence = "";
+        for (String key : keys) {
+            if (sentence.length() == 0) {
+                sentence = this.getText(key);
+            } else {
+                sentence = sentence + " " + this.getText(key).toLowerCase();
+            }
+        }
+        if (words != null) {
+            for (int i = 0; i < words.length; i++) {
+                sentence = sentence.replaceAll("%" + (i + 1), words[i]);
+            }
+        }
+        return sentence;
+    }
+
+    public static Language parseText(FileConfiguration node, String topkey) {
+        Language newholder = new Language();
+        Set<String> keys = node.getConfigurationSection(topkey).getKeys(false);
+        for (String key : keys) {
+            newholder.text.put(key, node.getString(topkey + "." + key));
+        }
+        return newholder;
+    }
+}

src/com/bekvon/bukkit/residence/text/help/HelpEntry.java

@@ -0,0 +1,214 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.text.help;
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.Residence;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Set;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+
+/**
+ *
+ * @author Administrator
+ */
+public class HelpEntry {
+    protected String name;
+    protected String desc;
+    protected String[] lines;
+    protected List<HelpEntry> subentrys;
+    protected static int linesPerPage = 7;
+
+    public HelpEntry(String entryname)
+    {
+        name = entryname;
+        subentrys = new ArrayList<HelpEntry>();
+        lines = new String[0];
+    }
+
+    public String getName() {
+        if(name==null)
+            return "";
+        return name;
+    }
+
+    public void setName(String inname)
+    {
+        name = inname;
+    }
+
+    public void setDescription(String description)
+    {
+        desc = description;
+    }
+    public String getDescription()
+    {
+        if(desc==null)
+            return "";
+        return desc;
+    }
+
+    public static int getLinesPerPage()
+    {
+        return linesPerPage;
+    }
+
+    public static void setLinesPerPage(int lines)
+    {
+        linesPerPage = lines;
+    }
+
+    public void printHelp(CommandSender sender, int page) {
+        List<String> helplines = this.getHelpData();
+        int pagecount = (int) Math.ceil((double)helplines.size() / (double)linesPerPage);
+        if (page > pagecount || page < 1) {
+            sender.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidHelp"));
+            return;
+        }
+        sender.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("HelpPageHeader",ChatColor.YELLOW + name + ChatColor.RED+"."+ChatColor.YELLOW + page + ChatColor.RED+"."+ChatColor.YELLOW + pagecount + ChatColor.RED));
+        sender.sendMessage(ChatColor.DARK_AQUA+Residence.getLanguage().getPhrase("Description")+": "+ChatColor.GREEN + desc);
+        int start = linesPerPage * (page - 1);
+        int end = start + linesPerPage;
+        boolean alternatecolor = false;
+        for (int i = start; i < end; i++) {
+            if (helplines.size() > i) {
+                if(alternatecolor)
+                {
+                    sender.sendMessage(ChatColor.YELLOW+helplines.get(i));
+                    alternatecolor = false;
+                }
+                else
+                {
+                    sender.sendMessage(ChatColor.GOLD+helplines.get(i));
+                    alternatecolor = true;
+                }
+            }
+        }
+        if(page<pagecount)
+            sender.sendMessage(ChatColor.GRAY+"---<"+Residence.getLanguage().getPhrase("NextPage")+">---");
+        else
+            sender.sendMessage(ChatColor.GRAY+"-----------------------");
+    }
+
+    public void printHelp(CommandSender sender, int page, String path)
+    {
+        HelpEntry subEntry = this.getSubEntry(path);
+        if(subEntry!=null)
+        {
+            subEntry.printHelp(sender, page);
+        }
+        else
+        {
+            sender.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidHelp"));
+        }
+    }
+
+    private List<String> getHelpData()
+    {
+        List<String> helplines = new ArrayList<String>();
+        helplines.addAll(Arrays.asList(lines));
+        if(subentrys.size()>0)
+            helplines.add(ChatColor.LIGHT_PURPLE+"---"+Residence.getLanguage().getPhrase("SubCommands")+"---");
+        for(HelpEntry entry : subentrys)
+        {
+            helplines.add(ChatColor.GREEN+entry.getName() + ChatColor.YELLOW+" - " + entry.getDescription());
+        }
+        return helplines;
+    }
+
+    public boolean containesEntry(String name)
+    {
+        return this.getSubEntry(name)!=null;
+    }
+
+    public HelpEntry getSubEntry(String name)
+    {
+        String[] split = name.split("\\.");
+        HelpEntry entry = this;
+        for(String entryname : split)
+        {
+            entry = entry.findSubEntry(entryname);
+            if(entry == null)
+                return null;
+        }
+        return entry;
+    }
+
+    private HelpEntry findSubEntry(String name)
+    {
+        for(HelpEntry entry : subentrys)
+        {
+            if(entry.getName().equalsIgnoreCase(name))
+                return entry;
+        }
+        return null;
+    }
+
+    public void addSubEntry(HelpEntry entry)
+    {
+        if(!subentrys.contains(entry))
+        {
+            subentrys.add(entry);
+        }
+    }
+
+    public void removeSubEntry(HelpEntry entry)
+    {
+        if(subentrys.contains(entry))
+        {
+            subentrys.remove(entry);
+        }
+    }
+
+    public int getSubEntryCount()
+    {
+        return subentrys.size();
+    }
+
+    public static HelpEntry parseHelp(FileConfiguration node, String key)
+    {
+        String split[] = key.split("\\.");
+        String thisname = split[split.length-1];
+        HelpEntry entry = new HelpEntry(thisname);
+        ConfigurationSection keysnode = node.getConfigurationSection(key);
+        Set<String> keys = null;
+        if(keysnode!=null)
+            keys = keysnode.getKeys(false);
+        if(keys!=null)
+        {
+            if(keys.contains("Info"))
+            {
+                List<String> stringList = node.getStringList(key + ".Info");
+                if(stringList != null)
+                {
+                    entry.lines = new String[stringList.size()];
+                    for(int i = 0; i < stringList.size(); i++)
+                    {
+                        entry.lines[i] = "- " + stringList.get(i);
+                    }
+                }
+            }
+            if(keys.contains("Description"))
+            {
+                entry.desc = node.getString(key + ".Description");
+            }
+            if(keys.contains("SubCommands"))
+            {
+                Set<String> subcommandkeys = node.getConfigurationSection(key + ".SubCommands").getKeys(false);
+                for(String subkey : subcommandkeys)
+                {
+                    entry.subentrys.add(HelpEntry.parseHelp(node, key+".SubCommands."+subkey));
+                }
+            }
+        }
+        return entry;
+    }
+
+}

src/com/bekvon/bukkit/residence/text/help/InformationPager.java

@@ -0,0 +1,61 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.text.help;
+import org.bukkit.ChatColor;
+
+import com.bekvon.bukkit.residence.Residence;
+import java.util.Arrays;
+import java.util.List;
+import org.bukkit.command.CommandSender;
+
+/**
+ *
+ * @author Administrator
+ */
+public class InformationPager {
+    
+    public static int linesPerPage=7;
+
+    public static int getLinesPerPage()
+    {
+        return linesPerPage;
+    }
+
+    public static void setLinesPerPage(int lines)
+    {
+        linesPerPage = lines;
+    }
+
+    public static void printInfo(CommandSender sender, String title, String[] lines, int page)
+    {
+        InformationPager.printInfo(sender, title, Arrays.asList(lines), page);
+    }
+
+    public static void printInfo(CommandSender sender, String title, List<String> lines, int page) {
+        int perPage = 6;
+        int start = (page-1) * perPage;
+        int end = start + perPage;
+        int pagecount = (int) Math.ceil((double)lines.size()/(double)perPage);
+        if(pagecount == 0)
+            pagecount = 1;
+        if(page>pagecount)
+        {
+            sender.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidPage"));
+            return;
+        }
+        sender.sendMessage(ChatColor.YELLOW+"---<"+ChatColor.GREEN+title+ChatColor.YELLOW+">---");
+        sender.sendMessage(ChatColor.YELLOW+"---<"+Residence.getLanguage().getPhrase("GenericPage",ChatColor.GREEN+String.format("%d",page)+ChatColor.YELLOW+"."+ChatColor.GREEN+pagecount+ChatColor.YELLOW)+">---");
+        for(int i = start; i < end; i ++)
+        {
+            if(lines.size()>i)
+                sender.sendMessage(ChatColor.GREEN+lines.get(i));
+        }
+        if(pagecount>page)
+            sender.sendMessage(ChatColor.GRAY+"---<"+Residence.getLanguage().getPhrase("NextPage")+">---");
+        else
+            sender.sendMessage(ChatColor.GRAY+"-----------------------");
+    }
+}

src/com/bekvon/bukkit/residence/utils/ActionBar.java

@@ -0,0 +1,100 @@
+package com.bekvon.bukkit.residence.utils;
+ 
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.logging.Level;
+ 
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.entity.Player;
+import org.json.simple.JSONObject;
+
+ 
+/**
+*
+* @author hamzaxx
+*/
+public class ActionBar {
+        private static String version = "";
+        private static Object packet;
+        private static Method getHandle;
+        private static Method sendPacket;
+        private static Field playerConnection;
+        private static Class<?> nmsChatSerializer;
+        private static Class<?> nmsIChatBaseComponent;
+        private static Class<?> packetType;
+ 
+        static {
+                try {
+                        version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
+                        packetType = Class.forName(getPacketPlayOutChat());
+                        Class<?> typeCraftPlayer = Class.forName(getCraftPlayerClasspath());
+                        Class<?> typeNMSPlayer = Class.forName(getNMSPlayerClasspath());
+                        Class<?> typePlayerConnection = Class.forName(getPlayerConnectionClasspath());
+                        nmsChatSerializer = Class.forName(getChatSerializerClasspath());
+                        nmsIChatBaseComponent = Class.forName(getIChatBaseComponentClasspath());
+                        getHandle = typeCraftPlayer.getMethod("getHandle");
+                        playerConnection = typeNMSPlayer.getField("playerConnection");
+                        sendPacket = typePlayerConnection.getMethod("sendPacket", Class.forName(getPacketClasspath()));
+                } catch (ClassNotFoundException | NoSuchMethodException | SecurityException | NoSuchFieldException ex) {
+                        Bukkit.getLogger().log(Level.SEVERE, "Error {0}", ex);
+                }
+        }
+ 
+        public static void send(Player receivingPacket, String msg) {        	
+                try {
+                        Object serialized = nmsChatSerializer.getMethod("a", String.class).invoke(null, "{\"text\": \"" + ChatColor.translateAlternateColorCodes('&', JSONObject.escape(msg)) + "\"}");
+                        if (!version.contains("1_7")) {
+                                packet = packetType.getConstructor(nmsIChatBaseComponent, byte.class).newInstance(serialized, (byte) 2);
+                        } else {
+                                packet = packetType.getConstructor(nmsIChatBaseComponent, int.class).newInstance(serialized, 2);
+                        }
+                        Object player = getHandle.invoke(receivingPacket);
+                        Object connection = playerConnection.get(player);
+                        sendPacket.invoke(connection, packet);
+                } catch (NoSuchMethodException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | InstantiationException ex) {
+                        Bukkit.getLogger().log(Level.SEVERE, "Error {0} " + version, ex);
+                }
+ 
+                try {
+                        Object player = getHandle.invoke(receivingPacket);
+                        Object connection = playerConnection.get(player);
+                        sendPacket.invoke(connection, packet);
+                } catch (SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) {
+                        Bukkit.getLogger().log(Level.SEVERE, "Error {0}", ex);
+                }
+        }
+ 
+        private static String getCraftPlayerClasspath() {
+                return "org.bukkit.craftbukkit." + version + ".entity.CraftPlayer";
+        }
+ 
+        private static String getPlayerConnectionClasspath() {
+                return "net.minecraft.server." + version + ".PlayerConnection";
+        }
+ 
+        private static String getNMSPlayerClasspath() {
+                return "net.minecraft.server." + version + ".EntityPlayer";
+        }
+ 
+        private static String getPacketClasspath() {
+                return "net.minecraft.server." + version + ".Packet";
+        }
+ 
+        private static String getIChatBaseComponentClasspath() {
+                return "net.minecraft.server." + version + ".IChatBaseComponent";
+        }
+ 
+        private static String getChatSerializerClasspath() {
+        	if(version.equals("v1_8_R1") || version.contains("1_7")){
+        		return "net.minecraft.server." + version + ".ChatSerializer";
+        	} else {
+        		return "net.minecraft.server." + version + ".IChatBaseComponent$ChatSerializer"; // 1_8_R2 moved to IChatBaseComponent
+        	}  
+        }
+ 
+        private static String getPacketPlayOutChat() {
+                return "net.minecraft.server." + version + ".PacketPlayOutChat";
+        }
+}

src/com/bekvon/bukkit/residence/vaultinterface/ResidenceVaultAdapter.java

@@ -0,0 +1,164 @@
+/*
+ * To change this template, choose Tools | Templates
+ * and open the template in the editor.
+ */
+
+package com.bekvon.bukkit.residence.vaultinterface;
+
+import com.bekvon.bukkit.residence.economy.EconomyInterface;
+import com.bekvon.bukkit.residence.permissions.PermissionsInterface;
+
+import net.milkbowl.vault.chat.Chat;
+import net.milkbowl.vault.economy.Economy;
+import net.milkbowl.vault.permission.Permission;
+
+import org.bukkit.Server;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.RegisteredServiceProvider;
+
+/**
+ * 
+ * @author Administrator
+ */
+public class ResidenceVaultAdapter implements EconomyInterface,
+		PermissionsInterface {
+
+	public static Permission permissions = null;
+	public static Economy economy = null;
+	public static Chat chat = null;
+
+	public boolean permissionsOK() {
+		if (permissions != null
+				&& !permissions.getName().equalsIgnoreCase("SuperPerms")) {
+			return true;
+		}
+		return false;
+	}
+
+	public boolean economyOK() {
+		return economy != null;
+	}
+
+	public boolean chatOK() {
+		return chat != null;
+	}
+
+	public ResidenceVaultAdapter(Server s) {
+		this.setupPermissions(s);
+		this.setupEconomy(s);
+		this.setupChat(s);
+	}
+
+	private boolean setupPermissions(Server s) {
+		RegisteredServiceProvider<Permission> permissionProvider = s
+				.getServicesManager().getRegistration(
+						net.milkbowl.vault.permission.Permission.class);
+		if (permissionProvider != null) {
+			permissions = permissionProvider.getProvider();
+		}
+		return (permissions != null);
+	}
+
+	private boolean setupChat(Server s) {
+		RegisteredServiceProvider<Chat> chatProvider = s.getServicesManager()
+				.getRegistration(net.milkbowl.vault.chat.Chat.class);
+		if (chatProvider != null) {
+			chat = chatProvider.getProvider();
+		}
+		return (chat != null);
+	}
+
+	private boolean setupEconomy(Server s) {
+		RegisteredServiceProvider<Economy> economyProvider = s
+				.getServicesManager().getRegistration(
+						net.milkbowl.vault.economy.Economy.class);
+		if (economyProvider != null) {
+			economy = economyProvider.getProvider();
+		}
+		return (economy != null);
+	}
+
+	public String getPlayerGroup(Player player) {
+		String group = permissions.getPrimaryGroup(player).toLowerCase();
+		if (group == null) {
+			return group;
+		} else {
+			return group.toLowerCase();
+		}
+	}
+
+	@SuppressWarnings("deprecation")
+	public String getPlayerGroup(String player, String world) {
+		String group = permissions.getPrimaryGroup(world, player);
+		if (group == null) {
+			return group;
+		} else {
+			return group.toLowerCase();
+		}
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public double getBalance(String playerName) {
+		return economy.getBalance(playerName);
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public boolean canAfford(String playerName, double amount) {
+		return economy.has(playerName, amount);
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public boolean add(String playerName, double amount) {
+		return economy.depositPlayer(playerName, amount).transactionSuccess();
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public boolean subtract(String playerName, double amount) {
+		return economy.withdrawPlayer(playerName, amount).transactionSuccess();
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	public boolean transfer(String playerFrom, String playerTo, double amount) {
+		if (economy.withdrawPlayer(playerFrom, amount).transactionSuccess()) {
+			if (economy.depositPlayer(playerTo, amount).transactionSuccess()) {
+				return true;
+			} else {
+				economy.depositPlayer(playerFrom, amount);
+				return false;
+			}
+		} else {
+			return false;
+		}
+	}
+
+	public String getEconomyName() {
+		if (economy != null) {
+			return economy.getName();
+		}
+		return "";
+	}
+
+	public String getPermissionsName() {
+		if (permissions != null) {
+			return permissions.getName();
+		}
+		return "";
+	}
+
+	public String getChatName() {
+		if (chat != null) {
+			return chat.getName();
+		}
+		return "";
+	}
+
+	public String getName() {
+		return "Vault";
+	}
+
+}