Java 类org.bukkit.event.world.ChunkUnloadEvent 实例源码

@EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
public void onChunkUnload(ChunkUnloadEvent e) {
    if (!cm.removeEntityWhenChunkUnload) {
        return;
    }
    for (Entity entity : e.getChunk().getEntities()) {
        if (NeverLagUtils.checkCustomNpc(entity)) {
            continue;
        }
        if (entity instanceof Monster && cm.removeMonsterWhenChunkUnload) {
            entity.remove();
        } else if (entity instanceof Animals && cm.removeAnimalsWhenChunkUnload) {
            entity.remove();
        } else if (entity instanceof Item && cm.removeItemWhenChunkUnload) {
            entity.remove();
        } else if (entity instanceof Arrow && cm.removeArrowWhenChunkUnload) {
            entity.remove();
        } else if (entity instanceof Squid && cm.removeSquidWhenChunkUnload) {
            entity.remove();
        }
    }
}

@EventHandler
public void onChunkUnload(ChunkUnloadEvent e) {
    if (QuestManagerPlugin.questManagerPlugin.getPluginConfiguration().getWorlds().contains(
            e.getWorld().getName()))
    for (Entity entity : e.getChunk().getEntities()) {
        for (NPC npc : questNPCs) {

            //if (npc.getEntity().getCustomName() != null &&
            if (npc.getName() != null &&
                    //npc.getEntity().getCustomName().equals(entity.getCustomName()))
                    npc.getName().equals(entity.getCustomName()))
            if (npc.getID().equals(entity.getUniqueId())) {
                return;
            }
        }
        if (entity instanceof LivingEntity) {
            LivingEntity live = (LivingEntity) entity;
            QuestManagerPlugin.questManagerPlugin.getEnemyManager().removeEntity(live);
            entity.remove();
        }
    }
}

/**
 * Prevent chunk that contain pearls from unloading
 * @param e The event args
 */
@EventHandler(priority=EventPriority.HIGH, ignoreCancelled = true)
public void onChunkUnload(ChunkUnloadEvent e) {
    Chunk chunk = e.getChunk();
    for (Entity entity : chunk.getEntities()) {
        if (!(entity instanceof Item)) {
            continue;
        }

        Item item = (Item)entity;
        ExilePearl pearl = pearlApi.getPearlFromItemStack(item.getItemStack());

        if (pearl != null) {
            e.setCancelled(true);
            pearlApi.log("Prevented chunk (%d, %d) from unloading because it contained an exile pearl for player %s.", chunk.getX(), chunk.getZ(), pearl.getPlayerName());
        }
    }
}

@EventHandler(priority = EventPriority.MONITOR)
public void OnChunkUnload(ChunkUnloadEvent event) {

    BonusGoodie goodie;

    for (Entity entity : event.getChunk().getEntities()) {
        if (!(entity instanceof Item)) {
            continue;
        }

        goodie = CivGlobal.getBonusGoodie(((Item)entity).getItemStack());
        if (goodie == null) {
            continue;
        }

        goodie.replenish(((Item)entity).getItemStack(), (Item)entity, null, null);
    }
}

@EventHandler(priority = EventPriority.HIGH)
public void onChunkUnload(ChunkUnloadEvent event) {
    Entity[] entitiesInChunk = event.getChunk().getEntities();
    if (entitiesInChunk.length == 0)
        return;

    List<EntityType> passives = Settings.getAllPassives();
    List<EntityType> hostiles = Settings.getAllHostiles();

    for (Entity e : entitiesInChunk) {
        if ((hostiles != null && hostiles.contains(e.getType())
                || (passives != null && passives.contains(e.getType())))) {
            LivingEntity le = (LivingEntity) e;
            if ((le.getCustomName() == null) && (!le.isCustomNameVisible())) {
                le.remove();
            }
        } else if (e.getType() == EntityType.WITHER_SKULL) {
            e.remove();
        }
    }
}

