Show HN: Neural emotion matrix for NPCs
github.comHey! I built this system to humanize NPCs by giving them emotions using Rust and ML.
The system provides emotion coordinates (based on Russell's circumplex model) from text input or actions, with persistent emotional memory per entity. Think NPCs that remember how they feel about specific players or events.
I pre-trained a DistilBERT model on ~1k video game dialogues (Skyrim, Cyberpunk, etc.) and plan to extract and evaluate 100k+ dialogues soon. However studio/team can manually add dialogues to enrich their own dataset.
The matrix doesn't generate dialogue, it only analyzes content. When you pass text or an action, it returns emotion coordinates on the valence (pleasant/unpleasant) and arousal(energetic/calm) scale. For example:
- [0.00, 0.00] = neutral
- [0.29, 0.80] = excited
- [-0.50, -0.30] = sad/tired
I made a quick visualizer here to help understand https://valence-arousal-visualizer.vercel.app/
The system helps select which dialogue/action to play based on emotional state:
- Player says something bad to NPC → system detects negative valence → game picks from "angry dialogue pool"
- NPC remembers past positive interactions → system returns positive valence → friendlier responses available
So, the devs still write the dialogues or choose the next actions, but the matrix helps manage NPC emotional states and memory dynamically.
Here's the project structure to better understand how it works:
- src/config: Helper utilities for NPC configuration setup
- src/module: The core engine with emotion prediction, memory storage, and entity management
- src/api: FFI layer with pub extern "C" to bridge our modules with C/C++ game engines and modding tools (Unity, Unreal, etc.)
To implement it, just call `build.sh`, it will create DLL files that you can use to call the matrix functions directly in C++/C/C#.
I'd love feedback on code quality and overall architecture.
Feel free to be honest about the good, the bad, and the ugly. PRs welcome if you want to contribute!
Isn't the whole system somewhat too limited? An interaction can be unpleasant and pleasant at the same time, like getting food offered I dislike when I am very hungry. Instead, shouldn't it be preferable to model the inner state of NPCs with a high dimensional vector space plus fading memory? Folk psychology emotions could than be interpreted as reductions of this high dimensional vector space. We also could use a part of the vector space for a dynamic feedback system, such as adjusting the fading of a particular memory depending on particular values (intens events remain longer in memory, ...) an overall condition (repeated recent events remain longer in memory; certain recent events in close proximity in the vector space improve their memorization, ...), other memories, etc.
That's super interesting. Yeah, the 2D model has limitations for sure. Actually, we have a memory decay system with time, but nothing as elaborate as what you're describing. I'm curious to know more about your idea. Theoretically, how would you imagine separating memories? Would you use memories clusters with different weight for example ?
Regarding modelling memory: Years ago, I was just for fun implementing different strategies for NPCs to walk around and interact with each other (little dots an a hex map). The NPCs had different personalities. For example one was an explorer prefering to move to unknown areas on the map. Another was staying at home and foraging. They could than exchange information of the world (memory) for food. Here the memory was quite specific: Each NPC had his own map of the world consisting of his personal knowledge and what he aquired by information. Some memories were static (the feature of the terrain), others dynamic (the last know location of another particular NPC). I had no concept of fading or inacurate memory. In the case of dynamic memories, the latest information was just overriding the older.
> Theoretically, how would you imagine separating memories? Would you use memories clusters with different weight for example ?
There are, of course, a lot of possibilities. I was always fascinated by the idea to use something like a Semantic Web as the basic structure to represent memory, because it is so flexible. Every atomic memory element is a subject-predicate-object or subject-predicate-value triple. We can build bigger memory structures just by repeatedly using the same entities for subjects or objects. The predicates may be predefined ontologies and/or themselves be represented as (higher order) subjects/objects modelled by very fundamentel predicates (like "<A> is a subtype of <B>"). We could model the fading of memory by removing atomic memory elements from the set. We could model the blurring of memory by slightly changing an atomic memory element (like "<Bob> has the haircolour <brown>" into "<Bob> has the haircolour <dark-brown>". For decision making, we could use an algorithm that explores the set memory elements, draws conclusion, prioritieses them according to some evalution function. The possibilites here are endless.
In this model, the combination of certain predicates, the structures resulting from them and of particular algorithms that operate on them are constituting a memory cluster. For example, if the NPC is hungry, this may activate an algorithm that looks for the predicate "<x> is of type of <Food>", then for every x found looks for "<x[1]> is located at <y>", then for every location tries to determine a path to that location by connecting memory elements ("The cheese is in the fridge", "The fridge is in the kitchen", "The kitchen is adjacent to the living room", "The armchair is in the living room", "The NPC sits in the armchair").
Going back to my old example of getting food offered I dislike when I am very hungry, this could be modelled as: "<Offer> is of type <Event>", "<Entity-4758> is of type <Offer>", "<Entity-4758> has actor <PC>", "<Entity-4758> has receiver <NPC-6587>", "<Entity-4758> has transfer-item <Item-8974>", "transfer-item <Item-8974> is of type <Apple>", "<NPC-6587> dislikes <Apple>", "<Entity-4758> has point in time <T-7125>", "<NPC-6587> has physical state <P-7894>", "<P-7894> has point in time <T-7125>", "<P-7894> is of type <Hunger>", "<P-7894> has intensity '0.95'" (rang from 0..1).[1]
To simulate remembering the situation, we can than run an evaluation function on this data set that gives us a valence/arousal vector. This function may have other parameters (for example the current mood of the NPC) that can modify the outcome of the evaluation. Or we can simulate the fading of memory by randomly modifying the value of predicate "<P-7894> has intensity '0.95'" towards neutral, or the object of "transfer-item <Item-8974> is of type <Apple>" into <Banana>. Both of which would change a later evaluation of event <Entity-4758>.
Not all of the predicates from my example represent memory in the strict sense. Some represent built in ontologies that should not change ("<Offer> is of type <Event>") or treated as immutable facts to keep things simple ("<NPC-6587> dislikes <Apple>"). Our algorithms that modify memory must not change them (unless we want to simulate that a NPC starts to become crazy).
Why such detailed modeling of memory mechanics? Would it really enhance NPC interactions that much to be worth it?
Is this related to https://qualiacomputing.com/2020/12/17/the-symmetry-theory-o...?
Probably I haven’t read the whole article, but it seems to be based on the Russell circumplex model of affect (valence/arousal).
https://www.researchgate.net/publication/235361517_A_Circump...
Excited for stuff like this as a CRPG player. A possible future for designing a crpg NPC might be to write a bunch of memories, descriptions, likes and dislikes, etc. in text instead of trying to convey those through branching dialogue.
Yeah, that’s the kind of direction I’m hoping for too. It could be hard to follow a narrative without branching dialogue, but maybe it will raise a new kind of NPC
Could you provide an example conversation that showcases the quality? For example either inferring states of npcs and re-ranking response options?
Kind of reminds me of the social interaction puzzle in oblivion :)
I plan to work on a Skyrim follower mod to showcase this in action. Meanwhile, you can try a short conversation example in main.rs if you want to test it without using C++ :)
This is really cool - the sort of thing I love seeing on HN. I'm very deeply interested in developing/interacting with realistic characters within a game world and watching them interact with another, e.g. intertribal/interpersonal squabbles in a kobold tribe, that kind of thing. I think the potential for this sort of experience in gaming is really untapped and is going to be incredible.
Thank you! Yeah, there are many use cases. The goal is really to expand what's possible with NPC interactions and emergent behaviors
Is there any specific reason to use this over e.g. manually setting an "emotional score" for specific dialogue? Maybe I'm misunderstanding how this works, but from a game design perspective I'd be a bit worried about the model inferring the emotion incorrectly, or more generally having a lack of control over the specific values being used.
Good question! Actually, it complements manual settings. There are many use cases but for example, in some games with multiple followers. You sometimes get bugs where they fight each other randomly for some reason. With this system, you could check their emotional state toward each other before triggering combat, and if they're actually friendly, you prevent the unintended fight
Looks really cool but I'm wondering if the whole Docker setup was necessary just to get onnx?
Thank you! Yes, I use Docker to get ONNX DLLs and cross-compile the main DLL using the MSVC toolchain (which is required for game engines)
>call the matrix functions directly in C++
Sweet so it can be used in unreal engine it would be awsome to see this used for a local llm game that can generate it's own unique NPCs
Thanks, that's an interesting idea! Some games need predictable dialogue, but as an option it could be great
[dead]