Thread: Problem-specific design question

Say I have a Ninja with certain configurable skills. By configurable, I mean the program reads in a configuration file and adds them in at runtime. ie:

Ninja:
  color: Red
  Skills:
    - High Jump
    - Invisibility

Now, assume these skills need to dynamically add functionality to the Ninja class. As in, if we configure Ninja to have a High Jump skill, then the class needs to follow the CanHighJump Interface, with public void highJump() as a method.

Now there are two ways I can think of to go about this. My first reaction would be to have a Ninja class with String color and then use Reflection to add in the functionality. However, now I realize I could do it through a relational database as well. Have a Ninja class with String color, and forget about any objects relating Ninjas with Skills - instead, whenever I need to check for a skill, just make a call to the database retrieving the possible skills that class can use. Those are the only two truly dynamic solutions I can come up with, and I can't comprehend the design pros/cons of each. I have a feeling the database solution would be far more scale-able, but the reflection method would make most sense to me when coding. No need to guess which skills a Ninja has, because I could easily check for the interface.

I'm hoping someone can give me a bit of insight over a standard design solution for this problem. Whether it be one of the two I came up with, or more likely something i didn't think of.

Thank you,
Phil

Originally Posted by KevinWorkman

Then each Skill would contain the code that does the work for that skill

Hmm, I'd say I'm familiar with java yet I don't understand how this would work. So say I want the Ninja to highJump, I would then...

ArrayList<Skill> mySkills = new ArrayList<Skill>
mySkills.add(new HighJump())
mySkills.add(new Invisibility())
 
Ninja myRedNinja = new Ninja("Red", mySkills)
Skill jump = myRedNinja.getSkill(HighJump)
if(jump != null){
  jump.executeSkill()
}else{
  //can't jump
}

The skill would gain a reference to the Ninja in the Ninja's constructor, thus executing the skill as expected. This code just reads strangely to me because it seems as if the Ninja is not the one jumping. Although i always read how reflection should be avoided - and this is basically doing the same thing as the relational database, so it's obviously not a bad solution. Two questions then.

1) I'm understanding your solution correctly?
2) Are there any large differences between using this solution as opposed to having the database? I mean in terms of functionality. The reason i ask is because this game Ragnarok uses a database to solve this exact problem, but I can't tell if it was a functional decision or solving a scaling problem (thousands of monsters with skills)

I'm not a database guy, but I couldn't figure out why they used a database to solve that problem. I will post on their forum to understand that portion.

It seems to me that as long as your solution is scalable, it will be the route I take. I do not want to use reflection if I don't have to, and this is very flexible.

Thanks for your time,
Phil

I wouldn't be surprised if they're building a data structure similar to the one I suggested.

I guess that makes sense. Where they might have 6000 monsters with associated skills, but the game only needs maybe 500 of them in memory at a time. That would be the only reason to use it in that situation correct? Because otherwise they might as well build the structure and hold it in memory, saving database calls.