comeplete 1.7-1.8 all version...

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

pom.xml

@@ -7,7 +7,6 @@
 	<name>Residence</name>
 	<build>
 		<finalName>${project.name}</finalName>
-		<sourceDirectory>src</sourceDirectory>
 		<resources>
 			<resource>
 				<directory>src/main/resources</directory>
@@ -19,8 +18,8 @@
 				<artifactId>maven-compiler-plugin</artifactId>
 				<version>3.1</version>
 				<configuration>
-					<source>1.7</source>
+					<source>1.8</source>
-					<target>1.7</target>
+					<target>1.8</target>
 				</configuration>
 			</plugin>
 			<plugin>
@@ -56,6 +55,10 @@
 			<id>spigot-repo</id>
 			<url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
 		</repository>
+		<repository>
+			<id>citycraft-repo</id>
+			<url>http://ci.citycraft.cn:8800/jenkins/plugin/repository/everything/</url>
+		</repository>
 	</repositories>
 	<dependencies>
 		<dependency>

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

@@ -40,6 +40,7 @@ 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.listeners.ResidencePlayerListener_1_8;
 import com.bekvon.bukkit.residence.permissions.PermissionManager;
 import com.bekvon.bukkit.residence.persistance.YMLSaveHelper;
 import com.bekvon.bukkit.residence.protection.ClaimedResidence;
