What D&D 5e systems are implemented vs. planned?

[david-courtis]

From reviewing the code, I can see:
Implemented:

• Weapon attacks, damage, conditions
• Ability scores, skills, saving throws
• Equipment system, action economy
• Grid movement, line of sight

Missing (correct me if I am wrong):

• Spells/magic system
• Character progression (leveling, classes, feats)
• Advanced combat (opportunity attacks, etc.)

Questions

• What's the intended scope of this project?
• Are spells planned? The architecture looks like it could support them well.
• Are you accepting contributions for missing systems?

The codebase looks very well designed - just trying to understand what's complete vs. what's roadmapped. Thanks!

[furlat]

Hi David, thanks a lot for opening the issue. I am very happy you are interested in this codebase.

Recent Updates

I just merged a big chunk of work I had left in the eventbus branch; it includes a big extension of the event system which I used for an implementation of the reactions system. So we do have opportunity attacks! And with some creativity, everything is implementable.

Reactions System: https://github.com/furlat/dnd_engine/blob/eventbus/dnd/reactions.py

The system can best be exposed via the FastAPI server through the event streams.

Frontend Implementation

I also added a React/Valtio based JS front-end client using the FastAPI server, with:

• Character sheet
• Isometric game map

Note: You probably won't be able to run it because I cannot push the art pack which I bought from https://smallscaleint.itch.io/

Demo Videos

You can see some videos here:

Video 1: https://x.com/Cyndesama/status/1927528875690532871/video/1

Video 2 (Top-down view with event system): https://x.com/Cyndesama/status/1927036552238055678/video/1

Current State of the Codebase

To reply to your questions, TL;DR is that there is everything BUT content (other than the basic conditions which I implemented to ensure everything works) and a turn/combat manager + enemy AI. Also, obviously there's no higher-level map organization nor save/load (but it's all Pydantic, so serialization is trivial).

Content Implementation Example

You can see an example of how to implement content like feats and magic items here:
https://github.com/furlat/dnd_engine/blob/main/dnd/monsters/circus_fighter_conditions.py

Spells

I did not implement spells yet, but they can be implemented in practice using the primitives as custom actions. I was planning a more structured approach. Something that is lacking is a principled aoe selection/shape based approach which is mostly due to having only a minimal map support for now, pathfinding and shadowcast currently run basically as functional methods on the ecs with some very inefficient queries to construct the spatial context. I was planning a 3d grid with z axis for verticality (too much Baldur's gate 3) so I did not spend time on the 2d version too much.

Current Status & Future Plans

Now the crucial question: what is going on with this codebase and why am I not actively pushing to it? I started focusing on the frontend for a free/open-source multiplayer web game using this as backend, and went down the rabbit hole of implementing almost everything from the ground up (https://github.com/furlat/PixyIsometricTemplate) - the classical "build your own game engine" conundrum. At the same time, I wrote an academic version of the entity and reactive event system I developed here in this repo (https://github.com/furlat/Abstractions/tree/main). I am currently developing an ARPG with Godot, focusing on more real-time mechanics using the same game assets (https://x.com/Cyndesama/status/1958716070090494022).

I definitely plan to finish this DND project and make it at least playable as text with a minimal graphical interface for both humans and LLMs via web interface.

What are you interested in? Are you interested for academic purposes, building a game, or actually playing D&D? Happy to help in any direction! Any contribution is infinitely welcomed

[david-courtis]

Hi Furlat,

Thank you for such a detailed and well formatted response!

My interest is largely seperate from my academic work for now. I work in embodied AI, so this engine may come up as a test interface for my planning models in the future, but right now I’m using this engine to build a game.

I plan to modify the engine slightly to optimise for the type of game I’m making. I’m considering a text-based dnd game with a minimal positioning interface. The game’s overall narrative will be importable as human written 5e campaign books, and the specific narrative interpolation accounting for player choice will be done by an LLM with access to tool use capabilities ( PydanticAI). Considering the current state of the API, which seems flexible and creative for human use but likely incomprehensible for an LLM, I’ll need to build an intuitive and likely simplified interface to allow agents to interact with it. I’m not sure yet if I want to isolate my interface behind the engine API or modify the engine directly; how much are you planning to add to this in the future?

Modifying it for this purpose is sort of my goal with this engine, I’m writing a test suite in my fork to make sure I don’t break something along the way. I made a list of things that I want to figure out how to create/implement in my fork’s readme. I realise now that some of these can be done with the current implementation, so I’ll need to update accordingly.

I haven’t taken a look at your implementations yet but thank you for sharing them, I expect to find them very useful moving forward and am looking forward to your game implementation if you get around to finishing it.

What sort of contributions are you looking for? Will my unit tests help?

[furlat]

Hey David just started development again - My main issue right now is creating an interface to play as most things are done