I love four-sided dice (which I will refer to from here on as d4s, in keeping with standard notation). I also love clean, simple dice mechanics in TTRPGs. Many of these use d6s, Fate uses d3s in the shape of d6s, some use only a percentile set or a single d20. I’m certainly not about to say that there aren’t any d4-based systems out there. But I have not encountered one on my own time, and my love of these pointy little bits has had me thinking about potential workings for a while now. And while I don’t have anything resembling a system here, I had some interesting thoughts and had my computer roll a few tens of millions of digital dice for me, and I’d like to lay out a few initial thoughts that may, some day, turn into something.

The TL;DR is this: players can, for any resolution1, roll two, three, or four d4s. If every die has the same value, regardless of what this value is, that counts as a special. Otherwise, the values are summed with 1s and 2s treated as negative (so, -1, -2, +3, +4). And that’s it, roll complete! What is a special, exactly? Well, I don’t really know. My initial thought was that the all-of-a-kind roll would be a critical success. After seeing the maths, and thinking about what I would opt to do in any given situation. Which led me to believe that the all-of-a-kind roll should certainly be special in some way, but likely a more interesting and dynamic way than just ‘you score very big’. This could be a trigger for something special on your character sheet related to whatever thing you are rolling for, or it could be a cue for the GM to pause the action and shift course. It should certainly always be something positive, but I don’t think the traditional crit mentality quite fits.

I’ll get into the numbers in more detail in a minute, but the key takeaways are:

Ignoring specials for a minute, we see a clear advantage to rolling more dice. Generally speaking, we will trend toward getting higher values, and the likeliest values for us to get on a given roll are better. When we factor in specials, rolling two dice becomes a lot more attractive; specials come up 25% of the time! Which is a very cool way to shift the balance, in my mind, but it’s also why it needs to be something other than just ‘BIG SMASH’. Make it too strong, and it basically becomes the universal choice. Making it more dynamic or narrative seems like a likely way to make the decision meaningful for players. Another possibility is a potential cooldown mechanic where rolling two specials in an encounter would force that character to cut out; that would likely leave the 3d4 option unused, however, as players would roll 2d4 until hitting a special, and then switch directly to 4d4.

I wrote a quick and dirty Lua3 script to let me roll a few tens of millions of virtual dice and run the numbers. The resultant percentage table is below. My initial script only returned the number of specials, positives, negatives, and zeroes. Upon seeing the steep declination toward 0% specials on rolls of more than 4 dice, I decided I was only going to do further testing on 2, 3, and 4. I’ve included the percentages of specials for 5, 6, 7, and 8 dice just to show the trend.

Result percentages in the Caltrops concept
# d4s 2 3 4 5 6 7 8
Special 25 6.3 1.6 0.4 0.1 0.025 0.006
-7 0 0 1.6
-6 0 0 2.3
-5 0 4.7 1.6
-4 0 4.7 0
-3 12.5 0 1.6
-2 0 0 6.3
-1 0 4.7 9.4
0 0 14.1 6.3
1 12.5 14.1 1.6
2 25 4.7 2.3
3 12.5 0 9.4
4 0 4.7 14.1
5 0 14.1 9.4
6 0 14.1 2.3
7 12.5 4.7 1.6
8 0 0 6.3
9 0 0 9.4
10 0 4.7 6.3
11 0 4.7 1.6
12 0 0 0
13 0 0 1.6
14 0 0 2.3
15 0 0 1.6

One final (for now) takeaway after having stared at these numbers in multiple forms. I mentioned the use of special instead of critical because of a traditional critical making a roll of 2d4s too powerful; you’ll get that hit 25% of the time. There’s another truth to 2d4 rolls, however, and that is that the chance of negative rolls is the lowest: 12.5% of 2d4 rolls are negative, 14.1% of 3d4 rolls are negative, and 22.8% of 4d4 rolls are negative. Every negative 2d4 roll is -3, however, and the chance of getting -3 or lower for 3d4 is 9.4% and for 4d4 is 7.1%. This raises a question as to what is a better motivator. You’re more likely to get a negative with more dice, and it’s possible to get a worse negative, but the trend is toward a better negative (the above numbers didn’t reflect zero; the likeliest non-positive result for 3d4 is, in fact, zero). It’s worth running through how this plays out and deciding whether negative values matter, or simply the fact that a negative was, in fact, rolled. My instinct says stay with values, but that doesn’t take into account the feeling of how the dice are treating you.

