How to implement mutable functionality at runtime?

Question

I am making a game in which the player character can gain traits that change how their character behaves in my world model or add functionality to it. For example, the character might gain the "feather" trait that changes how fall damage is calculated or the "strong" trait that means the player can now pick up items that were previously just part of the scenery.

I have been hard coding traits in their relevant classes and switching a boolean to change behavior when they come into play, but it is getting rather unmanageable as my trait list grows. There must be a more scalable and decoupled way of doing this.

(The perfect scenario I want is a way that I can just program the class variations and get them switched at runtime in some way while keeping the context and references of the previous object, but any other way to suitably fulfill the requirements bellow is a good answer.)

How would you implement such a feature where methods change and new functionality is gained and removed at runtime?(Please provide an hypothetical example on the given scenario) If you are not inclined to do my work for me, which programming patterns would you use to achieve this kind of behavior?

P.S.:Please feel free to suggest a better title. I suck at those. I will edit this out once a better one has been found.

Answer 1

You could try to implement the Decorator Pattern, which is usually used to add and remove behaviors to an object dynamically, without changing the reference of the original object. The Wikipedia page gives you good explanations and examples. Anyway I'll try to show you a simple Java (hope you'll understand it, you didn't specified the language) example maybe closer to your case. Suppose you have a character class like this:

public class Character {

    public int calculateFallDamage() {
         return 10;
    }

    public void pickUpItem() {
    // initially this method could be empty
    // nothing happens when you try to pick up items
    }
}

Now we create a subclass of Character that adds the "feather" trait. This subclass must contain a field of the class that it extends in order to change its behaviors:

public class FeatherDecorator extends Character {

    private Character decoratedCharacter;

    public FeatherDecorator(Character character) {
        this.decoratedCharacter = character;
    }

    @Override
    public int calculateFallDamage() {
        int fallDamage = decoratedCharacter.calculateFallDamage();  // call the function of the decorated class
        return fallDamage - 5;  // change the result 
    }
}

If you want to add the "feather" trait you have create a new object like this:

Character character = new Character();
int fallDamage = character.calculateFallDamage(); // returns 10
character = new FeatherDecorator(character);
int newFallDamage = character.calculateFallDamage(); // returns 5

Doing in this way you can keep the original reference to the Object but at the same time you can change his behavior. If you are interested to remove a decoration you could add a method like this:

public class Character() {
    ...
    public Character getDecoratedComponent() {
    // exception becaus it's not decorated
    }
    ...
}

public class FeatherDecorator extends Character {

    private Character decoratedCharacter;
    ...
    @Override
    public Character getDecoratedComponent() {
        return decoratedCharacter;
    }
    ...
}

Now it's very easy to obtain the original object without decorations:

Character character = new FeatherDecorator(new Character());
character = character.getDecoratedComponent(); // returns the object without the feater decorator

I hope I have helped you, the Decorator Pattern is a very powerful pattern which gives some flexibility to the objects' behavior. Please let me know if you need more explanations.