Not sure if this is a bug or not but TileEnity stays valid after chunk unloads.

The code for TileEntity (onChunkUnload)

    /**
     * Called when the chunk this TileEntity is on is Unloaded.
     */
    public void onChunkUnload()
    {
    }

As you can see onChunkUnload() doesn't call invalidate()

 

After overriding it with this code:

@Override
public void onChunkUnload() {
	// TODO Auto-generated method stub
	super.onChunkUnload();
	this.invalidate();
}

Everything works and calling isInvalid() for TileEntity returns true.

As i load the TileEntity into List and the execute tick manually I get multiple TileEnities each time chunk reloads.

Also as far as I can tell it could create problem is TileEntity is stored somewhere and unloaded if isInvalid(), as it ever happens if the chunk is unloaded.

Why the hell are you storing your own list of tile entities and injecting them where they should not be?

Use the systems as intended, its not our problem if you decide to hack shit in and break it.

 

Ok then tell me how would you call a method on all TileEntities of specific type?

Should I scan all of the chunks for it?

The world already contains a list of all active tile entities.

Use that list.

Sure... scanning through all of the entities and calling method only on specific ones makes more sense and is way faster than storing them in separate list and accessing them from there...

Where all you need to do is call invalidate the TileEntity when chunk unload.

 

(compare scanning through lots of entities[called each time] just to find few that you are interested in, to changing 1 variable on chunk unload[called only once])

 

Memory is not an issue.

 

BTW:

Any TileEntity in unloaded chunk is invalid and should be marked as such.

They may or may not be invalid, there are a few things out there that act wonkey if you call invalidate on unload.

What you should do is hook into the unload event.

And invalidate your list.

 

However, i dont know what you're doing, but it seems like a very bad way to do things....

I'm sorry for the approach, I assumed they get invalidated after chunk unload and was wondering why is doesn't work for over 1 hour and got really pissed off because of it.

I'm aware of the fact that TileEntity gets unloaded straight after chunk gets unloaded, so it is not necessary to call invalidate but it could help mods that store TileEntity instances.

I'm implementing it as @Override method anyway, so that not much of a problem.

I was just trying to suggest that it might be better to make it default or create another TileEntity class (such as CheckedTileEntity)

 

I'm designing a multidimensional system working with inventories.

It will be really complex and needs to be optimized in any possible way to work at any acceptable speed.

Scanning through all TileEntities is not an option.

 

As each time I would need to:

-get item from list

-check if it is instanceof

-cast it if it is

-then work with it

 

Now all I do is:

-invalidate on unload (only when chunk unloads)

-cleanup (from time to time)

-and when I'm calling I check for null pointer and isInvalid() to make sure it is valid

Which works faster

you could do and IF statement and check if the chunk is loaded into the world.

you could do and IF statement and check if the chunk is loaded into the world.

I will be putting in some extra checking (that will be called from time to time):

Probably:

this.worldObj.loadedTileEntityList.contains(this);

 

Or this:

this.worldObj.getChunkProvider().chunkExists(this.xCoord >> 4, this.zCoord >> 4);

But I will have to check this one.

There are chunk load/unload events, use them -.-