Index

• On the shoulders of the cloud giants : citation practices in the TTRPG
• Epigraphs (part 1, part 2, part 3)
  
• Wikidata > SPARQL > R Studio
  
• Ampersand, Assonances & Alliterations : The Shape of Dungeons & Dragons's Name
• Dataviz with JS and Observable
  
• Cease & Desist
• Citation Practices in Games. Why Citing or Not Citing ?
• Building community by citing
  
• On the shoulders ... (first post in 2018) 
  
• TTTTRPG (Timeline Tree of Tabletop Role-playing games)
  
  • dot code structure
  • Creating an Ontology of game designs part2
  • Phylomemetics of boardgames and tabletop role-playing games
  • Exhibition Donjons & Données probantes in the Université de Montréal
  • Greg Stafford (scholarly) obituary
• TTRPG & education
  • TRPG Elements to Engage Students in Information Literacy Workshops
  • Side-Quests & Character Sheets
  • Roleplayification
    
• Bibliometrics
  • Quarto or RStudio & Javascript for Zotero library
    
  • Role-play in PubMed
  • In PsycNet
•  Misc
  • ThesaurusRex: a controlled vocabulary thesaurus for RPGs
  • Tabletop role-playing games as hospitality and hosting rituals
  • TTRPG as game of expectations
    
  • What if... TRPGs were created before 1971 ?
  • Psychology : Storytelling ; De-roling 1/ 2
  • Socratic questioning
  • Role-playing game groups as hunter-gatherer bands; Anthropology & RPG
  • The 1st game masters
  • Dante's Inferno
  • Starvation, famine and cannibalism in tabletop role-playing games
    

Citation Networks of Role-Playing Game Blogs

A new network of RPG blogs has just been built by elmcat. In his post, Mapping the Blogosphere, elmcat explains his project involving web scraping, analysis, and the publication of results in the form of a superb interactive visualization.

One format to gather them all

His idea of using RSS to obtain super-clean blog posts (no banners, no JavaScript, etc.) is brilliant!

I had actually tried to build a similar project using ObservableHQ for the dataviz component, combined with a mix of Python scripts, wget, and httrack for the web scraping. However, I eventually stopped because the scraping itself was a colossal task, especially when it came to cleaning the data of all the excess code. I really should try again using this RSS-based method.

And in the darkness, hypotheses to forge

Through Mastodon, I asked elmcat a few questions and hypotheses to test.

Does citing inline (not blog roll) make a blog last longer? Produce more content?

Does citing other blogs by creating links within blog posts (rather than in the sidebar or header, i.e., in a generic way) make a blog last longer or produce more content? This is based on the hypothesis that community connections make blogs more enduring or more productive.

Does new bloggers cite more legacy bloggers compared to the avg bloggers, and to well established bloggers?

Do newcomers to the blogosphere cite more than average bloggers, or than well-established, reputable bloggers? Based on the hypothesis that people cite to connect to a movement or to other individuals, or that blogging may be a response to ideas expressed elsewhere that they wish to continue engaging with.

Is there a curve/pattern of citing over time?

Is there a curve in the number of links to other blogs over the lifespan of a blog? For instance, do people cite more at the beginning, or at the end, etc.

Do citing somebody make you cited by them afterwards?

Does citing a blog post make it more likely that you will be cited back later? Does citing create connection and reciprocity? For example, breaking the fourth wall: I am currently citing elmcat and his project, but I do not know whether I will be mentioned in return.

Prospects

To answer all these questions, one must not only collect and structure the data, but also have statistical analysis methods that I do not yet master. Perhaps elmcat will provide part of these answers.

In the meantime, the first observation suggested by the citation graph of the blogs is the existence of several groups, currents, or trends within the OSR (the Old School Renaissance play style relied heavily on blogs to share gaming experiences and innovations). Although many bloggers identify with this movement, the graph seems to reveal a great diversity of sub-communities rather than a single homogeneous whole.

