Fred Drake wrote:
> This is a little off-topic, but this seems as reasonable a place to
> ask as I'm aware of.
>
> Does anyone know of a version of the SRD in LaTeX format, instead of
> the RTF from the Wizard's site?  I'd be interested in finding such a
> beast.

As far as I know, there is no LaTeX-version, but IIRC one could use
XeTeX for transforming XML into LaTeX. But I'm not sure which XML
formats XeTeX works with already, though certainly the support can be
created.

Best regards,
Johannes Luber

This is a little off-topic, but this seems as reasonable a place to
ask as I'm aware of.

Does anyone know of a version of the SRD in LaTeX format, instead of
the RTF from the Wizard's site?  I'd be interested in finding such a
beast.


   -Fred

--
Fred L. Drake, Jr.    <fdrake at gmail.com>
"Don't let schooling interfere with your education." -- Mark Twain

> Good points and pretty valid observation, from my standpoint.  I'll just
> add
> that I bother with XML because I use .NET and *love* strongly-typed
> datasets.  Strongly-typed datasets are a natural for data objects and they
> speak XML natively.  It's a powerful combo.  Also, having the data in a
> human-readable format (and being able to nest related data-i.e.
> hierarchically structured object layout) makes it easy to gut-check data
> validity.  Since all the d20 that ever existed isn't enough to worry about
> storage space, or even serialization speeds (particularly VS 2005), I
> figure
> why bother with a "real" database for storage?

One of the main reasons that I use XML for the data storage is that I can
edit it directly in one place with any kind of text editor. Also the
reading, writing and validation of the XML format can be done by third
party libraries so it means less work for me to do. I also have a bunch of
scripts that will convert from Andargors XML data or from PCGen LST format
into my own format.

If I used a database then I would either have to use the DB front end
(probably SQL), or write my own custom front end that was more specific to
my dataset.

If I used a binary data format then I would definitely have to write my
own data entry front end.

> And being able to leverage Andargor's excellent work by creating routines
> to
> break his stuff into more program-friendly structures is a pretty big
> draw,
> too (as you allude to below).  Seriously, Andargor has done some
> outstanding
> translations and gets all the kudos I can give.

Oh yes, I am a big fan of his XML, I use it for all of the spell
information and the basis of the feat information. I converted the PCGen
data for classes and equipment because there were already a series of
bonuses applied to them that were not present in Andargors data.

--
regards,
Frugal

I had a look into the mdb of e-tools too, and yes it works.
But as an aesthete I have to say this file looks awful from the
inside. But maybe that is the only the way: Makeing you code looking
awful in order to make it work. ^^


--- In d20-xml@yahoogroups.com, "Laura Thompson" <lathompson@...>
wrote:
>
> That is the reaction most people have. I came up with it after
doing a lot
> of data modelling on d20 and I haven't found anything else that
gets past
> about 60% of cases. When I couldn't come up with anything better I
took a
> peek at e-tools and hacked their database, and guess what, this is
exaclty
> the system it uses (albiet they do it in MS Access).
>
> -Laura
>
>   _____
>
> From: d20-xml@yahoogroups.com [mailto:d20-xml@yahoogroups.com] On
Behalf Of
> Jacob Proffitt
> Sent: Tuesday, April 25, 2006 10:44 PM
> To: d20-xml@yahoogroups.com
> Subject: RE: [d20-xml] Current Snapshot of Developement
>
>
> Blah.  And ick.  I'd hate trying to implement (or use) this.
There's a
> trade-off between flexible and usable.  I tend to go more on the
usable
> side.
>
> (and yes, I know usable is a malleable concept.)
>
> Jacob
>
>   _____
>
> * From: Laura Thompson
>
> <label-value label="BAB" value="+1" value-type="numeric" stack-
type=""
> stack-action="add" />
>
> The parser then needs to know that when it sees this tag it needs
to create
> a lable-value pair in memory, with a label of "BAB". If such a
label already
> exists it should add the given value to the value already present,
and it
> should not use stacking rules when it does so.
>
> Modeling "+1 level of existing spell-casting class" is espeically
complex,
> because it implies that the base data for classes must be broken
into two
> parts - the normal class-based abilities and the spell abilities.
In fact,
> there are many situations where this comes up in prestige classes
and
> level-based abilities where the text says "levels in class ___
stack with
> existing levels in ____".
>
>
>
>
>   _____
>
> YAHOO! GROUPS LINKS
>
>
> *  Visit your group "d20-xml
<http://groups.yahoo.com/group/d20-xml> "
> on the web.
>
>
> *  To unsubscribe from this group, send an email to:
>  d20-xml-unsubscribe@yahoogroups.com
> <mailto:d20-xml-unsubscribe@yahoogroups.com?subject=Unsubscribe>
>
>
> *  Your use of Yahoo! Groups is subject to the Yahoo! Terms of
Service
> <http://docs.yahoo.com/info/terms/> .
>
>   _____
>

I know that it is sometimes faster and cheaper to hard-code master
data, and it might work with the standard rules. If it does and it's
all you need, that's okay. No problem.
But what if you want to define new classes, spells et cetera? That
is what I'm worring about.
If I want to just use the basic rules I don't need XML files. In
this case I would store the data in a local *.mdf file or save the
objects as binary data. This would save storage memory and would be
easiest to work with.
So I think if I use XML it should be as generic as possible. If I
can't accomplish that. I should leave it.


