Applied The Lora Playbook

Mechanics Breakdown

Last reviewed

Beginner

What you'll learn

~30 min
  • Plan and build a Node.js CLI tool that structures freeform gameplay observations into engineering-ready specs
  • Decompose BloodRayne's core mechanics into combat, movement, and enemy behavior systems
  • Output structured JSON specifications for each mechanic with parameters, states, and triggers
  • Generate a pre-filled BloodRayne breakdown as a reusable analysis template

What you’re building

You have spent most of this module on the business case: market analysis, storefront economics, runway planning. You have already played one combat prototype. The spreadsheet side of starting a game company is solid. Now comes the part that actually matters: what does the game play like?

If you watch BloodRayne gameplay footage on YouTube, you see a lot happening at once. Rayne swings blades in multi-hit combos. A blood rage meter fills up and triggers a powered state. Aura vision highlights enemies and objectives through walls. She runs, jumps, climbs walls, grinds on rails. Enemies patrol, get alerted, attack in patterns. It looks fluid in motion, but underneath all of that is a set of discrete mechanical systems — each one with inputs, states, transitions, and parameters.

To remake the game, someone needs to document every one of those mechanics in a format that a game designer or programmer can implement. Right now, that documentation process is “watch footage, take notes, organize notes into a document.” You are going to build a CLI tool that takes your freeform gameplay observations and converts them into structured JSON specifications — one per mechanic, with states, triggers, parameters, and relationships to other systems. The output is something you could hand to a developer and say “build this.”

💬The gap between watching and building

Everyone who has played BloodRayne can describe what it feels like. “The combat is fast.” “The blood rage is cool.” “The aura vision is useful.” But you cannot build a game from feelings. You need: “Blood Rage activates when the meter reaches 100, lasts 15 seconds, increases attack damage by 2x, grants health regeneration at 5HP/sec, and the meter drains at 6.67 units/sec during activation.” That is the difference between a fan and a game designer. This tool bridges that gap.

By the end of this lesson you will have a Node.js CLI tool that accepts freeform gameplay observations (plain text notes from watching footage), parses them into mechanical categories, and outputs structured JSON specifications for each system. It comes pre-loaded with a complete BloodRayne breakdown covering combat, movement, enemy AI, and special abilities.

ℹSoftware pattern: Unstructured text to structured specification

Freeform natural-language input organized into a rigid schema with typed fields, state machines, and relationship graphs. This pattern appears in requirements engineering, scientific observation logging, and any domain where experts think in prose but engineers need specifications. The key technique is defining the output schema first and then mapping observations to it.


The showcase

Here is what the finished tool produces:

  • Input: Freeform text observations from watching gameplay. Example: “Rayne has a 3-hit blade combo, the third hit does extra damage. If she holds attack she does a spinning slash. Blood rage meter fills when she hits enemies, about 10 hits to fill. When activated she does double damage and heals.”
  • Output: Structured JSON for each identified mechanic, with:
    • System name, category, description
    • States (idle, active, cooldown, etc.) with transitions
    • Parameters (damage values, durations, rates, thresholds)
    • Input triggers (button presses, conditions, timers)
    • Relationships to other systems (“Blood Rage depends on Combat Hit Counter”)
  • Pre-filled BloodRayne data: A complete breakdown of all core mechanics, ready to use as-is or modify
  • Multiple output formats: JSON (for code), Markdown (for documentation), or both
  • Validation: Warns about incomplete specs (e.g., “Blood Rage has no defined cooldown — is that intentional?”)
Terminal window
# Use the pre-filled BloodRayne breakdown
node src/index.js --preset bloodrayne --output ./specs
# Analyze custom observations
node src/index.js --input observations.txt --output ./specs
# Generate both JSON and Markdown
node src/index.js --preset bloodrayne --format both --output ./specs

Before you start

If your AI tool is still open from the last lesson, leave it (/exit, or Ctrl+D in Antigravity) so you are back at the terminal prompt. Create a fresh folder for this lesson and step into it:

Terminal window
mkdir -p ~/retro-remake/09-mechanics-breakdown && cd ~/retro-remake/09-mechanics-breakdown

In Windows PowerShell:

Terminal window
mkdir ~/retro-remake/09-mechanics-breakdown; cd ~/retro-remake/09-mechanics-breakdown

Using a desktop agent app? Open ~/retro-remake/09-mechanics-breakdown as your workspace folder instead. Then start your AI tool the way Workbench Setup showed.

Switch to plan mode

Inside your active session, switch to Plan mode (Shift+Tab, /plan, or the mode picker in your desktop app) so the agent clarifies the schema and preset mechanics before writing files.

The conversation

Each message below is an example. Say it in your own words.

Say what you want

Ask for a command-line tool that turns gameplay observations into structured mechanic specs and includes a BloodRayne preset:

