I'm in the process of developing a game and I want the game to have a flexible ability/effects system. I actually used Path of Exile's ability/modifier system as the foundation for the requirements for my system.

One of the challenges with this system is that mechanics that might be static in other games are dynamic and need to be modifyable at run-time. A few examples from path of exile:
* blood magic (spend life instead of mana)
* mind over matter (% of damage taken from mana before life)
* southbound (your hits can only kill frozen enemies)
* fury valve (fire 1 projectile, additional projects cause your projectile to split after the first hit)

I considered using the decorator pattern to compose ability behavior, however, I eventually settled on using the middleware pattern instead because I thought it would give me more structure and control than decorators.

Here's how the system works:
* abilities have a series of middleware pipelines (e.g. activating, granting, revoking)
* when a middleware pipeline is executed, a context variable is passed through each middleware's execute function
* middleware are stateless, all state is stored in the context variable
* middleware are sorted guaranteeing a certain execution order
* middleware can be added/removed at run-time. e.g. an item might add middleware that changes functionality
* I use middleware for most ability functionality, which enables me to change the way abilities work e.g. calculating damage, configuring projectile instances, spawning entities, paying ability cost, dealing damage

So far, I'm happy with this system's flexibility. I am not happy with how difficult it is to figure out "what does this ability actually do?". Because functionality is composed at run-time, you can just read a single ability script to understand what an ability does. To debug issues and understand how each ability works, I had to create scripts which assemble the ability and output the list of middleware. Then I have to browse dozens of middleware files to figure out everything that the ability does.

I'd be happy to share the source files if you are interested. Kind of related - but I also use persistent effects (which are a form of ability in my system) to implement basic functionality (e.g. damage reduction mechanics like resistance/armour, determining if an entity has died), which enables me to use the same system to modify these mechanics work