# DM Genie



## Delak (Oct 2, 2002)

Hello everyone,

I just wanted to let everyone know out there that this program is great. much better then campagin suite or DM Familar.

Go to www.dmgenie.com and see for yourself.


Delak


----------



## Eternalknight (Oct 2, 2002)

Delak said:
			
		

> *Hello everyone,
> 
> I just wanted to let everyone know out there that this program is great. much better then campagin suite or DM Familar.
> 
> ...




Can you fill us all in a little more?  What makes it better than Campaign Suite and DM Familiar, all of which are fine programs?


----------



## Delak (Oct 2, 2002)

Here is what i feel makes it better then the other two.

It combines the combat managment and enconter managment of DM Familar with a much better form of campagin managment.

You can enter in the PC's as they are no need to modify a generated character.

The campagin tree is very easy to use you can add maps and create hotspots that link them to infomartion on other tabs in the adventure. You can also link anything in the notes field to any tab in the adventure.

There is no character generator per say but you can import stat block npc's or even pc's. If the all the better character generators out there with stat block formating its very easy to add pc's npc's or monsters.

You can import maps and pictures


----------



## Luke (Oct 2, 2002)

*Problems...*

Hmmm...

This may well seem better than Campagin Suite or DM Familar. On the surface it looks quite pretty without going much into 3rd edition mechanics calculations or flexibility. It's never approaching PCGen for mechanics calculations, as an example.

*But...*

This is *going* to have some very serious problems with section 8 compliance of the Open Gaming License.

I feel for these guys, since the section 8 compliance can easily catch you out, and is the hardest part, by far, to live up to. They seemed to sort the more obvious D20 license issues. The issues aren't very obvious at all, from a casual glance. On the other hand, since they're asking as much as the price of E-Tools (ie. a commercial venture), a bit more legal research would have been a good idea. There's certainly plenty of section 8 compliance problems discussion in the official mail list archives. PCGen did a lot of work to fix up the basics there.

They've gone for the D20 license (which Campaign Suite recently decided to give up), but can't even live up to the OGL - which legally leaves them nowhere.

I greatly suspect that Wizard's will shut this one down till the issues are addressed, and that fixing up the problems is going to require very major, serious programming surgery (I know exactly what I'm talking about here...).

The constant different types of reminders to register the software (even directly from PCs after their attacks!), is ...interesting. From a personal perspective I think it's way too early to ask money for it. It seems that there's lot of stuff that you still have to do manually. Doing *everything* manually helps avoid section 8 license problems (like DM's Familiar). Watch out for ending up with a tool that is little more than an RPG wordprocessor, and begs the question whether all the data entry and manual calculations make it worth using a computer at all.
I'd recommend researching section 8 issues in the official OGL list archives.

Regards,


----------



## Twin Rose (Oct 2, 2002)

Delak said:
			
		

> *Hello everyone,
> 
> I just wanted to let everyone know out there that this program is great. much better then campagin suite or DM Familar.
> 
> *




Having had a couple of looks, I myself have seen some pretty big differences between Campaign Suite and this program.  Granted, it does combat management - something we have never even claimed to do.  So, naturally, it is better at Combat Management. 

The fact that so many rules are hard-coded will result in a problem much as e-Tools has, where one cannot add certain features from certain books simply because there is no methodology of doing so.  CS is presented as a configurable program, where everything is data-driven rather than code-driven.


----------



## DMFTodd (Oct 3, 2002)

The computer-assisted gaming market has a lot to offer lately, huh? (Those of us competing for your gaming dollars might even call the market "crowded").

I think the competition is good. The more programs out there to choose from, the more people will start thinking they might want a computer at the gaming table. And that gives me a chance to win those dollars.

DMGenie looks interesting though I only gave it a very cursory look. Chris and Luke seem to see some problems. I would encourage people to compare. 

So, for the prospective gamer who wants to delve into computer-aided gaming, what's out there? (If I miss anything or get anything wrong guys, be sure to let me know).

*Character Generation* : These are programs to help create PCs/NPCs and do the calculations for you. Examples: PCGen, E:Tools, Campagn Suite, Roleplaying Master. 
   Interestingly, programs that don't do character generation are starting to import from programs that do. Examples: DM's Familiar, DMGenie. 

*Combat Management* A program that manages combat for you. Does things like rolling initiative, keeping track of rounds, keeping notes, makes attack/damage rolls, tracks spell durations, etc. These are programs meant to be used at the gaming table during the game. Examples: DM's Familiar, DMGenie, Role-playing Master, Crystalball (Mac), assorted Excel spreadsheets out there.

*Game Prep* Software that helps you write adventures, setup your campaign world, and, in general, write notes. This might be software you use before the game, print it, and bring paper to the game, or it might be a program you use at the game table. Examples: DM's Familiar, Campaign Suite, Roleplaying Master, DMGenie.

*Rules Reference* This is software that puts the rulles - Spells, Monsters, Rules, Feats, Skills, etc. - at your fingertips so you don't have to lug a bunch of books to each game session or know which book a particular thing is in. Examples: Pretty much all of them.

*Random Tables* Programs that can generatre random results for you, whether it be the innkeep's name, treasure, wandering monster, etc. Examples: Tablesmith, Campaign Suite, RPM (I think?)

*Miscellaneous* Programs that do assorted "little" things. Weather generation programs like WeatherMaster or Kaima Weather Generator. Anything else?

As you see, many of the programs encompass multiple desirable things. Check out a couple of them and see which ones you like. Some things to keep in mind when reviewing software:

* Interface: Does the interface make sense to you? Is it easy to use? D&D involves dice & books. If the program is making it much more complicated than that, it's probably going to detract from your gaming, not enhance it.

* Customizable: Can the program handle your house rules? Do you have house rules? Is it flexible enough to deal with the way you want to game? If it does allow a way to customize the program, how hard is it to customize?

* Support and Longevity: All of these programs are relatively new to the market. Is this a supported, growing program that is going to be around for a while? Are bugs getting fixed? New features introducted? How easy is it to ask questions and get answers?

* Cost: Price is probably something you'll want to think about at least a little. For me, I take my gaming fairly seriously. I'd much rather spend $30 on something that helps my game a lot than a free program that only helps a little. Those with different budgets/goals may think differently. 

* Expandability: What happens when Company Y comes out with Product X and you want it? Can that information get entered into the program easily? Are you going to have to type all that information or does the program support some Import/Export features?

(Apologies to Crystalball for the Mac. I don't know anything about it. It probably does several of the things above and I didn't give it credit for. If you have a Mac, be sure to look into this program.)

(Apologies to DM Buddy, I know nothing about it.)


----------



## Therigwin (Oct 3, 2002)

DMFTodd said:
			
		

> *Game Prep* Software that helps you write adventures, setup your campaign world, and, in general, write notes. This might be software you use before the game, print it, and bring paper to the game, or it might be a program you use at the game table. Examples: DM's Familiar, Campaign Suite, Roleplaying Master, DMGenie.
> 
> 
> *Random Tables* Programs that can generatre random results for you, whether it be the innkeep's name, treasure, wandering monster, etc. Examples: Tablesmith, Campaign Suite, RPM (I think?)




I think eTools should be added to both of those list.
First, I use it for game prep from creating encounters, setting up the treasure list, etc.  I just paste it into Word and I am all set.

And Table Generation, eTools has a table generator that some would argue is almost as powerful as Tablesmith.  Plus it integrates back into the other objects of the program.

Just wanted to point that out.


----------



## Janik (Oct 3, 2002)

Hello!

My name is Janik Zikovsky, and I wrote DM Genie (sorry for not posting earlier, I don't visit the Enworld messageboards too often).

I'd like to reply to some of your concerns:



> (From Twin Rose) The fact that so many rules are hard-coded will result in a problem much as e-Tools has, where one cannot add certain features from certain books simply because there is no methodology of doing so. CS is presented as a configurable program, where everything is data-driven rather than code-driven.



My feeling on this is that the average user will never need to alter the basic game mechanics (for example, no one would want to turn the system on something based on d30...). Also, while I could have integrated some sort of generalized script engine, I believe this would be too difficult a feature, even for an advanced user (except those with good programming skills). Future updates will include extra game mechanics, without the need for users to learn and program it themselves.



> (From Luke) This is going to have some very serious problems with section 8 compliance of the Open Gaming License.



Section 8 says: "Identification: If you distribute Open Game Content You must clearly indicate which portions of the work that you are distributing are Open Game Content."

If you go to the Help->About box, you'll see "The rules, creature statistics, race statistics, conditions, spells, powers, feats, skills are distributed as Open Game Content and are licensed for public use under the terms of the Open Game License v1.0a. 
DM Genie program code, interface, graphics, layout, algorithms are all Copyright 2002, Janik Zikovsky, Author."

I hope that is clearly identified enough, if WotC has concerns i'll change it. They haven't complained yet, but then again the program _just_ came out ;-)



> It seems that there's lot of stuff that you still have to do manually.



I wouldn't say a *lot* - all attack/damage etc. bonuses are automatically calculated, which really is the big part of the work, and what I wanted a program to take care of. Features which I believed could be done faster manually are left to the DM to do. For example, setting a target for each attack takes a while to do in a program, I think it's easier just to report the total attack value, and let the DM say: "Well, Markus, your character was hit by the skeleton". The player records the damage, and the game moves on - it's faster than trying to keep track of the PCs, NPCs and the monsters. The DM has enough to do 

P.S. DMFTodd mentionned weather generators, I should point out that DM Genie has a weather generator function which I think is pretty cool (I had fun programming it). Try it (Shift-F11)!

Thanks to all, and happy gaming!


----------



## Twin Rose (Oct 3, 2002)

Janik said:
			
		

> *Hello!
> 
> Section 8 says: "Identification: If you distribute Open Game Content You must clearly indicate which portions of the work that you are distributing are Open Game Content."
> 
> ...




You will definately want to check with WOTC before they check with you, this is something that I learned through my dealings with them in the course of developing Campaign Suite.  They are VERY particular about 'clearly marking' OGC, including all game mechanics such as calculations.

A number of websites, generators, and other electronic products have been shut down in recen tweeks by Wizard's of the Coast, so you really want to be careful and check with them.


----------



## Luke (Oct 4, 2002)

Janik said:
			
		

> *Section 8 says: "Identification: If you distribute Open Game Content You must clearly indicate which portions of the work that you are distributing are Open Game Content."
> 
> If you go to the Help->About box, you'll see "The rules, creature statistics, race statistics, conditions, spells, powers, feats, skills are distributed as Open Game Content and are licensed for public use under the terms of the Open Game License v1.0a.
> DM Genie program code, interface, graphics, layout, algorithms are all Copyright 2002, Janik Zikovsky, Author."
> ...




HiYa Janik,

Welcome to 3rd edition RPG programming 
Be certain that Wizards are now looking at DM Genie.

I'll stand by those section 8 warnings - here's the (non-obvious) issue:
Clearly indicating portions that you use actually means that you need to "provide the code" that does any calculations of rules from the SRD. The code must be human readable (script is okay), and actually be what is executed (distributing your source code, along with a compiled binary is not sufficient).

For example, determining that a Str of 18 has a Str mod of +4 is a game mechanic, and you must be able to see the code that does this calculation.
If you work out the Reflex save bonus, based on level, dex, and other things - this is also a game mechanic where you need to show all the code that does that work.
Working out an AC, initiative modifiers etc etc etc are all part of that.

Essentially, any game mechanic you perform can't be part of a compiled (non-human readable) binary, since it is then no longer clearly indicated.

There's your catch 22. The nicer you make your program, by automatically working out things, the more you violate section 8, unless you go to a lot of effort, as I did with RPM.

In RPM I've developed a specialized RPG scripting language from the basics of JavaScript. Having made that effort, I'm pretty well free to offer the best possible computerized RPG utility without license problems. After recent scrutiny by Wizards, I only needed to dot my "i"s and cross my "t"s with regard to displaying the license, and watch my trademark references. My program is fine. Well, sort of. You never actually get to say that you are OGL/D20 compliant (though you may have read such claims).  All you ever get to say is that Wizards don't have any issues with you currently outstanding.

You *may* also have some problems with your interactive game D20 compliance. I understand your interpretation that you're okay since you show what AC an attack can hit, rather than actually target an opponent and fully work it out. You *may* find that the interpretation is that you have determined the success of hitting a particular AC, even if you don't apply it to a specific target. The bottom line is that truly useful software and the D20 trademark just don't mix.

You have an "ultimate utility" description of DM Genie, so you may want to consider doing the whole thing, by making the effort to get your section 8 issues firmly smacked on the head 

Hope I didn't offend with the "it's too early to charge people" comment. I'd just hate to see that people pay and then find that they can't get update fixes because it's shut down by Wizards. My worry is that you'll either have to pull features that they paid for, or you'll disappear for a long time trying to get section 8 compliance working. You made a good visual start...

I apologise for my part in turning this "DM Genie" post into a general software utility and compliance thread. I guess that the comparison to other products kind of invited it, and the compliance issues are important.

Regards,


----------



## Brent (Oct 4, 2002)

So here is the deal...

I just started working on an object oriented character manager/generator.  The basic D20 mechanics are in the code.  All of the ojects are serialized to xml files ("data").  I can expose the public properties and methods of the objects through XML also, but it is not human readable.

I thought this was a great idea.  Want to impliment a new race, skill, feat, class, etc., that somebody else input?  Just drop the file into the skill, feat, class, etc., directory.  Want to invent a new one?  Just enter the properties in the GUI and save it.  The program takes car of the rest.

From what you are saying, I can't make a program like this.  Should I contact WotC?  This is really kind of depressing...


----------



## Luke (Oct 4, 2002)

Brent said:
			
		

> *The basic D20 mechanics are in the code.  All of the ojects are serialized to xml files ("data").  I can expose the public properties and methods of the objects through XML also, but it is not human readable.
> *



First up - don't construe anything I say as being legal advice.

I would think that XML satisfies "human readable". The important part is that any code you execute to achieve a game mechanic cannot be compiled into a non-readable binary of some sort.

Remember that the code is as much a part of the license as the data.
If you do include script code in your XML objects, be sure to scratch the surface of what you're doing.
For example, a feat or weapon might result in a modifier of some sort (such as +2 leather armor adding 2 to the AC). However, that modifier will typically have to be part of a greater piece of code that considers stacking rules. So the code that adds up all the modifiers whilst considering the stacking rules is also part of the license constraints.
From my experience, any decent legal implementation of 3rd Edition game mechanics is a huge effort, and will go well beying exposing methods and properties of individual XML objects.


----------



## Twin Rose (Oct 4, 2002)

Brent said:
			
		

> *So here is the deal...
> 
> I just started working on an object oriented character manager/generator.  The basic D20 mechanics are in the code.  All of the ojects are serialized to xml files ("data").  I can expose the public properties and methods of the objects through XML also, but it is not human readable.
> 
> ...




You will definately want to talk to them.  I'd encourage ANYONE wanting to get into the industry to read all FAQs, information sheets, everything you can get your hands on and learn everything there is to know about the licenses.  Consult a lawyer if there is anything youd on't think you understand fully.


----------



## Fractalwave (Oct 4, 2002)

Brent said:
			
		

> *So here is the deal...
> 
> I just started working on an object oriented character manager/generator.  The basic D20 mechanics are in the code.  All of the ojects are serialized to xml files ("data").  I can expose the public properties and methods of the objects through XML also, but it is not human readable.
> 
> ...



One thing the others forgot to mention is that if the program is solely for your use, you don't have to worry about these things. If you distribute it to others in any way, shape or form whether it's free or not then you do have to worry about them.

WotC takes what some would consider to be a very hard line in defining what is allowed to be included in code and what is not regardless of license under which you choose to distribute. Designing a program without talking to them is just lining you up for a likely rewrite/redesign later.

Talk to a lawyer. Research the licenses. Then talk to WotC. And I suggest doing that before you set the code down in stone.

One no-no that seems to be written in stone is there shouldn't be any rules embedded in code anywhere. That tends to change the scope of the project dramatically.

I would assume that you wish to use OGC in the program. That use would necessitate either complying with the OGL or negotiating legal agreements (licenses) with all the copyright owners of material you wish to include.

Being D20 compliant raises a lot more issues as it is more restrictive than the OGL. Whether you use the D20 license then becomes a question of whether you need to be able to do the things that license says you can't do.

So the bad news is...to do this you need to become a pseudo-lawyer. The good news is that it is most certainly possible.


----------



## smetzger (Oct 4, 2002)

Brent said:
			
		

> *So here is the deal...
> 
> I just started working on an object oriented character manager/generator.  The basic D20 mechanics are in the code.  All of the ojects are serialized to xml files ("data").  I can expose the public properties and methods of the objects through XML also, but it is not human readable.
> *




1) "Human Readable" is not part of the d20 license.  Although "Clearly marked OGC" is.

