In reply to steelsmiter (msg # 37):

Well I would set it up for "STBox*STBox/5" as that would be simpler for everyone involved, except perhaps those that don't know what squaring means (in which case how can they be expected to the math for a regular sheet? Such individuals would find this really helpful, cause then only the GM would need to worry about the math.)

Besides, I would expect the whole thing to be optional, particularly since you have free-form games and such that don't need any math done.

This idea would only have a fill-in-the-blanks thing from the player's perspective.

I certainly don't expect everyone to like it, though I still don't see why everyone keeps attaching more to it then is needed. Of course, I would personally be staying away from a game that requires me to be squaring numbers on my sheet.

But the way I see it, the more math that needs done, the more helpful something like this would be, but also the more likely those involved would like this, as dealing with a lot more crunch is generally liked by those that not only find this type of stuff easier, but also enjoys this type of stuff.

In reply to bigbadron (msg # 38):

The GM would only have to check the numbers once, though, instead of for every player.

The simplicity is not gained on a single sheet but rather over time, as the GM would do less math and stuff in the long run. Once it is set up, you have much less work. Leveled up?, just increase the level and the skill ranks, and everything based on those are automatically done.

So more work up front, less afterwards. For the GM anyway, the players have less work all the way through as they don't have to do any of the common, the just fill in the blanks and the form gives them the numbers they need. They only have to worry about temp modifiers (which would be no different then current).

Also, a GM probably runs the same system or small selection of systems, so once the GM has the sheet made, they can often just import to any newer games they make, which means one time set-up, which occasional adjustment.

That's a pretty big assumption.  I've seen a lot of GMs (myself included) who run a wide variety of systems.

I am going off the GMs I know (and I have played with plenty). I am also considering systems to be the same when they are basically the same thing, such as most d20 variants are essentially the same system despite having a dozen or so "different" games. The same sheet would be usable for each with only minor fixes.

I'm judging it from the 100 to 150 different RPoL sticky lists I see each week when I'm doing account checks.  Lots of GMs run multiple systems.

As for different systems... in the last few years I've run Runequest, Bushido, Traveller, D&D, Cyberpunk, Amber, GURPS, FATE, Cat, Tunnels & Trolls... so not really much cross-over there.

The "formula" box sounds simple at first blush, but it's a giant can of worms.  Essentially, someone's going to have to be responsible for coding that -- and then to use it, GMs have to learn this strange character sheet algebra.  And I say "strange" because if your sheet is geared toward one system, it stays fairly simple, but if the algebra has to be generic enough to be useful to a wide variety of people, it's going to quickly turn into a full scripting language complete with arrays and the whole deal.

For example, I generally play oldschool basic D&D.  Saving Throws, AC, and THAC0 are just three parts of that character sheet, but most players are looking at their sheets for precisely that information -- and none of them are a simple "A + B" type calculation.  They all rely on tables which require multiple look-ups, such as cross-referencing class and level and then adjusting for an ability score and, possibly, class.

That's not a simple calculation, and without it, the sheet would be useless for even the most basic game.

In the same game, most GMs I've seen don't have players roll for their characters' six ability scores in order; they instead roll a pool of results then organize them as they see fit.  I can't imagine how the sheet's algebra would take care of that either.  So it's not good for basic character gen either.

What's above is too simple to be useful.  The reality is too complex for someone to do as anything other than a job.
This message was last edited by the user at 14:33, Sun 10 Aug 2014.

It sounds to me that you'd be better off creating your 'sheet' in spreadsheet form (Excel for example), and then linking to it.

Anyone who developed one could then share it with interested GMs, possibly via Heaven or by offering them to others in their games.

Take it from someone who's done the excel-fu ninja thing.  It can be HORRENDOUSLY complex.  I've given up on almost every single one, because most of the way through it it just got so complex that one little incompatibility (don't read that as an error) earlier in the design crashes the whole thing.

If you have any excel skills, I can send you the sheets.  These are sheets done for single specific things too.  Designing weapons in Traveller, campaign aids for Battletech.  Not something as complex as character generation.

I'm not saying that it CAN'T be done.  It can.  It's just incredibly complex.  And in trying to make it 'multi-function' you end up tossing in more variables.  Usually, the more functions a device has, the less optimally it performs those functions.  Look at a spork or a multi-tool.  You CAN go a different route and achieve standard functionality with a multi-tool, but then you end up with something with as byzantine of a design as a computer (and I'm talking complete design down to circuit boards).

I know you aren't talking about a full fledged character generator, but then the question is "Why".  As a GM, not here, but elsewhere.  I see little use for it otherwise.  If it's a simple math tool, you can come up with it on your own, with MS Office or Open Office with just a couple of web searches to figure out what to do.

In reply to bigbadron (msg # 43):

+1 to that message. Not to mention those of us that run indie systems that don't even come close to having anything 'traditional' on the sheet.

In reply to steelsmiter (msg # 47):

Traditional or not wouldn't have an effect.

___

The idea was never to include a bunch data about systems. I can get that people might not care about simplifying some of the math, but honestly, it was never intended to look up rules or character options, it is purely for simplifying the common math, which may not be equally useful for all systems, but it is simple to do as far as programming goes.

Besides, if you have to go sorting through giant lists of features, wouldn't it be easier to just type up the description and enter the bonus into a "misc bonus" box?

And yeah, some games have tables, usually during creation though and still some calculations could be done. For example, bab, just enter lvl and bab speed, the sheet then will multiply the two for each class, then add, and viola, a total bab automatically, though one stil has to find out which bab to use, but then lvling up has one less thing to do, just increase the level by one that is it.

And these other things are complicated, which is why I never included them to begin with, however, the idea I presented does make a good base for individual functions could be added as they get figured out.

And in any case, I hate having to use external stuff, particularly office documents because they can't be used on my phone, and external websites are additional hoops to go through as a player everytime I want to see the sheet, which requires a fair amount of time of waiting every shift in site, and if it has a bunch flash ads, that triples the wait timex and external sites can't be modified for house rules, etc.

Every option has problems, it is just a matter of deciding which problems are worth dealing with. I personally have a saying "ten minutes now saves you ten hours later" so yeah, I prefer heavier up front work if it makes follow up work easier.

For some of us, the current status quo is 10 minutes now, and the change will be ten hours now.

In reply to steelsmiter (msg # 49):

The only thing I have suggested that might not be optional is to color the GMs name for posts in games (and that could be made optional). Anything else I suggest, I present with the idea of being optional, hence you can use it if you want or ignore it.

I would not use it and I am actively opposed to anything that would cause more strain on the site.  There are plenty of outside options for character sheet creation; RPoL doesn't need that bloat.

-1.

Well, I really do like that idea, optional or otherwise.


I suppose that depends on what games I join now doesn't it?

I have a question:
Why can't you just use an off-site sheet/generator to do this and then fill in the character sheet template your GM gives you?

You've mentioned sources which already do what you're asking. Why build another here? Because typing character sheets is a pain? There are ways and places to host character sheets off-site if you really feel the need to.

-1

The character sheet is fine as it is, allowing a great variety of people to play a great variety of games flexibly. If someone is too lazy to translate their own character sheet even into simple text or finding the numerous ones out there in the Heaven forum, they probably shouldn't be running a game in the first place.

I think the likelihood of jase or the moderators volunteering to create a generic character sheet to be used across a multitude of games is somewhere between none and minuscule-ly thin.

If someone wishes to create one that they'd like to submit for consideration to see how it might be implemented, then that's at least a starting point.

Otherwise, the discussion will likely not progress much.  :-)

If I understand it right, what DLH is suggesting isn't really a generic character sheet or anything like that; it's more a simple spreadsheet option, for people who want to make their own.  With just a couple of basic spreadsheet operations, like the ability to reference another cell and some automatic addition.  I see it useful in that part mostly for being able to set it up so that, say, when someone adds +1 to their Dexterity, all fifteen of their Dexterity-based Skills go up with it (and maybe their Initiative, and quite possibly their Missile Attack Bonus, and..), instead of me (as player or GM) having to go down the sheet and make sure I don't miss anything.

It seems to me it would have to be kind of an alternate Character Sheet - one that's divided into spreadsheet cells, rather than just an open word processing form, with the cell-lines presumably disappearing from the "View Charactersheet" screen and only appearing in the Edit screen.  With the ability to store a character sheet under the GM name, too, you could just build one and then copy it into the others when you add new players -- as I'm pretty sure people do now.  And, yeah, it probably would be nice if people offered some common systems, like Chill and Nephilim and OKfineyesImeanD&D, to put up in Heaven.

It would be something that the GM would pick when they set up the character sheets in the first place.  Which incidentally, if it keeps working anything like it is now, means that it would be on a sheet-by-sheet-basis -- so if spreadsheets really drive you crazy and the GM wants you to keep your own sheet updated in the game, you can ask them not to for just you even if the other players are all using them.  Or vice-versa.

And since it would just be one-or-the-other... well, I don't know the coding side, but Jase has said to leave that to him.  On the storage side, it doesn't sound like `bloat' to me, because you still have One Character = One Character Sheet.

...I don't know. Given that Spreadsheets are actually the tool-of-choice for character sheet building, just for their formatting differences (eg., being easier to keep lines and columns absolutely straight) -- I would be a +1 on adding a very simple one as an alternative to the open kind we have now.  I have a GM who has worked very hard on embedding the Tables into the character sheets in his game, and it's very nice to look at... but very awkward when you have to edit, because they put in so much extra coding.  I don't know any GMs who have actually built whole sheets into Tables, but I do know some that have wished they could.  Starting from a Spreadsheet, all you'd need would be a way to keep the lines visible in an area.


Um.  Which makes me think, this is a feature that, once implemented, I do see people requesting more and more functionality for over the years, but I'm not sure that's a bad thing -- that strikes me more as `room for growth'; starting simple and gradually letting it shape into what people really want it to do.  Something for Jase to keep in mind, though, probably. grin

Perhaps we could get something like this enabled on the wikipages that we have here: https://www.mediawiki.org/wiki...erFunctions/Extended if it isn't already?  Or anything from https://www.mediawiki.org/wiki...gory:Math_extensions (noting that some are far safer than others)?

Parser functions are very tricky and care has to be taken.  What if someone tries to put in a calculation of "10+hjfd-2" or "2+*4".  Worse is "10/0", or even "echo y|format c:".  You have to take an incredible amount of care that the equation is not only valid but is not insidious.

That said, I was working on something about a year ago.  After it consumed an inordinate amount of time I eventually had to put it on the backburner so concentrate on and finish other things.  I haven't been back to tackle the beast since.

That's exactly what I was trying to say back around the 30 something messages range. I just didn't really have some idea how to clarify it. That comes from a knowledge of parsing that is far less complete than say... jase... or any other programmer for that matter. Seriously the most complicated programming I ever did was for the Elder Scrolls Construction Set in which I created a function that would allow a spell to steal the enemy's entire inventory. Better yet, the 'theft' flag wasn't activated.

Anywho that's all on a tangent. It was mind numbing. The same way automated character sheets are.

Just use what MediaWiki already has and the latter can't happen.  The MediaWiki #expr parser is basically a big set of PHP defines
https://git.wikimedia.org/blob...c3bf32830ca/Expr.php  If the calculation is gibberish, like 10+hjfd-2 then you'll get gibberish back (or an error, probably you'll get an error).

echo y|format c: isn't a defined PHP command in the MediaWiki file -- it doesn't have one of the magic words in it and as such is just treated like a string.  You'll get back what you put in (unless you check for is_numeric and then you'll either get nothing or whatever error message you have checking for that).

For instance:
/ Character classes
define( 'EXPR_WHITE_CLASS', " \t\r\n" );
define( 'EXPR_NUMBER_CLASS', '0123456789.' );

// Token types
define( 'EXPR_WHITE', 1 );
define( 'EXPR_NUMBER', 2 );
define( 'EXPR_NEGATIVE', 3 );
define( 'EXPR_POSITIVE', 4 );
define( 'EXPR_PLUS', 5 );
define( 'EXPR_MINUS', 6 );
define( 'EXPR_TIMES', 7 );
define( 'EXPR_DIVIDE', 8 );
define( 'EXPR_MOD', 9 );
define( 'EXPR_OPEN', 10 );
define( 'EXPR_CLOSE', 11 );
Skipping a bunch...
   /**
    * Evaluate a mathematical expression
    *
    * The algorithm here is based on the infix to RPN algorithm given in
    * http://montcs.bloomu.edu/~bobmon/Information/RPN/infix2rpn.shtml
    * It's essentially the same as Dijkstra's shunting yard algorithm.
    * @param $expr string
    * @throws ExprError
    * @return string
    */
   function doExpression( $expr ) {
       $operands = array();
       $operators = array();

       # Unescape inequality operators
       $expr = strtr( $expr, array( '&lt;' => '<', '&gt;' => '>',
           '&minus;' => '-', '&#8722;' => '-' ) );

       $p = 0;
       $end = strlen( $expr );
       $expecting = 'expression';
       $name = '';

       while ( $p < $end ) {
           if ( count( $operands ) > $this->maxStackSize || count( $operators ) > $this->maxStackSize ) {
               throw new ExprError( 'stack_exhausted' );
           }
           $char = $expr[$p];
           $char2 = substr( $expr, $p, 2 );

           // Mega if-elseif-else construct
           // Only binary operators fall through for processing at the bottom, the rest
           // finish their processing and continue

           // First the unlimited length classes

           if ( false !== strpos( EXPR_WHITE_CLASS, $char ) ) {
               // Whitespace
               $p += strspn( $expr, EXPR_WHITE_CLASS, $p );
               continue;
           } elseif ( false !== strpos( EXPR_NUMBER_CLASS, $char ) ) {
               // Number
               if ( $expecting != 'expression' ) {
                   throw new ExprError( 'unexpected_number' );
               }

               // Find the rest of it
               $length = strspn( $expr, EXPR_NUMBER_CLASS, $p );
               // Convert it to float, silently removing double decimal points
               $operands[] = floatval( substr( $expr, $p, $length ) );
               $p += $length;
               $expecting = 'operator';
               continue;
           } elseif ( ctype_alpha( $char ) ) {
               // Word
               // Find the rest of it
               $remaining = substr( $expr, $p );
               if ( !preg_match( '/^[A-Za-z]*/', $remaining, $matches ) ) {
                   // This should be unreachable
                   throw new ExprError( 'preg_match_failure' );
               }
               $word = strtolower( $matches[0] );
               $p += strlen( $word );

               // Interpret the word
               if ( !isset( $this->words[$word] ) ) {
                   throw new ExprError( 'unrecognised_word', $word );
               }
               $op = $this->words[$word];
               switch( $op ) {
               // constant
               case EXPR_EXPONENT:
                   if ( $expecting != 'expression' ) {
                       continue;
                   }
                   $operands[] = exp( 1 );
                   $expecting = 'operator';
                   continue 2;
               case EXPR_PI:
                   if ( $expecting != 'expression' ) {
                       throw new ExprError( 'unexpected_number' );
                   }
                   $operands[] = pi();
                   $expecting = 'operator';
                   continue 2;
               // Unary operator
               case EXPR_NOT:
               case EXPR_SINE:
               case EXPR_COSINE:
               case EXPR_TANGENS:
               case EXPR_ARCSINE:
               case EXPR_ARCCOS:
               case EXPR_ARCTAN:
               case EXPR_EXP:
               case EXPR_LN:
               case EXPR_ABS:
               case EXPR_FLOOR:
               case EXPR_TRUNC:
               case EXPR_CEIL:
               case EXPR_SQRT:
                   if ( $expecting != 'expression' ) {
                       throw new ExprError( 'unexpected_operator', $word );
                   }
                   $operators[] = $op;
                   continue 2;
               }
               // Binary operator, fall through
               $name = $word;
           }

           // Next the two-character operators

           elseif ( $char2 == '<=' ) {
And the code continues from there.

Now, I have no idea how RPoL is coded, other than that a large part of it is PHP.  That being said, this PHP document would seem to really do the trick, and it's licensed under the GPLv2 (see https://www.mediawiki.org/wiki...sion:ParserFunctions ) which means that if you add/modify the RPoL code with this code you wouldn't have to make the RPoL code public.

Edit: And of course the wiki runs on... whatever it is that it runs on, but you could put the GPLv2 code in there without making the rest of the wiki code public.  I got sidetracked and started thinking of this code applying to all of RPoL instead of just a wiki for a game.
This message was last edited by the user at 05:35, Mon 18 Aug 2014.

In reply to Genghis the Hutt (msg # 60):

I'd like to avoid that like the plague.
This message was last edited by a moderator, as it was moot, at 06:16, Mon 18 Aug 2014.

Why?  It's no more complicated than most code that runs websites like RPoL and it's not code that the user would ever see.  The user would only see things like:
{{#expr: 1/6 round 5 }} which would give 0.16667
And then the user would only see that in the wiki code if they edited a sheet.  Otherwise they'd presumably see a well-formatted sheet that automatically does some math.  It could look like this when a person views it:
And then when they edit it, they could see something like:Although the thought occurs to me, we'd have to have some way of defining constants that would be limited in scope to particular wikipages.  It looks like games have their own branch of the wiki, wiki.rpol.net/gameNumber/gamePages so they'd have to be defined with respect to that.  I'm not sure off the top of my head how that could be accomplished, but I have some ideas.
This message was last edited by the user at 06:10, Mon 18 Aug 2014.

Since jase has already said that he looked at this about a year ago, but that it was taking up far too much time, further discussion is probably moot at this point.