G.Franco
PT-BREN
← All projects

2026 - Present

Beneath the Eternal Flame

Programmer & Game Designer

In active development, no public build yet. A party-builder / narrative dungeon crawler with turn-based push-your-luck runs, developed in collaboration with a co-developer (lore and visual direction). Players lead a lineage of explorers, draft an imperfect party, build a loadout each run, and decide how much risk is worth taking before heading back. Single-player PC, 15-30 minute sessions, custom retro CRT presentation. Built in Unity 6 (URP), reusing the Steel Horse Framework as a submodule. I own the game design and all of the programming systems.

In development, not available for testing yet

Screenshots

Game Design

  • Designed the core attribute system: all attributes start at -3, with 12 points to freely distribute at character creation, so a build can carry deliberate weaknesses instead of only strengths.
  • Designed the event resolution formula (roll + leader's bonus + assist contribution from the rest of the party, weighed against a floor-scaled difficulty), and the floor difficulty curve that scales with tier and progress within that tier.
  • Designed the dual-currency economy: a permanent "vault" gold that persists in town versus a run-scoped "bag" gold that's subject to loss, with hired party members taking a percentage cut of net profit, and a guaranteed minimum payout floor so a bad run never feels worthless.
  • Designed the permadeath continuity model: a "Snapshot" system lets the lineage continue through a registered successor if the protagonist dies mid-run, and a purchasable "Clone" softens the loss of a full party wipe, as two distinct systems solving different failure states.
  • Designed the Obelisk Flame modifier: a global, visible-in-advance run modifier that shifts item/enemy/event weights without fully determining outcomes, changing each play cycle rather than in real time.

Character & Party Systems

  • Built a data-driven stat architecture (Attributes, Resources, and an IModifier pipeline with four composable strategies: flat, tag-conditional, resource-scaled, and a stubbed flame-based modifier), replacing an earlier buff/debuff prototype.
  • Built a PartyController that aggregates four party members into party-level stats (leader plus the floored average of the rest), handles automatic leader reassignment when the leader is incapacitated, and resolves damage across single, random, or whole-group targeting.
  • Built a live dungeon HUD (portraits, health, attributes, injuries, leader badge) using a dumb-view/owning-controller event pattern that refreshes only the single UI cell that changed, rather than re-binding the whole party display.

Character Lifecycle & Persistence

  • Designed and built three explicitly distinct character lifetimes: player-authored Player Characters (saved to disk, one AES-encrypted JSON file per character for independent permadeath), procedurally generated Generic NPCs (roster filler, discarded after a run), and hand-authored Important NPCs (dialogue-only, never playable).
  • Built Player Character creation on a fluent Builder pattern, with a schema-migration hook (IVersionedSaveData) so future save-format changes won't break existing player saves.
  • Tracked a persistent town currency separately from the per-run resource pool, so meta-progression and run-scoped risk never get mixed up in the same number.

Dungeon System

  • Built the floor-exploration flow on a State pattern (base state controller, exploration state fully implemented, encounter/interactable/loot states stubbed for future work), driven by a scene-local manager recreated fresh per scene load rather than a persistent singleton.
  • Wired all six core player actions (Explore, Rest, Flame Offering, Next Floor, Return Risky, Return Safe) end-to-end at the UI/event level, with a fade-transition curtain between states.

Rendering

  • Built a custom two-camera retro CRT rendering pipeline: a low-resolution RenderTexture pass sampled by a Shader Graph CRT material (warp, scanlines, static, phosphor stripes), kept in sync with the player's actual resolution at runtime.

Engineering Practices

  • Maintain a running architecture and design-decisions log documenting why choices were made, not just what was built, including self-corrected mistakes (an accidental singleton, a wrong attribute-scaling formula) preserved with their rationale rather than silently fixed.
  • Recently hardened the UI for Steam Deck by converting canvases and HUD elements to stretch anchors for resolution independence.

Technologies

  • Unity 6 (URP)
  • C#
  • ScriptableObjects
  • Shader Graph
  • Unity Localization
  • Unity Input System
  • DOTween
  • GitHub Actions