@EventHandler(priority = EventPriority.HIGHEST)
public void onChunkUnload(ChunkUnloadEvent event)
{
    if(!event.isCancelled())
    {
        Chunk chunk = event.getChunk();

        for(Machine machine : SQTechBase.machines)
        {
            if(machine.getMachineType() instanceof Harvester)
            {
                if(machine.getGUIBlock().getLocation().getChunk() == chunk)
                {
                    main.setInactive(machine);
                    machine.data.put("blocked", false);
                }
            }
        }
    }
}

@EventHandler(priority = EventPriority.HIGHEST)
public void onChunkUnload(ChunkUnloadEvent event)
{
    if(!event.isCancelled())
    {
        Chunk chunk = event.getChunk();

        for(Machine machine : SQTechBase.machines)
        {
            if(machine.getMachineType().name == "Drill")
            {
                if(machine.getGUIBlock().getLocation().getChunk() == chunk)
                {
                    machine.data.put("isActive", false);
                    machine.data.put("blocked", false);
                }
            }
        }
    }
}

@EventHandler(priority = EventPriority.NORMAL)
public void onChunkUnloaded(ChunkUnloadEvent event) {
    Chunk c = event.getChunk();

    Entity[] entities = c.getEntities();

    for(Entity e: entities){
        if (this.manager.isHorse(e))
        {
            if (this.manager.isOwned(e.getUniqueId()))
            {
                // We save horse location
                Location loc = e.getLocation();
                this.data.getHorsesData().set("horses."+e.getUniqueId()+".lastpos",loc.getWorld().getName()+":"+loc.getX()+":"+loc.getY()+":"+loc.getZ()+":"+loc.getYaw()+":"+loc.getPitch());

                this.data.save();
            }
        }
    }
}

@EventHandler
public void onChunkUnload(ChunkUnloadEvent event) {
    if (ignoreUnload) {
        return;
    }
    if (Settings.Chunk_Processor.AUTO_TRIM) {
        Chunk chunk = event.getChunk();
        String world = chunk.getWorld().getName();
        if (PS.get().hasPlotArea(world)) {
            if (unloadChunk(world, chunk, true)) {
                return;
            }
        }
    }
    if (processChunk(event.getChunk(), true)) {
        event.setCancelled(true);
    }
}

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onChunkUnload(ChunkUnloadEvent event)
{
    final Chunk c = event.getChunk();
    for(Entity entity : c.getEntities())
    {
        if(!(entity instanceof LivingEntity))
            continue;

        RemoteEntity rentity = RemoteEntities.getRemoteEntityFromEntity((LivingEntity)entity);
        if(rentity != null && rentity.isSpawned())
        {
            m_toSpawn.add(new EntityLoadData(rentity, entity.getLocation()));
            rentity.despawn(DespawnReason.CHUNK_UNLOAD);
        }
    }
}

@EventHandler(priority = EventPriority.MONITOR)
private void onChunkUnload(ChunkUnloadEvent cue) {
  Chunk chunk = cue.getChunk();
  ConfigurationSection config = configs.get(cue.getChunk());
  if(config != null && config.isConfigurationSection("blocks")) {
    ConfigurationSection blocks = config.getConfigurationSection("blocks");
    for(Map.Entry<String, Object> entry : blocks.getValues(false).entrySet()) {
      ConfigurationSection section = (ConfigurationSection) entry.getValue();
      String[] locationParts = entry.getKey().split(" ");
      int[] locationValues = new int[3];
      for(int i = 0; i < 3; i++) {
        locationValues[i] = Integer.parseInt(locationParts[i]);
      }
      BlockConfigUnloadEvent event = new BlockConfigUnloadEvent(plugin, section, cue.getChunk().getBlock(locationValues[0], locationValues[2], locationValues[2]));
      Bukkit.getPluginManager().callEvent(event);
    }
  }
  saveConfig(cue.getChunk());
  configs.remove(chunk);
  blockConfigs.remove(chunk);
}

/**
 * Remove the unloaded EnderDragons from the loaded set
 *
 * @param event a Chunk Unload Event
 */
