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

can INCLUDE & EXCLUDE be used on Ability files?

Expand Messages
  • Eddy Anthony
    Can the pcc INCLUDE and EXCLUDE features be used on Ability files? Given that we need to reference the ability category everywhere else abilities are used what
    Message 1 of 9 , May 6, 2008
    • 0 Attachment
      Can the pcc INCLUDE and EXCLUDE features be used on Ability files? Given
      that we need to reference the ability category everywhere else abilities
      are used what is the syntax for this in INCLUDE/EXCLUDE?

      --
      ~ Eddy Anthony (MoSaT)
      ~ Chair Second, PCGen Board of Directors
      ~ Data Content Second, Doc Chimp, OS Tamarin
    • James Dempsey
      Hi Eddy, On 6/05/2008 10:50 PM Eddy Anthony wrote ... Currently it isn t considered and you need to do a basic key match. If there are duplicates you would get
      Message 2 of 9 , May 6, 2008
      • 0 Attachment
        Hi Eddy,

        On 6/05/2008 10:50 PM Eddy Anthony wrote
        > Can the pcc INCLUDE and EXCLUDE features be used on Ability files? Given
        > that we need to reference the ability category everywhere else abilities
        > are used what is the syntax for this in INCLUDE/EXCLUDE?
        >
        >
        Currently it isn't considered and you need to do a basic key match. If
        there are duplicates you would get undefined results :(

        I think we will need a quick discussion about syntax and then to raise a
        bug to get it implemented. Having key references only will be a probable
        later conversion problem, one of Tom's favourite things - ambiguity :)

        Current syntax:

        ABILITY:filename(INCLUDE:x|x)

        as multiple includes on a single file are not supported we will need to
        make sure multiple categories can be supported.

        So the options are either

        * (INCLUDE:CATEGORY=cat|abilityKey|...)
        where you have a series of pairs, or a category followed by
        multiple ability keys within that category, and then the new
        category precedes another list of keys e.g. CATEGORY=Class
        Ability|Foo1|Foo2|CATEGORY=Feat|Alertness

        or

        * (INCLUDE:CATEGORY=cat;abilityKey|...)
        where each key now consists of both the category and the key.
        While more wordy I'd prefer this format. I'm a bit rusty on
        separators, so semicolon may not be the correct one.
        e.g. CATEGORY=Class Ability;Foo1|CATEGORY=Class
        Ability;Foo2|CATEGORY=Feat;Alertness

        --
        Cheers,
        James Dempsey
        PCGen Code SB
      • Eddy Anthony
        ... Hi James I like the first, less wordy option myself. -- ~ Eddy Anthony (MoSaT) ~ Chair Second, PCGen Board of Directors ~ Data Content Second, Doc Chimp,
        Message 3 of 9 , May 6, 2008
        • 0 Attachment
          James Dempsey wrote:
          > Hi Eddy,
          >
          > On 6/05/2008 10:50 PM Eddy Anthony wrote
          >
          >> Can the pcc INCLUDE and EXCLUDE features be used on Ability files? Given
          >> that we need to reference the ability category everywhere else abilities
          >> are used what is the syntax for this in INCLUDE/EXCLUDE?
          >>
          >>
          >>
          > Currently it isn't considered and you need to do a basic key match. If
          > there are duplicates you would get undefined results :(
          >
          > I think we will need a quick discussion about syntax and then to raise a
          > bug to get it implemented. Having key references only will be a probable
          > later conversion problem, one of Tom's favourite things - ambiguity :)
          >
          > Current syntax:
          >
          > ABILITY:filename(INCLUDE:x|x)
          >
          > as multiple includes on a single file are not supported we will need to
          > make sure multiple categories can be supported.
          >
          > So the options are either
          >
          > * (INCLUDE:CATEGORY=cat|abilityKey|...)
          > where you have a series of pairs, or a category followed by
          > multiple ability keys within that category, and then the new
          > category precedes another list of keys e.g. CATEGORY=Class
          > Ability|Foo1|Foo2|CATEGORY=Feat|Alertness
          >
          > or
          >
          > * (INCLUDE:CATEGORY=cat;abilityKey|...)
          > where each key now consists of both the category and the key.
          > While more wordy I'd prefer this format. I'm a bit rusty on
          > separators, so semicolon may not be the correct one.
          > e.g. CATEGORY=Class Ability;Foo1|CATEGORY=Class
          > Ability;Foo2|CATEGORY=Feat;Alertness
          >

          Hi James
          I like the first, less wordy option myself.

          --
          ~ Eddy Anthony (MoSaT)
          ~ Chair Second, PCGen Board of Directors
          ~ Data Content Second, Doc Chimp, OS Tamarin
        • Tom Parker
          ... Given ... abilities ... raise a ... probable ... There is a third option: * (INCLUDE:CATEGORY=cat;abilityKey,abilityKey|...) This makes each CATEGORY
          Message 4 of 9 , May 6, 2008
          • 0 Attachment
            --- In pcgen@yahoogroups.com, James Dempsey <jdempsey@...> wrote:
            >
            > Hi Eddy,
            >
            > On 6/05/2008 10:50 PM Eddy Anthony wrote
            > > Can the pcc INCLUDE and EXCLUDE features be used on Ability files?
            Given
            > > that we need to reference the ability category everywhere else
            abilities
            > > are used what is the syntax for this in INCLUDE/EXCLUDE?
            > >
            > >
            > Currently it isn't considered and you need to do a basic key match. If
            > there are duplicates you would get undefined results :(
            >
            > I think we will need a quick discussion about syntax and then to
            raise a
            > bug to get it implemented. Having key references only will be a
            probable
            > later conversion problem, one of Tom's favourite things - ambiguity :)
            >
            > Current syntax:
            >
            > ABILITY:filename(INCLUDE:x|x)
            >
            > as multiple includes on a single file are not supported we will need to
            > make sure multiple categories can be supported.
            >
            > So the options are either
            >
            > * (INCLUDE:CATEGORY=cat|abilityKey|...)
            > where you have a series of pairs, or a category followed by
            > multiple ability keys within that category, and then the new
            > category precedes another list of keys e.g. CATEGORY=Class
            > Ability|Foo1|Foo2|CATEGORY=Feat|Alertness
            >
            > or
            >
            > * (INCLUDE:CATEGORY=cat;abilityKey|...)
            > where each key now consists of both the category and the key.
            > While more wordy I'd prefer this format. I'm a bit rusty on
            > separators, so semicolon may not be the correct one.
            > e.g. CATEGORY=Class Ability;Foo1|CATEGORY=Class
            > Ability;Foo2|CATEGORY=Feat;Alertness

            There is a third option:


            * (INCLUDE:CATEGORY=cat;abilityKey,abilityKey|...)
            This makes each CATEGORY separable by | while using unique separators
            to break apart the CATEGORY from the keys. This makes parsing rather
            easy...
            for each item separated by |
            for the first item separated by ; set the CATEGORY
            for the second item separated by ;
            for each item separated by , do stuff with that Ability

            e.g. CATEGORY=Class Ability;Foo1,Foo2|CATEGORY=Feat;Alertness

            This gives the "finer control" (and less jumping back and forth
            between token types) of the second option without the verbosity.

            TP.
          • Eddy Anthony
            Trackered and assigned to James so it doesn t get lost, I haven t assigned a group to it. [ 1959968 ] INCLUDE & EXCLUDE usage on Ability files
            Message 5 of 9 , May 7, 2008
            • 0 Attachment
              Trackered and assigned to James so it doesn't get lost, I haven't assigned a
              group to it.

              [ 1959968 ] INCLUDE & EXCLUDE usage on Ability files
              https://sourceforge.net/tracker/index.php?func=detail&aid=1959968&group_id=2
              5576&atid=384719

              Tom Parker scribed:

              > --- In pcgen@yahoogroups.com, James Dempsey <jdempsey@...> wrote:
              >>
              >> Hi Eddy,
              >>
              >> On 6/05/2008 10:50 PM Eddy Anthony wrote
              >>> Can the pcc INCLUDE and EXCLUDE features be used on Ability files?
              > Given
              >>> that we need to reference the ability category everywhere else
              > abilities
              >>> are used what is the syntax for this in INCLUDE/EXCLUDE?
              >>>
              >>>
              >> Currently it isn't considered and you need to do a basic key match. If
              >> there are duplicates you would get undefined results :(
              >>
              >> I think we will need a quick discussion about syntax and then to
              > raise a
              >> bug to get it implemented. Having key references only will be a
              > probable
              >> later conversion problem, one of Tom's favourite things - ambiguity :)
              >>
              >> Current syntax:
              >>
              >> ABILITY:filename(INCLUDE:x|x)
              >>
              >> as multiple includes on a single file are not supported we will need to
              >> make sure multiple categories can be supported.
              >>
              >> So the options are either
              >>
              >> * (INCLUDE:CATEGORY=cat|abilityKey|...)
              >> where you have a series of pairs, or a category followed by
              >> multiple ability keys within that category, and then the new
              >> category precedes another list of keys e.g. CATEGORY=Class
              >> Ability|Foo1|Foo2|CATEGORY=Feat|Alertness
              >>
              >> or
              >>
              >> * (INCLUDE:CATEGORY=cat;abilityKey|...)
              >> where each key now consists of both the category and the key.
              >> While more wordy I'd prefer this format. I'm a bit rusty on
              >> separators, so semicolon may not be the correct one.
              >> e.g. CATEGORY=Class Ability;Foo1|CATEGORY=Class
              >> Ability;Foo2|CATEGORY=Feat;Alertness
              >
              > There is a third option:
              >
              >
              > * (INCLUDE:CATEGORY=cat;abilityKey,abilityKey|...)
              > This makes each CATEGORY separable by | while using unique separators
              > to break apart the CATEGORY from the keys. This makes parsing rather
              > easy...
              > for each item separated by |
              > for the first item separated by ; set the CATEGORY
              > for the second item separated by ;
              > for each item separated by , do stuff with that Ability
              >
              > e.g. CATEGORY=Class Ability;Foo1,Foo2|CATEGORY=Feat;Alertness
              >
              > This gives the "finer control" (and less jumping back and forth
              > between token types) of the second option without the verbosity.
              >
              > TP.

              --
              ~ Eddy Anthony (MoSaT)
              ~ Chair Second, PCGen Board of Directors
              ~ Data Content Second, Doc Chimp, OS Tamarin
            • James Dempsey
              Hi Eddy, I presume we will go with Tom s suggestion? That seems the best to me. Cheers, James. ... [Non-text portions of this message have been removed]
              Message 6 of 9 , May 7, 2008
              • 0 Attachment
                Hi Eddy,

                I presume we will go with Tom's suggestion? That seems the best to me.

                Cheers,
                James.


                2008/5/8 Eddy Anthony <eddyba@...>:

                > Trackered and assigned to James so it doesn't get lost, I haven't assigned
                > a
                > group to it.
                >
                > [ 1959968 ] INCLUDE & EXCLUDE usage on Ability files
                >
                > https://sourceforge.net/tracker/index.php?func=detail&aid=1959968&group_id=2
                > 5576&atid=384719<https://sourceforge.net/tracker/index.php?func=detail&aid=1959968&group_id=25576&atid=384719>
                >
                > Tom Parker scribed:
                >
                > > --- In pcgen@yahoogroups.com, James Dempsey <jdempsey@...> wrote:
                > >>
                > >> Hi Eddy,
                > >>
                > >> On 6/05/2008 10:50 PM Eddy Anthony wrote
                > >>> Can the pcc INCLUDE and EXCLUDE features be used on Ability files?
                > > Given
                > >>> that we need to reference the ability category everywhere else
                > > abilities
                > >>> are used what is the syntax for this in INCLUDE/EXCLUDE?
                > >>>
                > >>>
                > >> Currently it isn't considered and you need to do a basic key match. If
                > >> there are duplicates you would get undefined results :(
                > >>
                > >> I think we will need a quick discussion about syntax and then to
                > > raise a
                > >> bug to get it implemented. Having key references only will be a
                > > probable
                > >> later conversion problem, one of Tom's favourite things - ambiguity :)
                > >>
                > >> Current syntax:
                > >>
                > >> ABILITY:filename(INCLUDE:x|x)
                > >>
                > >> as multiple includes on a single file are not supported we will need to
                > >> make sure multiple categories can be supported.
                > >>
                > >> So the options are either
                > >>
                > >> * (INCLUDE:CATEGORY=cat|abilityKey|...)
                > >> where you have a series of pairs, or a category followed by
                > >> multiple ability keys within that category, and then the new
                > >> category precedes another list of keys e.g. CATEGORY=Class
                > >> Ability|Foo1|Foo2|CATEGORY=Feat|Alertness
                > >>
                > >> or
                > >>
                > >> * (INCLUDE:CATEGORY=cat;abilityKey|...)
                > >> where each key now consists of both the category and the key.
                > >> While more wordy I'd prefer this format. I'm a bit rusty on
                > >> separators, so semicolon may not be the correct one.
                > >> e.g. CATEGORY=Class Ability;Foo1|CATEGORY=Class
                > >> Ability;Foo2|CATEGORY=Feat;Alertness
                > >
                > > There is a third option:
                > >
                > >
                > > * (INCLUDE:CATEGORY=cat;abilityKey,abilityKey|...)
                > > This makes each CATEGORY separable by | while using unique separators
                > > to break apart the CATEGORY from the keys. This makes parsing rather
                > > easy...
                > > for each item separated by |
                > > for the first item separated by ; set the CATEGORY
                > > for the second item separated by ;
                > > for each item separated by , do stuff with that Ability
                > >
                > > e.g. CATEGORY=Class Ability;Foo1,Foo2|CATEGORY=Feat;Alertness
                > >
                > > This gives the "finer control" (and less jumping back and forth
                > > between token types) of the second option without the verbosity.
                > >
                > > TP.
                >
                > --
                > ~ Eddy Anthony (MoSaT)
                > ~ Chair Second, PCGen Board of Directors
                > ~ Data Content Second, Doc Chimp, OS Tamarin
                >


                [Non-text portions of this message have been removed]
              • Eddy Anthony
                If it looks good to you that s enough for me. -Eddy ... -- ~ Eddy Anthony (MoSaT) ~ Chair Second, PCGen Board of Directors ~ Data Content Second, Doc Chimp, OS
                Message 7 of 9 , May 7, 2008
                • 0 Attachment
                  If it looks good to you that's enough for me.
                  -Eddy

                  James Dempsey scribed:

                  > Hi Eddy,
                  >
                  > I presume we will go with Tom's suggestion? That seems the best to me.
                  >
                  > Cheers,
                  > James.
                  >
                  >
                  > 2008/5/8 Eddy Anthony <eddyba@...>:
                  >
                  >> Trackered and assigned to James so it doesn't get lost, I haven't assigned
                  >> a
                  >> group to it.
                  >>
                  >> [ 1959968 ] INCLUDE & EXCLUDE usage on Ability files
                  >>
                  >> https://sourceforge.net/tracker/index.php?func=detail&aid=1959968&group_id=2
                  >> 5576&atid=384719<https://sourceforge.net/tracker/index.php?func=detail&aid=19
                  >> 59968&group_id=25576&atid=384719>
                  >>
                  >> Tom Parker scribed:
                  >>
                  >>> --- In pcgen@yahoogroups.com, James Dempsey <jdempsey@...> wrote:
                  >>>>
                  >>>> Hi Eddy,
                  >>>>
                  >>>> On 6/05/2008 10:50 PM Eddy Anthony wrote
                  >>>>> Can the pcc INCLUDE and EXCLUDE features be used on Ability files?
                  >>> Given
                  >>>>> that we need to reference the ability category everywhere else
                  >>> abilities
                  >>>>> are used what is the syntax for this in INCLUDE/EXCLUDE?
                  >>>>>
                  >>>>>
                  >>>> Currently it isn't considered and you need to do a basic key match. If
                  >>>> there are duplicates you would get undefined results :(
                  >>>>
                  >>>> I think we will need a quick discussion about syntax and then to
                  >>> raise a
                  >>>> bug to get it implemented. Having key references only will be a
                  >>> probable
                  >>>> later conversion problem, one of Tom's favourite things - ambiguity :)
                  >>>>
                  >>>> Current syntax:
                  >>>>
                  >>>> ABILITY:filename(INCLUDE:x|x)
                  >>>>
                  >>>> as multiple includes on a single file are not supported we will need to
                  >>>> make sure multiple categories can be supported.
                  >>>>
                  >>>> So the options are either
                  >>>>
                  >>>> * (INCLUDE:CATEGORY=cat|abilityKey|...)
                  >>>> where you have a series of pairs, or a category followed by
                  >>>> multiple ability keys within that category, and then the new
                  >>>> category precedes another list of keys e.g. CATEGORY=Class
                  >>>> Ability|Foo1|Foo2|CATEGORY=Feat|Alertness
                  >>>>
                  >>>> or
                  >>>>
                  >>>> * (INCLUDE:CATEGORY=cat;abilityKey|...)
                  >>>> where each key now consists of both the category and the key.
                  >>>> While more wordy I'd prefer this format. I'm a bit rusty on
                  >>>> separators, so semicolon may not be the correct one.
                  >>>> e.g. CATEGORY=Class Ability;Foo1|CATEGORY=Class
                  >>>> Ability;Foo2|CATEGORY=Feat;Alertness
                  >>>
                  >>> There is a third option:
                  >>>
                  >>>
                  >>> * (INCLUDE:CATEGORY=cat;abilityKey,abilityKey|...)
                  >>> This makes each CATEGORY separable by | while using unique separators
                  >>> to break apart the CATEGORY from the keys. This makes parsing rather
                  >>> easy...
                  >>> for each item separated by |
                  >>> for the first item separated by ; set the CATEGORY
                  >>> for the second item separated by ;
                  >>> for each item separated by , do stuff with that Ability
                  >>>
                  >>> e.g. CATEGORY=Class Ability;Foo1,Foo2|CATEGORY=Feat;Alertness
                  >>>
                  >>> This gives the "finer control" (and less jumping back and forth
                  >>> between token types) of the second option without the verbosity.
                  >>>
                  >>> TP.

                  --
                  ~ Eddy Anthony (MoSaT)
                  ~ Chair Second, PCGen Board of Directors
                  ~ Data Content Second, Doc Chimp, OS Tamarin
                • James Dempsey
                  Hi, I ve implemented Tom s option in both 5.14 and trunk. e.g. INCLUDE:CATEGORY=Occupation,Academic,Celebrity,Adventurer|CATEGORY=Wealth,Wealth Roll of 2 Note:
                  Message 8 of 9 , May 17, 2008
                  • 0 Attachment
                    Hi,

                    I've implemented Tom's option in both 5.14 and trunk. e.g.
                    INCLUDE:CATEGORY=Occupation,Academic,Celebrity,Adventurer|CATEGORY=Wealth,Wealth
                    Roll of 2

                    Note: This introduces a new deprecation warning. INCLUDE:key is no longer
                    valid on feat or ability includes in PCC files. A deprecation warning has
                    been added in both 5.14 and trunk for this. The trunk one will be removed
                    once the core data has been updated.

                    Cheers,
                    James.

                    2008/5/8 Eddy Anthony <eddyba@...>:

                    > If it looks good to you that's enough for me.
                    > -Eddy
                    >
                    > James Dempsey scribed:
                    >
                    > > Hi Eddy,
                    > >
                    > > I presume we will go with Tom's suggestion? That seems the best to me.
                    > >
                    > > Cheers,
                    > > James.
                    > >
                    > >
                    > > 2008/5/8 Eddy Anthony <eddyba@...>:
                    > >
                    > >> Trackered and assigned to James so it doesn't get lost, I haven't
                    > assigned
                    > >> a
                    > >> group to it.
                    > >>
                    > >> [ 1959968 ] INCLUDE & EXCLUDE usage on Ability files
                    > >>
                    > >>
                    > https://sourceforge.net/tracker/index.php?func=detail&aid=1959968&group_id=2
                    > >> 5576&atid=384719<
                    > https://sourceforge.net/tracker/index.php?func=detail&aid=19
                    > >> 59968&group_id=25576&atid=384719>
                    > >>
                    > >> Tom Parker scribed:
                    > >>
                    > >>> --- In pcgen@yahoogroups.com, James Dempsey <jdempsey@...> wrote:
                    > >>>>
                    > >>>> Hi Eddy,
                    > >>>>
                    > >>>> On 6/05/2008 10:50 PM Eddy Anthony wrote
                    > >>>>> Can the pcc INCLUDE and EXCLUDE features be used on Ability files?
                    > >>> Given
                    > >>>>> that we need to reference the ability category everywhere else
                    > >>> abilities
                    > >>>>> are used what is the syntax for this in INCLUDE/EXCLUDE?
                    > >>>>>
                    > >>>>>
                    > >>>> Currently it isn't considered and you need to do a basic key match. If
                    > >>>> there are duplicates you would get undefined results :(
                    > >>>>
                    > >>>> I think we will need a quick discussion about syntax and then to
                    > >>> raise a
                    > >>>> bug to get it implemented. Having key references only will be a
                    > >>> probable
                    > >>>> later conversion problem, one of Tom's favourite things - ambiguity :)
                    > >>>>
                    > >>>> Current syntax:
                    > >>>>
                    > >>>> ABILITY:filename(INCLUDE:x|x)
                    > >>>>
                    > >>>> as multiple includes on a single file are not supported we will need
                    > to
                    > >>>> make sure multiple categories can be supported.
                    > >>>>
                    > >>>> So the options are either
                    > >>>>
                    > >>>> * (INCLUDE:CATEGORY=cat|abilityKey|...)
                    > >>>> where you have a series of pairs, or a category followed by
                    > >>>> multiple ability keys within that category, and then the new
                    > >>>> category precedes another list of keys e.g. CATEGORY=Class
                    > >>>> Ability|Foo1|Foo2|CATEGORY=Feat|Alertness
                    > >>>>
                    > >>>> or
                    > >>>>
                    > >>>> * (INCLUDE:CATEGORY=cat;abilityKey|...)
                    > >>>> where each key now consists of both the category and the key.
                    > >>>> While more wordy I'd prefer this format. I'm a bit rusty on
                    > >>>> separators, so semicolon may not be the correct one.
                    > >>>> e.g. CATEGORY=Class Ability;Foo1|CATEGORY=Class
                    > >>>> Ability;Foo2|CATEGORY=Feat;Alertness
                    > >>>
                    > >>> There is a third option:
                    > >>>
                    > >>>
                    > >>> * (INCLUDE:CATEGORY=cat;abilityKey,abilityKey|...)
                    > >>> This makes each CATEGORY separable by | while using unique separators
                    > >>> to break apart the CATEGORY from the keys. This makes parsing rather
                    > >>> easy...
                    > >>> for each item separated by |
                    > >>> for the first item separated by ; set the CATEGORY
                    > >>> for the second item separated by ;
                    > >>> for each item separated by , do stuff with that Ability
                    > >>>
                    > >>> e.g. CATEGORY=Class Ability;Foo1,Foo2|CATEGORY=Feat;Alertness
                    > >>>
                    > >>> This gives the "finer control" (and less jumping back and forth
                    > >>> between token types) of the second option without the verbosity.
                    > >>>
                    > >>> TP.
                    >
                    > --
                    > ~ Eddy Anthony (MoSaT)
                    > ~ Chair Second, PCGen Board of Directors
                    > ~ Data Content Second, Doc Chimp, OS Tamarin
                    >


                    [Non-text portions of this message have been removed]
                  • Andrew Wilson
                    ... That isn t Tom s proposed syntax. It s missing the semi-colons. INCLUDE:CATEGORY=Occupation;Academic,Celebrity,Adventurer|CATEGORY=Wealth;Wealth Roll of
                    Message 9 of 9 , May 18, 2008
                    • 0 Attachment
                      On Sun, May 18, 2008 at 10:56:45AM +1000, James Dempsey wrote:
                      > I've implemented Tom's option in both 5.14 and trunk. e.g.
                      > INCLUDE:CATEGORY=Occupation,Academic,Celebrity,Adventurer|CATEGORY=Wealth,Wealth
                      > Roll of 2

                      That isn't Tom's proposed syntax. It's missing the semi-colons.

                      INCLUDE:CATEGORY=Occupation;Academic,Celebrity,Adventurer|CATEGORY=Wealth;Wealth
                      Roll of 2

                      andrew
                      --
                      Aries: (March 21 - April 19)
                      You'll be simultaneously struck by mystical lightning, bathed
                      with otherworldly cosmic rays, and injected with the Apollo
                      Serum, so you'll be a pretty powerful superhero if you ever
                      get out of the coma.
                    Your message has been successfully submitted and would be delivered to recipients shortly.