Learning to play a Mastermind Rogue

Last weekend, getting ready to move a few hours away, I had to say goodbye to my usual D&D group, and— by extension— my rogue.

Admittedly, I’d spent months regretting the build, a Mastermind-archetype Rogue in a room full of fighters, paladins, and rangers, but something about him had grown on me in the last few sessions. After it ended, I realised what it was: I finally learned how to play that class.

For a bit of background on it, the Mastermind is a new-ish archetype for the D&D 5th edition Rogue class, introduced in the “Xanathar’s Guide to Everything” addendum. Unlike the Assassin or Arcane Trickster archetypes, the Mastermind firmly places it’s flag in the “Cloak” part of “Cloak and Dagger”. At the start, they come with two abilities: use the “Help” action as a bonus action from up to 30 feet away, and accurately mimic the accents of anyone they’ve listened to for more than a minute.

For a lot of you reading this, you’ll think (as I did), “Wow! What an interesting and useful set of skills for a person in the world!” And in most cases you’d be right, except, I was playing with a table of combat-focused number crunchers. The rogue is not a particular combat-ready class in even the best circumstances (though if you can play a lawful evil assassin at any point in your life, I highly recommend it), and playing the Mastermind skewed my stats away from Strength and Dexterity enough that my usual effectiveness was, at its peak, nil. I was knocked out my very first session with this group, and only barely avoided death itself.

Despite my better judgment, though, I opted to stick with the character, and learned a thing that I hope will help you in your roguish endeavours:

Stop rolling the dice.

There, I said it. That’s the whole of my advice. Just, stop rolling. You can do it!

A thing I noticed after playing the Mastermind for a few sessions is that, unless you really want to lean towards combat or role-playing, you’re kind of just bad at both, numerically-speaking. Especially until you reach 6th level and start getting actually helpful rogue things, like Uncanny Dodge, or your second round of Expertise. If you’re rolling a new character and the table is already starting at level 3 or 4, you’re really buckling in for a few levels of bad rolls, especially if your party is just going around looking for a fight.

My particular rogue tried splitting the uprights between Dexterity and Charisma, and at level 6 had a +3 in each. Not horrible, but compared to the Dwarf fighter’s +5 Strength, my combat skills were lacking considerably. Rogues also get multiple attacks later than other classes, and typically have lower armour values, so if you miss that sneak attack, you’re pretty much always hosed the next round.

As a result of this, I decided to begin playing my own game within D&D, which was to see how long I could go before my character absolutely had to take a risk. I figured if I didn’t roll the dice, I wouldn’t have the chance to fail.

Weirdly, it kind of worked.

Rather than engaging in combat directly, I used the Mastermind’s help ability to grant my party advantage from a distance, while the rogue’s Cunning Action let me move and hide that same turn. From a safe distance I could “help” the combat along by firing a hand crossbow, but that only ever did minimal damage. The real damage would come from the paladin that I’d just given advantage to, and who consequently drew attention away from the hiding rogue (no matter how bad my stealth roll was).

Similarly, rather than engage directly in role-playing situations that might require single deception/persuasion rolls (for example, lying to the cult leaders about who we were and why we were there), I purposefully spent time performing smaller actions that could lead up to that interaction. Part of this, I learned, involved being the opposite of the typical rogue, and spending lots of money. “You have to spend money to earn money”, as they say. In my case, that money went towards forged identifications, hiring thieves to go do my work for me, purchasing a variety of nice clothing, joining a temple, and slowly falsifying documents for no less than three distinct personas whose reputation would precede them. It’s amazing how much a few gold can do for one’s reputation when placed in the right hands.

I’ve written previously about how spending money in D&D is sort of a non-issue past a certain point, so if nothing else I encourage you to spend it any way you can. Hirelings are a perfect straight-from-the-book example that I haven’t seen enough players take advantage of. Not to carry your things, but may to head to the next town over, and talk loudly about how someone matching your description has just slain a mighty beast.

The end result of all of this is that when it did come time for me to roll the dice, it was largely on my own terms. The prep work combined with a few rolls for insight or investigation would often grant advantage, and even when it didn’t (or I failed anyway), the information received would be enough to weigh my choices without crossing the line into meta-gaming.

I’ve read a lot of places now that the Mastermind rogue is basically the support class of rogues, and I feel like that’s largely true. But, in true rogue fashion, I encourage you to not thing about it in terms of supporting your party, but supporting yourself. Rather than leaping to action with the fighters and the sorcerers and those other impulsive classes, ask yourself:

What are the things that your character can do in the moment that A) Don’t involve rolling the dice, and B) when it comes time to roll the dice eventually, will give them the best shot at success?

Tyler
Making my own numbers stations

Creation

Last weekend, I got to run a game of Monster of the Week for some friends. It was the first time in a while, and knowing our luck it will probably be a while yet until the next one. Something in me decided to go big, and I found myself doing more preparation than I’ve done for any game in a very, very long time.

I made my own numbers stations.

You can listen to the bits I gave to the players here: link.

Setup

The audio was accompanied by an encoded journal, which I made a fumbled attempt at weathering, and handed to the group towards the start of the game.

IMG_0937.jpg

After playing an initial radio broadcast from my computer, I handed over an iPad with the page above loaded up, along with a pair of headphones, so that the players could browse and decode at their own pace.

The conceit being, of course, that something is sending out these cryptic radio signals, and the mysterious figure that dropped this notebook was somehow related.

Play

Luckily for me, play worked out pretty much how I anticipated: one player (the team’s hacker) assumed the role of the decoder, while the other players went around gathering clues. I used their rolls towards Investigate the Mystery and Read a Bad Situation feed back into clues about the code itself, which the players then relayed back to the person doing the decoding. The decoder then finished a page, relayed its contents to the rest of the group, and they used that information to inform where to go investigate next.

It all culminated in the party taking turns wielding a giant magical sword against a seven-headed alien child that had been manipulating catholic imagery for centuries, and narrowly avoiding an apocalypse-initiating explosion. So, you know, pretty typical stuff.

Building the thing

The stations operate under the idea that somewhere in the world (a notebook, in this case), you have at last one key and a variety of codes. The station reads off numbers that line up with a code, and when the number from the code is subtracted from the number from the station, you get a result that lines up to one of the keys.

In my game, I used four different keys, and had the station call out both the key and page number at the start of each transmission.

To quickly create the various keys, I wrote a bit of javascript that ran in my browser’s console (though you could easily improve on it aesthetically if you wanted):

const createCypher = () => {
  var cypher = [];
  while(cypher.length < 26){
    var c = Math.floor(Math.random()*100);
    if(cypher.indexOf(c) === -1){
      cypher.push(c);
    }
  }
  console.log(cypher);
}

I repeated that function until I had four arrays of 26 numbers, and plopped those into an object. I also made sure to have an array with each letter of the alphabet, like this:

const alphabet = ["A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"];
const cyphers = {
  'man': [4, 56, 82, 11, 0, 35, 85, 73, 14, 98, 80, 32, 43, 57, 21, 88, 78, 45, 19, 83, 66, 97, 89, 72, 12, 86],
  'lion': [62, 11, 40, 58, 78, 49, 21, 94, 87, 77, 96, 95, 7, 6, 27, 34, 83, 26, 5, 33, 72, 70, 91, 8, 42, 98],
  'calf': [97, 48, 86, 10, 53, 54, 65, 69, 80, 58, 23, 38, 71, 55, 24, 88, 79, 82, 12, 64, 34, 57, 8, 42, 41, 77],
  'eagle': [33, 32, 8, 79, 12, 45, 38, 64, 15, 39, 19, 89, 14, 58, 37, 18, 30, 24, 20, 91, 2, 53, 86, 98, 36, 28]
};

The array names correspond with the keys that I wrote into the physical book, they could really be anything (they don’t even have to be named, technically).

Finally, I wrote out each of the passages that I wanted to encode in all-caps strings, assigned a key to each string, and plugged them into this function to create the final ciphers:

const encodeText = (input, cypher) => {
  var cypher = cyphers[cypher];
  var input = input.replace(/[^\w]/g,'').toUpperCase().split('');
  var result = [];
  var code = [];
  var audio = [];
  for(var i = 0; i < input.length; i++){
    var p = alphabet.indexOf(input[i]);
    result.push(cypher[p]);
    var a = Math.floor(Math.random()*125);
    audio.push(a);
    var c = a - cypher[p];
    code.push(c);
  }
  console.log("Audio:",audio);
  console.log("Code:",code);
  console.log("Result:",result);
  console.log("Text:",input);
}

The final result here is that I have the text that goes to our audio, the code that I write into the notebook, the result of audio-code which should match up with the key that I entered, and the text, which is what I put in. I suppose, looking back at it now, I could have had this function double-check my work by subtracting each item in code from the corresponding item in audio, then grabbing the correct letter from alphabet according to the key, but alas. I was in a hurry.

Creating the stations

To create the audio, I dropped the “audio” variable into a TextEdit document, and used Apple’s Automator program to create a folder workflow, which takes incoming text files, and uses the “Text to Speech” feature to get an MP3 of a voice reading the numbers, along with my text stating the key and page number, four times.

I finished it off by dropping these into Audacity along with a downloaded clip of radio noise, and a vaguely creepy version of the Doxology. Well, it was vaguely creepy in context, anyway. You could recreate the voice on a PC by using the Narrator feature, and recording the output directly into Audacity.

I uploaded the files all at once to a page on this site, which you have a link to at the top of the page, and used a bit of CSS to hide the usual Squarespace header and links.

Future adjustments

In the end, I found it was a pretty effective, if labour-intensive, way to help tell the story I was trying to tell. If I were to do it again, I’d definitely use a different music sample (think something along the lines of Stranger Things 3), and I’d have someone do a live read of the numbers, rather than relying on the computer (which I felt read a bit fast).

Creating a Twitter clone with Zapier

One of the things that I struggle with personally is deciding exactly how “connected” I want to be in my day-to-day. Currently, I use social media like Twitter, Facebook, and Instagram, for two reasons:

  1. Posting weird Yu-Gi-Oh screen-caps for the podcast

  2. Keeping tabs on important family updates

As weird as I feel about freely giving Facebook any more of my data to sell, it’s also how I found out that my mom was getting remarried, so I feel a sort of obligation to keep it around. (This was a while ago now, and she at least called before the ceremony, so we’re all good.)

The thing is, I don’t want to be obligated to any one company when it comes to either of the above things. I would far and away prefer losing a bit of functionality, even paying a bit of actual money, for the comfort of knowing that what I say to my friends and family stays within that circle, and only gets sent elsewhere when I explicitly opt in. Even with GDPR and social platforms making renewed efforts to keep my data “safe”, I feel that there’s something to be said for knowing exactly where my information is kept. I want to be able to go and see the bytes, I guess.

This isn’t a new concept, and I’ve tried out projects like Mastodon, diaspora*, or even tilde.club to see if it was possible to create something that I could convince my friends and family to use, while satisfying my need to not give Zuck any more free labour.

The quick answer: I haven’t, yet.

But, I’ve made some interesting progress.

I recently started working for the automation platform Zapier (and please know that everything I’m saying here is completely my own personal view, does not reflect the views of the company, etc., etc.), and in playing around with the product, I realised that it gives access to two pretty powerful tools:

  1. The ability to send/receive webhooks

  2. The ability to update an RSS feed

The latter of the two I had already seen used in a number of articles regarding podcast hosting, which may be something I circle back around to. But I wanted to know if I could use these two things to build something like what I was picturing: A way to post “content” within a small group, and know exactly where my data is.

It has a few limitations, which I’ll cover briefly here and then maybe more extensively later on, but you can see the result here:

A couple big things:

  1. There’s literally no security on it, so don’t trust anything written there.

  2. Due to the limits in Zapier (because there had to be some limits), it can only handle 100 posts per month, and displays only the 50 latest posts.

While this definitely disqualifies the solution from wide release, it could be a viable solution for small groups. Because the RSS feed and all of the processing is hosted entirely by Zapier, and can be run using a free (free-as-in-free, not free-as-in-beer) Zapier account, there’s nothing saying that the “client” file couldn’t be kept offline. All you really need is the HTML/JS powering the form and displaying the RSS feed, and an internet connection.

There are still some tweaks to be made here and there, but in the vein of “here’s a weird internet thing I’ve made”, I felt it warranted sharing. From here, there are a few other projects I’d like to explore, given the time:

  • Internet-powered games played on phones or laptops in the same room (a-la Jackbox)

  • Free podcast hosting (as mentioned above)

  • Chatroom-esque spaces that only exist for a short time

  • Determining what an ad-free, user-run social network (that actually works — sorry, Ello) might look like

BlogTylerinternet, project, wip
An Update on my "Simplified D&D" 5e Hack

A while back I wrote (potentially too much) about the benefits of using a micro-RPG to “ramp up” new players into Dungeons & Dragons. After a bit more play-testing and chatting with other players, I’m happy to say that it’s worked out much better than I originally anticipated. There’s now an online character creator, and a moderately cleaned-up version of the PDF that I’ll call the “living document”:

The character creator doesn’t yet have a save function, partially because I wrote it on a plane, and partially because I just don’t know how. But! It did let us get from zero-to-roleplay in about five minutes, which is the intended effect.

Other notable changes include the advanced training section, the optional “combat intelligence” rule, and a bit of an introduction to the doc (which I may still go back and clean up or add to). To my knowledge, no one else has run the game using these rules yet, but just from personal experience, the Dungeon Master’s guide at the end still feels pretty good.

If you have friends or loved ones who want to play D&D but do not have the time or wherewithal, I hope you give this a shot!

TylerD&D
I got to be on "Party Of One"!

Some of you may remember a while back when I wrote up a custom Monster of the Week playbook for one of my favourite failed pilots: The Amazing Screw-On Head.

soh.jpg

A while back, Jeff Stormer invited me to come on his fantastic podcast “Party of One”, and use the playbook in a GM-less version of MotW, in which we tell the story of the epic team-up we’ve always wanted. This week, the episode is live for you to enjoy!

Tyler
Building "Monopoly" in Shortcuts - Update #1: The Beginning of Something Terrible

As it had been a few months since my last post on building un-productive things in iOS Shortcuts, I felt like it was time to get back in the game and build something new. I knew that I wanted to create a game of some sort, though I didn’t feel quite up to perfecting the roguelite engine that I had painstakingly laid out previously— largely because, let’s face it, it’s a pain in the ass.

What I settled on was that I should use Shortcuts to build a local multiplayer game; something that used the phone and the power of Shortcuts, but still relied on good old-fashioned human interaction. Examples like Spaceteam and the Exploding Kittens apps were two of the big inspirations. Rather than starting from scratch, I wanted to emulate an existing game that most people would at least sort of know the rules of, saving me the burden of explanation.

The result, I’m sorry to say, is that I’ve started building Monopoly in Shortcuts.

If you are reading this on an iOS device with Shortcuts installed, you can run the current version of the game using this link:

https://www.icloud.com/shortcuts/9b9c8b7103444aa2bd804561b88dac85

