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

Re: [pcgen_developers] Experimenting with a generic rules engine

Expand Messages
  • Andrew
    Looks nice and exciting.
    Message 1 of 8 , Jun 15, 2013
    • 0 Attachment
      Looks nice and exciting.



      On 6/15/2013 10:20 AM, Chris Dolan wrote:
      > I've posted my initial code on Github.
      > https://github.com/chrisdolan/pcgen-drools
      > Again, this is just a fun experiment right now. Who knows where this will lead...
      >
      > I've implemented Pathfinder ability scores, AC, saves, initiative, encumbrance and conditions. I've added support for alternative rule systems, but haven't built any.
      >
      > The rule files are at this URL. The size.drl is one of the easiest to read.
      > https://github.com/chrisdolan/pcgen-drools/tree/master/net.chrisdolan.pcgen.drools/src/main/resources/net/chrisdolan/pcgen/drools/pathfinder
      >
      > Chris
      >
      >
      > On Jun 13, 2013, at 9:32 PM, Chris Dolan <chris@...> wrote:
      >
      >> Hi all. Here's something to distract you from the hard work of putting out another release. :-)
      >>
      >>
      >> Ever since I halted work on my Android port of PCGen, I've been contemplating alternative ways of representing RPG rules and data. In that time, I failed to come up with a good plan that didn't require a massive rewrite of the LST files and/or the code to interpret those rules.
      >>
      >> So, last week I started an experiment. I said to myself, what if I *could* start from scratch using a off-the-shelf Java rules engine to do most of the hard work? So I picked a small piece of the Pathfinder system (the Armor Class calculation) and encoded it in the Drools DRL syntax. Drools is a spinoff of the RedHat JBoss project that implements an efficient knowledge base and rules engine. (www.jboss.org/drools) Enterprise-y people often use it to encode when-then business logic, like "WHEN I get a customer order THEN send this message to the warehouse", etc.
      >>
      >> Now, I'm NOT actually proposing to start over with PCGen!! This is just a what-if experiment. Especially on the eve of another release of the spectacular 6.0 branch, I don't want to diminish the enormous amount of work that has come before me.
      >>
      >> So now with that disclaimer aired, here's an example of what Pathfinder looks like when encoded in Drools. First some setup code and injection of initial conditions (which would probably be XML or JSON and not Java code, of course)
      >>
      >> Engine engine = new Engine();
      >> engine.create();
      >> engine.insert(new AttributeInput(AttributeInput.STR, 10));
      >> engine.insert(new AttributeInput(AttributeInput.DEX, 12));
      >> engine.insert(new AttributeInput(AttributeInput.CON, 11));
      >> engine.insert(new AttributeInput(AttributeInput.WIS, 18));
      >> engine.insert(new AttributeInput(AttributeInput.INT, 10));
      >> engine.insert(new AttributeInput(AttributeInput.CHA, 10));
      >> engine.insert(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_ARMOR, 2));
      >> engine.insert(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_DEFLECTION, 2));
      >> engine.insert(new Condition(Condition.TYPE_CHARGE));
      >> engine.run();
      >> engine.query(...); // ask knowledge questions about total AC or the Touch AC
      >>
      >> The actual rules look like this (somewhat abbreviated for readability). The insertLogical() function is an important tool for the rules to inject new inferred facts back into the engine, which in turn trigger other rules which inject new facts and so on.
      >>
      >> ------ armorclass.drl -------
      >>
      >> // These are generic rules for how bonuses should stack
      >> rule "Stack.Sum"
      >> when
      >> StackRule($t:type, $st:subtype, rulename == "Sum") // this bonus type/subtype wants to be summed
      >> Number($sum : intValue) from accumulate(Input(type == $t, subtype == $st, $v:value), sum($v)) // add 'em up
      >> then
      >> insertLogical(new Stack($sum,$t,$st)); // inject the total as a known fact
      >> end
      >> rule "Stack.Max"
      >> when
      >> $s : Input($t:type, $st:subtype, $v:value) // pick the highest input of a given type/subtype
      >> not Input(type == $t, subtype == $st, value > $v)
      >> StackRule(type == $t, subtype == $st, rulename == "Max") // and that type/subtype follows the "Max" stacking logic
      >> then
      >> insertLogical(new Stack($v,$t,$st));
      >> end
      >>
      >> // This is an example of what happens when we inject a condition into the engine
      >> rule "Condition.Charging"
      >> when
      >> Condition(type == Condition.TYPE_CHARGE) // if the engine has a matching condition...
      >> then
      >> insertLogical(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_OTHER, -2)); // ... then inject facts
      >> insertLogical(new Input("Attack", "Charge", 2));
      >> insertLogical(new Input("CMB", "BullRush", 2));
      >> end
      >>
      >> // These rules compute ability bonuses, like Dex 18 => +4
      >> rule "Attribute.UserInputs"
      >> when
      >> AttributeInput($attname:name, $v:value) // these are user-supplied Str, Dex, Con, etc
      >> then
      >> insertLogical(new Input(AttributeInput.TYPE + $attname, AttributeInput.SUBTYPE_BASE, $v)); // turn it into a fact
      >> end
      >> rule "Attribute.Totals"
      >> when
      >> AttributeName($attname:name) // for each known attribute type...
      >> Number($att : intValue) from accumulate( // ... sum the bonuses, including user input base score
      >> Stack($v:value, type == (AttributeInput.TYPE + $attname)),
      >> sum($v)
      >> )
      >> then
      >> insertLogical(new Attribute($attname, $att)); // the total ability score
      >> insertLogical(new AttributeBonus($attname, $att/2 - 5)); // 10-11 => +0, 12-13 => +1, etc
      >> end
      >>
      >> // And finally these rules refine and collect the AC inputs
      >> rule "Dex.AC"
      >> when
      >> AttributeBonus(name == AttributeInput.DEX, $v:value) // Given the dex bonus computed above...
      >> then
      >> insertLogical(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_DEXTERITY, $v)); // ...insert an AC bonus equal to it
      >> end
      >>
      >> rule "Size.AC.Large" // ... omitting all of the other sizes for brevity...
      >> when
      >> Input(type == "Size", subtype == "Large")
      >> then
      >> insertLogical(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_SIZE, -1));
      >> end
      >>
      >> rule "AC.Normal" // Sum up all AC bonuses, including the base 10
      >> when
      >> Number($ac : intValue) from accumulate(
      >> Stack($v:value, type == ArmorClass.TYPE),
      >> sum($v)
      >> )
      >> then
      >> insertLogical(new ArmorClass(ArmorClass.ACTYPE_NORMAL, $ac));
      >> end
      >> rule "AC.Touch" // Sum up all AC bonuses *except* armor, shield, natural
      >> when
      >> Number($ac : intValue) from accumulate(
      >> Stack($v:value, type == ArmorClass.TYPE, subtype not in ( "Armor", "Shield", "Natural" )),
      >> sum($v)
      >> )
      >> then
      >> insertLogical(new ArmorClass(ArmorClass.ACTYPE_TOUCH, $ac));
      >> end
      >>
      >> ------ armorclass.drl -------
      >>
      >>
      >> The nice thing about Drools is that it's incredibly efficient at recomputing outcomes when you inject new facts. So, if you were to inject a "new Condition(Condition.TYPE_FATIGUED)" Drools would fire the minimal set of rules to adjust your Dex by -2 and thus your AC by -1.
      >>
      >> The DRL syntax gets compiled down to Java bytecode at runtime or at build time. The latter might work well for Android, but I haven't tested that theory yet.
      >>
      >> So with 1300 lines of Java and 250 lines of DRL, I've managed to build a nearly-complete Pathfinder AC calculator, including Monk bonuses, size modifiers and most of the conditions from the back of the core rulebook.
      >>
      >> Chris
      >>
      >>
      >>
      >>
      >> ------------------------------------
      >>
      >> Yahoo! Groups Links
      >>
      >>
      >>
      >
      >
      >
      > ------------------------------------
      >
      > Yahoo! Groups Links
      >
      >
      >
      >
    • Eric Jarman
      Poking around on the drools website reveals a gui rule editor (often requested), web presentation interface (occasionally requested), and an event processing
      Message 2 of 8 , Jun 18, 2013
      • 0 Attachment
        Poking around on the drools website reveals a gui rule editor (often requested), web presentation interface (occasionally requested), and an event processing interface (makes me think gmgen).

        I echo the sentiment of exciting.


        On Sat, Jun 15, 2013 at 1:15 PM, Andrew <drew0500@...> wrote:
        Looks nice and exciting.



        On 6/15/2013 10:20 AM, Chris Dolan wrote:
        > I've posted my initial code on Github.
        >    https://github.com/chrisdolan/pcgen-drools
        > Again, this is just a fun experiment right now. Who knows where this will lead...
        >
        > I've implemented Pathfinder ability scores, AC, saves, initiative, encumbrance and conditions. I've added support for alternative rule systems, but haven't built any.
        >
        > The rule files are at this URL. The size.drl is one of the easiest to read.
        >     https://github.com/chrisdolan/pcgen-drools/tree/master/net.chrisdolan.pcgen.drools/src/main/resources/net/chrisdolan/pcgen/drools/pathfinder
        >
        > Chris
        >
        >
        > On Jun 13, 2013, at 9:32 PM, Chris Dolan <chris@...> wrote:
        >
        >> Hi all. Here's something to distract you from the hard work of putting out another release. :-)
        >>
        >>
        >> Ever since I halted work on my Android port of PCGen, I've been contemplating alternative ways of representing RPG rules and data. In that time, I failed to come up with a good plan that didn't require a massive rewrite of the LST files and/or the code to interpret those rules.
        >>
        >> So, last week I started an experiment. I said to myself, what if I *could* start from scratch using a off-the-shelf Java rules engine to do most of the hard work? So I picked a small piece of the Pathfinder system (the Armor Class calculation) and encoded it in the Drools DRL syntax. Drools is a spinoff of the RedHat JBoss project that implements an efficient knowledge base and rules engine. (www.jboss.org/drools) Enterprise-y people often use it to encode when-then business logic, like "WHEN I get a customer order THEN send this message to the warehouse", etc.
        >>
        >> Now, I'm NOT actually proposing to start over with PCGen!! This is just a what-if experiment. Especially on the eve of another release of the spectacular 6.0 branch, I don't want to diminish the enormous amount of work that has come before me.
        >>
        >> So now with that disclaimer aired, here's an example of what Pathfinder looks like when encoded in Drools. First some setup code and injection of initial conditions (which would probably be XML or JSON and not Java code, of course)
        >>
        >>        Engine engine = new Engine();
        >>        engine.create();
        >>        engine.insert(new AttributeInput(AttributeInput.STR, 10));
        >>        engine.insert(new AttributeInput(AttributeInput.DEX, 12));
        >>        engine.insert(new AttributeInput(AttributeInput.CON, 11));
        >>        engine.insert(new AttributeInput(AttributeInput.WIS, 18));
        >>        engine.insert(new AttributeInput(AttributeInput.INT, 10));
        >>        engine.insert(new AttributeInput(AttributeInput.CHA, 10));
        >>        engine.insert(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_ARMOR, 2));
        >>        engine.insert(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_DEFLECTION, 2));
        >>        engine.insert(new Condition(Condition.TYPE_CHARGE));
        >>        engine.run();
        >>        engine.query(...); // ask knowledge questions about total AC or the Touch AC
        >>
        >> The actual rules look like this (somewhat abbreviated for readability). The insertLogical() function is an important tool for the rules to inject new inferred facts back into the engine, which in turn trigger other rules which inject new facts and so on.
        >>
        >>  ------ armorclass.drl -------
        >>
        >> // These are generic rules for how bonuses should stack
        >> rule "Stack.Sum"
        >>    when
        >>        StackRule($t:type, $st:subtype, rulename == "Sum") // this bonus type/subtype wants to be summed
        >>        Number($sum : intValue) from accumulate(Input(type == $t, subtype == $st, $v:value), sum($v)) // add 'em up
        >>    then
        >>        insertLogical(new Stack($sum,$t,$st)); // inject the total as a known fact
        >> end
        >> rule "Stack.Max"
        >>    when
        >>        $s : Input($t:type, $st:subtype, $v:value) // pick the highest input of a given type/subtype
        >>        not Input(type == $t, subtype == $st, value > $v)
        >>        StackRule(type == $t, subtype == $st, rulename == "Max") // and that type/subtype follows the "Max" stacking logic
        >>    then
        >>        insertLogical(new Stack($v,$t,$st));
        >> end
        >>
        >> // This is an example of what happens when we inject a condition into the engine
        >> rule "Condition.Charging"
        >>    when
        >>        Condition(type == Condition.TYPE_CHARGE) // if the engine has a matching condition...
        >>    then
        >>        insertLogical(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_OTHER, -2)); // ... then inject facts
        >>        insertLogical(new Input("Attack", "Charge", 2));
        >>        insertLogical(new Input("CMB", "BullRush", 2));
        >> end
        >>
        >> // These rules compute ability bonuses, like Dex 18 => +4
        >> rule "Attribute.UserInputs"
        >>    when
        >>        AttributeInput($attname:name, $v:value) // these are user-supplied Str, Dex, Con, etc
        >>    then
        >>        insertLogical(new Input(AttributeInput.TYPE + $attname, AttributeInput.SUBTYPE_BASE, $v)); // turn it into a fact
        >> end
        >> rule "Attribute.Totals"
        >>    when
        >>        AttributeName($attname:name) // for each known attribute type...
        >>        Number($att : intValue) from accumulate(   // ... sum the bonuses, including user input base score
        >>            Stack($v:value, type == (AttributeInput.TYPE + $attname)),
        >>            sum($v)
        >>        )
        >>    then
        >>        insertLogical(new Attribute($attname, $att)); // the total ability score
        >>        insertLogical(new AttributeBonus($attname, $att/2 - 5)); // 10-11 => +0, 12-13 => +1, etc
        >> end
        >>
        >> // And finally these rules refine and collect the AC inputs
        >> rule "Dex.AC"
        >>    when
        >>        AttributeBonus(name == AttributeInput.DEX, $v:value) // Given the dex bonus computed above...
        >>    then
        >>        insertLogical(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_DEXTERITY, $v)); // ...insert an AC bonus equal to it
        >> end
        >>
        >> rule "Size.AC.Large" // ... omitting all of the other sizes for brevity...
        >>    when
        >>        Input(type == "Size", subtype == "Large")
        >>    then
        >>        insertLogical(new Input(ArmorClass.TYPE, ArmorClass.SUBTYPE_SIZE, -1));
        >> end
        >>
        >> rule "AC.Normal" // Sum up all AC bonuses, including the base 10
        >>    when
        >>        Number($ac : intValue) from accumulate(
        >>            Stack($v:value, type == ArmorClass.TYPE),
        >>            sum($v)
        >>        )
        >>    then
        >>        insertLogical(new ArmorClass(ArmorClass.ACTYPE_NORMAL, $ac));
        >> end
        >> rule "AC.Touch" // Sum up all AC bonuses *except* armor, shield, natural
        >>    when
        >>        Number($ac : intValue) from accumulate(
        >>            Stack($v:value, type == ArmorClass.TYPE, subtype not in ( "Armor", "Shield", "Natural" )),
        >>            sum($v)
        >>        )
        >>    then
        >>        insertLogical(new ArmorClass(ArmorClass.ACTYPE_TOUCH, $ac));
        >> end
        >>
        >>  ------ armorclass.drl -------
        >>
        >>
        >> The nice thing about Drools is that it's incredibly efficient at recomputing outcomes when you inject new facts. So, if you were to inject a "new Condition(Condition.TYPE_FATIGUED)" Drools would fire the minimal set of rules to adjust your Dex by -2 and thus your AC by -1.
        >>
        >> The DRL syntax gets compiled down to Java bytecode at runtime or at build time. The latter might work well for Android, but I haven't tested that theory yet.
        >>
        >> So with 1300 lines of Java and 250 lines of DRL, I've managed to build a nearly-complete Pathfinder AC calculator, including Monk bonuses, size modifiers and most of the conditions from the back of the core rulebook.
        >>
        >> Chris
        >>
        >>
        >>
        >>
        >> ------------------------------------
        >>
        >> Yahoo! Groups Links
        >>
        >>
        >>
        >
        >
        >
        > ------------------------------------
        >
        > Yahoo! Groups Links
        >
        >
        >
        >


        ------------------------------------

        Yahoo! Groups Links

        <*> To visit your group on the web, go to:
            http://groups.yahoo.com/group/pcgen_developers/

        <*> Your email settings:
            Individual Email | Traditional

        <*> To change settings online go to:
            http://groups.yahoo.com/group/pcgen_developers/join
            (Yahoo! ID required)

        <*> To change settings via email:
            pcgen_developers-digest@yahoogroups.com
            pcgen_developers-fullfeatured@yahoogroups.com

        <*> To unsubscribe from this group, send an email to:
            pcgen_developers-unsubscribe@yahoogroups.com

        <*> Your use of Yahoo! Groups is subject to:
            http://docs.yahoo.com/info/terms/


      • Chris Dolan
        Thanks for the positive feedback. I recommend that you do NOT get excited about the web presentation layer for Drools. :-) As for rules editing, I m just using
        Message 3 of 8 , Jun 18, 2013
        • 0 Attachment
          Thanks for the positive feedback. I recommend that you do NOT get excited
          about the web presentation layer for Drools. :-) As for rules editing, I'm
          just using the Drools plugin for Eclipse.

          Lately I'm working on porting my experiment to Android. I expect it to
          fail because I believe Drools compiles down to Java bytecode instead of
          Dalvik bytecode, but I might be surprised. If it does fail, I'm going to
          experiment with pre-compiled rulesets, which will make homebrew rules much
          harder to implement in an Android-compatible way.

          All this started because I wanted to apply Rage to my Barbarian at the
          tabletop instead of swapping between two PDFs on my Nexus tablet...

          Chris


          On Tue, June 18, 2013 11:00 am, Eric Jarman wrote:
          > Poking around on the drools website reveals a gui rule editor (often
          > requested), web presentation interface (occasionally requested), and an
          > event processing interface (makes me think gmgen).
          >
          > I echo the sentiment of exciting.
          >
          >
          > On Sat, Jun 15, 2013 at 1:15 PM, Andrew <drew0500@...> wrote:
          >
          >> Looks nice and exciting.
          >>
          >>
          >>
          >> On 6/15/2013 10:20 AM, Chris Dolan wrote:
          >> > I've posted my initial code on Github.
          >> > https://github.com/chrisdolan/pcgen-drools
          >> > Again, this is just a fun experiment right now. Who knows where this
          >> will lead...
          >> >
          >> > I've implemented Pathfinder ability scores, AC, saves, initiative,
          >> encumbrance and conditions. I've added support for alternative rule
          >> systems, but haven't built any.
          >> >
          >> > The rule files are at this URL. The size.drl is one of the easiest to
          >> read.
          >> >
          >> https://github.com/chrisdolan/pcgen-drools/tree/master/net.chrisdolan.pcgen.drools/src/main/resources/net/chrisdolan/pcgen/drools/pathfinder
          >> >
          >> > Chris
          >> >
          >> >
          >> > On Jun 13, 2013, at 9:32 PM, Chris Dolan <chris@...> wrote:
          >> >
          >> >> Hi all. Here's something to distract you from the hard work of
          >> putting
          >> out another release. :-)
          >> >>
          >> >>
          >> >> Ever since I halted work on my Android port of PCGen, I've been
          >> contemplating alternative ways of representing RPG rules and data. In
          >> that
          >> time, I failed to come up with a good plan that didn't require a massive
          >> rewrite of the LST files and/or th
        • Chris Dolan
          I hit a milestone tonight. I can now parse the following PC and auto-compute several combat-related values for him. Note: the XML syntax is *far* from set in
          Message 4 of 8 , Jun 22, 2013
          • 0 Attachment
            I hit a milestone tonight. I can now parse the following PC and auto-compute several combat-related values for him. Note: the XML syntax is *far* from set in stone. I just threw something together that described the bare minimum of player choices. Also, my rules do no validation of the PC. You could easily cheat and give him 100 extra feats and the code won't care.

            <pc xmlns="http://chrisdolan.net/pcgen/drools/input">
            <ruleset name="pathfinder"/>
            <input>
            <property name="CharacterName" value="Aarn"/>
            <property name="PlayerName" value="Chris Dolan"/>

            <alignment name="LawfulEvil"/>

            <stat value="14" name="Strength"/>
            <stat value="14" name="Dexterity"/>
            <stat value="12" name="Constitution"/>
            <stat value="10" name="Intelligence"/>
            <stat value="14" name="Wisdom"/>
            <stat value="8" name="Charisma"/>

            <race name="Human" age="24">
            <favoredclass name="Monk"/>
            <statbonus name="Strength"/>
            <trait name="Suspicious"/>
            </race>

            <level class="Monk">
            <archetype class="Monk" name="HungryGhost"/>
            <hitpoints value="8"/>
            <skill ranks="1" name="Acrobatics"/>
            <skill ranks="1" name="Climb"/>
            <skill ranks="1" name="EscapeArtist"/>
            <skill ranks="1" name="Perception"/>
            <skill ranks="1" name="SenseMotive"/>
            <favoredclassbonus name="Hitpoint"/>
            <feat source="class" name="CombatReflexes"/>
            <feat name="Toughness"/>
            <feat name="ViciousStomp"/>
            </level>
            </input>
            </pc>


            The current output of the rules engine looks like the following (abbreviated).
            Known flaws:
            * hit points are wrong

            AC[Melee=14]
            AC[MeleeTouch=14]
            AC[Normal=14]
            AC[Range=14]
            AC[RangeTouch=14]
            AC[Touch=14]
            Alignment[LawfulEvil]
            Archetype[Monk.Base]
            BAB( value=0 )
            CMB( type=Base, value=2 )
            CMB( type=BullRush, value=2 )
            CMB( type=Disarm, value=2 )
            CMB( type=Grapple, value=2 )
            CMB( type=Overrun, value=2 )
            CMB( type=Sunder, value=2 )
            CMB( type=Trip, value=2 )
            CMD( type=Base, value=14 )
            CMD( type=BullRush, value=14 )
            CMD( type=Disarm, value=14 )
            CMD( type=Grapple, value=14 )
            CMD( type=Overrun, value=14 )
            CMD( type=Sunder, value=14 )
            CMD( type=Trip, value=14 )
            CurrentHitpoints( type=Lethal, value=1 )
            CurrentHitpoints( type=Nonlethal, value=1 )
            CurrentHitpoints( type=Temporary, value=0 )
            CurrentSpeed( value=30 )
            Hitpoints( value=1 )
            Initiative[2]
            Language( name=Common )
            Level[PC-1/Monk-1]
            Property[CharacterName=Aarn]
            Property[PlayerName=Chris Dolan]
            Race( name=Human )
            SavingThrow[Fortitude=3]
            SavingThrow[Reflex=4]
            SavingThrow[Will=4]
            Size( type=Medium )
            Speed( value=30 )
            Stat( name=Charisma, value=8 )
            Stat( name=Constitution, value=12 )
            Stat( name=Dexterity, value=14 )
            Stat( name=Intelligence, value=10 )
            Stat( name=Strength, value=14 )
            Stat( name=Wisdom, value=14 )
            StatBonus( name=Charisma, value=-1 )
            StatBonus( name=Constitution, value=1 )
            StatBonus( name=Dexterity, value=2 )
            StatBonus( name=Intelligence, value=0 )
            StatBonus( name=Strength, value=2 )
            StatBonus( name=Wisdom, value=2 )



            On Jun 18, 2013, at 12:21 PM, Chris Dolan <chris@...> wrote:

            > Thanks for the positive feedback. I recommend that you do NOT get excited
            > about the web presentation layer for Drools. :-) As for rules editing, I'm
            > just using the Drools plugin for Eclipse.
            >
            > Lately I'm working on porting my experiment to Android. I expect it to
            > fail because I believe Drools compiles down to Java bytecode instead of
            > Dalvik bytecode, but I might be surprised. If it does fail, I'm going to
            > experiment with pre-compiled rulesets, which will make homebrew rules much
            > harder to implement in an Android-compatible way.
            >
            > All this started because I wanted to apply Rage to my Barbarian at the
            > tabletop instead of swapping between two PDFs on my Nexus tablet...
            >
            > Chris
            >
            >
            > On Tue, June 18, 2013 11:00 am, Eric Jarman wrote:
            >> Poking around on the drools website reveals a gui rule editor (often
            >> requested), web presentation interface (occasionally requested), and an
            >> event processing interface (makes me think gmgen).
            >>
            >> I echo the sentiment of exciting.
            >>
            >>
            >> On Sat, Jun 15, 2013 at 1:15 PM, Andrew <drew0500@...> wrote:
            >>
            >>> Looks nice and exciting.
            >>>
            >>>
            >>>
            >>> On 6/15/2013 10:20 AM, Chris Dolan wrote:
            >>>> I've posted my initial code on Github.
            >>>> https://github.com/chrisdolan/pcgen-drools
            >>>> Again, this is just a fun experiment right now. Who knows where this
            >>> will lead...
            >>>>
            >>>> I've implemented Pathfinder ability scores, AC, saves, initiative,
            >>> encumbrance and conditions. I've added support for alternative rule
            >>> systems, but haven't built any.
            >>>>
            >>>> The rule files are at this URL. The size.drl is one of the easiest to
            >>> read.
            >>>>
            >>> https://github.com/chrisdolan/pcgen-drools/tree/master/net.chrisdolan.pcgen.drools/src/main/resources/net/chrisdolan/pcgen/drools/pathfinder
            >>>>
            >>>> Chris
            >>>>
            >>>>
            >>>> On Jun 13, 2013, at 9:32 PM, Chris Dolan <chris@...> wrote:
            >>>>
            >>>>> Hi all. Here's something to distract you from the hard work of
            >>> putting
            >>> out another release. :-)
            >>>>>
            >>>>>
            >>>>> Ever since I halted work on my Android port of PCGen, I've been
            >>> contemplating alternative ways of representing RPG rules and data. In
            >>> that
            >>> time, I failed to come up with a good plan that didn't require a massive
            >>> rewrite of the LST files and/or th
            >
            >
            >
            > ------------------------------------
            >
            > Yahoo! Groups Links
            >
            >
            >
          Your message has been successfully submitted and would be delivered to recipients shortly.