Step-die RPG systems and variance

I once heard a sports pundit—it may have been Frank Deford—say that amateur golfers ought to stop saying, “At least I’m consistent.” He argued that consistency was exactly what separated the amateur from the professional.

I mentioned that I like the idea of “smaller is better” step-die systems over the more common “bigger is better”. Here’s why: In a step-die system, the variance of a skill check changes with the character’s skill. In a “bigger is better” step-die system, the variance increases with character skill. In a “smaller is better” step-die system, the variance decreases with character skill.

The latter makes more sense to me.

Dictate

Dictation for the iPhone is very impressive. I am not sure, however, that speaking this message has been faster for me than typing it. Furthermore I think the time it takes me to type a message is dwarfed by the amount of time it takes me to organize and compose my thoughts.

The trouble with retweeting

It bothers me when someone I follow on Twitter says “please retweet”.

Case 1: Someone who follows me also follows the original tweeter. My retweet will just be noise for them.

Case 2: Someone who follows me and isn’t interested in the original tweeter. My retweet will just be noise for them.

Case 3: Someone who follows me who doesn’t follow the original tweeter but would be interested in following them. The retweet is only useful to the extent that it has made this person aware of the original tweeter.

While case 3 is good, a lot of case 1 & 2 noise is going to be generated to achieve it. Surely there are better ways to help people find followees than this.

I think the occasional “this person tweeted something unusually clever or insightful that I want to share” kind of retweet is just fine. “Please retweet”, however, tends to signal my above concerns.

Because it’s just like forwarding e-mail, isn’t it? Occasionally there are times when forwarding an e-mail is exactly the right thing to do. E-mails that were written with the expectation of being forwarded, however, are the one’s that are wasteful.

Interactive install

Computer install & update mechanisms should ensure that all needed user interaction happens up-front. It should also tell the user when the interactive portion is complete.

People debate whether these machine actually improve productivity, but babysitting them during lengthy operations is clearly unproductive.

Separating layout

The hypertext markup language (HTML) used to create the pages of the world-wide web began as a description for simple documents with hyperlinks. It supported headings, paragraphs, lists, and links. (Plus a handful of other things.)

Then tables were added. (Also notable was the addition of forms, but that’s another branch of the story.) Tables could not only be used to display tabular data, they could also be abused to create layouts beyond simply headings, paragraphs, and lists.

As styling was added to HTML, there was also a move to separate style from content, which brought us cascading style sheets (CSS).

There were problems with table-based layouts. To try to get away from the problems of table-based layouts, people have tried various HTML+CSS tricks. Many of which are based on a grid. Personally, I find these at least as troublesome as table-based layouts.

Perhaps we should separate content, style, and layout. HTML tables are, I think, a good way to describe a grid-based layout. If we, however, separate them from the content, does this eliminate or mitigate the problems we had with table-based layout?

OK, at this point, some understanding of HTML and CSS will be required.

Imagine a grid file containing mark-up similar to HTML tables. We’ll replace “table” with “grid”, “tr” with “row”, and “td” with “cell”. Cells support the rowspan and cellspan attributes. Cells contain CSS selectors that indicate what content from the HTML file should appear within that cell in the layout’s grid.

<grid>
  <row>
    <cell rowspan="2">div#header</cell>
  </row>
  <row>
    <cell>div#body</cell>
    <cell>div#rightsidebar</cell>
  </row>
  <row>
    <cell rowspan="2">div#footer</cell>
  </row>
</grid>

There’s probably a better way to describe layout, but I think HTML tables aren’t a bad start—once separated out. Personally, I’m not crazy about SGML/XML for things other than mark-up. S-expressions or some other syntax might be preferable. (CSS has its own syntax, so let’s not feel constrained to keep SGML/XML syntax for grid files.)

