Player "Commands" in RPGs: a Parsely RPG hack for Vermis and video emulation in TTRPGs

In my experimentation with Vermis I was inspired by Parsely, a pseudo-RPG that emulates a text prompt based adventure games from the early days of computer gaming, such as Zork. Parsely is not an RPG as we would think of it, though it is an interactive, imaginatively evocative game. Jared A. Sorensen, the publisher describes Parsely thusly:

Relive the glory days of floppy disks, dot-matrix printers and 128K RAM with this collection of party games inspired by the text-adventures of the 1980s.

As the parser, you’ll take on the role of a computer game with a limited vocabulary. One by one, the players will give you commands like GO NORTH, LIGHT LAMP or GET SWORD, which you’ll follow to the best of your ability. There’s no limit to the number of people that can play and no limit to the fun you’ll have. So what are you waiting for? It’s time to unplug from your computer and plug into Parsely!

If you're interested, you can try Parsely's free demo.

Let's be clear, this is Hard Mode. The idea is that if you don't say computer-style commands correctly, the Parser responds "I don't understand" and the action doesn't take effect and is wasted. In Exploration ("slow time") this will extend certain actions such as searching and possibly risk encounter rolls or the like, but in Combat ("fast time") this could be disastrous. This is to emulate a failed input in a game, meant to evoke multiple aesthetics with a bit of player-assisted buy-in for immersion. If the aesthetic is text-based, you didn't type fast or well enough. If it's point-and-click (i.e. Eye of the Beholder, Castle Grimrock, Stonekeep), you mis-clicked. If it's action RPG (i.e. a Souls-like), you fumbled the controller, didn't react fast enough, or something to that effect.

What are the commands?  When you want to act in character, use the following: 

HELP lists the system commands. Either keeping the commands written nearby or forcing players to use the HELP command may improve immersion.

Interface Commands: 

INVENTORY: View or access inventory items. This could include/require specification of LOOK INVENTORY or TAKE/GRAB {item}. You could also hold onto the player's inventory and only let them look at it when they use this command, which would be odd but interesting.

SAVE: According to Parsely, this stores the player character’s current location, inventory and status. SAVE always overwrites the previous save point. The way I play, it must take place at a Bonfire/save point. For it to accurately store inventory and status, it would require some bookkeeping, as it might be hard to remember what their status or inventory was at the time. One possible way of doing this could be to not put items on the character sheet until it is Saved, keeping it on a spare index card or something similar in the meantime. Similarly, statuses (tired, poisoned, etc.) should not be erased from the character sheet until they're cured and saved in that cured state. Crossing out but not erasing them might help. This might work for items as well, such as expended arrows, but remember that rations, torches, and magic item charges in particular are expended and do not replenish on when the game is Loaded.

LOAD/RELOAD: Loads from the save point. Only one Save is allowed, so this should be easy.

RESTART/RESET: Begin again from the start of the dungeon, with items, charges, statuses, etc. restored. I would ask "Are you sure? [Y/N]" first.

SCORE: In Parsely, players earn points for completing hidden objectives (such as KISS PRINCESS), with a maximum score of 100 upon completing a session, which gives it replay value. This isn't necessarily useful for our case, as far as I can see, but who knows?

Perception Commands

LOOK, EXAMINE, SEARCH, SMELL, LISTEN, TASTE and TOUCH. These emulate simple inputs that produce a short "boxed text" output which tells the player how they interact. In RPGs, we are descriptive and it has a huge effect on how the game plays out. How you search the room matters. You could handle this several ways, shown below in the "Command Parsing Styles" section.

Move Commands

The standard Parsely commands are ENTER, EXIT LEAVE, BACK, EAST, WEST, NORTH, SOUTH, UP and DOWN. Some areas may allow other directions, such as NORTHWEST. Players can also use GO {direction}. These are self-explanatory. They could be borderline unnecessary, or you could insist that they are used with a direction command or specified target, or they don't take effect, advancing the clock. For example: 

 

Player: LEAVE

Parser: I don't understand.

Player: LEAVE NORTH.

Parser: You exit through the North passage, closing the banded iron door behind you.

You could introduce more specific commands such as RUN, SNEAK, CLIMB, CRAWL, etc. Making these commands rather than allowing a player to use GO and then specify how they do so seems too particular to me, but could reinforce the theme or streamline things if players are good at memorizing a larger array of commands.

Interaction Commands

TAKE/GET, PUT, DROP, TALK, LIGHT, WEAR, USE, ATTACK.

You could use common ATTACK commands like SLASH/STAB/SMASH/SHOOT, or you could insist on ATTACK {enemy} WITH {weapon}. You could also initiate with the ATTACK command and then have the player answer the question "How do you ATTACK the {enemy}?".

Command Parsing Styles

The command gimmick can be done in several ways. 

1. "How do you ___ the ___?":  

