I ran a fun game of Daredevils at North Texas at the beginning of the month. I set it in 1976 in the Kolchak: The Night Stalker television series universe. I can’t take credit for how great the game was—it was the great characterization by the players of their Kolchak television series characters that made it a high point of the con for me.

But the preparation of those characters was all on me, and I pregenerated a lot of characters for them to choose from. The pregens were various sources Kolchak had used over the series. Everyone from Lila Morton (the bereaved widow from Chopper) to Charles Rolling Thunder (the aged shaman from Bad Medicine), as well as each of Carl’s colleagues at Independent News Service.

This meant a lot of character sheets and it also meant adjusting skills a lot as I attempted to make each character unique and useful to the adventure. I continued adjusting each character as I slowly went through viewing the season again—rewatching Kolchak is never a chore—and added not just stats but quotes and background.

Doing all this rewriting by hand is a recipe for disaster. So I wrote a script (Zip file, 16.8 KB) to:

• calculate each character’s calculated stats;
• handle old age for the older characters;
• verify each character’s attribute and development totals;
• keep the format of the character sheets standard.

By using a script to calculate the calculated statistics, I ensure that no character has a mistake.¹ And when I wanted to add a new calculated stat, I just had to add it to the script and re-run the script on the characters to give everyone that new calculation.

In a game like Daredevils, that’s useful, because while the rulebook lists a few official calculated statistics in the character creation section, there are also unofficial calculations scattered throughout the book. These are calculations that are technically not character stats but for all practical purposes are character stats. It’s nice to give them to the players to see.

When I decided to add the Healing Rate calculation—not technically a stat—I added its calculation to the script, and it added that line to all of the character files.

When I decided to add the optional “Luck” rule, I added Luck to the script, and it added Luck to all of the character files.

Old age is also an interesting rule in Daredevils. Newly-created Daredevils characters get more development opportunities the older they are. To offset this, really old characters have penalties applied to physical stats and, later, to mental stats. When any stat drops to zero, the character dies.² The script handles that, checking the character’s age and then reducing the appropriate attributes.³ There are a lot of older characters in the Kolchak series compared to modern series.

All of the characters I used, even Kolchak, conformed to the Daredevils character creation rules. To make it easier to use a script to generate character sheets, I also assumed that all rolls were averages. Daredevils uses an interesting combination of die rolls and point allocation for character creation. But I didn’t want characters getting new die rolls each time I ran the program. I wanted their stats to be stable so that I could make changes to them without the reason for those changes being obviated by the dice the next time I ran the script.

For each character, I kept a text file of my notes on the character, including who the actor was, what age the character was⁴, their attributes and skills, and so on.

Each of my character files starts out with the basic attributes and talents, as well as some background information about the character:

The script ensures that important information, such as the age, nationality, and “player” name, is in the file, so I don’t forget to include it on the character sheet. It also ensures that the initial attribute total adds up to 75 and that the initial talent total ranges from -2 to 3.⁵

Next, I kept a “development” section for each character:

Here, the number of adds to attributes and to skills must equal the character’s age. The number of adds to talents must equal 27: the average of 20+2d6. While it’s not quite Daredevils rules, I assume that each add to attributes is d3, that is, 2; strictly by the rules, players don’t assign adds to individual attributes, they decide on a number of adds to all attributes, roll d3 for each add, and then allocate the resulting points. But assuming that each add applies to a particular Attribute makes adjustments easier while statting up each character, because it means a 1-to-1 correspondence between the Attribute bonus and the character’s age.

Skills take one add to get the skill at the base score, and then one add for each increase beyond the base score; each add increases a skill by 7 (the average of 2d6). For Charles Rolling Thunder, for example, he has Survival and then three adds to Survival, for a total of 56. Survival is made up of the Health and Wit attributes, and the Natural talent. Charles’s initial Health and Wit are 12 and 13; his Natural talent is 10. That makes a base of 35, plus 3 times 7 (21) equals 56.

As you can see, there is a lot of room to make mistakes if I were to do the calculations for all the skills of nineteen characters by hand!

Besides doing the calculations, the script makes sure that skill scores do not exceed 100, attributes do not exceed 40, and talents do not exceed 20.

Finally, I also provided some background items and quotes for each character:

The script collects the background items but otherwise mostly doesn’t use them. The exception is for characters with Heightened Attribute Use. The attribute that is heightened gets better Attribute Saving Throws and Critical Saving Throws, and the script recognizes that and redoes the calculations.

Heightened Attribute Use: Deftness. Attribute Saving Throw and Critical Saving Throw values are both increased. The values on the front page reflect the increase.

The script takes my character notes, does its calculations and validations, and either tells me I did something wrong—and where I failed—or generates a simple character sheet. The files generated by the script could be used directly as character sheets; all you’d have to do is open them in a text editor and print them, or open them in a word processor and perhaps convert them to two columns, perhaps putting the background and quotes on the back page.

Like the source files, the output uses a mutated Markdown format.

What I did, however, was take the generated files and use a second script to import them into Scribus, ensuring a standard character sheet for each character. Stay tuned for part 2 if you’re interested in that.

There used to be a huge overlap between computer users and roleplayers. This is the kind of utility that would be used to automate repetitive tasks. This particular script is a little too complex to use as a detailed tutorial, but some parts of it might be instructive.

Here’s the main loop:

The script loops through every file given and instantiates⁶ a Daredevils character based on what it finds in the top-level section—or dies with an error if it doesn’t find a top-level section. It then loops through each subsection, collecting the initial attributes and talents, the development allocations, the background, and the quotes.

Once it’s looped through all of the sections, it calculates the initial development allocations and shows each section of the character sheet.

Then it starts over again on the next character file. Here’s how I’d create the character sheet for Dr. Agnes Temple:

While working through the character and creating the source file, I might just look at the results directly in the Terminal, using the aligntabs script from 42 Astounding Scripts.

Here’s an example of how the script adds a new skill to a character:

At the top of the file is a list of skills, and the attributes and talents that contribute to a character’s initial score in that skill:

The addSkill method takes the skill name, gets a list of the parts that make up the initial score, and then loops through those parts, adding their value to the initial value of the skill. It then adds that skill to the character’s skill list, possibly multiplying it by two if it’s the character’s native language.

Another simple method prints out the character’s background. This typically would go on the back of the character sheet.

This prints out a background section if the character has any background items; it then prints out any notes that are needed for particular skills, such as the linguistics skill. Linguistics allows the character to speak languages they don’t specifically know, as long as they know another language in that language family.

Each of the sections of the character sheet has a method like that; there’s a showSkills, a showQuotes, a showTalents, and so on.

Next, I’ll show how I automated pulling them into a Scribus document.