--- In d20-xml@yahoogroups.com, "Jacob Proffitt" <jacob@...> wrote:
>
> I agree with your analysis, but disagree with your conclusion,
Al.  What I
> mean is that yes, he is hard-coding master data into his modules.
I just
> don't have a problem with that and I honor him for doing it that
way if it
> means he has usable modules sooner.  Sometimes it's just more
useful to put
> some of the logic into the actual code.  Sometimes your code has
to know
> about the objects it's using.  d20 is so close to being
programmable (I
> mean, it has stack considerations for heaven's sake) that it is
very
> tempting to think you can code all the rules right off.  And you
probably
> actually *can*.  But should you really?  Designing a format that
takes all
> the little exceptions and asides into account is almost as
challenging as
> programming something that will accept and implement that format.
If you're
> not careful, you can design something that is so daunting and
obscure that
> you quit when you're half way through implementing it.  Much
better (IMO) to
> program around what you can't include in your data so you can get
something
> useful sooner.  Refactor from there if you have to, but first push
should be
> to come up with something you can actually use without breaking
your back.
>
> I caught some heat for my Monster Manual xml that had similar
issues.  Some
> of it I took and altered my format to accommodate.  Some I
didn't.  It all
> comes down to what the designer decides as a trade-off between
usability and
> flexibility.
>
> Jacob
>
>   _____
>
> From: alnatrus
>
>
> This format looks nice.
> What I dislike is the fact that your program seems to use hard
coded
> master data.
>
> I see two ways to realize the reverse engeneering:
>
> First:
> You store all your data in the character XML.
> This would make master data XML files as nothing more than
template.
> You would only exchange the character XML and with it the master
> data.
>
> Second:
> You store the Data realational.
> You would have some files with the master data and the charakter
> XML. This would make it necessary to exchange master data and
> character data.
>
> --- In d20-xml@yahoogroups.com, "Roger Hicks" <pidgepot@> wrote:
> >
> > The information for feat prerequisites is programmed into
the .NET
> code,
> > although I don't think it would be too difficult to turn the
> entire thing
> > into XML with script blocks for truly abnormal abilities. In
order
> to track
> > class abilities that stack, my code simply adds a hidden
variable
> to the
> > character. For example, taking a level of either the Barbarian
and
> Rogue
> > class increases the character's "Uncanny_Dodge_Levels" by 1. Of
> course, you
> > do have to correctly identify the variable name for special
> abilities with
> > different names that stack together.
> >
> > The XML stores the character's complete leveling history, so
> levels can be
> > removed as easily as they can be added. It's still in a rough
> form, but
> > essentially, here's how the XML looks:
> >
> > <info>
> >  <race>Human</race>
> >  <align>CG</align>
> >  <name>Bob</name>
> >  <atts>
> >   <strength>18</strength>
> >   ...other attributes here...
> >  </atts>
> >  <levels>
> >   <level class="Barbarian">
> >    <hp>8</hp>
> >    <skill points="3">Use Rope</skill>
> >    <skill points="2">Jump</skill>
> >    <feat name="Combat Expertise">
> >      ....feat specific information goes here (such as skill
> selection for
> > Skill Focus feat, etc.). This is fed to the class that handles
the
> feat
> > allowing it to parse and process the specifics.
> >    </feat>
> >    <special>
> >     ...this is the information of any unusual class abilities
that
> don't fit
> > the mold. Like the Barbarian's literacy...
> >    </special>
> >   </level>
> >   <level /> - each level has it's own entry, in the order it was
> taken.
> >   <template name="Zombie" />
> >   <adjustment> - can be used to track misc. changes outside of
the
> normal
> > class progression, for example if the GM awards a bonus to a
> character, or a
> > cursed magic item permanantly reduces a stat.
> >     <hp>3</hp>
> >     <reason>Blessing of the Oracle</reason>
> >   </adjustment>
> >  </levels>
> > </info>
> >
> > The .NET library does all the work of determining prerequisites,
> calculating
> > stats, etc. In addition, it can track stats under different
> conditions. For
> > example, you can calculate your Barbarian's stats under the Rage
> and Shaken
> > conditions, which would give you the STR and CON bonus, and
reduce
> saves,
> > skill checks, etc. by 2. I also have plans for the system to be
> able to
> > track temporary ability damage.
> >
> > BobTHJ
> >
> >
> >   _____
> >
> > From: d20-xml@yahoogroups.com [mailto:d20-xml@yahoogroups.com]
On
> Behalf Of
> > Wayne Pearson
> > Sent: Tuesday, April 25, 2006 10:32 AM
> > To: d20-xml@yahoogroups.com
> > Subject: Re: [d20-xml] Current Snapshot of Developement
> >
> >
> > I'd be curious how you're handling feats (and their
prerequisites)
> and
> > especially special abilities that can stack, including across
> multiple
> > classes.
> >
> > Specifically, classes and prestige classes that provide
> > evasion/improved evasion, or sneak attack bonuses, etc. where the
> > description specifically goes into "...if the character has
_____
> from
> > previous class levels, these levels stack..."  This can get
awkward
> > when some special abilities aren't named exactly the same across
> > classes/prestige classes, but do stack in this manner.
> >
> > Or perhaps I've been spending too much time worrying about
> > multiclassing.  *:^)
> >
> >
> > Also, do you store specifics about the character's levelling up
> > (one rank in X, one rank in Y) at each level, or just a final
> > total of skill ranks (and other decisions made during levelling
> up)?
> >
> > --
> >   Crwth
> >
> >
> >
> > || From Roger Hicks:
> > ||
> > ||  I'm currently working on a D20 XML format to work with an
> online
> > character
> > ||  generator for my website Roleplay Market
> > (http://www.roleplaymarket.com).
> > ||  The format does not store detailed text for class abilities,
> etc.
> > However,
> > ||  it does store a snapshot of the character and their
> advancement, which
> > is
> > ||  then manipulated by a .NET library I wrote to generate a
visual
> > character
> > ||  sheet. The goal here is to create an updateable character
> sheet that can
> > be
> > ||  stored as XML so players can generate a character, save it,
> and then go
> > back
> > ||  later and add a level, template, etc. The library uses the
XML
> to
> > calculate
> > ||  all applicable stats for the character.
> > ||
> > ||  The project is about 50% complete presently. I should have
it
> working
> > within
> > ||  the next few weeks, although the difficult part will be
> programming the
> > ||  individual classes and feats.
> > ||
> > ||  Thanks,
> > ||  BobTHJ
> >
> >
> >   _____
> >
> > YAHOO! GROUPS LINKS
> >
> >
> >
> > *      Visit your group "d20-xml
> <http://groups.yahoo.com/group/d20-xml> "
> > on the web.
> >
> >
> > *      To unsubscribe from this group, send an email to:
> >  d20-xml-unsubscribe@yahoogroups.com
> > <mailto:d20-xml-unsubscribe@yahoogroups.com?subject=Unsubscribe>
> >
> >
> > *      Your use of Yahoo! Groups is subject to the Yahoo! Terms
of
> Service
> > <http://docs.yahoo.com/info/terms/> .
> >
> >
> >   _____
> >
>
>
>
>
>
>
>   _____
>
> YAHOO! GROUPS LINKS
>
> *  Visit your group "d20-xml
<http://groups.yahoo.com/group/d20-xml> "
> on the web.
>
> *  To unsubscribe from this group, send an email to:
>  d20-xml-unsubscribe@yahoogroups.com
> <mailto:d20-xml-unsubscribe@yahoogroups.com?subject=Unsubscribe>
>
> *  Your use of Yahoo! Groups is subject to the Yahoo! Terms of
Service
> <http://docs.yahoo.com/info/terms/> .
>
>   _____
>

I'm not so sure.  One of the prestige classes in Tome of Magic allows
you to drop previous classes for levels in the prestige class, showing
a history of character progression can be a useful thing to have, even
if it's all going to be merged together in the final result.

Granted, this doesn't specifically disprove your statement, but shows
that future additions to the system can require flexibility that you
had skipped over earlier.  That being said, we're back to that line
of "how much abstraction do you put in before it's unwieldy?"

--
   Crwth


|| From glaziusf:
||
||  For a final character sheet I don't think it matters whether you
||  got your spell levels from a core class, prestige class, or the
||  gods, it's the same 12 levels of wizard spells any way you slice
||  it.

I didn't say it was difficult, I said it was complex. It is very easy to
model any one aspect of d20 without regard to the rest, it only becomes
difficult when you try to bring it all into a cohesive whole.

-Laura

-----Original Message-----
From: d20-xml@yahoogroups.com [mailto:d20-xml@yahoogroups.com] On Behalf Of
glaziusf
Sent: Wednesday, April 26, 2006 10:01 AM
To: d20-xml@yahoogroups.com
Subject: [d20-xml] Re: Current Snapshot of Developement

--- In d20-xml@yahoogroups.com, "Laura Thompson" <lathompson@...> wrote:

> Modeling "+1 level of existing spell-casting class" is espeically
complex,
> because it implies that the base data for classes must be broken
into two
> parts - the normal class-based abilities and the spell abilities. In
fact,
> there are many situations where this comes up in prestige classes and
> level-based abilities where the text says "levels in class ___ stack
with
> existing levels in ____".
>
> -Laura

...er, I'm just an XML newbie, but why's this so difficult?

<character-spells>
    <class-spells class="bard" castlevel="7" knowlevel="7" />
    <class-spells class="sorceror" castlevel="4" knowlevel="4" />
</character-spells>

Maybe add in (spelltype="arcane" or spelltype="divine") too.

One table of lookup data for a given spell progression, and a note in the
class advancement that 1 level of bard grants 1 bard caster level and 1
level of bard spell knowledge (known/perday).

This also makes it easy to store those monsters who "cast spells as an Xth
level Y class". For prestige classes which add some type of spell
progression, the class ability could be stored as... well, for a character
creator an XPath expression that would work on the character-spells to give
a list of possible classes. For a final character sheet I don't think it
matters whether you got your spell levels from a core class, prestige class,
or the gods, it's the same
12 levels of wizard spells any way you slice it.

I could be wrong though.

--GF







Yahoo! Groups Links

That's good to know -- that someone has found a good "problem case"
with which to code towards and test with.  Sounds like a challenge to
me.  *:^)

