Loading ...
Sorry, an error occurred while loading the content.

Re: [pcgen-xml] Skill pool and classes

Expand Messages
  • Keith Davies
    ... Yes. It seems a little odd, but it works, and can cover racial differences and effects at various levels (HD and/or origins of changes). ... Much
    Message 1 of 18 , Apr 1 7:44 AM
    • 0 Attachment
      On Thu, Apr 01, 2004 at 01:06:07PM +0100, Frugal wrote:
      >
      > <quote who="Keith Davies">
      > > In my design, a character does not contain a progression, it contains
      > > information describing the steps along that progression. For instance,
      > > after gaining a few levels the character probably contains something like
      > >
      > > Only those things that require a decision or can vary between
      > > characters (hit points, feats, and skill points). Note that I've
      > > added feats both within the class <add:rank> (these are fighter
      > > feats) and outside (the first-level feat). Racial bonus feats are
      > > probably handled in the race description.
      >
      > So in the above example adding a rank of "race.human" caused the
      > addition of a rank of characterlevel which in turn causeed the adition
      > of the rank of "class.fighter".

      Yes. It seems a little odd, but it works, and can cover racial
      differences and effects at various 'levels' (HD and/or origins of
      changes).

      > I am assuming that there ar a whole load of <add:score/> that you have
      > not shown in the example (stats for example)

      Much elided, yeah. The example was long enough.

      > > 'Exclusive' is a flag on the skill itself. If not exclusive, assume
      > > cross-class. If a class skill in the class being added, or the
      > > character has it as a 'personal class' skill (as with Versatile) the
      > > cost gets reduced to 1; if the character has it as a class skill for at
      > > least one class skill, max ranks is equal to level+3 (barring exclusive
      > > skill behavior) but he pays class or cross-class skill cost as
      > > appropriate.
      >
      > How do you plan to encode that information in the meta data ?

      probably as a rule or effect on the 'skill' superclass -- create an
      object that knows all this crap and works on flags ('if exclusive is
      set, etc.') to handle it. I'm really not happy about skills... but
      there doesn't seem to *be* a good way of handling them. The best I'm
      hoping for now is effective and correct.

      > > The rule for the characterlevel progression would have to know to look
      > > at the list of skills associated with the selected class and add them --
      > > if necessary -- to the character's list of class skills. To determine
      > > the cost of a rank in a skill necessarily requires information from the
      > > character, the race, and the class.
      >
      > Actually it requires information from every single entity that the
      > character has had applied to them. As an example I have come across a
      > piece of equipment that gives "Open Lock" and "Disable Device" as class
      > skills...

      That's not so bad -- the equipment changes the character to add the
      skills as class skills, then the effects are present after that.

      All entities need to be able to make any change to any entity it is
      applied to. In this case, the equipment adds the class skill to the
      character (which is exactly what you described), we don't determine
      through examination 'is there anything that adds this class skill to the
      character'.

      > > Since character is the only one
      > > that knows -- directly or indirectly -- about the others, this
      > > determination needs to be done in the character-processing rules.
      >
      > In the Meta data rules, or the Application rules ?

      I'd really, really like to see this in data rather than code. If
      necessary we can fold it into code, but I'd prefer to keep it out where
      it can be changed without modifying code.

      That said, it's probably not unreasonable to allow extensions in code
      for things that can't be done reasonably in data. For instance -- and
      this might not apply, so don't hold me to it -- weapon handedness might
      be best modeled as showing whether the weapon is one-handed, two-handed,
      or both, plus the conditions or effects of doing it. I'd rather see a
      series of enumerated values for this rather than a bit of nasty data for
      each... and shorthand could be very valuable (being able to just say
      'bastard' for handedness would be really useful).

      OTOH, using entities (define a &bastard; entity that contains the nasty
      data needed) can be a reasonable workaround -- in data -- for this. It
      gets lost on export, though, because it gets expanded on load; the
      program never sees the entity after it passes through the parser.

      > > Actually, it's possible that the characterlevel progression could do it,
      > > since (for other purposes) it has to know things about the character
      > > it's being applied to (such as to determine whether feat or class
      > > prereqs are being met).
      >
      > However the character level progression does not know about the race
      > progression (i.e. +4 skill points to character level 1 if race=human).

      true, but the race progression *does* (or rather, can) know to give the
      additional skill points.

      > The only thing that knows enough information is the character object.

      Which is why some rules (for instance, prereqs) will need to be able to
      bounce off the entity they are being used on to determine validity.
      This mechanism can be extended.

      > So the characterlevel progression has to hold the counter of the skill
      > point pool which is determined by the class rank in the characterlevel
      > rank, plus the race, plus all of the other entities. Plus the fact
      > that this can all change from level to level...

      Not quite, I think, *if* we require that the points be spent at each
      level -- as the rule state they must be. If we do that, we get points
      from *this* class level, and possibly a bonus for race at *this* level.

      On the other hand, it needs to be able to handle *reduced* skill points
      (low Int, possibly a racial penalty against skills) as well. Yeah, they
      need to be able to accumulate across the character.

      > So the skillpoints for a characterlevel rank are
      >
      > (X*Y)+Z
      >
      > Where
      >
      > X = classrank_skillpoints + bonus_skill_points_for_classlevel
      > Y = skillpoint_multiplier_for_classlevelrank
      > Z = extra_bonus_skill_points_for_classlevelrank
      >
      > So at the meta data level we need a way to index into the contents of
      > a class rank that has been applied via a characterlevel rank using
      > both the characterlevel rank number and the class rank number.
      >
      > The more I look at this the more I realise that in D&D A depends on B
      > depends on C depends on A ;O(

      This makes me sad. I was hoping it wasn't necessary.


      Keith
      --
      Keith Davies I gave my 2yo daughter a strawberry
      keith.davies@... Naomi: "Strawberry!"
      me: "What do you say?"
      Naomi: "*MY* strawberry!"
    • Frugal
      ... In the first of your examples the progression was like this:
      Message 2 of 18 , Apr 2 12:25 AM
      • 0 Attachment
        <quote who="Keith Davies">
        > On Thu, Apr 01, 2004 at 01:06:07PM +0100, Frugal wrote:
        >> So in the above example adding a rank of "race.human" caused the
        >> addition of a rank of characterlevel which in turn causeed the adition
        >> of the rank of "class.fighter".
        >
        > Yes. It seems a little odd, but it works, and can cover racial
        > differences and effects at various 'levels' (HD and/or origins of
        > changes).

        In the first of your examples the progression was like this:

        <character>
        <add:rank key='race.human'>
        <add:rank key='characterlevel' />
        </add:rank>
        <add:rank key='race.human'>
        <add:rank key='characterlevel' />
        </add:rank>
        </character>

        And in the next two it was:

        <character>
        <add:rank key='race.cat' />
        <add:rank key='characterlevel' />
        <add:rank key='characterlevel' />
        <add:rank key='characterlevel' />
        <add:rank key='characterlevel' />
        </character>

        So are you saying that a character is made up of ranks of race (which have
        ranks of characterlevel), but that a character can also be made up of just
        ranks of characterlevel?

        >> However the character level progression does not know about the race
        >> progression (i.e. +4 skill points to character level 1 if race=human).
        >
        > true, but the race progression *does* (or rather, can) know to give the
        > additional skill points.

        - So the client asks that character for skill points at level 1.
        - The Character has no explicit value fo skillpoints
        - The Character looks at rank:1 which is race.human.
        - The Character asks rank:1 for skillpoints
        - The race.human:1 has a formula for calculating skillpoints:
        characterlevel_skillpoints * 4
        - The race rank asks the character level rank for skillpoints
        - The character level rank does not have an explicit value for
        skillpoints, so it asks the class rank 1.
        - The Class rank 1 has a formula for calculating skillpoinrts: INT.1 + 2
        - The Class asks the character for the value of INT.1
        - The character looks at all of the bonuses up to rank 1 that apply to
        INT, returns +3 (from client set value to stat).
        - the class returns 3+2 = 5
        - the characterlevel returns 5
        - The race level returns 5*4 = 20
        - The character returns 20
        - The client displays the value 20.

        >> So the characterlevel progression has to hold the counter of the skill
        >> point pool which is determined by the class rank in the characterlevel
        >> rank, plus the race, plus all of the other entities. Plus the fact
        >> that this can all change from level to level...
        >
        > Not quite, I think, *if* we require that the points be spent at each
        > level -- as the rule state they must be. If we do that, we get points
        > from *this* class level, and possibly a bonus for race at *this* level.

        For a whole raft of things I think we are going to need to be able to say:
        "What is the value of this at level x".

        for hit points we are going to want to know how many hit points were given
        at each level.

        For skill points we need to know how many skill points are available at
        each level

        For a lot of formulas we need to know what the value of a variable was at
        a certain level (i.e. for skill points at level 5 we need the intelligence
        modifier for level 5).



        >> (X*Y)+Z
        >>
        >> Where
        >>
        >> X = classrank_skillpoints + bonus_skill_points_for_classlevel
        >> Y = skillpoint_multiplier_for_classlevelrank
        >> Z = extra_bonus_skill_points_for_classlevelrank
        >>
        >> So at the meta data level we need a way to index into the contents of
        >> a class rank that has been applied via a characterlevel rank using
        >> both the characterlevel rank number and the class rank number.
        >>
        >> The more I look at this the more I realise that in D&D A depends on B
        >> depends on C depends on A ;O(
        >
        > This makes me sad. I was hoping it wasn't necessary.

        The more I look at this the more I think that the meta-data needs to be
        turing complete ;O( I can not think of a way of encoding the rules such
        that they can be all defined by simple rules.

        I am beginning to think that the only way to do this without going insane
        is to define a simple set of data holders in xml, and a character/rule
        framework in Java, then implement a concrete instance of the DnD rules.

        So just define an XML character as a series of progressions, ranks,
        entities and effects. But have all of the rules for manipulating them in
        the Java layer.

        I think that everything can be defined in simple XML, I just do not
        believe that it can be manipulated without a fully featured turing machine
        ;o(

        --
        regards,
        Frugal
        -OS Chimp
      • Keith Davies
        ... It depends on the particular race. Humans are defined as advance by class , so their racial progression (race.human) contains instructions to add a class
        Message 3 of 18 , Apr 2 7:43 AM
        • 0 Attachment
          On Fri, Apr 02, 2004 at 09:25:45AM +0100, Frugal wrote:
          >
          > <quote who="Keith Davies">
          > > On Thu, Apr 01, 2004 at 01:06:07PM +0100, Frugal wrote:
          > >> So in the above example adding a rank of "race.human" caused the
          > >> addition of a rank of characterlevel which in turn causeed the adition
          > >> of the rank of "class.fighter".
          > >
          > > Yes. It seems a little odd, but it works, and can cover racial
          > > differences and effects at various 'levels' (HD and/or origins of
          > > changes).
          >
          > In the first of your examples the progression was like this:
          >
          > <character>
          > <add:rank key='race.human'>
          > <add:rank key='characterlevel' />
          > </add:rank>
          > <add:rank key='race.human'>
          > <add:rank key='characterlevel' />
          > </add:rank>
          > </character>
          >
          > And in the next two it was:
          >
          > <character>
          > <add:rank key='race.cat' />
          > <add:rank key='characterlevel' />
          > <add:rank key='characterlevel' />
          > <add:rank key='characterlevel' />
          > <add:rank key='characterlevel' />
          > </character>
          >
          > So are you saying that a character is made up of ranks of race (which
          > have ranks of characterlevel), but that a character can also be made
          > up of just ranks of characterlevel?

          It depends on the particular race.

          Humans are defined as 'advance by class', so their racial progression
          (race.human) contains instructions to add a class level at each rank of
          race.human.

          Cats, on the other hand, are animals and would have a simple HD
          advancement scheme. They don't (normally) get character levels. As a
          result, race.cat does not contain 'add class level' in its definition.
          However, class levels can still be added in addition to HD advancement.

          > >> However the character level progression does not know about the race
          > >> progression (i.e. +4 skill points to character level 1 if race=human).
          > >
          > > true, but the race progression *does* (or rather, can) know to give the
          > > additional skill points.
          >
          > - So the client asks that character for skill points at level 1.
          > - The Character has no explicit value fo skillpoints
          > - The Character looks at rank:1 which is race.human.
          > - The Character asks rank:1 for skillpoints
          > - The race.human:1 has a formula for calculating skillpoints:
          > characterlevel_skillpoints * 4
          > - The race rank asks the character level rank for skillpoints
          > - The character level rank does not have an explicit value for
          > skillpoints, so it asks the class rank 1.
          > - The Class rank 1 has a formula for calculating skillpoinrts: INT.1 + 2
          > - The Class asks the character for the value of INT.1
          > - The character looks at all of the bonuses up to rank 1 that apply to
          > INT, returns +3 (from client set value to stat).
          > - the class returns 3+2 = 5
          > - the characterlevel returns 5
          > - The race level returns 5*4 = 20
          > - The character returns 20
          > - The client displays the value 20.

          That looks about right. Lots of steps (sad) but I think it tracks
          everything necessary.

          > >> So the characterlevel progression has to hold the counter of the skill
          > >> point pool which is determined by the class rank in the characterlevel
          > >> rank, plus the race, plus all of the other entities. Plus the fact
          > >> that this can all change from level to level...
          > >
          > > Not quite, I think, *if* we require that the points be spent at each
          > > level -- as the rule state they must be. If we do that, we get points
          > > from *this* class level, and possibly a bonus for race at *this* level.
          >
          > For a whole raft of things I think we are going to need to be able to
          > say: "What is the value of this at level x".
          >
          > for hit points we are going to want to know how many hit points were
          > given at each level.
          >
          > For skill points we need to know how many skill points are available
          > at each level
          >
          > For a lot of formulas we need to know what the value of a variable was
          > at a certain level (i.e. for skill points at level 5 we need the
          > intelligence modifier for level 5).

          I think it's the right way to go to ensure characters that are legal all
          the way through, and can be rolled back if necessary.

          > The more I look at this the more I think that the meta-data needs to be
          > turing complete ;O( I can not think of a way of encoding the rules such
          > that they can be all defined by simple rules.
          >
          > I am beginning to think that the only way to do this without going insane
          > is to define a simple set of data holders in xml, and a character/rule
          > framework in Java, then implement a concrete instance of the DnD rules.

          Probably, though I was trying to keep it a little more abstract. OTOH,
          as long as the pieces can be subbed out it shouldn't be too ugly.

          Heh, I just remembered the framework UML I did up... GameEngine is
          abstract -- it can be replaced. I was hoping it wouldn't be needed, but
          ah well.

          > So just define an XML character as a series of progressions, ranks,
          > entities and effects. But have all of the rules for manipulating them in
          > the Java layer.

          This isn't quite what I *want*, but I think it will be necessary. It
          should be possible to define primitives that are used by the data. For
          instance, adding a small rule for 'bastard weapons' into code, then just
          hooking onto it for weapon definitions, rather than trying to encode the
          mess in data.

          I'm not happy about that, but I'm willing to be pragmatic.

          > I think that everything can be defined in simple XML, I just do not
          > believe that it can be manipulated without a fully featured turing machine
          > ;o(

          You're probably right. Right now, everything is being done by code.
          Ideally I'd reduce that to 'engine is in code, specifics are in data'
          but it looks like that won't be feasible. 'Engine plus (extensible)
          primitives in code, rest in data' could probably be done, though.


          Keith
          --
          Keith Davies I gave my 2yo daughter a strawberry
          keith.davies@... Naomi: "Strawberry!"
          me: "What do you say?"
          Naomi: "*MY* strawberry!"
        Your message has been successfully submitted and would be delivered to recipients shortly.