2) You can put OGC material in your "code" but that would mean that your code is now OGC also.  Therefore you would somehow need to mark your code clearly as OGC.


----------



## Brent (Oct 4, 2002)

I appreciate all of the advice everyone has given!  This is kind of long; so don't feel the need to respond.  Judging by the programs I have seen from you guys, you are all pretty busy.

My mind is still trying to come to grips with all of this.  Lets look as skills as an example.  We have three XML files: SkillName1.xml, SkillName2.xml, CharacterName.xml and ClassName.xml:

Each of these files contains a copy of the OGL and/or D20 license.
ClassName.xml lists SkillName1 & SkillName2 as class skills with 8 ranks each.
CharacterName.xml lists ClassName as one of the characters classes.
SkillName1.xml lists SkillName2 as a synergy skill granting a +2 for 5 ranks.

All of this is in the data and can be seen by looking at the XML file or displayed in the program (including the copyright and license info for the class and skills).

The program has binary code that knows that CharacterName can have SkillName1 and SkillName2 because he has ClassName (so can anyone else by reading the files either directly or through the program).

The binary code also knows what a Synergy Bonus is and to apply the +2 bonus when CharacterName uses SkillName2 because he has 5 ranks of SkillName1.  This part isn't in human readable format.  Anyone who owns the PHB knows what a Synergy Bonus is, but you can't see it on screen.

Assuming the program is marked as OGC in the Help>About, is this a problem?
What if I show the calculation on screen?
What is I distribute a Class Library with the program?
What is the difference between doing this and distributing an Excel spreadsheet with a formula such as: Ranks + SynergyBonus?

I will definitely get touch with WotC one I have enough of a program so they can see what I am doing.  Everyone keeps talking about scripts.  My idea is not to use scripts but rather OOP utilizing the Microsoft .NET framework.  I think it will allow the program to be fast and easy to use, but it requires non-human-readable binary code to implement, Although the data is stored in semi-human-readable XML files.  This allows anyone to create style sheets to view data, or other programs that read the files for other purposes.

If another programmer wanted to write an adventure management, combat management or any other type of software that read my CharacterName.xml file they could.  That is what XML is for.  I don't have to export some delimited file from my program in some agreed upon format so that it can be imported into another program.  If a standard set of tags were developed, any program could talk to any other program without having to know the structure of the data.  All it needs to know is the meaning of the tags.  This is where I think eTools falls short.  All the data is stored in a Db with unknown structure or binary .chr files.  I can't work with any of the data without opening it from eTools copy/pate into another program.

