If, over the past decade or so, the default indie postmortem script has been “I carried programming, art, music, and writing alone, then closed by saying never solo again,” then on 10 September 2026 Ben (credited as RNG), on itch.io, almost rewrote how that bill gets settled. The game is *Memento Manor*: a top-down spooky RPG in mission format inside a manor held by paranormal Residents. You play Mara Kalina, a paranormal investigator hunting stolen Mementos inside nightmares of past cases. The engine is Godot; scripts moved from GDScript on the prior project *Phantom Forest* to C# / .NET. This piece has not playtested the finished build; scenes and systems below come from the author’s public postmortem and from observation of the game page.
The through-images here are “signal up” and “the queue at the door.” The first sounds like scene-tree hygiene; as production ethics it is a verifiable decoupling promise: a child can speak without knowing its parent, and the parent takes references downward when it needs them on demand. The second sounds like an engineering joke—everyone knows doors drag programmers into the mud—yet in Ben’s write-up it is the honest battlefield of solo work: one door must serve Open, Peek, and Loud Knock, queue multiple Residents through, and force the player out of Peek when a Resident opens the same door. The weight of solo is not the slogan of being “full-stack”; it is these systems nailed one by one until the author can say: next round, I want to collaborate.
1. Default logic: solo means omnipotence; global managers mean convenience
Industry default logic is clean, and therefore lazy.
When one person ships a whole game, teams usually open a familiar menu: dump all persistent state into one giant Game Manager; copy level trees with scene inheritance so “add one node” fans out everywhere; hang a single “press E to interact” on objects; hard-code NPC paths from A to B; call a top-down view “done” once it looks like sprites glued to a background. Players learn the same vocabulary for reading solos—“playable is enough,” “programmer art has charm,” “a hitch in the door animation is fine.” That pact turns solo roughness into forgivable industry grammar.
*Memento Manor* is hard to absorb into that grammar: the manor splits render and collision by room; Residents carry Routine / Search / Chase / Sleep / Wander / Stunned / Trapped; missions customize rooms, Residents, door links, and pickups through Investigation structs; the player has Walk / Run / Idle / Busy / Peek / Faint. The aim was a complete experience, not a demo that boots. Stuff that into one person’s schedule, and industry instinct points almost automatically at “cut systems, cut doors, cut the second floor.”
Ben’s public postmortem refuses the self-consolation of that shortcut. He is blunt: solo is a lot of work; he knew that beforehand, but had to see the *why* firsthand. He is primarily a programmer; his best work is behind-the-scenes functionality—yet choosing solo means music, graphics, and dialogue must be learned too. The sharper line is not self-pity but direction: he looks forward to collaborative projects next, because solo taught him the basics of other roles so he can write his piece with those pipelines in mind. The fork is here. Default asks what to cut when one person cannot carry it. He asks which decoupling, if written right while one person *can* carry it, keeps the next collaborative round from dragging the same coupling back into the mud.
2. Breaking the script: signal up, reference down, and state machines that make “busy” explicit
Decoupling is easy to claim and hard to prove. The “sure win” often means making everything a global singleton, or treating scene inheritance as free duplication. Ben arrives with prior experience: *Phantom Forest* already used GDScript; moving to C# was not only “know another language,” but fear that GDScript-only work would limit future engine and IDE options, while .NET Godot plugs into Visual Studio and lets him keep university-era C#. The postmortem lists hash tables, statics, lambdas, enums, interfaces, structs, inheritance, polymorphism, null-conditional assignment, async, and a custom assert. The intent is hard: if you use C#, do not wear it like GDScript skin.
C# also bills you. Unlike GDScript’s near-instant clear, the GC clears in bulk and infrequently, so freshly cleared refs can still be touched; global managers must never store non-global object refs or scene changes leak; static lists must be duplicated before mutation or shared Resident dictionaries get polluted; local nodes wired to global signals must disconnect in `_ExitTree`—GDScript often clears on scene change, C# does not. These are not abstract pedantry; they are the “small quirks” that explode in month three of solo.
What really breaks the default script is composition and the discipline **signal up, reference down**. Children report upward with signals without knowing the parent; parents hold downward references when they need live data. A HealthComponent-style child can hang on player or enemy; an Interact Area as an Area2D child can attach to any interactable, the parent only connecting the “someone in range” signal. Risk is in the same paragraph: poorly documented components blind systems; the fix is names that say purpose (e.g. HealthComponent), short components, single duties. Flexibility is not free—it buys reuse of small systems under different parents, and pays with interfaces that read like contracts for other humans.
State machines here are not textbook nouns; they nail “can this character move right now” into an inheritable method table. Player side: Walk / Run / Idle handle move and interact; Busy strips movement during interactions; Peek also moves door-gap lights and exits immediately on player input, another character using the door, or being seen—then tells the door to reset; Faint waits out the faint animation and in-manor time skip after capture, hiding UI. Resident default is Routine by time and place; NoiseArea or torch in listen / detect range enters Search; raycast line-of-sight enters Chase; at destination, Sleep or Wander; weaknesses and traps enter Stunned / Trapped and often drop a Memento. Overridable Move / Turn on base State let Busy do nothing while Walk must answer input—complexity stays inside the new state instead of a three-thousand-line `if`.
3. Doors, routes, Investigations: writing the hardest system as customizable missions
Beyond frame budgets, solo’s dearest cost is often “one door.” Ben says plainly: among all designs, doors took the most reworks, tweaks, and compromises; Residents may be the most complex object, but doors stayed vicious throughout. The reason is dirt-simple and accurate—doors are rarely only level transitions: they are interactables, environment dividers, usable by multiple character types, lockable, peekable, loud-knockable. Each use wants state change, clean reset, and notice to others that “this door is unavailable now.”
*Memento Manor* doors use a Pokémon-like fade transition rather than walking through the doorway: open sprite, fade character out, move to opposite door marker, fade in, close. Interactables share an Action system; doors hang three standard slots: Open, Peek, Loud Knock. Only one character may open at a time, priority over peeking; if the player peeks while a Resident opens, Peek is forced off until the Resident arrives and a short delay ends; multiple Residents queue, retry after a short delay up to a limit, then unstuck back to routine. The planned “walk in, hide behind the wall, walk out” animation was too slow, too hard, thin gain—so it was cut. That is not romance about finishing everything; it is solo’s expensive honesty: the transition only needs to say “room change,” not perform it.
Navigation pins “NPCs can walk” with concrete structures. Each room gets a NavigationRegion2D; furniture and walls use NavigationObstacle2D; doors link with NavigationLink2D. Residents carry a goal node stepping toward door markers or the end. A Route struct holds start, room list, markers, and step-filter functions; a prefilled connections dictionary yields shortest routes and supports custom room links. The state machine decides when to recompute—Routine maybe once or twice per room; Chase / Search refresh often for moving targets. Rooms own render, collision, ambient lights and sound: player entry lights layers; Residents in other rooms keep nav but skip visuals; collision can disable when empty. The fancier trick is “projectors”: custom SubViewports project a live room “below” another for floor depth—Lobby from Balcony, Garden from Bridge. Intent is visible in the materials; this piece has not measured the feel in play.
The mission heart is the Investigation struct. After the desk selects a case, the manor reads it: rooms dark / locked / disabled, door remaps, Resident types, routines, difficulty, NPC dialogue and placement, pickup chances and order, player start room, items, sanity. Difficulty is not a linear multiply—Resident ratings 1–10 sample a Curve resource nonlinearly into speed, sanity damage, detect radius, and more. The world sits in a 960×540 SubViewport stretched ×2 to align with 1920×1080 UI, Nearest filter for pixels; Tween vs AnimationPlayer is one executable philosophy: “Use tweens when the final value is unknown; otherwise use an AnimationPlayer.” Scene inheritance is explicitly demoted: base scenes forcing nodes waste and bind; he prefers composing scenes, keeping script inheritance inside objects.
Top-down “not flat” is also a checklist, not mood adjectives. Foot shadows scale opacity by size and height; CPUParticles2D dust on move gives weight; Y-sorting makes front/back around NPCs and props hold; near foreground walls and rails fade on approach, outdoor rooms can disable fade to keep enclosure, dark rooms default-fade foreground so darkness stays the main obstruction. Interactables inherit one base, up to three Action slots, dynamically rewritable (locked door, enter/exit wardrobe), with action state names so the player snaps to Busy or the matching state; a global Interaction Manager middleman validates, mutexes, and calls clear on end. On singletons: Game / Save / UI / Player / Audio / Item / Time / Interaction each own a slice—and the author names Item and Time as better local-to-manor today than everywhere-reachable singletons. That is not late-stage humility; it is the rare solo veto: extra globals become black holes nobody dares touch in the next collaborative round.
4. Closing: indie means willing to turn solo into the textbook for the next collaboration
Put this 10 September write-up back into the autumn 2026 Godot solo scene, and it first hits a hidden production inertia. People default solo to omnipotence myth, default more global singletons to convenience, default “the door works” as enough, and rarely ask: is your decoupling saving one person’s next week, or leaving interfaces for a multi-person next project? Ben opens another path. Signal up / reference down can be discipline. State machines can cage Busy / Peek / Faint and Chase / Search in their own method tables. Investigation structs can turn “another mission” into filling a form, not cloning a level tree. Doors can admit they are nightmares and still leave queues and forced Peek exits. He even self-critiques Item and Time Managers: today he would lean local. In a solo postmortem, “I over-scoped globals” is more useful than “I did everything.”
For small teams the packet is sharp and useful. You may lack a full Resident state table or SubViewport projectors. You certainly have a “defaults are fine” list. One interact key only. A door with no queue so the second NPC clips through. A global manager holding refs that should die with the scene. A GDScript-to-C# move that forgot `_ExitTree` disconnects. A top-down with only a background plate—no foot shadow, dust, Y-sort, or near fade. Linear difficulty that “suddenly unfair” at rank ten. Ben’s public homework writes the cost in dirt: solo was to learn other crafts; prototypes can stay solo; full games he wants collaborative; inspirations include *Luigi’s Mansion*, *Gregory Horror Show*, *Amnesia: The Dark Descent*, *Pokémon Platinum*—cited as source notes, not a substitute for play. The itch page lists Windows / Linux, v1.0.0, and “No generative AI was used.”
Executable prompts, short:
- Before the first “global manager” commit, write a discipline line: which updates signal up, which data reference down; when temporary nodes connect to global signals, write `_ExitTree` disconnects in the same change.
- Once character decisions exceed three mutually exclusive behaviors, extract a base State and a state-machine component first; make Busy / immovable states explicit, not scattered bools.
- For doors, teleports, and multi-character shared interactables, design queue, mutex, and forced-exit conditions before debating doorway walk animations.
- Customize mission variants with structs (or equivalent data), not cloned scene trees; sample difficulty on curves, do not linearly explode at rank ten.
- If solo’s exit is “learn to collaborate,” turn non-specialty craft into handoffable interfaces and names, not magic numbers only you can edit.
Signal up, queue at the door, Investigation as forms, and the line “solo development is a lot of work.” While the postmortem stays public and the game stays downloadable on itch, the author already fixed the audit standard: not “can one person finish,” but “after finishing, did you leave the decoupling the next collaborative round needs in the repo.”
Sources and further reading
Ben (RNG) (2026-09-10) Memento Manor - A Paranormal Postmortem Introspection
Game page Memento Manor (Windows / Linux, v1.0.0; notes No generative AI was used)