Merge pull request #36 from RedstonerServer/gradle

Finished Teleport Module and Fixed a bug in the WorldBorder Module

src/main/java/com/redstoner/modules/teleport/TPAType.java

@@ -0,0 +1,5 @@
+package com.redstoner.modules.teleport;
+
+public enum TPAType {
+	TPA, TPAHERE
+}

src/main/java/com/redstoner/modules/teleport/Teleport.cmd

@@ -1,71 +1,80 @@
-command teleport {
+command tp {
-    alias eteleport;
+    alias teleport;
-    alias tp;
-    alias etp;
     alias to;
-    alias eto;
+    
-    alias tpo;
-    alias etpo;
-    alias tp2p;
-    alias etp2p;
     [string:player] {
         run tp player;
-        perm utils.teleport.tp;
+        help Teleports you to a player.;
+        perm utils.teleport.tpa;
+        type player;
     }
     [string:player] [string:player2] {
         run tp2 player player2;
-        perm utils.teleport.tp.other;
+        help Teleports the first player to the second.;
+        perm utils.teleport.tpa;
+    }
+    [int:x] [int:y] [int:z] {
+    	run tploc x y z;
+    	help Teleports you to specific coords.;
+    	perm utils.teleport.tploc;
+    	type player;
+    }
+    
+    [string:player] [int:x] [int:y] [int:z] {
+    	run tploc2 player x y z;
+    	help Teleports a player to specific coords.;
+    	perm utils.teleport.tploc.other;
     }
 }
 
-command teleporthere {
+command tphere {
-    alias eteleporthere;
+    alias tph;
-    alias tphere;
+    alias teleoprthere;
-    alias etphere;
-    alias tpohere;
-    alias etpohere;
     perm utils.teleport.tp;
+    type player;
+    
     [string:player] {
         run tphere player;
+        help Teleports the player to you.;
         perm utils.teleport.tp.here;
     }
 }
 
-command teleportask {
+command tpa {
-    alias eteleportask;
-    alias tpa;
-    alias etpa;
     alias tpr;
-    alias etpr;
     alias tpask;
-    alias etpask;
+    alias teleportask;
     perm utils.teleport.tpa;
+    type player;
+    
     [string:player] {
         run tpa player;
+        help Request to teleport to a player.;
     }
 }
 
-command teleportaskhere {
+command tpahere {
-    alias eteleportaskhere;
+    alias tpah;
-    alias tpahere,
-    alias etpahere;
     alias tprhere;
-    alias etrphere;
     alias tpaskhere;
-    alias etpaskhere;
+    alias teleportaskhere;
     perm utils.teleport.tpa;
+	type player;
+	
     [string:player] {
         run tpahere player;
+        help Request a player to teleport to you,;
         help ask another player to teleport to you.;
     }
 }
 
 command tpall {
-    alias etpall;
     perm utils.teleport.tpall;
+    
     [empty] {
         run tpall;
         help Teleports everyone to you.;
+        type player;
     }
     [string:player] {
         run tpall2 player;
@@ -73,53 +82,48 @@ command tpall {
     }
 }
 
-command tpaall {
-    alias etpall;
-    perm utils.teleport.tpaall;
-    [empty] {
-        run tpaall;
-        help Sends a tpa request to every player.;
-    }
-    [string:player] {
-        run tpaall2 player;
-        help Sends a tpa request to every player.;
-    }
-}
-
 command tpaccept {
-    alias etpaccept;
     alias tpyes;
-    alias etpyes;
     perm utils.teleport.request;
+    type player;
+    
     [empty] {
         run tpaccept;
         help Accepts the latest pending tpa request.;
     }
-    [int:index] {
+    [string:player] {
-        run tpaccept2 index;
+        run tpaccept2 player;
         help Accepts the specified pending tpa request.;
     }
 }
 
-command tpacancel {
+command tpcancel {
-    alias etpacencel;
+    alias tpastop;
     perm utils.teleport.request;
+    type player;
+    
     [empty] {
         run tpacancel;
-        help Cancels an outgoing pending tpa request.;
+        help Cancels the latest outgoing pending tpa request.;
+    }
+    [string:player] {
+        run tpacancel2 player;
+        help Cancels the specific outgoing pending tpa request.;
     }
 }
 
 command tpdeny {
-    alias etpdeny;
     alias tpno;
-    alias etpno;
     perm utils.teleport.request;
+    type player;
+    
     [empty] {
         run tpdeny;
+        help Denies the latest pending tpa request.;
     }
-    [int:index] {
+    [string:player] {
-        run tpdeny2 index;
+        run tpdeny2 player;
+        help Denies the specified pending tpa request.;
     }
 }
 
@@ -128,20 +132,20 @@ command tplist {
     alias tpl;
     alias etpl;
     perm utils.teleport.request;
+    type player;
+    
     [empty] {
         run tplist;
+        help Shows you a list of all the incoming tpa requests.;
     }
 }
 
 command tptoggle {
-    alias etptoggle;
     perm utils.teleport.toggle;
+    type player;
+    
     [string:status] {
         run tptoggle status;
-        help sets your tpa status;
+        help sets your tpa status (All, ToMe, ToThem, None);
-    }
-    [string:command] [string:status] {
-        run tptoggle2 command status;
-        help sets your tpa status for only one command (e.g. tpa/tpahere).;
     }
 }

src/main/java/com/redstoner/modules/teleport/Teleport.java

@@ -1,262 +1,490 @@
 package com.redstoner.modules.teleport;
 
-import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Stack;
 
 import org.bukkit.Bukkit;
+import org.bukkit.Location;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerTeleportEvent.TeleportCause;
 
 import com.nemez.cmdmgr.Command;
+import com.redstoner.annotations.AutoRegisterListener;
 import com.redstoner.annotations.Commands;
 import com.redstoner.annotations.Version;
 import com.redstoner.misc.CommandHolderType;
 import com.redstoner.modules.Module;
 import com.redstoner.modules.datamanager.DataManager;
 
-import net.nemez.chatapi.click.Message;
+import net.nemez.chatapi.ChatAPI;
 
 @Commands(CommandHolderType.File)
+@AutoRegisterListener
 @Version(major = 5, minor = 0, revision = 0, compatible = 4)
-public class Teleport implements Module
+public class Teleport implements Module, Listener
 {
-	public static final String PERMISSION_TELEPORT = "utils.admin.teleport";
+	public static final String PERMISSION_TELEPORT = "utils.teleport.tp";
+	public static final String PERMISSION_TELEPORT_OTHER = "utils.teleport.tp.other";	
 	
-	public ArrayList<TPRequest> pending_requests;
+	private Map<Player, Map<Player, TPAType>> pending_requests = new HashMap<>();
+	private Map<Player, Stack<Player>> last_request = new HashMap<>();
+	private Map<Player, Stack<Player>> last_request_got = new HashMap<>();
 	
-	@Override
+	@Command(hook = "tploc")
-	public void postEnable()
+	public void tploc(CommandSender sender, int x, int y, int z) {
-	{
+		Player p = (Player) sender;
-		pending_requests = new ArrayList<TPRequest>();
+		
+		p.teleport(new Location(p.getWorld(), x, y, z), TeleportCause.COMMAND);
+		getLogger().message(sender, "Teleported to &e(" + x + "," + y + "," + z + ")&7.");
+	}
+	
+	@Command(hook = "tploc2")
+	public void tploc2(CommandSender sender, String player, int x, int y, int z) {
+		Player p = Bukkit.getPlayer(player);
+		
+		if (p == null)
+			playerDoesNotExistError(sender, player);
+		else if (sender.getName().equals(p.getName()))
+			cannotTpToYourself(sender);
+		else {
+			p.teleport(new Location(p.getWorld(), x, y, z), TeleportCause.COMMAND);
+			getLogger().message(sender, "Teleported &e" + p.getDisplayName() +
+					            "&7 to &e(" + x + "," + y + "," + z + ")&7.");
+			getLogger().message(p, "You've been teleported to &e(" + x + "," + y + "," + z + ")&7, by &e" +
+					            (sender instanceof Player? ((Player)sender).getDisplayName()
+					            	                     : sender.getName()) + "&7.");
+		}
 	}
 	
 	@Command(hook = "tp")
-	public boolean teleport(CommandSender sender, String player)
+	public void teleport(CommandSender sender, String player) {
-	{
+		if (!sender.hasPermission(PERMISSION_TELEPORT)) {
-		if (!sender.hasPermission(PERMISSION_TELEPORT))
+			tpa(sender, player);
-			return tpa(sender, player);
+			return;
-		return true;
+		}
+		
+		Player p = Bukkit.getPlayer(player);
+		if (p == null)
+			playerDoesNotExistError(sender, player);
+		else if (sender.getName().equals(p.getName()))
+			cannotTpToYourself(sender);
+		else {
+			((Player)sender).teleport(p, TeleportCause.COMMAND);
+			getLogger().message(sender, "Teleported to &e" + p.getDisplayName() + "&7.");
+		}
 	}
 	
 	@Command(hook = "tp2")
-	public boolean teleport(CommandSender sender, String player, String player2)
+	public void teleport(CommandSender sender, String player, String player2) {
-	{
+		if (!sender.hasPermission(PERMISSION_TELEPORT)
-		if (!sender.hasPermission(PERMISSION_TELEPORT))
+		  && sender.getName().equalsIgnoreCase(player2)) {
-			if (player2.equals(((Player) sender).getName()))
+			tpahere(sender, player);
-				return tpahere(sender, player);
+			return;
-			else
+		}
-			{
+		
-				getLogger().message(sender, "You do not have the required permissions to run that Command!");
+		Player p1 = Bukkit.getPlayer(player);
-				return true;
+		Player p2 = Bukkit.getPlayer(player);
-			}
+		
-		Player p1 = Bukkit.getPlayer(player);
+		if (p1 == null)
-		Player p2 = Bukkit.getPlayer(player2);
+			playerDoesNotExistError(sender, player);
-		if (p1 == null || p2 == null)
+		else if (p2 == null)
-		{
+			playerDoesNotExistError(sender, player2);
-			getLogger().message(sender, true, "The specified player couldn't be found!");
+		else if (p1.getName().equals(p2.getName()))
-			return true;
+			cannotTpToYourself(sender);
+		else {
+			p1.teleport(p2, TeleportCause.COMMAND);
+			getLogger().message(sender, "&e" +p1.getDisplayName() + "&7 has been teleported to &e" +
+			                            p2.getDisplayName() + "&7.");
+			getLogger().message(p1, "You've been teleported to &e" + p2.getDisplayName() +
+					                "&7 by &e" + (sender instanceof Player?
+					                ((Player)sender).getDisplayName(): sender.getName()));
 		}
-		p1.teleport(p2);
-		getLogger().message(p1, "You have been teleported to: " + p2.getDisplayName());
-		if (!sender.getName().equals(p1.getName()))
-			getLogger().message(sender,
-					p1.getDisplayName() + "&7 has been teleported to " + p2.getDisplayName() + "&7!");
-		return true;
 	}
 	
 	@Command(hook = "tphere")
-	public boolean tphere(CommandSender sender, String player)
+	public void tphere(CommandSender sender, String player) {
-	{
+		Player p = Bukkit.getPlayer(player);
-		return true;
+		if (p == null)
+			playerDoesNotExistError(sender, player);
+		else if (sender.getName().equals(p.getName()))
+			cannotTpToYourself(sender);
+		else {
+			p.teleport((Player)sender);
+			getLogger().message(sender, "&e" + p.getDisplayName() + "&7 has been teleported to you.");
+			getLogger().message(p, "&e" + ((Player)sender).getDisplayName() + "&7 has teleported you to them.");
+		}
 	}
 	
 	@Command(hook = "tpa")
-	public boolean tpa(CommandSender sender, String player)
+	public void tpa(CommandSender sender, String player) {
-	{
+		Player p = Bukkit.getPlayer(player);
-		return true;
+		if (p == null)
+			playerDoesNotExistError(sender, player);		
+		
+		else if (sender.getName().equals(p.getName()))
+			cannotTpToYourself(sender);
+		
+		else if ( (Boolean) DataManager.getOrDefault(p, "allow-tpa", true) == false )
+			getLogger().message(sender, true, "&e" + p.getDisplayName() + "&7 doesn't accept TPA requests.");
+		
+		else {
+			Player s = (Player) sender;
+			insertIntoMaps(s, p, TPAType.TPA);
+			getLogger().message(sender, "TPA request sent to &e" + p.getDisplayName() + "&7.");
+			notifyAskie(p, s, TPAType.TPA);
+		}
+		
 	}
 	
 	@Command(hook = "tpahere")
-	public boolean tpahere(CommandSender sender, String player)
+	public void tpahere(CommandSender sender, String player) {
-	{
+		Player p = Bukkit.getPlayer(player);
-		return true;
+		if (p == null)
+			playerDoesNotExistError(sender, player);		
+		
+		else if (sender.getName().equals(p.getName()))
+			cannotTpToYourself(sender);
+		
+		else if ( (Boolean) DataManager.getOrDefault(p, "allow-tpahere", true) == false )
+			getLogger().message(sender, true, "&e" + p.getDisplayName() + "&7 doesn't accept TPA Here requests.");
+		
+		else {
+			Player s = (Player) sender;
+			insertIntoMaps(s, p, TPAType.TPAHERE);
+			getLogger().message(sender, "TPA Here request sent to &e" + p.getDisplayName() + "&7.");
+			notifyAskie(p, s, TPAType.TPAHERE);
+		}
 	}
 	
 	@Command(hook = "tpall")
-	public boolean tpall(CommandSender sender)
+	public void tpall(CommandSender sender)	{
-	{
+		Player to = (Player) sender;
-		return true;
+		for (Player p : Bukkit.getOnlinePlayers()) {
+			if (p.getName().equals(sender.getName()))
+				continue;
+			p.teleport(to, TeleportCause.COMMAND);
+			getLogger().message(p, "&e" + to.getDisplayName() + "&7 has teleported everyone to them.");
+		}
+		getLogger().message(sender, "Everyone has sucessfully teleported to you.");
 	}
 	
 	@Command(hook = "tpall2")
-	public boolean tpall2(CommandSender sender, String player)
+	public void tpall2(CommandSender sender, String player)	{
-	{
+		Player to = Bukkit.getPlayer(player);
-		return true;
+		if (to == null) {
-	}
+			playerDoesNotExistError(sender, player);
+			return;
+		}
 		
-	@Command(hook = "tpaall")
+		String s = (sender instanceof Player? ((Player)sender).getDisplayName() :sender.getName());
-	public boolean tpaall(CommandSender sender)
+		for (Player p : Bukkit.getOnlinePlayers()) {
-	{
+			p.teleport(to, TeleportCause.COMMAND);
-		return true;
+			getLogger().message(p, "&e" + s + "&7 has teleported everyone to &e" + to.getDisplayName() + "&7.");
-	}
+		}
-	
+		getLogger().message(sender, "Everyone was sucessfully teleported to &e" + to.getDisplayName() + "&7.");
-	@Command(hook = "tpaall2")
-	public boolean tpaall2(CommandSender sender, String player)
-	{
-		return true;
 	}
 	
 	@Command(hook = "tpaccept")
-	public boolean tpaccept(CommandSender sender)
+	public void tpaccept(CommandSender sender) {
-	{
+		Player to = (Player) sender;
-		return true;
+		Player from = getLastRequestGot(to);
+		
+		if (from == null)
+			getLogger().message(sender, true, "You have no incoming TPA requests.");
+		else
+			teleport(to, from, pending_requests.get(to).get(from));		
 	}
 	
 	@Command(hook = "tpaccept2")
-	public boolean tpaccept2(CommandSender sender, int index)
+	public void tpaccept2(CommandSender sender, String player) {
-	{
+		Player to = (Player) sender;
-		return true;
+		Player from = Bukkit.getPlayer(player);
+		
+		if (from == null) {
+			playerDoesNotExistError(sender, player);
+			return;
+		}
+		
+		if (from.getName().equals(sender.getName())) {
+			cannotTpToYourself(sender);
+			return;
+		}
+		
+		Map<Player, TPAType> m = pending_requests.get(to);
+		
+		if (m == null)
+			getLogger().message(sender, true, "You have no incoming TPA requests.");
+		else if (!m.containsKey(from))
+			getLogger().message(sender, true, "&e" + from.getDisplayName() + "didn't send a TPA request.");
+		else
+			teleport(to, from, m.get(from));
+	}
+	
+	
+	private void teleport(Player to, Player from, TPAType type) {
+		switch (pending_requests.get(to).get(from)) {
+			case TPA: from.teleport(to, TeleportCause.COMMAND); break;
+			case TPAHERE: to.teleport(from, TeleportCause.COMMAND); break;
+		}
+		clearRequest(to, from);
+	
+		getLogger().message(from, "&e" + to.getDisplayName() + "&7 has &aaccepted&7 your TPA request.");
+		getLogger().message(to, "You've &aaccepted&7 &e" + from.getDisplayName() + "&7's TPA request.");
 	}
 	
 	@Command(hook = "tpdeny")
-	public boolean tpdeny(CommandSender sender)
+	public void tpdeny(CommandSender sender) {
-	{
+		Player to = (Player) sender;
-		return true;
+		Player from = getLastRequestGot(to);
+		
+		if (from == null) {
+			getLogger().message(sender, true, "You have no incoming TPA requests.");
+			return;
+		}
+		
+		clearRequest(to, from);
+		
+		getLogger().message(from, "&e" + to.getDisplayName() + "&7 has &cdenied&7 your TPA request.");
+		getLogger().message(to, "You've &cdenied&7 &e" + from.getDisplayName() + "&7's TPA request.");
 	}
 	
 	@Command(hook = "tpdeny2")
-	public boolean tpdeny2(CommandSender sender, int index)
+	public void tpdeny2(CommandSender sender, String player) {
-	{
+		Player to = (Player) sender;
-		return true;
+		Player from = Bukkit.getPlayer(player);
+		
+		if (from == null) {
+			playerDoesNotExistError(sender, player);
+			return;
+		}
+		
+		if (from.getName().equals(sender.getName())) {
+			cannotTpToYourself(sender);
+			return;
+		}
+		
+		Map<Player, TPAType> m = pending_requests.get(to);
+		
+		if (m == null)
+			getLogger().message(sender, true, "You have no incoming TPA requests.");
+		
+		else if (!m.containsKey(from))
+			getLogger().message(sender, true, "&e" + from.getDisplayName() + "&7 doesn't have an active TPA request with you.");
+		
+		else {
+			clearRequest(to, from);
+			getLogger().message(from, "&e" + to.getDisplayName() + "&7 has &cdenied&7 your TPA request.");
+			getLogger().message(to, "You've &cdenied&7 &e" + from.getDisplayName() + "&7's TPA request.");
+		}
 	}
 	
 	@Command(hook = "tpacancel")
-	public boolean tpacancel(CommandSender sender)
+	public void tpacancel(CommandSender sender)	{
-	{
+		Player from = (Player) sender;
-		return true;
+		Player to = getLastRequest(from);
+		
+		if (to == null)
+			getLogger().message(sender, true, "You don't have outgoing TPA requests.");
+		else
+			cancel(to, from);
+	}
+	
+	@Command(hook = "tpacancel2")
+	public void tpacancel2(CommandSender sender, String player)	{
+		Player from = (Player) sender;
+		Player to = Bukkit.getPlayer(player);
+		
+		if (to == null)
+			playerDoesNotExistError(sender, player);
+		else
+			cancel(to, from);
+	}
+	
+	private void cancel(Player to, Player from) {
+		Stack<Player> s = last_request.get(from);
+		
+		if (s == null)
+			getLogger().message(from, true, "You have no outgoing TPA requests.");
+		
+		else if (!s.contains(to))
+			getLogger().message(from, true, "You didn't send a TPA request to &e"
+		                                      + to.getDisplayName() + "&7.");
+		
+		else {
+			clearRequest(to, from);
+			getLogger().message(to, "&e" + from.getDisplayName() + "&7 has &ccanceled&7 their request.");
+			getLogger().message(from, "You &ccanceled&7 your request to &e" + to.getDisplayName() + "&7.");
+		}
 	}
 	
 	@Command(hook = "tplist")
-	public boolean tplist(CommandSender sender)
+	public void tplist(CommandSender sender) {
-	{
+		Player to = (Player) sender;
-		return true;
+		
+		Map<Player,TPAType> m = pending_requests.get(to);
+		
+		if (m == null) {
+			getLogger().message(sender, true, "You don't have any incoming TPA requests.");
+			return;
+		}
+		ChatAPI.send(sender, getLogger().getHeader());
+		ChatAPI.send(sender, "");
+		
+		for (Player from : m.keySet()) {
+			ChatAPI.createMessage(sender)
+			.appendText("&e" + from.getDisplayName() + "&7: ")
+			.appendSendChatHover("&aAccept", "/tpaccept " + from.getName(), "&eClick to &aAccept")
+			.appendText("&7 or ")
+			.appendSendChatHover("&cDeny", "/tpdeny " + from.getName(), "&eClick to &cDeny")
+			.send();
+		}
 	}
 	
 	@Command(hook = "tptoggle")
-	public boolean tptoggle(CommandSender sender, String status)
+	public void tptoggle(CommandSender sender, String status) {
-	{
-		return true;
-	}
 		
-	@Command(hook = "tptoggle2")
+		switch (status.toLowerCase()) {
-	public boolean tptoggle2(CommandSender sender, String command, String status)
+			case "all":
-	{
+				DataManager.setData(sender, "allow-tpa", true);
-		return true;
+				DataManager.setData(sender, "allow-tpahere", true);
-	}
-	
-	@Command(hook = "tpmenu")
-	public boolean tpinventory(CommandSender sender)
-	{
-		return true;
-	}
-	
-	protected void remove(TPRequest request)
-	{
-	
-	}
-}
-
-class TPRequest implements Runnable
-{
-	private final Teleport holder;
-	private final Player sender;
-	private final Player target;
-	private final Type type;
-	private int index;
-	
-	Thread t;
-	
-	public TPRequest(Player sender, Player target, Type type, int index, Teleport holder)
-	{
-		this.sender = sender;
-		this.target = target;
-		this.type = type;
-		this.index = 0;
-		this.holder = holder;
-	}
-	
-	public Player getSender()
-	{
-		return sender;
-	}
-	
-	public Player getTarget()
-	{
-		return target;
-	}
-	
-	public Type getType()
-	{
-		return type;
-	}
-	
-	public int getIndex()
-	{
-		return index;
-	}
-	
-	public void setIndex(int index)
-	{
-		this.index = index;
-	}
-	
-	public void execute()
-	{
-		switch (type)
-		{
-			case tpa:
-				sender.teleport(target);
 				break;
-			case tpahere:
+			case "tome":
-				target.teleport(sender);
+				DataManager.setData(sender, "allow-tpa", true);
+				DataManager.setData(sender, "allow-tpahere", false);
 				break;
+			case "tothem":
+				DataManager.setData(sender, "allow-tpa", false);
+				DataManager.setData(sender, "allow-tpahere", true);
+				break;
+			case "none":
+				DataManager.setData(sender, "allow-tpa", false);
+				DataManager.setData(sender, "allow-tpahere", false);
+				break;
+			default:
+				getLogger().message(sender, true, "Invalid status, &e" + status +
+						            "&7. Available: &eAll&7, &eToMe&7, &eToThem&7, and &eNone&7. ");
+				return;
 		}
+		getLogger().message(sender, "Status set to &e" + status + "&7.");
 	}
 	
-	public void abort()
+	private void playerDoesNotExistError(CommandSender sender, String player) {
-	{
+		getLogger().message(sender, true, "The player, &e" + player + "&7, is not online.");
-		t.interrupt();
+	}
+	private void cannotTpToYourself(CommandSender sender) {
+		getLogger().message(sender, true, "You can't teleport to yourself.");
 	}
 	
-	@Override
+	private void insertIntoMaps(Player from, Player to, TPAType type) {
-	public void run()
+		Map<Player, TPAType> m = pending_requests.getOrDefault(to, new HashMap<>());
-	{
+		m.put(from, type);
-		t = Thread.currentThread();
+		pending_requests.put(to, m);
-		try
+		
-		{
+		Stack<Player> s1 = last_request.getOrDefault(from, new Stack<>());
-			Thread.sleep(60000);
+		s1.push(to);
+		last_request.put(from, s1);
+		
+		Stack<Player> s2 = last_request_got.getOrDefault(to, new Stack<>());
+		s2.push(from);
+		last_request_got.put(to, s2);
+	}
+	
+	private void notifyAskie(Player to, Player from, TPAType type) {
+		ChatAPI.createMessage(to)
+		.appendText(getLogger().getPrefix() + "&e" + from.getDisplayName()
+		          + "&7 has requested " +
+				  (type == TPAType.TPA? "to teleport to you" : "you teleport to them") +
+				  ".\nResponce: ")
+		.appendSendChatHover("&aAccept", "/tpaccept " + from.getName(), "&eClick to &aAccept")
+		.appendText("&7 or ")
+		.appendSendChatHover("&cDeny", "/tpdeny " + from.getName(), "&eClick to &cDeny")
+		.send();
+	}
+	
+	private Player getLastRequest(Player from) {
+		Stack<Player> stack = last_request.get(from);
+		if (stack == null)
+			return null;
+		Player toReturn = stack.peek();
+		if (stack.isEmpty())
+			last_request.remove(from);
+		else
+			last_request.put(from, stack);
+		return toReturn;
+	}
+	
+	private Player getLastRequestGot(Player to) {
+		Stack<Player> stack = last_request_got.get(to);
+		if (stack == null)
+			return null;
+		Player toReturn = stack.peek();
+		if (stack.isEmpty())
+			last_request_got.remove(to);
+		else
+			last_request_got.put(to, stack);
+		return toReturn;
+	}
+	
+	private void clearRequest(Player to, Player from) {
+		Stack<Player> s1 = last_request.get(from);
+		Stack<Player> s2 = last_request_got.get(to);
+		Map<Player, TPAType> m = pending_requests.get(to);
+		
+		s1.remove(to);
+		s2.remove(from);
+		m.remove(from);
+		
+		if (s1.isEmpty())
+			last_request.remove(from);
+		else
+			last_request.put(from, s1);
+		if (s2.isEmpty())
+			last_request_got.remove(to);
+		else
+			last_request_got.put(to, s2);
+		if (m.isEmpty())
+			pending_requests.remove(from);
+		else
+			pending_requests.put(from, m);				
+	}
+	
+	@EventHandler
+	public void onPlayerQuit(PlayerQuitEvent event) {
+		Player p = event.getPlayer();
+		
+		pending_requests.remove(p);
+		last_request.remove(p);
+		last_request_got.remove(p);
+		
+		for (Player fl : pending_requests.keySet()) {
+			Map<Player, TPAType> m = pending_requests.get(fl);
+			m.remove(p);
+			if (m.isEmpty())
+				pending_requests.remove(fl);
+			else
+				pending_requests.put(fl, m);
 		}
-		catch (InterruptedException e)
+		for (Player fl : last_request.keySet()) {
-		{
+			Stack<Player> s = last_request.get(fl);
-			holder.remove(this);
+			s.remove(p);
-			Message m = new Message(sender, null);
+			if (s.isEmpty())
-			if (DataManager.getState(sender, "AFK"))
+				last_request.remove(fl);
-			{
+			else
-				m.appendText(target.getDisplayName() + " is AFK and might not respond. ");
+				last_request.put(fl, s);
-				m.appendSendChat("Try again?", "/" + type.toString() + " " + target.getName());
+		}
-			}
+		for (Player fl : last_request_got.keySet()) {
-			if (DataManager.getState(sender, "BUSY"))
+			Stack<Player> s = last_request_got.get(fl);
-			{
+			s.remove(p);
-				m.appendText(target.getDisplayName() + " is BUSY and might not respond. ");
+			if (s.isEmpty())
-				m.appendSendChat("Try again?", "/" + type.toString() + " " + target.getName());
+				last_request_got.remove(fl);
-			}
+			else
-			return;
+				last_request_got.put(fl, s);
 		}
-		holder.remove(this);
 	}
 }
 
-enum Type
-{
-	tpa,
-	tpahere;
-}

src/main/java/com/redstoner/modules/worldborder/WorldBorder.java

@@ -183,11 +183,14 @@ public class WorldBorder implements Module, Listener {
 		if (info == null || info.isCordanateWithinBounds(to.getBlockX(), to.getBlockZ()))
 			return to;
 		else {
-			System.out.println(p.isInsideVehicle());
 			if (p.isInsideVehicle())
 				p.getVehicle().remove();
 			ChatAPI.sendActionBar(p, message);
-			return from;
+			
+			if (info.isCordanateWithinBounds(from.getBlockX(), from.getBlockZ()))
+				return from;
+			else
+				return new Location(to.getWorld(), info.getCX(), 80, info.getCZ());
 		}
 	}
 }

src/main/java/com/redstoner/modules/worldborder/WorldBorderInfo.java

@@ -23,6 +23,14 @@ public class WorldBorderInfo {
 		return x > minX && x < maxX && z > minZ && z < maxZ;
 	}
 	
+	public int getCX() {
+		return cx;
+	}
+	
+	public int getCZ() {
+		return cz;
+	}
+	
 	public String getMessage() {
 		return message;
 	}
@@ -42,5 +50,4 @@ public class WorldBorderInfo {
 		return new WorldBorderInfo(((Long)j.get("cx")).intValue(),
 				                   ((Long)j.get("cz")).intValue(), ((Long)j.get("r")).intValue());
 	}	
-	
 }