I am a very big fan of a number of the programs that the posters on this list have created.  I just want to use them all without a lot of copy/paste, and allow other people to do the same.


----------



## smetzger (Oct 5, 2002)

Brent said:
			
		

> *I appreciate all of the advice everyone has given!  This is kind of long; so don't feel the need to respond.  Judging by the programs I have seen from you guys, you are all pretty busy.
> 
> My mind is still trying to come to grips with all of this.  Lets look as skills as an example.  We have three XML files: SkillName1.xml, SkillName2.xml, CharacterName.xml and ClassName.xml:
> 
> ...



*
*

Sounds good so far as long as you make sure you update section 15 appropriatly.



			
				Brent said:
			
		

> *The program has binary code that knows that CharacterName can have SkillName1 and SkillName2 because he has ClassName (so can anyone else by reading the files either directly or through the program).
> 
> The binary code also knows what a Synergy Bonus is and to apply the +2 bonus when CharacterName uses SkillName2 because he has 5 ranks of SkillName1.  This part isn't in human readable format.  Anyone who owns the PHB knows what a Synergy Bonus is, but you can't see it on screen.*



*
*

If the program knows that Synergy bonus gives a +2 then it would be derivative content and therefore OGC.  If however, you define Synergy as a +2 bonus to a skill under such and such circumstances in the data file, then only your data file is OGC.



			
				Brent said:
			
		

> *Assuming the program is marked as OGC in the Help>About, is this a problem?
> What if I show the calculation on screen?
> What is I distribute a Class Library with the program?
> What is the difference between doing this and distributing an Excel spreadsheet with a formula such as: Ranks + SynergyBonus?*



*
*

If you mark your program as OGC than that should be fine.  Keep in mind that if you do so then someone else could actually sell your program and they would only have to update section 15 of the OGL.


----------



## Luke (Oct 5, 2002)

smetzger said:
			
		

> *
> 
> 1) "Human Readable" is not part of the d20 license.  Although "Clearly marked OGC" is.
> 
> 2) You can put OGC material in your "code" but that would mean that your code is now OGC also.  Therefore you would somehow need to mark your code clearly as OGC. *




If you check out the official OGL list archives, this issue has been re-opened many times. It's the "dead horse that won't die".

Wizard's position is pretty much that:
- "Clearly marked" effectively means human readable. The license and content is for humans.

- Your OGC code must live up to this as well. You simply cannot compile a program with OGC code buried in there. Even separately including your source doesn't get you off the hook. 

I agree that it's an unexpected point that will badly catch developers who've never delved deeply enough into the "official" information pipelines - but there it is.

Their position is pretty clear. If you want to contest the interpretation Wizard's put on the license, I gather you end up doing it in court. 
I really hope that such a thing never happens. What Wizard's have done with the the whole open gaming/3rd edition scenario is a wonderful gift that has worked very well for both them and the RPG community.
After all the effort I put into RPM over the last 1.5 years, the "gentleman's agreement" behind the draft SRD really worried me, but I have to say that Wizard's have come through at every level!

Regards,


----------



## CRGreathouse (Oct 5, 2002)

smetzger said:
			
		

> *If the program knows that Synergy bonus gives a +2 then it would be derivative content and therefore OGC.  If however, you define Synergy as a +2 bonus to a skill under such and such circumstances in the data file, then only your data file is OGC.*




It may still be derivitive.  The OGL listserv constantly debates this issue -- how far must closed code be from OGL material?  There are some pretty hard-line views there.


----------



## CRGreathouse (Oct 5, 2002)

Luke said:
			
		

> *Wizard's position is pretty much that:
> - "Clearly marked" effectively means human readable. The license and content is for humans.
> 
> - Your OGC code must live up to this as well. You simply cannot compile a program with OGC code buried in there. Even separately including your source doesn't get you off the hook.*




There's a way to get around this: declare the entire binary OGC.  Of course, this generally requires you to own all of the libraries and causes problems of its own, but...


----------



## Luke (Oct 5, 2002)

CRGreathouse said:
			
		

> *There's a way to get around this: declare the entire binary OGC.  Of course, this generally requires you to own all of the libraries and causes problems of its own, but... *




You still can't put anything derived from the SRD (the core rules) into compiled a binary (if you plan to distribute it in some way).

I'm not sure about putting any of your own new material (that isn't an SRD derivation) into a binary. By it's very nature *Open* Game Content, and *binary* tend to be mutually exclusive. It still isn't _clearly identified_ (in human readable format).

