Tuesday, November 6, 2018

Streamlined Combat for OpenD6 Solo Gamebooks

I’m developing a solitaire D6 Space gamebook, a programmed adventure in the spirit of the numerous solo “tutorial” scenarios I’ve written over the years and have enjoyed in other games. I’m having fun with it, incorporating science fiction tropes I admire, going off to explore entertaining tangents, offering a few seemingly outrageous options, and (hopefully) providing an engaging adventure with plenty of meaningful player choices. Along the way, however, I’ve discovered a particular drawback to using OpenD6 in this programmed solo gamebook format: the combat system isn’t really conducive to providing players with an adversary’s stats and letting them resolve the fight on their own...a staple of many gamebooks and solitaire adventures. It’s not as much a factor in the scenario I’m writing now – it’s not particularly combat-heavy, though it contains a few fights at pivotal moments – but it’s given me cause to think about and develop a better system for more combat-oriented solo gamebooks using OpenD6.

Other programmed solo gamebooks rely on the relative simplicity of combat mechanics. I’m most familiar with two in particular I’ll reference – BSolo Ghost of Lion Castle for B/X Dungeons & Dragons and the Fighting Fantasy gamebooks – though others exist. Each relies on the related game system to resolve combat. Ghost of Lion Castle assumes players know how to run D&D combat; it presents an adversary’s game stats and expects the player will make initiative, attack, and damage rolls for both their character and the foe, tracking hit points until one meets his doom. The Fighting Fantasy gamebooks provide a very basic rules system relying on skill and stamina stats; in combat players roll two dice for their foe and two for themselves, adding each one’s skill score, the highest roller inflicting two points of damage (subtracted from stamina) on the other. I find the Fighting Fantasy method more elegant than the D&D one simply because combat between the two parties is simultaneous and easy to simulate with two pairs of differently colored dice. D&D clings to the established game protocols of initiative, to hit rolls, armor class comparison, and damage dice alternately between player and adversary. D&D’s system, of course, can also account for other actions during combat, such as spellcasting. Even the amazing Sorcery! books (of Fighting Fantasy gamebook fame) included the option to use magic memorized from a spell book, giving the reader a choice of three-letter-coded spells to use, some of which were inappropriate to the situation and others were outright incorrect, with only one proving effective.

D&D and Fighting Fantasy gamebooks have a fairly self-contained, self-run combat system between two adversaries, the player and a foe. Sure, the player is on the honor system not to fudge rolls and to run the combat encounter properly, but it means the gamebook writer doesn’t have to explain and adjudicate every step in each round of combat. Fights in OpenD6, however, employ more granular mechanics, more on par with the intricacies of D&D, though at times seemingly more involved. The process still entails lots of die-rolling and sum comparison in an alternating fashion. The player makes the attack roll against a difficulty rating and, if it hits, rolls damage, then rolls the target’s Strength (plus any armor bonuses) and compares the two to determine incremental wound results...which further limit the foe’s abilities. Then the player carries out a similar process on behalf of the adversary. Factoring in dodge attempts, character points, and multiple actions in a round further complicates the procedure both technically and morally: does the player allow her foe to dodge, make multiple attacks, or use character point to boost their score? (If one follows the Fighting Fantasy model such options remain open only to players, who can “test their luck” to increase damage to foes or reduce damage on themselves...and I agree with giving players a more heroic advantage.)

Right now in my current OpenD6 space scenario I’m handling combat through numerous programmed entries (a symptom of my having written numerous solitaire tutorial adventures meant to teach rules and introduce setting elements). The initial entry has the character making a combat roll, going to one entry if it fails and another if it succeeds...where she rolls damage and compares it to the Strength value I’ve assigned to the adversary for this particular instance. Then the character may try dodging the opponent’s attack, with failure inflicting some degree of damage (with the requisite comparison of damage result to Strength roll). Combat doesn’t last very long under these circumstances, in part because I create characters that can hold their own against goons in a fight and because I have only limited patience for programming the various outcomes. The adventure itself has only a handful of pivotal fights, with other momentary uses of force more easily resolved (usually with hits knocking out an opponent and misses leading to other consequences). Still, it’s not terribly elegant or efficient, certainly not good mechanics for a more combat-heavy scenario.

