What is most Efficient way to store block.locations?

What I try to accomplish is to have breakable Glass blocks and panes,
But these locations have to be saved, because after x time or when some method is called.
These locations has to being reset, and place there a glass block or glass plane.
But what is an efficient way to store the locations of the broken glass?

 

as a hashmap?

 

I would go for:

• HashMap if a server restart would clean the list
• YAML if after a restart it should still have the list

Keep in mind that both these can become very big. So it solely depends on how many blocks you think that are broken

 

I thought Player and Locations are not safe to save?
But if Locations are, I could use that, if it efficient on big scale.

 

I do not know about players, use their names for that. For Locations I would say .clone() them, as Java passes on by reference here, and we all know pistons are good with moving blocks :3 (just to be on the safe side)

 

Cloning them won't help much.

The problem with storing Location is that it keeps a reference to the parent world object, and as a result, will prevent the garbage collector from cleaning up if the world is unloaded.

So, you either have to use a class that's safe to store (BlockVector) or use weak references. Since you mentioned a timeout, I suppose you could Google Guava (included in CraftBukkit) to do most of the work (download):

Code:java

public class TemporaryModifcations extends JavaPlugin implements Listener {
 
    public static int TICKS_PER_SECOND = 20;
 
    private static class BlockData {
        private WeakReference<World> worldReference;
        private int typeID;
        private byte data;
 
        public BlockData(Block block) {
            this.worldReference = new WeakReference<World>(block.getWorld());
            this.typeID = block.getTypeId();
            this.data = block.getData();
        }
 
        /**
         * Restore the current block.
         * @return TRUE if the block was restored, FALSE otherwise.
         */
        public boolean restore(BlockVector vector) {
            if (getWorld() != null) {
                Block block = getWorld().getBlockAt(vector.toLocation(getWorld()));
 
                // Restore type and data
                block.setTypeId(typeID);
                block.setData(data);
                return true;
            } else {
                return false;
            }
        }
 
        public World getWorld() {
            return worldReference.get();
        }
    }
 
    private Cache<BlockVector, BlockData> restoreQueue;
 
    @Override
    public void onLoad() {
        restoreQueue = CacheBuilder.
            newBuilder().
            concurrencyLevel(2).
            weakValues().
            expireAfterWrite(10, TimeUnit.SECONDS).
            removalListener(new RemovalListener<BlockVector, BlockData>() {
                @Override
                public void onRemoval(RemovalNotification<BlockVector, BlockData> entry) {
                    entry.getValue().restore(entry.getKey());
                }
            }).
            build(new CacheLoader<BlockVector, BlockData>() {
                @Override
                public BlockData load(BlockVector arg0) throws Exception {
                    throw new RuntimeException("Unsupported! Cannot generate entries, must be placed manually.");
                }
            });
    }
 
    @Override
    public void onEnable() {
        PluginManager manager = getServer().getPluginManager();
        manager.registerEvents(this, this);
 
        // Run the block cleanup once per second
        getServer().getScheduler().scheduleSyncRepeatingTask(this, new Runnable() {
            @Override
            public void run() {
                restoreQueue.cleanUp();
            }
        }, TICKS_PER_SECOND, TICKS_PER_SECOND);
    }
 
    @EventHandler
    public void onBlockBreakEvent(BlockBreakEvent event) {
        BlockData data = new BlockData(event.getBlock());
        BlockVector vector = new BlockVector(event.getBlock().getLocation().toVector());
 
        // Expire after two minutes
        restoreQueue.asMap().put(vector, data);
    }
}

 

Thanks a lot Comphenix

I've one last question,
because it u got the knowledge how some things get garbage collected.
I've a problem with shooting snowballs.
I use:

PHP:

        Snowball snowball = player.getWorld().spawn(player.getEyeLocation(), Snowball.class);

But the problem is that the snowballs that are shooted in a direction that isn't loaded get's stuck and not removed.
The problem is so bad, that after 5minutes the entity counter goes to 5-10k each 5 minutes.
I use now a entity remover plugin, but this should not be the solution.
Is this a problem of bukkit? that projectiles don't get removed when its reaches an unloaded chunk?
Or is there an other way to remove these projectiles, because we had spikes of 50-100k entities...
And that drains the RAM like crazy. Thanks a lot for advice.

 

Player can be saved as a string, using the getName() method.
Locations can be serialized.

 

*must be serialized before they can be saved iirc. There's custom methods out there to do so - or if you just need to compare, you can save the world+getX, getY, getZ to a string.