It’s important to note that the current version is just barely playable, and well below the minimum viable product for a Monopoly clone, but it’s been about a week since I’ve had time to work on it, so I wanted to share where it was at right now.

What it has:

  • Support for 2-6 local players

  • Emojis instead of token pieces

  • Full Monopoly board

  • Roll dice for movement

  • Purchase properties, stations, and utilities. Each space keeps track of its owner, so you can’t buy another player’s property.

  • Each player gets their own money to spend

  • Players get $200 each time they pass Go

  • All of the Chance and Community Chest cards from the U.S. version of the game

  • Income Tax/Luxury Tax spaces

What it does not yet have:

  • Rent payments

  • Bankruptcy Rules

  • The Community Chest cards don’t do anything yet

  • The Chance cards have minimal functionality, certain cards don’t do what they say they do

  • Landing in/getting out of Jail

  • Monopolies

  • Win conditions

  • An end state

What it will probably never have:

  • Trading

  • Houses/Hotels

  • Fun


Roughly How It Works:

Lists. I’ve used Lists for basically everything here.

The board is a list, where each item contains the space’s name, colour, purchase cost, rental cost, and owner, as an array separated by forward slashes (“/”). I use the slashes a lot here to spoof a two-dimensional array, so if I need a particular part of the space’s information (like the name), I grab the list variable, “get item in list” based on which item I need, “split text” by “/”, and “get item in list” to grab the specific item I need.

The players’ cash-on-hand, token, and board position are all separate lists, where the index matches the player’s spot in the turn order. When I need a bit of player info, I just grab the relevant list variable, and “get item in list” by the current player’s number (1 through 6). If I ever get around to figuring out monopolies, I’ll probably have a list to catalogue how many spaces of each colour each player owns.

Repeats. There are two sort of “core” repeat functions.

The big loop: After the more universal variables and lists have been set, I wrap the whole of the “gameplay” in one big loop, set to repeat an insane number of times. Because Shortcuts doesn’t give us custom functions or “loop forever” support, I get around this by taking a number function, and mashing the 9 key until my thumb gets tired (there is a max value for the number, but it’s something like 1^10*25). Passing this value to the repeat lets it loop until the heat death of the universe, or at least until someone accidentally hits “cancel”. This means that the game won’t end after the first round.

The turn loop: Immediately inside the #BigLoop is another repeat function that loops a number of times equal to the number of players (which is the first question asked of the user). This benefits us in two ways:

  1. When all of the players have taken a turn, we can perform “end of round” actions, like ranking charts or special events.

  2. “Repeat Index 2” == the current player, so we have an easy way of finding the information pertinent to the person whose turn it is, and no one else.

Even smaller loops: There are a few places where I need to update a player’s information inside of one of the lists. Because Shortcut’s doesn’t really let us update items in the middle of lists, we use short loops to achieve this. Each one looks roughly like this:

  • Define which list we’re updating data in

  • Repeat for “number of players”

    • If “repeat index 3” (because we’re in the big and turn loops) equals “current player”

      • Get whatever relevant variable

      • Add it to a temporary variable

    • Otherwise

      • Get item from the list we’re updating, at the “repeat index 3” index

      • Add it to a temporary variable

    • End if

  • End repeat

  • Get that temporary variable

  • Split text by new lines

  • Set variable so that it overrides the original list

It’s a bulkier workaround than I would like, however it lets us reliably update things as needed. We used this to update the player’s money and positions at the end of each turn, plus it’s how we handle payments in the middle of each turn.


Next steps:

  1. Add in paying rent to a player when you land on a space they own. (I know how I want to do this, I just need to make the time for it.)

  2. Add alerts and rules for bankruptcy.

  3. Add an endgame event, and win conditions.

I genuinely don’t know if I want to bother adding houses/hotels. I might rather adjust the dollar values and some minor rules to make this more of a “Speed Monopoly” so that it’s more tenable for a mobile experience.

I would add “make it fun” as a next step here, but, come on. It’s Monopoly.

TylerShortcuts
Using a micro-RPG to "ramp up" new players into D&D

TL;DR: I wrote a simplified version of D&D that evokes the feel of the game, without the nitty-gritty. It’s great for new or hesitant players, gets up and running in five minutes, and is free to download here:

Choosing whether or not to play Dungeons & Dragons in 2018 (soon to be 2019) is an interesting dilemma. Independent games are on the rise across the Internet and local game stores, and offer fresh, exciting, and arguably more “fun” takes on the tabletop role-playing game genre. Meanwhile, despite several attempts to streamline Dungeons & Dragons for new audiences, the game requires books with hundreds of pages, and a minimum investment of $180 USD for a new group to get started. Not to mention the hours on hours of reading, explaining, and re-reading those rules to get started. For many groups, the first session of D&D involves one player walking the rest through character creation for three or four hours, while trying their best to convince them that it will be more fun once they actually start playing. The current creative director of the D&D franchise has even gone on record on Twitter stating that the Dungeon Master (the player who “runs” the game by putting forth obstacles and playing many of the characters in the shared imaginary world) shouldn’t have fun while playing the game.

And yet, we continue to want to play Dungeons & Dragons.

For those of us who played through the days of Satanic Panic (which I was fortunate enough to only see the tail-end of, and is high on my list of “Things to Write About” in 2019), continuing to play D&D might be a show of loyalty. Many, in more ways that one, have earned the right to continue playing the game that has been accused of summoning demons (or worse), and don’t want to let those days go to waste.

It’s also a matter of investment. While packing up to move to the UK, I realized that I had conservatively $800 worth of Dungeons & Dragons material, which now sits in a storage space back in Oregon. This is a low number for a lot of people, too, as I’m not including many of the 3.5e books that were given away (or ruined), and I didn’t buy anything for 4th edition. Lauren and I have collectively spent something like $400 on 5th edition alone, just for the core rules and a selection of campaign reference books. This also doesn’t count the time and emotional investment that goes into preparing for Dungeons & Dragons, especially if you are creating any content (adventures, maps, character races or classes) for yourself. The homebrew community for Dungeons & Dragons represents its own kind of investment in the hobby, and transmogrify it from the game that you read about on the back of the box, into something else entirely. For players who have invested anything above and beyond the norm, be it financial or otherwise, continuing to play D&D reflects a sort of “making good” on those payments.

Lastly, thanks to its years of market domination, media references (like some great episodes of Community), and the recent rise in “actual play” podcast and live streams, Dungeons & Dragons is what new players have actually heard of. Unless they’re already in the role-playing game community in some way, it’s likely that most people will know the Dungeons & Dragons brand, and not much else. For the most part, new players don’t ask, “How do I get into role-playing games?” Instead, they’ll express interest specifically in “learning Dungeons & Dragons”, because so far as they know that’s the only game in the genre. And, to me at least, it feels disingenuous to give them anything else.

The trouble for me is that, when it comes right down to it, I’m not sure that I want to be playing D&D over other games these days. I also worry that new players will be repelled by the text, or the hours of character creation, or the maths that may not come easily to everyone. It’s a big ask to get someone who has never played a TTRPG before to come in and play “real” D&D in their precious free time. At the same time, I don’t want to be the person keeping new players from that experience, if it turns out that is what they want. I also don’t want to disregard the legacy of D&D, and its importance in the larger games space. The real trouble, then, is finding an easy way to bring new players into the world of Dungeons & Dragons that gives them a real idea of what the game is like and do it fast enough that they feel like they’re actually playing a game. If they leave the table not knowing what D&D is, or like they spent the whole time solving some word problem, then I’ve failed them.

In past games, introducing new players to the game has looked like doing the majority of the prep work for them. Lauren and I will typically roll up new character sheets, or print the pre-made sheets from the WOTC website (the existence of which prove the necessity of what I’m talking about), and present the new players with a selection between two or three options, rather than twenty-plus. We then attempt to introduce the rules of the game to the players as we play, so that they don’t have to stress about reading or prep beforehand, and can leap more-or-less directly into the game. While this meets the “actually play the game” criteria, it fails in a couple of important respects:

First, part of the experience of playing Dungeons & Dragons is making your character in a tangible, hands-on way. The mechanics of rolling for stats, selecting race and class, and debating the various pros and cons of equipment choices helps the player build a more concrete understanding of who their character is, and how they operate in the fictional world.

Second, while teaching rules as they come up keeps the paperwork at a minimum, we’ve seen it limit the options that players feel they have at the table. While the rule of thumb given to them is always, “Just say whatever you feel like your character would do,” many players don’t assume that anything is an option, unless a word on their character sheet prompts them. For some classes, such as Paladin or Barbarian, this isn’t an issue, as most everything the character would do is there in the text. For other classes, such as any of the spellcasters, the choices aren’t so clear. When the choices are unclear, often new players will default to inaction.

When friends approached us recently with a desire to learn how to play D&D, the opportunity presented itself to try and resolve these two issues. Once we had figured out schedules, it would be myself as the DM, along with Lauren (who’s been playing for as long as I have), two people who had never played, and a fourth who had played before, but felt that they “weren’t good” at D&D, and were a little hesitant to get back into it.

This became the brief: develop an experience that would show new players what D&D felt like, a player who had less than ideal past experiences that the point isn’t to “be good” at D&D, and still be entertaining and interesting for an experienced player. You can download the finished product here:

While I initially only wanted to create a simplified character sheet, the end result here is a sort of micro-RPG that uses the terminology of D&D, gives off the feel of D&D, but relieves the pain points of getting a new player into the game.

Character creation is done by selecting one “look”, and “training”, which replace race and class. The names give a better idea of what they mean for the character, and each come with a selection of what the character is “great”, “good”, or “bad” at. This gives a new player a one-line synopsis of what they’re getting themselves into with their selection. They also pick two pieces of equipment that are more-or-less exact replicas of their D&D 5e counterparts— they do the same damage and damage types, though we’ve gotten rid of cost or weight, for sake of simplicity. Finally, they select between “Great”, “Good”, “Okay”, or “Bad” for each of the classic D&D attributes (one great, two good, two okay, one bad).

Notice that we’ve completely gotten rid of numbers in our attributes. I’ll be honest, this is 75% because I’m tired of explaining the difference between attribute numbers and modifiers. The other 25% is because this let me right an explanation of what to roll right there on the sheet: if your attribute or skill is “great”, you roll three times, and use the highest result. If it’s “good”, roll twice and use the highest. “Okay”, roll the once and take what you get. Lastly, if it’s “bad”, roll twice and take the lowest.

Those with experience in D&D 5th edition will recognize this as a modified take on the advantage/disadvantage system. What it allows us to do is keep challenge difficulties the same, monster AC the same, and players are given agency in determining how likely they are to accomplish certain actions. I’ve also listed the relevant skills underneath each attribute, which (at least in play-testing) helps alleviate the issue where players don’t know what actions to attempt.

Spellcasting has had a revision since the last test, as initially it had a more PbtA-style fluid vibe. Originally, you could choose what effect you wanted the magic to have, and that would affect the roll’s difficulty. In this version, I’ve created a pared-down spell list, with basic instructions for casting each spell. This further helps give players the “feeling” of playing D&D by bringing in classic spell names, the proper spell terminology (like “saving throws” and “spell slots”), and at least a bit of distinction between different kinds of training.

Finally, the advancement table is listed directly on the character sheet. The rolling system lets us keep all of the same difficulty classes, so we can keep the same XP goals for each level, which helps DMs a bit. Because all of the classes are on the same sheet, the advancement is an approximation of what all classes have in common. At level 3, they may select another training to act as the “specialization” offered by traditional D&D classes, At level 4, they can improve an attribute (maybe someday I’ll feel like writing up a list of feats to choose from instead), and at level 5 they gain an extra attack. While this isn’t 100% accurate for all classes, it provides a close enough representation of what it feels like to advance to level 5. By that point, hopefully the player has a good enough idea of whether they want to play “real D&D” or move on to something else.

So far, this has been pretty successful, especially with new or hesitant players. Character creation is typically done in about five minutes, and we’re able to play fairly intricate one-offs, with the players driving a lot of the action (which is fun for me as a DM). I’ve used monsters straight out of the book with minor editing, and the “feel” of play is very similar to real D&D on both sides of the screen. Up next, the goal is to use these sheets along with official campaign books, editing as little as possible from the text. Something like “Dragon Heist” should play quite well, though if I have players who are into the idea, I may try for “Curse of Strahd” to see how it translates.

Games, HacksTylerD&D
Working with Save States in iOS Shortcuts games

While experimenting with the text adventure frameworks outlined in a previous post, I became frustrated with having to start from scratch each time I re-loaded the shortcut. For shorter games, this isn’t an issue, but it prevents us from making longer experiences attractive to players. It’s not much fun to play an epic space opera adventure if you have to do it all in one sitting. So, I began playing around with the idea of implementing basic save states in a text adventure game.

To start, I made a basic layout according to the MUD-style format I outlined here: Text Adventures in iOS Shortcuts

You can download the example here:

Utilizing the “Get File” and “Save File” features, I allow the shortcut to save and receive information from iCloud Drive. In this example, I use this to create a text file with the following information:

  1. Player Class

  2. Player Position

  3. Player Inventory

  4. Amount of Gold the player has

I also put the words “Save Data” right at the top. This lets me load data using this process:

  1. Get File “filename” from iCloud Drive

  2. If file contains “Save Data”

  3. Get Text from Input

  4. Split Text by New Lines

  5. Get each item, and assign it to the proper variable.

We want to use the “Save Data” text check to verify that there is even a save file there to begin with. Otherwise, we only allow the player to start a new game. All of this is done before the main Repeat function of the game takes place, so that if we are loading a game, the player begins right where they left off. Since the loop does not particularly care where we start, no extra steps are necessary within the loop for differentiating between new or saved games.

To save the game’s progress, all you have to do is create a new Text element with the variables you want to save, in their proper order. Then pass this to the Save File function, being sure to check the “Overwrite if already exists” option. I hid this option within a couple of menus, to allow the player to start a new game and save over the previous one, but you could feasibly add the Save File function to the end of the Repeat, so that the game auto-saves after each action the player takes. It’s up to how you want things to play out.

Additionally, you’ll notice that I created a “Filename” element, and un-checked the option to “Show file selector” in both the Get File and Save File functions. This was largely an aesthetic choice for me, as I don’t much enjoy the file picker. This also allows us to ensure that the correct file is saved and loaded each time, preventing any potential errors. If you would rather let the player pick where they save/load from, just enable that option.

TylerShortcuts
Building a Roguelike in iOS Shortcuts

Diverging off of my last post about using iOS Shortcuts, an app built with the intention of productivity, for purely useless reasons, I’m going to go into detail on another one of my ill-conceived Shortcuts-in-progress: Roguemoji.

Link: https://www.icloud.com/shortcuts/a8b49fe817ed43f4b20b78322b2d8d07

With a bit of elbow grease and repetition, Shortcuts actually allows us to build a fairly plausible roguelike game, complete with random maps and items that we can pick up. No monsters yet, that’s on the way.

How it works