@@ -67,7 +68,7 @@ import cn.citycraft.PluginHelper.config.FileConfig;
  */
 public class Residence extends JavaPlugin {
 
-	public static String bukkitver;
+	public static float bukkitver;
 	protected static ResidenceManager rmanager;
 	protected static SelectionManager smanager;
 	protected static PermissionManager gmanager;
@@ -75,6 +76,7 @@ public class Residence extends JavaPlugin {
 	protected static ResidenceBlockListener blistener;
 	protected static ResidencePlayerListener plistener;
 	protected static ResidenceEntityListener elistener;
+	protected static ResidencePlayerListener_1_8 plistener1_8;
 	protected static TransactionManager tmanager;
 	protected static PermissionListManager pmanager;
 	protected static LeaseManager leasemanager;
@@ -103,40 +105,26 @@ public class Residence extends JavaPlugin {
 
 	protected Map<String, String> deleteConfirm;
 
-	private Runnable doHeals = new Runnable() {
+	private Runnable doHeals = () -> plistener.doHeals();
-		@Override
+
-		public void run() {
+	private Runnable rentExpire = () -> {
-			plistener.doHeals();
+		rentmanager.checkCurrentRents();
-		}
+		if (cmanager.showIntervalMessages())
+			getLog().info(" - Rent Expirations checked!");
 	};
 
-	private Runnable rentExpire = new Runnable() {
+	private Runnable leaseExpire = () -> {
-		@Override
+		leasemanager.doExpirations();
-		public void run() {
+		if (cmanager.showIntervalMessages())
-			rentmanager.checkCurrentRents();
+			getLog().info(" - Lease Expirations checked!");
-			if (cmanager.showIntervalMessages())
-				getLog().info(" - Rent Expirations checked!");
-		}
 	};
 
-	private Runnable leaseExpire = new Runnable() {
+	private Runnable autoSave = () -> {
-		@Override
+		try {
-		public void run() {
+			if (initsuccess)
-			leasemanager.doExpirations();
+				saveYml();
-			if (cmanager.showIntervalMessages())
+		} catch (Exception ex) {
-				getLog().info(" - Lease Expirations checked!");
+			getLog().warning("领地数据保存错误,可能造成部分领地丢失,请尝试恢复备份文件!");
-		}
-	};
-
-	private Runnable autoSave = new Runnable() {
-		@Override
-		public void run() {
-			try {
-				if (initsuccess)
-					saveYml();
-			} catch (Exception ex) {
-				getLog().warning("领地数据保存错误,可能造成部分领地丢失,请尝试恢复备份文件!");
-			}
 		}
 	};
 
@@ -235,6 +223,10 @@ public class Residence extends JavaPlugin {
 		return wmanager;
 	}
 
+	public static boolean is1_8() {
+		return bukkitver == 1.8;
+	}
+
 	public static boolean isResAdminOn(Player player) {
 		if (resadminToggle.contains(player.getName()))
 			return true;
@@ -312,7 +304,7 @@ public class Residence extends JavaPlugin {
 	public void onEnable() {
 		try {
 			log = this.getLogger();
-			bukkitver = this.getServer().getBukkitVersion().substring(0, 5);
+			bukkitver = Float.parseFloat(this.getServer().getBukkitVersion().substring(0, 3));
 			initsuccess = false;
 			deleteConfirm = new HashMap<String, String>();
 			resadminToggle = new ArrayList<String>();
@@ -412,9 +404,11 @@ public class Residence extends JavaPlugin {
 				blistener = new ResidenceBlockListener();
 				plistener = new ResidencePlayerListener();
 				elistener = new ResidenceEntityListener();
+				plistener1_8 = new ResidencePlayerListener_1_8();
 				PluginManager pm = getServer().getPluginManager();
 				pm.registerEvents(blistener, this);
 				pm.registerEvents(plistener, this);
+				pm.registerEvents(plistener1_8, this);
 				pm.registerEvents(elistener, this);
 
 				firstenable = false;

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

@@ -4,14 +4,6 @@
  */
 
 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;
@@ -20,480 +12,389 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.Set;
 
+import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.event.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;
+
 /**
  *
  * @author Administrator
  */
 public class RentManager {
-    protected Map<String,RentedLand> rentedLand;
+	protected Map<String, RentedLand> rentedLand;
-    protected Map<String,RentableLand> rentableLand;
+	protected Map<String, RentableLand> rentableLand;
 
-    public RentManager()
+	public RentManager() {
-    {
+		rentedLand = new HashMap<String, RentedLand>();
-        rentedLand = new HashMap<String,RentedLand>();
+		rentableLand = new HashMap<String, RentableLand>();
-        rentableLand = new HashMap<String,RentableLand>();
+	}
-    }
 
-    public void setForRent(Player player, String landName, int amount, int days, boolean repeatable, boolean resadmin)
+	@SuppressWarnings("unchecked")
-    {
+	public static RentManager load(Map<String, Object> root) {
-        if(!Residence.getConfigManager().enabledRentSystem())
+		RentManager rentManager = new RentManager();
-        {
+		if (root != null) {
-            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("MarketDisabled"));
+			Map<String, Object> rentables = (Map<String, Object>) root.get("Rentables");
-            return;
+			for (Entry<String, Object> rent : rentables.entrySet())
-        }
+				rentManager.rentableLand.put(rent.getKey(), RentableLand.load((Map<String, Object>) rent.getValue()));
-        if(Residence.getTransactionManager().isForSale(landName))
+			Map<String, Object> rented = (Map<String, Object>) root.get("Rented");
-        {
+			for (Entry<String, Object> rent : rented.entrySet())
-            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("SellRentFail"));
+				rentManager.rentedLand.put(rent.getKey(), RentedLand.load((Map<String, Object>) rent.getValue()));
-            return;
+		}
-        }
+		return rentManager;
-        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)
+	public void checkCurrentRents() {
-    {
+		Iterator<Entry<String, RentedLand>> it = rentedLand.entrySet().iterator();
-        if(!Residence.getConfigManager().enabledRentSystem())
+		while (it.hasNext()) {
-        {
+			Entry<String, RentedLand> next = it.next();
-            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("RentDisabled"));
+			RentedLand land = next.getValue();
-            return;
+			if (land.endTime <= System.currentTimeMillis()) {
-        }
+				ClaimedResidence res = Residence.getResidenceManager().getByName(next.getKey());
-        ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
+				if (Residence.getConfigManager().debugEnabled())
-        if(res!=null)
+					System.out.println("Rent Check: " + next.getKey());
-        {
+				if (res != null) {
-            if(res.getPermissions().getOwner().equalsIgnoreCase(player.getName()))
+					ResidenceRentEvent revent = new ResidenceRentEvent(res, null, RentEventType.RENT_EXPIRE);
-            {
+					Residence.getServ().getPluginManager().callEvent(revent);
-                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("OwnerRentFail"));
+					if (!revent.isCancelled()) {
-                return;
+						RentableLand rentable = rentableLand.get(next.getKey());
-            }
+						if (!rentable.repeatable) {
-        }
+							rentableLand.remove(next.getKey());
-        else
+							it.remove();
-        {
+							res.getPermissions().applyDefaultFlags();
-            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidResidence"));
+						} else if (land.autoRefresh) {
-            return;
+							if (!Residence.getEconomyManager().canAfford(land.player, rentable.cost)) {
-        }
+								it.remove();
-        PermissionGroup group = Residence.getPermissionManager().getGroup(player);
+								res.getPermissions().applyDefaultFlags();
-        if(!resadmin && this.getRentCount(player.getName()) >= group.getMaxRents())
+							} else if (!Residence.getEconomyManager().transfer(land.player, res.getPermissions().getOwner(), rentable.cost)) {
-        {
+								it.remove();
-            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceMaxRent"));
+								res.getPermissions().applyDefaultFlags();
-            return;
+							} else
-        }
+								land.endTime = System.currentTimeMillis() + this.daysToMs(rentable.days);
-        if(!this.isForRent(landName))
+						} else {
-        {
+							res.getPermissions().applyDefaultFlags();
-            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceNotForRent"));
+							it.remove();
-            return;
+						}
-        }
+					}
-        if(this.isRented(landName))
+				} else {
-        {
+					rentableLand.remove(next.getKey());
-            String[] split = landName.split("\\.");
+					it.remove();
-            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)
+	public int getCostOfRent(String landName) {
-    {
+		return rentableLand.containsKey(landName) ? rentableLand.get(landName).cost : 0;
-        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)
+	public int getRentableCount(String player) {
-    {
+		Set<String> set = rentableLand.keySet();
-        return (((long)days) * 24L * 60L * 60L * 1000L);
+		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;
+	}
 
-    @SuppressWarnings("unused")
+	public boolean getRentableRepeatable(String landName) {
-	private int msToDays(long ms)
+		return rentableLand.containsKey(landName) ? rentableLand.get(landName).repeatable : false;
-    {
+	}
-        return (int) Math.ceil(((((double)ms/1000D)/60D)/60D)/24D);
-    }
 
-    public void unrent(Player player, String landName, boolean resadmin)
+	public int getRentCount(String player) {
-    {
+		Set<Entry<String, RentedLand>> set = rentedLand.entrySet();
-        String[] split = landName.split("\\.");
+		int count = 0;
-        ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
+		for (Entry<String, RentedLand> land : set)
-        if(res == null)
+			if (land.getValue().player.equalsIgnoreCase(player))
-        {
+				count++;
-            player.sendMessage(ChatColor.YELLOW+Residence.getLanguage().getPhrase("InvalidResidence"));
+		return count;
-            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));
 
-        }
+	public int getRentDays(String landName) {
-        else
+		return rentableLand.containsKey(landName) ? rentableLand.get(landName).days : 0;
-        {
+	}
-            player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("ResidenceNotForRent"));
-        }
-    }
 
-    public void removeFromRent(String landName)
+	public boolean getRentedAutoRepeats(String landName) {
-    {
+		return getRentableRepeatable(landName) ? (rentedLand.containsKey(landName) ? rentedLand.get(landName).autoRefresh : false) : false;
-        rentedLand.remove(landName);
+	}
-    }
 
-    public void removeRentable(String landName)
+	public String getRentingPlayer(String landName) {
-    {
+		return rentedLand.containsKey(landName) ? rentedLand.get(landName).player : null;
-        removeFromRent(landName);
+	}
-        rentableLand.remove(landName);
-    }
 
-    public boolean isForRent(String landName)
+	public boolean isForRent(String landName) {
-    {
+		return rentableLand.containsKey(landName);
-        return rentableLand.containsKey(landName);
+	}
-    }
 
-    public boolean isRented(String landName)
+	public boolean isRented(String landName) {
-    {
+		return rentedLand.containsKey(landName);
-        return rentedLand.containsKey(landName);
+	}
-    }
 
-    public String getRentingPlayer(String landName)
+	public void printRentableResidences(Player player) {
-    {
+		Set<Entry<String, RentableLand>> set = rentableLand.entrySet();
-        return rentedLand.containsKey(landName) ? rentedLand.get(landName).player : null;
+		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 getCostOfRent(String landName)
+	public void printRentInfo(Player player, String landName) {
-    {
+		RentableLand rentable = rentableLand.get(landName);
-        return rentableLand.containsKey(landName) ? rentableLand.get(landName).cost : 0;
+		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"));
+	}
 
-    public boolean getRentableRepeatable(String landName)
+	public void removeFromForRent(Player player, String landName, boolean resadmin) {
-    {
+		RentedLand rent = rentedLand.get(landName);
-        return rentableLand.containsKey(landName) ? rentableLand.get(landName).repeatable : false;
+		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"));
+	}
 
-    public boolean getRentedAutoRepeats(String landName)
+	public void removeFromRent(String landName) {
-    {
+		rentedLand.remove(landName);
-        return getRentableRepeatable(landName) ? (rentedLand.containsKey(landName) ? rentedLand.get(landName).autoRefresh : false) : false;
+	}
-    }
 
-    public int getRentDays(String landName)
+	public void removeRentable(String landName) {
-    {
+		removeFromRent(landName);
-        return rentableLand.containsKey(landName) ? rentableLand.get(landName).days : 0;
+		rentableLand.remove(landName);
-    }
+	}
 
-    public void checkCurrentRents()
+	public void rent(Player player, String landName, boolean repeat, boolean resadmin) {
-    {
+		if (!Residence.getConfigManager().enabledRentSystem()) {
-        Iterator<Entry<String, RentedLand>> it = rentedLand.entrySet().iterator();
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("RentDisabled"));
-        while(it.hasNext())
+			return;
-        {
+		}
-            Entry<String, RentedLand> next = it.next();
+		ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
-            RentedLand land = next.getValue();
+		if (res != null) {
-            if(land.endTime<=System.currentTimeMillis())
+			if (res.getPermissions().getOwner().equalsIgnoreCase(player.getName())) {
-            {
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("OwnerRentFail"));
-                ClaimedResidence res = Residence.getResidenceManager().getByName(next.getKey());
+				return;
-                if(Residence.getConfigManager().debugEnabled())
+			}
-                    System.out.println("Rent Check: "+next.getKey());
+		} else {
-                if (res != null) {
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidResidence"));
-                    ResidenceRentEvent revent = new ResidenceRentEvent(res, null, RentEventType.RENT_EXPIRE);
+			return;
-                    Residence.getServ().getPluginManager().callEvent(revent);
+		}
-                    if (!revent.isCancelled()) {
+		PermissionGroup group = Residence.getPermissionManager().getGroup(player);
-                        RentableLand rentable = rentableLand.get(next.getKey());
+		if (!resadmin && this.getRentCount(player.getName()) >= group.getMaxRents()) {
-                        if (!rentable.repeatable) {
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ResidenceMaxRent"));
-                            rentableLand.remove(next.getKey());
+			return;
-                            it.remove();
+		}
-                            res.getPermissions().applyDefaultFlags();
+		if (!this.isForRent(landName)) {
-                        } else if (land.autoRefresh) {
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ResidenceNotForRent"));
-                            if (!Residence.getEconomyManager().canAfford(land.player, rentable.cost)) {
+			return;
-                                it.remove();
+		}
-                                res.getPermissions().applyDefaultFlags();
+		if (this.isRented(landName)) {
-                            } else {
+			String[] split = landName.split("\\.");
-                                if (!Residence.getEconomyManager().transfer(land.player, res.getPermissions().getOwner(), rentable.cost)) {
+			if (split.length != 0)
-                                    it.remove();
+				player.sendMessage(Residence.getLanguage().getPhrase("ResidenceAlreadyRented",
-                                    res.getPermissions().applyDefaultFlags();
+						ChatColor.YELLOW + split[split.length - 1] + ChatColor.RED + "." + ChatColor.YELLOW + this.getRentingPlayer(landName)));
-                                }
+			return;
-                                else
+		}
-                                {
+		RentableLand land = rentableLand.get(landName);
-                                    land.endTime = System.currentTimeMillis() + this.daysToMs(rentable.days);
+		if (Residence.getEconomyManager().canAfford(player.getName(), land.cost)) {
-                                }
+			ResidenceRentEvent revent = new ResidenceRentEvent(res, player, RentEventType.RENT);
-                            }
+			Residence.getServ().getPluginManager().callEvent(revent);
-                        } else {
+			if (revent.isCancelled())
-                            res.getPermissions().applyDefaultFlags();
+				return;
-                            it.remove();
+			if (Residence.getEconomyManager().transfer(player.getName(), res.getPermissions().getOwner(), land.cost)) {
-                        }
+				RentedLand newrent = new RentedLand();
-                    }
+				newrent.player = player.getName();
-                }
+				newrent.startTime = System.currentTimeMillis();
-                else
+				newrent.endTime = System.currentTimeMillis() + daysToMs(land.days);
-                {
+				newrent.autoRefresh = repeat;
-                    rentableLand.remove(next.getKey());
+				rentedLand.put(landName, newrent);
-                    it.remove();
+				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 setRentRepeatable(Player player, String landName, boolean value, boolean resadmin)
+	public Map<String, Object> save() {
-    {
+		Map<String, Object> root = new HashMap<String, Object>();
-        String[] split = landName.split("\\.");
+		Map<String, Object> rentables = new HashMap<String, Object>();
-        RentableLand land = rentableLand.get(landName);
+		for (Entry<String, RentableLand> rent : rentableLand.entrySet())
-        ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
+			rentables.put(rent.getKey(), rent.getValue().save());
-        if(land!=null && res!=null && (res.getPermissions().getOwner().equalsIgnoreCase(player.getName()) || resadmin))
+		Map<String, Object> rented = new HashMap<String, Object>();
-        {
+		for (Entry<String, RentedLand> rent : rentedLand.entrySet())
-            land.repeatable = value;
+			rented.put(rent.getKey(), rent.getValue().save());
-            if(!value && this.isRented(landName))
+		root.put("Rentables", rentables);
-                rentedLand.get(landName).autoRefresh = false;
+		root.put("Rented", rented);
-            if(value && split.length!=0)
+		return root;
-                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)
+	public void setForRent(Player player, String landName, int amount, int days, boolean repeatable, boolean resadmin) {
-    {
+		if (!Residence.getConfigManager().enabledRentSystem()) {
-        String[] split = landName.split("\\.");
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("MarketDisabled"));
-        RentedLand land = rentedLand.get(landName);
+			return;
-        if(land!=null && (land.player.equals(player.getName()) || resadmin))
+		}
-        {
+		if (Residence.getTransactionManager().isForSale(landName)) {
-            land.autoRefresh = value;
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SellRentFail"));
-            if(value && split.length!=0)
+			return;
-                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("RentEnableRenew",ChatColor.YELLOW+split[split.length-1] + ChatColor.RED));
+		}
-            else if(split.length!=0)
+		ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
-                player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("RentDisableRenew",ChatColor.YELLOW+split[split.length-1] + ChatColor.RED));
+		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 printRentInfo(Player player, String landName)
+	public void setRentedRepeatable(Player player, String landName, boolean value, boolean resadmin) {
-    {
+		String[] split = landName.split("\\.");
-        RentableLand rentable = rentableLand.get(landName);
+		RentedLand land = rentedLand.get(landName);
-        RentedLand rented = rentedLand.get(landName);
+		if (land != null && (land.player.equals(player.getName()) || resadmin)) {
-        if(rentable!=null)
+			land.autoRefresh = value;
-        {
+			if (value && split.length != 0)
-            player.sendMessage(ChatColor.GOLD+Residence.getLanguage().getPhrase("Land")+":"+ChatColor.DARK_GREEN + landName);
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("RentEnableRenew", ChatColor.YELLOW + split[split.length - 1] + ChatColor.RED));
-            player.sendMessage(ChatColor.YELLOW+Residence.getLanguage().getPhrase("Cost")+": "+ChatColor.DARK_AQUA + rentable.cost + " per " + rentable.days + " days");
+			else if (split.length != 0)
-            player.sendMessage(ChatColor.GREEN+Residence.getLanguage().getPhrase("RentableAutoRenew")+":"+ChatColor.DARK_AQUA + rentable.repeatable);
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("RentDisableRenew", ChatColor.YELLOW + split[split.length - 1] + ChatColor.RED));
-            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 void setRentRepeatable(Player player, String landName, boolean value, boolean resadmin) {
-	public static RentManager load(Map<String,Object> root)
+		String[] split = landName.split("\\.");
-    {
+		RentableLand land = rentableLand.get(landName);
-        RentManager rentManager = new RentManager();
+		ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
-        if(root!=null)
+		if (land != null && res != null && (res.getPermissions().getOwner().equalsIgnoreCase(player.getName()) || resadmin)) {
-        {
+			land.repeatable = value;
-            Map<String,Object> rentables = (Map<String, Object>) root.get("Rentables");
+			if (!value && this.isRented(landName))
-            for(Entry<String, Object> rent : rentables.entrySet())
+				rentedLand.get(landName).autoRefresh = false;
-            {
+			if (value && split.length != 0)
-                rentManager.rentableLand.put(rent.getKey(), RentableLand.load((Map<String, Object>) rent.getValue()));
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("RentableEnableRenew", ChatColor.YELLOW + split[split.length - 1] + ChatColor.RED));
-            }
+			else if (split.length != 0)
-            Map<String,Object> rented = (Map<String, Object>) root.get("Rented");
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("RentableDisableRenew", ChatColor.YELLOW + split[split.length - 1] + ChatColor.RED));
-            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()
+	public void unrent(Player player, String landName, boolean resadmin) {
-    {
+		String[] split = landName.split("\\.");
-        Map<String,Object> root = new HashMap<String,Object>();
+		ClaimedResidence res = Residence.getResidenceManager().getByName(landName);
-        Map<String,Object> rentables = new HashMap<String,Object>();
+		if (res == null) {
-        for(Entry<String, RentableLand> rent : rentableLand.entrySet())
+			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("InvalidResidence"));
-        {
+			return;
-            rentables.put(rent.getKey(), rent.getValue().save());
+		}
-        }
+		if (!res.getPermissions().hasResidencePermission(player, true) && !resadmin) {
-        Map<String,Object> rented = new HashMap<String,Object>();
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-        for(Entry<String, RentedLand> rent : rentedLand.entrySet())
+			return;
-        {
+		}
-            rented.put(rent.getKey(), rent.getValue().save());
+		if (rentedLand.containsKey(landName) && !resadmin) {
-        }
+			if (split.length != 0)
-        root.put("Rentables", rentables);
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ResidenceAlreadyRented",
-        root.put("Rented", rented);
+						ChatColor.YELLOW + split[split.length - 1] + ChatColor.RED + "." + ChatColor.YELLOW + rentedLand.get(landName).player) + ChatColor.YELLOW);
-        return root;
+			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);
+				res.getPermissions().applyDefaultFlags();
+			}
+			if (split.length != 0)
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ResidenceRemoveRentable", ChatColor.YELLOW + split[split.length - 1] + ChatColor.RED));
 
-    public void updateRentableName(String oldName, String newName)
+		} else
-    {
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ResidenceNotForRent"));
-        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)
+	public void updateRentableName(String oldName, String newName) {
-    {
+		if (rentableLand.containsKey(oldName)) {
-        Set<Entry<String, RentableLand>> set = rentableLand.entrySet();
+			rentableLand.put(newName, rentableLand.get(oldName));
-        player.sendMessage(ChatColor.YELLOW+Residence.getLanguage().getPhrase("RentableLand")+":");
+			rentableLand.remove(oldName);
-        StringBuilder sbuild = new StringBuilder();
+		}
-        sbuild.append(ChatColor.GREEN);
+		if (rentedLand.containsKey(oldName)) {
-        boolean firstadd = true;
+			rentedLand.put(newName, rentedLand.get(oldName));
-        for(Entry<String, RentableLand> land : set)
+			rentedLand.remove(oldName);
-        {
+		}
-            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)
+	private long daysToMs(int days) {
-    {
+		return ((days) * 24L * 60L * 60L * 1000L);
-        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)
+	@SuppressWarnings("unused")
-    {
+	private int msToDays(long ms) {
-        Set<String> set = rentableLand.keySet();
+		return (int) Math.ceil((((ms / 1000D) / 60D) / 60D) / 24D);
-        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/main/java/com/bekvon/bukkit/residence/listeners/ResidenceEntityListener.java

@@ -5,19 +5,40 @@
 
 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.ChatColor;
-
+import org.bukkit.Location;
+import org.bukkit.Material;
 import org.bukkit.block.Block;
+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.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Ghast;
+import org.bukkit.entity.Horse;
+import org.bukkit.entity.IronGolem;
 import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Monster;
+import org.bukkit.entity.Ocelot;
+import org.bukkit.entity.Pig;
 import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Rabbit;
+import org.bukkit.entity.Sheep;
+import org.bukkit.entity.Slime;
+import org.bukkit.entity.Snowman;
+import org.bukkit.entity.Squid;
+import org.bukkit.entity.Villager;
+import org.bukkit.entity.Wolf;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
 import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.event.entity.EntityChangeBlockEvent;
 import org.bukkit.event.entity.EntityCombustEvent;
@@ -25,130 +46,48 @@ 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.entity.PotionSplashEvent;
 import org.bukkit.event.hanging.HangingBreakByEntityEvent;
 import org.bukkit.event.hanging.HangingBreakEvent;
 import org.bukkit.event.hanging.HangingPlaceEvent;
 
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.ClaimedResidence;
+import com.bekvon.bukkit.residence.protection.FlagPermissions;
+
 /**
  *
  * @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))) {
+		if ((!(damager instanceof Arrow)) && (!(damager instanceof Player)))
 			return;
-		}
 
 		Player cause;
-		if ((damager instanceof Arrow)
+		if ((damager instanceof Arrow) && (!(((Arrow) damager).getShooter() instanceof Player)))
-				&& (!(((Arrow) damager).getShooter() instanceof Player))) {
 			return;
-
+		else if (damager instanceof Player)
-		} else if (damager instanceof Player) {
 			cause = (Player) damager;
-		} else {
+		else
 			cause = (Player) ((Arrow) damager).getShooter();
-		}
 
-		if (Residence.isResAdminOn(cause)) {
+		if (Residence.isResAdminOn(cause))
 			return;
-		}
 
 		Entity entity = event.getEntity();
-		ClaimedResidence res = Residence.getResidenceManager().getByLoc(
+		ClaimedResidence res = Residence.getResidenceManager().getByLoc(entity.getLocation());
-				entity.getLocation());
 
-		if (res != null
+		if (res != null && !res.getPermissions().playerHas(cause.getName(), "animalkilling", true))
-				&& !res.getPermissions().playerHas(cause.getName(),
-						"animalkilling", true)) {
 			if (isAnimal(entity)) {
-				cause.sendMessage(ChatColor.RED
+				cause.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-						+ Residence.getLanguage().getPhrase("NoPermission"));
 				event.setCancelled(true);
 			}
-		}
 	}
 
 	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
@@ -156,100 +95,126 @@ public class ResidenceEntityListener implements Listener {
 		FlagPermissions perms = Residence.getPermsByLoc(event.getLocation());
 		Entity ent = event.getEntity();
 		if (isAnimal(ent)) {
-			if (!perms.has("animals", true)) {
+			if (!perms.has("animals", true))
 				event.setCancelled(true);
-			}
+		} else if (!perms.has("monsters", true) && isMonster(ent))
-		} 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) {
+	public void onEndermanChangeBlock(EntityChangeBlockEvent event) {
-		if (event instanceof HangingBreakByEntityEvent) {
+		if (event.getEntityType() != EntityType.ENDERMAN && event.getEntityType() != EntityType.WITHER)
-			HangingBreakByEntityEvent evt = (HangingBreakByEntityEvent) event;
+			return;
-			if (evt.getRemover() instanceof Player) {
+		FlagPermissions perms = Residence.getPermsByLoc(event.getBlock().getLocation());
-				Player player = (Player) evt.getRemover();
+		FlagPermissions world = Residence.getWorldFlags().getPerms(event.getBlock().getWorld().getName());
-				if (Residence.isResAdminOn(player)) {
+		if (event.getEntityType() == EntityType.WITHER) {
-					return;
+			if (!perms.has("wither", perms.has("explode", world.has("wither", world.has("explode", true)))))
-				}
+				event.setCancelled(true);
-				String pname = player.getName();
+		} else if (!perms.has("build", true))
-				FlagPermissions perms = Residence.getPermsByLocForPlayer(event
+			event.setCancelled(true);
-						.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()
+		FlagPermissions perms = Residence.getPermsByLoc(event.getEntity().getLocation());
-				.getLocation());
+		if (!perms.has("burn", true))
-		if (!perms.has("burn", true)) {
 			event.setCancelled(true);
-		}
 	}
 
 	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
-	public void onExplosionPrime(ExplosionPrimeEvent event) {
+	public void onEntityDamage(EntityDamageEvent event) {
-		EntityType entity = event.getEntityType();
+		Entity ent = event.getEntity();
-		FlagPermissions perms = Residence.getPermsByLoc(event.getEntity()
+		if (ent.hasMetadata("NPC"))
-				.getLocation());
+			return;
-		if (entity == EntityType.CREEPER) {
+		boolean tamedWolf = ent instanceof Wolf ? ((Wolf) ent).isTamed() : false;
-			if (!perms.has("creeper", perms.has("explode", true))) {
+		ClaimedResidence area = Residence.getResidenceManager().getByLoc(ent.getLocation());
-				event.setCancelled(true);
+		/* Living Entities */
-				event.getEntity().remove();
+		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) {
+					if (attacker != null)
+						attacker.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPVPZone"));
+					event.setCancelled(true);
+					return;
+				}
+				/* Check for Player vs Player */
+				if (area == null) {
+					/* World PvP */
+					if (damager != null)
+						if (!Residence.getWorldFlags().getPerms(damager.getWorld().getName()).has("pvp", true)) {
+							if (attacker != null)
+								attacker.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("WorldPVPDisabled"));
+							event.setCancelled(true);
+						}
+				} else /* Normal PvP */
+					if (!area.getPermissions().has("pvp", true)) {
+					if (attacker != null)
+						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 (entity == EntityType.PRIMED_TNT
+		if (area == null) {
-				|| entity == EntityType.MINECART_TNT) {
+			if (!Residence.getWorldFlags().getPerms(ent.getWorld().getName()).has("damage", true) && (ent instanceof Player || tamedWolf))
-			if (!perms.has("tnt", perms.has("explode", true))) {
 				event.setCancelled(true);
-				event.getEntity().remove();
+		} else if (!area.getPermissions().has("damage", true) && (ent instanceof Player || tamedWolf))
-			}
+			event.setCancelled(true);
-		}
+		if (event.isCancelled())
-		if (entity == EntityType.FIREBALL) {
+			/* Put out a fire on a player */
-			if (!perms.has("fireball", perms.has("explode", true))) {
+			if ((ent instanceof Player || tamedWolf) && (event.getCause() == EntityDamageEvent.DamageCause.FIRE || event.getCause() == EntityDamageEvent.DamageCause.FIRE_TICK))
-				event.setCancelled(true);
+				ent.setFireTicks(0);
-				event.getEntity().remove();
+	}
-			}
+
-		}
+	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
-		if (entity == EntityType.SMALL_FIREBALL) {
+	public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
-			if (!perms.has("fireball", perms.has("explode", true))) {
+		if (event.getEntityType() == EntityType.ITEM_FRAME || (Residence.is1_8() && event.getEntityType() == EntityType.ARMOR_STAND)) {
-				event.setCancelled(true);
+			Entity dmgr = event.getDamager();
-				event.getEntity().remove();
+			Player player;
-			}
+			if (dmgr instanceof Player)
-		}
+				player = (Player) event.getDamager();
-		if (entity == EntityType.WITHER_SKULL) {
+			else if (dmgr instanceof Projectile && ((Projectile) dmgr).getShooter() instanceof Player)
-			if (!perms.has("witherdamage", perms.has("damage", true))) {
+				player = (Player) ((Projectile) dmgr).getShooter();
-				event.setCancelled(true);
+			else
-				event.getEntity().remove();
+				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) {
+				if (!res.getPermissions().has("container", false))
+					if (isMonster(dmgr)) {
+						event.setCancelled(true);
+						return;
+					}
+
+				if (!res.getPermissions().playerHas(player.getName(), "container", false)) {
+					event.setCancelled(true);
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("FlagDeny", "container"));
+				}
 			}
 		}
 	}
@@ -260,63 +225,113 @@ public class ResidenceEntityListener implements Listener {
 			return;
 		Boolean cancel = false;
 		EntityType entity = event.getEntityType();
-		FlagPermissions perms = Residence.getPermsByLoc(event.getEntity()
+		FlagPermissions perms = Residence.getPermsByLoc(event.getEntity().getLocation());
-				.getLocation());
+		FlagPermissions world = Residence.getWorldFlags().getPerms(event.getEntity().getWorld().getName());
-		FlagPermissions world = Residence.getWorldFlags().getPerms(
+		if (entity == EntityType.CREEPER)
-				event.getEntity().getWorld().getName());
+			if (!perms.has("creeper", perms.has("explode", true)))
-		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)))
-		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)))
-		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)))
-		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)))))
-		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
+				FlagPermissions blockperms = Residence.getPermsByLoc(block.getLocation());
-						.getLocation());
+				if ((!blockperms.has("wither", blockperms.has("explode", world.has("wither", world.has("explode", true)))) && (entity == EntityType.WITHER || entity == EntityType.WITHER_SKULL)
-				if ((!blockperms.has("wither", blockperms.has("explode",
+						|| (!blockperms.has("fireball", blockperms.has("explode", true)) && (entity == EntityType.FIREBALL || entity == EntityType.SMALL_FIREBALL))
-						world.has("wither", world.has("explode", true))))
+						|| (!blockperms.has("tnt", blockperms.has("explode", true)) && (entity == EntityType.PRIMED_TNT || entity == EntityType.MINECART_TNT))
-						&& (entity == EntityType.WITHER || entity == EntityType.WITHER_SKULL)
+						|| (!blockperms.has("creeper", blockperms.has("explode", true)) && entity == EntityType.CREEPER)))
-						|| (!blockperms.has("fireball",
+					preserve.add(block);
-								blockperms.has("explode", true)) && (entity == EntityType.FIREBALL || entity == EntityType.SMALL_FIREBALL))
+			}
-						|| (!blockperms.has("tnt",
+			for (Block block : preserve)
-								blockperms.has("explode", true)) && (entity == EntityType.PRIMED_TNT || entity == EntityType.MINECART_TNT)) || (!blockperms
+				event.blockList().remove(block);
-						.has("creeper", blockperms.has("explode", true)) && entity == EntityType.CREEPER))) {
+		}
-					if (block != null) {
+	}
-						preserve.add(block);
+
-					}
+	@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);
+	}
+
+	@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 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"));
 				}
 			}
-			for (Block block : preserve) {
+		}
-				event.blockList().remove(block);
+	}
-			}
+
+	@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"));
 		}
 	}
 
@@ -325,158 +340,24 @@ public class ResidenceEntityListener implements Listener {
 		if (event.isCancelled())
 			return;
 		Entity ent = event.getEntity();
-		boolean srcpvp = Residence.getPermsByLoc(ent.getLocation()).has("pvp",
+		boolean srcpvp = Residence.getPermsByLoc(ent.getLocation()).has("pvp", true);
-				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())
+				Boolean tgtpvp = Residence.getPermsByLoc(target.getLocation()).has("pvp", true);
-						.has("pvp", true);
+				if (!srcpvp || !tgtpvp)
-				if (!srcpvp || !tgtpvp) {
 					event.setIntensity(target, 0);
-				}
 			}
 		}
 	}
 
-	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
+	private boolean isAnimal(Entity ent) {
-	public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
+		return (ent instanceof Horse || ent instanceof Bat || ent instanceof Snowman || ent instanceof IronGolem || ent instanceof Ocelot || ent instanceof Pig || ent instanceof Sheep
-		if (event.getEntityType() == EntityType.ITEM_FRAME
+				|| ent instanceof Chicken || ent instanceof Wolf || ent instanceof Cow || ent instanceof Squid || ent instanceof Villager || (Residence.is1_8() && ent instanceof Rabbit));
-				|| event.getEntityType() == EntityType.ARMOR_STAND) {
-			Entity dmgr = event.getDamager();
-			Player player;
-			if (dmgr 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) {
-				if (!res.getPermissions().has("container", false)) {
-					if (isMonster(dmgr)) {
-						event.setCancelled(true);
-						return;
-					}
-				}
-
-				if (!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)
+	private boolean isMonster(Entity ent) {
-	public void onEntityDamage(EntityDamageEvent event) {
+		return (ent instanceof Monster || ent instanceof Slime || ent instanceof Ghast);
-		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/main/java/com/bekvon/bukkit/residence/listeners/ResidencePlayerListener.java

@@ -28,7 +28,6 @@ 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;
@@ -69,9 +68,8 @@ public class ResidencePlayerListener implements Listener {
 		playerToggleChat = new ArrayList<String>();
 		minUpdateTime = Residence.getConfigManager().getMinMoveUpdateInterval();
 		chatenabled = Residence.getConfigManager().chatEnabled();
-		for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+		for (Player player : Bukkit.getServer().getOnlinePlayers())
 			lastUpdate.put(player.getName(), System.currentTimeMillis());
-		}
 	}
 
 	public void doHeals() {
@@ -79,15 +77,13 @@ public class ResidencePlayerListener implements Listener {
 			for (Player player : Bukkit.getServer().getOnlinePlayers()) {
 				String resname = Residence.getPlayerListener().getCurrentResidenceName(player.getName());
 				ClaimedResidence res = null;
-				if (resname != 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()) {
+					if (health < 20 && !player.isDead())
 						player.setHealth(health + 1);
-					}
 				}
 			}
 		} catch (Exception ex) {
@@ -116,9 +112,8 @@ public class ResidencePlayerListener implements Listener {
 		ClaimedResidence ResOld = null;
 		if (currentRes.containsKey(pname)) {
 			ResOld = Residence.getResidenceManager().getByName(currentRes.get(pname));
-			if (ResOld == null) {
+			if (ResOld == null)
 				currentRes.remove(pname);
-			}
 		}
 		if (res == null) {
 			lastOutsideLoc.put(pname, loc);
@@ -129,40 +124,31 @@ public class ResidencePlayerListener implements Listener {
 				ResidenceChangedEvent chgEvent = new ResidenceChangedEvent(ResOld, null, player);
 				Residence.getServ().getPluginManager().callEvent(chgEvent);
 
-				if (leave != null && !leave.equals("")) {
+				if (leave != null && !leave.equals(""))
-					if (Residence.getConfigManager().useActionBar()) {
+					if (Residence.getConfigManager().useActionBar())
-						ActionBar.send(player,
+						ActionBar.send(player, (new StringBuilder()).append(ChatColor.YELLOW).append(insertMessages(player, ResOld.getName(), ResOld, leave)).toString());
-								(new StringBuilder()).append(ChatColor.YELLOW).append(insertMessages(player, ResOld.getName(), ResOld, leave))
+					else
-										.toString());
-					} else {
 						player.sendMessage(ChatColor.YELLOW + this.insertMessages(player, ResOld.getName(), ResOld, leave));
-					}
-				}
 				currentRes.remove(pname);
 				Residence.getChatManager().removeFromChannel(pname);
 			}
 			return;
 		}
-		if (move) {
+		if (move)
-			if (!res.getPermissions().playerHas(pname, "move", true) && !Residence.isResAdminOn(player)
+			if (!res.getPermissions().playerHas(pname, "move", true) && !Residence.isResAdminOn(player) && !player.hasPermission("residence.admin.move")) {
-					&& !player.hasPermission("residence.admin.move")) {
 				Location lastLoc = lastOutsideLoc.get(pname);
-				if (lastLoc != null) {
+				if (lastLoc != null)
 					player.teleport(lastLoc);
-				} else {
+				else
 					player.teleport(res.getOutsideFreeLoc(loc));
-				}
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ResidenceMoveDeny", res.getName().split("\\.")[res.getName().split("\\.").length - 1]));
-				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) {
+			if (subzone == null)
 				chatchange = true;
-			}
 
 			// "from" residence for ResidenceChangedEvent
 			ClaimedResidence chgFrom = null;
@@ -170,15 +156,11 @@ public class ResidencePlayerListener implements Listener {
 				String leave = ResOld.getLeaveMessage();
 				chgFrom = ResOld;
 
-				if (leave != null && !leave.equals("") && ResOld != res.getParent()) {
+				if (leave != null && !leave.equals("") && ResOld != res.getParent())
-					if (Residence.getConfigManager().useActionBar()) {
+					if (Residence.getConfigManager().useActionBar())
-						ActionBar.send(player,
+						ActionBar.send(player, (new StringBuilder()).append(ChatColor.YELLOW).append(insertMessages(player, ResOld.getName(), ResOld, leave)).toString());
-								(new StringBuilder()).append(ChatColor.YELLOW).append(insertMessages(player, ResOld.getName(), ResOld, leave))
+					else
-										.toString());
-					} else {
 						player.sendMessage(ChatColor.YELLOW + this.insertMessages(player, ResOld.getName(), ResOld, leave));
-					}
-				}
 			}
 			String enterMessage = res.getEnterMessage();
 
@@ -186,18 +168,14 @@ public class ResidencePlayerListener implements Listener {
 			ResidenceChangedEvent chgEvent = new ResidenceChangedEvent(chgFrom, res, player);
 			Residence.getServ().getPluginManager().callEvent(chgEvent);
 
-			if (enterMessage != null && !enterMessage.equals("") && !(ResOld != null && res == ResOld.getParent())) {
+			if (enterMessage != null && !enterMessage.equals("") && !(ResOld != null && res == ResOld.getParent()))
-				if (Residence.getConfigManager().useActionBar()) {
+				if (Residence.getConfigManager().useActionBar())
-					ActionBar.send(player, (new StringBuilder()).append(ChatColor.YELLOW).append(insertMessages(player, areaname, res, enterMessage))
+					ActionBar.send(player, (new StringBuilder()).append(ChatColor.YELLOW).append(insertMessages(player, areaname, res, enterMessage)).toString());
-							.toString());
+				else
-				} else {
 					player.sendMessage(ChatColor.YELLOW + this.insertMessages(player, areaname, res, enterMessage));
-				}
-			}
 		}
-		if (chatchange && chatenabled) {
+		if (chatchange && chatenabled)
 			Residence.getChatManager().setChannel(pname, areaname);
-		}
 	}
 
 	public String insertMessages(Player player, String areaname, ClaimedResidence res, String message) {
@@ -211,32 +189,6 @@ public class ResidencePlayerListener implements Listener {
 		return message;
 	}
 
-	private boolean isCanUseEntity(Material mat, Block block) {
-		return isCanUseEntity_BothClick(mat, block) || isCanUseEntity_RClickOnly(mat, block);
-	}
-
-	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 isContainer(Material mat, Block block) {
-		return FlagPermissions.getMaterialUseFlagList().containsKey(mat) && FlagPermissions.getMaterialUseFlagList().get(mat).equals("container")
-				|| Residence.getConfigManager().getCustomContainers().contains(Integer.valueOf(block.getTypeId()));
-	}
-
 	@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
 	public void onPlayerBucketEmpty(PlayerBucketEmptyEvent event) {
 		Player player = event.getPlayer();
@@ -244,15 +196,13 @@ public class ResidencePlayerListener implements Listener {
 			return;
 		String pname = player.getName();
 		ClaimedResidence res = Residence.getResidenceManager().getByLoc(event.getBlockClicked().getLocation());
-		if (res != null) {
+		if (res != null)
-			if (Residence.getConfigManager().preventRentModify() && Residence.getConfigManager().enabledRentSystem()) {
+			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"));
@@ -267,18 +217,15 @@ public class ResidencePlayerListener implements Listener {
 		if (Residence.isResAdminOn(player))
 			return;
 		ClaimedResidence res = Residence.getResidenceManager().getByLoc(event.getBlockClicked().getLocation());
-		if (res != null) {
+		if (res != null)
-			if (Residence.getConfigManager().preventRentModify() && Residence.getConfigManager().enabledRentSystem()) {
+			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",
+		boolean hasbucket = perms.playerHas(pname, player.getWorld().getName(), "bucket", perms.playerHas(pname, player.getWorld().getName(), "build", true));
-				perms.playerHas(pname, player.getWorld().getName(), "build", true));
 		if (!hasbucket) {
 			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("FlagDeny", "bucket"));
 			event.setCancelled(true);
@@ -292,9 +239,8 @@ public class ResidencePlayerListener implements Listener {
 			String area = currentRes.get(pname);
 			if (area != null) {
 				ChatChannel channel = Residence.getChatManager().getChannel(area);
-				if (channel != null) {
+				if (channel != null)
 					channel.chat(pname, event.getMessage());
-				}
 				event.setCancelled(true);
 			}
 		}
@@ -308,11 +254,10 @@ public class ResidencePlayerListener implements Listener {
 		if (block == null)
 			return;
 		Material mat = block.getType();
-		if (!((isContainer(mat, block) || isCanUseEntity_RClickOnly(mat, block)) && event.getAction() == Action.RIGHT_CLICK_BLOCK
+		if (!((isContainer(mat, block) || isCanUseEntity_RClickOnly(mat, block)) && event.getAction() == Action.RIGHT_CLICK_BLOCK || isCanUseEntity_BothClick(mat, block)
-				|| isCanUseEntity_BothClick(mat, block) || event.getAction() == Action.PHYSICAL)) {
+				|| event.getAction() == Action.PHYSICAL)) {
 			int typeId = player.getItemInHand().getTypeId();
-			if (typeId != Residence.getConfigManager().getSelectionTooldID() && typeId != Residence.getConfigManager().getInfoToolID()
+			if (typeId != Residence.getConfigManager().getSelectionTooldID() && typeId != Residence.getConfigManager().getInfoToolID() && typeId != 351 && typeId != 416)
-					&& typeId != 351 && typeId != 416)
 				return;
 		}
 		FlagPermissions perms = Residence.getPermsByLocForPlayer(block.getLocation(), player);
@@ -328,8 +273,7 @@ public class ResidencePlayerListener implements Listener {
 					return;
 				}
 			}
-			if (!perms.playerHas(player.getName(), world, "trample", perms.playerHas(player.getName(), world, "build", true))
+			if (!perms.playerHas(player.getName(), world, "trample", perms.playerHas(player.getName(), world, "build", true)) && (mat == Material.SOIL || mat == Material.SOUL_SAND)) {
-					&& (mat == Material.SOIL || mat == Material.SOUL_SAND)) {
 				event.setCancelled(true);
 				return;
 			}
@@ -343,31 +287,27 @@ public class ResidencePlayerListener implements Listener {
 		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 (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")
+				if (player.hasPermission("residence.select") || player.hasPermission("residence.create") && !player.isPermissionSet("residence.select")
-						&& !player.isPermissionSet("residence.select") || group.canCreateResidences() && !player.isPermissionSet("residence.create")
+						|| group.canCreateResidences() && !player.isPermissionSet("residence.create") && !player.isPermissionSet("residence.select") || resadmin) {
-						&& !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
+						player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SelectPoint", Residence.getLanguage().getPhrase("Primary")) + ChatColor.RED + "(" + loc.getBlockX()
-								+ Residence.getLanguage().getPhrase("SelectPoint", Residence.getLanguage().getPhrase("Primary")) + ChatColor.RED
+								+ "," + loc.getBlockY() + "," + loc.getBlockZ() + ")" + ChatColor.GREEN + "!");
-								+ "(" + 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
+						player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SelectPoint", Residence.getLanguage().getPhrase("Secondary")) + ChatColor.RED + "(" + loc.getBlockX()
-								+ Residence.getLanguage().getPhrase("SelectPoint", Residence.getLanguage().getPhrase("Secondary")) + ChatColor.RED
+								+ "," + loc.getBlockY() + "," + loc.getBlockZ() + ")" + ChatColor.GREEN + "!");
-								+ "(" + loc.getBlockX() + "," + loc.getBlockY() + "," + loc.getBlockZ() + ")" + ChatColor.GREEN + "!");
 					}
 					event.setCancelled(true);
 				}
 			}
-			if (player.getItemInHand().getTypeId() == Residence.getConfigManager().getInfoToolID()) {
+			if (player.getItemInHand().getTypeId() == Residence.getConfigManager().getInfoToolID())
 				if (event.getAction() == Action.LEFT_CLICK_BLOCK) {
 					Location loc = block.getLocation();
 					String res = Residence.getResidenceManager().getNameByLoc(loc);
@@ -380,13 +320,11 @@ public class ResidencePlayerListener implements Listener {
 						player.sendMessage(Residence.getLanguage().getPhrase("NoResHere"));
 					}
 				}
-			}
 			if (!resadmin) {
-				if (heldItem != null) {
+				if (heldItem != null)
 					if (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
-						if (player.getItemInHand().getTypeId() == 351) {
+						if (player.getItemInHand().getTypeId() == 351)
-							if (player.getItemInHand().getData().getData() == 15 && block.getType() == Material.GRASS
+							if (player.getItemInHand().getData().getData() == 15 && block.getType() == Material.GRASS || player.getItemInHand().getData().getData() == 3 && block.getTypeId() == 17
-									|| 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)) {
@@ -394,22 +332,21 @@ public class ResidencePlayerListener implements Listener {
 									return;
 								}
 							}
-						}
+						if (Residence.is1_8())
-						if (heldItem == Material.ARMOR_STAND) {
+							if (heldItem == Material.ARMOR_STAND) {
-							perms = Residence.getPermsByLocForPlayer(block.getRelative(event.getBlockFace()).getLocation(), player);
+								perms = Residence.getPermsByLocForPlayer(block.getRelative(event.getBlockFace()).getLocation(), player);
-							if (!perms.playerHas(player.getName(), world, "build", true)) {
+								if (!perms.playerHas(player.getName(), world, "build", true)) {
-								player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
+									player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-								event.setCancelled(true);
+									event.setCancelled(true);
-								return;
+									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()) {
+					for (Entry<Material, String> checkMat : FlagPermissions.getMaterialUseFlagList().entrySet())
-						if (mat == checkMat.getKey()) {
+						if (mat == checkMat.getKey())
-							if (!perms.playerHas(player.getName(), world, checkMat.getValue(), hasuse)) {
+							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()));
@@ -419,56 +356,30 @@ public class ResidencePlayerListener implements Listener {
 									player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("FlagDeny", "use"));
 									return;
 								}
-							}
+					if (Residence.getConfigManager().getCustomContainers().contains(Integer.valueOf(block.getTypeId())))
-						}
-					}
-					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 (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 (event.getAction() == Action.RIGHT_CLICK_BLOCK) {
+						if (Residence.getConfigManager().getCustomRightClick().contains(Integer.valueOf(block.getTypeId())))
-						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 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 onPlayerInteractEntity(PlayerInteractEntityEvent event) {
 		Player player = event.getPlayer();
@@ -510,9 +421,8 @@ public class ResidencePlayerListener implements Listener {
 	public void onPlayerJoin(PlayerJoinEvent event) {
 		Player player = event.getPlayer();
 		lastUpdate.put(player.getName(), 0L);
-		if (Residence.getPermissionManager().isResidenceAdmin(player)) {
+		if (Residence.getPermissionManager().isResidenceAdmin(player))
 			Residence.turnResAdminOn(player);
-		}
 		handleNewLocation(player, player.getLocation(), false);
 	}
 
@@ -530,10 +440,9 @@ public class ResidencePlayerListener implements Listener {
 		if (now - last < Residence.getConfigManager().getMinMoveUpdateInterval())
 			return;
 		lastUpdate.put(player.getName(), now);
-		if (event.getFrom().getWorld() == event.getTo().getWorld()) {
+		if (event.getFrom().getWorld() == event.getTo().getWorld())
 			if (event.getFrom().distance(event.getTo()) == 0)
 				return;
-		}
 		handleNewLocation(player, event.getTo(), true);
 	}
 
@@ -556,15 +465,12 @@ public class ResidencePlayerListener implements Listener {
 			return;
 		if (res.getPermissions().playerHas(player.getName(), "move", true))
 			return;
-		if (bed) {
+		if (bed)
 			loc = player.getWorld().getSpawnLocation();
-		}
 		res = Residence.getResidenceManager().getByLoc(loc);
-		if (res != null) {
+		if (res != null)
-			if (!res.getPermissions().playerHas(player.getName(), "move", true)) {
+			if (!res.getPermissions().playerHas(player.getName(), "move", true))
 				loc = res.getOutsideFreeLoc(loc);
-			}
-		}
 		player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoSpawn"));
 		event.setRespawnLocation(loc);
 	}
@@ -580,8 +486,7 @@ public class ResidencePlayerListener implements Listener {
 		}
 
 		ClaimedResidence res = Residence.getResidenceManager().getByLoc(loc);
-		if (event.getCause() == TeleportCause.ENDER_PEARL || event.getCause() == TeleportCause.COMMAND
+		if (event.getCause() == TeleportCause.ENDER_PEARL || event.getCause() == TeleportCause.COMMAND || event.getCause() == TeleportCause.NETHER_PORTAL)
-				|| event.getCause() == TeleportCause.NETHER_PORTAL) {
 			if (res != null) {
 				String areaname = Residence.getResidenceManager().getNameByLoc(loc);
 				if (!res.getPermissions().playerHas(player.getName(), "move", true)) {
@@ -590,8 +495,7 @@ public class ResidencePlayerListener implements Listener {
 					return;
 				}
 			}
-		}
+		if (event.getCause() == TeleportCause.PLUGIN)
-		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")) {
@@ -600,7 +504,6 @@ public class ResidencePlayerListener implements Listener {
 					return;
 				}
 			}
-		}
 		handleNewLocation(player, loc, false);
 	}
 
@@ -611,9 +514,8 @@ public class ResidencePlayerListener implements Listener {
 		playerToggleChat = new ArrayList<String>();
 		minUpdateTime = Residence.getConfigManager().getMinMoveUpdateInterval();
 		chatenabled = Residence.getConfigManager().chatEnabled();
-		for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+		for (Player player : Bukkit.getServer().getOnlinePlayers())
 			lastUpdate.put(player.getName(), System.currentTimeMillis());
-		}
 	}
 
 	public void tooglePlayerResidenceChat(Player player) {
@@ -626,4 +528,28 @@ public class ResidencePlayerListener implements Listener {
 			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("ResidenceChat", ChatColor.RED + "ON" + ChatColor.YELLOW + "!"));
 		}
 	}
+
+	private boolean isCanUseEntity(Material mat, Block block) {
+		return isCanUseEntity_BothClick(mat, block) || isCanUseEntity_RClickOnly(mat, block);
+	}
+
+	private boolean isCanUseEntity_BothClick(Material mat, Block block) {
+		return mat == Material.LEVER || mat == Material.STONE_BUTTON || mat == Material.WOOD_BUTTON || mat == Material.WOODEN_DOOR
+				|| (Residence.is1_8() && (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 isContainer(Material mat, Block block) {
+		return FlagPermissions.getMaterialUseFlagList().containsKey(mat) && FlagPermissions.getMaterialUseFlagList().get(mat).equals("container")
+				|| Residence.getConfigManager().getCustomContainers().contains(Integer.valueOf(block.getTypeId()));
+	}
 }

src/main/java/com/bekvon/bukkit/residence/listeners/ResidencePlayerListener_1_8.java

@@ -0,0 +1,45 @@
+/*
+ * 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.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractAtEntityEvent;
+
+import com.bekvon.bukkit.residence.Residence;
+import com.bekvon.bukkit.residence.protection.FlagPermissions;
+
+/**
+ *
+ * @author Administrator
+ */
+public class ResidencePlayerListener_1_8 implements Listener {
+
+	@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"));
+		}
+	}
+
+}

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

@@ -32,52 +32,8 @@ import com.bekvon.bukkit.residence.text.help.InformationPager;
  */
 public class ClaimedResidence {
 
-	@SuppressWarnings({ "unchecked", "rawtypes" })
-	public static ClaimedResidence load(Map 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 tploc = (Map) 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;
-	}
-
 	protected ClaimedResidence parent;
+
 	protected Map<String, CuboidArea> areas;
 	protected Map<String, ClaimedResidence> subzones;
 	protected ResidencePermissions perms;
@@ -86,17 +42,8 @@ public class ClaimedResidence {
 	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);
 	}
@@ -111,114 +58,129 @@ public class ClaimedResidence {
 		parent = parentResidence;
 	}
 
+	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);
+	}
+
+	@SuppressWarnings({ "unchecked", "rawtypes" })
+	public static ClaimedResidence load(Map 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 tploc = (Map) 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 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) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidNameCharacters"));
-						+ Residence.getLanguage().getPhrase("InvalidNameCharacters"));
-			}
 			return false;
 		}
 		if (areas.containsKey(name)) {
-			if (player != null) {
+			if (player != null)
 				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaExists"));
-			}
 			return false;
 		}
-		if (!resadmin && Residence.getConfigManager().getEnforceAreaInsideArea()
+		if (!resadmin && Residence.getConfigManager().getEnforceAreaInsideArea() && this.getParent() == null) {
-				&& this.getParent() == null) {
 			boolean inside = false;
-			for (CuboidArea are : areas.values()) {
+			for (CuboidArea are : areas.values())
-				if (are.isAreaWithinArea(area)) {
+				if (are.isAreaWithinArea(area))
 					inside = true;
-				}
-			}
 			if (!inside)
 				return false;
 		}
 		if (!area.getWorld().getName().equalsIgnoreCase(perms.getWorld())) {
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaDiffWorld"));
-						+ Residence.getLanguage().getPhrase("AreaDiffWorld"));
-			}
 			return false;
 		}
 		if (parent == null) {
-			String collideResidence = Residence.getResidenceManager()
+			String collideResidence = Residence.getResidenceManager().checkAreaCollision(area, this);
-					.checkAreaCollision(area, this);
 			if (collideResidence != null) {
-				if (player != null) {
+				if (player != null)
-					player.sendMessage(ChatColor.RED
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaCollision", ChatColor.YELLOW + collideResidence));
-							+ 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 != null && res != this)
 					if (res.checkCollision(area)) {
-						if (player != null) {
+						if (player != null)
-							player.sendMessage(ChatColor.RED
+							player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaSubzoneCollision", ChatColor.YELLOW + sz));
-									+ Residence.getLanguage().getPhrase("AreaSubzoneCollision",
-											ChatColor.YELLOW + sz));
-						}
 						return false;
 					}
-				}
 			}
 		}
 		if (!resadmin && player != null) {
 			if (!this.perms.hasResidencePermission(player, true)) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-						+ Residence.getLanguage().getPhrase("NoPermission"));
 				return false;
 			}
 			if (parent != null) {
 				if (!parent.containsLoc(area.getHighLoc()) || !parent.containsLoc(area.getLowLoc())) {
-					player.sendMessage(ChatColor.RED
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaNotWithinParent"));
-							+ Residence.getLanguage().getPhrase("AreaNotWithinParent"));
 					return false;
 				}
-				if (!parent.getPermissions().hasResidencePermission(player, true)
+				if (!parent.getPermissions().hasResidencePermission(player, true) && !parent.getPermissions().playerHas(player.getName(), "subzone", true)) {
-						&& !parent.getPermissions().playerHas(player.getName(), "subzone", true)) {
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ParentNoPermission"));
-					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
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-						+ Residence.getLanguage().getPhrase("NoPermission"));
 				return false;
 			}
 			if (areas.size() >= group.getMaxPhysicalPerResidence()) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaMaxPhysical"));
-						+ Residence.getLanguage().getPhrase("AreaMaxPhysical"));
 				return false;
 			}
 			if (!group.inLimits(area)) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaSizeLimit"));
-						+ Residence.getLanguage().getPhrase("AreaSizeLimit"));
 				return false;
 			}
 			if (group.getMinHeight() > area.getLowLoc().getBlockY()) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaLowLimit", ChatColor.YELLOW + String.format("%d", group.getMinHeight())));
-						+ Residence.getLanguage().getPhrase("AreaLowLimit",
-								ChatColor.YELLOW + String.format("%d", group.getMinHeight())));
 				return false;
 			}
 			if (group.getMaxHeight() < area.getHighLoc().getBlockY()) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaHighLimit", ChatColor.YELLOW + String.format("%d", group.getMaxHeight())));
-						+ Residence.getLanguage().getPhrase("AreaHighLimit",
-								ChatColor.YELLOW + String.format("%d", group.getMaxHeight())));
 				return false;
 			}
 			if (parent == null && Residence.getConfigManager().enableEconomy()) {
@@ -230,10 +192,8 @@ public class ClaimedResidence {
 		Residence.getResidenceManager().removeChunkList(getName());
 		areas.put(name, area);
 		Residence.getResidenceManager().calculateChunks(getName());
-		if (player != null) {
+		if (player != null)
-			player.sendMessage(ChatColor.GREEN
+			player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("AreaCreate", ChatColor.YELLOW + name));
-					+ Residence.getLanguage().getPhrase("AreaCreate", ChatColor.YELLOW + name));
-		}
 		return true;
 	}
 
@@ -246,40 +206,29 @@ public class ClaimedResidence {
 
 	public boolean addSubzone(Player player, String owner, Location loc1, Location loc2, String name, boolean resadmin) {
 		if (!Residence.validName(name)) {
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidNameCharacters"));
-						+ Residence.getLanguage().getPhrase("InvalidNameCharacters"));
-			}
 			return false;
 		}
 		if (!(this.containsLoc(loc1) && this.containsLoc(loc2))) {
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneSelectInside"));
-						+ Residence.getLanguage().getPhrase("SubzoneSelectInside"));
-			}
 			return false;
 		}
 		if (subzones.containsKey(name)) {
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneExists", ChatColor.YELLOW + name));
-						+ Residence.getLanguage().getPhrase("SubzoneExists",
-								ChatColor.YELLOW + name));
-			}
 			return false;
 		}
 		if (!resadmin && player != null) {
-			if (!this.perms.hasResidencePermission(player, true)) {
+			if (!this.perms.hasResidencePermission(player, true))
-				if (!this.perms.playerHas(player.getName(), "subzone",
+				if (!this.perms.playerHas(player.getName(), "subzone", this.perms.playerHas(player.getName(), "admin", false))) {
-						this.perms.playerHas(player.getName(), "admin", false))) {
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-					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
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneMaxDepth"));
-						+ Residence.getLanguage().getPhrase("SubzoneMaxDepth"));
 				return false;
 			}
 		}
@@ -288,11 +237,8 @@ public class ClaimedResidence {
 		for (Entry<String, ClaimedResidence> resEntry : set) {
 			ClaimedResidence res = resEntry.getValue();
 			if (res.checkCollision(newArea)) {
-				if (player != null) {
+				if (player != null)
-					player.sendMessage(ChatColor.RED
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneCollide", ChatColor.YELLOW + resEntry.getKey()));
-							+ Residence.getLanguage().getPhrase("SubzoneCollide",
-									ChatColor.YELLOW + resEntry.getKey()));
-				}
 				return false;
 			}
 		}
@@ -311,22 +257,15 @@ public class ClaimedResidence {
 				newres.setEnterMessage(group.getDefaultEnterMessage());
 				newres.setLeaveMessage(group.getDefaultLeaveMessage());
 			}
-			if (Residence.getConfigManager().flagsInherit()) {
+			if (Residence.getConfigManager().flagsInherit())
 				newres.getPermissions().setParent(perms);
-			}
 			subzones.put(name, newres);
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.GREEN
+				player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SubzoneCreate", ChatColor.YELLOW + name));
-						+ Residence.getLanguage().getPhrase("SubzoneCreate",
-								ChatColor.YELLOW + name));
-			}
 			return true;
 		} else {
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneCreateFail", ChatColor.YELLOW + name));
-						+ Residence.getLanguage().getPhrase("SubzoneCreateFail",
-								ChatColor.YELLOW + name));
-			}
 			return false;
 		}
 	}