--
   Crwth


|| From Laura Thompson:
||
||  When this effort was originally started, Ryan Dancey said that no
||  character generator/manager could be said to be even close to
||  working unless it could properly handle the Dragon Disciple
||  prestige class.

--- In d20-xml@yahoogroups.com, "Laura Thompson" <lathompson@...> wrote:

> Modeling "+1 level of existing spell-casting class" is espeically
complex,
> because it implies that the base data for classes must be broken
into two
> parts - the normal class-based abilities and the spell abilities. In
fact,
> there are many situations where this comes up in prestige classes and
> level-based abilities where the text says "levels in class ___ stack
with
> existing levels in ____".
>
> -Laura

...er, I'm just an XML newbie, but why's this so difficult?

<character-spells>
    <class-spells class="bard" castlevel="7" knowlevel="7" />
    <class-spells class="sorceror" castlevel="4" knowlevel="4" />
</character-spells>

Maybe add in (spelltype="arcane" or spelltype="divine") too.

One table of lookup data for a given spell progression, and a note in
the class advancement that 1 level of bard grants 1 bard caster level
and 1 level of bard spell knowledge (known/perday).

This also makes it easy to store those monsters who "cast spells as an
Xth level Y class". For prestige classes which add some type of spell
progression, the class ability could be stored as... well, for a
character creator an XPath expression that would work on the
character-spells to give a list of possible classes. For a final
character sheet I don't think it matters whether you got your spell
levels from a core class, prestige class, or the gods, it's the same
12 levels of wizard spells any way you slice it.

