Creating an Ontology of Role-Playing Game Designs

I've recently resumed a project I had left dormant: celebrating game design innovations in role-playing games. Previously, I had included this dimension in the TTTTRPG (Timeline Tree of Tabletop Role-Playing Games) timeline. I've decided to extract it from that timeline and create a separate ontology.

Ontology

An ontology is a structured system for representing and organizing information within a specific domain. It doesn't just list elements; it establishes clear relationships between them, creating a framework for understanding and reasoning. In our case, this ontology will primarily rely on two elements:

• A taxonomy, which is a hierarchical list of concepts, classes, and multiple levels of subclasses. These classes represent theoretical ideas or abstract concepts. They are "mental constructs" that don't exist physically but help us categorize the world. Under each class, there will be increasingly specific levels of subclasses. This tree-like structure allows for precise classification and logical navigation through the concepts.
• A list of individuals, which are the concrete elements of the world that will be indexed (described) with one or more links, each link pointing to a class. Unlike classes, which are abstractions, individuals are tangible or specific entities.

In this example, the taxonomy will represent all types of game design, or more broadly, all "ludemes" (bits of game elements). The individuals will be specific and interesting game designs from notable games. The game's name is added in parentheses after the game design's label.

Examples:

Ghost die

• The ghost die from Ghostbusters (1986) is an instance of the subclass side die and the subclass die with special icon(s).

• Changing alignment due to famine in Dark Sun (1991) is an instance of the subclass food resource management, the subclass alignment change, and the subclass players lose control of character.

My Mistake Last Month

I started building a huge taxonomy of classes and subclasses that ALSO integrated game designs from certain games INTO the class tree (often at the end/bottom of subclasses). In this organization, the individuals were the games.

Excerpt from the erroneous ontology in WebProtégé

This isn't entirely bad in itself, but this knowledge system has limitations:

• If a game design has multiple dimensions (like the famine example mentioned previously), then you have to choose only one. Of course, it's always possible for a subclass to have multiple parents, but it's not very elegant.
• If we plan to comprehensively list all role-playing games and their game design mechanics, it's crucial not to overload the class taxonomy with excessive granularity. Trying to create classes for every specific game design element could turn the taxonomy into an "overloaded tree," potentially too heavy and difficult to manage.

Compressed archive containing the 4 files from this erroneous step (in an open science approach):

• TTTRPG_ontologie-erronee.owl: Erroneous data organization in RDF/XML format. It can be loaded into WebProtégé (a simple and free online service) or Protégé (a more advanced, free/open-source software).
• ontology_formatter_rdf_owl_to_html_tree_with_individuals.py: A Python script to transform this file into a readable HTML file: owl_class_tree_with_individuals.html
• change-owl.py: A Python script to transform this ontology into a more satisfactory one (still needs a lot of work but on a good foundation). It was designed in conversation with Anthropic's Claude 4. The prompt is included in the script.

« Bye bye ontologie erronée »

 

How to Design a (Good) Game Design Ontology?

The key is to find a balance. It's better to maintain a more general and abstract taxonomy, relying on individuals to be indexed in parallel. Each role-playing game design element (an individual) can be described with precise links to the relevant classes in the taxonomy. For example, instead of creating a class for each type of dice pools used, we could have a more general dice pool class, or one or two subclasses (e.g., linear dice pool, non-linear dice pool), and let the individual's description specify the type of dice used.

This approach allows for a clear and manageable taxonomy while offering the necessary flexibility to capture the specific details of each role-playing game via the links between the taxonomy and the list of individuals.

Creating a Taxonomy of Classes and Subclasses

This means creating a hierarchical list of concepts to describe, classify, group, and qualify the various existing game design elements.

Here's an overview of this taxonomy in WebProtégé:

Example of taxonomy with classes and subclasses

 

Ideally, each more specific element (child) should have only one more generic element (parent) because this ensures a clear hierarchical structure and avoids ambiguities in the inheritance of properties and relationships. Generally, I think this indicates a well-thought-out and structured breakdown, as it forces the factorization of ideas into different, separate categories and requires making choices. Additionally, remember that an individual can belong to multiple classes.

In an ontology, a subclass inherits all the characteristics (properties) and definitions (axioms and concepts) of its parent classes (or superclasses). For example: moral mechanics has the attributes of character mechanics, and themselves have the attributes of game mechanics.

Indexing a Series of Individuals

Each individual is of one or more Types, derived from a class or subclass. For now, there is only one type of individual: game designs. Currently, the associated game names are hardcoded as a string in parentheses within the individual's label.

Example: Ghost die (Ghostbusters)

Example of an individual

 

Drawbacks

Besides the need to re-index everything, separating specific game designs into individuals prevents me from displaying them all together and grouping them as was possible before (in the erroneous case). Even though it's better designed, I feel a loss of control because the visualization of the data together is lost. This is likely why I initially pursued an erroneous path that gave me a greater sense of control over the overall ontology.

Comments on Generative AIs

I find Google Gemini to be very good at generating accurate comments on the most well-known rules of notable role-playing games (GURPS, D&D, CoC, etc.). I don't know if it's as good for niche games. A deontological drawback: it invisibilizes all those who have done analyses, critiques, or written the text of the games.

Anthropic's Claude is very good at generating somewhat complex computer code. The change-owl.py script (see above) which transforms the old erroneous ontology into the new one was not a foregone conclusion. OpenAI's ChatGPT, on the other hand, yielded nothing good after many attempts. Anthropic's Claude produced good code with almost the same prompts in two trial-and-error attempts. I have no conflict of interest with the mentioned products. I only used the free versions.

To Be Continued

Once the new ontology and individuals are stable, I will share everything again as part of an open science initiative. This will be done in open files (likely RDF/XML for the complete structure and HTML for visualization).

In my wildest dreams, I imagine this being used to create a large database indexing tabletop role-playing game designs. Perhaps as a participatory science endeavor, where several volunteer participants could contribute? By integrating all or part of it into Grog, RPGGeek, or Wikidata?

To my knowledge, this would be the first detailed catalog of game mechanics. Exciting!