TL;DR: This post converts Dexter Magic to Cortex Prime, from a previous conversion of Castle Falkenstein’s Sorcery to Dexter Magic—but everything could apply to any magic system.

A while ago, Dexter Dunbar from the Fate Core | Accelerated RPG FB group left a comment about a post and was nice enough to let me develop a Fate hack out of it. The group is private, and the link won’t work if you’re not a member, so I reproduced the original comment below.

“Because I am _______ and want to use magic to ______, I will need ______. The caveat to my spell is ______.” The effect walks up the [FATE RPG Adjective] Ladder. The caveat walks down the Ladder. The trappings and your personal qualifications can go either way. That’s all you need for FATE magic IMO.

Dexter Dunbar

I never got to play with Fate-based Dexter Magic (FDM) because I ported my games to Cortex Prime before I could. But I recently undertook a conversion of Castle Falkenstein for Cortex, and already had an FDM translation halfway done, so I figured cortexifying it would be easier than scratch-build it from the original game.

And that’s what I do in that post, although everything applies in principle to any magic system for Cortex Prime that’s Vancian enough (i.e.: where spells have free parameters).

Before going any further, a caveat: this post was edited from a Discord conversation with the prospective player for the Castle Falkenstein game, familiar with Cortex Prime rules. If you lack familiarity, the translation may seem a bit opaque. But then, why would you read any further?

Unpacking a Spell

I’ll use the conversion of Castle Falkenstein Sorcery to showcase the conversion process, but you can apply the same ideas mutatis mutandis to any Vancian system. The basic idea is to identify which parameters matter to you and map them to mechanics.

Dexter Magic has a few parameters that I’ll illustrate with a write-up from an earlier Castle Falkenstein post, for the Mental Command spell, found in the Manuscriptum Mentalis, one of the Illuminated Brotherhood of Bayern lorebooks.

Because I belong to the Illuminated Brothers of Bayern and want to use Sorcery to Issue a Mental Command to [Name(s) or Description(s)], I will need [the name(s) or description(s) of N/PC(s)]. The caveat to my spell is [possible fallout].”

---

Let’s unpack this, and map the spell description to Cortex Prime mechanics, generalizing the example, and commenting on why I’d picked what.

• “Because I belong to [Order]“: this is narrative permission; a distinction or a relationship (if using that mod) with the [Order] would do the trick;
• “use Sorcery to [Spell Name and other Definitions]“: the spell belongs to a lorebook accessible to the members of [Order], so a signature asset is a good fit (either for the whole lorebook, or for piecemeal spells);
• “I will need [Conditions & Component(s)]“: FDM-like narrative permissions translate into modifiers which Cortex Prime does not have, so I went for (mandatory) assets to include in a dice pool for casting the spell;
• “The caveat to my spell is [possible fallout]“: that could be the predictable result of spell failure, but there’s a more interesting possibility.

FDM recipes for spells tally numerical modifiers to obtain a difficulty to roll against. Replacing Fate-specific mechanics with their effect, we can infer Cortex Prime replacements for numerical modifiers. Here are the Fate mechanics, paraphrased:

• Spell Effects & Trappings: [incremental numerical modifiers to base difficulty for] altering an Exchange/a Scene/a Session or Episode/a whole Campaign.
• Components: from [low numerical modifiers to player skill] (unchallenging to procure) to [high numerical modifiers to player skill] (a dangerous side-quest).
• Caveats: from [low numerical modifiers to player skill] ([small consequence to player’s physical or mental health]) to [high numerical modifiers to player skill] (fallout might spur an entire storyline).

Components are partly taken care of with assets, but there’s more to come. As for Caveats, it took me a while to figure out a solution, and it’s optional anyway, so I’ll postpone until I’ve dealt with the Effects & Trappings (and difficulty).

Spells as 2-Dimensional Challenges

In Castle Falkenstein, spellcasting is a time-consuming process with multiple occasions of going wrong. Using Cortex Prime challenges seems a natural match, with constraints on the spell challenge pool being both mechanical and narrative.

Now, Castle Falkenstein uses Definitions as a catch-all category for effects, trappings, and components, and can pile a good number of numerical modifiers in multiple categories. Specifying a spell’s parameters can soon become a nightmare (fig. 1).

Comparatively, Cortex Prime challenges spread difficulty along two dimensions only, one for the number of dice, and one for dice rating (Fig. 2). So I decided to stick with only two (narrative) parameters, rather than a multitude of “Definition” categories.

Furthermore, Castle Falkenstein is a simulationist system (at least for magick), whereas Cortex Prime makes better sense as a narrative system. So I decided to go with two narrative parameters: the scope of a spell, intuitively: how far it ripples in the story, and its magnitude, or how big of a splash it makes.

For scope, assuming a default difficulty of magic at die rating, the number of dice for the challenge is correlated with the following story slices:

• the spell affects a single test/contest: a one-die challenge;
• the spell affects a single scene: a two-die challenge;
• the spell affects a single session: a three-die challenge;
• the spell affects the remainder of the current campaign: a four-die challenge.