I could be wrong though.

--GF

I agree with everyone.  I, too, started to come up with the same
design that Laura showed, but concluded as Jacob did that there's
a point where your abstraction goes too far;  that it may finally
allow all things to be represented, but has gone past "useable".
And it was the limitations in Neverwinter Nights that made me want
to go that far.

So where does that leave us?  Is there a line that can be made
where some rules are coded, and some are in data, that take care
of all cases, or are we eventually going to hit the same problem
as Bioware did?

--
   Crwth


|| From Jason:
||
||
||  --- Jacob Proffitt <jacob@...> wrote:
||
||  > Okay, two replies to the same post is weird.  I just want to make
||  > sure you
||  > don't get the feeling that I'm denigrating your design.  I think it
||  > might be
||  > the only real solution that has a chance of success given that you
||  > want the
||  > xml to contain the full and complete description of your objects.
||  > It's a
||  > good design given that requirement.  I just wouldn't personally make
||  > that a
||  > part of my functional requirements is all.
||  >
||  > Jacob
||
||  One key piece of making all the rules fit within the XML is that it
||  makes it very easy to separate the Open Gaming License content from the
||  code. If you can factor the rules into the XML, then it is easy to say
||  that the XML is Open Gaming Content and the code is whatever license
||  you want. Strict adherence to the Open Gaming License very nearly
||  requires this.
||
||  Also, I think Laura's design has another thing going for it,
||  abstraction. With something like what it appears she's aiming for, it
||  could be quite possible to create a generic D20 engine in code and then
||  have the XML to specify the parameters of a game or character creation,
||  whatever. Such a system maybe more cumbersome for the programmer and
||  designer of the XML, but in the end it pays off in flexibility. You
||  could use the same program to do your work for multiple D20 games by
||  simply pointing it at a different XML ruleset.
||
||  That said, I fully understand Jacob's point. There's a real value to
||  having something that you can use sooner rather than later,
||  particularly in a hobbyist endeavor, or even when you have a deadline
||  looming. I'm not knocking Jacob's position, really. I'm just pointing
||  out two very strong advantages of complete separation of code and data
||  in this case (if you consider the XML to be data).
||
||  If you look at one of the most prominent D20 computer games available
||  today, Neverwinter Nights, the designers definitely followed Jacob's
||  idea of mixing code and data. Some things in NWN are hardcoded, but
||  much of the game can be changed by a module builder by modifying the
||  2DA files that describe things. However, some of the things which they
||  chose to hardcode forced them into compromises later. For instance,
||  they were unable to properly implement the spell casting prestige
||  classes because they had hardcoded the list of spell casting classes
||  and spell progression tables, and I guess they felt it too much work to
||  go back and add new ones or to change it so that the spell progression
||  could be stored in external data.
||
||  I guess there's a lot to be said in favor of either approach, and which
||  one you choose depends a good bit on your goals for your project.
||
||  Cheers,
||  Jason
||
||  __________________________________________________
||  Do You Yahoo!?
||  Tired of spam?  Yahoo! Mail has the best spam protection around
||  http://mail.yahoo.com
||
||
||
||  Yahoo! Groups Links
||
||
||
||
||

I think there is a lot of truth here. It is always a question of how do you
compromise in order to meet today's goals. I find it helpful to keep an
over-arching design in mind when building smaller pieces so I don't shoot
myself in the foot in the future. I am not always successful.

When this effort was originally started, Ryan Dancey said that no character
generator/manager could be said to be even close to working unless it could
properly handle the Dragon Disciple prestige class. There is a lot of merit
to this point of view, since this class turns many very basic assumptions on
their ears. It changes the creature type, natural attacks, ability scores,
grants Spell-Like, Supernatural, and Extraordinary abilities. It also has
conditional changes that are based on the size of the base creature, and it
throws out the spell chart by adding new spell slots in a progression that
duplicates a high ability score rather than being fixed to a given level.