At its core, the roguelike “loop” reads very similarly to the text adventure outlined in the previous post: Find the player’s current position, draw the surroundings accordingly, allow the user to change position, repeat. What it does differently is incorporate graphics into the equation, allowing us to visualize a maze (dungeon,. labyrinth, what-have-you) around the player character, rather than relying on just text. Even though it may be more accurate to tradition to use ASCII characters, the iPhone gives us plenty of emoji to play with, so we’ll use them.

As with the text adventure, we start by defining all of our required variables outside of the main “loop”. Most importantly, we’ll need to know what our Map looks like, what our player’s Position is, and since we’re bringing graphics into this, we’ll define a Camera element, as well. The idea here being that we don’t want to show the entire map at once, and show instead a small part of it, centered around the player.

To define the Map, I recommend using the Text function, and drawing in a map of your liking using the Black Square emoji for walls, and the White Square emoji for walk-able floor tiles. The map should be a rectangle of any width/height you prefer, though I recommend keeping the width to something like 12 or 13 characters, as I found that gave me the best legibility while working in the app. Then, use the Set Variable function to save the Text as a variable that we can call up later.

Note: You’ll notice that in the example provided, I used a variety of different Text functions, and assigned them to a list. This allowed me to pseudo-randomly generate a map, which works well enough most of the time. Procedural map-building is a hallmark of the roguelike genre, but not yet a strength of mine, so this will be something we revisit later on. For the time being, feel free to use a single, static Text command to make your Map.

For example purposes, let’s say that we have a map that is 12 emoji wide, with a good spot for the player to start off in at 3 spaces in, and three lines from the top. Our first bit of the Shortcut should then look something like this:

Text: [Map of emoji blocks here]

Set Variable: Map

Number: 12

Set Variable: Map Width

Number: 3

Set Variable: Player X

Set Variable: Player Y

Notice that we’re using two separate variables for X and Y. Since our emoji map exists in a Text function, we can manipulate it into letting us use the two-dimensional arrays that our text adventure lacked. We’ll come back to that, though. Next, let’s look at the camera.

Because there’s only so much space on the phone screen, we don’t want to show the whole Map all at once. Instead, we want to show the player just a segment of it, centered on the player character. This should have enough information of the player character’s surroundings to be useful, but not so much that it becomes cumbersome or difficult for the program to load. After some experimenting, I settled for showing the player a 5-by-5 square, with the character positioned in the camera’s center as often as possible. To achieve this, we first set the Camera’s beginning X and Y positions by subtracting from the player position:

Number: 3

Set Variable: Player X

Set Variable: Player Y

Calculate: Subtract 3

Set Variable: Camera X

Set Variable: Camera Y

Number: 5

Set Variable: Camera Width

Set Variable: Camera Height

Using this, when the Player is at X,Y {3,3}, for instance, the Camera will be at {0,0}, showing us the first 5 characters of the first 5 rows of the Map. If this doesn’t make sense just yet, keep going, and play around with it later. You could also replace the “3” in the Calculate command with a variable that you can easily change later on, so that you can find a balance that you prefer.

Disclaimer: I’m sure you’ve already noticed something about Shortcuts: it takes a while to do literally anything. It certainly isn’t as efficient as programming this sort of thing in C++, Java, Bash, Python, or whatever. Hell, you could probably do this faster in BASIC if you wanted. Shortcuts does not equal programming. This is just how my brain works: taking something that is clearly intended for being useful, and making dumb games with it. Savvy? Okay, moving on.

The Camera

Now that we’ve done all of our setup for the Player and Camera positions, we have to turn that into something that actually does something, right? We’ll do this by returning to the “Nigh-Infinite Repeat” trick that we used for the text adventure in my previous post, which starts like this:

Number: 99999999999999999999999999999

Repeat: [Number] times

We’ll place that at the bottom of the program, under our setup functions, and put our gameplay “loop” inside. For starters, let’s go ahead and figure out what the Camera sees of the Map. I’ll write out what the functions look like first, then explain it line-for-line after. Feel free to also consult the example I provided for a less-than-perfect reference as you go.

Get Variable: Camera Height

Get Variable: Camera Width

Repeat: [Camera Height] times

Get Variable: Camera Y

Calculate: Add [Repeat Index 2]

Set Variable: Row To Get

Get Variable: Map

Split Text: New Lines

Get Item From List: Item at Index [Row To Get]

Set Variable: Current Row

Repeat: [Camera Width] times

Get Variable: Camera X

Calculate: Add [Repeat Index 3]

Set Variable: Character To Get

Get Variable: Current Row

Split Text: Every Character

Get Item From List: Item at Index [Character To Get]

Set Variable: Current Item

Get Variable: Character To Get

If: Equals [Player X]

Get Variable: Row To Get

If: Equals [Player Y]

Text: [Whatever emoji you want to represent your character]

Set Variable: Current Item

End If

End If

Get Variable: Current Item

Add To Variable: Row To Draw

End Repeat

Get Variable: Row To Draw

Split Text: New Lines

Combine Text: Custom [Leave blank]

Add To Variable: What The Camera Sees

Nothing

Set Variable: Row To Draw

End Repeat

Text: [What The Camera Sees]

Alright, wow! That was a lot. It looks like a lot. It is a lot.

But!

That is the core of what we’re doing here today. Everything else is secondary to this, and it’s not that hard once we break it down. Let’s do that now:

First, we’re going to put two more Repeat functions into our big Repeat function (yo dawg, etc., etc.). This is how we create the “square” of what our camera sees: the first Repeat looks at five rows, starting at Camera Y then adding the Repeat Index 2 each time to move to the next row down. Notice that it’s Repeat Index 2, because Repeat Index would correspond to our “master” repeat, and be no use at all. The second Repeat then takes whatever row we’re looking at, and breaks it up into individual characters. From there, we grab the Camera X value, and add Repeat Index 3 to find the individual character that we’re looking to draw.

If the result of Camera X plus Repeat Index 3 matches Player X, and If Camera Y plus Repeat Index 2 matches Player Y, that’s where the character is! Let’s draw that emoji instead of whatever’s on the map.

Whether we’re drawing the Player character or whatever’s at that place on the map, we’re going to Add To Variable to add it to our “Row To Draw”. If you’re playing around with the Add To Variable function, you’ll see pretty quickly that it adds whatever’s passed to it into a new line in the variable. While this would be fine if our map was one character wide and an infinite number of characters long, it doesn’t suit our two-dimensional look. That’s why, after we’ve gone through all of the steps in the second Repeat function (getting the characters out of the row), we Split Text on the “Row To Draw” variable, then immediately Combine Text. Combine Text allows us to combine a List (which is what Split Text gives us) using a Custom value, which we’re just going to leave blank. That takes our vertical column, and returns it as a horizontal row of the proper characters. We then Add To Variable again, adding this nice horizontal row to “What The Camera Sees”.

Before looping back around and going to the next row, let’s use the Nothing function to set the “Row to Draw” variable back to nil. Otherwise, we’ll just keep adding to that variable, and things will get real weird.

Once we have all of the rows that the Camera sees, we’ll use Text to neatly wrap them all up, and if you’re feeling intrepid, you can use Quick Look to check your work.

A Few Notes Before Braving Forth

So far, we’ve done a handful of things:

  1. Trick Shortcuts into letting us use Text as two-dimensional arrays

  2. Used those arrays to display only a small part of the overall map

  3. Separated our camera from our player

The first two things are essential parts of bringing the roguelike genre to this format; if we showed the player the whole map at once, that would not only ruin some of the surprise element, but also not fit on the most mobile device screens (although the iPhone XS is massive so, like, who knows).

The third thing is a simple one, probably, but one that I’m really proud of. That’s because it’s a fundamental element of making games that are set in the third-person (where you see your player character on the screen): the Camera object and the Player object are two separate entities, and can be moved independently. This means that as the Player character approaches the edges of the map, we can have them move all the way up to that edge, without the Camera trying to show the “great beyond” that doesn’t exist.

As an example of this in our roguelike game, imagine that the player wants to move to a space at Row 1, Column 1 (Shortcuts only uses 1-indexed arrays, so there’s no real 0,0). Using what we’ve set up so far, once the player moves to that space, placing them in the middle of what the Camera is showing would first require pulling two empty rows, then two empty characters, before showing the player. You would be using only about a quarter of the space we set up for our Camera to display on, and risk errors or funky display issues.

Using what we’ve set up now, we can let the Player move all the way to that corner, and simultaneously make sure that the Camera doesn’t go past that point. The player would temporarily move out of the Camera’s center while they explore those edges, but come safely back to center once they turn back and explore the rest of the map. It’s a small thing when you put it into words, but speaks volumes for the quality of the final product.

Okay, coming down off my soap box. Now that we’ve set up the base variables, and our loop for using the camera to the player and the map, let’s set up the interface for actually playing the game.

Actually playing the game

If you’ll remember from our previous Text Adventure example, the main cruft of the game revolved around using the Choose From Menu function in a loop, wherein the choices adjusted the Player’s X and Y positions. Here, we’re going to do roughly the same thing, with some extra If functions to keep our Player and Camera in line, and from going off the map. Let’s start with dropping in the Choose From Menu, which we’ll place after the Text function we used at the end of the last section, and before the End Repeat at the end of the function (we want this to take place within our main loop).

Text: [What The Camera Sees]

Choose From Menu: [What The Camera Sees]

Up

Down

Left

Right

End Menu

Nothing

Set Variable: What The Camera Sees

End Repeat

Pretty basic so far. We display “What The Camera Sees”, then ask the player to choose from the four cardinal directions. If you wanted to get more fancy, you could add more things to the Text function (health, inventory, etc.) and use that in the menu instead, or add diagonal directions for a fun isometric feel. For now, we’ll keep things as simple as we can, probably.

We also pass Nothing back to the “What The Camera Sees” variable, so that we don’t just keep adding to it with each repeat.

Within each of the four options (which you’re welcome to rearrange or rename as you like, I ended up using emoji), we’re going to add If statements to make sure that there’s space that direction, then update the Player and Camera positions as needed. Because these get pretty big, pretty fast, I’ll take a look at each direction separately, then we can look at the Menu as a whole. Let’s start with the easiest one:

Up

Get Variable: Player Y

If: Is Greater Than 1

Calculate: Subtract 1

Set Variable: Player Y

Get Variable: Camera Y

If: Is Greater Than 1

Calculate: Subtract 1

Set Variable: Camera Y

End If

End If

We’ll start with the obvious: If the Player’s Y value is greater than 1 (I keep having to remind myself that Shortcuts uses arrays that start at 1), then we subtract 1 from that value, and assign the result back to Player Y.

If the Player changed positions, we’ll also check to see If the Camera has space to move, as well. We do this in the exact same way: If Camera Y is greater than 1, we subtract one from that value, and return it to Camera Y.

Challenge: We can apply that same basic function to the Left option in our Menu, but trading in Player X and Camera X for Player Y and Camera Y. Give it a shot!

We’ll now tackle the more complex movements:

Down

Get Variable: Map

Count: New Lines

Set Variable: Map Height

Get Variable: Player Y

If: Is Less Than [Map Height]

Calculate: Add 1

Set Variable: Player Y

Get Variable: Camera Y

Calculate: Add [Camera Height]

If: Is Less Than [Map Height]

Get Variable: Camera Y

Calculate: Add 1

Set Variable: Camera Y

End If

End If

At lot of the same notes as the other direction, but with some important additions. First, unlike the “Map Width” variable, we didn’t set a variable for getting the Map’s height, so we use Count to get the number of lines in “Map”, representing the number of rows we have to work with. You could do this right up top with Map Width, I supposed, but calling the action here allows us a degree of dynamism (Is that the right word? Probably not.) and gives us the opportunity to change the height of the Map between actions (secret rooms!).

Second, we grab Camera Y and Calculate where the bottom of the frame is, by adding the “Camera Height” variable that we set a forever ago. This way, we are actually checking to see if the bottom of the camera’s viewport is going to go off the edge of the map, then adjust the Camera Y value if it is not.

Challenge: This same concept can be applied to the Right option in our Menu, using Map With, Player X, and Camera X. Can you figure it out before we put everything together?

Putting Everything Together

By now, we have something resembling the structure of a basic, top-down game, with the potential for roguelike elements. Moving into those specific elements will complicate what we’ve done today, at least in my own brain, so I’m going to compile an overview of what we’ve done here, then go into more depth in my next post. If you have questions or comments, let me know! I’m positive I fucked something up somewhere, so don’t be shy.

If you’ve been following along, here’s likely what you have so far in your Shortcut:

Text: [Map of emoji blocks here]

Set Variable: Map

Number: 12

Set Variable: Map Width

Number: 3

Set Variable: Player X

Set Variable: Player Y

Calculate: Subtract 3

Set Variable: Camera X

Set Variable: Camera Y

Number: 5

Set Variable: Camera Width

Set Variable: Camera Height

Number: 99999999999999999999999999999

Repeat: [Number] times

Get Variable: Camera Height

Get Variable: Camera Width

Repeat: [Camera Height] times

Get Variable: Camera Y

Calculate: Add [Repeat Index 2]

Set Variable: Row To Get

Get Variable: Map

Split Text: New Lines

Get Item From List: Item at Index [Row To Get]

Set Variable: Current Row

Repeat: [Camera Width] times

Get Variable: Camera X

Calculate: Add [Repeat Index 3]

Set Variable: Character To Get

Get Variable: Current Row

Split Text: Every Character

Get Item From List: Item at Index [Character To Get]

Set Variable: Current Item

Get Variable: Character To Get

If: Equals [Player X]

Get Variable: Row To Get

If: Equals [Player Y]

Text: [Whatever emoji you want to represent your character]

Set Variable: Current Item

End If

End If

Get Variable: Current Item

Add To Variable: Row To Draw

End Repeat

Get Variable: Row To Draw

Split Text: New Lines

Combine Text: Custom [Leave blank]

Add To Variable: What The Camera Sees

Nothing

Set Variable: Row To Draw

End Repeat

Text: [What The Camera Sees]

Choose From Menu: [What The Camera Sees]

Up

Get Variable: Player Y

If: Is Greater Than 1

Calculate: Subtract 1

Set Variable: Player Y

Get Variable: Camera Y

If: Is Greater Than 1

Calculate: Subtract 1

Set Variable: Camera Y

End If

End If

Down

Get Variable: Map

Count: New Lines

Set Variable: Map Height

Get Variable: Player Y

If: Is Less Than [Map Height]

Calculate: Add 1

Set Variable: Player Y

Get Variable: Camera Y

Calculate: Add [Camera Height]

If: Is Less Than [Map Height]

Get Variable: Camera Y

Calculate: Add 1

Set Variable: Camera Y

End If

End If

Left

Get Variable: Player X

If: Is Greater Than 1

Calculate: Subtract 1

Set Variable: Player X

Get Variable: Camera X

If: Is Greater Than 1

Calculate: Subtract 1

Set Variable: Camera X

End If

End If

Right

Get Variable: Map Width

Get Variable: Player X

If: Is Less Than [Map Width]

Calculate: Add 1

Set Variable: Player X

Get Variable: Camera X

Calculate: Add [Camera Width]

If: Is Less Than [Map Width]