So I started considering how I could streamline the OpenD6 system for a scenario with more combat encounters, simplifying it while still incorporating the game’s core mechanics. I wanted to keep the reference to skill, weapon damage, and Strength die codes, but incorporate the simultaneous combat resolution I like from the Fighting Fantasy gamebooks. In a combat round, the player rolls their character’s combat skill dice and rolls the adversary’s attack skill dice, too. The highest total wins the round (with the player having the option to use up to three character points to influence their total) and inflicts damage on the other party. Rather than requiring an additional roll of weapon damage dice compared to Strength dice (plus armor or cover, where applicable), I have the die codes for each of those distilled to basic numbers (dropping any +1 or +2 indicating “pips”). The difference between the weapon die code number minus the Strength die code represents the number of dice the target loses from subsequent combat rolls, with a minimum of –1D in cases where the difference favors the target. When damage reduces one combatant’s skill to zero, the other one wins the fight.

Here’s an example. The character from my solo space adventure, Vanno del Rask, is in a fistfight with an agent from a crime syndicate who wants to eliminate him. Vanno’s brawling skill is 5D and his Strength is 3D (used in this case for both “weapon” damage and resisting damage). His opponent has a brawling skill of 4D and a Strength of 3D. Neither one has armor. Each round the player rolls 5D for her attack and 4D for her opponent’s. The first round the results are 16 for Vanno and 10 for his foe, so Vanno hits; however, subtracting the die codes for the target’s Strength from Vanno’s damage gives a result of zero...so Vanno inflicts the minimum one point of damage, forcing his opponent to attack at –1D on subsequent turns.

This system still allows for the use of character points to boost a final combat skill roll and, for daring characters, one can still use the hero point rules to double combat die codes before rolling (though this, without multiple actions as in regular games, might seem excessive). Although it distills the damage mechanics to rely on die code values rather than random rolls, this still takes into account weapon power and the target’s Strength and armor.

This method also allows me to abbreviate an adversary’s skill listing in the text to only those essential stats. For instance, a Fighting Fantasy adversary’s stats might look something like this:


An OpenD6 opponent’s stats, even in short “paragraph” stat format, would include all relevant information, including skill die codes, equipment (with damage die codes), and any character points. With the very basic, simultaneous mechanics I have in mind, however, the stat listing only provides the necessary information required for combat:

Minotaur: melee 5D (damage 4D), Strength 4D (armor +1D).

The Fighting Fantasy books also allow – when noted in the text – for characters to choose to retreat from a combat encounter, though they take damage from their adversary’s parting shot and may face other consequences. The streamlined OpenD6 combat might also benefit from giving characters this option; it’s something I don’t mind incorporating since I’m not piling on additional entries accounting for every variable in the normal combat procedure.

The system can also handle other nuances related to OpenD6. After a fight, if the character took any damage (no matter how much), consider that character “wounded” with a –1D penalty to all subsequent skill rolls (combat or otherwise) until healed. One could even factor in combat against a group (either melee or ranged combat); the adversaries still get one roll, but adding a bonus of half the combat die code per additional participant (so a group of four troopers with firearms skill of 4D would roll 4D+6...half the skill code of 4D, so +2, for each additional trooper).

These combat mechanics do not take into account situations where one side or the other has a “free shot” advantage, such as surprise, ambush, sneaking, or other circumstances...instances where, in the text of a programmed adventure, I settle through basic skill rolls and options.

Granted, this kind of automated combat subroutine works better in a game centered around frequent combat encounters. While this abbreviation for the D6 System can streamline combat encounters, the rest of the system – rolling dice corresponding to die codes for skill checks – leaves lots of room for diversity of action within a programmed gamebook scenario.

I apologize if I’ve indulged in some “thinking out loud” on this subject, especially since it won’t affect my current OpenD6 space-themed project. Depending on the success of the current solo adventure gamebook and my interest in developing other OpenD6 solo projects, I might consider wandering off to write another solo gamebook – maybe returning to the pulp genre – which incorporates more combat encounters within the overall scenario. The more simplified combat mechanics presented above certainly remove some of my anxiety about programming extended fight encounters and encourage me to incorporate them around more developed story elements. Taking a more streamlined route for solitaire combat represents a transition for me. The solo tutorial scenarios I’m used to writing intend to demonstrate and impart an understanding of the full rules. Gamebooks, on the other hand, seek to provide a full adventure experience without the need to furnish overly comprehensive examples of game systems...the principle mechanic being streamlined combat resolution.