If your d20-xml model can handle Dragon Disciple you've done a very good job
indeed.

-Laura

-----Original Message-----
From: d20-xml@yahoogroups.com [mailto:d20-xml@yahoogroups.com] On Behalf Of
Jason
Sent: Wednesday, April 26, 2006 7:16 AM
To: d20-xml@yahoogroups.com
Subject: RE: [d20-xml] Current Snapshot of Developement


--- Jacob Proffitt <jacob@...> wrote:

> Okay, two replies to the same post is weird.  I just want to make sure
> you don't get the feeling that I'm denigrating your design.  I think
> it might be the only real solution that has a chance of success given
> that you want the xml to contain the full and complete description of
> your objects.
> It's a
> good design given that requirement.  I just wouldn't personally make
> that a part of my functional requirements is all.
>
> Jacob

One key piece of making all the rules fit within the XML is that it makes it
very easy to separate the Open Gaming License content from the code. If you
can factor the rules into the XML, then it is easy to say that the XML is
Open Gaming Content and the code is whatever license you want. Strict
adherence to the Open Gaming License very nearly requires this.

Also, I think Laura's design has another thing going for it, abstraction.
With something like what it appears she's aiming for, it could be quite
possible to create a generic D20 engine in code and then have the XML to
specify the parameters of a game or character creation, whatever. Such a
system maybe more cumbersome for the programmer and designer of the XML, but
in the end it pays off in flexibility. You could use the same program to do
your work for multiple D20 games by simply pointing it at a different XML
ruleset.

That said, I fully understand Jacob's point. There's a real value to having
something that you can use sooner rather than later, particularly in a
hobbyist endeavor, or even when you have a deadline looming. I'm not
knocking Jacob's position, really. I'm just pointing out two very strong
advantages of complete separation of code and data in this case (if you
consider the XML to be data).

If you look at one of the most prominent D20 computer games available today,
Neverwinter Nights, the designers definitely followed Jacob's idea of mixing
code and data. Some things in NWN are hardcoded, but much of the game can be
changed by a module builder by modifying the 2DA files that describe things.
However, some of the things which they chose to hardcode forced them into
compromises later. For instance, they were unable to properly implement the
spell casting prestige classes because they had hardcoded the list of spell
casting classes and spell progression tables, and I guess they felt it too
much work to go back and add new ones or to change it so that the spell
progression could be stored in external data.

I guess there's a lot to be said in favor of either approach, and which one
you choose depends a good bit on your goals for your project.

Cheers,
Jason

__________________________________________________
Do You Yahoo!?
Tired of spam?  Yahoo! Mail has the best spam protection around
http://mail.yahoo.com



Yahoo! Groups Links

--- Jacob Proffitt <jacob@...> wrote:

> Okay, two replies to the same post is weird.  I just want to make
> sure you
> don't get the feeling that I'm denigrating your design.  I think it
> might be
> the only real solution that has a chance of success given that you
> want the
> xml to contain the full and complete description of your objects.
> It's a
> good design given that requirement.  I just wouldn't personally make
> that a
> part of my functional requirements is all.
>
> Jacob

One key piece of making all the rules fit within the XML is that it
makes it very easy to separate the Open Gaming License content from the
code. If you can factor the rules into the XML, then it is easy to say
that the XML is Open Gaming Content and the code is whatever license
you want. Strict adherence to the Open Gaming License very nearly
requires this.

Also, I think Laura's design has another thing going for it,
abstraction. With something like what it appears she's aiming for, it
could be quite possible to create a generic D20 engine in code and then
have the XML to specify the parameters of a game or character creation,
whatever. Such a system maybe more cumbersome for the programmer and
designer of the XML, but in the end it pays off in flexibility. You
could use the same program to do your work for multiple D20 games by
simply pointing it at a different XML ruleset.

That said, I fully understand Jacob's point. There's a real value to
having something that you can use sooner rather than later,
particularly in a hobbyist endeavor, or even when you have a deadline
looming. I'm not knocking Jacob's position, really. I'm just pointing
out two very strong advantages of complete separation of code and data
in this case (if you consider the XML to be data).

If you look at one of the most prominent D20 computer games available
today, Neverwinter Nights, the designers definitely followed Jacob's
idea of mixing code and data. Some things in NWN are hardcoded, but
much of the game can be changed by a module builder by modifying the
2DA files that describe things. However, some of the things which they
chose to hardcode forced them into compromises later. For instance,
they were unable to properly implement the spell casting prestige
classes because they had hardcoded the list of spell casting classes
and spell progression tables, and I guess they felt it too much work to
go back and add new ones or to change it so that the spell progression
could be stored in external data.

I guess there's a lot to be said in favor of either approach, and which
one you choose depends a good bit on your goals for your project.

Cheers,
Jason

__________________________________________________
Do You Yahoo!?
Tired of spam?  Yahoo! Mail has the best spam protection around
http://mail.yahoo.com

This format looks nice.
What I dislike is the fact that your program seems to use hard coded
master data.

I see two ways to realize the reverse engeneering:

First:
You store all your data in the character XML.
This would make master data XML files as nothing more than template.
You would only exchange the character XML and with it the master
data.