_Clearly identified_ seems to be the crux of the problem. A compiled binary tends to bring together non-game material (user interfaces and other things), along with core SRD (which is necessarily open), and SRD derivations (which is necessarily open), and finally, possibly completely new material (such as a new setting, which is either open or closed, at the author's discretion).
In binary form, none of these different portions is necessarily clearly identified from each other.
Finally, Wizards have provided the SRD to you as *open*, with the condition that anything you derive from directly is also *open*. That is to say, you were able to make use of Wizard's intellectual propoerty, and your distributed derivation must also be just as usable by others. Human readable content (such as scripts) satisfy this, but a compiled binary doesn't (others can't derive from it).


----------



## Sm!rk (Oct 5, 2002)

How about including the license as a string somewhere in your code, const char * etc. Then including an app like string from Unix which will output all the strings in a binary, which in this case will also output the OGC license?


----------



## Luke (Oct 5, 2002)

Sm!rk said:
			
		

> *How about including the license as a string somewhere in your code, const char * etc. Then including an app like string from Unix which will output all the strings in a binary, which in this case will also output the OGC license?
> *



As long as it picked out *every* SRD and derivation thereof in the binary and output that as well


----------



## Fractalwave (Oct 5, 2002)

Luke said:
			
		

> *
> 
> If you check out the official OGL list archives, this issue has been re-opened many times. It's the "dead horse that won't die".
> 
> ...



You're absolutely right about this Luke. People are being given a wealth of information in this thread. It'll be interesting to see what they do with it.

One caveat regarding the OGL lists. The OGL list archives are full of information, though you do need to read them carefully. Just as people are playing 'what if' in this thread that is done there to a much larger degree. You can learn a lot in those lists. But don't make the mistake of assuming it's all correct.

*What I see happening with RPG programming tools is:*

_People are programming without taking the licenses into account._
Ignorance is no excuse. And ignorance is easily overcome by just a little bit of research. I'm not sure what that says about programmers who don't do the research.

_People are programming in such a manner that the licenses are attacked._
This is just a general attitude taken by some. I don't recommend this for several reasons. It makes you look like you don't give a hoot about the licenses and just want to abuse them. This is very much a gaming 'community' and attacking anything will result in a backlash of some form. You'll have a very difficult time digging yourself out of the hole of a reputation you give yourself if you do this. Also, I don't recommend this method unless you intend to take on WotC/Hasbro legally which would mean you need the resources to do so.

_People are programming in a manner where they are doing their very best to comply with licenses._
This is the best option as it's actually good for the entire community.

*So if it's advice you're wanting, here it is in a nutshell.*

Do the research. Assume an attitude of interpretation where if it was your license what's the most rigid interpretation you could give it. Then work from that point.

If you come up with something that's questionable according to that point of view then it's probably questionable according to WotC's point of view. At that point, you have two choices. You can do it anyway while entering into a series of discussions with WotC to prove your point. Or you can back off and come up with something else.

I will say that there are some issues that we at Twin Rose Software chose to push. We won some and we lost some. Such is life. You move on. Just remember that the ultimate group of people you must satisfy in order to use the OGL and/or the D20 license work for WotC. And working WITH them will be much better for you and the community in the long run.


----------



## smetzger (Oct 6, 2002)

Luke said:
			
		

> *
> I'm not sure about putting any of your own new material (that isn't an SRD derivation) into a binary. By it's very nature Open Game Content, and binary tend to be mutually exclusive. It still isn't clearly identified (in human readable format).
> 
> Clearly identified seems to be the crux of the problem. A compiled binary tends to bring together non-game material (user interfaces and other things), along with core SRD (which is necessarily open), and SRD derivations (which is necessarily open), and finally, possibly completely new material (such as a new setting, which is either open or closed, at the author's discretion).
> *




I still fail to see why you couldn't just say "This whole program and all the data files are OGC."  As long as you only included 3rd party material that was in fact OGC.   You have just opened up the door for anyone to take your binary file and use it just as they would any other OGC material.  I think its just the same as when a 3rd party publisher says "anything derived from the SRD is OGC."  

Besides Binary is human readable.   PDF files are binary so why not an executable program that needs a Windows OS to 'read' the binary code instead of Acrobat Reader to 'read' the binary PDF.

If WOTC wants to further define what is and what is not clearly identifiable they should come out with a new license for d20.


----------



## Luke (Oct 6, 2002)

smetzger said:
			
		

> *
> Besides Binary is human readable.   PDF files are binary so why not an executable program that needs a Windows OS to 'read' the binary code instead of Acrobat Reader to 'read' the binary PDF.
> *




Well, you could say that everything is binary (coded as ones and zeros), but a subset of that is ascii that makes sense to a human reading.
PDFs are binary, but they're also human readable, as are word documents.
A program like RPM has database tables that have SRD content in binary format (internal integer, floating point numbers, and even rick-text format descriptions that are not strictly human readable).The point is that RPM also comes with a method that reveals every piece of SRD (and SRD-derived ) content in a human readable format. This is in the form of tabale table viewers, and script viewers.
The content is still open, and you could copy and paste anything to make use of it.


----------



## Anakyne (Oct 6, 2002)

Very interesting thread... and one by witch I'm deeply concerned. I am about to start developping my own OGC/D20 application. I have plan it for a while and have started coding... My main concern remains with the respect of the OGL.

I have made several choices for my implementation (db-base, non-db-base, etc) and one of my main concern is how I could dynamically add methods/procedures within my application at runtime considering my development environment.

I don't plan on having a database or datafiles containing the OGC content ! I would like to implements the information within my code in Classes. Now considering the current thread, this would be against the OGL.

However, since my endeavour is not commercial, what if I distribute the complete source code freely and explain to users how to install the development environment (freely available), load the code and compile their own version ?

(regards to dmgenie software author, I work in the city where he live


----------



## Luke (Oct 6, 2002)

Anakyne said:
			
		

> *
> However, since my endeavour is not commercial, what if I distribute the complete source code freely and explain to users how to install the development environment (freely available), load the code and compile their own version ?
> 
> (regards to dmgenie software author, I work in the city where he live  *




I can definitely tell you that it's irrelevant whether or not your application is commercial.

Quite probably, though, you could distribute your source code, but you wouldn't be able to distribute a binary with it, or make a binary available to anyone.
Anyone who wanted to use your stuff would have to set  up their own development environment and compile it themselves, as you suggest.

Do you suspect that given all the hassle and issues with being able to supply a decent program that doesn't rely on decent 3rd party components (which you are unlikely to be able to provide with your source), that you'll actually offer something better than is already available?


----------



## Fractalwave (Oct 6, 2002)

Anakyne said:
			
		

> *However, since my endeavour is not commercial, what if I distribute the complete source code freely and explain to users how to install the development environment (freely available), load the code and compile their own version ?*



There are other considerations, as well, that are discussed on the OGF lists and apply to programming specifically.

One item that comes to mind is license compatibility. Using software libraries and licenses can make the material in the program be considered to be derivative of those libraries and licenses. It depends on how the particular software license you use reads. Almost all licenses that are open have a little clause in them that talks about how no other license can apply. Other licenses talk about when the program you write is considered to be derivative of their libraries, etc.

So you must be careful about which you use and whether they allow you to comply with the license(s) from WotC that you are using. One thread ended with a serious discussion as to whether publishing PDF's was not compliant with WotC's licenses and why. And yes, that's an extreme example.

I'm not going to go into details. This discussion has been killed several times on the OGF lists and it won't die. At this point it can get to be very complicated and I highly recommend that you go to the archives of the OGF lists for the technical discussions.


----------



## CRGreathouse (Oct 6, 2002)

Luke said:
			
		

> *You still can't put anything derived from the SRD (the core rules) into compiled a binary (if you plan to distribute it in some way).
> 
> I'm not sure about putting any of your own new material (that isn't an SRD derivation) into a binary. By it's very nature Open Game Content, and binary tend to be mutually exclusive. It still isn't clearly identified (in human readable format).
> 
> ...




OGC doesn't need to be human readable.  Releasing an entire binary as OGC is fine, assuming you have the legal right to so release it and don't mind that anyone can distribute the binary.


----------



## Luke (Oct 6, 2002)

CRGreathouse said:
			
		

> *OGC doesn't need to be human readable.  Releasing an entire binary as OGC is fine, assuming you have the legal right to so release it and don't mind that anyone can distribute the binary. *




That's why I distinguished between SRD/SRD-derived content, and your own *(pure)* OGC.
If you distribute a work that does contain SRD or SRD-derived content then it must remain open and clearly distinguished (ie human readable). The same applies if you use other people's OGC.
Mixed in with other binary content doesn't cut it.

You're right about "assuming you have the legal right to so" - which you *don't have*, if there's any of that SRD, SRD-derived, or others OGC inside it.


----------



## Klintus Fang (Oct 6, 2002)

This is all very interesting.  I've worked off and on on gaming utility software for my game, so I have some cursory interest in this topic.

I get the impression that if one codes up all of the SRD material one needs into data tables that can be read by the binary, and then has all the binary's calculations derive only from the content in those tables, then you are in compliance so long as your data tables are in compliance.  It seems this would have to be the case anyway, because if you code it up this way then the program is in essence nothing more than a generic "data file interpreter".

So I have a question:  why don't a team of disparate people get together and rewrite the entire content of the SRD in some agreed upon (the team would have to haggle and debate to achieve that agreement), human readable , XML format (assuming XML is considered "human readable") that all of us can then use in our programs?

It seems like that might be a big undertaking, but wouldn't it simplify life for a lot of people?  It would definitely simplify life for a newbie like me.


----------



## Fast Learner (Oct 6, 2002)

If it included an XSL stylesheet that cleared out the tags then the two together would surely be considered human readable, eh?


----------



## Klintus Fang (Oct 6, 2002)

I would not know, but I would assume so.

I know next to nothing about XML.  But I am a programmer and am familiar with numberous other data formats, so I could familiarize myself with it fairly quickly.  In other words, I'll set out trying to convert the SRD to XML by myself eventually I am sure.  

But why I should do so alone, I have no idea.  I guess the PCGen people are doing that to some degree, no?


----------



## Fractalwave (Oct 6, 2002)

Klintus Fang said:
			
		

> *I would not know, but I would assume so.
> 
> I know next to nothing about XML.  But I am a programmer and am familiar with numberous other data formats, so I could familiarize myself with it fairly quickly.  In other words, I'll set out trying to convert the SRD to XML by myself eventually I am sure.
> 
> But why I should do so alone, I have no idea.  I guess the PCGen people are doing that to some degree, no? *



The main problem with doing this has been getting anyone to come to a consensus on the XML DTD. There is a group working on it. I just wouldn't hold my breath.


----------



## CRGreathouse (Oct 6, 2002)

Luke said:
			
		

> *If you distribute a work that does contain SRD or SRD-derived content then it must remain open and clearly distinguished (ie human readable). The same applies if you use other people's OGC.
> Mixed in with other binary content doesn't cut it.*




No.  Example:

Hypothetical SRD OGC


> Blah.




Hypothetical SRD-based program source (red comes from 'SRD')


> System.out.println ("Blah");




Hypothetical OGC declaration (OGC in green)


> System.out.println ("Blah");




Hypothetical compiled [binary] (OGC in green)


> 01000101010010101010101001010101010100101000010101011010100101010010101010010101010101001010100010010100100111100101010101010110101001010101010010100101




This is perfectly acceptable.  The OGL never requires OGC to be human-readable.


----------



## Klintus Fang (Oct 7, 2002)

Fractalwave said:
			
		

> *The main problem with doing this has been getting anyone to come to a consensus on the XML DTD. There is a group working on it. I just wouldn't hold my breath. *




Who is working on it?


----------



## Luke (Oct 7, 2002)

CRGreathouse said:
			
		

> *...This is perfectly acceptable.  The OGL never requires OGC to be human-readable. *




I'm just repeating myself here:
- Wizard's interpretation is that "clearly identified" implies "human readable".
- As far as they're concerned open scripting is a viable method for expressing SRD mechanics, but compiled binary isn't.
- This has surfaced many times in the official forums in often heated discussion, and has never been refuted.
- Interpret it differently, then distribute despite warnings, and you probably end up defending your interpretation in court.

That's not the way I wanted it to be, but it is the way it is. It certainly made my life a *lot* harder, and it's probably the one single great reason that you see unexpectedly few 3rd edition apps out there doing good stuff. I had to develop an entire RPG scripting engine to make RPM legally possible.


----------



## CRGreathouse (Oct 7, 2002)

Luke said:
			
		

> *I'm just repeating myself here:
> - Wizard's interpretation is that "clearly identified" implies "human readable".
> - As far as they're concerned open scripting is a viable method for expressing SRD mechanics, but compiled binary isn't.
> - This has surfaced many times in the official forums in often heated discussion, and has never been refuted.
> ...




I'll also sum myself up: Wizards does not believe that binaries allow for any identification of OGC beyond all/none.

I'll edit in supporting links from the OGF mailing list later; their website seems to be down at the moment.


----------



## Luke (Oct 7, 2002)

Klintus Fang said:
			
		

> *I get the impression that if one codes up all of the SRD material one needs into data tables that can be read by the binary, and then has all the binary's calculations derive only from the content in those tables, then you are in compliance so long as your data tables are in compliance.  It seems this would have to be the case anyway, because if you code it up this way then the program is in essence nothing more than a generic "data file interpreter". *




No.

Both code *and* data that is part of the SRD needs to fulfil the criteria. Making the data alone openly readable (clearly identified), isn't enough.

Consider working out a creatures AC, by way of example. You may pull together a whole bunch of modifiers (dodge, dex, armor, magical enhancement, natural AC, magical item benefits, size etc etc).
The SRD is the source that tells you that the AC is 10, and what sort of modifiers are applied to it.

Now, the process of adding these together (choosing the right things to add), and applying the correct stacking rules, is all an SRD derivation. Therefore, _the code that does all the work of calculating the AC_ is a derivation of the SRD, and must fulfil the license obligations. It can't be in binary.


----------



## Luke (Oct 7, 2002)

CRGreathouse said:
			
		

> *
> 
> I'll also sum myself up: Wizards does not believe that binaries allow for any identification of OGC beyond all/none.
> *




How does that reconcile with why PCGen had to go and do all that restructuring.

They are a free, open source project. Is it really possible that all they had to do was say - our entire "binary" is all OGC, and somehow everybody missed it?


----------



## Anakyne (Oct 7, 2002)

> _Originally posted by Luke _*
> I can definitely tell you that it's irrelevant whether or not your application is commercial.
> *




I know what I meant is that I don't care if the source code is distributed  since it won't be shareware nor commercial.



> _Originally posted by Luke _*
> Quite probably, though, you could distribute your source code, but you wouldn't be able to distribute a binary with it, or make a binary available to anyone.
> *




Ironically I could even only distribute two binaries, binaries that are used by the development environment which allow to consult the code... but that's another matter.



> _Originally posted by Luke _*
> Anyone who wanted to use your stuff would have to set  up their own development environment and compile it themselves, as you suggest.
> *




The environment is not complicated, download, install, copy two files, run through some steps for compilation... done... but I agree, it's not a good idea for end users... but only a way to respect the license. And since I have found other ways to compile at run time 



> _Originally posted by Luke _*
> Do you suspect that given all the hassle and issues with being able to supply a decent program that doesn't rely on decent 3rd party components (which you are unlikely to be able to provide with your source), that you'll actually offer something better than is already available? *




First of all, I don't expect to offer something better than is already available. I only hope for that


----------



## Anakyne (Oct 7, 2002)

> _Originally posted by Fractalwave _*
> There are other considerations, as well, that are discussed on the OGF lists and apply to programming specifically.
> *




[...]



> _Originally posted by Fractalwave _*
> One thread ended with a serious discussion as to whether publishing PDF's was not compliant with WotC's licenses and why. And yes, that's an extreme example.*




To some extent, PDF are binaries AFAIK... But to get this further, do you consider RTF to be human readable ? However WOTC are distributing the official release of the SRD as RTF... not as TXT ? I'm not denouncing what WOTC do, they can do what they want with their OGC, basically the OGF has really been a good thing for RPG IMHO.


----------



## Klintus Fang (Oct 7, 2002)

Luke said:
			
		

> *
> 
> No.
> 
> ...




I'm aware of that Luke.  But you misunderstand me.  I am thinking much more general.  I am assuming that _every game mechanic_ will be encoded in this theoretical data file, including all the rules for how stacking works (to take your example).  I am assuming that the core engine will read the data file to determine what the stats are, and what their names are.  The data files will also inform the binary of what type of value each stat holds (could be an integer, a string, a float or whatever).  The core binary won't even assume that any such stat as "AC" even exists.  It will find that in the data file.  It will also find in the data file that this thing called "AC" is a sum of a bunch of other things (also defined in the data file).  Those other things would be some stats called things like "AC:natural", "AC:armor", "AC:deflection", etc.  Then in the data file there will also be some rules that specify how to calculate each of these sub-stats.  Stacking rules really aren't a big deal in that respect.  To calculate "AC:deflection" you simply specify in the data file that you take the "maximum" of all the relevant components rather than summing them together.

I realize there would have to be a lot of nitty gritty details that would make defining the format of this data file a serious endeavor, but in principle there is no reason that all of the rules cannot be encoded in a data file in such a way that a general purpose "rpg engine" would be able to interpret it and then construct a set of data structures at run time that model the rule system.  This engine would _assume nothing that can be construed as another person's copyrighted material._  It would assume only that there will be a bunch of statistics that need to be calculated and added together according to certain rules, all which will be defined in some data file that has a predefined format.


----------



## Klintus Fang (Oct 7, 2002)

In fact, _in theory_, (though this would be a nigh impossible thing to code), if the technology for software that is able to intuit meaning from text was just a little better, there is no reason that a person could not write a program that was capable of reading the SRD directly, figuring out the rules and then building a character generator, or combat management tool, or what have you, at run time.

In truth this is what I have in mind.  I'm just proposing that someone rephrase the SRD in a more "table oriented" format that makes the process of interpreting it and constructing a model of the rule system easier.

Instead of 



> Every character has six basic ability scores:  Strength, Dexterity, Constitution, Intelligence, Wisdom, Charisma....




One would write something like:

begin_stat_group ability_scores("Ability Scores")
integer str("Strength")
integer dex("Dexterity")
integer con("Constitution")
integer int("Intelligence")
integer wis("Wisdom")
integer cha("Charisma")
end_stat_group

etc.


----------



## Mynex (Oct 7, 2002)

Klintus Fang said:
			
		

> *
> 
> I'm aware of that Luke.  But you misunderstand me.  I am thinking much more general.  I am assuming that every game mechanic will be encoded in this theoretical data file, including all the rules for how stacking works (to take your example).  I am assuming that the core engine will read the data file to determine what the stats are, and what their names are.  The data files will also inform the binary of what type of value each stat holds (could be an integer, a string, a float or whatever).  The core binary won't even assume that any such stat as "AC" even exists.  It will find that in the data file.  It will also find in the data file that this thing called "AC" is a sum of a bunch of other things (also defined in the data file).  Those other things would be some stats called things like "AC:natural", "AC:armor", "AC:deflection", etc.  Then in the data file there will also be some rules that specify how to calculate each of these sub-stats.  Stacking rules really aren't a big deal in that respect.  To calculate "AC:deflection" you simply specify in the data file that you take the "maximum" of all the relevant components rather than summing them together.
> 
> I realize there would have to be a lot of nitty gritty details that would make defining the format of this data file a serious endeavor, but in principle there is no reason that all of the rules cannot be encoded in a data file in such a way that a general purpose "rpg engine" would be able to interpret it and then construct a set of data structures at run time that model the rule system.  This engine would assume nothing that can be construed as another person's copyrighted material.  It would assume only that there will be a bunch of statistics that need to be calculated and added together according to certain rules, all which will be defined in some data file that has a predefined format. *




Just to chime in here, you realize, what you described above, is exactly how PCGen operates now?

All the information _is_ contained in the data files, the interface itself is completely dumb and will not do anything it is not told to specifically do by the data files with regards to character creation.

This applies to stats and AC calc's etc, but does not apply to random character name generation (by definition a name does not determine success or failure for a character, so per Wizards that is legitimate)...  But the data files tell the interface 'Hey, I have x stats here, these are their names, here's a short name, here's what they do, and here's how they work'... each class is broken down completely for it's BAB's, saves, etc, and tell the interface what to do.  same for spells, equipements, skills, etc...

Now it's not perfect, there's still some bugs to work out (ins't there always? ), but the end goal is to be completely generic, eventually being able to define any rule sets in the data files telling the interface what to do.  And yes, eventually, we'll be moving the data formats, currently text, to XML to make them easier to manipulate by other programs, but that's still a work in progress.


----------



## ladyofdragons (Oct 7, 2002)

I've been watching this thread with interest, because I've been working on my own D20 software off and on (mostly off) for some time now, mostly as a programming exercise.  I have a few comments and questions.

1) Repeatedly people say to look in the OGL lists.  I went ahead and tried to search through the lists to find these elusive posts, try to get some more info.  Which would probably take me hours, since there isn't a search facility or a FAQ or anything, and nobody's nice enough to actually subject their posts properly as to the nature of the information contained therein so I'd have to read every post for the past 6 months.  Just a comment on my part about the state of the OGL lists, which I am now subscribed to.

2)  binaries vs. 'human readable'.  I'm a VB coder, and as such my code is compiled into binary.  So, I'm trying to figure out ways to do what I need without violating any licenses, and without having to load all of the script in afterwards as text (which will slow things down considerably).  So trying to figure out what's legal:
- could I have a button on each form that will bring up notepad with the uncompiled code for that form, as well as code in all called modules & classes, with OGC-derived content clearly marked?  it's not exactly like giving out the source code with the binary, and would be human readable.
- or perhaps just have buttons that come up listing just the code bits that are OGC-derived.  Maybe in a help file?  then you could click the AC label, and it would bring up the topic containing the code used to derive AC, and that it is OGC derived content.
- I've created a database to hold the information.  The database currently is in Access, and is human readable (if you have Access).  Can I just say that the database structure is my own design, based on principals that are OGC-derived?  

This is such a sticky situation.  I'd rather do this right the first time than have to go back and change it later like so many small-time coders are doing.


----------



## Luke (Oct 7, 2002)

ladyofdragons said:
			
		

> *
> - could I have a button on each form that will bring up notepad with the uncompiled code for that form, as well as code in all called modules & classes, with OGC-derived content clearly marked?  it's not exactly like giving out the source code with the binary, and would be human readable. *




There seems to be an easy legal approach to this which is technically challenging,  and a technically easy approach which is legally very difficult.
Charles suggests a different easy "silver bullet" where anything is okay, as long as you declare everything open.

If I were to hedge a bet, I'd suggest that the reason PCGen didn't take Charles' easy silver bullet, was because WotC wouldn't wear it.

What I can tell you is that when WotC tested my own software, they wanted to know that changing what I show as SRD-derived scripts actually changed the interpretation of the rules. There was a very strong implication that what I showed as being the SRD-derived content actually needed to be what was being executed. This is another way of saying that distributing source and compiled binary may not be sufficient. You need to execute the source itself. A notepad showing context-sensitive source for binaries is unlikely to be okay. If you think about it, binary and supplied source are different things, and it's only your word that indicates that they are even the same thing.

I've really being trying to avoid saying this, but here goes...
Without putting any names to it (and I'm disinclined to explain this any further):

The originator(s) of the SRD and the OGL behind it were fairly convinced that software of the RolePlayingMaster-type capabilities would never occur - especially from a fan-based effort. Wizard's interpretation of their license was that such an application would throw almost everyone, because of the compiled binary problem.
Guys, from a developer viewpoint - it's not to difficult to knock up a "DM Genie" style app. It's a lot harder to go the RPM/PCGen route, and actually comply with the license.
This whole binary/human-readable problem is the crux of the issue. Wizards did not expect a workable solution to appear from a fan-based effort.

So, you can accept the Wizard's interpretation of their own license implications and try to work with that (yes, it's hard), or you can look for an easy way out, and risk resolving it in court.

As I stated before (as has being echoed by another), I really hope that people work with "the spirit" of the license. This entire possibility from Wizards is a gift, and trying for loopholes in the license does not help the industry.

I can understand that the difficulties are frustrating for those of us who really want to create something they can share with the community. I agree that the whole "clearly indicated/human readable" gotcha can too easily catch out those who start with the best of intentions to follow the license ( aka DM Genie) - but there it is...
Life is easy for "paper" publishers, and a lot harder for software publishers.

I remember the TSR days where anything even remotely like a D&D application landed you threats of court-time. Now, Wizard's have even given you the ability to compete with their own product (E-Tools). I certainly don't blame them for not making it an easy "free-for-all". I suspect that Wizards technically risked millions of dollars worth of intellectual property in going down the whole opening gaming path, to our own advantage, and I'd hate to see a loophole-search somehow succeed in invalidating the concept. Of course, disputes in interpretation are ultimately decided in courts - and I don't think Wizards would lose.

It may seem that this is an easy position for me to adopt, since I am now "vetted" against the license. From the start, though, I made a clear decision to take the hard road, and to work with the license, rather than against it. That made it a very hard road...

Perhaps Wizards could release another version of the OGL. They wouldn't need to give up any restrictions, but could reword a little to make these issues a bit more obvious.


----------



## ladyofdragons (Oct 7, 2002)

Luke said:
			
		

> *
> 
> There seems to be an easy legal approach to this which is technically challenging,  and a technically easy approach which is legally very difficult.
> Charles suggests a different easy "silver bullet" where anything is okay, as long as you declare everything open.
> ...




ah.  I can see that.  hmm.  quite a pickle then.  Alrighty.  if I were to have a log window, that showed every bit of OGC-derived functionality as it was being performed (hideable by uninterested users) including formulae and OGC notes, would that be moderately acceptable? 

I realize this is probably a pain for those like twinrose, pcgen and you to keep answering all these questions when you've long since done the work to make sure that you're OGL compliant, but for those of us just starting out, I give my thanks for your opinions on the subject.  I'm posting here trying to come up with a solution that perhaps all little freeware developers can follow when designing their fan-based program, so they don't have to get all the way through and then realize they need to completely rewrite in order to avoid litigation.  I'm not a lawyer, I'm a code monkey.


----------



## Luke (Oct 7, 2002)

ladyofdragons said:
			
		

> *
> 
> ah.  I can see that.  hmm.  quite a pickle then.  Alrighty.  if I were to have a log window, that showed every bit of OGC-derived functionality as it was being performed (hideable by uninterested users) including formulae and OGC notes, would that be moderately acceptable? *



If I read you correctly, that's okay. You'd be going a lot further than you actually need to go, though. Showing OGC-derived functionality as it's executed is a (typically) heavy and unnecessary burden. Just having it there and viewable should be sufficient.




			
				ladyofdragons said:
			
		

> *I realize this is probably a pain for those like twinrose, pcgen and you to keep answering all these questions when you've long since done the work to make sure that you're OGL compliant, but for those of us just starting out, I give my thanks for your opinions on the subject.  I'm posting here trying to come up with a solution that perhaps all little freeware developers can follow when designing their fan-based program, so they don't have to get all the way through and then realize they need to completely rewrite in order to avoid litigation.  I'm not a lawyer, I'm a code monkey. *



Not a problem. I agree with you. I'm sticking out my own neck here and saying things people probably don't want to hear, so that we can hopefully avoid the type of situation that arose around the "DM Genie" release. If Janik decides it's all too hard, and just walks away from it, that's a lot of wasted effort. Whether it's freeware or commercial is irrelevant to the license.


----------



## Luke (Oct 7, 2002)

*What do I know? Am I too harsh?*

Do I need to backtrack?

I've been saying that any SRD rules mechanics cannot be compiled into a distributable, and after coming out strong on this, I'm now a little shaken.

PCGen was vetted a while ago by Wizards, and I assumed that their latest release would show how they had tackled the issues. Out of interest, at the time, I downloaded PCGen to have a look at a vetted example.
I quick look seemed to show that they basically had a "compiled" jar file, and a bunch of lst files. At the time, with only a brief look, it seemed to me that the lst files were pure data, and that the compiled mechanics were in the compiled file (the bites that add the numbers together). I was a little confused, but, being busy, moved on.

Having made some big statements on this thread about license compliance, though, I thought I'd go and have a closer look at the PCGen source that is actually compiled.

I want to stress that I've only had a cursory look, so it doesn't necessarility mean much, but what I found is surprising.

I picked on AC calculations by way of example. The calculations of AC, and the various sorts (standard, touch, range) and the bits that compose add up to make AC are, to my mind, clear SRD derivations that cannot be done in compiled code.

I actually found a file called "ACCalculator.java", which seems to be clearly compiled into the main executable.
That file clearly contains functions which implement SRD mechanics. An example is the "calculateACBonusTouch()" function which adds together size, dexterity and natural AC bonuses, to get the "touch AC".
There's lots of other examples. To a large extent, it appears that PCGen is mostly composed of generic processing functions that in themselves don't implement specific SRD functions. On the other hand, there are functions that I personally would clearly interpret as being derivations of the SRD. Since the lst files don't appear to contain anything other than pure data, I'm now assuming that virtually everything specifically calculated in PCGen (like a fully calculated save bonus, or skill check) is actually using compiled code.

This is pretty unexpected, and my confidence in what I've previously said is a little shaken. Either:
1) PCGen contains fundamental violations, and Wizards just missed them (seems unlikely), or;
2) I've been too harsh in my interpretations, of discussions and Wizard stances on the official OGL list.

