/**
 * Modify the to location of the given event to prevent the movement and
 * move the player so they are standing on the center of the block at the
 * from location.
 */
private static void resetPosition(final PlayerMoveEvent event) {
    Location newLoc;
    double yValue = event.getFrom().getY();

    if(yValue <= 0 || event instanceof PlayerTeleportEvent) {
        newLoc = event.getFrom();
    } else {
        newLoc = BlockUtils.center(event.getFrom()).subtract(new Vector(0, 0.5, 0));
        if(newLoc.getBlock() != null) {
            switch(newLoc.getBlock().getType()) {
            case STEP:
            case WOOD_STEP:
                newLoc.add(new Vector(0, 0.5, 0));
                break;
            default: break;
            }
        }
    }

    newLoc.setPitch(event.getTo().getPitch());
    newLoc.setYaw(event.getTo().getYaw());
    event.setCancelled(false);
    event.setTo(newLoc);
}
 

@Override
public void cancelAction(User user, PacketEvent packetEvent)
{
    final IWrapperPlayPosition positionWrapper = packetEvent::getPacket;

    final Vector moveTo = new Vector(positionWrapper.getX(),
                                     positionWrapper.getY(),
                                     positionWrapper.getZ());

    final Location knownPosition = user.getPlayer().getLocation();

    // Not many blocks moved to prevent exploits and world change problems.
    if (moveTo.distanceSquared(knownPosition.toVector()) < 4) {
        // Teleport back the next tick.
        Bukkit.getScheduler().runTask(AACAdditionPro.getInstance(), () -> user.getPlayer().teleport(knownPosition, PlayerTeleportEvent.TeleportCause.UNKNOWN));
    }
}
 

/**
 * Called whenever a player teleports, for use with NPC guarding logic.
 */
public void onPlayerTeleports(final PlayerTeleportEvent event) {
    if (event.getFrom().getWorld().equals(event.getTo().getWorld())) {
        npc.teleport(event.getTo(), PlayerTeleportEvent.TeleportCause.PLUGIN);
    }
    else { // World loading up can cause glitches.
        event.getFrom().getChunk().load();
        event.getTo().getChunk().load();
        Bukkit.getScheduler().runTaskLater(SentinelPlugin.instance, new Runnable() {
            @Override
            public void run() {
                if (!event.getPlayer().getWorld().equals(event.getTo().getWorld())) {
                    return;
                }
                event.getFrom().getChunk().load();
                event.getTo().getChunk().load();
                npc.spawn(event.getTo());
            }
        }, 1);
    }
}
 

@EventHandler(priority=EventPriority.HIGH, ignoreCancelled=true)
public void onTeleport(PlayerTeleportEvent e) {
    FileConfiguration config = this.expansion.getConfig("cheat-prevention.yml");
    if(!config.getBoolean("teleportation.prevent-teleport")) return;

    Player player = e.getPlayer();
    ICombatManager manager = this.plugin.getCombatManager();
    if(!manager.isInCombat(player)) return;

    PlayerTeleportEvent.TeleportCause cause = e.getCause();
    if(isAllowed(cause)) {
        if(cause == PlayerTeleportEvent.TeleportCause.ENDER_PEARL && config.getBoolean("teleportation.restart-timer-for-ender-pearl")) {
            manager.tag(player, null, PlayerPreTagEvent.TagType.UNKNOWN, PlayerPreTagEvent.TagReason.UNKNOWN);
        }
        return;
    }

    e.setCancelled(true);
    String message = this.plugin.getLanguageMessageColoredWithPrefix("cheat-prevention.teleportation.block-" + (cause == PlayerTeleportEvent.TeleportCause.ENDER_PEARL ? "pearl" : "other"));
    this.plugin.sendMessage(player, message);
}
 

@EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
public void onTeleport(PlayerTeleportEvent event) {
    if (event.getTo() != null || !plugin.getWorldManager().isSkyWorld(event.getTo().getWorld())) {
        return;
    }
    final Player player = event.getPlayer();
    boolean isAdmin = player.isOp() || player.hasPermission("usb.mod.bypassprotection");
    IslandInfo islandInfo = uSkyBlock.getInstance().getIslandInfo(WorldGuardHandler.getIslandNameAt(event.getTo()));
    if (!isAdmin && islandInfo != null && islandInfo.isBanned(player.getUniqueId())) {
        event.setCancelled(true);
        player.sendMessage(tr("\u00a74That player has forbidden you from teleporting to their island."));
    }
    if (!isAdmin && islandInfo != null && islandInfo.isLocked() && !islandInfo.getMembers().contains(player.getName()) && !islandInfo.isTrusted(player)) {
        event.setCancelled(true);
        player.sendMessage(tr("\u00a74That island is \u00a7clocked.\u00a7e No teleporting to the island."));
    }
    if (!event.isCancelled()) {
        final PlayerInfo playerInfo = plugin.getPlayerInfo(player);
        playerInfo.onTeleport(player);
    }
}
 

@EventHandler(priority=EventPriority.HIGHEST, ignoreCancelled=true)
public void onTeleport(PlayerTeleportEvent e) {
    ICombatLogX plugin = this.expansion.getPlugin();
    ICombatManager manager = plugin.getCombatManager();

    Player player = e.getPlayer();
    if(!manager.isInCombat(player)) return;

    LivingEntity enemy = manager.getEnemy(player);
    if(enemy == null) return;

    Location toLocation = e.getTo();
    TagType tagType = (enemy instanceof Player ? TagType.PLAYER : TagType.MOB);

    NoEntryHandler handler = this.expansion.getNoEntryHandler();
    if(!handler.isSafeZone(player, toLocation, tagType)) return;

    e.setCancelled(true);
    this.expansion.sendNoEntryMessage(player, enemy);
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerTeleport(final PlayerTeleportEvent event) {
    final Player p = event.getPlayer();
    final IPet pi = EchoPet.getManager().getPet(p);
    Iterator<IPet> i = EchoPet.getManager().getPets().iterator();
    while (i.hasNext()) {
        IPet pet = i.next();
        if (pet.getEntityPet() instanceof IEntityPacketPet && ((IEntityPacketPet) pet.getEntityPet()).hasInititiated()) {
            if (GeometryUtil.getNearbyEntities(event.getTo(), 50).contains(pet)) {
                ((IEntityPacketPet) pet.getEntityPet()).updatePosition();
            }
        }
    }
    if (pi != null) {
        if (!WorldUtil.allowPets(event.getTo())) {
            Lang.sendTo(p, Lang.PETS_DISABLED_HERE.toString().replace("%world%", WordUtils.capitalizeFully(event.getTo().getWorld().getName())));
            EchoPet.getManager().saveFileData("autosave", pi);
            EchoPet.getSqlManager().saveToDatabase(pi, false);
            EchoPet.getManager().removePet(pi, false);
        }
    }
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerTeleport(PlayerTeleportEvent event) {
    if (event.isCancelled()) {
        return;
    }

    Location from = event.getFrom();
    Location to = event.getTo();

    if (from.getWorld().equals(to.getWorld())) {
        return;
    }

    ConsoleLogger.debug("[EVENTS] Player '" + event.getPlayer().getName() + "' going from world '" + from + "' to world '" + to + "'");

    Group groupFrom = groupManager.getGroupFromWorld(from.getWorld().getName());
    Group groupTo = groupManager.getGroupFromWorld(to.getWorld().getName());

    if (groupFrom.equals(groupTo)) {
        return;
    }

    playerManager.addPlayer(event.getPlayer(), groupFrom);
    event.getPlayer().closeInventory();
}
 

@Test
public void noInteractionsSameWorld() {
    // given
    Player player = mock(Player.class);

    World worldFrom = mock(World.class);
    Location from = new Location(worldFrom, 1, 2, 3);
    Location to = new Location(worldFrom, 4, 5, 6);

    PlayerTeleportEvent event = new PlayerTeleportEvent(player, from, to);

    // when
    listener.onPlayerTeleport(event);

    // then
    verifyZeroInteractions(groupManager);
    verifyZeroInteractions(playerManager);
}
 

@Test
public void noPlayerInteractionsSameGroup() {
    // given
    Player player = mock(Player.class);

    World worldFrom = mock(World.class);
    given(worldFrom.getName()).willReturn("world");
    Location from = new Location(worldFrom, 1, 2, 3);
    World worldTo = mock(World.class);
    given(worldTo.getName()).willReturn("world_nether");
    Location to = new Location(worldTo, 4, 5, 6);

    Group group = TestHelper.mockGroup("world");
    given(groupManager.getGroupFromWorld("world")).willReturn(group);
    given(groupManager.getGroupFromWorld("world_nether")).willReturn(group);

    PlayerTeleportEvent event = new PlayerTeleportEvent(player, from, to);

    // when
    listener.onPlayerTeleport(event);

    // then
    verifyZeroInteractions(playerManager);
}
 

@Test
public void shouldAddPlayer() {
    // given
    Player player = mock(Player.class);

    World worldFrom = mock(World.class);
    given(worldFrom.getName()).willReturn("world");
    Location from = new Location(worldFrom, 1, 2, 3);
    World worldTo = mock(World.class);
    given(worldTo.getName()).willReturn("world2");
    Location to = new Location(worldTo, 4, 5, 6);

    Group groupFrom = TestHelper.mockGroup("world");
    Group groupTo = TestHelper.mockGroup("world2");
    given(groupManager.getGroupFromWorld("world")).willReturn(groupFrom);
    given(groupManager.getGroupFromWorld("world2")).willReturn(groupTo);

    PlayerTeleportEvent event = new PlayerTeleportEvent(player, from, to);

    // when
    listener.onPlayerTeleport(event);

    // then
    verify(playerManager).addPlayer(player, groupFrom);
}
 

@EventHandler(priority = EventPriority.HIGHEST)
public void onPlayerTeleport(PlayerTeleportEvent event) {
    Player player = event.getPlayer();
    if (isCitizensNPC(player)) {
        return;
    }
    GlobalPlayer dPlayer = dPlayers.get(player);

    World toWorld = event.getTo().getWorld();

    if (dPlayer instanceof InstancePlayer && ((InstancePlayer) dPlayer).getWorld() == toWorld) {
        return;
    }

    if (plugin.getInstanceWorld(toWorld) != null) {
        dPlayer.sendMessage(DMessage.ERROR_JOIN_GROUP.getMessage());
        dPlayer.sendMessage(ChatColor.GOLD + DMessage.CMD_ENTER_HELP.getMessage());
        event.setCancelled(true);
    }
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerTeleport(PlayerTeleportEvent event) {
    if (event.isCancelled()) {
        return;
    }

    Location from = event.getFrom();
    Location to = event.getTo();

    if (from.getWorld().equals(to.getWorld())) {
        return;
    }

    ConsoleLogger.debug("[EVENTS] Player '" + event.getPlayer().getName() + "' going from world '" + from + "' to world '" + to + "'");

    Group groupFrom = groupManager.getGroupFromWorld(from.getWorld().getName());
    Group groupTo = groupManager.getGroupFromWorld(to.getWorld().getName());

    if (groupFrom.equals(groupTo)) {
        return;
    }

    playerManager.addPlayer(event.getPlayer(), groupFrom);
    event.getPlayer().closeInventory();
}
 

@Test
public void noInteractionsSameWorld() {
    // given
    Player player = mock(Player.class);

    World worldFrom = mock(World.class);
    Location from = new Location(worldFrom, 1, 2, 3);
    Location to = new Location(worldFrom, 4, 5, 6);

    PlayerTeleportEvent event = new PlayerTeleportEvent(player, from, to);

    // when
    listener.onPlayerTeleport(event);

    // then
    verifyZeroInteractions(groupManager);
    verifyZeroInteractions(playerManager);
}
 

@Test
public void noPlayerInteractionsSameGroup() {
    // given
    Player player = mock(Player.class);

    World worldFrom = mock(World.class);
    given(worldFrom.getName()).willReturn("world");
    Location from = new Location(worldFrom, 1, 2, 3);
    World worldTo = mock(World.class);
    given(worldTo.getName()).willReturn("world_nether");
    Location to = new Location(worldTo, 4, 5, 6);

    Group group = TestHelper.mockGroup("world");
    given(groupManager.getGroupFromWorld("world")).willReturn(group);
    given(groupManager.getGroupFromWorld("world_nether")).willReturn(group);

    PlayerTeleportEvent event = new PlayerTeleportEvent(player, from, to);

    // when
    listener.onPlayerTeleport(event);

    // then
    verifyZeroInteractions(playerManager);
}
 

@EventHandler
public void onPlayerTeleport(PlayerTeleportEvent event) {
	if (HOLOGRAMS.isEmpty() || !event.getFrom().getWorld().equals(event.getTo().getWorld()) /* World change is handled in another event*/) {
		return;
	}
	
	List<Hologram> copy = new ArrayList<>(HOLOGRAMS);
	for (Hologram hologram : copy) {
		if (hologram.isEmpty() || !hologram.hasViewers()) {
			HOLOGRAMS.remove(hologram);
			continue;
		}
		try {
			Player player = event.getPlayer();
			List<Player> viewers = hologram.getViewers();
			Location loc = hologram.getLocation();
			if (viewers.contains(player) && player.getWorld().equals(loc.getWorld())) {
				if (event.getTo().distanceSquared(loc) < VISIBILITY_DISTANCE_SQUARED
					&& event.getFrom().distanceSquared(loc) >= VISIBILITY_DISTANCE_SQUARED) {
					hologram.update(player, hologram.getAllSpawnPackets(), false);
				} else if (event.getTo().distanceSquared(loc) >= VISIBILITY_DISTANCE_SQUARED
					&& event.getFrom().distanceSquared(loc) < VISIBILITY_DISTANCE_SQUARED) {
					hologram.update(player, Arrays.asList(hologram.getFullDestroyPacket()), false);
				}
			}
		} catch (Throwable t) {
		}
	}
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onPlayerTeleportEvent(PlayerTeleportEvent event) {
	if (event.getCause().equals(TeleportCause.COMMAND) ||
			event.getCause().equals(TeleportCause.PLUGIN)) {
		CivLog.info("[TELEPORT] "+event.getPlayer().getName()+" to:"+event.getTo().getBlockX()+","+event.getTo().getBlockY()+","+event.getTo().getBlockZ()+
				" from:"+event.getFrom().getBlockX()+","+event.getFrom().getBlockY()+","+event.getFrom().getBlockZ());
	}
}
 

/** Prevent teleporting outside the map */
@EventHandler(priority = EventPriority.HIGH)
public void onPlayerTeleport(final PlayerTeleportEvent event) {
  if (event.getCause() == PlayerTeleportEvent.TeleportCause.PLUGIN) {
    double fromY = event.getFrom().getY();
    double toY = event.getTo().getY();

    if ((fromY >= 0.0D && fromY < 255.0D) && (toY < 0.0D || toY >= 255.0D)) {
      event.setCancelled(true);
    }
  }
}
 

@EventHandler(ignoreCancelled = true)
public void onPlayerTeleport(PlayerTeleportEvent e) {

    final Player p = e.getPlayer();
    Location lfrom = e.getFrom();
    Location lto = e.getTo();

    if (e.getCause().equals(PlayerTeleportEvent.TeleportCause.CHORUS_FRUIT)) {
        final Region rfrom = RedProtect.get().rm.getTopRegion(lfrom);
        final Region rto = RedProtect.get().rm.getTopRegion(lto);

        if (rfrom != null && !rfrom.canTeleport(p)) {
            RedProtect.get().lang.sendMessage(p, "playerlistener.region.cantuse");
            e.setCancelled(true);
        }
        if (rto != null && !rto.canTeleport(p)) {
            RedProtect.get().lang.sendMessage(p, "playerlistener.region.cantuse");
            e.setCancelled(true);
        }
    }

    if (p.getInventory().getChestplate() != null &&
            p.getInventory().getChestplate().getType().equals(Material.ELYTRA) &&
            !RedProtect.get().config.globalFlagsRoot().worlds.get(lto.getWorld().getName()).player_glide.allow_elytra) {
        RedProtect.get().lang.sendMessage(p, "globallistener.elytra.cantworld");
        e.setCancelled(true);
    }
}
 

/** Prevent teleporting outside the border */
@EventHandler(priority = EventPriority.HIGH)
public void onPlayerTeleport(final PlayerTeleportEvent event) {
  if (event.getCause() == PlayerTeleportEvent.TeleportCause.PLUGIN) {
    if (WorldBorders.isInsideBorder(event.getFrom())
        && !WorldBorders.isInsideBorder(event.getTo())) {
      event.setCancelled(true);
    }
  }
}
 

@Override
public void teleportEntity(
        @NotNull Entity entity,
        @NotNull Location location,
        @Nullable PlayerTeleportEvent.TeleportCause cause) {
    if (cause == null) {
        entity.teleport(location);
    } else {
        entity.teleport(location, cause);
    }
}
 

@EventHandler
public void onPlayerTeleport(PlayerTeleportEvent event) {
	if (HOLOGRAMS.isEmpty() || !event.getFrom().getWorld().equals(event.getTo().getWorld()) /* World change is handled in another event*/) {
		return;
	}
	
	List<Hologram> copy = new ArrayList<>(HOLOGRAMS);
	for (Hologram hologram : copy) {
		if (hologram.isEmpty() || !hologram.hasViewers()) {
			HOLOGRAMS.remove(hologram);
			continue;
		}
		try {
			Player player = event.getPlayer();
			List<Player> viewers = hologram.getViewers();
			Location loc = hologram.getLocation();
			if (viewers.contains(player) && player.getWorld().equals(loc.getWorld())) {
				if (event.getTo().distanceSquared(loc) < VISIBILITY_DISTANCE_SQUARED
					&& event.getFrom().distanceSquared(loc) >= VISIBILITY_DISTANCE_SQUARED) {
					hologram.update(player, hologram.getAllSpawnPackets(), false);
				} else if (event.getTo().distanceSquared(loc) >= VISIBILITY_DISTANCE_SQUARED
					&& event.getFrom().distanceSquared(loc) < VISIBILITY_DISTANCE_SQUARED) {
					hologram.update(player, Arrays.asList(hologram.getFullDestroyPacket()), false);
				}
			}
		} catch (Throwable t) {
		}
	}
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onTeleport(PlayerTeleportEvent e) {
    Location loc = e.getTo();
    if(!loc.getWorld().isChunkLoaded(loc.getBlockX() >> 4, loc.getBlockZ() >> 4)) {
        lastBigTeleportTime.put(e.getPlayer().getUniqueId(), hawk.getHawkPlayer(e.getPlayer()).getCurrentTick());
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerMove(PlayerTeleportEvent event) {
    if (event.getPlayer().getUniqueId().equals(this.player)) {
        updateAndTeleport(event.getTo().position());
    } else {
        sendOrRemoveZombies(event.getPlayer(), event.getTo().position(), Bukkit.getPlayer(player).getLocation().position());
    }
}
 

private void tickNpcs() {
    for (NPC npc : this.npcRegistry) {
        if (!npc.isSpawned() || !npc.hasTrait(ClickableTrait.class)) continue;

        Npc helperNpc = npc.getTrait(ClickableTrait.class).npc;

        // ensure npcs stay in the same position
        Location loc = npc.getEntity().getLocation();
        if (loc.getBlockX() != helperNpc.getInitialSpawn().getBlockX() || loc.getBlockZ() != helperNpc.getInitialSpawn().getBlockZ()) {
            npc.teleport(helperNpc.getInitialSpawn().clone(), PlayerTeleportEvent.TeleportCause.PLUGIN);
        }

        // don't let players stand near npcs
        for (Entity entity : npc.getStoredLocation().getWorld().getNearbyEntities(npc.getStoredLocation(), 1.0, 1.0, 1.0)) {
            if (!(entity instanceof Player) || this.npcRegistry.isNPC(entity)) continue;

            final Player p = (Player) entity;

            if (p.getGameMode() == GameMode.CREATIVE || p.getGameMode() == GameMode.SPECTATOR) {
                continue;
            }

            if (npc.getEntity().getLocation().distance(p.getLocation()) < 3.5) {
                p.setVelocity(p.getLocation().getDirection().multiply(-0.5).setY(0.4));
            }
        }
    }
}
 

/**
 * Prevent teleporting outside the map
 */
@EventHandler(priority = EventPriority.HIGH)
public void onPlayerTeleport(final PlayerTeleportEvent event) {
    if(event.getCause() == PlayerTeleportEvent.TeleportCause.PLUGIN) {
        double fromY = event.getFrom().getY();
        double toY = event.getTo().getY();

        if((fromY >= 0.0D && fromY < 255.0D) && (toY < 0.0D || toY >= 255.0D)) {
            event.setCancelled(true);
        }
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onTeleport(PlayerTeleportEvent e) {
    if (e.getCause() == TeleportCause.ENDER_PEARL && plugin.getConfig().getBoolean("mobSpawning.endermites", true)
            && e.getTo().getWorld().getAllowMonsters()) {
        Random rand = new Random();
        if(rand.nextInt(100) < 5) {//5% probability of spawning
        	EntityEndermite ender = new EntityEndermite(((CraftWorld) e.getFrom().getWorld()).getHandle());
            ender.spawn(e.getFrom());
        }
    }
}
 

/**
 * Fire a CoarsePlayerMoveEvent that wraps the given event, only if it crosses
 * a block boundary, or the PoseFlags change.
 * @param event         The movement event to potentially wrap
 * @return True if the original event was not cancelled, and a coarse event was fired,
 *         and that coarse event was cancelled. In this case, the wrapped event won't
 *         actually be cancelled, but callers should treat it like it is.
 */
private boolean callCoarsePlayerMove(final PlayerMoveEvent event) {
    // Don't fire coarse events for teleports that are not "in-game"
    // e.g. /jumpto command
    if(event instanceof PlayerTeleportEvent) {
        PlayerTeleportEvent teleportEvent = (PlayerTeleportEvent) event;
        if(teleportEvent.getCause() != TeleportCause.ENDER_PEARL &&
           teleportEvent.getCause() != TeleportCause.UNKNOWN) {
            return false;
        }
    }

    // If the movement does not cross a block boundary, and no PoseFlags changed, we don't care about it
    final EntityLocation from = event.getEntityFrom();
    final EntityLocation to = event.getEntityTo();
    if(from.position().coarseEquals(to.position()) && from.poseFlags().equals(to.poseFlags())) {
        return false;
    }

    // Remember whether the original event was already cancelled
    boolean wasCancelled = event.isCancelled();

    CoarsePlayerMoveEvent generalEvent = new CoarsePlayerMoveEvent(event, event.getPlayer(), from, to);
    this.eventBus.callEvent(generalEvent);

    if(!wasCancelled && generalEvent.isCancelled()) {
        // When a coarse event is cancelled, we have our own logic for resetting the
        // player's position, so we un-cancel the event and instead modify its
        // to location to put the player where we want them.
        resetPosition(event);
        return true;
    } else {
        return false;
    }
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onTeleport(PlayerTeleportEvent event) {
    if (event.getCause() == PlayerTeleportEvent.TeleportCause.UNKNOWN) {
        return;
    }
    Player p = event.getPlayer();
    // The player will either quit, die, or close the inventory at some point
    if (plugin.getInVault().containsKey(p.getUniqueId().toString())) {
        return;
    }
    saveVault(p, p.getOpenInventory().getTopInventory());
}
 

@EventHandler(ignoreCancelled = true) @SuppressWarnings("unused")
public void onPlayerTeleport(PlayerTeleportEvent event) {
    Player player = event.getPlayer();
    Civilian civilian = CivilianManager.getInstance().getCivilian(player.getUniqueId());

    if (!ConfigManager.getInstance().isAllowTeleportInCombat()) {
        if (civilian.isInCombat()) {
            event.setCancelled(true);
            player.sendMessage(Civs.getPrefix() + LocaleManager.getInstance().getTranslationWithPlaceholders(player,
                    "in-combat"));
            return;
        }
    }

    if (!ConfigManager.getInstance().isAllowTeleportingOutOfHostileTowns()) {
        Town town = TownManager.getInstance().getTownAt(event.getFrom());
        if (town != null && !town.getPeople().containsKey(player.getUniqueId())) {
            Region region = RegionManager.getInstance().getRegionAt(event.getTo());
            if (region == null || !region.getEffects().containsKey("bypass_hostile_port")) {
                event.setCancelled(true);
                player.sendMessage(Civs.getPrefix() + LocaleManager.getInstance().getTranslationWithPlaceholders(player,
                        "no-tp-out-of-town"));
                return;
            }
        }
    }
}