Second:
You store the Data realational.
You would have some files with the master data and the charakter
XML. This would make it necessary to exchange master data and
character data.

--- In d20-xml@yahoogroups.com, "Roger Hicks" <pidgepot@...> wrote:
>
> The information for feat prerequisites is programmed into the .NET
code,
> although I don't think it would be too difficult to turn the
entire thing
> into XML with script blocks for truly abnormal abilities. In order
to track
> class abilities that stack, my code simply adds a hidden variable
to the
> character. For example, taking a level of either the Barbarian and
Rogue
> class increases the character's "Uncanny_Dodge_Levels" by 1. Of
course, you
> do have to correctly identify the variable name for special
abilities with
> different names that stack together.
>
> The XML stores the character's complete leveling history, so
levels can be
> removed as easily as they can be added. It's still in a rough
form, but
> essentially, here's how the XML looks:
>
> <info>
>  <race>Human</race>
>  <align>CG</align>
>  <name>Bob</name>
>  <atts>
>   <strength>18</strength>
>   ...other attributes here...
>  </atts>
>  <levels>
>   <level class="Barbarian">
>    <hp>8</hp>
>    <skill points="3">Use Rope</skill>
>    <skill points="2">Jump</skill>
>    <feat name="Combat Expertise">
>      ....feat specific information goes here (such as skill
selection for
> Skill Focus feat, etc.). This is fed to the class that handles the
feat
> allowing it to parse and process the specifics.
>    </feat>
>    <special>
>     ...this is the information of any unusual class abilities that
don't fit
> the mold. Like the Barbarian's literacy...
>    </special>
>   </level>
>   <level /> - each level has it's own entry, in the order it was
taken.
>   <template name="Zombie" />
>   <adjustment> - can be used to track misc. changes outside of the
normal
> class progression, for example if the GM awards a bonus to a
character, or a
> cursed magic item permanantly reduces a stat.
>     <hp>3</hp>
>     <reason>Blessing of the Oracle</reason>
>   </adjustment>
>  </levels>
> </info>
>
> The .NET library does all the work of determining prerequisites,
calculating
> stats, etc. In addition, it can track stats under different
conditions. For
> example, you can calculate your Barbarian's stats under the Rage
and Shaken
> conditions, which would give you the STR and CON bonus, and reduce
saves,
> skill checks, etc. by 2. I also have plans for the system to be
able to
> track temporary ability damage.
>
> BobTHJ
>
>
>   _____
>
> From: d20-xml@yahoogroups.com [mailto:d20-xml@yahoogroups.com] On
Behalf Of
> Wayne Pearson
> Sent: Tuesday, April 25, 2006 10:32 AM
> To: d20-xml@yahoogroups.com
> Subject: Re: [d20-xml] Current Snapshot of Developement
>
>
> I'd be curious how you're handling feats (and their prerequisites)
and
> especially special abilities that can stack, including across
multiple
> classes.
>
> Specifically, classes and prestige classes that provide
> evasion/improved evasion, or sneak attack bonuses, etc. where the
> description specifically goes into "...if the character has _____
from
> previous class levels, these levels stack..."  This can get awkward
> when some special abilities aren't named exactly the same across
> classes/prestige classes, but do stack in this manner.
>
> Or perhaps I've been spending too much time worrying about
> multiclassing.  *:^)
>
>
> Also, do you store specifics about the character's levelling up
> (one rank in X, one rank in Y) at each level, or just a final
> total of skill ranks (and other decisions made during levelling
up)?
>
> --
>   Crwth
>
>
>
> || From Roger Hicks:
> ||
> ||  I'm currently working on a D20 XML format to work with an
online
> character
> ||  generator for my website Roleplay Market
> (http://www.roleplaymarket.com).
> ||  The format does not store detailed text for class abilities,
etc.
> However,
> ||  it does store a snapshot of the character and their
advancement, which
> is
> ||  then manipulated by a .NET library I wrote to generate a visual
> character
> ||  sheet. The goal here is to create an updateable character
sheet that can
> be
> ||  stored as XML so players can generate a character, save it,
and then go
> back
> ||  later and add a level, template, etc. The library uses the XML
to
> calculate
> ||  all applicable stats for the character.
> ||
> ||  The project is about 50% complete presently. I should have it
working
> within
> ||  the next few weeks, although the difficult part will be
programming the
> ||  individual classes and feats.
> ||
> ||  Thanks,
> ||  BobTHJ
>
>
>   _____
>
> YAHOO! GROUPS LINKS
>
>
>
> *  Visit your group "d20-xml
<http://groups.yahoo.com/group/d20-xml> "
> on the web.
>
>
> *  To unsubscribe from this group, send an email to:
>  d20-xml-unsubscribe@yahoogroups.com
> <mailto:d20-xml-unsubscribe@yahoogroups.com?subject=Unsubscribe>
>
>
> *  Your use of Yahoo! Groups is subject to the Yahoo! Terms of
Service
> <http://docs.yahoo.com/info/terms/> .
>
>
>   _____
>

No, this is exactly the issue that shut down development of a cohesive
schema for character creation last year. The only way to make this work from
a data modeling perspective is to create an abstract schema that uses
attributes or subtags to define the actual class/race/template features. You
pretty much have to build all aspects of the character as variable elements
that can be adjusted by tags further down in the schema. For example, a tag
that increments the BAB of a character might look something like this:

<label-value label="BAB" value="+1" value-type="numeric" stack-type=""
stack-action="add" />

The parser then needs to know that when it sees this tag it needs to create
a lable-value pair in memory, with a label of "BAB". If such a label already
exists it should add the given value to the value already present, and it
should not use stacking rules when it does so.

Modeling "+1 level of existing spell-casting class" is espeically complex,
because it implies that the base data for classes must be broken into two
parts - the normal class-based abilities and the spell abilities. In fact,
there are many situations where this comes up in prestige classes and
level-based abilities where the text says "levels in class ___ stack with
existing levels in ____".

-Laura

-----Original Message-----
From: d20-xml@yahoogroups.com [mailto:d20-xml@yahoogroups.com] On Behalf Of
Wayne Pearson
Sent: Tuesday, April 25, 2006 10:32 AM
To: d20-xml@yahoogroups.com
Subject: Re: [d20-xml] Current Snapshot of Developement

I'd be curious how you're handling feats (and their prerequisites) and
especially special abilities that can stack, including across multiple
classes.

Specifically, classes and prestige classes that provide evasion/improved
evasion, or sneak attack bonuses, etc. where the description specifically
goes into "...if the character has _____ from previous class levels, these
levels stack..."  This can get awkward when some special abilities aren't
named exactly the same across classes/prestige classes, but do stack in this
manner.

Or perhaps I've been spending too much time worrying about multiclassing.
*:^)


