This is very fascinating, and I applaud the discussion so far. Also, I would love to be part of the email discussion. I can’t rifle a message off right now, I’m at work, so I’ll do so when I’m at home. But if any of you are composing something right now, please add me to the list, mike@rpgprofiler.net.
I think there are also two discussions happening. One, about being a generator, and another about how to implement a totally customizable data/ruleset. I’m for the moment going to focus on the data/ruleset, and some theory on how one would go about the design of a program that uses absolutely no hard-coded data.
We know the program has to be flexible, to allow for rule mods, splat books, etc. The question is how do we handle the data, and how do we handle the mods?
Sanglant’s idea of a character being an entity collection I think is bang on. If we focus on d20 products, this is rather easily done. The system is designed around incremental changes to properties (entities) of a character. But as a general theory, the question rises, how are these entities defined? We need to prevent a hard-coded approach, otherwise we’ve defeated the purpose of this discourse.
I use a program on a daily basis that I think we can learn a lot from. It’s a raw numerical data crunching tool, but it is very flexible, customizable, and most of all, it’s rediculously fast. Probably the biggest concern when implementing a custom data library of undefined size is program speed, memory consumption, and general performance, as I think it was Luke that mentioned. Even back in the day of MacIIs, when a few megs of ram was hard to come by, this program could throw around data matrices a meg in size and operate on them in a few seconds. Even on user-written ‘scripted’ tools. How?
Through the combination of compiled and scripted languages. The program has a C-like language that it reads. Depending on the context, this language can serve as a script that is parsed at run-time, and making calls to other pre or user defined functions (acting essentially as a macro language), which is of course slow. But in another context, the program reads this language, compiles it at start up, and the resulting functions/methods/objects are kept in memory and can be executed just as fast as any hard-coded function call or operation.
I think a project like this needs something similar to the above. AI routines, interpolative procedures are nice, but in the end, they will not be perfect, and run the possibility of introducing quirky behavior to the program. The only way to really accomplish this is to let the author of a dataset/tool/addon to define it themselves.
The structure of the language that the theoretical application would use is irrelevant to the current discussion. It could be data-driven like xml, it could be language driven, like a C-style, whatever…
But how to use it? To be flexible and be able to accommodate any new material, the entire data set, the operations, and everything needs to be defined outside of the actual application. What your program essentially ends up being is a wrapper for a language of some type, that generates a UI.
At start up, the program scans the data files, the procedure files, the rules files, compiles them, and once done, the program operates without lag or slowdowns, as if everything was hard-coded. Compiling at start up is time-consuming, but this can be worked around. Say, for example, you look at each file, and save an md5 digest or something. At start up, the program digests the code of a rule, and only re-compiles it if it has changed. Startup is lightning fast after the first compile.
The program resolves conflicts by building a hierarchy of the data and methods it compiles. If the base rule set defines MethodA, but it is redefined in the implementation of a splat book mod, then the program determines which implementation takes priority.
The bad side to the above, is it will obviously require anyone who wants to add a tool to be reasonably proficient at programming. And of course, the author of such a program needs to develop a language. But the language need not be complex.
What need be done? As I see it, you need to define three things. What a character is. This will be an entity collection. You then need to define your entities. What are they? In the end, they boil down to an arbitrarily complex structure of numeric and string data. Finally, you need to define some methods that operate on these entities. The methods are essentially operations that are performed on the entity data.