I am planning a BloodRayne remake. Build a command-line tool that turns freeform gameplay observations into structured mechanic specs and includes a pre-filled BloodRayne breakdown. Ask me what you need first.

Answer its questions

Your agent will ask about the specification schema, the BloodRayne preset mechanics, output formats, and command-line options. Here are short ways to steer it:

If it asksYou might say
What fields belong in each mechanic specification?States with transitions, numeric parameters with units, player inputs, dependencies, complexity, and source confidence.
Which BloodRayne systems should the preset cover?Eight specs: blade combo, blood rage, feed attack, aura vision, locomotion, wall climb, patrol/alert, enemy attacks.
How should the freeform observation parser work?Group sentences by keyword category, extract numbers with units, and mark parsed values as estimated.
What output formats and validation do you want?Output JSON, Markdown with a table of contents, or both, and warn on missing fields.
Which options should the command-line tool support?Support --preset, --input, --format, --output, and --validate with readable color-coded terminal summaries.

Read the plan

Before you approve the build, check the plan for four things:

  1. The schema is complete: each spec includes id, name, category, states (with transitions), parameters (value, unit, notes), inputs, dependencies, estimatedComplexity, and sourceConfidence (observed, estimated, or speculated), built as a clean Node.js CLI (for example, using CommonJS with commander@14 and chalk@4).
  2. All eight BloodRayne preset systems are planned: blade combo (3-hit chain plus spinning slash), blood rage (0-100 meter, 15s duration, 2x damage, 5 HP/s regen), feed/bite drain, aura vision toggle, core locomotion, wall interactions, enemy patrol/alert FSM, and enemy attack patterns.
  3. Cross-system dependencies and warnings exist: blood-rage and feed-attack depend on combat-blade-combo, wall-interactions depends on core-locomotion, and the analyzer flags incomplete specs such as missing cooldowns or unspec’d references.
  4. Both JSON and Markdown outputs are generated: specs/mechanics.json as a flat array of mechanic objects and specs/mechanics.md with a table of contents, state flows, parameter tables, and dependency summary.

If the plan leaves out the dependency check or confidence field, tell it before approving:

Mark every preset mechanic with an estimated confidence level, and have the tool warn me about missing cooldowns or unspec'd dependencies.

Once the plan covers those details, approve it and let the agent build. When it finishes and passes a test run, ask it to save a Git checkpoint.

💡The preset is the point

For BloodRayne, you want the preset. It contains a complete starting breakdown of estimates for you to check against gameplay footage. The freeform parser is useful for analyzing other games or adding mechanics you notice in footage that the preset does not cover.


What you get

After the agent generates the tool, the project folder structure looks like this:

09-mechanics-breakdown/
package.json
src/
index.js
parser.js
schema.js
analyzer.js
formatter.js
presets/
bloodrayne.js

Fire it up

Ask your agent to install dependencies and run the BloodRayne preset breakdown:

Install what is needed, run the BloodRayne preset to generate both JSON and Markdown specs in ./specs, and show me the summary.

If you prefer to run the commands yourself in a terminal:

Terminal window
cd ~/retro-remake/09-mechanics-breakdown
npm install
node src/index.js --preset bloodrayne --format both --output ./specs

You should see the summary printed to your console — 8 mechanics across 4 categories, with complexity ratings and dependency relationships. Open specs/mechanics.json to see the structured data. Open specs/mechanics.md to see the formatted documentation.

If something is off

ProblemFollow-up prompt
Preset data not loadingRunning --preset bloodrayne says "Preset not found." Make sure the BloodRayne preset loads cleanly from the presets folder when I pass --preset bloodrayne.
Parser doesn’t extract numbersFreeform notes like "about 15 damage" or "lasts 15 seconds" are not pulling out the numbers and units. Extract numeric values and their units (damage, HP, hits, seconds, percent) into the parameter list.
JSON output is nested too deepThe mechanics.json file wraps the specs inside extra nested layers. Output a clean top-level list of mechanic objects where each item has id, name, category, states, parameters, inputs, and dependencies.
Markdown has no table of contentsThe Markdown file is a long scroll with no navigation. Add a clickable table of contents at the top linking to each mechanic section.

How it works (the 2-minute version)

  1. The schema defines what a complete mechanic spec looks like. States, parameters, inputs, dependencies, complexity, confidence. This is the contract between “someone watching gameplay” and “someone implementing gameplay.” Without the schema, observations are just notes. With the schema, they are actionable specifications.

  2. The preset is a set of hypotheses, not data. The BloodRayne preset is a set of starting estimates that the tool formats into structured specs. Treat every number as a hypothesis: check it against footage and change its confidence field to “observed” only when you have. Every preset entry starts as “estimated”; the field earns “observed” only after you have seen that number in footage yourself.

  3. The parser converts freeform text into partial specs. It uses keyword matching to categorize observations and regex to extract numeric values. It is not a natural language understanding system — it is a structured extraction tool. If you write “the combo has 3 hits and the third does 35 damage,” the parser will extract: category = combat, parameter = hits: 3, combo3_damage: 35. It gets you 70% of the way there.

  4. The analyzer fills gaps and builds relationships. It checks each spec against the schema and flags missing fields. More importantly, it identifies cross-references: “Blood Rage increases attack damage” links the blood rage system to the combat system. These dependency relationships are critical for implementation planning — you cannot build blood rage until the combo system works.

  5. The formatter outputs two views of the same data. JSON is for machines — feed it into a game engine, a project management tool, or the next tool in your pipeline. Markdown is for humans — print it, share it in a meeting, hand it to a game designer. Same data, two audiences.