@EventHandler(priority = EventPriority.NORMAL)
public void onEndChunkUnload(final ChunkUnloadEvent event) {
    if (event.getWorld().getEnvironment() == Environment.THE_END) {
        final String worldName = event.getWorld().getName();
        final EndWorldHandler handler = this.plugin.getHandler(StringUtil.toLowerCamelCase(worldName));
        if (handler != null) {
            EndChunk chunk = handler.getChunks().getChunk(event.getChunk());
            if (chunk == null) {
                chunk = handler.getChunks().addChunk(event.getChunk());
            }
            for (final Entity e : event.getChunk().getEntities()) {
                if (e.getType() == EntityType.ENDER_DRAGON) {
                    final EnderDragon ed = (EnderDragon)e;
                    handler.getLoadedDragons().remove(ed.getUniqueId());
                    chunk.incrementSavedDragons();
                }
            }
        }
    }
}

@EventHandler
public void onChunkProtect(ChunkUnloadEvent e) {
    for(Entity entity : e.getChunk().getEntities()) {
        if(entity instanceof WitherSkull) {
            WitherSkull wither = (WitherSkull) entity;
            if(pl.getConfiguration().getDebugConfig().isEnabled()) {
                xEssentials.log("removed wither skull at: {" + wither.getWorld().getName() + ", " + wither.getLocation().getBlockX() + ", " + wither.getLocation().getBlockY() + ", " + wither.getLocation().getBlockZ() + "} to prevent lag", LogType.INFO);
            }
            wither.remove();
        } else if(entity instanceof Fireball) {
            Fireball fb = (Fireball) entity;
            if(pl.getConfiguration().getDebugConfig().isEnabled()) {
                xEssentials.log("removed fireball at: {" + fb.getWorld().getName() + ", " + fb.getLocation().getBlockX() + ", " + fb.getLocation().getBlockY() + ", " + fb.getLocation().getBlockZ() + "} to prevent lag", LogType.INFO);
            }
            fb.remove();
        }
    }
}

@EventHandler
public void onChunkUnload(ChunkUnloadEvent event) {
    ArrayList<Entity> toRemove = new ArrayList<Entity>();
    for (Entity e : event.getChunk().getEntities()) {
        EffectHolder holder = EffectManager.getInstance().getEffect(e.getUniqueId());
        if (holder != null) {
            EffectManager.getInstance().clear(holder);
            continue;
        }

        if (e instanceof Item && ItemSpray.UUID_LIST.contains(e.getUniqueId())) {
            toRemove.add(e);
        }
    }
    if (!toRemove.isEmpty()) {
        Iterator<Entity> i = toRemove.iterator();
        while (i.hasNext()) {
            i.next().remove();
        }
    }
}

@EventHandler
public void onUnload(ChunkUnloadEvent event) {
    Chunk unloadedChunk = event.getChunk();
    for (Entity entity : unloadedChunk.getEntities()) {
        if (entity instanceof LivingEntity) {
            Object handle = BukkitUnwrapper.getInstance().unwrap(entity);
            if (handle instanceof ControllableEntityHandle) {
                ControllableEntity controllableEntity = ((ControllableEntityHandle) handle).getControllableEntity();
                if (controllableEntity != null && controllableEntity.isSpawned()) {
                    this.SPAWN_QUEUE.add(new EntityChunkData(controllableEntity, entity.getLocation()));
                    controllableEntity.despawn(DespawnReason.CHUNK_UNLOAD);
                }
            }
        }
    }
}

/**
 * Marks a loaded chunk as pending unload. It'll be unloaded later en-masse.
 * 
 * @param e The chunk to unload.
 */
@EventHandler(ignoreCancelled = true)
public void onChunkUnload(ChunkUnloadEvent e) {
    Chunk chunk = e.getChunk();

    CropControl.getDAO().unloadChunk(chunk);
}

@EventHandler(priority=EventPriority.MONITOR, ignoreCancelled = true)
public void onChunkUnload(ChunkUnloadEvent event) {
    Chunk chunk = event.getChunk();
    ChunkReloader.addUnloadedChunk(event.getWorld(), chunk.getX(), chunk.getZ());

    //Orebfuscator.log("Chunk x = " + chunk.getX() + ", z = " + chunk.getZ() + " is unloaded");/*debug*/
}

