Moved project out of subfolder.

src/main/java/com/majinnaibu/bukkitplugins/metropolis/Cuboid.java

@@ -0,0 +1,231 @@
+package com.majinnaibu.bukkitplugins.metropolis;
+
+import java.util.logging.Logger;
+
+import javax.persistence.Embeddable;
+
+import org.bukkit.Location;
+
+
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldedit.bukkit.selections.Selection;
+
+@Embeddable
+public class Cuboid implements Comparable<Cuboid> {
+	private int id;
+	
+	public int minX;
+	public int minY;
+	public int minZ;
+	
+	public int maxX;
+	public int maxY;
+	public int maxZ;
+	
+	public int getId(){
+		return id;
+	}
+	
+	public void setId(int id){
+		this.id = id;
+	}
+	
+	public Cuboid(int minX, int minY, int minZ, int maxX, int maxY, int maxZ){
+		this.minX = minX;
+		this.minY = minY;
+		this.minZ = minZ;
+		this.maxX = maxX;
+		this.maxY = maxY;
+		this.maxZ = maxZ;
+	}
+	
+	public Cuboid(BlockVector min, BlockVector max) {
+		this.minX = min.getBlockX();
+		this.minY = min.getBlockY();
+		this.minZ = min.getBlockZ();
+		this.maxX = max.getBlockX();
+		this.maxY = max.getBlockY();
+		this.maxZ = max.getBlockZ();
+	}
+
+	public Cuboid() {
+		this.minX = 0;
+		this.minY = 0;
+		this.minZ = 0;
+		this.maxX = 0;
+		this.maxY = 0;
+		this.maxZ = 0;
+	}
+
+	public Cuboid(Selection selection) {
+		this.minX = selection.getMinimumPoint().getBlockX();
+		this.minY = selection.getMinimumPoint().getBlockY();
+		this.minZ = selection.getMinimumPoint().getBlockZ();
+		this.maxX = selection.getMaximumPoint().getBlockX();
+		this.maxY = selection.getMaximumPoint().getBlockY();
+		this.maxZ = selection.getMaximumPoint().getBlockZ();
+	}
+
+	public BlockVector getMin(){
+		return new BlockVector(minX, minY, minZ);
+	}
+	
+	public BlockVector getMax(){
+		return new BlockVector(maxX, maxY, maxZ);
+	}
+
+	@Override
+	public int compareTo(Cuboid o) {
+		BlockVector min = getMin();
+		BlockVector otherMin = o.getMin();
+		
+		if(min.getBlockX() < otherMin.getBlockX()){
+			return -1;
+		}else if(min.getBlockX() > otherMin.getBlockX()){
+			return 1;
+		}else if(min.getBlockZ() < otherMin.getBlockZ()){
+			return -1;
+		}else if(min.getBlockZ() > otherMin.getBlockZ()){
+			return 1;
+		}else if(min.getBlockY() < otherMin.getBlockY()){
+			return -1;
+		}else if(min.getBlockY() > otherMin.getBlockY()){
+			return 1;
+		}else{
+			return 0;
+		}
+	}
+
+	public static int compareBlockVectors(BlockVector v1, BlockVector v2){
+		Logger log = Logger.getLogger("Minecraft");
+		
+		if(v1 == null){
+			if(v2 == null){
+				log.info("in Cuboid.compareBlockVectors v1 and v2 are null");
+				return 0;
+			}else{
+				log.info("in Cubiod.compareBlockVectors v1 is null");
+				return -1;
+			}
+		}else if(v2 == null){
+			log.info("in Cubiod.compareBlockVectors v2 is null");
+			return 1;
+		}
+		log.info(String.format("v1.x: %d, v1.y: %d, v1.z: %d, v2.x: %d, v2.y: %d, v2.z: %d", v1.getBlockX(), v1.getBlockY(), v1.getBlockZ(), v2.getBlockX(), v2.getBlockY(), v2.getBlockZ()));
+		if(v1.getBlockX() < v2.getBlockX()){
+			return -1;
+		}else if(v1.getBlockX() > v2.getBlockX()){
+			return 1;
+		}else if(v1.getBlockZ() < v2.getBlockZ()){
+			return -1;
+		}else if(v1.getBlockZ() > v2.getBlockZ()){
+			return 1;
+		}else if(v1.getBlockY() < v2.getBlockY()){
+			return -1;
+		}else if(v1.getBlockY() > v2.getBlockY()){
+			return 1;
+		}else{
+			return 0;
+		}
+	}
+	
+	public static boolean isBlockLessThan(BlockVector v1, BlockVector v2) {
+		return compareBlockVectors(v1, v2) < 0;
+	}
+	
+	public Cuboid inset(int amount){
+		return inset(amount, amount, amount);
+	}
+	
+	public Cuboid inset(int x, int z){
+		return inset(x, 0, z);
+	}
+	
+	public Cuboid inset(int x, int y, int z){
+		return new Cuboid(this.minX + x, this.minY, this.minZ + z, this.maxX - x, this.maxY, this.maxZ - z);
+	}
+
+	public int getVolume() {
+		return (this.maxX - this.minX) * (this.maxY - this.minY) * (this.maxZ - this.minZ);
+	}
+	public int getMinX(){return minX;}
+	public void setMinX(int minX){this.minX = minX;}
+	public int getMinY(){return minY;}
+	public void setMinY(int minY){this.minY = minY;}
+	public int getMinZ(){return minZ;}
+	public void setMinZ(int minZ){this.minZ = minZ;}
+	public int getMaxX(){return maxX;}
+	public void setMaxX(int maxX){this.maxX = maxX;}
+	public int getMaxY(){return maxY;}
+	public void setMaxY(int maxY){this.maxY = maxY;}
+	public int getMaxZ(){return maxZ;}
+	public void setMaxZ(int maxZ){this.maxZ = maxZ;}
+
+	public Cuboid outset(int amount) {
+		return outset(amount, amount, amount);
+	}
+
+	public Cuboid outset(int x, int z){
+		return outset(x, 0, z);
+	}
+	
+	public Cuboid outset(int x, int y, int z) {
+		return new Cuboid(this.minX - x, this.minY - y, this.minZ - z, this.maxX + x, this.maxY + y, this.maxZ + z);
+	}
+	
+	public int getCenterX(){
+		return (this.minX + this.maxX) /2;
+	}
+	
+	public int getCenterY(){
+		return (this.minY + this.maxY)/2;
+	}
+	
+	public int getCenterZ(){
+		return (this.minZ + this.maxZ)/2;
+	}
+
+	public boolean intersects(Cuboid other) {
+		if (this.maxX >= other.minX && this.minX <= other.maxX)
+        {
+            if (this.maxZ >= other.minZ && this.minZ <= other.maxZ)
+            {
+                if (this.maxY >= other.minY && this.minY <= other.maxY)
+                {
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+            else
+            {
+                return false;
+            }
+        }
+        else
+        {
+            return false;
+        }
+	}
+
+	public boolean contains(Location bedSpawn) {
+		if(this.minX > bedSpawn.getBlockX() || this.maxX < bedSpawn.getBlockX()){
+			return false;
+		}else if(this.minZ > bedSpawn.getBlockZ() || this.maxZ < bedSpawn.getBlockZ()){
+			return false;
+		}else if(this.minY > bedSpawn.getBlockY() || this.maxY < bedSpawn.getBlockY()){
+			return false;
+		}
+		
+		return true;
+	}
+
+	@Override
+	public String toString() {
+		return String.format("{Cuboid minX=%d, minY=%d, minZ=%d, maxX=%d, maxY=%d, maxZ=%d}", minX, minY, minZ, maxX, maxY, maxZ);
+	}
+	
+	
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/PlayerHome.java

@@ -0,0 +1,100 @@
+package com.majinnaibu.bukkitplugins.metropolis;
+
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+import com.avaje.ebean.validation.NotNull;
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+
+@Entity()
+@Table(name="Metropolis_PlayerHome")
+public class PlayerHome extends Plot{
+	@NotNull
+	private String playerName;
+	public String getPlayerName(){return this.playerName;}
+	public void setPlayerName(String playerName){this.playerName = playerName;}
+	
+	private int number;
+		
+	public PlayerHome(String owner, BlockVector min, BlockVector max) {
+		super("h_" + owner, min, max);
+		this.playerName = owner;
+	}
+	
+	public PlayerHome() {
+		this.playerName = "";
+	}
+	
+	public PlayerHome(ProtectedRegion homeRegion){
+		try{
+			String rname = homeRegion.getId();
+			
+			if(rname.startsWith("h_")){
+				int secondUnderscore = rname.indexOf('_', 2);
+				if(secondUnderscore > 2){
+					try{
+						this.number = Integer.parseInt(rname.substring(2, secondUnderscore));
+						this.playerName = rname.substring(secondUnderscore+1);
+					}catch(Exception ex){
+						this.number = 0;
+					}
+				}else{
+					this.number = 0;
+					this.playerName = rname.substring(2);
+				}
+				
+				setCuboid(new Cuboid(homeRegion.getMinimumPoint(), homeRegion.getMaximumPoint()));
+			}
+			else{
+				throw new RuntimeException("Method not implemented.");
+			}
+		}catch(Exception ex){
+			throw new RuntimeException("Method not implemented.", ex);
+		}
+	}
+
+	@Override
+	public boolean equals(Object other) {
+		if(!(other instanceof PlayerHome)){
+			return super.equals(other);
+		}
+		
+		PlayerHome otherPlayerHome = (PlayerHome)other;
+		
+		if(!this.playerName.equals(otherPlayerHome.playerName)){
+			return false;
+		}
+		
+		if(!getCuboid().equals(otherPlayerHome.getCuboid())){
+			return false;
+		}
+		
+		return true;
+	}
+
+	public String toFriendlyString() {
+		StringBuilder sb = new StringBuilder();
+		
+		sb.append(String.format("Metropolis Home {Owner: %s min: (%d, %d, %d) max: (%d, %d, %d)}", getPlayerName(), getCuboid().getMinX(), getCuboid().getMinY(), getCuboid().getMinZ(), getCuboid().getMaxX(), getCuboid().getMaxY(), getCuboid().getMaxZ()));
+		
+		return sb.toString();
+	}
+	
+	public static PlayerHome get(ProtectedRegion homeRegion){
+		if(homeRegion instanceof ProtectedCuboidRegion){
+			return new PlayerHome((ProtectedCuboidRegion) homeRegion);
+		}else{
+			return null;
+		}
+	}
+	
+	public Integer getNumber() {
+		return number;
+	}
+	
+	public void setNumber(int number){
+		this.number = number;
+	}
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/Plot.java

@@ -0,0 +1,130 @@
+package com.majinnaibu.bukkitplugins.metropolis;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+import javax.persistence.Table;
+
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+
+import com.avaje.ebean.validation.NotNull;
+import com.sk89q.worldedit.BlockVector;
+import com.sk89q.worldguard.protection.regions.ProtectedCuboidRegion;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+
+@Entity()
+@Table(name="Metropolis_Plot")
+public class Plot implements Comparable<Plot>{
+	@Id
+	private int _id;
+	public int getId(){return _id;}
+	public void setId(int id){_id = id;}
+	
+	@NotNull
+	
+	private Cuboid _cuboid;
+	public Cuboid getCuboid(){return _cuboid;}
+	public void setCuboid(Cuboid cuboid){_cuboid = cuboid;}
+
+	@NotNull
+	private String _regionName;
+	public String getRegionName(){return _regionName;}
+	public void setRegionName(String regionName){_regionName = regionName;}
+	
+	public Plot(String regionName, BlockVector min, BlockVector max){
+		_cuboid = new Cuboid(min, max);
+		_regionName = regionName;
+	}
+	
+	public Plot(ProtectedCuboidRegion cuboid){
+		_cuboid = new Cuboid(cuboid.getMinimumPoint(), cuboid.getMaximumPoint());
+		_regionName = cuboid.getId();
+	}
+	
+	public Plot(){
+		_cuboid = new Cuboid();
+		_regionName = "";
+	}
+
+	public BlockVector getPlotMin(int roadWidth) {
+		return new BlockVector(_cuboid.minX - roadWidth/2, _cuboid.minY, _cuboid.minZ - roadWidth/2);
+	}
+	
+	public int getRow(int roadWidth, int plotSizeZ){
+		BlockVector min = getPlotMin(roadWidth);
+		return min.getBlockZ() / plotSizeZ;
+	}
+	
+	public int getCol(int roadWidth, int plotSizeX){
+		return getPlotMin(roadWidth).getBlockX() / plotSizeX;
+	}
+	
+	@Override
+	public boolean equals(Object other) {
+		if(!(other instanceof Plot)){
+			return super.equals(other);
+		}
+		
+		Plot otherPlayerHome = (Plot)other;
+		
+		if(!getCuboid().equals(otherPlayerHome.getCuboid())){
+			return false;
+		}
+		
+		return true;
+	}
+
+	@Override
+	public int compareTo(Plot another) {
+		return getCuboid().compareTo(another.getCuboid());
+	}
+
+	@Override
+	public String toString(){
+		StringBuilder sb = new StringBuilder();
+		
+		sb.append(String.format("{PlayerHome }"));
+		
+		return sb.toString();
+	}
+	
+	public static Plot get(ProtectedRegion region){
+		if(region instanceof ProtectedCuboidRegion){
+			return new Plot((ProtectedCuboidRegion) region);
+		}else{
+			return null;
+		}
+	}
+	
+	public String toFriendlyString() {
+		StringBuilder sb = new StringBuilder();
+		
+		sb.append(String.format("Metropolis Reserved Plot {min: (%d, %d, %d) max: (%d, %d, %d)}", getCuboid().getMinX(), getCuboid().getMinY(), getCuboid().getMinZ(), getCuboid().getMaxX(), getCuboid().getMaxY(), getCuboid().getMaxZ()));
+		
+		return sb.toString();
+	}
+	
+	public boolean contains(Location bedSpawn) {
+		return _cuboid.contains(bedSpawn);
+	}
+	
+	public Location getViableSpawnLocation(World world) {
+		Cuboid cuboid = getCuboid();
+		for(int y=cuboid.maxY-1; y>= cuboid.minY; y--){
+			for(int x=cuboid.minX; x<= cuboid.maxX; x++){
+				for(int z=cuboid.minZ; z<= cuboid.maxZ; z++){
+					Block block = world.getBlockAt(x, y, z);
+					Block blockAbove = world.getBlockAt(x, y+1, z);
+					Block blockUnder = world.getBlockAt(x, y-1, z);
+					if(block.getType() == Material.AIR & blockAbove.getType() == Material.AIR && blockUnder.getType() != Material.AIR){
+						return new Location(world, x, y, z);
+					}
+				}
+			}
+		}
+		
+		return null;
+	}
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/UserOverride.java

@@ -0,0 +1,17 @@
+package com.majinnaibu.bukkitplugins.metropolis;
+
+public class UserOverride {
+	private String _username;
+	private int _plotMultiplier;
+	private int _maxPlots;
+	
+	public String getUsername(){return _username;}
+	public int getPlotMultiplier(){return _plotMultiplier;}
+	public int getMaxPlots(){return _maxPlots;}
+	
+	public UserOverride(String username, int plotMultiplier, int maxPlots){
+		_username = username;
+		_plotMultiplier = plotMultiplier;
+		_maxPlots = maxPlots;
+	}
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisCommand.java

@@ -0,0 +1,24 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+
+public class MetropolisCommand implements CommandExecutor {
+	private MetropolisPlugin _plugin;
+	
+	public MetropolisCommand(MetropolisPlugin plugin){
+		_plugin = plugin;
+	}
+	
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+		
+		sender.sendMessage("Metropolis: version "+ _plugin.pdf.getVersion());
+		
+		return true;
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisDebugGenerateTestHomesCommand.java

@@ -0,0 +1,32 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+
+public class MetropolisDebugGenerateTestHomesCommand implements CommandExecutor {
+
+	private MetropolisPlugin _plugin;
+
+	public MetropolisDebugGenerateTestHomesCommand(MetropolisPlugin plugin) {
+		_plugin = plugin;
+		
+	}
+
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+		try{
+			int numHomes = Integer.parseInt(args[0]);
+			for(int i=1; i<= numHomes; i++){
+				_plugin.generateHome(String.format("test%d", i));
+			}
+		
+			return true;
+		}catch(NumberFormatException ex){
+			return false;
+		}
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisFlagResetCommand.java

@@ -0,0 +1,53 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+import com.sk89q.worldguard.protection.flags.DefaultFlag;
+import com.sk89q.worldguard.protection.flags.StateFlag;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+
+public class MetropolisFlagResetCommand implements CommandExecutor {
+	private MetropolisPlugin _plugin;
+
+	public MetropolisFlagResetCommand(MetropolisPlugin plugin){
+		_plugin = plugin;
+	}
+	
+	@Override
+	public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+		ProtectedRegion cityRegion = _plugin.regionManager.getRegion("City");
+		cityRegion.setFlag(DefaultFlag.PVP, StateFlag.State.DENY);
+		cityRegion.setFlag(DefaultFlag.MOB_DAMAGE, StateFlag.State.DENY);
+		cityRegion.setFlag(DefaultFlag.MOB_SPAWNING, StateFlag.State.DENY);
+		cityRegion.setFlag(DefaultFlag.CREEPER_EXPLOSION, StateFlag.State.DENY);
+		cityRegion.setFlag(DefaultFlag.ENDER_BUILD, StateFlag.State.DENY);
+		cityRegion.setFlag(DefaultFlag.GHAST_FIREBALL, StateFlag.State.DENY);
+		cityRegion.setFlag(DefaultFlag.TNT, StateFlag.State.DENY);
+		cityRegion.setFlag(DefaultFlag.LAVA_FLOW, StateFlag.State.DENY);
+		cityRegion.setFlag(DefaultFlag.SNOW_FALL, StateFlag.State.DENY);
+		
+		for(ProtectedRegion homeRegion: _plugin.regionManager.getRegions().values()){
+			if(homeRegion.getId().startsWith("h_")){
+				homeRegion.setFlag(DefaultFlag.PVP, StateFlag.State.DENY);
+				homeRegion.setFlag(DefaultFlag.MOB_DAMAGE, StateFlag.State.DENY);
+				homeRegion.setFlag(DefaultFlag.MOB_SPAWNING, StateFlag.State.DENY);
+				homeRegion.setFlag(DefaultFlag.CREEPER_EXPLOSION, StateFlag.State.DENY);
+				homeRegion.setFlag(DefaultFlag.ENDER_BUILD, StateFlag.State.DENY);
+				homeRegion.setFlag(DefaultFlag.GHAST_FIREBALL, StateFlag.State.DENY);
+				homeRegion.setFlag(DefaultFlag.TNT, StateFlag.State.DENY);
+				
+			}
+		}
+		
+		sender.sendMessage("Metropolis: flags have been reset");
+		
+		return true;
+		
+		
+
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisHomeAcquire.java

@@ -0,0 +1,35 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+
+public class MetropolisHomeAcquire implements CommandExecutor {
+	MetropolisPlugin _plugin;
+	
+	public MetropolisHomeAcquire(MetropolisPlugin plugin){
+		_plugin = plugin;
+	}
+
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+		if(!(sender instanceof Player)){
+			sender.sendMessage("This command can only be used by players");
+			return false;
+		}
+		
+		Player player = (Player) sender;
+		
+		if(_plugin.getNumPlots(player.getName()) >= _plugin.getMaxPlots(player.getName())){
+			sender.sendMessage("You cannot have any more plots");
+			return false;
+		}
+		
+		_plugin.assignPlot(player);
+		return true;
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisHomeEvictCommand.java

@@ -0,0 +1,60 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+import com.sk89q.worldguard.protection.regions.ProtectedRegion;
+
+public class MetropolisHomeEvictCommand implements CommandExecutor {
+	MetropolisPlugin _plugin = null;
+
+	public MetropolisHomeEvictCommand(MetropolisPlugin plugin){
+		_plugin = plugin;
+	}
+	
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+		//get the player and region
+		String playerName = "";
+		
+		if(args.length == 0){
+			return false;
+		}
+		
+		if(args.length >= 1){
+			playerName = args[0];
+		}
+		
+		OfflinePlayer player = _plugin.getServer().getOfflinePlayer(playerName);
+		if(player == null){
+			sender.sendMessage(String.format("The requested player {%s}does not appear to exist.", playerName));
+			return false;
+		}
+		
+		ProtectedRegion region = _plugin.getRegion(String.format("h_%s", player.getName()));
+		if(region == null){
+			sender.sendMessage(String.format("The player {%s} has no home to be evicted from."));
+			return false;
+		}
+		
+		//remove the player as owner and/or member of the region
+		region.getMembers().removePlayer(playerName);
+		region.getOwners().removePlayer(playerName);
+		
+		//if the region has no owners delete the region
+		if(region.getMembers().size() == 0 && region.getOwners().size() == 0){
+			_plugin.removeRegion(region.getId());
+		}
+		
+		_plugin.saveRegions();
+		
+		//?optionally regen the region
+		//_plugin.worldEdit.getCommand("regen").execute(_plugin.getServer().getConsoleSender(), "regen", new String[]{});
+		
+		return true;
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisHomeGenerateCommand.java

@@ -0,0 +1,30 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+
+public class MetropolisHomeGenerateCommand implements CommandExecutor {
+
+	private MetropolisPlugin _plugin;
+	
+	public MetropolisHomeGenerateCommand(MetropolisPlugin plugin){
+		_plugin = plugin;
+	}
+	
+	@Override
+	public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+		if(args.length < 1){
+			return false;
+		}
+		
+		_plugin.generateHome(args[0]);
+		
+		sender.sendMessage("[Metropolis] Home generated for " + args[0]);
+		
+		return true;
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisHomeGoCommand.java

@@ -0,0 +1,76 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.Location;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+import com.majinnaibu.bukkitplugins.metropolis.PlayerHome;
+
+public class MetropolisHomeGoCommand implements CommandExecutor {
+	MetropolisPlugin _plugin = null; 
+	
+	public MetropolisHomeGoCommand(MetropolisPlugin plugin){
+		_plugin = plugin;
+	}
+	
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+		Player player = null;
+		if(sender instanceof Player){
+			player = (Player)sender;
+
+			if(args.length >= 1){
+				if(player.hasPermission("")){
+					player = _plugin.getServer().getPlayer(args[0]);
+					
+					if(player == null){
+						sender.sendMessage(String.format("Unable to find player %s", args[0]));
+						return false;
+					}
+				}else{
+					sender.sendMessage("Permission denied");
+					return false;
+				}
+			}			
+		}else{
+			if(args.length >= 1){
+				player = _plugin.getServer().getPlayer(args[0]);				
+
+				if(player == null){
+					sender.sendMessage(String.format("Unable to find player %s", args[0]));
+					return false;
+				}
+			}else{
+				sender.sendMessage("You must be a player");
+				return false;
+			}
+		}
+		
+		PlayerHome home = _plugin.getPlayerHome(player);
+		
+		Location loc = null;
+		Location bedSpawn = player.getBedSpawnLocation();
+		
+		if(home.contains(bedSpawn)){
+			loc = bedSpawn;
+		}else {
+			loc = home.getViableSpawnLocation(_plugin.getWorld());
+		}
+		
+		if(loc != null){
+			player.teleport(loc);
+		}else{
+			if(sender == player){
+				sender.sendMessage("There is no valid spawn location in your home");
+			}else{
+				sender.sendMessage(String.format("There is no valid spawn location in %s's home", player.getName()));
+			}
+			return false;
+		}
+		
+		return true;
+	}
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisHomeListCommand.java

@@ -0,0 +1,25 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+import com.majinnaibu.bukkitplugins.metropolis.Plot;
+
+public class MetropolisHomeListCommand implements CommandExecutor {
+	private MetropolisPlugin _plugin;
+	
+	public MetropolisHomeListCommand(MetropolisPlugin plugin){
+		_plugin = plugin;
+	}
+	
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+		for(Plot cityBlock : _plugin.getCityBlocks()){
+			sender.sendMessage(String.format("%s", cityBlock.toFriendlyString()));
+		}
+		return true;
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisHomeMoveCommand.java

@@ -0,0 +1,53 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.OfflinePlayer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+
+public class MetropolisHomeMoveCommand implements CommandExecutor {
+	MetropolisPlugin _plugin;
+
+	public MetropolisHomeMoveCommand(MetropolisPlugin plugin) {
+		_plugin = plugin;
+	}
+
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+		OfflinePlayer player = null;
+		int newHomeNumber = 0;
+		
+		if(sender instanceof OfflinePlayer){
+			player = (OfflinePlayer)sender;
+		}
+		
+		if(args.length == 1){
+			try{
+				newHomeNumber = Integer.parseInt(args[0]);
+			}catch(NumberFormatException ex){
+				return false;
+			}
+		}else if(args.length >= 2){
+			try{
+				newHomeNumber = Integer.parseInt(args[0]);
+			}catch(NumberFormatException ex){
+				return false;
+			}
+			
+			player = _plugin.getOfflinePlayer(args[1]);
+		}else{
+			return false;
+		}
+		
+		if(player == null || !_plugin.homeExists(player.getName(), newHomeNumber)){
+			return false;
+		}
+		
+		_plugin.setHome(player.getName(), newHomeNumber);
+				
+		return true;
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisPlotGoCommand.java

@@ -0,0 +1,49 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+import com.majinnaibu.bukkitplugins.metropolis.Plot;
+
+public class MetropolisPlotGoCommand implements CommandExecutor {
+	MetropolisPlugin _plugin;
+
+	public MetropolisPlotGoCommand(MetropolisPlugin plugin) {
+		_plugin = plugin;
+	}
+
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+		Player player = null;
+		Plot plot = null;
+		
+		if(sender instanceof Player){
+			player = (Player) sender;
+		}
+		
+		if(args.length == 1 && player != null){
+			plot = _plugin.getPlot(args[0]);
+		}else if(args.length >= 2){
+			player = _plugin.getPlayer(args[1]);
+			plot = _plugin.getPlot(args[0]);
+		}else{
+			return false;
+		}
+		
+		if(plot == null || player == null){
+			return false;
+		}
+		
+		String errorMessage = _plugin.teleportPlayerToPlot(player, plot);
+		if(errorMessage != null){
+			sender.sendMessage(errorMessage);
+			return false;
+		}
+		
+		return true;
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/commands/MetropolisPlotReserveCommand.java

@@ -0,0 +1,67 @@
+package com.majinnaibu.bukkitplugins.metropolis.commands;
+
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import com.majinnaibu.bukkitplugins.metropolis.Cuboid;
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+import com.sk89q.worldedit.bukkit.selections.Selection;
+
+public class MetropolisPlotReserveCommand implements CommandExecutor {
+	MetropolisPlugin _plugin;
+
+	public MetropolisPlotReserveCommand(MetropolisPlugin metropolisPlugin) {
+		_plugin = metropolisPlugin;
+	}
+
+	@Override
+	public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+		int minX = 0;
+		int minY = 0;
+		int minZ = 0;
+		int maxX = 0;
+		int maxY = 0;
+		int maxZ = 0;
+		Cuboid cuboid = new Cuboid();
+		
+		if(sender instanceof Player && args.length == 1){
+			Selection selection = _plugin.worldEdit.getSelection((Player) sender);
+			cuboid = new Cuboid(selection);
+		}else if(args.length == 6){
+			try{
+				minX = Integer.parseInt(args[1]);
+				minY = Integer.parseInt(args[2]);
+				minZ = Integer.parseInt(args[3]);
+				maxX = Integer.parseInt(args[4]);
+				maxY = Integer.parseInt(args[5]);
+				maxZ = Integer.parseInt(args[6]);
+			}catch(NumberFormatException ex){
+				return false;
+			}
+			cuboid = new Cuboid(minX, minY, minZ, maxX, maxY, maxZ);
+		}else if(args.length == 4){
+			try{
+				minX = Integer.parseInt(args[1]);
+				minY = 0;
+				minZ = Integer.parseInt(args[2]);
+				maxX = Integer.parseInt(args[3]);
+				maxY = _plugin.getWorld().getMaxHeight();
+				maxZ = Integer.parseInt(args[4]);
+			}catch(NumberFormatException ex){
+				return false;
+			}
+			cuboid = new Cuboid(minX, minY, minZ, maxX, maxY, maxZ);
+		}else{
+			return false;
+		}
+		
+		String regionName = args[0];
+		
+		_plugin.reserveCuboid(regionName, cuboid);
+		
+		return true;
+	}
+
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/eventlisteners/DebugListener.java

@@ -0,0 +1,21 @@
+package com.majinnaibu.bukkitplugins.metropolis.eventlisteners;
+
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerInteractEvent;
+
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+
+public class DebugListener implements Listener {
+	MetropolisPlugin _plugin;
+	
+	public DebugListener(MetropolisPlugin plugin){
+		_plugin = plugin;
+	}
+	
+	@EventHandler(priority=EventPriority.MONITOR)
+	public void onEvent(PlayerInteractEvent event){
+		//event.
+	}
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/eventlisteners/PlayerJoinListener.java

@@ -0,0 +1,40 @@
+package com.majinnaibu.bukkitplugins.metropolis.eventlisteners;
+
+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.PlayerJoinEvent;
+
+import com.majinnaibu.bukkitplugins.metropolis.Cuboid;
+import com.majinnaibu.bukkitplugins.metropolis.MetropolisPlugin;
+import com.majinnaibu.bukkitplugins.metropolis.PlayerHome;
+
+public class PlayerJoinListener implements Listener {
+	private MetropolisPlugin _plugin = null;
+	
+	public PlayerJoinListener(MetropolisPlugin plugin){
+		_plugin = plugin;
+		plugin.getServer().getPluginManager().registerEvents(this, plugin);
+	}
+	
+	@EventHandler(priority=EventPriority.MONITOR)
+	public void onPlayerJoin(PlayerJoinEvent event){
+		Player player = event.getPlayer();
+		if(player == null){
+			return;
+		}
+		
+		PlayerHome home = _plugin.getPlayerHome(player);
+		if(home==null){MetropolisPlugin.log.info("home is null");}
+		else if(home.getCuboid() == null){MetropolisPlugin.log.info("home.getCuboid() is null");}
+		else if(home.getCuboid().getVolume() == 0){MetropolisPlugin.log.info("home.getCuboid().getVolume() is 0");}
+		
+		if(home == null || home.getCuboid() == null || home.getCuboid().getVolume() == 0){
+			MetropolisPlugin.log.info(String.format("Metropolis: Unable to get or create home for player %s", player.getName()));
+		}else{
+			Cuboid cuboid = home.getCuboid();
+			player.sendMessage(String.format("Metropolis: Welcome %s your home is between (%d, %d, %d) and (%d, %d, %d)", player.getName(), cuboid.getMinX(), cuboid.getMinY(), cuboid.getMinZ(), cuboid.getMaxX(), cuboid.getMaxY(), cuboid.getMaxZ()));
+		}
+	}
+}

src/main/java/com/majinnaibu/bukkitplugins/metropolis/util/Material.java

@@ -0,0 +1,5 @@
+package com.majinnaibu.bukkitplugins.metropolis.util;
+
+public class Material {
+	public static final int signTypeId = 63;
+}