@@ -339,23 +278,21 @@ public class ClaimedResidence {
 		Set<String> set = areas.keySet();
 		for (String key : set) {
 			CuboidArea checkarea = areas.get(key);
-			if (checkarea != null) {
+			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) {
+		for (CuboidArea key : keys)
 			if (key.containsLoc(loc)) {
 				if (parent != null)
 					return parent.containsLoc(loc);
 				return true;
 			}
-		}
 		return false;
 	}
 
@@ -374,10 +311,9 @@ public class ClaimedResidence {
 	}
 
 	public CuboidArea getAreaByLoc(Location loc) {
-		for (CuboidArea thisarea : areas.values()) {
+		for (CuboidArea thisarea : areas.values())
 			if (thisarea.containsLoc(loc))
 				return thisarea;
-		}
 		return null;
 	}
 
@@ -386,10 +322,9 @@ public class ClaimedResidence {
 	}
 
 	public String getAreaIDbyLoc(Location loc) {
-		for (Entry<String, CuboidArea> area : areas.entrySet()) {
+		for (Entry<String, CuboidArea> area : areas.entrySet())
 			if (area.getValue().containsLoc(loc))
 				return area.getKey();
-		}
 		return null;
 	}
 
@@ -434,8 +369,7 @@ public class ClaimedResidence {
 		if (area == null)
 			return insideLoc;
 		Location highLoc = area.getHighLoc();
-		Location newLoc = new Location(highLoc.getWorld(), highLoc.getBlockX(),
+		Location newLoc = new Location(highLoc.getWorld(), highLoc.getBlockX(), highLoc.getBlockY(), highLoc.getBlockZ());
-				highLoc.getBlockY(), highLoc.getBlockZ());
 		boolean found = false;
 		int it = 0;
 		while (!found && it < maxIt) {
@@ -445,14 +379,12 @@ public class ClaimedResidence {
 			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)
+			while ((newLoc.getBlock().getTypeId() != 0 || lowLoc.getBlock().getTypeId() == 0) && lowLoc.getBlockY() > -126) {
-					&& lowLoc.getBlockY() > -126) {
 				newLoc.setY(newLoc.getY() - 1);
 				lowLoc.setY(lowLoc.getY() - 1);
 			}
-			if (newLoc.getBlock().getTypeId() == 0 && lowLoc.getBlock().getTypeId() != 0) {
+			if (newLoc.getBlock().getTypeId() == 0 && lowLoc.getBlock().getTypeId() != 0)
 				found = true;
-			}
 		}
 		if (found)
 			return newLoc;
@@ -478,11 +410,9 @@ public class ClaimedResidence {
 
 	public ArrayList<Player> getPlayersInResidence() {
 		ArrayList<Player> within = new ArrayList<Player>();
-		for (Player player : Bukkit.getServer().getOnlinePlayers()) {
+		for (Player player : Bukkit.getServer().getOnlinePlayers())
-			if (this.containsLoc(player.getLocation())) {
+			if (this.containsLoc(player.getLocation()))
 				within.add(player);
-			}
-		}
 		return within;
 	}
 
@@ -512,6 +442,8 @@ public class ClaimedResidence {
 		}
 		if (!found)
 			return null;
+		if (res == null)
+			return null;
 		ClaimedResidence subrez = res.getSubzoneByLoc(loc);
 		if (subrez == null)
 			return res;
@@ -521,11 +453,9 @@ public class ClaimedResidence {
 	public String[] getSubzoneList() {
 		ArrayList<String> zones = new ArrayList<String>();
 		Set<String> set = subzones.keySet();
-		for (String key : set) {
+		for (String key : set)
-			if (key != null) {
+			if (key != null)
 				zones.add(key);
-			}
-		}
 		return zones.toArray(new String[zones.size()]);
 	}
 
@@ -542,6 +472,8 @@ public class ClaimedResidence {
 		}
 		if (key == null)
 			return null;
+		if (res == null)
+			return null;
 		String subname = res.getSubzoneNameByLoc(loc);
 		if (subname != null)
 			return key + "." + subname;
@@ -569,9 +501,8 @@ public class ClaimedResidence {
 	public long getTotalSize() {
 		Collection<CuboidArea> set = areas.values();
 		long size = 0;
-		for (CuboidArea entry : set) {
+		for (CuboidArea entry : set)
 			size = size + entry.getSize();
-		}
 		return size;
 	}
 
@@ -605,34 +536,25 @@ public class ClaimedResidence {
 			CuboidArea a = entry.getValue();
 			Location h = a.getHighLoc();
 			Location l = a.getLowLoc();
-			temp.add(ChatColor.GREEN + "{" + ChatColor.YELLOW + "ID:" + ChatColor.RED
+			temp.add(ChatColor.GREEN + "{" + ChatColor.YELLOW + "ID:" + ChatColor.RED + entry.getKey() + " " + ChatColor.YELLOW + "P1:" + ChatColor.RED + "(" + h.getBlockX() + "," + h.getBlockY()
-					+ entry.getKey() + " " + ChatColor.YELLOW + "P1:" + ChatColor.RED + "("
+					+ "," + h.getBlockZ() + ") " + ChatColor.YELLOW + "P2:" + ChatColor.RED + "(" + l.getBlockX() + "," + l.getBlockY() + "," + l.getBlockZ() + ") " + ChatColor.YELLOW + "(Size:"
-					+ 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"),
+		InformationPager.printInfo(player, Residence.getLanguage().getPhrase("PhysicalAreas"), temp, page);
-				temp, page);
 	}
 
 	public void printAreaList(Player player, int page) {
 		ArrayList<String> temp = new ArrayList<String>();
-		for (String area : areas.keySet()) {
+		for (String area : areas.keySet())
 			temp.add(area);
-		}
+		InformationPager.printInfo(player, Residence.getLanguage().getPhrase("PhysicalAreas"), temp, page);
-		InformationPager.printInfo(player, Residence.getLanguage().getPhrase("PhysicalAreas"),
-				temp, page);
 	}
 
 	public void printSubzoneList(Player player, int page) {
 		ArrayList<String> temp = new ArrayList<String>();
-		for (Entry<String, ClaimedResidence> sz : subzones.entrySet()) {
+		for (Entry<String, ClaimedResidence> sz : subzones.entrySet())
-			temp.add(ChatColor.GREEN + sz.getKey() + ChatColor.YELLOW + " - "
+			temp.add(ChatColor.GREEN + sz.getKey() + ChatColor.YELLOW + " - " + Residence.getLanguage().getPhrase("Owner") + ": " + sz.getValue().getOwner());
-					+ Residence.getLanguage().getPhrase("Owner") + ": " + sz.getValue().getOwner());
+		InformationPager.printInfo(player, Residence.getLanguage().getPhrase("Subzones"), temp, page);
-		}
-		InformationPager.printInfo(player, Residence.getLanguage().getPhrase("Subzones"), temp,
-				page);
 	}
 
 	public void remove() {
@@ -647,20 +569,17 @@ public class ClaimedResidence {
 
 		if (this.getPermissions().hasResidencePermission(player, true) || resadmin) {
 			if (!areas.containsKey(id)) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaNonExist"));
-						+ Residence.getLanguage().getPhrase("AreaNonExist"));
 				return;
 			}
 			if (areas.size() == 1 && !Residence.getConfigManager().allowEmptyResidences()) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaRemoveLast"));
-						+ Residence.getLanguage().getPhrase("AreaRemoveLast"));
 				return;
 			}
 			removeArea(id);
 			player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("AreaRemove"));
-		} else {
+		} else
 			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-		}
 	}
 
 	public void removeArea(String id) {
@@ -676,11 +595,8 @@ public class ClaimedResidence {
 			return false;
 		}
 		subzones.remove(name);
-		if (player != null) {
+		if (player != null)
-			player.sendMessage(ChatColor.GREEN
+			player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SubzoneRemove", ChatColor.YELLOW + name + ChatColor.GREEN));
-					+ Residence.getLanguage().getPhrase("SubzoneRemove",
-							ChatColor.YELLOW + name + ChatColor.GREEN));
-		}
 		return true;
 	}
 
@@ -690,38 +606,28 @@ public class ClaimedResidence {
 
 	public boolean renameArea(Player player, String oldName, String newName, boolean resadmin) {
 		if (!Residence.validName(newName)) {
-			player.sendMessage(ChatColor.RED
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidNameCharacters"));
-					+ Residence.getLanguage().getPhrase("InvalidNameCharacters"));
 			return false;
 		}
 		if (player == null || perms.hasResidencePermission(player, true) || resadmin) {
 			if (areas.containsKey(newName)) {
-				if (player != null) {
+				if (player != null)
-					player.sendMessage(ChatColor.RED
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaExists"));
-							+ Residence.getLanguage().getPhrase("AreaExists"));
-				}
 				return false;
 			}
 			CuboidArea area = areas.get(oldName);
 			if (area == null) {
-				if (player != null) {
+				if (player != null)
-					player.sendMessage(ChatColor.RED
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaInvalidName"));
-							+ Residence.getLanguage().getPhrase("AreaInvalidName"));
-				}
 				return false;
 			}
 			areas.put(newName, area);
 			areas.remove(oldName);
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.GREEN
+				player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("AreaRename", oldName + "." + newName));
-						+ Residence.getLanguage().getPhrase("AreaRename", oldName + "." + newName));
-			}
 			return true;
 		} else {
-			if (player != null) {
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-				player.sendMessage(ChatColor.RED
-						+ Residence.getLanguage().getPhrase("NoPermission"));
-			}
 			return false;
 		}
 	}