This choice is arbitrary, and you might as well use the number of dice for magnitude. But I didn’t, and thus used dice ratings for effect magnitude, with the scale left intentionally vague:

• the spell has an insignificant effect: step down the challenge dice rating;
• the spell has a moderate effect: keep the default rating;
• the spell has a significant effect: step up the challenge dice once;
• the spell has a world-changing effect: step up the challenge dice twice.

With this, assuming the default difficulty of magic at die rating, here are a few examples:

• causing the King of Bavaria to sneeze (insignificant) any time he says “Prussia” (remainder of the campaign) would be a four-die, stepped-down challenge.
• the spell that brought Tom Olam to the world of Castle Falkenstein (world-changing) to alter the Prussia-Bavaria balance of power (whole campaign), would have been a four-die, stepped-up twice challenge.
• stopping the Street Urchin who stole your wallet you wanted to pay the cab driver (single test, if any) instead of letting your friend do that (insignificant) with a Mental Command, would be a one die, stepped-down challenge.

The adjustments are narrative (aka: simulating fictional impact) rather than objective (aka: simulating distances, time, number of targets, etc.) but the mechanical difference is not as big as the “fiction, not physics” crowd would have you think. At the end of the day, it’s all parameters and scaling.

As an aside, Cortex dice ratings or dice numbers can absolutely track objective parameters, and some rules and mods do just that (e.g. mobs, for size; and some resources, for stock). Also, I’ve witnessed two of this blog’s readers “fiddling with “objectifying” traits that are usually not—and one of them is convinced they’re hardcore “fiction, not physics.”

If the mechanical differences are negligible, the gameplay consequences of which parameters you choose are significant. The original Castle Falkenstein post discussed examples where the benefits of narrative parameters are conspicuous, but Dexter Magic may have some odd-looking consequences (see the Fine Print).

Caveats, Fallouts and Doom

Dexter Magic components that matter narratively are handled as permission from traits—in a Castle Falkenstein hack, distinctions, relationships, and assets, but other traits would work too. Effects and Trappings are tracked with the challenge pool (but see the Wrap-up). That leaves us with caveats and fallouts.

My first instinct was to disregard mechanical effects and just take care of them narratively. But then, I thought twice. In FDM, Caveats and Fallouts fulfill a double duty essential to the narrative logic. Simply put the more dramatic the fallout, the easier the spell. In details:

1. a caveat translates into a discount on difficulty (Dexter’s original framing) or into a bonus to a skill roll (mine, equivalent, avoiding negative modifiers) proportional to the possible fallout;
2. a fallout provides a narrative frame for the Things That Would Go Wrong—not necessarily a special mechanical effect—on failure.

Handling caveats and fallouts narratively make spellcasting harder, as there’s no difficulty discount or bonus. But it does not make it more interesting. So I revised my first instinct and came up with an alternative functionally equivalent to the caveat/fallout pair from Dexter Magic, using the Doom Pool mod.

• Before the roll. The player can borrow a die from the Doom Pool, with a rating based on the fallout (if there is no such die, just pick one from elsewhere).
• During the roll. The borrowed die is rolled with the player’s dice pool; a hitch (1) shouldn’t earn the PC a plot point, because it’s borrowed, but hey, if you disagree, just do you.
• After the roll. On a success, the die is returned to the Doom Pool, and stepped up; on a failure, the die is converted into a consequence, in addition to any other effect of failure.

As for choosing the borrowed die’s rating, I’ll suggest a rule-of-thumb: match the rating to the cost the GM would have to pay from the Doom Pool to introduce a complication, distinction, or NPC equivalent to the “fallout.” Or make up you own cost scale (that’s your game).

And that’s it, that’s the whole Cortex Prime conversion of Fate-Dexter-Castle Falkenstein magick. At least, what generalizes to other parametric magic systems. But I never got to convert specific lorebooks, or aspected magic, to Fate. The first is doable with the above. For the second, see the Fine Print.

Fine Prints

Wrapping Up: Parameters and Scaling

Casting a spell in Castle Falkenstein was designed to force a party of PCs to either protect a sorcerer while they slowly collected energy, or throw caution through the roof and use anything. It worked well until you’d try something complicated and start arguing about “definitions.”

Dexter Magic solved most of the hurdles in one fell swoop, by substituting a narrative logic for the original’s simulationist logic (at times, with odd-looking but consistent consequences). While designed for Fate’s numerical modifiers, it translates easily to Cortex, because it’s all about parameters and scaling.

Challenges are a good fit for Castle Falkenstein sorcery because they’re ablative pools and they draw out the spellcasting process. I don’t see that working too well for high-fantasy fireballs, but I hate fireballs anyway. Still, if that’s your thing, you could simply use the challenge pool for a one-shot test.

Anyhoo, once my Castle Falkenstein game is rolling, I’ll post a few cortexified lorebooks (converted, and original) and real-play examples of spellcasting. But that will be all for today, folks.