Creating a game-design ontology (for studying evolution of games) 3/*

Reading a thread on Bluesky by Sergi Valverde about the evolution of software, I thought it might be fruitful to draw parallels with the evolution of game design for tabletop role-playing games.

How so?

First of all, the study of software evolution is quite convincing. They are often viewed as living systems traversed and guided by evolutionary forces.

« we see the same evolutionary forces: imitation, recombination, competition, parasitism, symbiosis. » in Sergi Valverde, Ricard V. Solé; Punctuated equilibrium in the large-scale evolution of programming languages. Journal of the Royal Society Interface 2015; 12 (107): 20150249. https://doi.org/10.1098/rsif.2015.0249

Far be it from me to claim mastery of the concepts, much less the basics, of complex systems analysis with an evolutionary angle, but I’m launching the reflection. However, I believe studying role-playing games could greatly benefit from methodological discoveries in other domains and, cautiously or boldly, import them.

Usually, in the study of complex systems, there are graphs with relations between many elements and also many variables (more or less measurable) to understand the interactions between elements.

Parallels between software and TRPGs

Both cultures share many similarities:

• Emergence and growth in the same parts of the world, in close generations, even with a similar sociology of their actors.

• Design of cultural products based on rules, procedures, recipes, ways of doing.

• Co-existence of a proprietary market and a “free or open” market.

• Inspirations, influences, movements, practical philosophies for each product.

• Access to the full corpus of games (their DNA), even possibly full indexing to obtain rich metadata,  just as code is for software.

• The same evolutionary forces mentioned above.

Here, another fascinating study by Valverde et al. studies the evolution of arcade video games.

Valverde S, Vidiella B, Spiridonov A, Bentley RA. The cultural macroevolution of arcade video games: innovation, collaboration, and collapse. Evolutionary Human Sciences. 2025;7:e30. doi:10.1017/ehs.2025.10015 

They find trends present in biology: “diversification, collapse, persistence.” According to the authors, technological objects offer a richness of description easier to obtain than biology and thus allow testing evolutionary theories. For example, as in nature, computing power and ROM memory of arcade games create constraints. Game clones can experience stagnation while collaborations between game publishers can create innovation.

What should be done

To properly analyze these evolutionary trends, one should:

• design an ontology (an organization of information) describing games and allowing fine-grained indexing of game mechanics.

• index games according to this ontology.

• do it for a representative sample of games (to be constituted), perhaps weighting this sample according to the notoriety of the game.

• process the results using mathematical methods I don’t master.

• (possibly) draw conclusions.

• the hardest part: absorb the literature on the evolution of cultural objects.

  • Understand the concepts.

  • Verify which ones could be adapted to tabletop role-playing games.

  • Create new ones?

What has already been done

• I started to design an ontology to describe tabletop role-playing games. It is described in the two previous posts.

• I also created a prototype in 2019 in the form of a Timeline Tree of Tabletop Role-Playing Games.

• RPGGeek and LeGrog each contain a database of games properly catalogued — though with less developed indexing of game mechanics.

• I tried to write a Python script to parse RPG rule PDFs to detect what types of dice are used.

• I contributed to Wikidata by adding some role-playing games with more or less rich metadata. At present, I have mainly indexed the citations of each.

Future paths

• Outside the reach of course: because I don’t have the reputation or the platform of influence to launch it — it would require carrying out indexing of the entire corpus by hand, with an army of volunteer indexers.

• Apply automatic processing (as for dice) to other transversal elements of role-playing games:

  • mention of a screen (GM screen), a character sheet, stats, skills, etc.

  • presence of tables in the rules, or ratio letters/numbers.

  • presence of exotic names.

  • etc.

In my opinion, these elements can benefit from a valid automatic numerical indexing. Maybe one day, language models (LLMs) will be able to index advanced game design.

Creating an anthology of game design 2/*

This post is a follow-up to the previous one, in which I described the construction of an ontology of role-playing game design. I'm sharing some of the results of this ongoing project.

New ontology

While I was working on the hierarchical relationships between the game design classes, I was developing the individuals to see if the system worked and what needed to be fixed.

From now on, the classes are more compact and I continue to clean them up to bring them together even more, because what makes a class strong is to bring together elements around it. To avoid going too granular, I also work on their hierarchy by trying not to make hierarchies too deep and therefore too forced. By better separating individuals from classes, the taxonomy is considerably simplified with a more spread-out factorization of concepts. I was strongly inspired by the work of Guillaume and Thibault Rioult and their PERSO model (1) to describe the game design bricks. More specifically, I used their divisions into functional operators ("substitution operator", etc.).

Each individual is now a module/brick/game design innovation of a particular role-playing game.

· They are not exhaustive in relation to a game.
· They are especially notable.
. There can be several per game.
. Examples of individuals: Apocalypse World moves , backup your ego in Eclipse Phase, etc.

Visualizations

Everything is built in WebProtégé, exported in RDF/OWL (an XML format). From this XML format, I mill it into 3 Python scripts to make simple visualizations. I created a repo in GitHub with a recent export of the OWL and the Python scripts. The HTML visualizations (linked and previewed below) are available on GitHub.io.

Examples of all nested classes with the individuals using them:

 

Examples of individuals with classes : 

 

Examples of individuals with classes and (sometimes) descriptions :  

 

genAI: 1 advantage 3 problems

For some individuals, the full description is placed in a drop-down menu (see image above). It was automatically generated by Google Gemini's generative artificial intelligence.

Advantage

In most of the well-known games, Google Gemini produced a quality text whose main use was to serve, after reading it by me, to complete the indexing with missing classes that had escaped me . This is a big advantage in my opinion AND a rather ethical use (when it is declared) since the generated text supports a task. It does not replace it or substitute for it.

Problems

However, in some cases of niche mechanics or games, Google Gemini has produced bullshit, admittedly with subjunctives ( would , could , ... ) but in a formally convincing manner if one does not know the games. Below is an excerpt from a failed attempt to explain what the approval mechanic is in Fréderic Sintes' Prosopopée. 

Additionally, last week Google Gemini aggressively pushed its algorithm across most of its products (Android, etc.) and that added another layer of rejection to this particular tool.

Finally, the time savings are rather marginal compared to the task of visiting a few websites and reading explanations on your own. Furthermore, these tools obscure the work of the authors and critics who have studied the games. To counterbalance this last point, I added links to authentic sources to the WebProtégé OWL file.

RDFS, SKOS or DC fields

Fields can follow different standards to describe data and metadata. These are specifically adapted for the sematic web and linked data. In an RDF/OWL file, these three standards can be found to describe an element. For each field, the language is coded in ISO 639: fr, en, es, pt, etc.

rdfs:label

Class Taxonomy: The name of the game design, usually beginning in lowercase. The textual form should be as short and unambiguous as possible.  

Individuals: The name of the game design, often in the form of a short sentence or title. Begins with a capital letter. Followed by the name of the game in parentheses (parentheses are reserved characters for this use).

skos:altLabel

Synonyms for the label.

skos:definition

Short definition of one to three sentences.

dc:description

Full description in MarkDown format. When this field is filled in, it is of-
ten copied and pasted from Google Gemini or other LLM if they have
produced a satisfactory summary.

dc:source 

URL or bibliographic reference of the information source.

rdfs:seeAlso

Cross-reference. Indicates what other descriptor could be used in addi-
tion.

Remaining aporias in the ontology of classes

• The temptation is sometimes strong to make double (or triple) parents rather than restricting oneself to a single parent per subclass.
• Dice pool: do I create two subcategories: linear dice pool and non-linear dice pool ? or do I separate these two in case there are other linear and non-linear elements?
• I need to figure out how to count the number of times each class is used. A class used once is not very relevant.
• Do I separate Magic into a separate class from the rest or do I integrate it into the other classes?
• Dice mechanics : potentially deep + separate concepts well. For example, roll-under > roll under target number (a class and its related subclass) be- comes: roll-under + target number (two separate classes to combine if necessary).
• Write class and individual labels correctly with controlled vocabulary (to be done):
• player character
• player
• gamemaster
• participants (P+GM)
• Clearly describe the definitions to remove ambiguities.
• Write a data dictionary.

Research questions and hypotheses

• Is an individual indexed with a lot of classes a sign of innovation, fun, etc .?
• How can we use this ontology to index an entire game, rather than just bricks of a game element?
• How to align part of this ontology with Wikidata?

Références : 

(1) Guillaume et Thibault Rioult, 2024,  Interfaces ludiques entre système de jeu et fiction, outil de modélisation au service du game design au colloque « Le jeu de rôle a 50 ans. Et maintenant, que faites-vous ?… » à la Sorbonne.

 

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!

 

Almost 50 Years of Academic Research on Tabletop Role-Playing Games: Historical Evolution and Bibliometric Analysis

Almost 50 Years of Academic Research on Tabletop Role-Playing Games: Historical Evolution and Bibliometric Analysis

https://pmartinolli.github.io/JDR50bibliometrie/index-english.html

This descriptive study offers an in-depth historical and bibliometric analysis of academic research on tabletop role-playing games. It examines the evolution of publications across various academic formats (conferences, monographs, theses, peer-reviewed articles) and explores new trends in scientific dissemination, including preprints and literature reviews. The analysis reveals a marked growth in scientific output since the origins of role-playing games, with a notable acceleration over the past decade. While research remains primarily based in North America and Europe, new hubs are emerging in Latin America and Asia. Several major themes are explored: the dominance of Dungeons & Dragons, the moral panics of the 1980s and 1990s, therapeutic applications, issues of diversity and representation, as well as the phenomenon of actual plays. The study also includes an analysis of theoretical reflections developed by the gaming community outside of traditional academic publications. It examines how these high-quality, para-academic contributions might be integrated and validated by scholarly institutions. Finally, it highlights the influence of academic practices and values, particularly in terms of citation, on role-playing game culture.  

This translation is to be submitted to a journal. It is a translation of the presentation in French made in the colloquia “Vous êtes dans une taverne…” Retour sur cinquante ans de jeux de rôle (27-28 mars 2024, Metz, Université de Lorraine) that will be published as a chapter in a monograph. The translation relies heavily on Claude 3 Haiku by Anthropic and ChatGPT 4o by OpenAI.

On the Shoulders of Cloud Giants: dataviz with JavaScript in Observable

 

My project On the Shoulders of Cloud Giants which attempts to describe citation practices in tabletop role-playing publications is a bit dormant at the moment. I am testing a new technique which consists of creating automatic citation indexes but it takes time.

Here it is : https://observablehq.com/@pascaliensis/on-the-shoulders-of-cloud-giants

• The code queries Wikidata and returns the data in a structured manner in the form of (mainly) a series of pairs between a citing tabletop role-playing game and a cited TTRPG.

• The data exists in Wikidata thanks to property P2860 (cites work).
• The code is in the appendix (at the very bottom of the Observable page) in the variable query=
• Other data is repatriated along the way: date of publication, “movement” to which the role-playing game belongs (The Forge, OSR, etc.), publishing house and game mechanics.

• This data in the form of a table is encoded in JSON format. This is important because as we are going to do JavaScript visualizations, we need to structure the data in this format so that it is absorbed correctly by the JavaScript visualization libraries.
• Then this JSON table is transformed into a JSON hierarchy, this is an organization of information specifically designed for network/relationship visualizations.
• Basically, the structure of this JSON hierarchy is divided into two parts: a part describing each game independently (nodes part) and a part listing each relationship (edges part).
• The transformation was done by a function named table2hierarchy
• The variable containing this file is located in data_citingCited
• From there, most of the work is done because the JavaScript libraries do all the rest of the work. You just have to modify them a little each time to have the desired effect (like filtering the data or coloring it). Several visualizations are thus made:
•         Undirected graphs
•         Chord diagrams
•         Classic bar charts, etc.

https://observablehq.com/@pascaliensis/on-the-shoulders-of-cloud-giants