Get Variable: Camera X

Calculate: Add 1

Set Variable: Camera X

End If

End If

End Menu

Nothing

Set Variable: What The Camera Sees

End Repeat

At the end of it all, we have a map built from emoji, a camera that displays only part of that map, a player character right in the middle, and a way to move them around. That leaves us with a certain set of new challenges!

  1. At the start, I mentioned that I used White Square and Black Square emoji for drawing our map. How do we keep the player character from passing through Black Squares? (I did this in the example, check it out.)

  2. How would we go about creating random maps?

  3. How do we handle item interactions?

  4. Can we add random enemies to the map, with their own discrete movement and actions?

I’ve tried my hand at the first three items, and will be tackling the last one soon. In the next post, we’ll go into detail about some potential ways to make this happen, and try it out ourselves.

GamesTylerShortcuts
Text Adventures in iOS Shortcuts

Like a lot of people, I was aware of Workflow as an iOS app that seemed to be a slightly more robust version of IFTTT, but didn’t see an immediate use for it until iOS 12 was released, and the app was re-branded as Apple’s official Shortcuts app.

Only problem was, by that time, I had very little left in my life that I really cared to automate. Something about being sad and unemployed? I don’t know, it sounds vaguely familiar. Anyway.

For Android users, or at least people who don’t care, Shortcuts is a tool that allows you to use a drag-and-drop programming interface to put a limited amount of functions together. The end result of this being a new app, which harnesses the power of other apps on your phone. This can range from things like, polling the Weather app to see whether you will need an umbrella today, and giving you a push notification letting you know when and where the rain will fall. Or, for the smart-homed, curating intricately-choreographed “scenes” far beyond what the Home app is capable of; perhaps texting your entire home an emoji, and watching as the lights, temperature, entertainment center, and coffee machine all work in unison to fit a certain mood.

You could also, if you’re a true Portlander and are so inclined, use it to brag about how many coffee shops are within walking distance.

Though the new tool, with the ability to run programs that brought apps together using Siri, Home Screen buttons, or even the Widgets panel, was designed for those with a will to capital-O Optimize their everyday life, I saw in it a very different potential.

This started with the discovery of Space Alert, a “crappy text adventure” that takes advantage of the branching “Choose from Menu” function. While it’s a short game all told, it proffered a revelation: While the functions provided within are small, they contain all of the necessary elements of a variety of text and turn-based games. And so I set to work.

What unfolded over the last month has been an exploration, of sorts, into the practicalities of building games within a program that is all but explicitly not decided for making games in. Many of them are still a work-in-progress, but it’s proving to be a deeper well of experimentation than I anticipated. Below are two of the methods that I’ve been exploring, with some detailed reference for trying it out yourself.

If neither of them interest you, I’ve also figured out how to make a roguelike with Shortcuts, but that’s… a much longer post. Stay tuned.


Choose-Your-Own-Adventure

Starting with the example set forth from Space Alert, you can use a combination of the Show Alert and Choose from Menu functions to create a narrative with branching paths. Because of the visual nature of the Shortcuts interface, the results of a choice get “nested” inside the choice in the code, so it may be wise to create “routes” that diverge based on choice, then eventually come back together.

Roughly, that looks like this:

Show Alert: “Hello! Welcome to the game. You are in a room with two doors.”

Choose From Menu: “Do you want to go Left, or Right?”

Left

Show Alert: “You have chosen the left path.”

Right

Show Alert: “You have chosen the right path.”

Show Alert “You win!”

Reading that back, you’ll first see an alert saying “Hello! Welcome to the game. You are in a room with two doors.” You will then be presented a menu, allowing you to choose left or right, resulting in the respective alert shown. Then, regardless of choice, you’ll be shown the alert “You win!”

Of course, this can get more complicated as you go deeper and deeper into the branches. You can place a “Choose From Menu” inside a “Choose From Menu”, for example, or even list the result of a previous choice as an option for a new menu to list. Space Alert does a great example showing this off, so I won’t try to provide my own reference outside of that.


MUD-Style Text Adventure

Example: Simple Text Adventure Framework

One of my earliest and most important memories of playing videogames with my dad involves playing my first “MUD”, or “Multi-User Dungeon". A precursor to MMOs and MMORPGs, a MUD allowed a bunch of users to connect to the same server, and play a simple text adventure game together. Typically, this would follow a stereotypical ZORK-like pattern: “You are in a very dark room. You are likely to be eaten by a grue. Exits are NORTH, SOUTH, and WEST.”

You would then have to type commands like, “go NORTH”, or, “attack GRUE” and see how the world responded.

The reason this particular memory stuck with me, however, is that the game we played took place over a large expanse of “rooms” with various descriptions. Sprawling mansions, open marketplaces, creepy dungeons, all of which rendered only in text, without a map to keep them all organized. If you wanted to remember which way you’d turned previously, so that you can make your way back out of the labyrinth before the minotaur catches you, you had better keep track of that somehow. So, we would spend hours together, drawing out each action and movement onto a large sheet (and quickly several large sheets) of graph paper. The game, just a virtual fantasy, soon had a weighty physical counterpart, that we had built ourselves.

In Shortcuts, it’s possible to recreate this same sort of game on a smaller scale by replicating the core conceit of the text adventure above, but adding a few more functions from the Shortcuts arsenal, namely List, Variables, Calculate, and Repeat. All very simple ideas unto themselves, but can be combined powerfully.

Let’s start with how we want the game to look, and work backwards from there. I would like to have the game described to me a fictional room that I’m in, and provide a list of directions, which I can then use to move to the next room, which will then be described to me, and so on…

This is the core “loop” of the game, and since Shortcuts applications are only designed to be run all the way through once, this is achieved through the Repeat function. As of yet, there isn’t a “repeat infinitely” option, however we can set a Repeat of something like 1,000,000,000,000 times, which is basically the same thing. Inside that “loop”, we will do four things:

  1. Calculate what room the player is in

  2. Show that room’s description

  3. Allow the player to choose from a list of available exits

  4. Update the player’s position accordingly

If, like me, you’re prone to draw out maps on graph paper, you’re probably used to thinking about locations and positions in terms of X and Y coordinates. Picturing the top-left corner of the page as the origin, subtracting from a player’s Y value moves them “up” the page, whereas adding to it moves them “down”. Same for the X value with left and right. Once you have the X and Y position of the player, all you have to do is return the room that matches that value, and you’re off to the races.

Well, almost.

Shortcuts, not being an app that’s designed for such purposes, doesn’t allow us an easy method for creating two-dimensional arrays, which is what we typically want for X/Y coordinates. So, we have to get creative (“yaaaaaay,” I hear you saying).

What we’re going to do instead, is take advantage of the List function: a one-dimensional array that we can trick into becoming a two-dimensional array.

To do this, let’s take a look at the total amount of space you’re looking to create. How many rooms wide and how many rooms tall will it be? For the purposes of example, I stuck with three rooms wide, and three rooms high, for a total of nine spaces altogether in our “map”. We then specify the Map Width and Map Height as variables, like this:

Number: 3

Set Variable: Map Width

Set Variable: Map Height

Note that we only have to set the Number once here, as the Set Variable function passes its input on to the next action. If we wanted the height to be different from the width, we would place another Number in-between the two Set Variable commands.

With those numbers in mind, we’ll now create a List of our rooms, with the idea that we will be listing 9 rooms, in imaginary rows of 3. You could conceivably picture them as columns of 3, as well, but I prefer rows, so there. In my example, the list looks roughly like this:

List: “Northwest Room”

“North Center Room”

“Northeast Room”

“West Room”

“Center Room”

“East Room”

“Southwest Room”

“South Center Room”

“Southeast Room”

Set Variable: Room Title

Using the three-by-three layout works well enough for these purposes, but remember that you can adjust this to fit any width or height that you need. You can then use the Set Variable command to save this list for easy use later.

If you want to get more detailed, as I did in the example Shortcut provided above, you can create multiple lists that all correspond to the same rooms. For example, you could have a list of Room Titles, another list of Room Descriptions, and another list of Room Items, just making sure that the order of each list lines up with the order of the others. To determine what item in our lists to return, we will use not X and Y, but the player’s “Position”, a gestalt of the two dimensions.

“Position” will represent the player’s current spot in our many lists, and moving the position up or down will affect what room is display. This is where knowing the width of your map ahead of time is important, because that allows us to fool the list into thinking that it has more dimensions than it really does. To move the player to the right or left, we simply add or subtract 1 from the player position as needed. To move the player “up”, or “down”, we will add or subtract the Map Width variable. This will have the effect of simulating vertical movement in our imaginary map.

In the example we’ve laid out so far, let’s say that we set the Player Position to 5, like so:

Number: 5

Set Variable: Player Position

We can use that number to then return the information that we have about the room at that position, using the Get Item From List function, like this:

Get Variable: Room Title

Get Item From List: Item at Index: Player Position

Show Alert: Get Item From List

When you create the Show Alert, you can use the Select Magic Variable option to pull the result of the Get Item From List directly, rather than having to set/get more variables. When this is all run together, we’ll see an alert telling us that we are currently in the “Center Room”.

With our map and our initial positions set, we must now find a way to move around, which we’ll accomplish by returning to our old friend Choose From Menu. First, we’ll create a menu giving us four options, which we’ll name “North”, “South”, “East”, and “West”, to keep with tradition. Inside each option, we will get, adjust, and set the “Player Position” accordingly:

Choose From Menu: “What direction would you like to go?”

North

Get Variable: Player Position

Calculate: Subtract “Map Width”

South

Get Variable: Player Position

Calculate: Add “Map Width”

East

Get Variable: Player Position

Calculate: Add 1

West

Get Variable: Player Position

Calculate: Subtract 1

End Menu

Set Variable: Player Position

Note that while we Get Variable in each option, to ensure that we really are dealing with the Player Position, we only Set Variable once at the end. Since the Choose From Menu function passes any result to the next action, we can rely on the correct calculation being applied to our variable in the end. If you’re a fan of redundancy, though, feel free to add Set Variable to the end of each choice (like I did in the example I linked above).

With the Player Position updated, we will now loop back around to the beginning of this diatribe, get the correct room from the list, display it, and start all over. In the briefest possible outline, here is how all of that looks within your Shortcuts program:

List: “Northwest Room”

“North Center Room”

“Northeast Room”

“West Room”

“Center Room”

“East Room”

“Southwest Room”

“South Center Room”

“Southeast Room”

Set Variable: Room Title

Number: 5

Set Variable: Player Position

Repeat: 9999999999999999 times

Get Variable: Room Title

Get Item From List: Item at Index: Player Position

Show Alert: Get Item From List

Choose From Menu: “What direction would you like to go?”

North

Get Variable: Player Position

Calculate: Subtract “Map Width”

South

Get Variable: Player Position

Calculate: Add “Map Width”

East

Get Variable: Player Position

Calculate: Add 1

West

Get Variable: Player Position

Calculate: Subtract 1

End Menu

Set Variable: Player Position

End Repeat

And that, as they say, is that. Every time you select a direction, the loop will reset, grab the new Player Position, and return the relevant room.

Now, obviously, that isn’t the whole story, but you’ve read enough! There are a number of remaining questions that I’ve attempted to answer in the example I linked to at the start of this, and invite you to try and answer in your own version of this:

  1. How do you keep the player from moving out of bounds?

  2. Can you make the limited number of Repeats interesting?

  3. Can you update the exits dynamically, forcing the player into corridors and such?

  4. Can you add elements of interactivity, such as items, puzzles, or enemies?

  5. Can you add graphics?

Happy hunting, my friends. As always, if you have questions or comments about any of this, please reach out! The amount of research being done into this avenue of using Shortcuts seems relatively limited, so I’m curious to hear what thoughts are out there.

Like I said at the start, I’ve also been working on a roguelike game, following similar principles to those outlined above, just… much more complex. I’ll work up a new post about that soon.

GamesTylerShortcuts
"The Amazing Screw-On Head" Playbook for Monster of the Week

Up until recently, I was convinced that I would be the only person to remember the brilliant pilot for Mike Mignola’s “The Amazing Screw-On Head”. Earlier this week, podcast host Jeff Stormer (who I’ve mentioned here once before) proved me wrong. In a tweet, he revealed that he shared my eternal frustration that the show never saw the full run that it deserved.

As Jeff is the host of the Party Of One Podcast (which I highly recommend), I replied jokingly that we should find a way to play The Amazing Screw-On Head as a two-player tabletop RPG.

Then, I left it alone for a few hours, content that I’d made a pleasant response and nothing would ever come of it. It was a silly idea that didn’t merit a second thought.

Or a third.

Or a fourth.

Inevitably, it was something like 7 o’clock at night, and I found myself trying to write an Amazing Screw-On Head standalone game. Nothing complex, maybe just in the vein of Cyberpunk Day Job or Teenagers With Attitude, so that I could crank it out and be done with it. Over three separate iterations, though, I realized that all I was really trying to do was re-write the excellent Monster of the Week, one of my favorite games.

So, I opted for the path of least resistance: make a new playbook for MotW.

So far, it seems to have gone over pretty well, which makes me happier than I’m fully able to convey here. You can download it from the link below, and try it in your own games!

A quick note about gameplay mechanics: You’ll notice that the playbook doesn’t include experience or advancement sections. This is for two reasons:

First, the goal was really to run this as a one-shot, or at most a series of monster-of-the-week episodes (see what I did there?) where the development is primarily narrative, rather than mechanical.

Second, this is to balance the mechanics of allowing one character to essentially erase their harm five times. The “advancement” in this case is the selecting of a new body, which is pretty unique to even the unofficial playbooks I’ve seen.

With regard to actually determining moves, much of what’s written is inspired by The Monstrous playbook, which is my favorite to play as. I wanted to make something that would feel like being a weird, wondrous, mechanical hero, and a lot of the Monstrous fit the bill. It’s also built for be played as the only Hunter, so it should (should) fit a handful of roles simultaneously. That said, I could see this running well alongside a Flake, or an Expert, or maybe even a Monstrous for a fun twist.


Let me know if you like it! I’ll likely be using the document as a template for future playbooks, and invite you to make copies and do the same. Unless there’s a better template out there that I was too lazy to look up. In that case, let me know about that too.

Adventurers between Adventures: Merchants and Customers

Accustomed to a certain lifestyle

While thinking about commerce in Dungeons & Dragons, I keep coming back to the question of how the average person affords the lifestyle they live. As the books are primarily written for the players, many of the rules regarding buying goods and services are built around abstracted costs of living between adventures. These costs are shown first in a high-level abstraction called Lifestyle Expenses, which represent the average daily costs of living in certain levels of comfort. This covers food and lodging, and determines the social strata that your character might interact with during their periods of downtime. The fresher the food or more comfortable the bed, the more expensive the daily costs.

I happen to like the online version of these rules a bit better than the printed copy, and the Basic Rules on expenses can be found here: https://www.dndbeyond.com/compendium/rules/basic-rules/equipment#Expenses