@@ -732,40 +638,28 @@ public class ClaimedResidence {
 
 	public boolean renameSubzone(Player player, String oldName, String newName, boolean resadmin) {
 		if (!Residence.validName(newName)) {
-			player.sendMessage(ChatColor.RED
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidNameCharacters"));
-					+ Residence.getLanguage().getPhrase("InvalidNameCharacters"));
 			return false;
 		}
 		ClaimedResidence res = subzones.get(oldName);
 		if (res == null) {
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidSubzone"));
-						+ Residence.getLanguage().getPhrase("InvalidSubzone"));
-			}
 			return false;
 		}
-		if (player != null && !res.getPermissions().hasResidencePermission(player, true)
+		if (player != null && !res.getPermissions().hasResidencePermission(player, true) && !resadmin) {
-				&& !resadmin) {
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-			if (player != null) {
-				player.sendMessage(ChatColor.RED
-						+ Residence.getLanguage().getPhrase("NoPermission"));
-			}
 			return false;
 		}
 		if (subzones.containsKey(newName)) {
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("SubzoneExists", ChatColor.YELLOW + newName));
-						+ Residence.getLanguage().getPhrase("SubzoneExists",
-								ChatColor.YELLOW + newName));
-			}
 			return false;
 		}
 		subzones.put(newName, res);
 		subzones.remove(oldName);