How hard is all this?????


----------



## ladyofdragons (Oct 7, 2002)

*Re: What do I know? Am I too harsh?*



			
				Luke said:
			
		

> *Do I need to backtrack?
> 
> *snipped*
> 
> ...




I wonder if perhaps wizards isn't a bit subjective on their compliance calls.  I don't know if they've come up with an actual standard yet on what crosses the line as far as uncompiled/compiled code,  it would seem that they tell different people different things (maybe just to keep us guessing?).  Until they come up with an OGL software license that spells things out for software versus published text-type material, it's very difficult to tell.

I for one am going to add the logging function (a 3 level logger should do it, none/minimum/verbose) when it comes time to doing calculations based on OGC information, but for now I'm still working on saving and retrieving various information from the database, and I have each record with an OGC signifier, so I'm pretty sure I'm safe so far


----------



## smetzger (Oct 7, 2002)

*Re: What do I know? Am I too harsh?*



			
				Luke said:
			
		

> *This is pretty unexpected, and my confidence in what I've previously said is a little shaken. Either:
> 1) PCGen contains fundamental violations, and Wizards just missed them (seems unlikely), or;
> 2) I've been too harsh in my interpretations, of discussions and Wizard stances on the official OGL list.
> 
> How hard is all this????? *




Yes, PCGen does have what they call 'Tags' in their .lst data files.  These 'Tags'  are representations of rules which can be configured by the data that is associated with the 'Tag'.  Thus via 'Tag' and data manipulation you should be able to tell PCGen to calculate AC in a different manner.  The way I read the OGL is that this is legal and this is the direction I am going in my little project.