The prices are then broken down into food and lodging of various comfort levels, also on a daily basis, and then food is broken down into individual items that one might order off a standard tavern menu. You know-- meat hunks, loaves of bread, gallons of ale and the like. This is my personal preferred view, though I might honestly prefer a more in-depth table based on the level of preparation, craftsmanship, and cost to import certain ingredients, but we'll get to that later.

The mile-high view of Lifestyle Expenses is interesting to me because its brevity indicates that there is an expectations for players to not pay it much mind. It creates a simple metric by which players can roughly estimate the cost of their lifestyle, and brush it aside as simply "the time until the next real thing." In truth, I have yet to see a player or dungeon master even reference these rules during play, to the point where for a time I didn't believe they existed. This is just as well, though, because even low-level adventures tend to ensure that players can quickly afford the Modest or Comfortable strati within the first dungeon delve. More, if they're crafty.

For example, a character who survives the introductory adventure The Lost Mines of Phandelver (or Here There Be Gerblins, for fans of The Adventure Zone) can expect to come away with anywhere from 10 to 50gp, plus a magical item or two, if they play their cards right. While this isn't enough to jump straight into the glamorous life of wealth and fame, it's more than enough to live comfortably until heading off into the next adventure. 

That's all well and good for the adventuring type-- the stoic Paladin or fearsome Barbarian who might throw themselves headlong into certain doom, with naught but a prayer to see them safely to the other side. They can use the spoils of their small wars to fund a certain lifestyle until the next evil emerges from its respective pit, and that'll be fine for them. What I wonder about consistently when reviewing these rules is how we are treating player- and non-player-characters who don't want that life for themselves? Even the smallest village is likely to have a humble carpenter, blacksmith, or shepherd. How do they earn enough to live? 

Let's take an example laid out in the Dungeon Master's Guide, and say that my Human Ranger "Karrson" has inherited a smithy. 

Thanks to his inheritance, Karrson doesn't have to shell out the cash to build "Karrson & Sons Smithy" from the ground up, so that's one expense out of the way. All Karsson needs to worry about here are the expenses for daily upkeep. The Player's Handbook and DMG provide some useful tables for average daily costs of a business, such as an inn, but smithy isn't on the list, so we get to improvise a little here. 

Running a smithy "by the book"

To begin running Karrson's smithy according to the books, we need to figure out what the average daily cost of business is. This includes paying staff, and purchasing basic supplies to keep the place running. For the average smithy, you might need 1 "Skilled" hireling to do the bulk of the blacksmithing, and 2 or 3 "Untrained" hirelings to be assistants, or clean the shop at the end of the day. Per the Player's Handbook, that comes to 2gp and 6sp per day, which we'll round up to 3gp for accounting's sake. Then we'll need raw materials to turn into our product, which we'll say is swords and axes. We'll estimate that we need about 10 pounds of iron per day, on average, depending on the work being done. That gives us enough to make a decent longsword or a big war axe, plus some extra for smaller orders (nails and the like). I will admit to not being a professional blacksmith, so one might argue for a smaller or larger number of pounds, that's fine. I'm saying 10 pounds solely so that we can say that our average daily cost for supplies is 1 gold piece. 

That brings us to 4 gold pieces per day to run the Karsson & Sons Smithy, which sounds fair! According to the Dungeon Master's Guide, that places us somewhere between running a shop and a guildhall, which feels appropriate for the concept. 

According to the DMG rules for running a business, whenever a player spends their downtime minding their business, as it were, they roll a percentile die. They add the number of days spent on this activity to their roll, with a maximum of 30 days, and subtract 10 from the roll for any missed payments. The result of the roll determines how the times goes for the business in a general sense, with higher numbers being generally better. For example, a roll of 41-60 reads "The business covers its own maintenance cost for each of the days", while a roll of 81-90 reads "The business covers its own cost for each of the days. It earns a profit of 2d8 x 5 gp." Lower rolls require the player to pay for office maintenance costs out of their own pocket, which may lead to the aforementioned missed payments. 

As you may have expected, I have a few problems with it. Why? Because, dear reader, I -- *pushes up glasses* -- am a loser

The book isn't what I need, and that's okay

I want to be really careful here: the book is not wrong. I have only found that in the particular kind of game that I want to play, these rules do not fit the mechanics or narrative that I want. In the spirit of Unearthed Arcana and years of D&D modules before me, all I want to do here is explore an alternative that I find interesting. 

The book doesn't provide what I'm looking for because of a few simple reasons: 

First, the rules only come into effect while the player is actively spending time on the business. This implies that while the player is not actively there, everything goes pretty much according to plan, and the business stays afloat. This incentivizes the player into never spending time on their business, for fear of losing money. 

Second, the rules specifically list a maximum of 30 days per roll. While this is most definitely included to prevent rolls consistently over 100+ (I can just see myself saying "I spend 100 days on my business lol"), it encourages players and Dungeon Masters to move swiftly between adventures, while sweeping the in-between stuff under the proverbial rug. This is fine if you want to focus primarily on going from dungeon to dungeon and dragon to dragon, but.... I don't? I know, it's the name of the game, it's fine.

Last and most importantly to me, it reduces the entirety of your downtime, up to thirty days' worth of hard work and interactions, to a single roll. Yes, this can be filled in (and done well!) with role-play and narration, but it presents a stark mechanical imbalance when compared to things like combat. Could you imagine reducing an entire dungeon crawl to a single percentile roll? No, of course not, don’t be ridiculous. And why is that? Because the player character, as an entity, is written for combat. The rules for combat in Dungeons & Dragons are more complex, more fleshed out, and more interesting to play.

The argument that I would like to present is that the player character is equally constructed for trade and social interaction, and with the proper implementation of rules that respect that fact, we can make running a shop as mechanically interesting as raiding a dungeon.

Below is a first draft of how those rules may look. Admittedly, I've written these down in spare moments over a number of days, so some thoughts may be incomplete or inconsistent. The intention is to use this as a starting point on the road towards making and play-testing something more "real".


Going into Business

Whether you are inheriting a business or starting something from the ground up, there are many factors that you'll want to keep track of as you get started. It's recommended that you do this on a separate sheet, or in the "Additional Notes" of your character sheet if possible. At the top of the page, outline the general description of your business: name, rough outline of what the business provides, and the primary operating location. Especially if you're building your business from scratch, you'll want to work with the Dungeon Master to figure out the cost of building (or buying) a location to use as your primary operating location.

Below the general description, create three columns: Assets, Expenses, and Extra.

Assets are anything that you can, will, or are actively making money from. This can be physical items that you want to sell, services that you can provide, space that you can rent, and so on. Really, it's anything that you can convince the Dungeon Master that someone else may want to pay an amount of money for at some point. These will be the things that you sell to customers when they come to your primary place of business, which we'll get to later. For example, if you run a small inn, your assets may be a small number of rooms to let, a small breakfast served in the morning, and a warm dinner at night. 

Expenses are everything that you have to pay money for to keep your business running. This includes the cost of crafting or maintaining the things in your Assets column. For example, if you are running a smithy (as in our example earlier), one of your Assets may be "Longswords". A corresponding expense may be the iron needed to craft new longswords, or hiring a blacksmith or assistant to do the actual crafting. Expenses for an inn may include the food to prepare for meals, and a hireling or two to help keep the rooms clean.

