Solved need some help, persistance objects or sort of

Hello,

I'm having a little trouble understanding the logic for example in a custom object.

the thing what ive recovered is whenever I make a custom object with the Player instance through the constructor it looks to be persistance even when the player leaves the server the Player object is still alive...

my code:

Code:java

 
public class SchematicBuilder {
    private final Schematic schematic;
    private final Location loc;
    private final Location playerLoc;
    private final Player player;
    private boolean warning = false;
    private LinkedHashMap<Block, Integer> data = new LinkedHashMap<Block, Integer>();
    public SchematicBuilder(Schematic schematic, Location base, Player player) {
        this.schematic = schematic;
        this.loc = base;
        this.playerLoc = loc.clone();
        this.loc.setX(loc.getX()-(schematic.getWidth()/2));
        this.loc.setZ(loc.getZ()-(schematic.getLength()/2));
        this.player = player;
    }
    /**
     * @author xize
     * @param returns the schematic
     * @return Schematic
     */
    public Schematic getSchematic() {
        return schematic;
    }
    /**
     * @author xize
     * @param slowly generates the schematic from bottom to highest.
     */
    public void startGeneration(final EntityType type) {
        new BukkitRunnable() {
            private Iterator<Entry<Block, Integer>> it;
            private LivingEntity entity;
            public void setData() {
                for (int y = 0; y < schematic.getHeight(); y++){
                    for(int x = 0; x < schematic.getWidth(); x++){
                        for (int z = 0; z < schematic.getLength(); ++z){
                            Location temp = loc.clone().add(x, y, z);
                            //Location temp = loc.clone().add(x/2, y, z/2); <- pastes the schematic but 1/² smaller this is per accident but pretty cool.
                            //Location loc = new Location(temp.getWorld(), temp.getBlockX()/2, temp.getBlockY(), temp.getBlockZ()/2);
                            Block block = temp.getBlock();
                            int index = y * schematic.getWidth() * schematic.getLength() + z * schematic.getWidth() + x;
                            if(getMaterial(schematic.getBlocks()[index]) != Material.AIR) {
                                data.put(block, index);    
                            }
                        }
                    }
                }
            }
            public void setupBuilderEntity() {
                if(this.entity instanceof LivingEntity) {
                    return;
                } else {
                    this.entity = (LivingEntity) playerLoc.getWorld().spawnEntity(playerLoc, type);
                    this.entity.addPotionEffect(new PotionEffect(PotionEffectType.SLOW, Integer.MAX_VALUE, 1));
                    this.entity.addPotionEffect(new PotionEffect(PotionEffectType.REGENERATION, Integer.MAX_VALUE, 1));
                    this.entity.setCustomName(ChatColor.GOLD + "[ManCo]"+ChatColor.WHITE + "builder!");
                    this.entity.setCustomNameVisible(true);
                }
            }
            @SuppressWarnings("deprecation")
            @Override
            public void run() {
                if(data.isEmpty()) {
                    setData();
                }
 
                if(!(player instanceof Player)) {
                    entity.remove();
                    data.clear();
                    cancel();
                    return;
                }
                setupBuilderEntity();
                if(!(it instanceof Iterator)) {
                    this.it = data.entrySet().iterator();
                }
                if(it instanceof Iterator) {
                    if(it.hasNext()) {
                        Entry<Block, Integer> entry = it.next();
                        Block block = entry.getKey();
                        int index = entry.getValue();
                        Material dataValue = getMaterial(schematic.getBlocks()[index]);
                        byte subValue = schematic.getData()[index];
                        if(entity instanceof Enderman) {
                            Enderman enderman = (Enderman) entity;
                            if(subValue == 0) {
                                enderman.setCarriedMaterial(new MaterialData(dataValue));
                            } else {
                                enderman.setCarriedMaterial(new MaterialData(dataValue.getId(), subValue));    
                            }
                        }
                        if(block.getType() == Material.AIR) {
                            try {
                                if(!block.getChunk().isLoaded()) {
                                    block.getChunk().load();
                                }
                                if(subValue == 0) {
                                    block.setType(dataValue);
                                } else {
                                    block.setTypeIdAndData(dataValue.getId(), subValue, true);    
                                }
                                saveRollback(block, player);
                                block.getWorld().playEffect(block.getLocation(), Effect.STEP_SOUND, dataValue);
                                entity.teleport(block.getRelative(BlockFace.UP).getRelative(BlockFace.UP).getLocation());
                                entity.setHealth(entity.getMaxHealth());
                            }catch(NullPointerException e) {e.printStackTrace();}
                        }
                        it.remove();
                        data.remove(block);
                    } else {
                        entity.remove();
                        data.clear();
                        cancel();
                    }
                }
            }
        }.runTaskTimer(ManCo.getPlugin(), 0L, 1L);
    }
    @SuppressWarnings("deprecation")
    public Material getMaterial(int id) {
        try {
            Material mat = Material.getMaterial(id);
            mat.getId();
            return mat;
        } catch(NullPointerException e) {
            if(!warning) {
                ManCo.log(LogType.SEVERE, "Warning we don't know anything about data value " + id + " at schematic " + schematic.getName() + " perhaps this schematic is made in a newer minecraft version or mod?");
                ManCo.log(LogType.SEVERE, "however this block will be changed to air, and the generation could have unpredictal results.");    
            }
            return Material.AIR;
        }
    }
    private void saveRollback(Block block, Player p) {
        if(p instanceof Player) {
            System.out.print("player still active");
            Bukkit.getPluginManager().callEvent(new BlockPlaceEvent(block, null, block, p.getItemInHand(), p, true));        
        }
    }
}
 

how is it even possible that the method saveRollback still says the player is active while the player already is gone from the server?, ive tried to check if the player is still an instanceof in the scheduler to debug it but it still claims its always an instanceof, could it be that the scheduler is litterly hostaging the player object?

thanks for the help though, I think this is something really usefulls to learn about.

 

Checking if a Player object can be cast to a Player object will always return true, so p instanceof Player will always return true. To check if a Player is online, you need to use OfflinePlayer#isOnline() or Player#isOnline()

 

When the player leaves the server, the connection is broken. But that's mostly as far as it goes. There is no connection between the server and the client anymore, but the Player object is still in memory. And it will continue to be in memory until the Garbage Collector has collected it. The garbage collector won't collect any object that has a strong reference. Which means the Player object will continue to exist at least until your SchematicBuilder stops referencing it.

So, in answer to your question. Yes, the scheduler IS hostaging the Player object, and you should make sure the object is garbage collected to avoid memory leaks, by removing all references to it.

 

Traks

well thats true, but if the player goes offline it should actually return null which for some reason doesn't happends D:
I suspect it will not be garbage collected when it is in a constant use since I'm able to use its name to...

edit
solved

 

I am afraid this is where you're wrong. The player disconnecting doesn't automatically nullify your reference. Mind you, there is a significant difference between an object and a reference. Please look into it. An object can never be null, but a variable can reference null.

 

Rocoty

I know, my page wasn't refreshed when I typed that response, but thanks it explained alot though

 

xize store the players name or uuid, and get the player object by the name or uuid, thats what i do