The Order of the Hollow Star
Systems Design — Full Breakdown

Description: 
An RPG where combat, faction reputation, and NPC memory dynamically shape quests, world state, and player progression
Discipline: 
Systems Design, Behavioural AI, Narrative Systems Architecture
Engine: Unreal Engine 5 (Blueprints, C++)Tools: 
C++, Blueprints, Behaviour Trees, EQS, UE5 DataTables, State Machines

Jump to: The System • Architecture • System Breakdown • Scenario • Interdependency • Failure Case • My Approach • What I Built • Full Project Page
What Is the System?
The Order of the Hollow Star is a behavioral narrative system where player actions, not explicit choices, drive story progression. NPCs continuously evaluate player behavior across variables like proximity, gaze, dialogue tone, and time investment to update emotional states such as trust, loyalty, and suspicion. These states dynamically gate dialogue, relationships, puzzle access, and narrative outcomes.
Instead of selecting from dialogue options, players express intent through movement, attention, and presence, creating a system where narrative emerges from behavior rather than choice selection.
The defining feature:  Narrative progression is inferred, not selected. The system interprets player behavior and converts it into emotional state changes that reshape the world. 6 emotional variables tracked per NPC, driving 100+ narrative conditions from 30–40+ behavioral inputs per session.
CORE DESIGN PHILOSOPHY
Emotion is not feedback, it is a gameplay system. The goal is not to tell players how characters feel, but to make players infer it through consequence, ambiguity, and delayed response.
WHAT THIS ENABLES
Players are not choosing who they are, they are revealing it. The system captures patterns across time, meaning identity is formed through consistency, contradiction, and hesitation rather than isolated decisions.
Design Inspiration: Disco Elysium was the primary reference: its skill economy makes every action a statement about who you are, not just what you can do. The Nemesis System from Shadow of Mordor was the closest technical parallel: 30+ NPC state variables continuously influencing behavior, access, and world response. Detroit: Become Human demonstrated how branching narrative gates feel earned when driven by accumulated relationship state. Hades showed how NPC emotional states can directly modify gameplay outcomes across sessions.
System Architecture
The entire system flows through one pipeline: player behavior is continuously evaluated, converted into emotional state changes, and resolved into world responses. Nothing is triggered by explicit choice, everything is inferred from accumulated behavior.
Player Behavior
movement · proximity · gaze · dialogue tone · time investment · hesitation · avoidance
↓
State Evaluation Layer (C++ + Blueprint)
weighted evaluation · delayed vs immediate checks · state transitions across NPC emotional models
↓
Emotional State System
Trust · Loyalty · Fear · Suspicion · Respect · Affection — multi-state combinations per NPC
↓
World Response Layer
dialogue branching · NPC availability · trial access · puzzle conditions · failure states
↓
Narrative Outcome ↺
different story paths · locked/unlocked information · shifting alliances · failure consequences
Narrative is resolved from accumulated behavioral state. Every outcome is the consequence of who the player has been, not what they selected.
System Breakdown
A. Emotional Evaluation System — The Core Engine
The system that makes everything else work. Player behavior is continuously evaluated and accumulated over time across 30–40+ input variables, weighted, and converted into interpretable emotional signals without exposing the underlying logic to the player.
BEHAVIORAL INPUTS TRACKED (30–40+ PER SESSION)
Proximity → time spent near NPCs, distance maintained during interactions, approach vs avoidance patterns
Gaze / Attention → eye contact duration, attention direction during NPC speech, gaze breaks at critical moments
Dialogue Tone → frequency of interaction, honesty vs evasion patterns, promise-keeping across sessions
Hesitation → timing delays before actions, pauses before dialogue choices, contradiction between stated and enacted intent
Avoidance → consistent disengagement patterns, route avoidance, deprioritization across sessions
Time Investment → time spent with each NPC relative to others, prioritization during limited-time scenarios
Action Timing → whether help arrives early, late, or not at all — NPC remembers timing of support across scenarios
Design intent: Convert ambiguous player behavior into interpretable emotional signals without exposing the underlying logic.
B. NPC State System — The Memory Layer
Each NPC maintains six persistent emotional state variables, updated continuously based on behavioral inputs. States are not binary — they blend, decay, reinforce, and conflict. A player can be trusted but feared simultaneously.
NPC StateBehavioral InputsWorld Effect
TrustDialogue honesty, time invested, promises keptReduced costs, expanded access, better rewards
LoyaltyConsistent prioritization, sacrifice for NPCUnlocks alternative narrative paths, NPC assists proactively
FearIntimidation, resource control, power displaysShort-term compliance, long-term instability and betrayal risk
SuspicionAvoidance, hesitation, contradictory actionsIncreased costs, restricted dialogue, withheld information
RespectDemonstrated competence, consistent behaviorImproved conversion efficiency, NPC shares hidden knowledge
AffectionAttention, proximity, emotional investmentAccess to unique narrative outcomes and hidden content
NPCs should feel like they remember behavior — not just respond to isolated events. State decay and reinforcement ensure that sustained patterns matter more than individual moments.
Design intent: NPCs should feel like they remember behavior, not just respond to isolated events.
These states are not independent meters, they interact. High Trust with low Loyalty produces different outcomes than high Loyalty with high Suspicion, creating emergent relationship dynamics rather than fixed archetypes.
C. Emotion-Gated Progression System
Replaces binary quest gating with dynamic emotional thresholds. Progression gates require specific NPC state combinations, not just currency or level requirements. Two players who made the same explicit choices can reach completely different outcomes based on how they behaved.
EXAMPLE GATE
Trial door unlocks when: NPC Trust ≥ threshold AND Loyalty ≥ threshold AND Suspicion ≤ threshold

