Solved Efficient way of getting all blocks in a chunk?

Hello,

I am currently developing a security plugin of the famous anarchy server 2B2T. This plugin will be used to remove illegal items that have been obtained through various glitches/hacks/exploits from the past 3 years.

To do this, I would like the plugin to hook into the chunkLoadEvent and check for tile entities (chests/dispensers/furnaces/droppers etc.) on the loaded chunks.

I am currently thinking of running an asynchronous task too check for chests with getTileEntities() (No Idea if that works).

Could anyone tell me if this is right or if I'm doing something wrong/something I can do to make the code run faster.

-Tristan

 

I've done something similar before for remove items from chests here is the code i used.

Code:

        getServer().getScheduler().runTaskAsynchronously(this, new Runnable() {
 
            @Override
            public void run() {
 
                int count = 0;
                for(Chunk chunk : Bukkit.getServer().getWorlds().get(0).getLoadedChunks())
                {
                    for(BlockState e : chunk.getTileEntities())
                    {
                        if(e instanceof Chest)
                        {
                            Chest chest = (Chest) e;
 
 
                            ListIterator<ItemStack> it = chest.getInventory().iterator();
                            while(it.hasNext()){
                                ItemStack is = it.next();
                                if(is != null && is.getType() == Material.CHAINMAIL_CHESTPLATE){//searh for chainmail chestplate
                                    chest.getInventory().removeItem(is);
                                    count++;
                                }
                            }
                        }
                    }
                }
 
                player.sendMessage(ChatColor.DARK_AQUA + "Found and removed " + ChatColor.DARK_GREEN + count + " items");
 
            }       
        });

 

Thanks a lot! I will try the code out.

 

I would recommend against using asynchronous threads in this case. You cannot safely call the Bukkit API on a different thread without risking a crash (ConcurrentModificationException) or worse - corrupt data. Unfortunately, these errors are not necessarily guaranteed to occur on every run, so you may think the asynchronous code above works just fine. It doesn't.

Instead, you will have to split up the work into several parts, and execute a small portion of it every tick (download):

Code:java

package com.comphenix.example;
 
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Queue;
import java.util.concurrent.TimeUnit;
 
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.block.BlockState;
import org.bukkit.plugin.Plugin;
import org.bukkit.scheduler.BukkitScheduler;
import org.bukkit.scheduler.BukkitTask;
 
import com.google.common.base.Preconditions;
 
public abstract class TileEntityProcessor {
    private static final int TICK_REPEAT_DELAY = 1;
    private static final int TICK_DELAY = 1;
 
    private Queue<Chunk> chunks;
    private Queue<BlockState> tileEntities;
 
    private final long tickProcessingTimeNano;
    private BukkitTask task;
 
    public TileEntityProcessor(long tickProcessingTime, TimeUnit tickProcessingUnit) {
        Preconditions.checkNotNull(tickProcessingUnit, "Tick processing unit cannot be NULL.");
 
        this.chunks = new ArrayDeque<Chunk>();
        this.tickProcessingTimeNano = tickProcessingUnit.toNanos(tickProcessingTime);
    }
 
    /**
     * Process a given tile entity.
     * @param state - the entity to process.
     */
    protected abstract void processTileEntity(BlockState state);
 
    /**
     * Determine if the entity processor is running.
     * @return TRUE if it is, FALSE otherwise.
     */
    public final boolean isRunning() {
        return task != null;
    }
 
    /**
     * Begin processing tile entities.
     * @param plugin - the current plugin.
     */
    public final void start(Plugin plugin) {
        start(Bukkit.getScheduler(), plugin);
    }
 
    /**
     * Begin processing tile entities.
     * @param scheduler - the current Bukkit scehduler.
     * @param plugin - the current plugin.
     */
    public final void start(BukkitScheduler scheduler, Plugin plugin) {
        Preconditions.checkState(!isRunning(), "Cannot start a processor twice.");
        Preconditions.checkNotNull(scheduler, "Scheduler cannot be NULL.");
        Preconditions.checkNotNull(plugin, "Plugin cannot be NULL.");
 
        scheduler.runTaskTimer(plugin, getRunnable(), TICK_DELAY, TICK_REPEAT_DELAY);
    }
 
    /**
     * Stop processing tile entities.
     * 
     */
    public final void stop() {
        Preconditions.checkState(isRunning(), "Cannot stop a stopped processor.");
 
        task.cancel();
        task = null;
    }
 
    private Runnable getRunnable() {
        return new Runnable() {
            @Override
            public void run() {
                long start = System.nanoTime();
 
                while (true) {
                    if (increment()) {
                        // Handle timeout
                        if (!processTileEntities(start))
                            break;
 
                    } else {
                        // Don't repeat
                        stop();
                        break;
                    }
                }
            }
        };
    }
 
    private boolean processTileEntities(long start) {
        while (!tileEntities.isEmpty()) {
            // Timeout?
            if (System.nanoTime() > start + tickProcessingTimeNano) 
                return false;
 
            BlockState state = tileEntities.poll();
            processTileEntity(state);
        }
 
        // Process more!
        return true;
    }
 
    private boolean increment() {
        if (isEmpty(tileEntities)) {
            // Process next chunk
            if (!isEmpty(chunks)) {
                tileEntities = new ArrayDeque<BlockState>(
                        Arrays.asList(chunks.poll().getTileEntities())
                );
                return true;
            }
        }
        return false;
    }
 
    private boolean isEmpty(Queue<?> queue) {
        return queue == null || queue.isEmpty();
    }
}

To use it, decide on the amount of work to perform every tick (maximum 50 milliseconds) and start it:

Code:java

public class ExampleMod extends JavaPlugin {
    @Override
    public void onEnable() {
        TileEntityProcessor processor = new TileEntityProcessor(10, TimeUnit.MILLISECONDS) {
            @Override
            protected void processTileEntity(BlockState state) {
                 // Whatever you need to do per tile entity!
                if (state instanceof Chest) {
                    Chest chest = (Chest) state;
                    Inventory inventory = chest.getInventory();
 
                    for (ItemStack stack : inventory.getContents()) {
                        if (stack != null && stack.getType() == Material.CHAINMAIL_CHESTPLATE) {
                            inventory.remove(stack);
                        }
                    }
                }
            }
        };
        processor.start(this);
    }
}

EDIT: Changed the code to be much more organized. The tile entity processing is now moved to a (inner) sub-class of TileEntityProcessor.

 

Thanks I will try the code.