Overview
MSc Dissertation: University of Limerick, 2026
The Undoing of Ashvale is a top-down 2D RPG I solo-developed in Godot 4 as my MSc thesis project. The full title of the dissertation is “Designing Neurodivergent-Friendly Accessibility Features in a Small-Scale RPG”. It investigates whether cognitive accessibility can be embedded into the architecture of interactive software from the beginning while not compromising the enjoyment of gameplay.
The answer, it turns out, is yes, and it makes adding more accessibility features even easier if the architecture is prepared properly from the beginning. This page walks through the key design decisions I made in the thesis, the software architecture that made them possible, and even what I learned that carried directly into my next project.
What makes this project unusual is the methodology. As a gamer with ADHD, I used an autoethnographic approach and treated my own experiences of cognitive friction in games as legitimate design evidence alongside the academic literature. The features in this game weren't pulled from a requirements document. Instead, they were built because I'd felt the friction of specific problems repeatedly across years of playing games that weren't designed with my brain in mind.
- Godot 4
- GDScript
- Signal Architecture
- Data Resources
- Autoethnography
- HCI
- UX

Designing with People in Mind
The accessibility features in Ashvale weren't designed from a checklist. Each one started with a specific, recurring frustration I'd experienced as a player with ADHD, backed by what the research literature says about why that frustration exists. Below are three of the best examples that demonstrate this.
Combined Inventory Check
The “forgot to grab the item” problem
Players with ADHD often struggle to maintain a mental model of where their items are distributed across multiple storage locations. In practice, this creates a failure loop that anyone with ADHD will recognise: you walk all the way to the builder's shop, realise the materials you need are in a chest back at your base, so you walk all the way back to retrieve them, but by the time you return, you've either lost track of what you were doing or the in-game shop has closed because it took you too long.
I've encountered this pattern constantly in other games, to the point that I am now dependent on a “chests anywhere” mod in Stardew Valley just to function. That mod became a hard accessibility requirement for me, meaning I can't play the game on any other platforms.
The Undoing of Ashvale eliminates this frustration entirely. The crafting system checks both the player's inventory and all chest storages simultaneously. The quest system does the same, so if a quest step requires 10 wood and you have 20 in a chest, it'll still count. Accessing any chest shows the contents of all chests in the game, so you never have to remember where you stored something. The cognitive load of resource location tracking is removed completely, letting the player focus on the gameplay itself.


Passive Dialogue Log
The “zoned out during the conversation” problem
Zoning out mid-conversation is one of the most common ADHD experiences in story-heavy games. You press through a few lines of dialogue, your attention drifts, and suddenly you've advanced past information you needed. Most games offer no way to recover that content without replaying the scene or searching online. The attention lapse gets treated as a failure, with the unfortunate penalty of losing out on story context.
Ashvale's encyclopedia includes a passive dialogue log that captures every line of NPC dialogue automatically, grouped by character, available to review at any time. There's no action required from the player because it just automatically records every line of dialogue they come across. During playtesting, I found myself using it not only as the safety net for missed content, but as a preferred way to engage with story information. Re-reading a conversation in a quiet menu context actually yielded more comprehension than processing it in real time during the initial scene.
The design treats attention lapses not as failures to be corrected, but as normal variation in how attention works. Architecturally, it was actually pretty cheap to build. The encyclopedia subscribes to a dialogue_line_shown signal that the dialogue system already emitted. No new systems needed and no modifications to existing ones. That's the compounding benefit of signal-based architecture, which I'll cover more in the section below.