-		if (player != null) {
+		if (player != null)
-			player.sendMessage(ChatColor.GREEN
+			player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SubzoneRename", oldName + "." + newName));
-					+ Residence.getLanguage().getPhrase("SubzoneRename", oldName + "." + newName));
-		}
 		return true;
 	}
 
@@ -779,45 +673,33 @@ public class ClaimedResidence {
 
 	public boolean replaceArea(Player player, CuboidArea newarea, String name, boolean resadmin) {
 		if (!areas.containsKey(name)) {
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaNonExist"));
-						+ Residence.getLanguage().getPhrase("AreaNonExist"));
-			}
 			return false;
 		}
 		CuboidArea oldarea = areas.get(name);
 		if (!newarea.getWorld().getName().equalsIgnoreCase(perms.getWorld())) {
-			if (player != null) {
+			if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaDiffWorld"));
-						+ Residence.getLanguage().getPhrase("AreaDiffWorld"));
-			}
 			return false;
 		}
 		if (parent == null) {
-			String collideResidence = Residence.getResidenceManager().checkAreaCollision(newarea,
+			String collideResidence = Residence.getResidenceManager().checkAreaCollision(newarea, this);
-					this);
 			if (collideResidence != null) {
-				if (player != null) {
+				if (player != null)
-					player.sendMessage(ChatColor.RED
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaCollision", ChatColor.YELLOW + collideResidence));
-							+ 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 != null && res != this)
 					if (res.checkCollision(newarea)) {
-						if (player != null) {
+						if (player != null)
-							player.sendMessage(ChatColor.RED
+							player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaSubzoneCollision", ChatColor.YELLOW + sz));
-									+ Residence.getLanguage().getPhrase("AreaSubzoneCollision",
-											ChatColor.YELLOW + sz));
-						}
 						return false;
 					}
-				}
 			}
 		}
 		// Remove subzones that are not in the area anymore