All three must be true simultaneously and all three are shaped by behavioral history, not explicit choices. A player who made "correct" dialogue selections but showed avoidance behavior will be blocked.  
Design intent: Progression should feel earned through relationship, not unlocked through completion.
SYSTEM INSIGHT
Correct choices do not guarantee progress. Players who say the "right" things but behave inconsistently are treated as untrustworthy — reinforcing that intent is measured through behavior, not dialogue.
D. Consequence and Failure System
Emotion directly determines success and failure — not as flavor text, but as gameplay consequence. Emotional missteps carry real weight.
Behavioral MisstepEmotional ResponseConsequence
Breaking eye contact at critical momentSuspicion spikesImmediate trial failure — game over state
Consistent avoidance of an NPCTrust erodes over sessionsPermanently locked dialogue branches
Prioritizing self over NPC in crisisLoyalty drops sharplyNPC withholds key information, narrative branch closes
Intimidation tacticsFear rises, Trust fallsShort-term compliance, long-term betrayal risk
Hesitation before promisesSuspicion accumulatesNPC stops sharing information, costs increase
Design intent: Emotional missteps must carry weight — not just alter flavor text, but close doors permanently.
Consequences are asymmetric, some mistakes close paths permanently, while others reshape future interactions, ensuring that failure creates new narrative states rather than simple resets.
E. Technical Architecture and Tooling
Built entirely in Unreal Engine 5 using a modular, data-driven architecture that allowed real-time tuning during playtests without recompilation.
State evaluation, thresholds, and progression gates were fully data-driven, allowing live tuning of emotional logic without recompilation and enabling rapid iteration across playtests without engineering involvement.
Technical Stack
C++ NPC state component — 30+ state transitions
Blueprint dialogue and narrative sequence integration
UE5 DataTables for all thresholds and scaling curves
Editor widgets and debug UI for real-time state visualization
Tooling Goals
Tune emotional thresholds without touching code
Visualize NPC state in real-time during playtests
Identify state transition failures instantly
Iterate rapidly between playtest sessions
Design intent: The system must be tunable at design speed, not engineering speed.
Example Gameplay Scenario
The player promises to help an NPC during a critical moment, then repeatedly delays returning. No explicit failure state triggers. The system just watches.
01
Player Promises to Help
verbal commitment made — Loyalty threshold begins tracking
↓
02
Player Repeatedly Delays
avoidance pattern registered · time investment drops · inconsistency logged
↓
03
Emotional State Shifts
Loyalty ↓ · Suspicion ↑ · Trust begins eroding
↓
04
Player Returns
dialogue options reduced · key information withheld · trial gate locked
WHAT THE PLAYER EXPERIENCES
The NPC is cooler. Less forthcoming. A door that should open doesn't.

The player didn't fail a quest. They failed a relationship and the system registered it without ever showing them a warning.  
This is the system working as designed. No failure screen. No explicit feedback. Just consequence — delivered through the world.
System Interdependency
No single system controls narrative, it emerges from the interaction between behavior tracking, emotional evaluation, and world response.
Player identity is not chosen — it is inferred by the system.
This creates a feedback loop where behavior shapes emotion, emotion shapes access, and access reshapes future behavior.
Behavior Tracking
30–40+ input variables
Emotional Evaluation
weighted state transitions
NPC Memory
persistent state per character
feeds into ↓
updates ↓
gates ↓
Emotional State
Trust · Loyalty · Fear · Suspicion · Respect · Affection
↓ shapes
↓ modifies
↓ resolves
World Response
access · costs · dialogue
Progression Gates
trials · narrative paths
Narrative Outcome
story · alliances · failure
CASCADE EXAMPLE
Player avoids NPC during crisis → Loyalty drops → Trust erodes over sessions → Trial gate requires Trust + Loyalty → Trial locked → Narrative branch permanently closed → Player never receives key information → Story resolves differently  
System Failure Case: Emotional Systems Becoming Visible
When players can see the system, they stop roleplaying and start optimizing. That was the failure.
What Players Did
Optimized emotional stats like resource bars
Treated NPC relationships as meters to fill
Lost immersion — the system became visible
Stopped making identity-driven decisions
Why It Happened
Feedback was too immediate — cause and effect too obvious
Emotional logic became predictable and gameable
UI surfaced state changes too directly
The system exposed itself
ROOT CAUSE → FIX → RESULT
Immediate feedback → Introduced delayed evaluation — state changes now accumulate before surfacing, breaking the direct cause-effect loop
Predictable logic → Reduced visible feedback and shifted emotional responses into NPC behavior rather than UI indicators
System exposed itself → Moved state visualization to debug UI only — players infer emotional state from NPC behavior, not from meters
After the fix: players stopped optimizing and started reading NPCs emotionally. They began making decisions based on perception and uncertainty rather than calculated state management which was exactly the intended experience.
  The goal was not to hide the system completely but to make it felt rather than seen.