Players and Dungeon Masters should work together to determine the prices and costs of both Assets and Expenses, starting with the examples provided by the book (we'll consider those "market value" for most items). Players may freely opt to mark up or down the prices of the Assets, though that may affect a customer's willingness to purchase something later on. One of the additional projects that I'm laying out for myself currently is writing up lists of example Assets and Expenses, to create a sample set for your businesses. This may turn into something resembling a separate character sheet for shopkeepers, but we'll keep things loosey-goosey for the time being.

Creating Customers

While a character owns a business, the business sees a number of customers per day equal to the character's Charisma modifier (minimum 0, though perhaps we could make a case for having an negative number of customers). This number can be increased through Marketing, which we'll talk about some time later on. Customers, from the Dungeon Master's perspective, should be treated like monsters. They have lives, react to other customers, and can intersect with the character's lives at the worst possible moments. 

When a customer enters the shop, give them a Goal, an Expectation, and a Demeanor. These can be selected from the list below or chosen randomly by rolling the corresponding dice. Goal and Expectation are to be kept secret by the Dungeon Master, while the Demeanor should be made known to the players immediately.

The Demeanor reflects both how the character behaves while in the shop, and the mechanical challenges that the player may face while they remain there. The Demeanor can be changed through successful skill checks, outlined in Making the Sale below.

The Goal reflects the initial desires of the customer (which they may or may not be honest about), and affects every roll made involving them. 

The Expectation reflects what is likely to catch the customer off-guard, and give the player the advantage. The first time a player character performs an action that proves the customer's expectation wrong, they gain advantage on their next roll. 

Goals (1d6)

  1. To purchase the most expensive item or service available at a 50% discount. (+2 DC against rolls to improve Demeanor)

  2. To haggle with the merchant as much as possible. (Failed Making the Sale rolls reduce the Demeanor by 2, to a minimum Demeanor of 1)

  3. To purchase a specific item or service at 80% market value. (+1 DC against rolls to improve Demeanor)

  4. To purchase something at an acceptable price. (+2 DC against rolls to improve Demeanor beyond 4)

  5. To spend money freely in exchange for premium service. (-2 DC against rolls to improve Demeanor. If another customer's needs are given priority, Demeanor is instantly reduced to 2)

  6. To purchase the desired item or without causing too much trouble.

Expectations (1d6)

  1. That service will be slow.

  2. That this store will not have the specific item/service that I need.

  3. To have to haggle to receive a fair price.

  4. That assumptions will be made about me based on appearance.

  5. That the merchant will know nothing about their product.

  6. That the quality of the item/service that I receive will be lacking.

Demeanor (1d6)

  1. Upset. Will pay 50% of market price. DC 18 to improve.

  2. Irked. Will pay 60% of market price. DC 16 to improve.

  3. Unsure. Will pay 80% of market price. DC 14 to improve.

  4. Reasonable. Will pay market price. DC 14 to improve.

  5. Gleeful. Will pay 125% market price. DC 12 to improve.

  6. Ecstatic. Will pay 150% market price. Cannot be improved.

When asked, a customer should be specific about the kind of item or service they intend to purchase. If a customer enters the store with a Gleeful or Ecstatic Demeanor, they may not even wait to be asked. The item or service should always be within the realm of what the business has to offer-- though it would be "more realistic" in some cases, we don't want customers coming into our smithy looking for the bed and breakfast. Additionally, the customer enters the store with the intention of purchasing something. If the Dungeon Master wants to bring in characters that are "window shopping", that's fine, but they should be treated separately from Customers.

As I mentioned about, when creating the business, Dungeon Masters and players should work together to create a short list of the kinds of items and services that the business is likely to have on-hand, and use the prices outlined in the books to create a sort of "menu" that can be referenced. Customers who may have doubts about the availability of a product or the shop's ability to produce it are likely looking at the more expensive products on the "menu", while most other customers are likely looking for something towards the middle. 

Making the Sale

When you interact with a customer with the intention of changing their demeanor, describe what action you take, and make a check according to the relevant skill. For example, lying to the customer about a product's value would require a Deception check, while extolling the virtues of a service may require a Performance check. If you are unsure what skill your action requires, defer to the Dungeon Master's judgement, or simply add your Charisma modifier to your roll. If your roll meets or exceeds the DC listed on the customer's current Demeanor, their Demeanor increases by 1 point, to a maximum of 6. Otherwise, the Demeanor decreases by 1. If the player's action is focused on a target on than the customer, their Demeanor decreases by 1 per action. 

If a customer's Demeanor reaches 0, or if the item or service they require is not offered for some reason, they will leave the establishment without purchasing anything. 

At any point while interacting with the customer, the player may opt to Make the Sale. At this point, they expend the item or service from their inventory, in exchange for the agreed upon amount. The customer then leaves the business. In the case that the item or service requires the customer remain at the place of business, such as renting a room in an inn, no further rolls are required for Making the Sale, and this has no impact on the number of customers seen per day.

While not required, I highly recommend creating names and quick descriptions for each customer. This can be something the player and Dungeon Master come up with together, or something pulled from a random generator for sake of ease. This is important to me, because it opens up the possibility to have recurring customers, adding further depth to the world and creating connections that may not have otherwise been made. Recurring customers could turn out to be the captain of the town guard, or a passing noble, or even the campaign's main villain. These characters can be played however the Dungeon Master prefers, and their goals, expectations, and demeanor may change freely.

Marketing and Advancement

While I enjoy the idea of a player character’s Charisma modifier dictating the number of customers a store sees each day, as it represents a sort of abstract word of mouth, I want there to be room for improvement in all things. We can’t leave out low-charisma characters, after all, and we should reward players who want to take the time and strategize well. There are a couple ways that I can think to do this, both of which I’ll look to detail further in later posts (because I believe I’ve written enough here, don’t you think?).  

The first method would be to give each store a separate character sheet, complete with attributes and skills and everything. Initially, the store’s sheet would match the character running the shop, but as the store earns capital, it can exchange it for experience points. This is similar to more “old-school” games like Labyrinth Lord or Dungeon Crawl Classics (though you can check my memory on that one). We’d have to do a bit of conversion math, but at a glance I feel that a 1 to 3 gold-to-XP ratio sounds fair.

What this allows us to do is separate the store’s progression from the character. If the store does well, it advances well, and at certain levels it can take advantage of an attribute point increase, then begin to use its own charisma modifier to bring in customers, rather than the player’s. We could conceivably translate a good number of feats to relate to commerce instead of combat, as well. 

The alternative, which I might like even better, is to take advantage of the existing hireling rules that I mentioned earlier. Only, instead of hiring someone to carry your things or help make new items, you hire town criers and advertisers to go around promoting your business. The conversion on this is fairly easy as well, if we think of a purely monetary value: skilled hirelings bring in one more customer per day, and unskilled hirelings bring in one new customer every 1d4 days. This is roughly equivalent to the kinds of daily value you can get from hirelings performing other tasks, and gives players a decent chance of breaking even on their investments rather quickly. 

 

Next Steps

I’d like to work on creating some fillable character sheets for stores, and perhaps coming up with a few commercial archetypes— weapon shops, taverns, inns, etc. It would be fun to treat these like classes in the PHB, with unique perks as they level up and everything. 

What I’ll write on next, though, is the idea of politics and public works. We’ll explore ways that players can, through their actions and investments, indirectly influence the events in a location, and how a Dungeon Master can help draw the lines between actions and outcomes on a large scale. 

HacksTylerD&D
A More Comprehensive Ruleset for Adventurers Between Adventures: Introduction

A Question of Loot

While running a game of Dungeons & Dragons 5th Edition recently, as the adventure wound to a close, and the adventurers made their way out of the Sunless Citadel, and the telling signs of late-night exhaustion made their way 'round my players' faces, I was struck with an urge to remind everyone of what loot they find on their way out. This wasn't something that we had much paid attention to (I'm lucky to play with people whose first instinct isn't always to loot the bodies), but the adventure's end triggered something in my lizardfolk-DM brain, saying that they might need these small treasures later on. 

Now, in the cold light of day, I don't think that they do. 

Of the combined 640+ pages of the 5e Player's Handbook and Dungeon Master's Guide, less than ten pages are dedicated to things that you can reasonably purchase on the daily. There's a chapter on Magical Items in the DMG, yes, but it's difficult to justify the average shop having anything more than a few Potions of Healing available on any given Tyr's Day. I'm strictly thinking of items that you can walk into a store and buy between adventures. 

While providing dense tables of trinkets and adventuring gear, replete with weight and cost and flavor, the latest edition of D&D is content with letting the mechanics of these tables play out "off-screen." I have yet to play in or watch a session in which the purchasing of equipment or "mundane" items is not hand-waved away with a "Sure, we'll say you got that while in town. Anyway, on to the combat..." Spending gold just is not the most interesting thing to do in this game. Neither is haggling for a better price, or determine an object's true value. A single successfully Deception or Persuasion check can get an NPC to do what you want, for the most part, while a single successful Insight or Investigation check will let you know what they're hiding. Why waste time on the <10 pages of paying for things and talking to people, when we can focus on the 20+ pages of combat rules, status conditions, and debates over the definitions of "grapple" and "invisibility"? Not to even mention the scores upon scores of spells and incantations to prepare each day. 

Why, indeed. Most people-- commonly referred to as "normal people"-- will agree that the exploration and combat elements of D&D are the most interesting, and provide the most mechanically interesting elements for a role-playing session. "The tables on buying land and paying upkeep are serviceable, and the rules for social interaction pillar were clearly intended to be fluid and allow for in-character improvisation and fun," the voices in my head tell me. Why would we fix what isn't broken? 


Let's be Barons

Of every campaign I've been a part of, the one I talk about most was the first one. You never forget your first, as they say. It was a fairly modified version of Decipher's The Lord of the Rings, which had been crudely printed out and shoved into a three-ring binder. Our group, which had consisted of mostly the same characters for the whole run, had been playing for four years in real-time, and nearly a decade in-game. This meant that, in addition to wielding mythical weapons of power, one of the three Elvish Rings of Power, and (not to brag) enough magical aptitude to take down a dragon in a single blow, we were also filthy rich

My father, a telecom engineer and the group's de facto banker, realized somewhat suddenly one day that his character (a ranger of the north), had been carrying roughly 900 pounds of gold, jewels, and knick-knacks on his person. Encumbrance issues aside, we hadn't the faintest what to spend it on. By that point, we had become heroes of the land, and were welcome with food and lodging wherever we traveled. We wanted for naught but the cool breeze of adventure in our faces and the warmth of victory at our backs. 

When our game master, a history teacher, presented us with a down-on-its-luck stronghold in need of proper management, there was only one true solution: we bought it, and became barons of the land.

Over the course of several months, spreadsheets were drawn up, detailing the intricate daily plans of the keep. Everything from transporting stones from the quarry to bringing in farmers and cattle to occupy the surrounding hills was detailed with an approximate cost in gold coins. We would hold small council meetings before and after each adventure, voting on which endeavors to fund and which to put on the back burner, slowly building a village around our new castle. With our spreadsheets, we could see the real-time impact of each decision, prompting us to develop investment schemes, saving plans, and plan adventures around how much gold we could bring back to continue our pet projects. I was more enthusiastic and responsible regarding this imaginary money than I have ever been, and potentially ever will be, about the small amount of money I possess in real life. 

So while the social and commercial interactions in D&D aren't broken, by any means, I miss that level of exuberant obsession in tabletop games. The kind ridiculed on TV and in movies, where nerds sit around a table for weeks on end, drowning in their own filth as they calculate the odds of a single arrow sparking a cultural revolution in the east. It was a sort of pure joy that people who liked math and stories could enjoy together, getting lost in not only the fantasy of being a knight in shining armor, but the mystical realities of being a capable accountant, shrewd lawyer, and wise ruler. 


New Adventures in Old Mundanity

Using Dungeons & Dragons as a framework, my intention is to write a small series of rules for adding a welcome complexity to the hum-drum everyday life of an adventurer between missions. Hopefully not too much complexity, but enough to make interaction, rolls, and a player's time valuable. The intent is to make it fun and interesting for players to haggle on prices, set up shops, compete with NPCs for market share, throw parties, and take time enjoying the finer things in life.

Each set of rules will become a new post here, and they'll eventually compiled in a small bundle called "A More Comprehensive Ruleset for Adventurers Between Adventures". I won't write them quickly, I'm sure, but that's the goal.

Topics I'll be covering include the following:

  • Spending Money
  • Property Management
  • Business Management
  • Marketing and Propaganda
  • Laws and Lawyers
  • Friends, Family, and Romantic Interests
  • Holidays, Festivals, and Other Events

With the introduction out of the way-- have you played games like this before? Would you play them again? What topics am I missing, or am I reinventing well-greased wheels?

Fixing Low-Level Combat in D&D

Edit (May 2, 2019): Nearly a year later, this is somehow the most popular thing I’ve ever written. If you use this method in your game, can you do me a favor and drop a comment below to let me know how it went?


The 5th edition of Dungeons and Dragons is very up-front about what it is.

The game rests, as it states in the first chapter of the Player’s Handbook, on three pillars of gameplay: Exploration, Social Interaction, and Combat. This simplicity helps keep the game and its players focused, aligned, and (for the most part) friendly. Which makes it all the more unfortunate that one of the pillars— Combat— is terrible.

I say this fully cognisant that it may be an unpopular opinion, so let me qualify it a bit: combat beyond 5th level, or Combat between player characters, can be incredibly rewarding. It’s at those points in the game where you can most accurately weigh the pros and cons of each action, and there is enough variety of available actions to provide actual depth and choice to each round. It’s the getting to that point that I can’t stand.

For example: most new parties of first or first-ish level will likely be introduced to fifth edition through a pre-written campaign like Hoard of the Dragon Queen. This is a perfectly fine set of adventures, and was my own introduction into the new rule set. The first set of combat encounters here primarily involve kobolds, which players will recognise as the bread and butter of the dungeon crawl.

For the uninitiated: kobolds are small, lizard-like creatures, famous for their cowardice and lack of combat prowess. Dungeon masters throw them at players like pretzels on the route from first to third level.

In the fiction, kobolds make a great choice for the start of Hoard of the Dragon Queen. They create an interesting plot that leads players on the path towards a cult of Tiamat-worshippers and a veritable sample platter of tasks that are typical for an adventuring party. I’m not here to complain specifically about kobolds.

But, since you insisted, I will.


Brief tangent warning!

Kobolds are the prime example of low-level combat that sets a false expectation for players and Dungeon Masters alike, specifically for maths reasons. This is supremely uninteresting to anyone but me. To begin, standard Monster Manual kobolds have an Armour Class of 12, and their winged cousins have 13. For the standard first-level adventurer with a Strength or Dexterity modifier between 1 and 3, you would need to roll an average of 10 or better to land a hit. On a 20-sided die, this gives players about a 50/50 chance to hit one kobold per round.

Then, consider the basic attacks given to kobolds in the Monster Manual: unless the DM decides to change something, they are given a dagger that does 1d4 + 2 damage, with a +4 bonus to hit.

+4!

Unless a DM hands out the more expensive armour at first level, the average player’s Armour Class sits at around 14. This puts the odds of a kobold hitting a player dead even with the odds of being hit themselves. While this may sound completely fair at first, let’s move finally to the kobold’s Challenge Rating. A challenge rating tells the Dungeon Master how difficult a particular monster is, and typically you’ll want to match the CR to the average level of the party (the book assumes four players in a party). The kobold has a CR of 1/8, meaning that an appropriate number of kobolds to throw at a party of first-level adventurers is EIGHT.


From that, let’s build a scenario: a first-level fighter, rogue, wizard, and cleric, walk into a tavern. For some inexplicable reason, the only other occupants of the tavern are eight hungry kobolds. Everyone rolls for initiative, and each adventurer squares off against two kobolds.

The Kobold Dilemma

The fighter goes first, and thanks to the 50/50 chance I mentioned earlier, they all but flip a coin to see if they can hit one of their two opponents.

For the sake of argument (and as a demonstration of how my luck goes), let’s assume they miss. The two kobolds then each take a swing at the fighter, again with the coin flip’s odds. The kobolds now have twice as many chances to hit the fighter as the fighter did to hit them. It doesn’t even matter at this point whether they hit or not, because until one of them is eliminated, the statistical imbalance remains.

This pattern continues with the rest of the party, though the others may not fair as well. The wizard, while she may be able to keep a distance at first and fire off a Magic Missile, will suffer from a lower AC than the fighter, further tipping the odds in the kobolds’ favour. 

Of all of the players in this scenario, the cleric may actually fair the best; they have access to decent AC, average strength, and healing spells. However, having only one action per turn, they would have to completely sacrifice their chance at hitting a kobold in order to heal members of their party. Even incredibly kind DMs wouldn’t pass up that opportunity to have the kobolds gang up on a party member (remember kids, always kill the healer first).

Finally, after all of the players and their respective kobolds have taken a turn, we circle back around to the fighter, who has not yet done anything useful in this combat. For anyone who has twiddled their thumbs for fifteen minutes while seven characters take their sweet time failing to hit each other, you know this feeling.

This brings me out of my first point:

I really hate kobolds

and onto my second:

Missing in combat feels bad, and it shouldn’t.

As it stands, missing in combat is essentially your cue to get up, get a snack, maybe use the restroom, and browse twitter for a bit. When you roll to swing your sword, preparing for the ecstasy of seeing a monster cleft in twain, missing that roll completely ceases the flow of combat. It is literally saying, “nothing happens, and your turn is now over.”

If you got into D&D to experience the escapist fantasy of being a capable adventurer in a high-fantasy world, this mechanic quickly whittles away at that ideal. I already have a hard enough time liking myself despite my stupid mistakes, I certainly don’t want to find myself feeling that way about a half-orc barbarian pirate that I’m trying to personify. Remember, Dungeons & Dragons is supposed to be a fun activity. I don’t know about you, but I would rather try and avoid that kind of existential dilemma if at all possible.

My main issue with missing attacks in low-level combat is that it fully breaks the illusion, and feels neither fair to the player, nor true to the fiction. This is not to say that missing an attack does not happen in combat— it certainly does! However, the context of that miss is important.


Tricks vs. Skill

In high school, I was part of a fencing club. I wasn’t great, but I wasn’t terrible either.

Largely, I attribute not being terrible to being left-handed, which gives you a sort of built-in advantage unless your opponent has a lot of experience fencing lefties, or is also left-handed, creating a sort of reverse-Princess Bride scenario.

My level of actual skill with the sword was fairly median, and once you figured out the one or two tricks I had in my back pocket, I became a middling-to-low-level opponent. Experienced fencers could not only pick up on this tricks, but had significantly more of their own. While they still fence within the rules of of the sport, the patterns that experienced fencers follow vary such that it becomes increasingly difficult to predict their line of attack, making each one more difficult to avoid.

At higher levels of D&D, combat can be very well suited to match that feeling, and missing a roll can play an important part in the fiction: though your aim may be true, your opponent is able to parry it away at the last second. Though you have prepared for the worst, they outsmarted you for a moment, but you can get them next time. It can feel very much like a real sword fight, with a back-and-forth leading to a worthwhile conclusion.

By contrast, Kobolds don’t even know what a parry is, much less how to perform one consistently.

So how do we fix this?

Using my narrow scope of frustration, one might be tempted to say “let’s just nerf kobolds”. But the problem extends beyond a singular monster. The root of this issue, the reason why missing an attack roll feels bad, is this:

What are we meant to gain from combat?

At early levels, the goal of combat against low-level creatures (such as kobolds, but also goblins or simple beasts) is simply to gain experience. With experience, you’ll level up, and eventually this will get interesting.

The trouble with this is that it takes time for experience to accumulate, and early levels may not give you the benefits necessary to ease the pain of missing an attack roll in combat. At best, you have something like the Fighter, which gains Action Surge at second level. This gives you one extra attack, once per rest, which... kind of helps? It feels like a waste to spend that move on a kobold, and waiting for a rest can feel like forever.

Plus, second level requires 300 experience points. That’s twelve kobolds that a character would have to take down by themselves, unless the DM gives out lots of non-combat experience. That’s like flipping a coin once every fifteen, maybe twenty minutes, until twelve of them come up heads. All for a reward that lets you flip twice one of those times.

What we want here is a way to reward the intelligence, experience, and dynamics of the character, relative to that of the monster they are fighting. While it’s appropriate for a fighter to square off against a bandit or lizardfolk of similar intelligence, it just doesn’t make sense for them to have the same experience when facing off against a lowly kobold or a goblin, at least after the first encounter or two.

My proposal to fix this requires a bit of dedication, and is best started at first level. If you’ve made it this far, I think you’ll be okay.


Combat Intelligence

On the back of your character sheet, write down your Intelligence score.

Below that, make a simple two-column table. Label the left column “Name” and the right column “Experience”.

When you encounter a creature in combat, add its name to the “Name” column, if it’s not there already. When you declare an attack against that creature— regardless of the attack’s success— mark a tally in the “Experience” column next the the creature’s name. The represents what you have learned about this creature’s fighting style, strengths and weaknesses, and general patterns.

If your Intelligence score plus your Experience with a creature exceeds that creature’s Intelligence score, you do not need to roll when declaring an attack. Thanks to your experience and careful study of the creature, you have learned how to consistently defeat it in fair combat.

Using this mechanic, every attack, even a miss, represents a tiny bit of progress. Even for that fighter who missed the first attack, and now has to wait twenty minutes for their turn again, that miss didn’t make them completely useless, and they’ll come back stronger for it.

While for some players and some creatures, this means that after one attack (even a miss!) you will be able to land hits each time, that makes sense in the fiction for some characters.

Are you a highly intelligent rogue or ranger who has spent time studying the combat styles of a particular creature? It makes sense that you would quickly find a way to counter that style.

Conversely, if you’re a big, low-INT barbarian stomping around, it may take you a bit longer to really get the feel for fighting some monsters, but your brute strength will get you there eventually.

Additionally, as you face higher-level monsters with higher intelligence scores, this will become a steadily more difficult feat to accomplish. While you may learn a little about how a vampire fights in a couple rounds of combat, it’s a safe bet that they won’t stick around long enough for you to learn all of their tricks in one fight.

As your characters advance in levels, the combat experience stays with them. When they return to fighting kobolds and goblins on the way to the next adventure not only because they are stronger and have magical weapons, but because in true Sun Tzu fashion, they have come to know their enemy.

HacksTylerrules, games, D&D
Storytelling game for Teenagers With Attitude!

A few weeks back, I wrote into one of my favorite podcasts, Teenagers With Attitude. It's a wonderful weekly Power Rangers recap podcast, which some people may recognize as one of the inspirations for You Activated My Podcast!. I wrote in because I'd finally made good on a promise that I thought I had made a year ago-- turns out, I'd written to them nearly two years ago to the day, commenting on the announcement of Rita Repulsa's wardrobe for the then-upcoming Power Rangers reboot movie. At the end of my email way back when, I'd mentioned that I was working up a since-abandoned role-playing game called "SPEEDPUNKS", based on a since-abandoned inside joke in the show. 

"SPEEDPUNKS", which was going to be a Rangers-inspired mess of kicking and driving and monsters and rolling far more dice than can be held in two hands, was put on hold after a time as the Power Rangers Hyperforce RPG and Hyper RPG Twitch streams were announced last year. It didn't seem to me that there was really a need for two Power Rangers role-playing games to exist in the world at one time.

Then about a month ago I was going through some old files, and realized that that was fucking bullshit, and I could do whatever I wanted. And I'll be damned if these weird folks didn't deserve a game that represented their (in their words) unique brand of bullshit. So I made one, and sent it to them, and I'm really proud of it. 

The game is aptly titled "Teenagers With Attitude", and it's a pseudo-role-playing, story-telling game for 3-6 players, in which you collaboratively create and tell a new episode of Power Rangers. You can listen to the podcast episode where they talk about it here, and download the 3-page PDF of the rules here. While it does help to be a fan of the podcast before playing the game, it should be fun even if you're just a fan of Mighty Morphin'. 

I hope you enjoy! Please go listen to the podcast, and may the Power protect you, always. 

Experimenting with Instagram Story RPGs

Over the last few days, I've been experimenting with using the new-ish Poll and Type features in Instagram Stories to create a loose choose-your-own-adventure format story. The story was called "VOID COUPON // CYBERPUNK JANITOR", and if you're on a mobile device, you can see it in the highlighted stories here: https://instagram.com/tylerdotgames

The story centered around a character named Void Coupon, whose only skills in life are being a Cyberpunk and being a Janitor. As the story progressed, Void would reach a point where the audience could vote on which aspect they should take action with: Cyberpunk or Janitor. I'd then write the next chunk of the story with the winning aspect in mind. Here's a small sampling of what some of those turning points looked like:

For the most part, I think the experiment paid off really well! I got lots of good feedback from my friends who read it, and maintained a fairly consistent reader base throughout the story. With a little more prep next time, I'm excited to come back to this idea in the future. 

Pros: Instant feedback, fun surprises, and an excuse to write a cyberpunk game for my friends. It's a great way to force myself to write something relatively interesting every day. 

Cons: Had to write something new and interesting each day, which apparently I’m not accustomed to yet. We’ll get there. Also, “Cyberpunk” didn’t quite fit in the allotted space for polls, so I shortened it to “cybrpunk”. For future reference: Instagram Polls have eight-character lines.

It also provided a great excuse to release a micro-RPG I've written called CYBERPUNK DAY JOB. The is game based in the same world as the Cyberpunk Janitor story, and fits on a single 8.5-by-11-inch page. You can read about it and download the free PDF here:

One-Shot Games in Long Campaigns

Recently I had the privilege of running a Monster of the Week one-shot for my partner Lauren and co-host Jimmy, and it had me thinking about the nature of the quick "one-shot" gaming sessions, and their place in the role-playing community. 

While role-playing has come to the fore in the last few years, thanks to media paragons like Critical Role or The Adventure Zone, it's remains difficult to really bring new fans into the fold. Take, for example, one of my favorite podcasts Friends at the Table, which I've been trying to get Lauren into for over a year now. Because the show has been going on for years now, the emotional beats rely on at least being generally aware of the history of the characters (some of which have been a part of the story for years).

The hosts do a good job ensuring that enough of the relevant plot points are known even to new listeners, but there's something missing there when you just hop in mid-story. Not to mention each episode is at least an hour/hour-and-a-half long, which is reasonably restrictive for a podcast where you're coming into what's effectively the middle of a years-long conversation. This is similar to the reason I haven't truly started watching Critical Role on a regular basis-- why am I going to settle into watching a 4-hour video, just for it to be mostly in-jokes that I don't get?

Conversely, we run into the opposite issues with media focus on one-shot games. While it's easier to see the start and end of the story, getting the "in" on the in-jokes or character arcs, the brevity restricts how close we can become to the players and their characters. While the lows of a one-shot adventure are much higher, the highs are much lower. You see this in podcasts like Party of One, the latest mini-arcs of The Adventure Zone, or the aptly-named One Shot Podcast. While moment-for-moment these pieces give a decent overview of a game's mechanics, and all are produced to a level of quality that deserves attention, they lose the emotional impact provided by longer-running campaigns.

For example, things like player banter, character deaths, or plot resolution tend to have more weight behind them when you are given the time to really flesh out the characters, the world, and the relationships. The same is true while actually playing the game. Longer campaigns, while more difficult to start and maintain, provide more opportunities for moments of genuine celebration or mourning. There seems to be an inverse relationship between length of a campaign and its lasting emotional impact, and if there's a sweet spot somewhere between the two, I don't know that I've found it yet. 

So, back to the game I ran the other night: as a group, we fell into what seems like a decent compromise between campaign length and emotional depth. For the last few sessions of Monster of the Week, Lauren has been running a larger adventure for Jimmy and myself, which had just wrapped up for the RPG equivalent of a mid-season hiatus. We decided that we wanted to play something, but didn't want to go through the trouble of establishing whole new characters and a new universe to romp around in. We wanted to know what we were dealing with off the jump, and make it mean something. 

We decided to keep the universe of Lauren's original campaign (which, due to a good roll and a few poor choices, we have coined "The Agents of DIPSHIT (Department for Internal and Public Safety and Health: Inspect Taskforce)"), and Jimmy continued to play his current character Deke, the over-paranoid conspiracy theorist. Rather than continuing the current story, we reverted to a flashback, exploring some more of Deke's earlier life and time with his mentor, a character named "Sunshine" that Lauren rolled up on the fly. 

Thanks to making it a flashback, we were able to do a lot of things that ultimately didn't affect the world at large (Guy Fieri is a Flavor Vampire, for instance), but allowed us as a group to set up some fun things that happened in our regular game. For instance, Jimmy failing a big magic roll at the end gave me a space to introduce my main character, the ghost of a K-Pop star named Donny Spektre. 

The whole thing only took about three hours of total playtime, and by the end of it we all felt pretty good about our contribution (while some of it was admittedly just silliness for silliness' sake). 

Perhaps there's something there, running one-shots in a single Marvel Cinematic-style connected universe? What do you think? Are there any podcasts or video streams that do this that I should get into? Should we make one together? Let me know. 

BlogTyler Robertson
Hacking together a Batman RPG

One of the things that many of us realize after growing up playing role-playing games is this: we’ve grown up. We have job(s), obligations, bills, significant others, and so on. We get home and we’re tired, and there are dishes to do.

But we still want to play games. 

For some people, keeping a role-playing group together is very much a part of their lives that they’ve made room for. My partner and I recently joined in on a friend’s Dungeons & Dragons group, and the DM explained that she was running three games because it was a form of therapy for her (which is a thing that I’d love to write about at a later date). For some people, that really works, and I love that. 

The problem is that I’m not one of those people. I get home and I cook dinner and do the dishes and maybe get in some laundry if I’m lucky, and then just about all I have energy for is watching The Chase on Netflix (I don’t even have energy for new shows some days). This pattern repeats until the weekend, when we occasionally get in a game of Pathfinder, provided our group (of adults in similar situations) is available. What I want, what I feel I need, is something that scratches the tabletop itch, but that my partner and I can put together on any evening, without a lot of prep, and play just the two of us.

Trying to find a solution to this, I came across Jeff Stormer’s fantastic podcast Party of One. Stormer, also the co-host of All My Fantasy Children, is an avid role-playing game enthusiast and writer, and the Party of One podcast explores games that require only one player and one (or fewer) game runner. Together with a guest, Stormer explores games that were built for two players, or works to hack a game into a two-player setting. The show, in addition to being entertaining (and relatively short for an actual-play podcast), is an informative look at what a tabletop role-playing game actually is at its core. 

For the show’s 100th episode, Jeff’s friend and “Writer of Adventure” Jared Axelrod ran a Powered by the Apocalypse hack that she’d written for the occasion. Rather than being a focus on the end times or a fantasy romp (both of which have featured prominently in older episodes with PbtA games), Jared turned the attention to Jeff’s favorite super hero: Superman.

For the two of you who might be reading this and aren’t familiar with Powered by the Apocalypse games, they are a loose family of tabletop role-playing games that share a common set of simple rules. Essentially: players have certain “moves” that only they can do. When they do them, they roll two six-sided dice (and typically add a number from their character sheet). A result of 10 or more is a success, 7 to 9 is a mixed success (you do the thing, but a thing is done to you), and a 6 or less is a failure. 

And that’s pretty much it. While the rest of us might be sitting around trying to calculate a spell-save DC (or THAC0, or what have you), PbtA games offer a decently simple set of mechanical expectations. The key here is that each design has to move the story forward— failing a roll does not, and should not, equate to ceasing action. 

To help foster that kind of story-first game feel, most PbtA games also contain a set of principles for the Game Runner to follow, which outline in simple terms what the person running the game should look to do. This both helps curb “evil” DMs, and encourage newer DMs to take full advantage of what their role entails. A few of my favorite principles, as an example:

  • Draw maps, leave blanks
  • Ask questions and use the answers
  • Be a fan of the characters

That last one lends itself particularly well to a super-heroic setting, because it’s pretty likely that everyone involved is already a fan of the character. Nobody wants to see the good guy lose in the end, even if normally the DM would slaughter a full adventuring party without batting an eye. Baked into the PbtA system is not only something that is mechanically flexible, but invites everyone involved to help the character just feel plain cool.

So now my problem is that I don’t much like Superman. 

By now, you’ve gone back and re-read the title and know that I’m not great at suspense. Of course we decided on making a Batman game. 

Other than simply liking him the best, we picked the Dark Knight for a handful of reasons. For starters, Batman encompasses something like four separate archetypes: The brawler, the ninja, the world’s greatest detective, and the billionaire playboy. In terms of gameplay, this provides the player and narrator with a lot of unique storytelling opportunities, and can quickly vacillate between them. The fiction supports this as well, with Batman’s adventures ranging from inter-dimensional romps to corporate intrigue, and everything in-between. Rather than needing one player to play four characters (another solo adventure strategy I’ve heard of), that person’s single character can feasibly see the possibilities that would otherwise be reserved for a full party. 

Selfishly, this versatility also allows me to improv a bit in our games, which I enjoy as a narrator. In Batman’s world, nothing is unheard of, and nothing is too weird. One day he can be fighting crime in Gotham, the next he’ll be a sheriff in the Old West, and the next still he’s helping take down Darkseid in another dimension. Throughout them all, he’s still Batman, and that gives us a lot of freedom here.

Once we decided that we wanted a Batman game that used the Powered by the Apocalypse engine, I started looking for a game to hack. There are stacks and stacks of PbtA games out there, at least one for each genre, and this may have been the hardest part of the process. Many of the first games I considered seemed to adhere really well to a specific part of Batman:

  • Spirit of ‘77 fits the whimsy and “BAM!” “BIFF!” of Batman ‘66
  • The Veil fits the sci-fi edge of Batman Beyond, or the latest Nolan films
  • Masks is literally a game about superheroes 

Then I read The Sprawl, which is what I’ve chosen to hack for this game. The Sprawl is, ostensibly, a game about a city: a dark, hazy, neon-lit city. Fueled by the slow oozing passage of cred, and meat, and bullets. It’s my favorite kind of cyberpunk, and with a bit of tweaking, can reflect Gotham in every period: The Art Deco, neo-Bauhaus movement of the Animated Series, the dark gritty underbelly of the Nolan trilogy, and the weird, boundless oddity of Burton and Schumacher.

The Sprawl fixes one of the conversations that I feared the most: “So which Batman do you want to play as?” And it fixes it in a wonderful and weird way: it allows me to say, “It doesn’t matter who you are, you’re in Gotham.

Using the Sprawl as a starting place, I combined moves from a bunch of different roles and brought them together. Initially, I split them into two parts, “Batman”, and “Bruce Wayne”. The thinking there being that I wanted to explore the duality of Batman, and invite the player to use Batman moves while acting as Bruce Wayne, and vice versa. This resulted in there not being very many interesting Bruce Wayne moves, so I’ve replaced that idea with the “I’m Batman” move up top:

Batman Moves

I’m Batman
When donning or doffing your Batman costume, roll Cool. On a 7+, pick 1 from the list below. On a 10+, pick 1 more:

  • Your costume change is concealed from those who might be watching
  • Alfred has something ready for you. Gain [gear] if donning costume, gain [intel] if doffing.
  • It goes quickly, and everything works as it should
  • Your ride is here, sir. +1 forward to The Bat-Signal or Student of Shadows

On a miss, the Narrator may make a move. This is up to them, but can include someone noticing, advancing a clock, or taking up time. 

When donning the Batsuit, gain access to the cyberware that you have added to it. When doffing then Batsuit, lose that access. This does not apply to access to vehicles like the Batmobile.

 

Nice Car
When you’re driving the Batmobile in a high-pressure situation, roll Edge. 10+: gain 3 hold, 7-9: gain 1 hold. You may spend hold one-for-one to do one of the following:

  • Avoid one external danger (a rocket, a burst of gunfire, a collision, etc)
  • Escape one pursuing vehicle
  • Maintain control of the vehicle
  • Impress, dismay or frighten someone

 

Nice... Jet? Plane? Boat?
You have two additional vehicles (build each using the custom vehicle rules from the Driver playbook). 

 

To the Bat-Computer
When you gather evidence and take it to the Batcave for examination, gain [intel] and roll research with Edge instead of Mind

 

Eye for Detail
You are a master at tailing people and stalking out locations. When you perform surveillance on a person or a place, gain [intel] and roll assess.

 

On the Trail
When you want to find someone or something, name your target. When you gain [intel], you may note that it concerns your target. When you spend three such [intel], the MC will describe where your target is; you say how the clues led you to that knowledge and how you have your target or its defenses at a disadvantage.

 

Covert entry
When you attempt to infiltrate a secure area alone, roll Cool. 10+: gain 3 hold, 7-9: gain 1 hold. As the MC describes the infiltration and the security measures you must overcome, you may spend hold one-for-one to describe how you overcome the obstacle and:

  • Bypass a security system or guard
  • Disable a security system you have bypassed
  • Disable a guard
  • Escape notice

 

Psychological warfare 
When you attempt to influence the morale of your enemies by leaving evidence of violence while remaining undetected, roll Edge.

7+: your enemies are impressed and overly cautious, scare and demoralized, or angry and careless (MC’s choice).
10+: You choose. 

 

Stealth Operative
You have an intuitive sense of how to blend in with the rhythms of a secure area and can take actions that make its security forces feel at ease. When you assess while undetected and roll a 12+, you may spend one hold to lower the Action Clock by one segment.

 

Student of Shadows
When shit hits the fan and you have to get out, name your escape route and roll Cool.

10+: Sweet, you’re gone
7-9: You can go or stay, but if you go it costs you: leave something behind, or take something with you; in either case, the MC will tell you what
6-: You’re caught in a vulnerable position, half in and half out. The MC will make a move

 

The Dark Knight
When you enter a charged situation, roll Style. 10+: gain 2 hold, 7-9: gain 1 hold. Spend hold one-for-one to make eye contact with an NPC present, who freezes or flinches and can’t act until you break it off. Roll 6-: your enemies identify you immediately as their foremost threat.

 

Trained Eye
When you evaluate a person, vehicle, drone or gang, roll Cool.

7+: ask the target “How are you vulnerable to me?” Take +1 forward when acting on the answer
10+: gain 1 ongoing when acting against that target

 

The Brave and the Bold 
Once per mission you may introduce a new Contact. Name the contact, say what they do, then roll Style.

10+: You’ve worked with the contact before; they have what you need. Write them down as a Contact.
7-9: You’ve never met them before, they’re an unknown quantity.
6-: You know them all right. Tell the MC why they dislike you.

After you’ve rolled, describe how you contact them. The MC will ask some questions.

 

World’s Greatest Detective
You’re a master of making connections between seemingly unrelated events. At the start of a mission, roll Edge.

10+: gain 3 hold
7-9: gain 1 hold

As you put everything together during the mission, spend 1 hold at any time to ask a question from the research list. 

 

Face
You specialize in infiltrating by appearing to belong in places you do not, hiding in plain sight. During your infiltration, you will have opportunity to see or overhear information which might be relevant later. After you have spent all your covert entry hold infiltrating a secure area through charm and social graces, gain [intel]. 

 

Corporate secrets
When you research a corporation, you may always ask a follow up question. On a 10+, take an additional [intel].

 

Blend in
When you’re about to be caught somewhere you shouldn’t be, but look and act like you belong there, roll Cool. 

10+: no one thinks twice about your presence until you do something to attract attention
7-9: you’ll be fine as long as you leave right now, but if you do anything else, your presence will arouse suspicion

 

What’s your superpower, again?
You’re rich. Choose another piece of cyberware to add to your Batsuit at character creation or downtime.

 

Cyberware

Rules-wise this works very similarly to the book, but rather than cyberware being built into the person themselves, it’s built into the bat-suit. As such, this means that you can’t use it without the suit. 

Choose one to start with: 

  • Cybereyes
  • Cyber ears
  • Cybercoms
  • Augmented Strength
  • Armor plating

 

Gear

Like the best boy scout, Batman always comes prepared with some gear:

  • Batarangs (2 damage hand +numerous +quick)
  • Smoke bombs (s-harm near area reload gas)
  • Batsuit (2-armor upgradeable)

 

I’ve also opted to make minor changes to Basic Moves that don’t quite fit in the Batman world. For example, “Getting the job.” Batman doesn’t get jobs, even mild-mannered Bruce Wayne doesn’t get jobs. Batman gets called in:

The Bat-Signal
When called into action, roll Edge. 10+: choose 3 from the list below. 7-9: choose 2 from the list below.

  • Something else alerts you to the situation, gain [intel]
  • Instinctively grab the right tools and gain [gear]
  • You arrive just in time
  • The villain is identifiable
  • You arrive without attracting attention

I want to write a Batman version of the “Getting the job” move’s counterpart “Getting paid”, but I can’t find a decent way to make it work yet. It may just be something that has to come out in play, which is fine. 


Wrapping Up

How do these changes look to you? Would you do anything better/differently? Let me know! We'll be recording a podcast mini-series soon with a couple one-off adventures, as a way to playtest this and play around in The Sprawl's version of Gotham city. Stay tuned!

HacksTyler Robertson
THE REBEL FLEET & Dice-less Mechanics

Been considering lately how little I enjoy d20 mechanics when it comes to large-scale encounters. While rolling a d20 and adding Dexterity is a decent fit for getting your dwarven fighter across a pit trap set deep into the mine, it rings somewhat hollow when applied to commanding legions across the field of battle. 

In a Star Wars game, for example: while it is exciting to roll dice and follow standard mechanics from the perspective of a single fighter pilot, it is somewhat less exciting to play the role of a general using the same mechanics. 

As an alternative, consider the following:


The Rebel Fleet

A game for 3+ players. Requires a long hallway or open space, and a stack of standard letter-sized paper.

One player takes the role of the Narrator. The other players are ace pilots in The Rebel Fleet. The Rebel Fleet can be any aerial force– be it World War II, outer space, or an alternate universe where lizardfolk ride tamed pteradons.

To create your vehicles (effectively your characters), each player should use one piece of paper to make a paper airplane. There are no rules for the shape that this plane must take, only that it must consist of a single piece of paper (8.5" x 11" if you’re American, A4 if otherwise). As an optional benefit, you can use a staple or paperclip to weigh down the nose of your craft.

The Narrator sets the scene. First, they should make one paper airplane for each major aircraft in the enemy fleet. For small squads, make one plane to represent a group of 5 or 10 (so you don’t waste all that paper). While making their planes, the Narrator describes the powerful regime that has ruined everything, which the Rebel Fleet is fighting against. Describe the battle that is taking place, and the broad strokes of the rebel fleet’s goals. Then, they ask what the players would like to do to achieve that goal.

Depending on how the players respond, the Narrator can engage the players in a series of challenges, using any and all relevant paper planes. These challenges can take place in two forms, or a combination/derivation of the two:

Race: The players and Narrator all stand on the same side of the space, and at the same time throw their planes in the same direction. The plane that makes it the farthest is the victor. This is used to represent outmaneuvering other planes, making it to destinations quickly, or rapidly closing on a target.

Battle: The players stand on the opposite side of the space from the Narrator, and then simultaneously the two sides throw their planes at each other. Make note of the planes that collide. If a plane crashes its nose into an enemy ship, it deals damage to it. Most enemy ships can only withstand one damage, while named ships (the players, or important enemies) can withstand five. Repeat until all named enemy ships are defeated, or until the players are defeated, or until the players opt to try a different approach.

At the end of each challenge, take a moment to discuss as a group how that maneuver took place, and describe how it moves the battle along. Continue until the players have achieved the goal stated at the beginning of the game.

 

GamesTyler Robertson
The 15-Step Powered by the Apocalypse Hack

Recently, I’ve put a hold on a few personal projects— partially due to life events, though mostly due to good, old-fashioned New Year’s self-doubt and writer’s block. I’ve realized over the last few months that I kept trying to perfect the system of the games I was making (more on those forthcoming) without paying enough mind to how much fun I was having while making them. If I didn’t enjoy making the game, I realized, I probably won’t have much fun playing it. So, fair warning, the next few things I post will probably be broken or buggy or what-have-you, but I’m okay with that for now. 

As a writing exercise to break myself out of that slump, I wanted to jot down a simple system for everyone’s favorite hack: the Powered by the Apocalypse game. Several of my favorite games right now are PbtA hacks (The Sprawl and Monster of the Week, for example), and while each one can be radically different in tone and scope, the core principles remain basically the same. Here, in 15 steps or less, I’ll walk you through the basics of designing a hack of your own:

  1. Pick a theme, and stick to it: Westerns, Sci-Fi, Gym Class, Anthropomorphized Turtles, whatever
  2. Write down one thing that players in that world can’t live without. Things like “health” or “oxygen” or “pizza” or “self-respect”.
  3. Write down five attributes that fit into the template. They can be called whatever, but fit the following general theme:
    1. What keeps the player’s “health” and helps them take it away from others in a very direct way. Examples: Strength, Meat, Brawn, Muscle, Grit
    2. What helps the player avoid danger, and create danger for others in an indirect way. Examples: Dexterity, Swift, Cool
    3. What helps the player know things that can be learned through traditional means. Examples: Intelligence, Savvy, Smarts, Edge
    4. What helps the player interact with other characters. Examples: Charisma, Style, Moxy
    5. What helps the character interact with the thing that embodies the spirit of the theme that you picked in step one. Examples: Weird, Wyrd, Synth, Qi, Spirit
  4. Players get bonuses to those attributes between -1 and +3. Usually the spread looks about like this at the start: -1 / 0 / 0 / +1 / +2
  5. Write some basic moves, using the standard PbtA system of rolling two six-sided dice, and adding the relevant attribute. Remember, a total of 6 or less is typically failure (though you can gain 1 "experience"), a 7-9 is a mixed success, and a 10+ is a no-questions-asked absolute success. Again, these moves can be whatever you need for your game. Typically, they will follow along this general theme:
    1. Attempt to take “health” from another character, roll + “Strength”. 10+ you do it, and maybe a little extra. 7-9 you do it, but “health” is taken from you as well. 6- “health” is only taken from you.
    2. Attempt to find things out about the world, roll + “Intelligence”. 10+ ask 3 questions from the list. 7-9 ask two. 6- answer a question about your character, in-character. (Write down a list of 5 questions that a normal person from your theme would ask if the line at Starbucks is taking too long.)
    3. Withstanding bad circumstances, roll + relevant attribute (decided by narrator). 10+ you did it, 7-9 you did it but have a lingering cost (usually cosmetic), 6- you don’t do it, and you suffer a mechanical cost (such as subtracting one from a relevant attribute).
    4. Help or hinder another character. 7+ they take +1 or -2 forward, your choice. 7-9 you expose yourself to danger. 
    5. Convince someone else to do something they don’t want to do. 10+ they do it, 7-9 they do it in exchange for something, 6- it’s up to them. 
  6. Copy and reword those moves as necessary, changing the specifics. Usually, this means changing the “select one” lists from gaining a positive thing to avoiding a negative thing. For example, create a copy of move 2 where instead of picking questions that get answers, you pick how you avoid detection, and don’t get screwed over. 
  7. Write down five-ish unique names for character roles. What are there only ONE of in this world? For example, in a western game, there is typically only one Sheriff. 
  8. For each job, pick the attribute that they best reflect. 
  9. For each job, rewrite the two or three of the basic moves, keeping the job’s main attribute in mind. Make it easy to be good at the thing they’re good at. For example, the Gunslinger may make moves similar to taking health, but rolls a dexterity attribute instead, and opt to take no damage on a success. The Documentary Filmmaker may have a move that lets them ask one extra question when following a story. These moves are the job’s standard moves. 
  10. Write four more moves for each job. Make them weird, and don’t worry about game balance. Make a move that makes the job look like the most that job can be. These are the advanced moves, available only after the character has reached a certain amount of experience (usually between 5 and 10 points). 
  11. Write ten single-sentence bad things that happen all the time in this world. Be general. Things like “the shit hits the fan”, “you have a bad day”, “your least favorite song comes on the radio”. These are the basis for your moves as the narrator. Keep them handy for reference.
  12. Create obstacles for the players to come across. These can be traps, environments, or characters. Write down a list of ways that these things can negatively affect the players if they fail a roll. Things like: 
    1. deal a little damage to the player’s “health”
    2. deal a lot of damage to the player’s “health”
    3. enact one of the bad things from step 11
    4. make the player vulnerable to another obstacle
    5. inhibit the player from using an item
    6. prevent the player from using an ability of theirs. 
      Rank the difficult of these obstacles: easy, medium, difficult, boss. Easy obstacles select only one of the items from the list, medium items select two, and so on.
  13. Have each player write down the ways in which their character is connected to two other characters. Call these something appropriate to the theme, such as “bonds”, “owed favors”, or “beliefs”. At the end of a session, if a player acted especially well on these connections (ie, good role-playing), grant them experience. 
  14. State a thing that the players should want to accomplish: save the world, save the girl, save some money, build a barn, what-have-you. Place obstacles in between the players and those goals.
  15. Ask “what do you do?”

Alright, there it is. Not perfect, certainly not complete by any means, but there you have it. Let’s try it out:

Let’s say that I want to make a game based on Downton Abbey. I only need this to be a one-off, so I’m going to come up with attributes, basic moves, roles, and two standard moves for each role. 

In this world, the thing that players can’t live without is STATUS, which each character begins with 6 of. Their five attributes are:

  • RHETORIC
  • WIT
  • EDUCATION
  • FASHION
  • SNOBBERY

Players may assign the following numbers to their attributes in any order: -1 / 0 / 0 / +1 / +2

Basic Moves:

  • Comment. Roll +RHETORIC. 10+ target loses 1 STATUS. 7-9 you and target each lose 1 STATUS. 6- you lose 1 STATUS. 
  • Query. Roll +EDUCATION. 10+ ask 3 from list below. 7-9 ask 2. 6- reveal a secret. Take +1 forward when acting on the answers.
    • Who has the most STATUS here?
    • What is the history of this place?
    • What is the history of _________’s family?
    • How is ____________ vulnerable?
    • What is ____________ hiding?
  • Excuse Yourself. Roll + Relevant Attribute (Narrator’s choice). 10+ you excuse yourself politely. 7-9 you excuse yourself, but at the expense of STATUS or an item (your choice). 6- you make things worse for yourself somehow.
  • Embolden or Embarrass. Roll +SNOBBERY. 7+ target takes +1 or -2 forward, your choice. 7-9 you become involved in the situation. 
  • Convince. Roll +FASHION. 10+ the target does what you want them to do without question. 7-9 they ask something in exchange. 6- it’s up to them.

Roles:

The COUNTESS

  • Scold. When you make a Comment, on a 10+ you may select two from the list below. 7-9, you may select one:
    • Target loses 1 more STATUS
    • You lose no STATUS
    • Target takes -2 forward
    • Another player takes +1 forward
  • Not Dead Yet. When you see a character lose STATUS due to another player’s actions, roll +SNOBBERY. 7+ gain 1 STATUS. 10+ give a character -1 forward. 6- the narrator may make you vulnerable to an uncomfortable situation.

The BUTLER

  • Ahem. When making a Comment, roll +SNOBBERY instead.
  • Keeper of the House. When using Query, also ask “Who does _______ belong to?”

The VETERAN

  • Rousing Speech. When aiding another player, on a roll of 10+ give the target +2 forward.
  • Years of Service. When excusing yourself, you may always opt to roll +SNOBBERY.

The DOCTOR

  • I was there when you were born. When you successfully embarrass a target, they take -1 ongoing against you. 
  • Medical expertise. When using Query, you may also observe the target’s physical behavior to learn about their health. Take +1 forward when acting on what you learn. 

The HEIR

  • Alluring. On a failed Convince roll, you may make it a mixed success, at the cost of a more difficult request from the target. 
  • Well-read. When making a Comment roll, you may opt to roll +EDUCATION instead. 

The setup and obstacles: your family has come into a large sum of money, and the relatives are coming over. Entertain them with dinners, tours of the town, grand celebrations, whatever you like. Most importantly: make them go away. There’s a knock at the door, what do you do?


And, there we have it. Not quite finished yet, as we need to create some Narrator moves and specifics about the obstacles, however I would need to brush up on Downtown Abbey to fill that in more completely. Things like, “introduce a new family member that no one’s heard of” or “propose marriage” would be conceivable in this setting. 

Hopefully, using just a few general rules, this has helped inspire some of you to start making the game you’ve always wanted to play. Remember: it doesn’t have to be perfect, or even all that good. You just need to have fun doing it. 

BlogTyler Robertson