Also, do you store specifics about the character's levelling up (one rank in
X, one rank in Y) at each level, or just a final total of skill ranks (and
other decisions made during levelling up)?

--
   Crwth



|| From Roger Hicks:
||
||  I'm currently working on a D20 XML format to work with an online
|| character  generator for my website Roleplay Market
(http://www.roleplaymarket.com).
||  The format does not store detailed text for class abilities, etc.
|| However,  it does store a snapshot of the character and their
|| advancement, which is  then manipulated by a .NET library I wrote to
|| generate a visual character  sheet. The goal here is to create an
|| updateable character sheet that can be  stored as XML so players can
|| generate a character, save it, and then go back  later and add a
|| level, template, etc. The library uses the XML to calculate  all
applicable stats for the character.
||
||  The project is about 50% complete presently. I should have it
|| working within  the next few weeks, although the difficult part will
|| be programming the  individual classes and feats.
||
||  Thanks,
||  BobTHJ



Yahoo! Groups Links

|| From Roger Hicks:
||
||  The information for feat prerequisites is programmed into the .NET
||  code, although I don't think it would be too difficult to turn the
||  entire thing into XML with script blocks for truly abnormal
||  abilities.

So you're saying that the specifics of each feat (and their prereqs)
are in the code, and not in a configuration or data file?

||  In order to track class abilities that stack, my code simply adds
||  a hidden variable to the character. For example, taking a level of
||  either the Barbarian and Rogue class increases the character's
||  "Uncanny_Dodge_Levels" by 1. Of course, you do have to correctly
||  identify the variable name for special abilities with different
||  names that stack together.

This is the approach I've considered.  The "hidden variable" would be
defined for each special ability as it was encountered, and if new
classes appear that mention they stack with it (even if they have a
different name), then they'd be associated with that hidden variable
name.  It sounds like a better idea now that someone else thought of
it too.  *:^)

||    <template name="Zombie" />

I find this interesting.  Does all the information for the Zombie
template exist in another XML file, or is that hard-coded into the
.NET code?

||    <adjustment> - can be used to track misc. changes outside of the normal
||  class progression, for example if the GM awards a bonus to a character, or a
||  cursed magic item permanantly reduces a stat.

I hadn't even considered this possibility yet.

||  The .NET library does all the work of determining prerequisites,
||  calculating stats, etc. In addition, it can track stats under
||  different conditions. For example, you can calculate your
||  Barbarian's stats under the Rage and Shaken conditions, which
||  would give you the STR and CON bonus, and reduce saves, skill
||  checks, etc. by 2. I also have plans for the system to be able to
||  track temporary ability damage.

I hadn't decided whether to make tools for during gameplay as well
as for the "off" time of character building and advancing.

--
   Crwth

||  A prerequisite might look something like:
||
||  <prerequisite type="attribute">
||  <attribute>STR</attribute><minval>13</minval>
||  </prerequisite>
||
||  The above would indicate a minimun of 13 STR required.

This is similar to what I've done so far.

||  No, my favorite PCs have often been multiclassed. I like mixing
||  different classes to come up with what may as well be a whole new
||  class.

I agree, as do my players.  In fact, I've been interested in getting
my players to try out monstrous characters, which brings up a whole
new set of problems.

Has anyone tried looking at a specific monster and tried to come up
with a level progression for it (basically reverse-engineer the
monster to its stages?)  I've been trying for some time (based on
what the Savage Species book has for a handful of monsters), and
just can't find a layout that has the monster class levels anywhere
near balanced with standard class levels.  Basically, I'm trying to
ask "Would you take a 20th level fighter, or a Balron with 2 levels
of fighter?"  Or whatever balance would be appropriate.  Can it be
found?  And if/when it is, how would that all fit into a character-
building system?