Clearly there are a lot of ‘what ifs’ to work through, and there’s a lot more involved in practical testing than just rolling millions and millions of dice. But I do think I’m on to something interesting here, something simple, but with slightly-less-than-simple decision determinations.

SVG d6

I’ve posted a few games-in-posts and other toys that involve rolls of dice, and my strategy is to use Unicode die-face symbols. I think, for the foreseeable future, this is how I will continue to handle such matters – it’s clean, compact, and rather portable. For whatever reason, I was wondering how best to achieve this in an SVG containing all of the pips, with the face selected via class and modified via CSS. So, below is an SVG die that contains seven pips, with its class set to .die1. But if we set it to .die2, it hides the (0-indexed, left to right, top to bottom) pips 1, 2, 3, 4, and 5. If we set it to .die4, it hides pips 2, 3, and 4. This works, of course, for .die3, .die5, and .die6 too, of course. Since pips 0 and 6 and pips 1 and 5 will always be (in)visible together, we can combine either set into a single class, .pip06, and .pip15 to simplify the .die classes that hide them.

Pros include the ability to customize dice (regular D6s and fudge dice, say, or simply multicolored pips), the potential to mix in other-sided dice, and likely superior accessibility. Cons are complexity and file-size (SVGs must be embedded into posts as SVG elements). The latter can be mitigated by generation of the SVGs from whatever JS would be running the show, but it’s still a bit clumsy. An interesting experiment, regardless of whether or not I ever use it.

Game-in-a-post: Rolling Market

Here it is! Game-in-a-post of ‘Rolling Market’, which I’m still pretty happy with, truth be told. Rules are here. This JS implementation has one bug I’m still aware of which lets you cheat during the endgame, so just… don’t do that until I fix it.

A few additional tips/thoughts on the game:

Rolling Market introduction & rules

I did end up implementing this as a game-in-a-post.

I’ve been testing out a little solo game design lately that’s somewhat inspired by Sackson’s Solitaire Dice. Inspired in the sense that I was looking to come up with something that has that same lack of Yahtzee-esque luck mitigation, instead relying on intuition, probabilities, and risk management. Much like Sackson’s game, this can backfire, and the dice can utterly screw you. But even when that happens, there’s enough going on to where the game is still enjoyable (in my humble opinion).

Full rules are listed after the jump, and will repeat some of this brief overview, but here’s the idea: players have four companies they can buy and sell stock shares from. On every turn, the player rolls dice which influence the current value of a given company’s shares. Buying and selling also affects values. On some turns, the market is closed, but when it is open the player can buy shares of one company and/or sell shares of a different company. The player goes through 12 of these buying/selling turns, and scores based on their final pile of cash.

I have a JS game-in-a-post implementation nearly ready to go, so that will appear shortly, along with a PDF of these rules, and potentially a few more strategic thoughts. Until then…

Game-in-a-post: Sid Sackson's Solitaire dice

Sid Sackson, in his book A Gamut of Games1, describes a solitaire dice game that I have grown very fond of. Fond enough that I decided to whip up a little js version of it, found below. I won’t go into the rules here, others have done that well enough. I will just put a couple of thoughts out there on why I find the game so compelling. Dice are obviously the epitome of randomness; roll-and-move mechanics are universally bemoaned for this. Games that try not to be awful while still using dice generally do so with some sort of randomness mitigation technique. Yahtzee is an easy example – a player gets three rolls to a turn to mitigate luck. Sackson’s Solitaire Dice does not offer any mitigation, and in fact it can be brutal. You could theoretically lose 400 points on your last turn. And while this sounds objectively terrible, it really isn’t. Occasionally you will have a game where the dice just torture you, but for the most part the game forces you to think about probabilities, and attempt to control pacing. If the game is going really well, you may want to try to blow one of your scratch piles up toward the game-ending 8 marks. Similarly, if things aren’t going great, it would probably be in your best interest to take poorly-scoring pairs in order to scratch dice evenly. In my plays thus far, I’d say that a meh game is in the -100-100 point range, a successful game being 350+.

Solo play: One Deck Dungeon