@EventHandler
public void ChunkloadClear(ChunkUnloadEvent event) {
    if (ConfigOptimize.UnloadClearenable != true) {
        return;
    }
    Chunk chunk = event.getChunk();
    boolean noclearitemchunk = false;
    int dcs = DeathChunk.size();
    for (int i = 0; i < dcs; i++) {
        Chunk deathchunk = DeathChunk.get(i);
        if (Utils.isSameChunk(chunk, deathchunk)) {
            DeathChunk.remove(chunk);
            noclearitemchunk = true;
            break;
        }
    }
    Entity[] entities = chunk.getEntities();
    for (int i = 0; i < entities.length; i++) {
        Entity ent = entities[i];
        if (ent.getType() == EntityType.DROPPED_ITEM && noclearitemchunk == false && ConfigOptimize.UnloadClearDROPPED_ITEMenable) {
            ent.remove();
        }
        if(ConfigOptimize.UnloadCleartype.contains(ent.getType().name())||ConfigOptimize.UnloadCleartype.contains("*")) {
            ent.remove();
        }
    }
}

/**
 * This eliminates pending bullets on chunk unload
 * 
 * @param event
 */
@EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
public void chunkUnloadClearBullets(ChunkUnloadEvent event) {
    if (event.getChunk() == null) return;
    Entity[] entities = event.getChunk().getEntities();
    for (Entity e : entities) {
        if (inFlightBullets.containsKey(e.getUniqueId())) {
            inFlightBullets.remove(e.getUniqueId());
            travelPaths.remove(e.getUniqueId());
            e.remove();
        }
    }
}

/**
 * Save unloaded chunk
 *
 * @param event Event
 */
@EventHandler
public void onChunkUnload(ChunkUnloadEvent event)
{
    for (Entity entity : event.getChunk().getEntities())
        if (!(entity instanceof Item || entity instanceof HumanEntity || entity instanceof Minecart))
            entity.remove();

    //event.setCancelled(true);
}

@EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
public void onUnloadChunk(ChunkUnloadEvent e) {
    if (!cm.hotChunkEnabled || NeverLag.getTpsWatcher().getAverageTPS() < cm.hotChunkTpsThreshold) {
        return;
    }
    ChunkInfo chunkInfo = new ChunkInfo(e.getChunk());
    if (hotChunkRecord.contains(chunkInfo)) {
        e.setCancelled(true);
        this.addHotChunkUnloadCount(chunkInfo);
    }
}

@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onUnloadChunkMonitor(ChunkUnloadEvent e) {
    if (!cm.hotChunkEnabled || NeverLag.getTpsWatcher().getAverageTPS() < cm.hotChunkTpsThreshold) {
        return;
    }
    ChunkInfo chunkInfo = new ChunkInfo(e.getChunk());
    chunkUnLoadTime.put(chunkInfo, System.currentTimeMillis());
}

@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
public void onChunkUnloadEvent(ChunkUnloadEvent event)
{
    for (ProtectedRegion region : WorldGuardExtraFlagsPlugin.getWorldGuardPlugin().getRegionManager(event.getWorld()).getApplicableRegions(new ProtectedCuboidRegion("UnloadChunkFlagTester", new BlockVector(event.getChunk().getX() * 16, 0, event.getChunk().getZ() * 16), new BlockVector(event.getChunk().getX() * 16 + 15, 256, event.getChunk().getZ() * 16 + 15))))
    {
        if (region.getFlag(FlagUtils.CHUNK_UNLOAD) == State.DENY)
        {
            event.setCancelled(true);
            break;
        }
    }
}

@EventHandler
public void onChunkUnloadEvent(final ChunkUnloadEvent event) {
    mrg.debug("ChunkUnloadEvent " + event.getChunk().getX() + " " + event.getChunk().getZ());

    if (chunkTasks.containsKey(event.getChunk())) {
        chunkTasks.remove(event.getChunk()).cancel();
    }

    if (CubitBukkitPlugin.inst().getYamlManager().getLimit().check_chunk_unload) {
        mrg.checkChunk(event.getChunk(), null);
    }
}

