Object-Oriented design - Spells

Question

I work on my first Java project, which is a basic roleplaying game. Now I work on spells, and I need some OOD guidance.

I have Character, which is an abstract class. Character has some subclasses (like mage, fighter, rogue, cleric).

Mage and cleric(as for now, cleric doesn't have mana, but it might change) are both spell-casters.

I also have a Spell class, with some info (like spell name, mana cost etc). MageSpellsList and ClericSpellsList are another classes and both have lists of class Spell. and I also have Effects class(casting a spell should use it).

What would be a good object oriented design for dealing with spells (the solution shouldn't include Effects class, I can deal with that later) ?

Maybe using a "SpellCaster" interface with some methods like castSpell and showSpellbook, so Mage and Cleric will implement the interface? .

Maybe MageSpellsList and ClericSpellsList should be a subclass of Spell ? My goal is to use castSpell("spell name here") and let castSpell do the job, by using a good OOD, rather than writing a specific method for each spell (and without duplicate code between mage and Cleric)

Mage.java:

public class Mage extends Character {

    private List<Spell> spellBook;
    private int mana;
    private int CurrentMana;

    public Mage(String name) {

        super(name);

        setName(name);
        setCharacterClass("Mage");
        setLevel(1);
        setHitDice(4);

        setStrength(10);
        setConstitution(10);
        setDexterity(14);
        setIntelligence(16);
        setWisdom(14);
        setCharisma(10);

        setHp((int) (4 + getModifier(getConstitution())));
        setCurrentHp(getHp());
        setArmorClass(10 + getModifier(getDexterity()));
        setBaseAttackBonus(0);

        setMana(20 + 2 * getModifier(getIntelligence()));
        setCurrentMana(getMana());
        spellBook = new ArrayList<Spell>();

    }

    public int getMana() {
        return mana;
    }

    public int getCurrentMana() {
        return CurrentMana;
    }

    protected void setMana(int mna) {
        mana = mna;
    }

    protected void setCurrentMana(int CurrMana) {
        CurrentMana = CurrMana;
    }

    public void showSpellBook() {

        for (Iterator<Spell> iter = spellBook.iterator(); iter.hasNext(); ) {
            Spell spell = iter.next();
            System.out.println("Spell name: " + spell.getSpellName());
            System.out.println("Spell effect: " + spell.getEffect());
        }
    }

    public void addToSpellBook(String spellName) {

        Spell newSpell;
        newSpell = MageSpellsList.getSpell(spellName);
        spellBook.add(newSpell);
        System.out.println(newSpell.getSpellName() + " has been added to the spellbook");

    }


    public void chooseSpells() {
        System.out.println();
    }

    void castSpell(String spellName, Character hero, Character target) {
        try {
            Spell spell = MageSpellsList.getSpell(spellName);
            System.out.println("You casted: " + spellName);
            System.out.println("Spell effect: " + spell.getEffect());
        } catch (Exception e) {
            System.out.println("No such spell");
        }
    }
}

Spell.java:

public class Spell {
    private String name;
    private int spellLevel;
    private String effect;
    private int manaCost;
    private int duration;

    Spell(String name, int spellLevel, String effect, int manaCost, int duration) {
        this.name = name;
        this.spellLevel = spellLevel;
        this.effect = effect;
        this.manaCost = manaCost;
        this.duration= duration;
    }

    String getSpellName() { return name; }

    int getSpellLevel() { return spellLevel; }

    String getEffect() { return effect; }

    int getManaCost() {
        return manaCost;
    }

    int getDuration() { return  duration; }
}

MageSpellsList.java:

public class MageSpellsList {
    static List<Spell> MageSpellsList = new ArrayList<Spell>();

    static {
        MageSpellsList.add(new Spell("Magic Missiles", 1, "damage", 2, 0));
        MageSpellsList.add(new Spell("Magic Armor", 1, "changeStat", 2, 0));
        MageSpellsList.add(new Spell("Scorching Ray ", 2, "damage", 4, 0));
        MageSpellsList.add(new Spell("Fireball", 3, "damage", 5,0 ));
        MageSpellsList.add(new Spell("Ice Storm", 4, "damage", 8, 0));
    }

    static void  showSpellsOfLevel(int spellLevel) {
        try {
            for (Iterator<Spell> iter = MageSpellsList.iterator(); iter.hasNext(); ) {
                Spell spell = iter.next();
                if (spellLevel == spell.getSpellLevel()) {
                    System.out.println("Spell name: " + spell.getSpellName());
                    System.out.println("Spell effect: " + spell.getEffect());
                }
            }
        } catch (Exception e){
            System.out.println("Epells of level " + spellLevel + " haven't been found in spells-list");
        }
    }

    static Spell getSpell(String spellName) {
        try {
            for (Iterator<Spell> iter = MageSpellsList.iterator(); iter.hasNext(); ) {
                Spell spell = iter.next();
                if (spellName.equals(spell.getSpellName())) {
                    return spell;
                }
            }
        } catch (Exception e){
            System.out.println(spellName + " haven't been found in spells-list");
            return null;
        }
        return null;
    }
}

Effects.java:

public class Effects {

    public  void  damage(int dice, Character attacker, Character target){

        int damage = DiceRoller.roll(dice);
        System.out.println(attacker.getName() + " dealt " + damage + " damage to " + target.getName());
        target.setCurrentHp(target.getCurrentHp() - damage);
    }

    public static void damage(int n, int dice, int bonus, Character target) {

        int damage = DiceRoller.roll(n,dice,bonus);
        System.out.println("You dealt" + damage + "damage to " + target.getName());
        target.setCurrentHp(target.getCurrentHp() - damage);
    }

    public static void heal(int n, int dice, int bonus, Character target) {

        int heal = DiceRoller.roll(n,dice,bonus);
        if (heal + target.getCurrentHp() >= target.getHp()) {
            target.setCurrentHp(target.getHp());
        } else {
            target.setCurrentHp(target.getCurrentHp() + heal);
        }

        System.out.println("You healed" + heal + " hit points!");
    }

    public static void changeStat(String stat, int mod, Character target){

        System.out.println(stat + " + " + mod);

        switch (stat) {
            case "strength":
                target.setStrength(target.getStrength() + mod);
                break;
            case "constitution":
                target.setConstitution(target.getConstitution() + mod);
                break;
            case "dexterity":
                target.setDexterity(target.getDexterity() + mod);
                break;
            case "intelligence":
                target.setIntelligence(target.getIntelligence() + mod);
                break;
            case "wisdom":
                target.setWisdom(target.getWisdom() + mod);
                break;
            case "charisma":
                target.setCharisma(target.getCharisma() + mod);
                break;
            case "armorClass":
                target.setArmorClass(target.getArmorClass() + mod);
                break;
        }
    }
}

Answer 1

Preamble

I try to generalise the classes as much as possible, so I do not end up with lots of specific classes that just represent different data, instead of a different structure. Also, I try to separate data structures from game mechanics. In particular, I try to keep the combat mechanics all in one place, instead of splitting them across different classes, and I try not to hard-code any data. In this answer, we will cover the characters, their abilities/spells, the effects of the abilities, and the combat mechanics.

Characters

Consider, for instance, a PlayableCharacter, that represents your characters. This is a standard data class. It provides methods for increasing or decreasing health and mana, and a collection of available abilities.

class PlayableCharacter {
    private final int maxHealth;
    private int health;
    private final int maxResource;    // mana, energy and so on
    private int resource;
    private final Collection<Ability> abilities;

    // getters and setters
}

Abilities

Abilities are equally data classes. They represent mana costs, triggered effects, and so on. I often represent this as a normal class, and then read the individual abilities from external data files. Here we can skip that and declare them with enumerations.

enum Ability {
    FIREBALL("Fireball", 3, 5, new Effect[] {
        new Effect(Mechanic.DAMAGE, 10, 0),
        new Effect(Mechanic.BURN, 2, 3)
    });

    private final String name;
    private final int level;
    private final int cost;
    private final List<Effect> effects;
}

Effects

Finally the effects tell what an ability does. How much damage, how long it lasts, how it affects a character. Again, this is all data, no game logic.

class Effect {
    private final Mechanic effect;
    private final int value;
    private final int duration;
}

The mechanics are just an enumeration.

enum Mechanic {
    DAMAGE, BURN;
}

Mechanics

Now it is time to make things work properly. This is the class that your game loop will be interacting with, and you must feed it the game state (which characters are battling, for instance).

class BattleEngine {
    void useAbility(PlayableCharacter source, PlayableCharacter target, Ability ability) {
        // ...
    }
}

How you implement each mechanic is up to you. It can range from an infernal switch or if/else for each Mechanic, or you can move the code to the Mechanic enum, or to private nested classes and use an EnumMap to retrieve each handler.

Example Mechanic

interface MechanicHandler {
    void apply(PlayableCharacter source, PlayableCharacter target, Effect effect);
}

class BattleEngine {
    private final Map<Mechanic, MechanicHandler> mechanics;

    void useAbility(PlayableCharacter source, PlayableCharacter target, Ability ability) {
        source.decreaseResource(ability.getCost());
        for (Effect effect: ability.getEffects()) {
            MechanicHandler mh = mechanics.get(e.getMechanic());
            mh.apply(source, target, effect);
        }
    }

    private static final class DicePerLevel implements MechanicHandler {
        @Override
        public void apply(PlayableCharacter source, PlayableCharacter target, Effect effect) {
            int levels = Math.min(effect.getValue(), source.getLevel());
            int damage = 0;
            for (int i = 0; i < levels; ++i) {
                int roll; // roll a d6 die
                damage += roll;
            }
            target.decreaseHealth(damage);
        }
    }
}

Answer 2

Why treat spells different than abilities? A fighter class might not have spells as magic spells, but it should be able to perform class specific moves like a whirlwind.

Class PlayableCharacter: abstract class, defines the abstract methods for handling resources(regen rate, max, effects on character), abilities, gear. And implements all the basics.

Class ManaCharacter: extends PlayableCharacter handles it resource as mana.

Class Mage extends ManaCharacter: Will just implement the methods to define what kind of gear it can use, the special abilities it can perform, etc.

Answer 3

I think your idea of having a SpellCaster interface (which includes the castSpell()) is a good one. This defines the behavior or ability of the character.

I would include the list of available spells as an instance field in the Mage or Cleric classes. Come to think of it, maybe it would be a good idea to create an abstract class called SpellCaster which extends Character. The SpellCaster class can declare the list of spells and subclasses (Mage and Cleric) can add specific spells to it.

I'm going to discard the Effects class for now. Each spell can take care of its own behavior. So for example, when calling castSpell("spellName", hero, target) you can pass the required parameters to the spell object and it can take care of dealing the damage or changing stats.

---

In addition, there could be multiple Spell subclasses. For example, DamageSpell, Buff, Debuff. The superclass Spell has a method apply() and each subclass can implement it with it's own behavior. When calling castSpell() then you delegate the control to a specific subclass of a Spell which has encapsulated the behavior and knows exactly if it should deal damage or change stats. That's essentially the Strategy Pattern.

Answer 4

The SpellCaster spellbook should be a Map<String, Spell> so you can look it up by name when it is cast. The Spell class should define an abstract method for applying the effects to a Character. I don't see the point of a "SpellCaster" interface because the implementation of the castSpell() method is always the same (the behavior is delegated to the Spell itself).

Here is a sample scenario:

Mage fireMage = new Mage("Red Niminim");
fireMage.addSpell(new Fireball());
fireMage.addAttribute(Attribute.RESIST_FIRE);
fireMage.addAttribute(Attribute.WEAK_TO_COLD);

Mage iceMage = new Mage("Blue Niminim");
fireMage.addSpell(new Icestorm());
fireMage.addAttribute(Attribute.RESIST_COLD);
fireMage.addAttribute(Attribute.WEAK_TO_FIRE);

Cleric cleric = new Cleric("Friar Joe");
cleric.addSpell(new Heal());

// battle!

fireMage.castSpell("Fireball", cleric);     // 15 damage
fireMage.castSpell("Fireball", iceMage);    // 30 damage
fireMage.castSpell("Fireball", fireMage);   // 0 damage

iceMage.castSpell("Icestorm", cleric);      // 15 damage
iceMage.castSpell("Icestorm", fireMage);    // 30 damage
iceMage.castSpell("Icestorm", iceMage);     // 0 damage

cleric.castSpell("Heal", cleric);           // 15 healed

Attribute.java

public enum Attribute {
    RESIST_FIRE, WEAK_TO_FIRE, RESIST_COLD, WEAK_TO_COLD;
}

Spell.java

public abstract class Spell {

    private String name;
    private int manaCost;

    public Spell(String name, int manaCost) {
        this.name = name;
        this.manaCost = manaCost;
    }

    public abstract void apply(Character character);

    public String getName() {
        return name;
    }

    public int getManaCost() {
        return manaCost;
    }
}

SpellCaster.java (snippet)

public void castSpell(String name, Character character) {
    getSpellBook().get(name).apply(character);
}

public void addSpell(Spell spell) {
    getSpellBook().put(spell.getName(), spell);
}

Fireball.java

public class Fireball extends Spell {

    private static final String NAME = "Fireball";
    private static final int MANA_COST = 8;
    private static final int DAMAGE_AMOUNT = 15;

    public Fireball() {
        super(NAME, MANA_COST);
    }

    @Override
    public void apply(Character character) {
        int damage = DAMAGE_AMOUNT;
        if (character.getAttributes().contains(Attribute.RESIST_FIRE)) {
            damage = 0;
        }
        else if (character.getAttributes().contains(Attribute.WEAK_TO_FIRE)) {
            damage = damage * 2;
        }
        character.setCurrentHp(character.getCurrentHp() - damage);
    }
}

Icestorm.java

public class Icestorm extends Spell {

    private static final String NAME = "Icestorm";
    private static final int MANA_COST = 8;
    private static final int DAMAGE_AMOUNT = 15;

    public Icestorm() {
        super(NAME, MANA_COST);
    }

    @Override
    public void apply(Character character) {
        int damage = DAMAGE_AMOUNT;
        if (character.getAttributes().contains(Attribute.RESIST_COLD)) {
            damage = 0;
        }
        else if (character.getAttributes().contains(Attribute.WEAK_TO_COLD)) {
            damage = damage * 2;
        }
        character.setCurrentHp(character.getCurrentHp() - damage);
    }
}

Heal.java

public class Heal extends Spell {

    private static final String NAME = "Heal";
    private static final int MANA_COST = 10;
    private static final int HEAL_AMOUNT = 15; 

    public Heal() {
        super(NAME, MANA_COST);
    }

    @Override
    public void apply(Character character) {
        character.setCurrentHp(character.getCurrentHp() + HEAL_AMOUNT);
    }
}

Answer 5

Here is an example of how you can use enum instead of strings in your Effects class. I took the liberty of renaming your Character class to PlayerCharacter to avoid collision with java.lang.Character.

Effects.java:

public class Effects {
...
    public static void changeStat(Stat status, int mod, PlayerCharacter target) {
        System.out.println(status + " + " + mod);

        status.effect(mod).accept(target);
    }
}

A little bit cleaner, isn't it? How it works? The magic is all in the enum:

Stat.java:

import java.util.function.Consumer;
import java.util.function.IntUnaryOperator;
import java.util.function.ObjIntConsumer;
import java.util.function.ToIntFunction;

public enum Stat {
    STRENGTH(PlayerCharacter::getStrength, PlayerCharacter::setStrength),
    CONSTITUTION(PlayerCharacter::getConstitution, PlayerCharacter::setStrength),
    DEXTERITY(PlayerCharacter::getDexterity, PlayerCharacter::setDexterity),
    INTELLIGENCE(PlayerCharacter::getIntelligence, PlayerCharacter::setIntelligence),
    WISDOM(PlayerCharacter::getWisdom, PlayerCharacter::setWisdom),
    CHARISMA(PlayerCharacter::getCharisma, PlayerCharacter::setCharisma),
    ARMORCLASS(PlayerCharacter::getArmorClass, PlayerCharacter::setArmorClass);

    Stat(ToIntFunction<PlayerCharacter> findcurrentvalue, ObjIntConsumer<PlayerCharacter> setnewvalue) {
        this.findcurrentvalue = findcurrentvalue;
        this.setnewvalue = setnewvalue;
    }

    private ToIntFunction<PlayerCharacter> findcurrentvalue;
    private ObjIntConsumer<PlayerCharacter> setnewvalue;

    Consumer<PlayerCharacter> effect(int mod) {
        return target -> {
            setnewvalue.accept(target, findcurrentvalue.applyAsInt(target) + mod);
        };
    }
}

The two mysterious types ToIntFunction and ObjIntConsumer are functional interfaces:

• ToIntFunction takes some kind of object as input (here: a PlayerCharacter) and returns an int.
• ObjIntConsumer takes some kind of object (here: a PlayerCharacter) and an int as input, and returns nothing.

You could also create your own functional interface if you like, like so:

Effect.java:

@FunctionalInterface
public interface Effect<T extends PlayerCharacter> {
    void affect(T t);
}

Stat.java:

    ...
    Effect<PlayerCharacter> effect(IntUnaryOperator calculator) {
        return target -> {
            setnewvalue.accept(target, calculator.applyAsInt(findcurrentvalue.applyAsInt(target)));
        };
    }
    ...

Then you can do this in changeStat:

public class Effects {
...
    public static void changeStat(Stat status, int mod, PlayerCharacter target) {
        System.out.println(status + " + " + mod);

        status.effect(x -> x + mod).affect(target);
    }
}

This way you can decide in the Effects class what will happen. Well, I don't imagine the character stats to change much from spells, but a similar mechanic can be used for HP and such :)

The x -> x + mod bit could come from the spell itself too. It's a function that takes an int and returns an int, which is called an IntUnaryOperator in Java:

Effects.java:

...
    public static void boost(int dice, PlayerCharacter target) {
        int value = DiceRoller.roll(dice);
        changeStat(Stat.STRENGTH, x -> x + value, target);
    }

    public static void changeStat(Stat status, IntUnaryOperator change, PlayerCharacter target) {
        status.effect(change).affect(target);
    }
...

Here the spell (boost in this case, which I just invented!) will increase the player's strength (the STRENGTH constant) by a dice roll. It accomplishes this by calling the changeStat with three parameters:

1. STRENGTH → tells the method what status to change.
2. A "formula" for changing the value (note that you don't actually need to know the value here, just the formula!).
3. The target to affect.

As you can see, there is no need here to know how to find the strength value, or how to set it to something else. That is all handled by the enum, so you can keep your spell code clean.

You could even inline the changeStat method directly in the spell method this way, since there isn't really any "real" code in it anymore – that logic is hidden in the enum.

Clean and neat :)