On to my number one solo game at the moment: Chris Cieslik’s One Deck Dungeon, released by Asmadi Games. This game takes all the uncertainty and the brutality of a roguelike, and packs it into a small deck of cards and a pile of dice. One’s character has attributes which indicate the number and color of dice that can be rolled in resolving a conflict. A section of dungeon, so to speak, is entered by spending time (discarding cards). This fills the player up to four face-down dungeon cards, which can then be encountered on a turn by flipping them up. One can either attempt to defeat the card or leave it for later, wasting time and available space to fill with new dungeon cards. Defeating these cards involves rolling the dice allowed by the player’s character attributes and placing them to beat numbers on the card. These can be color-specific or not, and spaces can either require the placement of one die or allow multiple dice. Unfilled slots are what ultimately cause damage – to either health, time, or both. Assuming the player lives, resolving a conflict allows them three choices – the card can be taken as an item (additional dice and/or health), a skill or potion, or experience.

Solo play: Deep Space D-6

My (probably, maybe) second most-played solo game currently is one of dice, cards, and worker placement. Designed by Tony Go and released by Tau Leader (in very small print runs, it seems, though one can print-and-play), Deep Space D-6 packs a lot of game into a very small package. One of several tiny boards with illustrated ships, explanations of their features, countdown tracks for hull and shield health, and placement areas for worker dice sits in front of the player. To the right of the players ship, tiny threat cards are added every turn, and positioned to indicate their health. The player rolls their crew dice for the turn and assigns them to various attack and defense roles. Worker actions are taken, then a die is rolled to see which, if any, enemies activate and attack on that turn.

Solo play: Intro and Dungeon Roll

As someone who is far more into board (and card) than video games, as someone who spends a lot of time alone, and as someone who has immense insomnia (compounded by the ridiculous anxiety brought on by recent politics), the volume and quality modern board/card games continues to impress me. While I know I’m not alone in seeking these out, I do think they get pushed to the side a bit, and I’ve been meaning to get a few write-ups out there about the games I’ve been enjoying as of late. Initially, I’m going to present this series as my current top five, but in the future I’ll be tacking others on in no particular order. With that…

First up is Dungeon Roll from Tasty Minstrel Games and designer Chris Darden. Its appeal is pretty clear: it’s cheap, has fun dice, and comes in a tiny cardboard chest that you pull treasure from during the game. They bill it as playing 1-4, but multiplayer is essentially just every individual playing a solo game while others watch. All of the encounters are based on dice, with no automatic rerolls (some character abilities grant rerolls), so it is very much a game of randomness and of pushing one’s luck. There are a handful of expansions out there (all bundled together in a cheap package at CoolStuff Inc., conveniently), which are largely just new player characters, though the winter one also adds some interesting new treasure.


I’ve been thinking a lot lately about new game concepts and designs using existing bits – dice, playing cards, checkers, &c. One such recurring thought is expanding on the Yahtzee sort of theme – solitaire dice-chucking games with poker-like scoring. It’s easy to pan Yahtzee as a garbage game, but as a quick solo activity it isn’t terrible. It isn’t great, but nor is it terrible. Over the past couple of weeks, I’ve been playing around with an idea for a dice game that offers a tiny bit extra in the decision-making category. I call it Yamzod, which is a name I came up with while on the brink of sleep, and have stuck with because it makes me laugh.

Game-in-a-post: Yz (or, on post-specific JS/CSS requirements in Hugo)

Finding the greatest Yahtzee score

A little over a year after writing this post, I decided to make a code golf challenge of it. Not too many people submitted answers, but there was a wild one in MS-DOS Batch, as well as some interesting tricks I hadn’t thought of.

I’ve been meaning to implement a way to incorporate style or script requirements into my posts using Hugo frontmatter. I’m not there yet, and before I get there, I need a test post that requires one or the other. I thought a little toy that lets one play a turn (three rolls) of Yahtzee, and then returns the highest possible score of the roll would be a fun and simple demonstration. Aside from small straights wigging me out a little (and I still have a nagging feeling this can be optimized), it was indeed simple1 to come up with an optimal score search. Fortunately, for a single-turn score, we don’t need to worry about a few scoring rules: bonus (joker) Yahtzees, the upper row bonus, nor chance. We could implement chance easily, but it really doesn’t make sense for single-turn scoring.