@EventHandler
public void onWorldChange(PlayerChangedWorldEvent event) {
	if (HOLOGRAMS.isEmpty()) {
		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())
				&& !event.getFrom().equals(loc.getWorld())) {
				if (player.getLocation().distanceSquared(loc) < VISIBILITY_DISTANCE_SQUARED) {
					hologram.update(player, hologram.getAllSpawnPackets(), false);
				}
			}
		} catch (Throwable t) {
		}
	}
}
 

@EventHandler
public void onWorldChange(PlayerChangedWorldEvent event) {
	if (HOLOGRAMS.isEmpty()) {
		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())
				&& !event.getFrom().equals(loc.getWorld())) {
				if (player.getLocation().distanceSquared(loc) < VISIBILITY_DISTANCE_SQUARED) {
					hologram.update(player, hologram.getAllSpawnPackets(), false);
				}
			}
		} catch (Throwable t) {
		}
	}
}
 

@EventHandler
public void onWorldChange(PlayerChangedWorldEvent event) {
    final Player p = event.getPlayer();
    final IPet pi = EchoPet.getManager().getPet(p);
    if (pi != null) {
        EchoPet.getManager().saveFileData("autosave", pi);
        EchoPet.getSqlManager().saveToDatabase(pi, false);
        EchoPet.getManager().removePet(pi, false);
        new BukkitRunnable() {

            @Override
            public void run() {
                EchoPet.getManager().loadPets(p, false, false, false);
            }

        }.runTaskLater(EchoPet.getPlugin(), 20L);
    }
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onWorldChange(PlayerChangedWorldEvent e) {
    try {
        final Player p = e.getPlayer();
        if (!plugin.getVanishStateMgr().isVanished(p.getUniqueId()))
            return;
        // check auto-reappear option
        if (plugin.getSettings().getBoolean("VanishStateFeatures.ReappearOnWorldChange")
                || plugin.getSettings().getBoolean("VanishStateFeatures.CheckPermissionOnWorldChange")
                && !CommandAction.VANISH_SELF.checkPermission(p, plugin)) {
            plugin.getVisibilityChanger().showPlayer(p);
        }
    } catch (Exception er) {
        plugin.logException(er);
    }
}
 

@EventHandler
public void onWorldChange(PlayerChangedWorldEvent event) {
    if (!this.worlds.contains(event.getPlayer().getWorld().getName())) return;
    if (!this.items.containsKey(event.getPlayer().getWorld().getName())) return;
    if (!this.worldChange.get(event.getPlayer().getWorld().getName())) return;
    if (this.clearInventory.get(event.getPlayer().getWorld().getName())) {
        event.getPlayer().getInventory().clear();
    }
    this.items.get(event.getPlayer().getWorld().getName()).forEach(id -> {
        CustomItem item = HubBasics.getItemManager().get(id);
        if (item == null) return;
        if (item.getPermission() != null && !event.getPlayer().hasPermission(item.getPermission())) return;
        this.removeItem(item, event.getPlayer().getInventory());
        if (item.getSlot() == null || item.getSlot() == -1) {
            event.getPlayer().getInventory().addItem(item.toItemStack(event.getPlayer()));
        } else {
            event.getPlayer().getInventory().setItem(item.getSlot(), item.toItemStack(event.getPlayer()));
        }
    });
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onWorldChange(PlayerChangedWorldEvent event) {
    final Player player = event.getPlayer();
    for (final Hologram h : HoloAPI.getManager().getAllHolograms().keySet()) {
        if (player.getLocation().getWorld().getName().equals(h.getWorldName()) && h.getVisibility().isVisibleTo(player, h.getSaveId())) {
            if (h instanceof AnimatedHologram && !((AnimatedHologram) h).isAnimating()) {
                ((AnimatedHologram) h).animate();
            }
            h.show(player, true);
        } else if (event.getFrom().getName().equals(h.getWorldName()) && h.getLocationFor(player) != null) {
            new BukkitRunnable() {
                @Override
                public void run() {
                    h.clear(player);
                }
            }.runTaskLater(HoloAPI.getCore(), 20L);
        }
    }
}
 

/**
 * Check if the player moves in a scoreboard disabled world
 *
 * @param worldChange the teleport event
 * @see com.github.games647.scoreboardstats.RefreshTask
 */
//ignore cancelled events
@EventHandler(ignoreCancelled = true, priority = EventPriority.HIGH)
public void onWorldChange(PlayerChangedWorldEvent worldChange) {
    Player player = worldChange.getPlayer();
    //new world
    if (Settings.isActiveWorld(player.getWorld().getName())) {
        //old world
        if (!Settings.isActiveWorld(worldChange.getFrom().getName())) {
            //Activate the scoreboard if it was disabled
            plugin.getRefreshTask().addToQueue(player);
        }
    } else {
        //Disable the scoreboard if the player goes into a disabled world
        plugin.getRefreshTask().remove(player);
        plugin.getScoreboardManager().unregister(player);
    }
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void a(PlayerChangedWorldEvent e){
	try {
		if (Shared.disabled) return;
		if (Configs.bukkitBridgeMode) return;
		ITabPlayer p = Shared.getPlayer(e.getPlayer().getUniqueId());
		if (p == null) return;
		p.onWorldChange(e.getFrom().getName(), p.world = e.getPlayer().getWorld().getName());
	} catch (Throwable t) {
		Shared.errorManager.printError("An error occurred when processing PlayerChangedWorldEvent", t);
	}
}
 

/**
 * Track a player's current world
 * - This information is needed when players go offline, but have planted saplings,
 * left furnaces running or have active bounties
 */
@EventHandler(ignoreCancelled = true)
public void onPlayerChangedWorldEvent(PlayerChangedWorldEvent event) {
    //Update the player's world:
    PlayerTable playerTable = gw.getTableManager().getPlayerTable();
    GPlayer gPlayer = playerTable.getPlayers().get(event.getPlayer().getUniqueId());
    gPlayer.setWorldId(event.getPlayer().getWorld().getUID());

    //Database update:
    PlayerUpdateQuery updateQuery = new PlayerUpdateQuery(gPlayer);
    AsyncDBQueue.getInstance().queueUpdateQuery(updateQuery);
}
 

@EventHandler
public void onPlayerChangedWorld(PlayerChangedWorldEvent e){
	GameManager gm = GameManager.getGameManager();
	Player player = e.getPlayer();

	if (gm.getConfiguration().getEnableTheEnd() && e.getFrom().getName().equals(gm.getConfiguration().getTheEndUuid())){
		World world = Bukkit.getServer().getWorld(gm.getConfiguration().getOverworldUuid());

		double maxDistance = 0.9 * gm.getWorldBorder().getCurrentSize();
		Location loc = gm.getPlayersManager().findRandomSafeLocation(world, maxDistance);

		player.teleport(loc);
	}
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onWorldChange(PlayerChangedWorldEvent event) {
    try {
        actOnEvent(event);
    } catch (Exception e) {
        errorLogger.log(L.ERROR, e, ErrorContext.builder().related(event).build());
    }
}
 

private void actOnEvent(PlayerChangedWorldEvent event) {
    long time = System.currentTimeMillis();

    Player player = event.getPlayer();
    UUID uuid = player.getUniqueId();

    String worldName = player.getWorld().getName();
    String gameMode = player.getGameMode().name();

    dbSystem.getDatabase().executeTransaction(new WorldNameStoreTransaction(serverInfo.getServerUUID(), worldName));
    worldAliasSettings.addWorld(worldName);

    Optional<Session> cachedSession = SessionCache.getCachedSession(uuid);
    cachedSession.ifPresent(session -> session.changeState(worldName, gameMode, time));
}
 

@EventHandler
public void onWorldChange(final PlayerChangedWorldEvent event)
{
    final User user = UserManager.getUser(event.getPlayer().getUniqueId());

    if (user != null) {
        user.getTimestampMap().nullifyTimeStamp(TimestampKey.INVENTORY_OPENED);
        user.getTimestampMap().updateTimeStamps(TimestampKey.LAST_TELEPORT, TimestampKey.LAST_WORLD_CHANGE);
    }
}
 

/**
 * Some users may have different permissions per world.
 * If this is enabled, their tag will be reloaded on TP.
 */
@EventHandler
public void onTeleport(final PlayerChangedWorldEvent event) {
    if (!refreshTagOnWorldChange) return;

    new BukkitRunnable() {
        @Override
        public void run() {
            applyTagToPlayer(event.getPlayer(), false);
        }
    }.runTaskLater(plugin, 3);
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onPlayerChangedWorldEvent(PlayerChangedWorldEvent event)
{
	Player player = event.getPlayer();
	
	if (player.getGameMode() != GameMode.CREATIVE && !this.essentialsPlugin.getUser(player).isAuthorized("essentials.fly"))
	{
		//Essentials now turns off flight, fuck him
		Boolean value = this.plugin.getWorldGuardCommunicator().getSessionManager().get(player).getHandler(FlyFlagHandler.class).getCurrentValue();
		if (value != null)
		{
			player.setAllowFlight(value);
		}
	}
}
 

@EventHandler
public void onPlayerChangedWorld(PlayerChangedWorldEvent e) {
    Player player = e.getPlayer();

    plugin.getPlayerInfosSafe(player).ifPresent(infos -> {
        plugin.updateHoldingSelectionItem(infos);

        infos.getEnabledVisualizations().forEach(PlayerSelection::resetSelection);
        plugin.getWorldEditHelper().updatePlayerVisualizations(infos);
    });
}
 

/**
 * Begins the process of a player changing worlds.
 *
 * @param event The called {@link PlayerChangedWorldEvent}.
 */
public void preProcessWorldChange(PlayerChangedWorldEvent event) {
    Player player = event.getPlayer();
    String worldFrom = event.getFrom().getName();
    String worldTo = player.getWorld().getName();
    Group groupFrom = groupManager.getGroupFromWorld(worldFrom);
    Group groupTo = groupManager.getGroupFromWorld(worldTo);

    processWorldChange(player, groupFrom, groupTo);
}
 

@EventHandler
public void onWorldChange(PlayerChangedWorldEvent e) {
    Player p = e.getPlayer();
    if (!plugin.getVanishStateMgr().isVanished(p.getUniqueId()))
        return;
    sendAddPotionEffect(p, new PotionEffect(PotionEffectType.NIGHT_VISION,
            INFINITE_POTION_EFFECT_LENGTH, 0));
}
 

@EventHandler
public void onSwitchWorld(PlayerChangedWorldEvent change) {
  Game game = BedwarsRel.getInstance().getGameManager().getGameOfPlayer(change.getPlayer());
  if (game != null) {
    if (game.getState() == GameState.RUNNING) {
      if (!game.getCycle().isEndGameRunning()) {
        if (!game.getPlayerSettings(change.getPlayer()).isTeleporting()) {
          game.playerLeave(change.getPlayer(), false);
        } else {
          game.getPlayerSettings(change.getPlayer()).setTeleporting(false);
        }
      }
    } else if (game.getState() == GameState.WAITING) {
      if (!game.getPlayerSettings(change.getPlayer()).isTeleporting()) {
        game.playerLeave(change.getPlayer(), false);
      } else {
        game.getPlayerSettings(change.getPlayer()).setTeleporting(false);
      }
    }
  }

  if (!BedwarsRel.getInstance().isHologramsEnabled()
      || BedwarsRel.getInstance().getHolographicInteractor() == null) {
    return;
  }

  BedwarsRel.getInstance().getHolographicInteractor().updateHolograms(change.getPlayer());
}
 

/**
 * Begins the process of a player changing worlds.
 *
 * @param event The called {@link PlayerChangedWorldEvent}.
 */
public void preProcessWorldChange(PlayerChangedWorldEvent event) {
    Player player = event.getPlayer();
    String worldFrom = event.getFrom().getName();
    String worldTo = player.getWorld().getName();
    Group groupFrom = groupManager.getGroupFromWorld(worldFrom);
    Group groupTo = groupManager.getGroupFromWorld(worldTo);

    processWorldChange(player, groupFrom, groupTo);
}
 

@EventHandler
public void onWorld(PlayerChangedWorldEvent event) {
    World world = event.getPlayer().getWorld();
    BossBarMessage bbm = getBossBar(world.getName(), getPointer(world.getName()));
    if (bbm != null) {
        this.setBossBar(event.getPlayer(), bbm.toBossBar(event.getPlayer()));
    }
}
 

@EventHandler
public void onChange(PlayerChangedWorldEvent event) {
    if (this.worldMessages.containsKey(event.getPlayer().getWorld().getName())) {
        HubBasics.getMessenger().send(event.getPlayer().getWorld(),
                PlaceHolderUtil.replace(event.getPlayer(), this.worldMessages.get(event.getPlayer().getWorld().getName())));
    }
}
 

@EventHandler(priority = EventPriority.NORMAL, ignoreCancelled=true)
public void onWorldEnter(final PlayerChangedWorldEvent event) {
    if (DEBUG)
        plugin.getLogger().info("DEBUG " + event.getEventName());
    if (!event.getPlayer().getWorld().equals(ASkyBlock.getIslandWorld()) &&
            !event.getPlayer().getWorld().equals(ASkyBlock.getNetherWorld())) {
        return;
    }
    if (DEBUG)
        plugin.getLogger().info("DEBUG correct world");
    Location islandLoc = plugin.getPlayers().getIslandLocation(event.getPlayer().getUniqueId());
    if (islandLoc == null) {
        if (DEBUG)
            plugin.getLogger().info("DEBUG  no island");
        // They have no island
        if (Settings.makeIslandIfNone || Settings.immediateTeleport) {
            event.getPlayer().performCommand(Settings.ISLANDCOMMAND);
        }
        if (DEBUG)
            plugin.getLogger().info("DEBUG Make island");
    } else {
        // They have an island and are going to their own world
        if (Settings.immediateTeleport && islandLoc.getWorld().equals(event.getPlayer().getWorld())) {
            if (DEBUG)
                plugin.getLogger().info("DEBUG teleport");
            event.getPlayer().performCommand(Settings.ISLANDCOMMAND + " go");
        }
    }
}
 

@EventHandler(priority = EventPriority.LOWEST)
public void onChangedWorld(PlayerChangedWorldEvent e)
{
    BukkitPlugin.getInstance().getNotifier().sendWorldUpdate(e.getPlayer());

    User u = config.isUseUUIDs() ? pm().getUser(e.getPlayer().getUniqueId()) : pm().getUser(e.getPlayer().getName());
    updateAttachment(e.getPlayer(), u);
}
 

protected void onWorldChange(PlayerChangedWorldEvent event) {
  if (this.viewer == event.getPlayer()) this.respawnFakeEntities();
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onWorldChange(PlayerChangedWorldEvent event) {
  TabView view = this.getViewOrNull(event.getPlayer());
  if (view != null) view.onWorldChange(event);
}
 

@EventHandler(priority = EventPriority.MONITOR)
public void onWorldChange(PlayerChangedWorldEvent e) {
    lastBigTeleportTime.put(e.getPlayer().getUniqueId(), hawk.getHawkPlayer(e.getPlayer()).getCurrentTick());
}
 

protected void onWorldChange(PlayerChangedWorldEvent event) {
    if(viewer.equals(event.getPlayer())) this.respawnFakeEntities();
}
 

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onWorldChange(PlayerChangedWorldEvent event) {
    TabView view = this.getViewOrNull(event.getPlayer());
    if(view != null) view.onWorldChange(event);
}
 

@EventHandler
public void onWorldChange(PlayerChangedWorldEvent e) {
    //make sure that all duct that were visible to the player get removed so they will spawn again when the player is nearby
    globalDuctManager.getPlayerDucts(e.getPlayer()).clear();
    ((PipeManager) (DuctManager<? extends Duct>) ductRegister.baseDuctTypeOf("pipe").getDuctManager()).getPlayerPipeItems(e.getPlayer()).clear();
}