@HookHandler(priority = Priority.CRITICAL, ignoreCanceled = true)
public void onChunkUnload(final ChunkUnloadHook hook) {
    ChunkUnloadEvent event =
            new ChunkUnloadEvent(new CanaryChunk(hook.getChunk(), new CanaryWorld(hook.getWorld())));
    event.setCancelled(hook.isCanceled());
    server.getPluginManager().callEvent(event);
    if (event.isCancelled()) {
        hook.setCanceled();
    }
}

@EventHandler
public void onUnload(ChunkUnloadEvent unload) {
  Game game = BedwarsRel.getInstance().getGameManager()
      .getGameByChunkLocation(unload.getChunk().getX(),
          unload.getChunk().getZ());
  if (game == null) {
    return;
  }

  if (game.getState() != GameState.RUNNING) {
    return;
  }

  unload.setCancelled(true);
}

@EventHandler
public static void onChunkUnload(ChunkUnloadEvent event) {
    Chunk chunk = event.getChunk();
    long pair = MathMan.pairInt(chunk.getX(), chunk.getZ());
    Long lastLoad = keepLoaded.get(pair);
    if (lastLoad != null) {
        if (Fawe.get().getTimer().getTickStart() - lastLoad < 10000) {
            event.setCancelled(true);
        } else {
            keepLoaded.remove(pair);
        }
    }
}

@EventHandler
public void onChunkUnload(ChunkUnloadEvent event) {

    /* Do not let chunks containing entities about to be teleported unload */
    for (Entity entity : event.getChunk().getEntities()) {
        if (Portals.justTeleportedEntities.contains(entity.getUniqueId())) {
            event.setCancelled(true);
        }   
    }

}

@EventHandler(priority = EventPriority.HIGH)
public void onChunkUnloadEvent(ChunkUnloadEvent event) {
    Boolean persist = CivGlobal.isPersistChunk(event.getChunk());       
    if (persist != null && persist == true) {
        event.setCancelled(true);
    }
}

public boolean unloadChunks() {
    if (!this.world.savingDisabled) {
        // CraftBukkit start
        Server server = this.world.getServer();
        for (int i = 0; i < 100 && !this.unloadQueue.isEmpty(); i++) {
            long chunkcoordinates = this.unloadQueue.popFirst();
            Chunk chunk = this.chunks.get(chunkcoordinates);
            if (chunk == null) continue;
            // Almura - Remove the chunk from cache if it is unloaded
            Chunk result = world.lastChunkAccessed;
            if (result != null && result.x == chunk.x && result.z == chunk.z) {
                world.lastChunkAccessed = null;
            }
            // Almura end

            ChunkUnloadEvent event = new ChunkUnloadEvent(chunk.bukkitChunk);
            server.getPluginManager().callEvent(event);
            if (!event.isCancelled()) {
                chunk.removeEntities();
                this.saveChunk(chunk);
                this.saveChunkNOP(chunk);
                // this.unloadQueue.remove(integer);
                this.chunks.remove(chunkcoordinates); // CraftBukkit
            }
        }
        // CraftBukkit end

        if (this.e != null) {
            this.e.a();
        }
    }

    return this.chunkProvider.unloadChunks();
}

/**
 * Monitor ChunkUnload events.
 *
 * @param event The event to watch
 */
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onChunkUnload(ChunkUnloadEvent event) {
    Chunk chunk = event.getChunk();

    mcMMO.getPlaceStore().chunkUnloaded(chunk.getX(), chunk.getZ(), event.getWorld());
}

@EventHandler(priority = EventPriority.HIGHEST)
public void onChunkUnload(ChunkUnloadEvent event)
{
    for (Entity entity : event.getChunk().getEntities())
    {
        if (entity.getUniqueId().equals(plugin.getLegendaryEntityId()))
        {
            entity.remove();
            plugin.removeLegendary();
        }
    }
}

