Skip to content
Andrew Popov

Project · 2026

Blood Rogue

A Diablo II-inspired roguelite deckbuilder playable in the browser, with phase-driven party combat, five acts, and seven playable classes.

Role: Creator
  • TypeScript
  • HTML
  • CSS
  • Electron
  • Playwright
  • Prisma
  • SQLite
Live site →

Project snapshot

Live browser game title screen with Begin Expedition and Battle Arena options.
Live deployment screenshot.
Status
Playable browser roguelite deckbuilder.
Scope
Five-act run structure, seven playable classes, three skill trees per class, bosses, elites, items, runes, and rewards.
Runtime
Plain TypeScript and DOM rendering on a single HTML page, with an Electron desktop package.
Balance
Headless simulation harness validates combat math, power curves, and economy tuning.

Technical proof

  • Deterministic turn-based combat with visible enemy intents and scripted boss phase behavior.
  • Profile persistence tracks active runs, stash, history, unlocks, and settings through SQLite and Prisma.
  • No frontend framework or canvas: views are rendered by diffing plain-object state into string-generated DOM.

In the app

Hero select screen showing the Amazon class with base attributes and a playstyle profile.
Hero select — eight classes, each with attributes, playstyle bars, and unlock gates.
Encounter route choice during a run, with three route cards offering different rewards.
In-run route choice — each path trades a combat modifier against a reward type.
Town camp screen with healer, blacksmith, vendor, and mercenary captain NPCs.
Wake Camp — town services between encounters: healer, vendor, mercenary hire, stash.

What it is

Blood Rogue is a browser-based roguelite deckbuilder built from scratch in TypeScript, drawing on Diablo II for its setting, classes, and item vocabulary. Runs span five acts — each a sequence of world_map -> encounter -> reward nodes — with quest events, shrines, aftermath events, and boss encounters routed through the same loop.

Combat and classes

Combat is deterministic and turn-based. The player fields a hero and one mercenary companion against procedurally chosen enemy groups. Enemies display visible intents each round; mercenaries act automatically; bosses follow scripted phase behaviors; elite enemies carry randomized affixes. Energy is spent to play cards from a shuffled deck, and card effects cover damage, guard, status conditions, summons, minion phases, chain triggers, and skill-window bonuses.

Seven classes are implemented — Amazon, Assassin, Barbarian, Druid, Necromancer, Paladin, and Sorceress — each with three skill trees. Skill points are earned on level-up and spent in trees; reaching five ranks in a skill unlocks the upgraded Card+ variant. Rewards after each encounter offer new cards, card upgrades, boons, items, runes, or runewords. Town screens between acts cover healing, belt refills, mercenary hire or revival, and a vendor with buy/sell flow.

Architecture

The entire runtime is plain TypeScript compiled with tsc and loaded as IIFE modules on a single HTML page — no framework, no canvas. All game state lives in plain objects; views are rendered by diffing against the DOM using string-based HTML generation. The project also packages as a desktop app via Electron.

Progression persists across sessions via a profile layer backed by SQLite through Prisma. The profile tracks active-run state, shared stash, run history, account-level unlocks, and preferred settings. A sim harness with dozens of balance scripts runs headlessly to validate combat math, power curves, and economy tuning.