More Thoughts on ‘Coriolis: The Great Dark’

As I reflect on what little Free League has released about their upcoming Coriolis: The Great Dark, I find myself becoming apprehensive about the new version of a game that became “obsolete” before I played it.

Here are some nagging thoughts running through my head.

The Great Shadowdark?

Coriolis: The Third Horizon presented a cluster of 36 stars; the main book and supplements detailed climates and cultures for most of them. The Third Horizon therefore provided players a varied, vibrant setting with numerous cultural, political, and religious factions with their own areas of influence, ideologies, technological advances (and regressions), and ultimate objectives.

Information available so far paints the “Lost Horizon” of Coriolis: The Great Dark as a dead, desolate volume of space where an outpost of humanity must delve into the remnants of abandoned alien technology while resisting the dreaded Blight. All the factions of the Lost Horizon coexist (barely) in the overcrowded corridors of Ship City.

The setting of The Great Dark, therefore, resembles the minimal setup of dungeon-centric games like Shadowdark: except for a few scenes in the nearby town outpost the the adventure begins when the part enters the dungeon, and ends after they escape the dungeon. Some people enjoy that sort of game. Some people don’t. It’s hard for me, at least, to imagine a game with such a narrow focus as a successor to the sprawling Coriolis: The Third Horizon.

You Can Take The Sky From Me …

Quoting from the Coriolis: The Great Dark Quickstart:

For a long time the people of Ship City thought themselves trapped in the Jumuah system. The dead star portal seemed to make any further exploration impossible. This all changed with the discovery of the Slipstream phenomenon. […] However, navigating this celestial current comes with its challenges, necessitating ships that are both stronger and more durable to endure the intense forces at play. Through costly trial and error, the shipwrights eventually managed to find a way to master the stream: the Greatships. […] Few in number and enormously expensive to build, Greatships are the largest vessels constructed by the people of Ship City. Often owned by a consortium of different guilds, these ships require a crew of hundreds and enough supplies to last years.

Gone, apparently, are the Third Horizon’s cosy, customized ships that serve as means of space travel, source of debt, weapon, and final refuge.

Maybe the “ship as home” trope has been overdone. Yet everyone remembers the Millenium Falcon, the Serenity, Moya, or the various ships Enterprise. Even the Nostromo or the Event Horizon have their own, warped personalities.¹ In contrast, the generic tramp steamer that ferries explorers to their latest adventure seldom has a name, or at least a memorable one.

The Coriolis: The Great Dark Campaign

As I said before, I invested in the Kickstarter, and I’d like it to produce a great game. I also invested in Flowers of Algorab, the campaign boxed set for C:TGD.

A Kickstarter update described Flowers of Algorab:

The campaign will serve several purposes:

• Provide a full tour of the setting, introducing Ship City and its intrigue, the concept of expeditions, and the exploration of the Lost Horizon.
• Answer one of the long-standing mysteries of the Coriolis universe: the fate of the long-lost ark ship Nadir.
• Provide a starting point from which GMs can build a continuing campaign, without having to wait for the next part to resolve the mystery.

The Great Pendragon Campaign for the King Arthur Pendragon RPG presents a massive timeline for the Arthurian cycle, broken down into gameable events. Even the more modest first edition sketched out how Greg Stafford intended others to play his game.

My hope is that Algorab provides that sort of framework, or at least a Rosetta Stone, for new players and game masters to run sessions of Coriolis: The Great Dark. As I find myself having misgivings about my rather large outlay for a game that won’t be available until next year, I hope that between the core book and the campaign boxed set there’s enough material and guidance to make campaigns of C:TGD lively and varied … and not just another deadly dungeon delve.

Extended Probability Table

Much like I did in a previous article, I calculated the Normal and Push probabilities for rolling 1 or more successes, 2 or more successes, and 3 or more successes. Unfortunately I couldn’t simply reuse those numbers, as Coriolis: The Great Dark only permits rerolling on a 2-5, while the original Coriolis (and Vaesen and Tales From The Loop) permit rerolls on 1-5.

Program

This one uses Python with type annotations because:

1. I’m sporadically trying to relearn Python.
2. Python provides both a choose function (math.comb) and a third-party library for formatting a list of lists as a Markdown table.
3. Thanks to this and the lack of the end keyword – Python detects code blocks through indentation – the code ended up a lot shorter than my usual Lua program.

I ran this program through mypy and pylint to check for typing and other errors, and pylint insisted on my adding doc strings. The doc strings take up almost as many lines as the actual code …

#! /usr/bin/env python3

"""
Computes a table of probabilities for _Coriolis: The Great Dark_.

Players roll a pool of six-sided dice; each die that rolls a six is a success.
Players can also "push" the roll as follows:

1. Pick up all the dice that did not roll 6 (already a succes) *or*
   1 (which designates a "bane" in the Year Zero Engine).
2. Reroll the dice collected.
3. Every old or new 6 counts as a success; each old or new 1 counts
   as a "bane", which in C:TGD inflicts Hope damage as a penalty for
   rerolling.

In some cases a single success is not sufficient, so this script also
calculates the probabilities of rolling two or three successes, normal
or pushed, on a number of 6-sided dice.
"""

import math
from tabulate import tabulate

#
# Note: Tabulate must be installed separately using:
#
#     pip3 install tabulate
#
# or
#
#     brew install python-tabulate
#

MAXDICE: int = 12

SUCCESS: float = 1/6

PUSH_SUCCESS: float = SUCCESS + (4/6) * SUCCESS


def success(n: int, k: int, p: float) -> float:
    """
    Return the probability of exactly `k` successes on `n` dice
    with success probabilty `p`.
    """
    return math.comb(n, k) * p**k * (1-p)**(n-k)


def success_at_least(n: int, k: int, p: float) -> float:
    """
    Return the probability of at least `k` successes on `n` dice
    with success probability `p`.
    """
    return sum(success(n, i, p) for i in range(k, n+1))


def format_pct(p: float) -> float | None:
    """
    Format a probability as a number between 0 and 100, or None if zero.
    """
    if p == 0.0:
        return None
    return p * 100


def main() -> None:
    """
    Print a table of probabilities for number of successes by normal or pushed
    by number of dice
    """
    headers: list[str] = [
        'Dice',
        '1+ Norm',
        '1+ Push',
        '2+ Norm',
        '2+ Push',
        '3+ Norm',
        '3+ Push',
    ]
    rows: list[list[float|None]] = [
        [
            n,
            format_pct(success_at_least(n, 1, SUCCESS)),
            format_pct(success_at_least(n, 1, PUSH_SUCCESS)),
            format_pct(success_at_least(n, 2, SUCCESS)),
            format_pct(success_at_least(n, 2, PUSH_SUCCESS)),
            format_pct(success_at_least(n, 3, SUCCESS)),
            format_pct(success_at_least(n, 3, PUSH_SUCCESS)),
        ]
        for n in range(1, MAXDICE+1)
    ]

    print(tabulate(rows, headers=headers, tablefmt='pipe', floatfmt='.2f'))

if __name__ == '__main__':
    main()