Design Patterns: Flyweight Pattern

What is the main problem that the Flyweight pattern solves?

Why did the game crash on the friend's computer?

What was the distinctive feature of the game?

What fields in the Particle class consume the most memory?

What is the main difference between the color and sprite fields and the other fields in the Particle class?

Why did the developer choose to implement a realistic particle system?

What was the consequence of not using the Flyweight pattern in the game?

What is the benefit of using the Flyweight pattern in the game?

What represents the always changing context in which a particle exists?

Which of the following is a characteristic of the intrinsic state?

What is the main reason for applying the Flyweight pattern?

What is the purpose of a separate context class in the Flyweight pattern?

Why is immutability important in the Flyweight pattern?

What is the purpose of a flyweight factory?

Where can the factory method be placed in the Flyweight pattern?

What is the advantage of using a separate context class in the Flyweight pattern?

What is the result of applying the Flyweight pattern in a game?

What is the relationship between the intrinsic state and the extrinsic state?

A structural design pattern that lets you fit more objects into the available amount of RAM by sharing common parts of state between multiple objects.
Aimed at reducing memory consumption by minimizing duplicate data.

Each particle (bullet, missile, or shrapnel) was represented by a separate object containing plenty of data.
Newly created particles no longer fit into the remaining RAM, causing the program to crash.
Problem emerged due to insufficient amount of RAM on less powerful computers.

Identify fields that consume a lot of memory (e.g., color and sprite) and store almost identical data across all particles.
Separate the object's state into intrinsic state (constant, unique to each particle) and extrinsic state (changing, unique to each particle).
Store the intrinsic state within the object (flyweight) and pass the extrinsic state to specific methods.

Stop storing the extrinsic state inside the object.
Only the intrinsic state stays within the object, letting you reuse it in different contexts.
Result: fewer objects needed, since they only differ in the intrinsic state.

Move the extrinsic state to the container object (e.g., main Game object) or a separate context class.
Store coordinates, vectors, and speed of each individual particle, along with references to the flyweight object.
Use a single array in the container class or a separate context class for more elegance.

Ensure the flyweight object's state can't be modified.
Initialize the state via constructor parameters, and don't expose setters or public fields.

Create a factory method to manage a pool of existing flyweight objects.
The method accepts the intrinsic state of the desired flyweight, looks for an existing object, and returns it if found, or creates a new one.
Place the factory method in a flyweight container, a new factory class, or as a static method inside the flyweight class.