Feature request: Being able to flag a instance to be ignored by payload / remove instance from payload

[E11KK]

I'm currently making a chunk system with your extension (which is REALLY nice), and I'm currently facing a problem where a Instance which was loaded by a room and then moved over to another room (chunk) gets de-loaded.

For now I'm going to find a way to make a fix for this myself, but it would be nice with a built-in function that could remove an instance from the payload of the given loaded room. This way, when a instance coming from another chunk could become independent when its no longer inside that chunk when it de-loads.

Another fix to this problem could also just be a blacklist where one could add the instance id, and everything in the blacklist could be ignored by cleanup.

[glebtsereteli]

Hey! Glad to hear you're enjoying the library, and thanks for the suggestion!

This has come up a few times before, and it's something I've had to deal with in my own projects as well. The usual workaround is to grab all instances within the chunk using collision_rectangle_list() (or instance_place_list(), if your chunks have dedicated colliders), loop through the list, and destroy them manually.

Since this is a fairly common issue, I'm thinking of adding that exact approach to the library and exposing it through an additional optional argument in payload's .Cleanup(destroyLayers?, destroyInstancesOutside?).

• If destroyInstancesOutside is left at its default (true), the current behavior stays the same and all instances belonging to the payload will be destroyed, regardless of where they are.
• If destroyInstancesOutside is set to false, it will instead collect all instances within the loaded room area and only destroy those.

Does that sound like a reasonable solution to you?

PS. If you need help implementing my suggested workaround (or any other pointers), feel free to ping me in the #gleb___gmroomloader channel on the GameMaker Kitchen Discord server. Looks like you're already there.

[E11KK]

Hey! Thanks for the quick reply and for being so willing to help!

I like your solution, but for my case destoryInstancesOutside would not work as I have some weird rules for which objects and also what state that some instances need to have in order to avoid being deloaded from its origin chunk. But I can absolutely see destroyInstancesOutside being a really nice parameter in other cases!

Something that would be really nice would be to have the ability to blacklist lets say all object instances on a payload from the cleanup. With this one could easily just use getter functions to save all instances to an array and then destroy everything in that array manually with a custom criteria.

Another solution would be to maybe also being able to add a filter function to cleanup, which would open for a lot of flexibility.

Example:
Cleanups everything like normal, but adds a custom filter for when cleanup loops through instances

chunk[0].CleanupFilterInstances(function(_inst){
      
   if instance_exsists(_inst) && _inst.state == STATE.SPECIAL_CONDITION{
       
      return false
   }

   return true
})

Even better would of course being able to add a filter for each element type aswell, but in my case only instances are relevant.
Maybe something like that could look like this?: (Where every element type filter is a optional parameter.)

chunk[0].CleanupFilter(InstanceFilter, LayerFilter, TilemapFilter, SpriteFilter, /*and so on*/){...}

Please let me know if there already is a easy way to do this that I'm not aware of!

Thanks a lot again!

[glebtsereteli]

Gotcha. I like the filter idea, but only for instances.

I think we'll add the following:

• .RemoveInstance(id) as the raw, most direct and performant option.
• The optional destroyInstancesOutside? = true argument for .Cleanup() as a convenient option that covers the most common use case so far.
• And the callback-based filtering via .CleanupFilterInstances(callback) for more complex custom logic.

---

I can't say when I'll be able to add these, but they're likely to be part of the next major v3.0.0 update sometime in the next couple months.

In the meantime if you'd like to collaborate, feel free to fork the library, implement (some of) this yourself, and open a pull request. It would be greatly appreciated :)

[E11KK]

I've found a solution for my problem in my project, but its a bit clunky, and would be much better by removing the instance from the Payload, so I'm looking forward to the update!

I would've loved to contribute, but I have a lot of other work ahead of me so I don't think I will be able to, for now :)

Thanks a lot for the help and for planning the feature!

[glebtsereteli]

No worries! I'll let you know when I have those implemented.

[glebtsereteli]

Thinking about this more, selectively skipping certain instances during cleanup becomes complicated. Destroying a layer also destroys all instances on that layer automatically, so all this new functionality would have to depend on either moving instances off those layers (by changing layer or depth), or preventing the layers themselves from being destroyed. This might be a little too messy to include in the library.

---

For your specific use case, what exactly are you loading into your chunks? Is it only instances, or are you also including tilemaps/sprites/other assets? I think I’ve got some good suggestions either way.

[E11KK]

I can absolutely see that could be a bit too messy for the library. I assume if i just were to manually remove the instance_id completely from the Payload and also moving it to a different layer then it would work? Because in that case it sounds like it should be quite easy for me and others doing this ourselves. But I really appreciate that you took the time to look at the possibility!

The chunks I'm loading includes instances, sprites, and tilemaps. Please let me know if you've got some suggestions!

[glebtsereteli]

I assume if i just were to manually remove the instance_id completely from the Payload and also moving it to a different layer then it would work?

Correct. We don't use instance_id anywhere though, to be clear. That's a built-in array holding all active instances in the room, and it's irrelevant here.

---

Alright cool. So in your case, I'd split loading and cleanup into two steps. The following is meant to run from the context of your chunk struct.

1. Load only the instances and store them in a separate array:

var _instancesPayload = RoomLoader.Instances().Load(yourRoom, yourX, yourY);
instances = _instancesPayload.GetInstances();

2. Load the rest of the room and store that payload normally:

payload = RoomLoader.Tilemaps().Sprites().Load(yourRoom, yourX, yourY);

3. Now that you have a separate instances array, you have full control over how instances are cleaned up. When unloading the chunk, you can run any per-instance logic you need:

array_foreach(instances, function(_inst) {
	if (_inst.ShouldDestroy()) { // or any other condition
		instance_destroy(_inst);
	}
});
payload.Cleanup();

[glebtsereteli]

Destroying a layer also destroys all instances on that layer automatically, so all this new functionality would have to depend on either moving instances off those layers (by changing layer or depth), or preventing the layers themselves from being destroyed.

And make sure to keep this in mind when implementing the above.

[glebtsereteli]

That solution works without introducing any new functionality. But we could make loading a little cleaner by adding an optional remove? = false parameter to payload's .GetInstances(). When set to true, it would remove all instances from the payload.

Here's what loading would look like with this addition:

payload = RoomLoader.Load(yourRoom, yourX, yourY);
instances = payload.GetInstances(true);

The cleanup logic would remain the same.

[E11KK]

Thank you for the suggestion!

I really like your idea with the functionality of removing instances using GetInstances! If this functionality is expected to be added I will use that, if not I will add your other suggestion when my current workaround ends up causing problems.