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

Re: [pcgen-xml] Skill pool and classes

Expand Messages
  • Frugal
    ... So in the above example adding a rank of race.human caused the addition of a rank of characterlevel which in turn causeed the
    Message 1 of 18 , Apr 1 4:06 AM
    View Source
    • 0 Attachment
      <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
      >
      > <character>
      > <add:rank key='race.human'>
      > <add:rank key='characterlevel'>
      > <add:rank progression='class.fighter'>
      > <add:score key='hitpoints' value='10' />
      > <add:set key='feats' selected='feat.power-attack' />
      > <!-- might allow a shorthand for this... might not, since each
      > rank can conceivably have effects -->
      > <add:rank progression='skill.ride' />
      > <add:rank progression='skill.ride' />
      > <add:rank progression='skill.ride' />
      > <add:rank progression='skill.ride' />
      > <add:rank progression='skill.jump' />
      > <add:rank progression='skill.jump' />
      > <add:rank progression='skill.jump' />
      > <add:rank progression='skill.jump' />
      > <add:rank progression='skill.craft.weaponsmith' />
      > <add:rank progression='skill.craft.weaponsmith' />
      > <add:rank progression='skill.craft.weaponsmith' />
      > <add:rank progression='skill.craft.weaponsmith' />
      > </add:rank>
      > <add:set key='feats' selected='feat.improved-sunder' />
      > </add:rank>
      > <add:set key='feats' selected='feat.toughness' />
      > </add:rank>
      > <add:rank key='race.human'>
      > <add:rank key='characterlevel'>
      > <add:rank progression='class.fighter'>
      > <add:score key='hitpoints' value='8' />
      > <add:set key='feats' selected='feat.cleave' />
      > <add:rank progression='skill.ride' />
      > <add:rank progression='skill.jump' />
      > <add:rank progression='skill.craft.weaponsmith' />
      > </add:rank>
      > </add:rank>
      > </add:rank>
      > </character>
      >
      > 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".

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

      > '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 ?

      > 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...

      > 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 ?

      > 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).

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

      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...

      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(

      --
      regards,
      Frugal
      -OS Chimp
    • 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 2 of 18 , Apr 1 7:44 AM
      View Source
      • 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 3 of 18 , Apr 2 12:25 AM
        View Source
        • 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 4 of 18 , Apr 2 7:43 AM
          View Source
          • 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.