||  I can't speak for Roger, but I would store a detailed level up
||  history.  Without it, it would be hard to undo things and return
||  to an earlier state if there was a wish/need to do so. It would
||  also be handy for those optimizers and tinkerers who'd like to
||  capture the full build and print it out for later reference.

That's what I've done as well;  this is what I've got in my current
pass:

         <Levels>
                 <Level number="1">
                         <Class>Cleric</Class>
                         <hp>8</hp>
                         <Feat source="level">Extra Turning</Feat>
                         <Feat source="race">Toughness</Feat>
                         <Skills>
                                 <Skill name="Heal" source="level">4</Skill>
                                 <Skill name="Craft (weaponsmithing)"
source="level">4</Skill>
                         </Skills>
                 </Level>
                 <Level number="2">
                         <Class>Cleric</Class>
                         <hp>5</hp>
                         <Skills>
                                 <Skill name="Heal" source="level">1</Skill>
                                 <Skill name="Craft (weaponsmithing)"
source="level">1</Skill>
                         </Skills>
                 </Level>
                 <Level number="3">
                         <Class>Cleric</Class>
                         <hp>3</hp>
                         <Feat source="level">Craft Wand</Feat>
                         <Skills>
                                 <Skill name="Heal" source="level">1</Skill>
                                 <Skill name="Craft (weaponsmithing)"
source="level">1</Skill>
                         </Skills>
                 </Level>
                 <Level number="4">
                         <Class>Cleric</Class>
                         <hp>3</hp>
                         <AbilityGain source="level">Wisdom</AbilityGain>
                         <Skills>
                                 <Skill name="Heal" source="level">1</Skill>
                                 <Skill name="Craft (weaponsmithing)"
source="level">1</Skill>
                         </Skills>
                 </Level>
	 </Levels>


I've yet to put it through all of its paces to see if it's effective,
but it works pretty well for now on my character sheet XSL.

And no laughing at my levelling up;  this is from my first 3.0 character.

*:^)

--
   Crwth

--- Wayne Pearson <crwth@...> wrote:

> I'd be curious how you're handling feats (and their prerequisites)
> and
> especially special abilities that can stack, including across
> multiple
> classes.
>

I'm not working on Roger's project, nor really doing anything specific
that is D20-related at the moment, but I have thought about the above
problem a little bit. For feats, etc. that can stack, that have
pre-requisites, or that can replace or supercede other abilities, it
could be expressed in the xml.

For your feats, abilities, etc., you have some additional elements that
they could have.

A prerequisite might look something like:

<prerequisite type="attribute">
<attribute>STR</attribute><minval>13</minval>
</prerequisite>

The above would indicate a minimun of 13 STR required.

For a feat, you could have a feat id or the feat name or whatever.

Same thing with supercedes or stackswith:

<stackswith type="feat">
<feat>Rogue: Sneak Attack</feat>
</stackswith>
<stackswith type="feat">
<feat>Assassin: Sneak Attack</feat>
</stackswith>

Or something like it.

As I've said, I've not sat down and worked out the details nor played
with it in code, so I'm not sure what I think ought to be attributes
and what ought to be elements, but you get the general idea.

> Or perhaps I've been spending too much time worrying about
> multiclassing.  *:^)

No, my favorite PCs have often been multiclassed. I like mixing
different classes to come up with what may as well be a whole new
class.

>
>
> Also, do you store specifics about the character's levelling up
> (one rank in X, one rank in Y) at each level, or just a final
> total of skill ranks (and other decisions made during levelling up)?

I can't speak for Roger, but I would store a detailed level up history.
Without it, it would be hard to undo things and return to an earlier
state if there was a wish/need to do so. It would also be handy for
those optimizers and tinkerers who'd like to capture the full build and
print it out for later reference.

Well, back to work.

Cheers,
Jason

__________________________________________________
Do You Yahoo!?
Tired of spam?  Yahoo! Mail has the best spam protection around
http://mail.yahoo.com

I'd be curious how you're handling feats (and their prerequisites) and
especially special abilities that can stack, including across multiple
classes.

Specifically, classes and prestige classes that provide
evasion/improved evasion, or sneak attack bonuses, etc. where the
description specifically goes into "...if the character has _____ from
previous class levels, these levels stack..."  This can get awkward
when some special abilities aren't named exactly the same across
classes/prestige classes, but do stack in this manner.

Or perhaps I've been spending too much time worrying about
multiclassing.  *:^)


Also, do you store specifics about the character's levelling up
(one rank in X, one rank in Y) at each level, or just a final
total of skill ranks (and other decisions made during levelling up)?

--
   Crwth



|| From Roger Hicks:
||
||  I'm currently working on a D20 XML format to work with an online character
||  generator for my website Roleplay Market (http://www.roleplaymarket.com).
||  The format does not store detailed text for class abilities, etc. However,
||  it does store a snapshot of the character and their advancement, which is
||  then manipulated by a .NET library I wrote to generate a visual character
||  sheet. The goal here is to create an updateable character sheet that can be
||  stored as XML so players can generate a character, save it, and then go back
||  later and add a level, template, etc. The library uses the XML to calculate
||  all applicable stats for the character.
||
||  The project is about 50% complete presently. I should have it working within
||  the next few weeks, although the difficult part will be programming the
||  individual classes and feats.
||
||  Thanks,
||  BobTHJ