My Approach
I approached emotional systems as interpretive systems rather than reactive ones, focusing on how players express intent through behavior over time, not how they select isolated choices.
Step 1 — Behavior Modeling
Mapped all player actions that could carry emotional meaning, not just dialogue choices, but spatial behavior, timing, attention, and avoidance. Built the input variable set from the ground up rather than inheriting a binary dialogue tree structure.
Step 2 — Non-Verbal Systems Design
Designed the evaluation layer to weight non-verbal inputs as heavily as dialogue choices. Proximity, gaze, and timing can override explicit dialogue tone — a player who says the right words while avoiding eye contact is read differently than one who maintains presence and attention throughout.
Step 3 — Emotional Threshold Design
Replaced binary pass/fail gates with multi-variable emotional thresholds that require sustained behavioral investment to reach. No single action unlocks a gate — it requires a pattern of behavior across multiple interactions and sessions.
Step 4 — Consequence Reinforcement
Iterated on consequence design across 8+ structured playtests to ensure emotional missteps felt real. Introduced high-stakes failure moments — including instant death from breaking eye contact — so players understood that emotional behavior had mechanical weight, not just narrative flavor.
DESIGN PROBLEM → DESIGN RESPONSE
System too visible → Delayed evaluation, moved feedback into NPC behavior not UI
Binary gating → Multi-variable thresholds requiring sustained behavioral investment
Emotion felt like flavor → High-stakes failure states where emotional missteps have hard mechanical consequences
Disconnected systems → Merged economy and emotional state — costs, access, and progression all gate on NPC emotional variables
Results
The system shifted player behavior from optimization to interpretation. Players began reading NPCs emotionally, making decisions based on uncertainty, trust, and perception rather than visible systems.
30+
NPC state combinations tracked in real-time per character
100+
branching narrative conditions driven by accumulated emotional state
8+
structured playtests reducing progression breaks to near zero
PLAYER BEHAVIOR INSIGHT
After the system matured, players began reading NPCs emotionally rather than mechanically:

"I don't think she trusts me — I've been ignoring her during the trials."
"I need to spend more time with him before I ask for help."
"I shouldn't have looked away. I could feel something shift."

Players were no longer managing state variables. They were forming relationships. That's when the system was working.  
BEFORE
Players optimized emotional stats like resource bars
NPC relationships felt mechanical and gameable
Narrative gates felt arbitrary and disconnected
Immersion broke when the system became visible
AFTER
Players read NPCs emotionally, not mechanically
Decisions driven by perception, uncertainty, and trust
Narrative outcomes felt earned through behavior
95% of playtesters reported no progression-blocking issues
What I Built
SYSTEM CONTRIBUTIONS
Behavioral AI → Designed an emotion evaluation system tracking 30–40+ behavioral inputs per session — proximity, gaze, timing, hesitation, and avoidance — weighted and converted into NPC emotional state without exposing logic to the player
NPC State Machines → Engineered a 6-variable NPC emotional state system across 30+ states — Trust, Loyalty, Fear, Suspicion, Respect, Affection — driving dialogue access, progression gates, and narrative outcomes in real-time
Branching Framework → Built a branching narrative framework with 100+ conditional paths resolved from accumulated behavioral state — not discrete choice selection
Emotion-Gated Progression → Implemented multi-variable emotional thresholds replacing binary quest unlocks — gates require sustained behavioral investment across sessions, not single actions
Data-Driven Tooling → Developed UE5 DataTable-driven tuning tools with debug UI for real-time state visualization — enabling full iteration without recompilation across 8+ playtest sessions
Key Design Takeaways
Emotion is a gameplay system, not feedback
When emotional state has mechanical consequences — costs, access, failure — it stops being flavor and becomes the game. The goal is not to show players how NPCs feel. It is to make players uncertain about it.
Behavior is richer data than choice
What players do between choices reveals more about intent than what they select. Proximity, timing, and attention are harder to game than dialogue options — which makes them better inputs for a system designed to resist optimization.
Visible systems get optimized
The moment players can see the emotional logic, they stop roleplaying and start calculating. Ambiguity and delayed feedback are not design weaknesses — they are what protect the system's intent.
Consequence must have mechanical weight
Emotional missteps that only affect flavor text teach players that emotion is decoration. When breaking eye contact ends a run instantly, players learn that emotional attentiveness is a survival skill — and the entire system changes meaning.

← Back to Full Project Page