I also think that there is nothing wrong with designating a binary as OGC.  I think that this would be most useful for DLLs.

I do not think that these are 'loopholes' in the licenses.  I am grateful for WOTC in releasing the OGL and d20 licenses, but that doesn't mean that I won't take what is the easiest path to compliance for me.


----------



## CRGreathouse (Oct 7, 2002)

Luke said:
			
		

> *How does that reconcile with why PCGen had to go and do all that restructuring.
> 
> They are a free, open source project. Is it really possible that all they had to do was say - our entire "binary" is all OGC, and somehow everybody missed it? *




PC Gen doesn't have sufficient rights to release their binary as OGC, because they use outside libraries and work (worked?) under the LGPL.

I couldn't find the quote I was origianlly thinking of from the OGL mailing list, but I found another:
http://mail.opengamingfoundation.org/pipermail/ogf-l/2002-September/002528.html


----------



## Luke (Oct 7, 2002)

*Re: Re: What do I know? Am I too harsh?*



			
				smetzger said:
			
		

> *I also think that there is nothing wrong with designating a binary as OGC.  I think that this would be most useful for DLLs.
> *



Well, I just spoke to Anthony Valterra, and he clearly has a problem with it, if it contains any Wizards OGC in it.
As far as Anthony is concerned, any Wizard's OGC used in a program has to be openly readable, and you cannot distribute it in compiled binary form. That would obviously apply to DLLs as well.

Basically Anthony and Ryan Dancey engineered the SRD and OGL, and Anthony appears to be the person at the helm of it now.

I believe that we can possibly expect Andy of Wizards to post a message on this board soon, and help clear up these issues.


----------



## smetzger (Oct 7, 2002)

*Re: Re: Re: What do I know? Am I too harsh?*



			
				Luke said:
			
		

> *
> Well, I just spoke to Anthony Valterra, and he clearly has a problem with it, if it contains any Wizards OGC in it.
> As far as Anthony is concerned, any Wizard's OGC used in a program has to be openly readable, and you cannot distribute it in compiled binary form. That would obviously apply to DLLs as well.
> *




I would be interested in hearing what a non-WOTC lawyer has to say about that.  Once again we get back to the 'Clearly Marked' question.   The license does not define 'clearly marked' and this is the crux of the problem and is what a court would need to decide.  I think that saying everything in such and such product is OGC is very clear and I really don't understand how anyone could argue otherwise.  AV and Wizard's may indeed have a 'problem' with this however I think it is permissable by the OGL.  

