Does it make sense to implement a Class Factory design in an RPG Character Creation module

Question

I'm a self-taught Engineer, a beginner in Java and I am trying to create a Dungeons and Dragons character creation module for a bigger game to solidify my understanding of core concepts while learning best practices for given scenarios. I have an implementation outline below, but I believe that there are better design choices that I could make.

I am trying to follow SOLID and Composition over Inheritance; I think this plan follows those concepts.

How can I make this implementation design better?

Implementation

It would contain

• An Interface for character that contain getters and setters for Name, Age, Height, etc...

• An Interface for character races to encapsulate racial traits into a portable template

• Multiple classes that implement the Character Interface and the Race Interface for the goal of creating the Character and Class(RPG) of the Character via a Class Factory.

  • This May be a lot of classes to define due to the possibilities of combinations. Is there a better way to instantiate a character object which abstracts the Class and Race into one object.

• A Class Factory class would have 2 arguments, one for Race and one for Class to create a character object and a switch case statement would take the Race and the Class to determine the Race-Class combination and return a race-class object (character).

  • Same bottle-neck as above.

The Execution

• The Main class would take user input for the character's Race and the character's Class to call the Class Factory which returns a character object.
  • It might be worth creating a character abstract class that I can use to extend the unique class combination classes so it is easier to understand when handling the character objects.

Like so:

Character character = new ElfWizard();

• Then it would prompt the user for the characters Name which will be used to call a Setter method for the character.

• Prompts again for the size specifications(Tiny, Small, Medium, Large, Extra Large) which will also call a setter.

  • Dependening on Race, size choices will be limited via some conditional flow.

• Base attribute stats at 10 and gives stat points for allocation with a hard cap at 20 which call setters for each input provided.

  • May be tricky to implement in a console application. It would be cool to find out how to do this.

• Then calls the character object methods for abilities to test.

Summary of Concerns

Is there a better way than sticking everything in Main? Would it be better to create a Character Creation class which will be instantiated in main to call a user creation method which prompts the user for input to create the character object and then prompts for inputs to set the character info?

Are there any current UI frameworks that I can use to prompt input instead of the Console?

I have interest in transforming this into a API later to store values into a database. This is so that I can create a Web Application to work with these methods.

Thank you for any feedback.

Answer 1

Since you are writing in Java and your explanation of the problem relies heavily on data members and not API calls via an interface, I would recommend you to prefer composition over inheritance. Creating a race-class object class (ElfWizard) for every combination is not preferring composition over inheritance.

Moreover, if Size is a character trait and it depends on Race, it's inappropriate to separate it from the Character class since they are cohesive.

I suggest that you will create a Character class with two private data members for Race and Stats classes. Character should expose an API for the user, and implements the logic you've mentioned before setting the values (the Race-Size, the stats limit, etc.).

And because Character/Race/Stats are very cohesive, Race and Stats can be (depending on your requirements) inner classes of Character in your system.

*There are many UI Frameworks for Java, but it's a separate topic.

Answer 2

I believe you are trying to run before you can crawl.

As I said in my comment on your question, your example is not composition, just regular inheritance. However, if all you are building is a character stats creator, you do not even need composition or inheritance. These deal with behavior, and since this is a stats creator, and not a game, your characters have no behavior.

Additionally, a factory is not appropriate here; the factory pattern is for your code, not your user. If anything, the builder pattern would be more appropriate here, but even that may be overkill for your application.

The only thing I can imagine (I am not a D&D player) needing an interface would be the character generator itself since different versions of the game may have different rules.

Again, I am not too familiar with D&D other than lurking on RPG Stack Exchange, but I would imagine your class structure would look more like this:

class Character {
     String getName() {} //snipped for brevity
     void setName() {}
     Race getRace() {}
     CharacterClass getClass() {}
     int getStrength(){
         return strengthRoll + getClass().getStrengthBoon() + getRace().getStrengthBoon();
     }
     // ect...
}

class Race
{
     int getStrengthBoon() {}
     void setStrengthBoon() {}
     // ect
}


// building your character
Character character = new Character();
character.setRace(raceDictionary.get(raceName));
character.setClass(classDictionary.get(className));
character.setStrengthRoll(rolledStrength);
character.setDexterityRoll(rolledDex);