Active Time-Passing
The counterintuitive “no real-time clock” decision
Most farming and life-sim games use a real-time day cycle where time passes whether you're doing something or not. This creates constant background pressure for things like the shop closing at 5pm, or crops needing watering before noon, so you're always racing a clock. For players with ADHD, this time pressure is a direct source of anxiety. If you forget to pause when you stop to think about what to do next, the day gets shorter. If you get distracted navigating, you lose time. The clock punishes exactly the behaviours that ADHD makes unavoidable.
Ashvale uses action-driven time instead. Time only advances when the player takes a meaningful action, like chopping down a tree or crafting an item. Standing still, walking around, opening menus, reading dialogue, none of these cost time. The day only progresses when you choose to do something, not while you're figuring out what that something is.
This was also a direct response to my own experiences in games. In Stardew Valley, I frequently found the day ending before I'd accomplished what I set out to do, simply because I'd spent time navigating or deciding. By tying time to action rather than elapsed real time, the game removes the clock as a source of cognitive load and lets players move at their own pace without feeling punished for pausing to think.
How the Systems Work
The features described above weren't expensive to build, which is the entire point. Good architecture compounds. The early decision to use a signal-first, data-driven design meant that every subsequent accessibility feature was cheaper to implement than the last, because each new feature could hook into existing communication channels without modifying the systems that owned them.
Signal-First Communication
Signals over direct calls to keep systems decoupled
Godot's built-in signal system works like a typed event bus where one object emits a signal, and any number of other objects can subscribe to it without either side needing a direct reference to the other. Ashvale uses this as the primary communication mechanism between systems wherever possible. Systems define what they announce, not who needs to know about it.
The InventorySystem is the clearest example of how this compounds. It emits two signals: inventory_changed and first_time_item_acquired. Seven separate systems subscribe to these: the HUD, player inventory screen, chest storage, crafting system, quest system, encyclopedia, and item-get cinematic. Each subscriber was added incrementally as a single signal connection. Not one of them required a change to InventorySystem itself.
This is precisely the reason why the dialogue log was so cheap to build. The DialogueSystem already emitted a dialogue_line_shown signal for its own UI purposes. The EncyclopediaSystem simply subscribed to it and started recording. One line of connection code, zero changes to the dialogue system, and the feature existed. The same pattern made the combined inventory check possible: ChestStorageSystem subscribes to inventory signals without InventorySystem knowing it exists.
InventorySystem Signal Fan-Out
One emitter, seven listeners, zero coupling between them. Hover over a consumer to see what the actual connection code does.
InventorySystem
Single source of truth
inventory_changed
QuestSystem
Step progression
HUD
Quest tracker update
InventoryScreen
Rebuilds grid
ChestScreen
Player-side refresh
CraftingPanel
Ingredient counts
first_time_item_acquired
Game
Item-get cinematic
EncyclopediaSystem
Discovery record
HUD
Item popup
Data-Driven Resources
Code written once to be infinitely scalable
Every piece of game content, including the items, quests, enemies, NPCs, dialogue, and recipes, is defined in structured data files rather than hardcoded into the actual game logic. Each content type has its own DataResource class that extends Godot's built-in Resource, declaring its fields as exported properties. Content is authored entirely in Godot's Inspector panel with full type safety and no code required.
I had to consider not only accessibility in the gameplay itself, but also for the development process to make it easier for myself. This data-driven approach matters for accessibility during the development process because it means adding or modifying content never risks breaking game systems. Adding a new quest requires zero code changes. You simply create a new resource file, set the steps via Inspector enums, and the QuestSystem handles auto-accept, progression, completion, and UI updates through existing signals. The entire quest pipeline in one sentence: gameplay event triggers notify_event, QuestDatabase matches the step, QuestSystem advances state, signals fire, and the HUD updates, including the quest arrow recalculation, and NPC indicators refreshing, all without any system knowing about the others.
The same architecture supports localisation, making it quite easy to add new languages in the future. All player-facing text comes from CSV files that the database resolves at runtime through Godot's built-in translation system. Adding a new language means adding a column to a spreadsheet, not touching game code.
What I'd Do Differently
Ashvale taught me what works in Godot, but finishing a project also means seeing clearly what you'd change if you had to do it again. The best evidence of learning isn't listing what you got wrong. It's showing what you did about it. Each of these improvements is already implemented in The Majestic Quest, my current project.
AshvaletoTMQ
Per-Autoload Signals → Single SignalBus
In Ashvale, each autoloaded system owned its own signals. InventorySystem declared inventory_changed, QuestSystem declared quest_completed, and so on. This worked well for the most part, but it created an annoying inconsistency. Some systems, like the EncyclopediaSystem, needed to track enemies and harvestables that couldn't use the signal pattern cleanly because they weren't autoloads. Those cases fell back to direct method calls, breaking the otherwise clean decoupling.
In my new project, The Majestic Quest, all cross-system signals live in a single SignalBus autoload. Every system communicates the same way, no exceptions. It doesn't matter whether the emitter is an autoloaded singleton or a scene-tree node because the SignalBus is always available and the pattern is always the same. The inconsistency that crept into Ashvale's architecture is eliminated by design.
AshvaletoTMQ
Inheritance → Composition for Data Resources
Ashvale gave each content type its own DataResource class, such as ItemDataResource, QuestDataResource, HarvestableDataResource, etc. Each class declared all its fields directly. This was fine for a thesis-scale project, but it meant that adding a new content type always required a new class, and shared fields were duplicated rather than reused.
The Majestic Quest uses a composition approach instead. A base item carries a common set of fields like ID, category, sell price, and stack size, and type-specific behaviour is attached as a separate, self-contained data chunk. A strawberry gets crop data plugged in (growth days, seasons, harvest amounts). A copper sword gets weapon data (damage, tier, weapon type). The base item never needs to know what type it is. Adding a completely new item type means creating a new data chunk, not modifying the base structure.
You can see this in action in the Majestic Quest data explorer: each item shows its “Base Data” next to a type-specific panel, which is this composition pattern rendered as a browsable interface.
AshvaletoTMQ
Manual Playtesting → Test-Driven Development
Ashvale's testing was entirely manual in that I played through the game repeatedly to verify that systems behaved correctly. For a thesis prototype this was workable, but it meant that regressions were caught late, and confidence in changes was based on memory rather than automated verification.
The Majestic Quest uses GdUnit4 for test-driven development. Tests define the expected behaviour before the feature is built, and the test suite runs automatically to catch regressions. This is the kind of professional development practice that matters in a production codebase, and adopting it organically from a real limitation, rather than just listing it as a skill, shows I fully understand why it is necessary.
Explore the Project
Play The Undoing of Ashvale on itch.io or browse the public repo yourself.