If 'Clearly Marked' means 'human readable'  someone will need to explain how one type of binary file (PDF) and another type (DLL or exe) can be treated differently.  Actually anything in electronic format is not in human readable format but is interpreted in some way by a computer before it is displayed on a monitor or printed out.


----------



## CRGreathouse (Oct 7, 2002)

I look forward to having Anthony post here, but I expect it will come down to "it's OK in theory but it's never been done right, and we don't expect it ever will be".

If the entire thing's Open, all OGC is marked, so there can be no problem.  Human-readable is not required by the OGL and hard -- if indeed possible -- to define for binary files.


----------



## Fractalwave (Oct 7, 2002)

*WotC and their processes of vetting*

It is difficult, at best, to describe what you go through to "pass" their examination of your product. Though I think Luke did a decent job of it. And you don't get any type of "official seal of approval" which has everyone confused. But think about it, there is no official seal of approval for publishers either.

I think you can expect a change in the license and/or the guide soon to cover these questions that people keep asking of us.

We can't, however, tell you HOW to do things in order to be compliant with the license other than to tell you how we did some things at various times. There is always more than one solution to any given problem.

There is also the fact that WotC's interpretation has changed several times to the point that we changed things within our program at different times in order to comply with their interpretation of the d20stl if the change in interpretation affected our program. That is one challenge with the d20stl as it relates to software. Right now, it's a moving target and hasn't settled down yet.

Also, you don't simply "pass" once and that's it. You can expect review, after review, after review. That's why we've said we've been talking to them for quite some time. (In fact, we dropped the d20stl from our product and we're STILL talking to them all the time.) It's been an ongoing process that includes in our QC for us to vet our own software after each update to make sure it's in compliance as of the last information we had from WotC. Even though the d20stl is being removed, we still vet our software for OGL compliance.

Because of this constant review process, if something is found in any software after it "passes" I am absolutely positive that WotC will address it with whomever distributes the product in question. I know we've been asked to change things from time to time, mostly just cosmetic things but they were still there.


----------



## CRGreathouse (Oct 7, 2002)

Luke said:
			
		

> *Charles suggests a different easy "silver bullet" where anything is okay, as long as you declare everything open.*




No matter where you stand, my solution is no silver bullet.  I don't know anyone who could release their compiled code as OGC, since it would require rewriting just about every basic programming function.  Even free software generally comes with terms of use (GPL, shaeware, etc.), so they couldn't be used.

However, if someone was willing to basically develop a programming language from the ground up and use it to make a binary derived only from their own efforts and information in the public domain, they could then add content from the SRD and OGL it.  It's not easy, and hardly practical, but it is possible.


----------



## smetzger (Oct 8, 2002)

CRGreathouse said:
			
		

> *
> 
> No matter where you stand, my solution is no silver bullet.  I don't know anyone who could release their compiled code as OGC, since it would require rewriting just about every basic programming function.  Even free software generally comes with terms of use (GPL, shaeware, etc.), so they couldn't be used.
> *




You should be able to release the binary as OGC.  This would be analogous to a publisher releasing a PDF product but not releasing his original work before he laid it out in PDF format.


----------



## Klintus Fang (Oct 8, 2002)

Mynex said:
			
		

> *
> 
> Just to chime in here, you realize, what you described above, is exactly how PCGen operates now?
> *




That's interesting.  I did download the PCGen source code and looked through it recently and I saw words like MONK and AC inside the definitions of some of PCGen's internal data structures.  This put quite a sour taste in my mouth, and led me to assume that PCGen was not entirely generic in its implementation.   Maybe those are hold overs from older versions of PCGen.  I'll take another look and see.

In any case, my interest in PCGen is somewhat limited:  it is too slow.  I'm not sure if that's because of PCGen or if it's inherent to Java or if its a side affect of the fact that PCGen depends on Sun's rather slow Java implentation.  After I installed the version of Java that PCGen says it requires (1.4.1), _*web browsing became slower across the board on my machine*_ (at least for any website that has a fair amount of Java going on behind the scenes) so I'm guessing maybe the Sun Java implementation is the culprit.


----------



## Klintus Fang (Oct 8, 2002)

Luke said:
			
		

> *
> The originator(s) of the SRD and the OGL behind it were fairly convinced that software of the RolePlayingMaster-type capabilities would never occur - especially from a fan-based effort. Wizard's interpretation of their license was that such an application would throw almost everyone, because of the compiled binary problem.
> *




That seems a very unwise assumption for them to have made.  It is not conceptually difficult to create a binary that makes no assumptions, contains no copyrighted content, but which can model the rule system exactly just by reading an appropriate data file that contains all the SRD material.  If just takes time.

It doesn't have to be slow either; not if the internal data structures are well constructed so that interpretation of the "rule set data file" occurs only during initialization.


----------



## merton_monk (Oct 8, 2002)

*code notes*

Hey all - we saw the comments in this thread about our code, so Mynex called Anthony Valterra to discuss it.  Anthony's take was, as Mynex then relayed to me, that as long as the code acts only like a calculator, that they're fine with it.  What that means is that as long as the code doesn't say "Well you get a dexterity bonus of +2 for your dex and an armor bonus of +3 which gives you a total bonus of +5" you're okay.  PCGen's code asks the stats (and there can be a variable number of stats, and none of them might be named "Dexterity"  You could create a stat named Hilda that impacted the AC if you so desired) for its AC modifier, and gets the AC modifier from your equipment, etc. and sums it all up.  

It sounds like Wotc is in the process of considering new wordings for the licenses to specifically speak to software issues, which I'm glad to hear.  The licenses were obviously written with printed press type works in mind and they just kind of slapped some software clauses in there - mostly because I don't think that 3 years ago they thought there'd be much in the way of fan generated software.  Now that they've had a lot of contact with various software groups I think they have a pretty good handle on what's causing the most confusion and they know that a lot of people are interested in their clarifications.


----------



## Cergorach (Oct 8, 2002)

1.) Could you call Dexterity "A" instead of Dexterity? And then still have all the mechanics in the binary? An external data file wouls say "A"=Dexterity
2.) Would it be 'legal' to make a source that's human readable and let the user compile it into a binary (preferably with a couple of klicks)?
3.) How far do you have to go in seperating data (OGL) and calculation (program)? Is it neccesary to have the formula for calculating AC in the data file or may i have that in the binary?


----------



## Klintus Fang (Oct 8, 2002)

Cergorach said:
			
		

> *1.) Could you call Dexterity "A" instead of Dexterity? And then still have all the mechanics in the binary? An external data file wouls say "A"=Dexterity
> *




I rather suspect not.  If it were that easy then a simple perl script could convert the entire source of any program to something that was compliant in about 10 minutes.



> *
> 2.) Would it be 'legal' to make a source that's human readable and let the user compile it into a binary (preferably with a couple of klicks)?
> *





It seems like it.  In fact that option is already being discussed on this thread....




> *
> 3.) How far do you have to go in seperating data (OGL) and calculation (program)? Is it neccesary to have the formula for calculating AC in the data file or may i have that in the binary? *




That seems to be an open question (at least on this thread).


----------



## Luke (Oct 8, 2002)

Cergorach said:
			
		

> *3.) How far do you have to go in seperating data (OGL) and calculation (program)? Is it neccesary to have the formula for calculating AC in the data file or may i have that in the binary? *



You cannot distribute a binary that encodes formula derived from the SRD.
As far as the license is concerned, content is content, and it really makes no difference whether the content is data or an algorithm.

This is what seems to catch people out.


----------



## Cergorach (Oct 8, 2002)

Luke said:
			
		

> *
> You cannot distribute a binary that encodes formula derived from the SRD.
> As far as the license is concerned, content is content, and it really makes no difference whether the content is data or an algorithm.
> 
> This is what seems to catch people out. *




Ok, maybe i wasn't to clear, what i meant was:
data (OGL) = human readable txt file
calculation (program) = binary

The problem i have with what is being said here is that the SRD/OGL 'prohibits' the use of algorithms that are in the SRD/OGL, correct? If so, the SRD/OGL also shows us how to add two values, does that mean that i can't make an OGL/SRD application that adds values in it's binary? (I hope i just heard a resounding NO!) Then my question is what can i code into a binary and what can't i?


----------



## Sm!rk (Oct 8, 2002)

Luke said:
			
		

> *
> The originator(s) of the SRD and the OGL behind it were fairly convinced that software of the RolePlayingMaster-type capabilities would never occur - especially from a fan-based effort. Wizard's interpretation of their license was that such an application would throw almost everyone, because of the compiled binary problem.
> *




I doubt highly that this is the case. You are saying that some number of non-technical people made a guess on software tecnology and figured that it would be out of the limits of fan based software to make a externally data driven program.
Considering the open source movement have created everything from operating systems to professional level image software, and the OGL seems to take its thoughts from many of the open source licenses I believe this statement to be complete conjecture and unbelievable.

In other words the people involved knew enough about OS to model their licenses and license goals from them, but were unaware of the scope of many of the OS projects? Doubtful.

The intent as can be easily seen reading the OGL and any of the OS licenses GPL in particular is that the "content" in this case will remain open and can be reused by anyone who wants to use it. 

We haven't see any of this *yet* but its perfectly acceptable for me to go and grab all the PCGen data files and reuse them in some other app of my own invention. THis is the point, and if PCGen has added in other OGL content beyond the SRD, I benefit since I don't have to reengineer the data myself. This should also apply to all the other software products, wether your product can handle changes in the date IMO seems meaningless, as long as I can use your data in some other program then the "open-ness" is satisfied.


----------



## Twin Rose (Oct 8, 2002)

Sm!rk said:
			
		

