Delayed Regeneration method not working?

So I want blocks to come back one after another after an explosion. So I tried this:

Code:java

package com.lewys.davies;
 
import java.util.HashMap;
 
import org.bukkit.Bukkit;
import org.bukkit.Effect;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.Sound;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityExplodeEvent;
import org.bukkit.plugin.java.JavaPlugin;
 
public class Main extends JavaPlugin implements Listener {
 
    public void onEnable()
    {
        Bukkit.getPluginManager().registerEvents(this, this);
        task();
    }
 
    HashMap<BlockState, Long> blocks = new HashMap<>();
 
    public void task(){
        Bukkit.getScheduler().scheduleSyncRepeatingTask(this, new Runnable(){
 
            @SuppressWarnings("deprecation")
            @Override
            public void run()
            {
                for(BlockState s : blocks.keySet())
                {
                    long diff = (System.currentTimeMillis() - blocks.values().size()) / 1000;
 
                    if(diff < 0){
                        s.update();
                        blocks.remove(s);
 
                        Location loc = s.getBlock().getLocation();
                        Block b = s.getBlock();
                        loc.getWorld().playEffect(loc, Effect.STEP_SOUND, b.getTypeId());
 
                        return;
 
                    }
                }   
            }
        }, 0, 20);
    }
 
    @EventHandler
    public void blockblowup(EntityExplodeEvent e)
    {
        long time = 3;
 
        for(Block b : e.blockList())
        {
            time++;
            final BlockState state = b.getState();
            blocks.put(state, time);
        }
    }
}
 

With no luck. Anyone know why this doesn't work? Thanks for any help!

 

What does it do? Throw a ConcurrentModificationException? Not work? All of the above?

Ah, ok, I think I see what you're after - this bit:

Code:

for(BlockState s : blocks.keySet())
                {
                    long diff = (System.currentTimeMillis() - blocks.values().size()) / 1000;

Is not doing what you want, I think. Should be more like

Code:

for(Map.Entry<BlockState, Long> entry : blocks.entrySet())
                {
                    long diff = (System.currentTimeMillis() - entry.value()) / 1000;

.. unless you were really trying to base a delay off of how big the list is- but I kind of think not?

I'm also not sure you can modify a Map while iterating over it like that. And, finally, this is more of a design thing than an "it won't work thing" - this is kind of an abuse of Map, and a waste of the hashing it's doing under the hood. All you really want here is a List of objects that have a BlockState and timestamp.

If you wanted to get really fancy, you could make an Object that implements Comparable (using the timestamp field as the sort key) and then store your data in a TreeSet. Using this method, you can stop iterating the first time you hit an object that's not ready to be restored, rather than having to loop through your whole list every time the scheduler fires.

EDIT by Moderator: merged posts, please use the edit button instead of double posting.

 

NathanWolf
I basicly want to do this:

Code:java

 
//Credit to pogostickdev29, I just added the random regen times to try to explain what I mean
 
public class Main extends JavaPlugin implements Listener {
 
public void onEnable()
{
Bukkit.getPluginManager().registerEvents(this, this);
}
@EventHandler
public void onEntityExplode(EntityExplodeEvent e) {
for (final Block b : e.blockList()) {
 
final BlockState state = b.getState();
 
b.setType(Material.AIR);
 
int delay = (int) (Math.random() * (200 - 500 +1)) + 300;
 
if ((b.getType() == Material.SAND) || (b.getType() == Material.GRAVEL)) {
delay += 1;
}
 
Bukkit.getServer().getScheduler().scheduleSyncDelayedTask(this, new Runnable() {
@SuppressWarnings("deprecation")
public void run() {
state.update(true, false);
b.getLocation().getWorld().playEffect(b.getLocation(), Effect.STEP_SOUND, b.getTypeId());
}
}, delay);
}
}
}

But at the end of the game for example. I want the blocks to generate back randomly like so with different delays. I have no idea the best way to do this or how to do it apart from delayed tasks. That's why I tried a hashmap to store the block state and the delay it should have to regenerate. Then Tried to have it in one repeating task rather than loads of delayed tasks to make it less ram hungry. It did not throw any errors but still did not regenerate.

 

The issue I pointed out above is going to prevent it from working- you're comparing a list size with a millisecond timing value to determine what to do, and that comparison doesn't make a whole lot of sense.

Code:

long diff = (System.currentTimeMillis() - blocks.values().size()) / 1000;
if (diff < 0) ...

"diff" is never going to be less than zero there, unless your list gets rediculously large.

The solution I gave in my last post should work, if you want to ignore all else- it's a pretty simple change to your original code.