Open Source d20 API/Engine

[nopantsyet]

I think this was brought up a couple of years ago and I'm assuming it never went anywhere since I can't find anything on Google. (Though I won't rule out googleblindness on my part.)

So I'm picking up the flag from the battle field and will wave it once more to see if there's anyone to rally around it...Anyone have any interest in working on or having access to an open source data model and rules engine for d20? It just seems like some of the software out there could progress better if they weren't all duplicating the effort of developing the data model, the engine and the application.

This effort is being launched in earnest. Please visit the RPGEngine Wiki to observe or participate.

 

[DMFTodd]

There's a yahoo group called D20 XML or some such thing. It hasn't made much progress.

 

[Planesdragon]

So I'm picking up the flag from the battle field and will wave it once more to see if there's anyone to rally around it...Anyone have any interest in working on or having access to an open source data model and rules engine for d20? It just seems like some of the software out there could progress better if they weren't all duplicating the effort of developing the data model, the engine and the application.

d20-XML and the FGA (FGA-Prometheus) both would have an interested in that.

d20-XML has hit a few snags, and is more of a forum for those that do XML things than a place to collaborate a project on.

The FGA--well, I want to give everyone a chance to recover from Easter. E-mail me off EnWorld or check www.theFGA.com in about a week or so.

The answer is "maybe us", and if that "maybe" is a "no", I'd still be interested in helping.

 

[JimAde]

I'm up for it. I'm not familiar with the efforts that have come before, but it seems like there's a definite need.

 

[JoeyD473]

I'd be willing to help out if I can

 

[nopantsyet]

Thanks for the responses. I joined d20-XML and there are XML and MySQL "SRD implementations," which appear to model at least some portion of the d20 data set. I'd like to see an entity relationship diagram for that. Might be something to learn there. Also, there are a number of free and closed products that demonstrate different approaches, upon which we can hopefully improve. As I see it, there are three main tasks I'd like to accomplish.

1. d20 Data Model - Define all relevant data and the states in which they exist. For example, AC: touch, flat-footed, etc. This should be as abstract as possible in order to best support rules extensions.

2. d20 Rules Engine - Create framework for generating, altering and persisting d20 data. Framework should be plugin-based to allow alternate or add-on rule and data sets. Implement d20 SRD rules as an extension to base environment

3. Reference Implementation - I think a reference implementation is important to demonstrate how this can be used as well as to get some practical benefit from this, that being the actual goal of this whole thing.

These three things are separate because of a basic design philosophy I want to follow. The data should be separate from the implementation, and the implementation should be separate from the application. On the lowest level, any application can be made to share data. On the second, any desired user interface can be built on the engine, allowing user experience to be optimized to different activities (e.g. DMing, running a PC, generating characters).

Obviously it must be OGL compliant in order to allow SRD materials to be distributed. I would like to release it under a free license, allowing it to be used in both free and commercial projects. If nobody ever uses it but us, that's fine. But should anyone else want to, the only thing I care about is that it remains compatible.

Planesdragon - I hadn't heard of the FGA before. I'm interpreting your statement as indicating that FGA will be making some sort of announcement soon, so I will watch the site for it then drop you an email.

Just to see if this is viable, I'm going to wait a few days to see if I get more responses to this, then I'll open a thread to start discussing some design ideas and see if we can build any momentum. If we can, I'll put some effort into getting resources (web site, etc.) behind this.

 

[Firzair]

Hi everybody,
I'm working on a piece of software that would be a universal RPG helper that you could use for D20, Rolemaster and probably anything else.
My approach (using Delphi) is just building a framework with a database behind.
In the application you can define your object layouts, e.g. using the SRD you define a object category skill with some variables like armor_penalty and use_untrained.
Then in the application you create a panel where you can enter data for this object.

Every variable and every object has its own rules-section.
Here's a working example:
Object: creature
Variable: attribute[].current (defined as calculated integer)
Rules:
:INIT
=attribute[].base

Variable: attribute[].mod (defined as calculated integer)
Rules:
:INIT
=(attribute[].current \ 2) - 5 ( \ is used for truncated division of numbers, so always rounding down)

attribute[] means there's an object type called attribute and that for every such available object an variable will be created using the correct code: attribute[strength].current will reference attribute[strength].base etc.

The :INIT-section only does initial calculations. Object- and variable-rules can add boni to calculated variables that will be evaluated after the :INIT-section.

Every variable and every object has a database field for credits and a licence reference (so you can enter all the OGLs you use in your data into your database and then you always stay OGL-compliant, as for everything on the screen you can get the relevant OGL onto the screen.

Object data ist stored as plain-text in an BLOB-field in a table. XML would be possible but I will only use this for export and import functions.

Sorry for advertising here a product that's in early alpha stadium, but my point is, an OPEN D20 API should use a similar approach: being just a framework, that gives you the possibility to enter (or import) any data and screen definitions.

Oh and one important thing I do in my program: every object and variable has got a display name. This display name can be changed without having to change the rules. Thus you can take the english SRD-data and just change the display names to german without loosing the functions. While I'm used to english texts my players are not and they like to get german texts

Greetings
Firzair

 

[JimAde]

Firzair, your app sounds interesting, but I think we're talking about a lower-level standard here. Unless I'm mistaken, nopantsyet wants to define an object model. For example: exactly what data makes up a character? Some of the elements will be simple values (like name) while others will be complex structure of their own (like feats, which would be a sequence of complex elements). What you're talking about is a specific implementation of that model. So we need several layers:

1) Object model: As described above. This could be described as XML schema (I assume that's where nopants is going with this). This has to be finished (or at least well-started) first.

2) API: These would be actual code objects (I would vote for Java classes) that allow programmers to manipulate the data structures.

3) Persistence: Some method of saving the objects. This could be a database that looks like the objects, or it could just read and write the XML files directly (which would be my vote) or a database that stores BLOBS containing the XML. Whatever.

4) Reference Implementation: One or more actual applications that use all the above to do useful work. This could be a character generator, a combat assistant or even a full-blown computer RPG (a little ambitious, I think... ). This could also include things like XSL style sheets that can read a data file and present it nicely.

So, anyway, it's way too early to start talking specifics like resource files for display names, and what programming language to use. On the other hand, it sounds like you are much farther along than we are.

 

[andargor]

If it can help, I was working on such an engine in C++ and stopped about a year ago (RL, other group priorities, yadda, yadda).

I made a small demo that builds a 25th level barbarian from "abstract" XML objects. There's a README with it that explains the approach:

http://www.andargor.com/files/panther-demo.zip

HTH,

Andargor

PS: I'll get back to it eventually...

 

[barsoomcore]

I'm very interested in such development work and would be happy to help out, at the least by contributing snarky comments and obscure movie references.



It's a big project, I think is why it hasn't happened yet. Somewhere there's a discussion of things that make it hard, one of those being the difference in data requirements for pen & paper versus software -- for pen & paper, every other instance can be an exception to the rule and that's no problem. Whereas when you're trying to develop an object model, those exceptions drive you crazy because you end up with a bazillion very similar but somewhat different objects. In pen and paper world that's fine, because they're all individual objects anyway, but in software it keeps adding complexity to your model.

Which explains PCGen, in a lot of ways.