🔍From spec to prototype: what happens nextclick to expand

The JSON output from this tool is designed to be consumed by a game engine or prototyping framework. Here is how each mechanic spec translates to implementation:

State machines map directly to state machine implementations in every major engine. Unreal, Unity and Godot all let you build state machines, either in their animation tools or in code. The states and transitions in your spec become nodes and edges in the engine’s visual editor.

Parameters become tunable constants. In a game engine, you would expose these as configurable values (Unreal: UPROPERTY, Unity: SerializeField, Godot: @export). During prototyping, designers adjust these numbers to tune how the game feels. “Combo window 0.6s” might become 0.5s or 0.7s based on playtesting.

Inputs map to the engine’s input system. “Press attack while grounded starts combo chain” becomes an input binding with a context condition. Modern engines have input action systems that make this straightforward.

Dependencies define your implementation order. You build core locomotion first because wall interactions depend on it. You build the blade combo system before blood rage because the meter fills from combo hits. The dependency graph is your sprint planning tool.

This is not theoretical. Studios working on remakes follow exactly this process: document the original mechanics, structure the documentation, prioritize by dependency, and implement in order. The only difference is that most studios do this with design documents written in Google Docs. You are doing it with a tool that outputs structured data a machine can read.


Customize it

Add visual state diagrams

Turn text-based state machines into visual diagrams:

Add a --diagrams option that generates a state diagram file for each mechanic, showing its states and transition triggers so they render visually in Markdown viewers.

Add a remake comparison mode

Compare your spec against another game’s implementation:

Add a second preset called dmc for Devil May Cry 1 combat and a --compare flag that takes two preset names and prints a side-by-side comparison by category.

Add implementation time estimates

Plan the development sprint from the spec:

Add an --estimate flag that calculates developer-week ranges from each mechanic's complexity, sequences dependent mechanics after their prerequisites reach 50%, and prints a text timeline with the total estimate.

Try it yourself

  1. Walk through the plan-mode conversation above and let your AI tool build the CLI.
  2. Ask your agent to run the BloodRayne preset (or run npm install && node src/index.js --preset bloodrayne --format both --output ./specs).
  3. Open specs/mechanics.json. Look at the blade combo system spec. Every state, transition, and parameter is structured and machine-readable. This is what implementation-ready documentation looks like.
  4. Open specs/mechanics.md. Scroll through the formatted document. The state diagrams, parameter tables, and dependency graph give you a complete picture of what you are building.
  5. Look at the dependency graph. Notice that combat (blade combo) is the foundation. Blood rage and feed attacks both depend on it. Core locomotion underpins wall interactions. This tells you what to build first.
  6. Now try the freeform parser. Create a text file with observations from a different game you know well (or a different aspect of BloodRayne you noticed in footage). Run it through with --input and see how much the parser extracts. Fill in the gaps manually.
  7. Try the state diagram customization. Seeing the state machines visually makes the mechanics concrete in a way that text tables cannot.

Key takeaways

  • Structured specs are the bridge between playing a game and building one. Watching BloodRayne and saying “the combat is cool” does not help a programmer. A JSON spec with states, transitions, parameters, and triggers does.
  • The schema forces completeness. When every mechanic must have states, parameters, and inputs defined, you cannot hand-wave past the details. Missing fields become explicit warnings, not silent omissions.
  • Dependencies define your implementation order. You cannot build blood rage until combos work. You cannot build wall jumps until basic movement works. The dependency graph is your project plan.
  • The preset is your starting asset. The pre-filled BloodRayne breakdown is not a demo. It is a structured starting template for the core mechanics of the game you want to remake, and it becomes a real specification as you check each value against footage. Modify it, extend it, and use it.
  • Freeform-to-structured is a reusable pattern. This same approach works for analyzing any game, documenting any system, or converting any set of observations into actionable specifications. The tool is specific to games. The pattern is universal.

What’s next

You now have a market tracker, a storefront revenue simulator, a studio runway planner, a first combat prototype and a mechanics spec. The spec is the bridge to the rest of the module: next, in The Movement and Camera Feel Lab, you turn the locomotion numbers into a sandbox you can tune by feel.

intellimetrics · Arlington, VA
© 2026 intellimetrics.net
Search lessons