; Just a thought...
(grid (row (cell (2 1) div#header))
  (row (cell div#body)
       (cell div#rightsidebar))
  (row (cell (2 1) div#footer)))

Without browser support for grid files, we could write a program that would read HTML and grid files and generate HTML that faked it with tables.

Just a thought.

P.S. Since writing this, I came across this: The Evolution of Web Design

Robilar’s method

For the role-playing gamers...

I don’t remember exactly where I read this, but I thought it was very interesting how Rob Kuntz’s character, Robilar, explored the dungeons under Castle Greyhawk. (Apologies if I’m misremembering any of this.)

He would often travel alone. Although human, he would explore in the dark—just following the walls and keeping his ears open. He might use some light at an intersection, but only briefly when he felt it was safe to do so. He would not open doors. At least, not until he’d explored what he could without opening doors.

There are some interesting things to note here:

This (as Rob was playing it) isn’t a game of combat. This is a game of exploration.

If this had been a computer game, Robilar’s method would only be possible if the designers had specifically enabled it. Well, that may not be entirely true, but how many CRPGs are there in which Robilar’s method is possible? While D&D may have rules to cover some of this, that is only because Rob did it so Gary added some of the stuff he made up to handle it to the rules.

Robilar was a fighter. If I understand correctly, his companions when not alone were other fighters and mages. Neither clerics nor thieves were considered vital.

Robilar survived despite traps, “save or die” situations, the level-draining ability of undead, and so forth. As much as I’ve sometimes seen such things as arbitrary, unfair, or unfun; Robilar managed them. I suspect due to a combination of Rob being cautious and Gary being fair.

This also reinforces for me something Gary himself said: If you played with Gary at a convention, he was assuming you wanted a no-holds-barred experience. Gary was a different DM at conventions than when not at conventions.

Prefix notation via closures

For the programmers in the audience...

Recently I’d read yet again someone saying that prefix notation is one of the things keeping more people from using Lisp. As I’ve said before, I find it hard to believe that this is an obstacle in practice. Especially since so many languages limit infix notation to essentially numbers (and only built-in numeric types at that) and Boolean values.

(Keep in mind that I’m saying this as someone who was raised on C rather than Lisp.)

Then I started thinking about the way that method invocation in many object-oriented languages is infixish. Consider Smalltalk: "hello" at: 3 Or Java: "hello".charAt(3) Or even: bigInt.add(anotherBigInt)

So, by using the closure-as-object idiom in Scheme...

(define (number-object-ctor n)
(λ (op arg)
  (if op
      (number-object-ctor (op n (arg #f #f)))
      n)))

(define (print-number-object n)
(display (n #f #f))
(newline))

(define x (number-object-ctor 4))
(define y (number-object-ctor 5))

(print-number-object (x + y))
(print-number-object ((x * x) + (y * y)))

It’s not as practical as an infix macro. I just thought it was interesting, however, that prefix notation could be twisted into infix notation that way.

Camera tricks and virtual cameras

While watching Up, it struck me how Pixar (and other 3D animation studios) delight in simulating the limitations of a camera’s focus. Creating shots in which one element is in focus and background and foreground objects are out of focus.

Yet, when making films with actual cameras, filmmakers have used tricks to workaround those limitations. Like building large props or combining two shots of the same scene with different focus.

Stupid or a jerk

[...] their animation director, Rob Hughes, agreed: “in all the other shows every character is either stupid or a jerk, but there are no stupid characters or jerks in this one.”

—“Phineas and Ferb”, Wikipedia

This is something that I really like about that show. So many of the characters on the shows my kids watch are fools. It’s one thing to have a token fool, but...

I heard Bonnie Hunt once say that when doing improv at The Second City, she was taught this guideline: The blue joke will always come to mind first. Skip that, and go with the second thing that comes to mind.

I think foolish characters are the blue comedy of kids’ entertainment.

A step-die system

Here’s some sketchy ideas for a step-die role-playing game system that I’ll never actually expand into a full system.

Character attributes, skills, and gear are rated by type of die. Dice with fewer sides are better than dice with more sides. Here they are with Fudge equivalents.

• d2: Legendary
• d4: Superb
• d6: Great
• d8: Good
• d10: Typical
• d12: Mediocre
• d20: Terrible

Notice that we’ve lost the Fudge step—Poor—between Mediocre and Terrible. We use this natural gap between the d12 and the d20 to represent “unskilled” or “no gear”.

When making a “check”, a player rolls three dice. One each for...

• Relevant attribute
• Relevant skill
• Relevant gear

(Or the game might us a different trio. e.g. attribute, skill, and specialty.)

Add each character’s dice together. Low roll wins.

e.g. Herc—with Superb strength, Superb fighting skill, and a Superb sword—would roll d4 + d4 + d4. Mouse—with Mediocre strength, no fighting skill, and no weapon—would roll d12 + d20 + d20.

In unopposed situations, the judge could either pick a static difficulty number that must be rolled under. Alternatively, a die roll could determine the difficulty. You could even come up with three different aspects of difficulty each represented by its own die.

I like the roll-low for a step die system, although it creates a ceiling. I’m not sure that the more typical roll-high step die is really any different besides swapping the ceiling for a floor.