The player starts with the command, then you use clarifying questions and plain language to build the narrative and determine different outcomes based on the specific desires of the player. There is no need to insist on talking around in circles using commands, which will destroy the novelty of using commands quickly.

Player: LOOK DOOR

Parser: How do you look at the door?

Player: I approach it quietly and put my eye to the keyhole.

versus:

Player: LOOK DOOR

Parser: How do you look at the door?

Player: I check around the lock and handle to see if anything is out of place or if it's trapped.

 

Stating the initial command correctly, however, could still mean the difference between success and an "I don't understand" response which advances time or results in a consequence. For example:

Player: I check the door for signs of entry.

Parser: I don't understand. (Advances exploration timer by 1 minute and checks for encounters)

Player: Oh, LOOK DOOR.

Parser: How do you look at the door?

Player: I check the door for signs of entry.

Parser: You see that the door is dust-covered and rusted shut, and has clearly been disused for years.

Player: Screw you, computer.

Parser: I don't understand.

This is a language of roleplaying rather than a reinvention of roleplaying itself. It reinforces that a player must think within bounds. They have a limited range of ways in which they can interact in the world, and when they do they must clearly name what they are doing and who/what they are doing it to. It might prompt them to seek more information in an area rather than just trying stuff- if they only get the intro blurb to an area, they're going to want to listen, look, or touch to see what else there is to it. Similar to video games, it might also draw stronger attention to the remarkable features; it becomes abundantly clear that a candelabra, desk, and wall hanging are interactive items, and seeing how they are meant to be interacted with becomes meaningful. The command-style of interaction could also make play quicker, as a command is somewhat more like a boardgame-style action than a narrative one, doable in 1-2 word chunks if desired. This becomes particularly helpful for my Vermis gameplay loop of die/respawn/re-enter/do better/probably die again. You already know what's there and how to interact with it, so you summarize that interaction in a 2-word command and move on.

2. Boxed text:

Using a command will give a predetermined response. This is what Parsely is.

Player: LISTEN

Parser: The room is quiet, with only the sound of distant drops of water falling from someway down the hall. You still your body and hold your breath, and subtle sounds of movement from the next room make themselves known. 

This will give a feel of a Choose Your Own Adventure book rather than an RPG, but if that's what you're looking for then go ahead. In Parsely the interactivity comes from bringing Item A to Location B to change the way you interact with Location B after your initial information-gathering interactions. It is fun because it's confusing, kind of repetitious, incredibly limited, but challenges you to find the right combination. It's not the type of "roleplaying" (if you could call it that) that I would want to do more than once in a blue moon. Even so, it's fun to try to find all the little easter eggs in the comparatively simple adventures within it. If you want to play in this way, keep in mind it will take a long time and players may have lots of questions that can't be answered. They have to infer or guess the correct commands.

In the above example, the Player didn't specify "I stand still and hold my breath" but the Parser used the narrative style to give that image and information. A Player's intention of listening at a door might not be compatible, because the boxed text only describes the water and the room sound, not what it sounds like in different areas. It might yield further useful information, such as the player saying SEARCH WATER to find the source, or it might not. There might not be any ability to "LISTEN DOOR" versus "LISTEN WATER" or even "LISTEN NORTH" versus "LISTEN SOUTH" if there are multiple doors. 

With this type of extreme rigidity and linearity, die rolls will also likely be limited to combat and ability usage. It's not complex and it's not roleplaying, but could be fun for a while. The RPG elements will mostly come from the Parser taking whatever material they are running and using their own judgment (behind the scenes) as to what responses that material would require and translating that into boxed text (or reading it, if it's that kind of text-heavy adventure). Vermis, in this case, could be used either way; it has prewritten, descriptive material that could be read verbatim, or could be interpreted in a more fill-in-the-gaps manner.

3. Boxed text with limited variable outcomes:

This is what most of us think of when we consider rudimentary or "beginner" roleplaying. Information is read or interpreted strictly and literally, and if it includes interactivity it will not give much of a range of responses or opportunities for creativity. It differs from the above style, which Parsely uses, in that there may be multiple ways to interact with the main elements of the area, while not having as much open-ended nuance as pure roleplaying. If OSR is "rulings not rules", well, this is going to be more or less "readings and rolls, not rulings". 

This approach is in between the other two because it is rigid, but affected by die rolls. The Player tells the Parser what they want to do with a command, not a descriptive action, and the Parser either tells them what happens or calls for a die roll to determine the degree of success, which has bounds based on what has been predetermined to be within the space. A very simple difficulty check system is well-suited to this, with minimal calculations and quick resolution. Because you are changing things from the strictly written boxed text after an action is taken, notes should be kept (especially strict time records) or you may forget important details. It should also not create a "soft lock" or unsolvable situation if something fails, unless you want to go to a Blue Screen Of Death type fail-state and restart. This could be better or worse than playing with strict boxed text because chance could derail otherwise correct actions.