/**
 * Handle chunk unload
 */
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
private void onChunkUnload(ChunkUnloadEvent event) {

    Entity[] entities = event.getChunk().getEntities();

    for (Entity entity : entities) {

        TrackedEntity tracked = _entities.get(entity.getUniqueId());
        if (tracked == null || isDisposed(tracked))
            continue;

        tracked.notifyChunkUnload(new ChunkCoords(event.getChunk()));
    }
}

@Override
public void remove() {

    //Unregister handlers for events.
    ChunkUnloadEvent.getHandlerList().unregister(this);
    PlayerMoveEvent.getHandlerList().unregister(this);
    MemberBlockChangeEvent.getHandlerList().unregister(this);
    PlayerInteractEvent.getHandlerList().unregister(this);
    //BlockFinder Class stuff.
    BlockPlaceEvent.getHandlerList().unregister(this);
    BlockBreakEvent.getHandlerList().unregister(this);
    BlockDamageEvent.getHandlerList().unregister(this);

    //Remove from the DB.
    removeFromDB();

    //Remove ALL NPC's in the area.
    for(NPC npc : this.workers) CitizensAPI.getNPCRegistry().deregister(npc);

    //Clear sign logic and change signs to air.
    this.signs = null;
    for(Block b : this.trainArea) {
        if(b.getState() instanceof Sign) {
            b.setType(Material.AIR);
        }
    }

    //Clear trains.
    this.departingTrains = null;
    this.trains = null;

    //Clear visitors
    this.visitors = null;

    //Clear name
    this.stationName = null;

    //Remove from the list
    trainStations.remove(this);
}

@EventHandler
public void onCleanup(ChunkUnloadEvent e) {
    for(Entity entity : e.getChunk().getEntities()) {
        if(entity instanceof Item) {
            Item item = (Item) entity;
            item.remove();
        } else if(entity instanceof Monster) {
            Monster monster = (Monster) entity;
            monster.remove();
        } else if(entity instanceof ExperienceOrb) {
            ExperienceOrb orb = (ExperienceOrb) entity;
            orb.remove();
        }
    }
}

@EventHandler
public void onChunkUnloadEvent(ChunkUnloadEvent event) {
    World w = event.getWorld();
    for (SedWorld ww: sedWorldList) {
        if (ww.world.equals(w)) {
            Chunk c = event.getChunk();
            ww.unload(c.getX(),  c.getZ());
        }
    }
}

public boolean unloadChunks() {
    if (!this.world.savingDisabled) {
        // CraftBukkit start
        Server server = this.world.getServer();
        for (int i = 0; i < 100 && !this.unloadQueue.isEmpty(); i++) {
            long chunkcoordinates = this.unloadQueue.popFirst();
            Chunk chunk = this.chunks.get(chunkcoordinates);
            if (chunk == null) continue;

            ChunkUnloadEvent event = new ChunkUnloadEvent(chunk.bukkitChunk);
            server.getPluginManager().callEvent(event);
            if (!event.isCancelled()) {
                chunk.removeEntities();
                this.saveChunk(chunk);
                this.saveChunkNOP(chunk);
                // this.unloadQueue.remove(integer);
                this.chunks.remove(chunkcoordinates); // CraftBukkit
            }
        }
        // CraftBukkit end

        if (this.e != null) {
            this.e.a();
        }
    }

    return this.chunkProvider.unloadChunks();
}

@EventHandler
public void onChunkUnload(ChunkUnloadEvent event) {
    if (event.isCancelled()) return;
    Chunk chunk = event.getChunk();
    List<Frame> frames = this.manager.getFramesInChunk(chunk.getWorld().getName(), chunk.getX(), chunk.getZ());

    for (Frame frame : frames) {
        frame.setEntity(null);
    }
}

@EventHandler
public void onChunkUnload(ChunkUnloadEvent event) {
    for (Itemcase itemcase : ItemCase.getInstance().getItemcaseManager()
            .getItemcases()) {
        if (event.getChunk().equals(itemcase.getBlock().getChunk())
                && itemcase.isChunkLoaded() == true) {
            itemcase.setChunkLoaded(false);
        }
    }
}

@EventHandler
public void onChunkUnload(ChunkUnloadEvent event) {
    despawnEntities(event.getChunk().getEntities());
}