@@ -826,74 +708,56 @@ public class ClaimedResidence {
 			ClaimedResidence res = getSubzone(sz);
 			if (res != null && res != this) {
 				String[] areas = res.getAreaList();
-				for (String area : areas) {
+				for (String area : areas)
 					if (!newarea.isAreaWithinArea(res.getArea(area))) {
 						boolean good = false;
-						for (CuboidArea arae : getAreaArray()) {
+						for (CuboidArea arae : getAreaArray())
-							if (arae != oldarea && arae.isAreaWithinArea(res.getArea(area))) {
+							if (arae != oldarea && arae.isAreaWithinArea(res.getArea(area)))
 								good = true;
-							}
+						if (!good)
-						}
-						if (!good) {
 							res.removeArea(area);
-						}
 					}
-				}
+				if (res.getAreaArray().length == 0)
-				if (res.getAreaArray().length == 0) {
 					removeSubzone(sz);
-				}
 			}
 		}
 		if (!resadmin && player != null) {
 			if (!this.perms.hasResidencePermission(player, true)) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-						+ Residence.getLanguage().getPhrase("NoPermission"));
 				return false;
 			}
 			if (parent != null) {
-				if (!parent.containsLoc(newarea.getHighLoc())
+				if (!parent.containsLoc(newarea.getHighLoc()) || !parent.containsLoc(newarea.getLowLoc())) {
-						|| !parent.containsLoc(newarea.getLowLoc())) {
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaNotWithinParent"));
-					player.sendMessage(ChatColor.RED
-							+ Residence.getLanguage().getPhrase("AreaNotWithinParent"));
 					return false;
 				}
-				if (!parent.getPermissions().hasResidencePermission(player, true)
+				if (!parent.getPermissions().hasResidencePermission(player, true) && !parent.getPermissions().playerHas(player.getName(), "subzone", true)) {
-						&& !parent.getPermissions().playerHas(player.getName(), "subzone", true)) {
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("ParentNoPermission"));
-					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
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-						+ Residence.getLanguage().getPhrase("NoPermission"));
 				return false;
 			}
 			if (!group.inLimits(newarea)) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaSizeLimit"));
-						+ Residence.getLanguage().getPhrase("AreaSizeLimit"));
 				return false;
 			}
 			if (group.getMinHeight() > newarea.getLowLoc().getBlockY()) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaLowLimit", ChatColor.YELLOW + String.format("%d", group.getMinHeight())));
-						+ Residence.getLanguage().getPhrase("AreaLowLimit",
-								ChatColor.YELLOW + String.format("%d", group.getMinHeight())));
 				return false;
 			}
 			if (group.getMaxHeight() < newarea.getHighLoc().getBlockY()) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("AreaHighLimit", ChatColor.YELLOW + String.format("%d", group.getMaxHeight())));
-						+ Residence.getLanguage().getPhrase("AreaHighLimit",
-								ChatColor.YELLOW + String.format("%d", group.getMaxHeight())));
 				return false;
 			}
 			if (parent == null && Residence.getConfigManager().enableEconomy()) {
-				int chargeamount = (int) Math.ceil((newarea.getSize() - oldarea.getSize())
+				int chargeamount = (int) Math.ceil((newarea.getSize() - oldarea.getSize()) * group.getCostPerBlock());
-						* group.getCostPerBlock());
+				if (chargeamount > 0)
-				if (chargeamount > 0) {
 					if (!TransactionManager.chargeEconomyMoney(player, chargeamount))
 						return false;
-				}
 			}
 
 		}
@@ -913,14 +777,12 @@ public class ClaimedResidence {
 		root.put("StoredMoney", bank.getStoredMoney());
 		root.put("BlackList", blacklist.save());
 		root.put("IgnoreList", ignorelist.save());
-		for (Entry<String, CuboidArea> entry : areas.entrySet()) {
+		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()) {
+		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) {
@@ -940,27 +802,22 @@ public class ClaimedResidence {
 		// player.sendMessage(ChatColor.RED+Residence.getLanguage().getPhrase("InvalidCharacters"));
 		// return;
 		// }
-		if (message != null) {
+		if (message != null)
-			if (message.equals("")) {
+			if (message.equals(""))
 				message = null;
-			}
+		PermissionGroup group = Residence.getPermissionManager().getGroup(perms.getOwner(), perms.getWorld());
-		}
-		PermissionGroup group = Residence.getPermissionManager().getGroup(perms.getOwner(),
-				perms.getWorld());
 		if (!group.canSetEnterLeaveMessages() && !resadmin) {
-			player.sendMessage(ChatColor.RED
+			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("OwnerNoPermission"));
-					+ Residence.getLanguage().getPhrase("OwnerNoPermission"));
 			return;
 		}
 		if (!perms.hasResidencePermission(player, false) && !resadmin) {
 			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
 			return;
 		}
-		if (enter) {
+		if (enter)
 			this.setEnterMessage(message);
-		} else {
+		else
 			this.setLeaveMessage(message);
-		}
 		player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("MessageChange"));
 	}
 
@@ -982,26 +839,22 @@ public class ClaimedResidence {
 			return;
 		}
 		tpLoc = player.getLocation();
-		player.sendMessage(ChatColor.GREEN
+		player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("SetTeleportLocation"));
-				+ 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
+				reqPlayer.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("TeleportDeny"));
-						+ Residence.getLanguage().getPhrase("TeleportDeny"));
 				return;
 			}
 			if (!reqPlayer.equals(targetPlayer)) {
-				reqPlayer.sendMessage(ChatColor.RED
+				reqPlayer.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-						+ Residence.getLanguage().getPhrase("NoPermission"));
 				return;
 			}
 			if (!this.perms.playerHas(reqPlayer.getName(), "tp", true)) {
-				reqPlayer.sendMessage(ChatColor.RED
+				reqPlayer.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("TeleportNoFlag"));
-						+ Residence.getLanguage().getPhrase("TeleportNoFlag"));
 				return;
 			}
 		}
@@ -1010,8 +863,7 @@ public class ClaimedResidence {
 			Residence.getServ().getPluginManager().callEvent(tpevent);
 			if (!tpevent.isCancelled()) {
 				targetPlayer.teleport(tpLoc);
-				targetPlayer.sendMessage(ChatColor.GREEN
+				targetPlayer.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("TeleportSuccess"));
-						+ Residence.getLanguage().getPhrase("TeleportSuccess"));
 			}
 		} else {
 			CuboidArea area = areas.values().iterator().next();
@@ -1024,8 +876,7 @@ public class ClaimedResidence {
 			Residence.getServ().getPluginManager().callEvent(tpevent);
 			if (!tpevent.isCancelled()) {
 				targetPlayer.teleport(targloc);
-				targetPlayer.sendMessage(ChatColor.YELLOW
+				targetPlayer.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("TeleportNear"));
-						+ Residence.getLanguage().getPhrase("TeleportNear"));
 			}
 		}
 	}

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