> *
> We haven't see any of this *yet* but its perfectly acceptable for me to go and grab all the PCGen data files and reuse them in some other app of my own invention. THis is the point, and if PCGen has added in other OGL content beyond the SRD, I benefit since I don't have to reengineer the data myself. This should also apply to all the other software products, wether your product can handle changes in the date IMO seems meaningless, as long as I can use your data in some other program then the "open-ness" is satisfied. *




The question woudl then be, whether or not I could write a character generator program if I knew NOTHING of the SRD or D&D or anything, and it would come out correct - with no assumptions made in code.


----------



## Cergorach (Oct 8, 2002)

Something just occured to me, you could make a D20 computer game in the same way PcGen was made...


----------



## Brent (Oct 8, 2002)

Luke,

If I want to change the ability mod in RPM from SCORE/2-5 to SCORE/3-2, how do I do this?


----------



## Fractalwave (Oct 9, 2002)

*Re: code notes*



			
				merton_monk said:
			
		

> *It sounds like Wotc is in the process of considering new wordings for the licenses to specifically speak to software issues, which I'm glad to hear.*



Yeah, they're rewording. But I'm going to go out on a limb here...

I think that what you will see is a rewording that will still leave a good bit to interpretation and will thus be a "work in progress" as opposed to the be-all, end-all license regarding software.

One reason I think this is that it is still being worked on and I would expect them to have to make corrections later. Another reason I think this is that technology changes quickly and any license dealing with technology, in this case programs, needs to be able to change as necessary.

The inherent problem is that this is a marriage of two slightly different industries, printing books and creating computer programs. They don't quite work the same way regardless how the governments like to classify them. (Remember, governments tend to think 5 year old computers are still cutting edge, too.) And currently, these licenses are attempting to control both industries in one document. There's bound to be conflicts.

What does this mean? This means that what is "ok" now may not be deemed as "ok" six months from now for any number of reasons which cannot be foreseen. If you develop now, you need to take that into consideration.

Of course, I may be wrong though I'd be surprised if I was. But I would rather develop in a worst case scenario as opposed to a best case scenario so as to not have a huge problem with rewrites later if they become necessary. Plus, there are other inherent advantages to developing this way that I won't go into here.


----------



## Klintus Fang (Oct 9, 2002)

Cergorach said:
			
		

> *
> does that mean that i can't make an OGL/SRD application that adds values in it's binary? (I hope i just heard a resounding NO!) Then my question is what can i code into a binary and what can't i? *




I'm far from an expert on this, but it seems to me that the distinction lies in whether or not you have any algorithms embedded into the binary that are specifically derived from their material.

Being able to add two numbers is a generic ability.  I can't see how they could tell you that can't happen in the binary.  But I think you've entered into the problematic space if your binary contains explicit algorithms that are directly derived from the SRD material.  For example, the example that keeps coming up is the Stacking rules.  If you've encoded the actual stacking rules from the SRD into an algorithm you're in an uncertain area.  I suspect you may also be on shaky ground if you explicitly encode rules for even the ability score bonus, i.e., if you explicitly assume in the binary that it is [(score-10)/2] then it seems to me that you've used SRD content and placed it in your binary.

I'm not saying that doing either of those things is a violation of the license.  That I am not qualified to say.  But I am saying that both these things seem to be on the edge of what the license allows and what it does not allow.

Again, I'm not an expert and haven't followed threads of this nature on other boards.  But this is how I logically understand it.


----------



## Luke (Oct 9, 2002)

Brent said:
			
		

> *Luke,
> 
> If I want to change the ability mod in RPM from SCORE/2-5 to SCORE/3-2, how do I do this? *




Given the nature of this thread, this isn't a thinly veiled compliance test to ensure that I honestly do SRD mechanics in open script is it? 

In the file "rpm.js", simply find the function called "abilityModifier", and edit it so that it looks like this:


> function abilityModifier( creat, ab )
> {
> var	num	= creat[ab];
> 
> ...




In other words edit the "2" so it becomes a "3", and the "5" so it becomes a "2". The other "fluff" is a special test for creatures that have a "0" ability (such as constitution scores for undead), where ability modifiers are meaningless, and should display "0".
You can do a "ReCalculate (all)" on any existing characters or creatures to force the change to ability modifiers immediately.

If you want to implement a few house rules like this, make a note of your changes. That way if you upgrade to bigger and better versions of RPM in the future, you get a new "rpm.js" file, but can re-apply your special rule changes.


----------



## smetzger (Oct 9, 2002)

Sm!rk said:
			
		

> *
> 
> I doubt highly that this is the case. You are saying that some number of non-technical people made a guess on software tecnology and figured that it would be out of the limits of fan based software to make a externally data driven program.
> *




Anthony Valtera has said on more than one occasion that he thought the creation of d20 software was impossible.


----------



## dpmcalister (Oct 9, 2002)

*Off Topic*



			
				Fractalwave said:
			
		

> *
> Remember, governments tend to think 5 year old computers are still cutting edge, too.*






You've worked with the British military before then...


----------



## Fractalwave (Oct 10, 2002)

*Re: Off Topic*



			
				dpmcalister said:
			
		

> *
> 
> 
> 
> ...



Actually, not personally. But the really weird thing is most governments tend to act almost the same way when it comes to this subject. Maybe they're all clones of each other.  

Government D20...coming soon to your local gaming store!


----------



## Davin (Oct 10, 2002)

*Re: Re: Off Topic*



			
				Fractalwave said:
			
		

> *Government D20...coming soon to your local gaming store! *



Oh, no!!!      

That is *one* new game we definitely do *not* need!  Don't give _them_ any ideas!


----------



## ddavison (Nov 6, 2002)

quote:
--------------------------------------------------------------------------------
Originally posted by Fractalwave 
Government D20...coming soon to your local gaming store! 
--------------------------------------------------------------------------------

I think GWB has been rolling a lot of critical failures on his foreign policy.


----------



## Traxx (Nov 7, 2002)

Klooge Werks at http://www.klooge.com is really good. We've been using it now for a few months and it's made the games go far smoother and added Roleplaying elements to our game without overpowering the game during combat.

Too bad a few of the programs couldn't be combined....hint hint.

Later,
Traxx


----------



## Berk (Nov 8, 2002)

Luke said:
			
		

> *
> 
> I can definitely tell you that it's irrelevant whether or not your application is commercial.
> 
> ...




What if I were to do the following:

1) Write the program in a language like Python, which is compiled on demand (hence I wouldn't need to ditribute a binary, it's made for the user of the software on the fly the first time the code is used)

2) Released all the source code as OGL and/or D20. (Which one give me access to the most rules/supplements base?) I would prefer to release all the code as GPL or LGPL or BSD licensed, but the OGL from what I've read of it would 'do'.

I have been thinking about writing something for a while but without the ability to include a LARGE set of data files it becomes useless.

For instance, I do use FRG magic items, feats and the like  in my (NON FRG) campaign world, but NO software currently supports the FRG stuff. So that software effectively becomes useless to me, unless I add it manually which sucks for various reasons.

I don't understand Wizards stance about including equipment stats/rules in data files (either human readable or not). In fact early PCGEN releases encouraged me to buy books, not 'get around buying them'. Just because I know some feat adds to X, or gives me an extra attack doesn't mean I don't want to read the actual entry in the book it was published in.


----------



## Luke (Nov 8, 2002)

Berk said:
			
		

> *
> 
> What if I were to do the following:
> 
> ...




- As long as you don't distribute a binary with SRD game mechanics or info compiled into it, you're okay.

- You can't release any game mechanics source code under any license other than the D20 or OGL ones.

- Choosing between OGL and D20 gives you no advantage on what other source material you can include. Basically using D20 allows you advertise the D20 logo, whereas OGL allows you to do more things in software.


----------



## smetzger (Nov 8, 2002)

I disagree with Luke on the issue of an OGC Binary.  I believe it is allowable under the d20 and OGL license.  If you do release a binary under the d20 or OGL, the easiest thing to do is to release it as completly OGC.  This would make it very difficult for you to make money off of it because anyone would then be allowed to distribute your program.


----------



## Luke (Nov 8, 2002)

smetzger said:
			
		

> *I disagree with Luke on the issue of an OGC Binary.  I believe it is allowable under the d20 and OGL license.  If you do release a binary under the d20 or OGL, the easiest thing to do is to release it as completly OGC.  This would make it very difficult for you to make money off of it because anyone would then be allowed to distribute your program. *





I've been through this many times now. Here is an official quote from Wizards on this board  (from the guy at Wizards who sends out the termination notices) :



> _Originally posted by TheAndy tm_
> *Section 8 of the OGL - Section 8 of the Open Gaming License states that “You must clearly indicate which portions of the work that you are distributing are Open Content.” For software “clearly indicated” means that someone has to be able to see all the Open Content. It isn’t enough to say “all rules are Open Content”, someone using that program has to be able to see those rules. The whole point of the OGL is to allow anyone to use Open Content under the license. If that content is compiled into binary, a user can’t access that and use it freely.*




Check out the last line. Wizards are very clear about this, and developers don't like it (since it complicates our lives). Believe me - it took me a *lot* of effort to get RPM to the stage its at.

You may choose to ignore the warning, and end up testing it out in court.


----------



## palin (Nov 9, 2002)

Luke said:
			
		

> *
> 
> - As long as you don't distribute a binary with SRD game mechanics or info compiled into it, you're okay.
> 
> ...




Okay, so If I release the software and data files as OGL I still can't use the rules from say Forgotten Realms or from any of the 'class' books (Tome & Blood, etc), since they are not OGL content.

Which sucks, because again, my own software would be useless to me in the end. Either that or I would need to maintain my own sets of non distrubutable data files, which defeats the whole purpose of Open Source...

P.S. I was the person who wrote the original message you replied to (two above). It was written using my brother's account by accident.


----------

