Easily optimize games

Do you have a lot of bullets in your bullet-hell or shooter? Maybe a lot of enemies in your vampire survivor-like game? If so, this plugin may save you tons of headaches and boost the performance of your project.

Pool is a behavior, that extends Construct's functions with the Object Pooling Pattern.

What is Object Pooling?

It's a pattern where instead of destroying objects, we store them. Instead of creating objects, we reuse the objects we stored.

From Wikipedia:

The object pool pattern is a pattern that uses a set of initialized objects kept ready to use – a "pool" – rather than allocating and destroying them on demand.

From Unity:

Object Pooling is a great way to optimize your projects and lower the burden that is placed on the CPU when having to rapidly create and destroy GameObjects. It is a good practice and design pattern to keep in mind to help relieve the processing power of the CPU to handle more important tasks and not become inundated by repetitive create and destroy calls.

A practice old as time

Object pooling is a common practice in game development. In other engines, tutorials about and around this pattern are constantly emerging and implementations exist set and ready to go.

It was time Construct has its own.

How it works?

You add the behavior to the object type you want a pool from and done! Quick and easy, drag & drop!

Internally, the behavior will override the creation and destruction functions of the object type you chose. 

• It will disable and store any object in the pool instead of destroying it. 
• It will retrieve & re-enable an object on the pool, if any, when creating.

Keep the control

The behavior includes ACEs to manually manage the pool if needed.

Check my other plugins

Support, ideas and feedback

You can contact me over contact[at]masterpose.dev, over Twitter or over discord on the Construct Community where I'm Luan Himmlisch. I'm open to ideas for new plugins!

Notice:

As any optimization tactic, this is not a "one size fits all" behavior. It won't solve magically badly optimized events, but can help you in the right circumstances to reduce memory spikes or where the cost of instantiation surpasses the cost of keeping the objects in memory.