@@ -30,83 +30,65 @@ 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>(
+	final static Map<Material, String> matUseFlagList = new EnumMap<Material, String>(Material.class);
-			Material.class);
+	protected static HashMap<String, ArrayList<String>> validFlagGroups = new HashMap<String, ArrayList<String>>();
 	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) {
+	public FlagPermissions() {
-		matUseFlagList.put(mat, flag);
+		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 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)) {
+		if (!validFlags.contains(flag))
 			validFlags.add(flag);
-		}
+		if (validFlagGroups.containsKey(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)
+		if (!FlagPermissions.validFlags.contains(group) && !FlagPermissions.validAreaFlags.contains(group) && !FlagPermissions.validPlayerFlags.contains(group)) {
-				&& !FlagPermissions.validAreaFlags.contains(group)
+			if (!validFlagGroups.containsKey(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) {
+	public static void addMaterialToUseFlag(Material mat, String flag) {
-		if (validFlagGroups.containsKey(group)) {
+		matUseFlagList.put(mat, flag);
-			ArrayList<String> flags = validFlagGroups.get(group);
+	}
-			flags.remove(flag);
+
-			if (flags.isEmpty()) {
+	public static void addPlayerOrGroupOnlyFlag(String flag) {
-				validFlagGroups.remove(group);
+		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);
 	}
 
 	public static boolean flagGroupExists(String group) {
 		return validFlagGroups.containsKey(group);
 	}
 
+	public static EnumMap<Material, String> getMaterialUseFlagList() {
+		return (EnumMap<Material, String>) matUseFlagList;
+	}
+
 	public static void initValidFlags() {
 		validAreaFlags.clear();
 		validPlayerFlags.clear();
@@ -188,19 +170,21 @@ public class FlagPermissions {
 		addMaterialToUseFlag(Material.WORKBENCH, "table");
 		addMaterialToUseFlag(Material.WOODEN_DOOR, "door");
 
-		/* 1.8 Doors */
+		if (Residence.is1_8()) {
-		addMaterialToUseFlag(Material.SPRUCE_DOOR, "door");
+			/* 1.8 Doors */
-		addMaterialToUseFlag(Material.BIRCH_DOOR, "door");
+			addMaterialToUseFlag(Material.SPRUCE_DOOR, "door");
-		addMaterialToUseFlag(Material.JUNGLE_DOOR, "door");
+			addMaterialToUseFlag(Material.BIRCH_DOOR, "door");
-		addMaterialToUseFlag(Material.ACACIA_DOOR, "door");
+			addMaterialToUseFlag(Material.JUNGLE_DOOR, "door");
-		addMaterialToUseFlag(Material.DARK_OAK_DOOR, "door");
+			addMaterialToUseFlag(Material.ACACIA_DOOR, "door");
+			addMaterialToUseFlag(Material.DARK_OAK_DOOR, "door");
 
-		/* 1.8 Fence Gates */
+			/* 1.8 Fence Gates */
-		addMaterialToUseFlag(Material.SPRUCE_FENCE_GATE, "door");
+			addMaterialToUseFlag(Material.SPRUCE_FENCE_GATE, "door");
-		addMaterialToUseFlag(Material.BIRCH_FENCE_GATE, "door");
+			addMaterialToUseFlag(Material.BIRCH_FENCE_GATE, "door");
-		addMaterialToUseFlag(Material.JUNGLE_FENCE_GATE, "door");
+			addMaterialToUseFlag(Material.JUNGLE_FENCE_GATE, "door");
-		addMaterialToUseFlag(Material.ACACIA_FENCE_GATE, "door");
+			addMaterialToUseFlag(Material.ACACIA_FENCE_GATE, "door");
-		addMaterialToUseFlag(Material.DARK_OAK_FENCE_GATE, "door");
+			addMaterialToUseFlag(Material.DARK_OAK_FENCE_GATE, "door");
+		}
 
 		addMaterialToUseFlag(Material.FENCE_GATE, "door");
 		addMaterialToUseFlag(Material.NETHER_FENCE, "door");
@@ -229,259 +213,151 @@ public class FlagPermissions {
 		addMaterialToUseFlag(Material.CAKE_BLOCK, "cake");
 	}
 
-	public static FlagPermissions parseFromConfigNode(String name,
+	public static FlagPermissions load(Map<String, Object> root) throws Exception {
-			ConfigurationSection node) {
+		FlagPermissions newperms = new FlagPermissions();
+		return FlagPermissions.load(root, newperms);
+	}
+
+	public static FlagPermissions parseFromConfigNode(String name, ConfigurationSection node) {
 		FlagPermissions list = new FlagPermissions();
 		Set<String> keys = node.getConfigurationSection(name).getKeys(false);
-		if (keys != null) {
+		if (keys != null)
 			for (String key : keys) {
 				boolean state = node.getBoolean(name + "." + key, false);
 				key = key.toLowerCase();
-				if (state) {
+				if (state)
 					list.setFlag(key, FlagState.TRUE);
-				} else {
+				else
 					list.setFlag(key, FlagState.FALSE);
-				}
 			}
-		}
 		return list;
 	}
 
-	public FlagPermissions() {
+	public static void removeFlagFromFlagGroup(String group, String flag) {
-		cuboidFlags = Collections
+		if (validFlagGroups.containsKey(group)) {
-				.synchronizedMap(new HashMap<String, Boolean>());
+			ArrayList<String> flags = validFlagGroups.get(group);
-		playerFlags = Collections
+			flags.remove(flag);
-				.synchronizedMap(new HashMap<String, Map<String, Boolean>>());
+			if (flags.isEmpty())
-		groupFlags = Collections
+				validFlagGroups.remove(group);
-				.synchronizedMap(new HashMap<String, Map<String, Boolean>>());
+		}
 	}
 
-	public boolean setPlayerFlag(String player, String flag, FlagState state) {
+	public static void removeMaterialFromUseFlag(Material mat) {
-		player = player.toLowerCase();
+		matUseFlagList.remove(mat);
-		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")
+		if (flagstate.equalsIgnoreCase("true") || flagstate.equalsIgnoreCase("t"))
-				|| flagstate.equalsIgnoreCase("t")) {
 			return FlagState.TRUE;
-		} else if (flagstate.equalsIgnoreCase("false")
+		else if (flagstate.equalsIgnoreCase("false") || flagstate.equalsIgnoreCase("f"))
-				|| flagstate.equalsIgnoreCase("f")) {
 			return FlagState.FALSE;
-		} else if (flagstate.equalsIgnoreCase("remove")
+		else if (flagstate.equalsIgnoreCase("remove") || flagstate.equalsIgnoreCase("r"))
-				|| flagstate.equalsIgnoreCase("r")) {
 			return FlagState.NEITHER;
-		} else {
+		else
 			return FlagState.INVALID;
+	}
+
+	@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 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 void clearFlags() {
+		groupFlags.clear();
+		playerFlags.clear();
+		cuboidFlags.clear();
+	}
+
+	public void clearPlayersFlags(String user) {
+		if (playerFlags.containsKey(user))
+			playerFlags.remove(user);
+	}
+
+	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 boolean playerHas(String player, String world, String flag,
+	public FlagPermissions getParent() {
-			boolean def) {
+		return parent;
-		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)) {
+		if (cuboidFlags.containsKey(flag))
 			return cuboidFlags.get(flag);
-		}
+		if (parent != null)
-		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) {
+		if (flags == null)
-			return parent == null ? false : parent.inheritanceIsGroupSet(group,
+			return parent == null ? false : parent.inheritanceIsGroupSet(group, flag);
-					flag);
+		return flags.containsKey(flag) ? true : parent == null ? false : parent.inheritanceIsGroupSet(group, flag);
-		}
+	}
-		return flags.containsKey(flag) ? true : parent == null ? false : parent
+
-				.inheritanceIsGroupSet(group, 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 inheritanceIsSet(String flag) {
+		return cuboidFlags.containsKey(flag) ? true : parent == null ? false : parent.inheritanceIsSet(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 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 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();
@@ -491,73 +367,17 @@ public class FlagPermissions {
 				Entry<String, Boolean> next = it.next();
 				if (next.getValue()) {
 					sbuild.append("+").append(next.getKey());
-					if (it.hasNext()) {
+					if (it.hasNext())
 						sbuild.append(" ");
-					}
 				} else {
 					sbuild.append("-").append(next.getKey());
-					if (it.hasNext()) {
+					if (it.hasNext())
 						sbuild.append(" ");
-					}
 				}
 			}
 		}
-		if (sbuild.length() == 0) {
+		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();
 	}
 
@@ -569,10 +389,8 @@ public class FlagPermissions {
 			while (it.hasNext()) {
 				String next = it.next();
 				String perms = listGroupFlags(next);
-				if (!perms.equals("none")) {
+				if (!perms.equals("none"))
-					sbuild.append(next).append("[" + ChatColor.DARK_AQUA)
+					sbuild.append(next).append("[" + ChatColor.DARK_AQUA).append(perms).append(ChatColor.RED + "] ");
-							.append(perms).append(ChatColor.RED + "] ");
-				}
 			}
 		}
 		return sbuild.toString();
@@ -590,14 +408,12 @@ public class FlagPermissions {
 					Entry<String, Boolean> next = it.next();
 					if (next.getValue()) {
 						sbuild.append("+").append(next.getKey());
-						if (it.hasNext()) {
+						if (it.hasNext())
 							sbuild.append(" ");
-						}
 					} else {
 						sbuild.append("-").append(next.getKey());
-						if (it.hasNext()) {
+						if (it.hasNext())
 							sbuild.append(" ");
-						}
 					}
 				}
 			}
@@ -606,59 +422,163 @@ public class FlagPermissions {
 				sbuild.append("none");
 			}
 			return sbuild.toString();
-		} else {
+		} else
 			return "none";
-		}
 	}
 
-	public void clearFlags() {
+	public String listOtherPlayersFlags(String player) {
-		groupFlags.clear();
+		player = player.toLowerCase();
-		playerFlags.clear();
+		StringBuilder sbuild = new StringBuilder();
-		cuboidFlags.clear();
+		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 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 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 void printFlags(Player player) {
-		player.sendMessage(ChatColor.YELLOW
+		player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Flags") + ":" + ChatColor.BLUE + " " + listFlags());
-				+ Residence.getLanguage().getPhrase("Flags") + ":"
+		player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Your.Flags") + ":" + ChatColor.GREEN + " " + listPlayerFlags(player.getName()));
-				+ ChatColor.BLUE + " " + listFlags());
+		player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Group.Flags") + ":" + ChatColor.RED + " " + listGroupFlags());
-		player.sendMessage(ChatColor.YELLOW
+		player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("Others.Flags") + ":" + ChatColor.RED + " " + listOtherPlayersFlags(player.getName()));
-				+ 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) {
+	public void removeAllGroupFlags(String group) {
-		fromUser = fromUser.toLowerCase();
+		groupFlags.remove(group);
-		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) {
+	public void removeAllPlayerFlags(String player) {
-		if (playerFlags.containsKey(user)) {
+		playerFlags.remove(player);
-			playerFlags.remove(user);
+	}
-		}
+
+	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 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 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 void setParent(FlagPermissions p) {
 		parent = p;
 	}
 
-	public FlagPermissions getParent() {
+	public boolean setPlayerFlag(String player, String flag, FlagState state) {
-		return parent;
+		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;
+	}
+
+	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;
+	}
+
+	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;
+	}
+
+	public static enum FlagState {
+
+		TRUE,
+		FALSE,
+		NEITHER,
+		INVALID
 	}
 }

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

@@ -29,12 +29,26 @@ import com.bekvon.bukkit.residence.permissions.PermissionManager;
  */
 public class ResidencePermissions extends FlagPermissions {
 
+	protected String owner;
+
+	protected String world;
+	protected ClaimedResidence residence;
+
+	public ResidencePermissions(ClaimedResidence res, String creator, String inworld) {
+		this(res);
+		owner = creator;
+		world = inworld;
+	}
+
+	private ResidencePermissions(ClaimedResidence res) {
+		residence = res;
+	}
+
 	public static ResidencePermissions load(ClaimedResidence res, Map<String, Object> root) throws Exception {
 		ResidencePermissions newperms = new ResidencePermissions(res);
 		newperms.owner = (String) root.get("Owner");
-		if (newperms.owner == null) {
+		if (newperms.owner == null)
 			newperms.owner = (String) root.get("OwnerLastKnownName");
-		}
 		if (newperms.owner == null) {
 			Residence.getLog().warning("发现未知所有者的领地,转换为Server Land...");
 			newperms.owner = "Server Land";
@@ -55,21 +69,6 @@ public class ResidencePermissions extends FlagPermissions {
 		return newperms;
 	}
 
-	protected String owner;
-	protected String world;
-
-	protected ClaimedResidence residence;
-
-	private ResidencePermissions(ClaimedResidence res) {
-		residence = res;
-	}
-
-	public ResidencePermissions(ClaimedResidence res, String creator, String inworld) {
-		this(res);
-		owner = creator;
-		world = inworld;
-	}
-
 	public void applyDefaultFlags() {
 		PermissionManager gm = Residence.getPermissionManager();
 		PermissionGroup group = gm.getGroup(owner, world);
@@ -77,33 +76,25 @@ public class ResidencePermissions extends FlagPermissions {
 		Set<Entry<String, Boolean>> dcflags = group.getDefaultCreatorFlags();
 		Set<Entry<String, Map<String, Boolean>>> dgflags = group.getDefaultGroupFlags();
 		this.applyGlobalDefaults();
-		for (Entry<String, Boolean> next : dflags) {
+		for (Entry<String, Boolean> next : dflags)
-			if (this.checkValidFlag(next.getKey(), true)) {
+			if (this.checkValidFlag(next.getKey(), true))
-				if (next.getValue()) {
+				if (next.getValue())
 					this.setFlag(next.getKey(), FlagState.TRUE);
-				} else {
+				else
 					this.setFlag(next.getKey(), FlagState.FALSE);
-				}
+		for (Entry<String, Boolean> next : dcflags)
-			}
+			if (this.checkValidFlag(next.getKey(), false))
-		}
+				if (next.getValue())
-		for (Entry<String, Boolean> next : dcflags) {
-			if (this.checkValidFlag(next.getKey(), false)) {
-				if (next.getValue()) {
 					this.setPlayerFlag(owner, next.getKey(), FlagState.TRUE);
-				} else {
+				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()) {
+			for (Entry<String, Boolean> flag : value.entrySet())
-				if (flag.getValue()) {
+				if (flag.getValue())
 					this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.TRUE);
-				} else {
+				else
 					this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.FALSE);
-				}
-			}
 		}
 	}
 
@@ -111,121 +102,65 @@ public class ResidencePermissions extends FlagPermissions {
 		if (this.hasResidencePermission(player, true) || resadmin) {
 			this.applyDefaultFlags();
 			player.sendMessage(ChatColor.YELLOW + Residence.getLanguage().getPhrase("FlagsDefault"));
-		} else {
+		} else
 			player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("NoPermission"));
-		}
 	}
 
 	public void applyGlobalDefaults() {
 		this.clearFlags();
 		FlagPermissions gRD = Residence.getConfigManager().getGlobalResidenceDefaultFlags();
 		FlagPermissions gCD = Residence.getConfigManager().getGlobalCreatorDefaultFlags();
-		Map<String, FlagPermissions> gGD = Residence.getConfigManager()
+		Map<String, FlagPermissions> gGD = Residence.getConfigManager().getGlobalGroupDefaultFlags();
-				.getGlobalGroupDefaultFlags();
+		for (Entry<String, Boolean> entry : gRD.cuboidFlags.entrySet())
-		for (Entry<String, Boolean> entry : gRD.cuboidFlags.entrySet()) {
+			if (entry.getValue())
-			if (entry.getValue()) {
 				this.setFlag(entry.getKey(), FlagState.TRUE);
-			} else {
+			else
 				this.setFlag(entry.getKey(), FlagState.FALSE);
-			}
+		for (Entry<String, Boolean> entry : gCD.cuboidFlags.entrySet())
-		}
+			if (entry.getValue())
-		for (Entry<String, Boolean> entry : gCD.cuboidFlags.entrySet()) {
-			if (entry.getValue()) {
 				this.setPlayerFlag(owner, entry.getKey(), FlagState.TRUE);
-			} else {
+			else
 				this.setPlayerFlag(owner, entry.getKey(), FlagState.FALSE);
-			}
+		for (Entry<String, FlagPermissions> entry : gGD.entrySet())
-		}
+			for (Entry<String, Boolean> flag : entry.getValue().cuboidFlags.entrySet())
-		for (Entry<String, FlagPermissions> entry : gGD.entrySet()) {
+				if (flag.getValue())
-			for (Entry<String, Boolean> flag : entry.getValue().cuboidFlags.entrySet()) {
-				if (flag.getValue()) {
 					this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.TRUE);
-				} else {
+				else
 					this.setGroupFlag(entry.getKey(), flag.getKey(), FlagState.FALSE);
-				}
-			}
-		}
 	}
 
 	public void applyTemplate(Player player, FlagPermissions list, boolean resadmin) {
 		if (player != null) {
 			if (!player.getName().equals(owner) && !resadmin) {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("NoPermission"));
-						+ Residence.getLanguage().getPhrase("NoPermission"));
 				return;
 			}
-		} else {
+		} else
 			resadmin = true;
-		}
 		PermissionGroup group = Residence.getPermissionManager().getGroup(owner, world);
-		for (Entry<String, Boolean> flag : list.cuboidFlags.entrySet()) {
+		for (Entry<String, Boolean> flag : list.cuboidFlags.entrySet())
-			if (group.hasFlagAccess(flag.getKey()) || resadmin) {
+			if (group.hasFlagAccess(flag.getKey()) || resadmin)
 				this.cuboidFlags.put(flag.getKey(), flag.getValue());
-			} else {
+			else if (player != null)
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("FlagSetDeny", ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
-						+ Residence.getLanguage().getPhrase("FlagSetDeny",
+		for (Entry<String, Map<String, Boolean>> plists : list.playerFlags.entrySet())
-								ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
+			for (Entry<String, Boolean> flag : plists.getValue().entrySet())
-			}
-		}
-		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())) {
+					if (!this.playerFlags.containsKey(plists.getKey()))
-						this.playerFlags.put(plists.getKey(),
+						this.playerFlags.put(plists.getKey(), Collections.synchronizedMap(new HashMap<String, Boolean>()));
-								Collections.synchronizedMap(new HashMap<String, Boolean>()));
-					}
 					this.playerFlags.get(plists.getKey()).put(flag.getKey(), flag.getValue());
-				} else {
+				} else if (player != null)
-					player.sendMessage(ChatColor.RED
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("FlagSetDeny", ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
-							+ Residence.getLanguage().getPhrase("FlagSetDeny",
+		for (Entry<String, Map<String, Boolean>> glists : list.groupFlags.entrySet())
-									ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
+			for (Entry<String, Boolean> flag : glists.getValue().entrySet())
-				}
-			}
-		}
-		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())) {
+					if (!this.groupFlags.containsKey(glists.getKey()))
-						this.groupFlags.put(glists.getKey(),
+						this.groupFlags.put(glists.getKey(), Collections.synchronizedMap(new HashMap<String, Boolean>()));
-								Collections.synchronizedMap(new HashMap<String, Boolean>()));
-					}
 					this.groupFlags.get(glists.getKey()).put(flag.getKey(), flag.getValue());
-				} else {
+				} else if (player != null)
-					player.sendMessage(ChatColor.RED
+					player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("FlagSetDeny", ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
-							+ Residence.getLanguage().getPhrase("FlagSetDeny",
+		if (player != null)
-									ChatColor.YELLOW + flag.getKey() + ChatColor.RED));
+			player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("PermissionsApply"));
-				}
-			}
-		}
-		if (player != null) {
-			player.sendMessage(ChatColor.GREEN
-					+ Residence.getLanguage().getPhrase("PermissionsApply"));
-		}
-	}
-
-	private boolean checkCanSetFlag(Player player, String flag, FlagState state, boolean globalflag, boolean resadmin) {
-		if (!checkValidFlag(flag, globalflag)) {
-			player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidFlag"));
-			return false;
-		}
-		if (state == FlagState.INVALID) {
-			player.sendMessage(ChatColor.RED
-					+ Residence.getLanguage().getPhrase("InvalidFlagState"));
-			return false;
-		}
-		if (!resadmin) {
-			if (!this.hasResidencePermission(player, false)) {
-				player.sendMessage(ChatColor.RED
-						+ Residence.getLanguage().getPhrase("NoPermission"));
-				return false;
-			}
-			if (!hasFlagAccess(owner, flag)) {
-				player.sendMessage(ChatColor.RED
-						+ Residence.getLanguage().getPhrase("OwnerNoPermission"));
-				return false;
-			}
-		}
-		return true;
 	}
 
 	public void fixNames() {
@@ -233,9 +168,8 @@ public class ResidencePermissions extends FlagPermissions {
 		Iterator<Entry<String, Map<String, Boolean>>> it = playerFlags.entrySet().iterator();
 		while (it.hasNext()) {
 			String name = it.next().getKey();
-			if (!name.equals(name.toLowerCase())) {
+			if (!name.equals(name.toLowerCase()))
 				fixNames.add(name);
-			}
 		}
 		for (String name : fixNames) {
 			Map<String, Boolean> get = playerFlags.get(name);
@@ -254,8 +188,7 @@ public class ResidencePermissions extends FlagPermissions {
 
 	@Override
 	public boolean groupHas(String group, String flag, boolean def) {
-		ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag, FlagType.GROUP,
+		ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag, FlagType.GROUP, group, def);
-				group, def);
 		Residence.getServ().getPluginManager().callEvent(fc);
 		if (fc.isOverriden())
 			return fc.getOverrideValue();
@@ -264,8 +197,7 @@ public class ResidencePermissions extends FlagPermissions {
 
 	@Override
 	public boolean has(String flag, boolean def) {
-		ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag,
+		ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag, FlagType.RESIDENCE, null, def);
-				FlagType.RESIDENCE, null, def);
 		Residence.getServ().getPluginManager().callEvent(fc);
 		if (fc.isOverriden())
 			return fc.getOverrideValue();
@@ -273,14 +205,7 @@ public class ResidencePermissions extends FlagPermissions {
 	}
 
 	public boolean hasApplicableFlag(String player, String flag) {
-		return super.inheritanceIsPlayerSet(player, flag)
+		return super.inheritanceIsPlayerSet(player, flag) || super.inheritanceIsGroupSet(Residence.getPermissionManager().getGroupNameByPlayer(player, world), flag) || super.inheritanceIsSet(flag);
-				|| super.inheritanceIsGroupSet(Residence.getPermissionManager()
-						.getGroupNameByPlayer(player, world), flag) || super.inheritanceIsSet(flag);
-	}
-
-	private boolean hasFlagAccess(String player, String flag) {
-		PermissionGroup group = Residence.getPermissionManager().getGroup(player, world);
-		return group.hasFlagAccess(flag);
 	}
 
 	public boolean hasResidencePermission(Player player, boolean requireOwner) {
@@ -298,8 +223,7 @@ public class ResidencePermissions extends FlagPermissions {
 		}
 		if (requireOwner)
 			return (owner.equalsIgnoreCase(player.getName()));
-		return (playerHas(player.getName(), "admin", false) || owner.equalsIgnoreCase(player
+		return (playerHas(player.getName(), "admin", false) || owner.equalsIgnoreCase(player.getName()));
-				.getName()));
 	}
 
 	public boolean playerHas(String player, String flag, boolean def) {
@@ -308,8 +232,7 @@ public class ResidencePermissions extends FlagPermissions {
 
 	@Override
 	public boolean playerHas(String player, String world, String flag, boolean def) {
-		ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag, FlagType.PLAYER,
+		ResidenceFlagCheckEvent fc = new ResidenceFlagCheckEvent(residence, flag, FlagType.PLAYER, player, def);
-				player, def);
 		Residence.getServ().getPluginManager().callEvent(fc);
 		if (fc.isOverriden())
 			return fc.getOverrideValue();
@@ -318,8 +241,7 @@ public class ResidencePermissions extends FlagPermissions {
 
 	public boolean removeAllGroupFlags(Player player, String group, boolean resadmin) {
 		if (this.hasResidencePermission(player, false) || resadmin) {
-			ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL",
+			ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL", ResidenceFlagChangeEvent.FlagType.GROUP, FlagState.NEITHER, null);
-					ResidenceFlagChangeEvent.FlagType.GROUP, FlagState.NEITHER, null);
 			Residence.getServ().getPluginManager().callEvent(fc);
 			if (fc.isCancelled())
 				return false;
@@ -332,8 +254,7 @@ public class ResidencePermissions extends FlagPermissions {
 
 	public boolean removeAllPlayerFlags(Player player, String targetPlayer, boolean resadmin) {
 		if (this.hasResidencePermission(player, false) || resadmin) {
-			ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL",
+			ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, "ALL", ResidenceFlagChangeEvent.FlagType.RESIDENCE, FlagState.NEITHER, null);
-					ResidenceFlagChangeEvent.FlagType.RESIDENCE, FlagState.NEITHER, null);
 			Residence.getServ().getPluginManager().callEvent(fc);
 			if (fc.isCancelled())
 				return false;
@@ -357,8 +278,7 @@ public class ResidencePermissions extends FlagPermissions {
 			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 fc = new ResidenceFlagChangeEvent(residence, player, flag, ResidenceFlagChangeEvent.FlagType.RESIDENCE, state, null);
-					ResidenceFlagChangeEvent.FlagType.RESIDENCE, state, null);
 			Residence.getServ().getPluginManager().callEvent(fc);
 			if (fc.isCancelled())
 				return false;
@@ -372,8 +292,7 @@ public class ResidencePermissions extends FlagPermissions {
 
 	@Override
 	public boolean setFlag(String flag, FlagState state) {
-		ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag,
+		ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag, ResidenceFlagChangeEvent.FlagType.RESIDENCE, state, null);
-				ResidenceFlagChangeEvent.FlagType.RESIDENCE, state, null);
 		Residence.getServ().getPluginManager().callEvent(fc);
 		if (fc.isCancelled())
 			return false;
@@ -384,11 +303,9 @@ public class ResidencePermissions extends FlagPermissions {
 		if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
 			ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
 			boolean changed = false;
-			for (String flag : flags) {
+			for (String flag : flags)
-				if (this.setFlag(player, flag, state, resadmin)) {
+				if (this.setFlag(player, flag, state, resadmin))
 					changed = true;
-				}
-			}
 			return changed;
 		}
 		return false;
@@ -398,11 +315,9 @@ public class ResidencePermissions extends FlagPermissions {
 		if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
 			ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
 			boolean changed = false;
-			for (String flag : flags) {
+			for (String flag : flags)
-				if (this.setGroupFlag(player, group, flag, state, resadmin)) {
+				if (this.setGroupFlag(player, group, flag, state, resadmin))
 					changed = true;
-				}
-			}
 			return changed;
 		}
 		return false;
@@ -412,11 +327,9 @@ public class ResidencePermissions extends FlagPermissions {
 		if (ResidencePermissions.validFlagGroups.containsKey(flaggroup)) {
 			ArrayList<String> flags = ResidencePermissions.validFlagGroups.get(flaggroup);
 			boolean changed = false;
-			for (String flag : flags) {
+			for (String flag : flags)
-				if (this.setPlayerFlag(player, target, flag, state, resadmin)) {
+				if (this.setPlayerFlag(player, target, flag, state, resadmin))
 					changed = true;
-				}
-			}
 			return changed;
 		}
 		return false;
@@ -427,31 +340,26 @@ public class ResidencePermissions extends FlagPermissions {
 		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 (checkCanSetFlag(player, flag, state, false, resadmin))
 			if (Residence.getPermissionManager().hasGroup(group)) {
-				ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag,
+				ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, player, flag, ResidenceFlagChangeEvent.FlagType.GROUP, state, group);
-						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
+					player.sendMessage(ChatColor.GREEN + Residence.getLanguage().getPhrase("FlagSet"));
-							+ Residence.getLanguage().getPhrase("FlagSet"));
 					return true;
 				}
 			} else {
-				player.sendMessage(ChatColor.RED
+				player.sendMessage(ChatColor.RED + Residence.getLanguage().getPhrase("InvalidGroup"));
-						+ Residence.getLanguage().getPhrase("InvalidGroup"));
 				return false;
 			}
-		}
 		return false;
 	}
 
 	@Override
 	public boolean setGroupFlag(String group, String flag, FlagState state) {
-		ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag,
+		ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag, ResidenceFlagChangeEvent.FlagType.GROUP, state, group);
-				ResidenceFlagChangeEvent.FlagType.GROUP, state, group);
 		Residence.getServ().getPluginManager().callEvent(fc);
 		if (fc.isCancelled())
 			return false;
@@ -462,9 +370,8 @@ public class ResidencePermissions extends FlagPermissions {
 		ResidenceOwnerChangeEvent ownerchange = new ResidenceOwnerChangeEvent(residence, newOwner);
 		Residence.getServ().getPluginManager().callEvent(ownerchange);
 		owner = newOwner;
-		if (resetFlags) {
+		if (resetFlags)
 			this.applyDefaultFlags();
-		}
 	}
 
 	public boolean setPlayerFlag(Player player, String targetPlayer, String flag, String flagstate, boolean resadmin) {
@@ -472,8 +379,7 @@ public class ResidencePermissions extends FlagPermissions {
 			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 fc = new ResidenceFlagChangeEvent(residence, player, flag, ResidenceFlagChangeEvent.FlagType.PLAYER, state, targetPlayer);
-					ResidenceFlagChangeEvent.FlagType.PLAYER, state, targetPlayer);
 			Residence.getServ().getPluginManager().callEvent(fc);
 			if (fc.isCancelled())
 				return false;
@@ -487,11 +393,37 @@ public class ResidencePermissions extends FlagPermissions {
 
 	@Override
 	public boolean setPlayerFlag(String player, String flag, FlagState state) {
-		ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag,
+		ResidenceFlagChangeEvent fc = new ResidenceFlagChangeEvent(residence, null, flag, ResidenceFlagChangeEvent.FlagType.PLAYER, state, player);
-				ResidenceFlagChangeEvent.FlagType.PLAYER, state, player);
 		Residence.getServ().getPluginManager().callEvent(fc);
 		if (fc.isCancelled())
 			return false;
 		return super.setPlayerFlag(player, flag, state);
 	}
+
+	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);
+	}
 }