Applied The Lora Playbook

The Movement and Camera Feel Lab

Last reviewed

Intermediate

What you'll learn

~55 min
  • Plan and build a real-time parameter tuning sandbox for Phaser 3 movement physics
  • Adjust run speed, jump height, gravity, dash, and air control with sliders while playing
  • Tune camera smoothing, zoom, and follow behavior for side-scrolling feel
  • Dial in the fast, acrobatic movement style that defines BloodRayne

What you’re building

You have combat. Now you need movement that feels right. BloodRayne was defined by how Rayne moved — fast, fluid, acrobatic. She could sprint across a room, leap over enemies, and change direction mid-air. That feel did not happen by accident. It happened because someone sat in a room and tuned numbers until the movement stopped feeling like a character and started feeling like an extension of the player’s hands.

That is what you are doing in this lesson. You are building a tuning sandbox — a Phaser 3 scene with a side-scrolling level and an HTML control panel that lets you adjust every movement parameter in real time. Change the run speed slider, the character moves faster immediately. Change the jump height, the character jumps higher on the next press. No code editing, no page reloads. Just play and tweak until it feels like BloodRayne.

ℹSoftware pattern: Real-time parameter tuning with hot reload

This is the same pattern used in professional game development — expose tunable values to a UI so designers can iterate without touching code. Unity has its Inspector panel, Unreal has Blueprints, and now you have an HTML slider panel that talks directly to your Phaser game. This pattern applies anywhere you need to find the right values by feel rather than calculation: animation timing, UI transitions, physics simulations.


The showcase

Here is what the finished sandbox gives you:

  • Side-scrolling level with multiple platforms at different heights, a long floor, and walls to test movement against
  • Player character (Rayne) with full movement: run, jump, dash, wall slide
  • Tuning panel (HTML sidebar) with real-time sliders for:
    • Run speed (50-500 px/s, default 200)
    • Acceleration (100-2000 px/s^2, default 800) — how fast you reach top speed
    • Deceleration (100-3000 px/s^2, default 1200) — how fast you stop
    • Jump velocity (-100 to -600, default -350) — how high you jump
    • Gravity (200-1200, default 600) — how fast you fall
    • Air control (0-100%, default 60%) — how much horizontal control mid-air
    • Dash distance (50-300 px, default 150)
    • Dash cooldown (200-2000 ms, default 800)
    • Camera lerp (0.01-1.0, default 0.1) — how smoothly the camera follows
    • Camera zoom (0.5-2.0, default 1.0) — zoom in for detail, out for overview
  • Real-time value display — each slider shows its current numeric value
  • Preset buttons — “BloodRayne Fast”, “Floaty Platformer”, “Tight and Precise”, “Reset Defaults”
  • Export button — copies all current values as a JSON object to your clipboard

The character responds instantly to every slider change. You can literally hold the jump button and drag the gravity slider to feel the difference in real time.


Before you start

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

Terminal window
mkdir -p ~/retro-remake/11-movement-camera-feel-lab && cd ~/retro-remake/11-movement-camera-feel-lab

In Windows PowerShell:

Terminal window
mkdir ~/retro-remake/11-movement-camera-feel-lab; cd ~/retro-remake/11-movement-camera-feel-lab

In a desktop agent app, open ~/retro-remake/11-movement-camera-feel-lab as your workspace folder. Then start your AI tool the way Workbench Setup showed.

Switch to plan mode

Switch into Plan mode (Shift+Tab, /plan, or the mode picker) so your agent aligns on the slider parameters, platform layout, and presets before writing index.html.

The conversation

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

Say what you want

Ask for a browser movement and camera tuning sandbox with live sliders:

Build a 2D side-scrolling movement and camera tuning sandbox in a single index.html file, with a platform test level and live sliders on the side. Ask me what you need first.

Answer its questions

Your agent will ask which movement and camera values need sliders, how the test level should be laid out, and whether you want presets or export support:

If it asksYou might say
Which movement and jump sliders should the panel include?Run speed, acceleration, deceleration, jump velocity, gravity, air control, dash distance, and dash cooldown.
What camera controls do you want to tune?Camera follow smoothing from 0.01 to 1.0 and camera zoom from 0.5x to 2.0x.
What obstacles should the test arena have?Stepping stones, a high runway, a tall wall, and a gap sized for the default 150px dash.
Which presets and export option should the sidebar have?Four presets (BloodRayne Fast, Floaty Platformer, Tight and Precise, Reset Defaults) plus Copy JSON to Clipboard.
What debug info should show on screen?Live horizontal/vertical velocity, grounded or airborne state, dash cooldown timer, and a high-speed afterimage trail.

Read the plan

Before approving the build, check the agent’s plan for these four points:

  1. Acceleration-driven movement: horizontal speed ramps up using acceleration (default 800) toward runSpeed (default 200), slows down using deceleration (default 1200) when no key is pressed, and scales airborne steering by airControl (default 60%).
  2. Live shared config binding: the HTML sliders on the right update a shared window.gameConfig object on every input event, and the Phaser update loop reads movement, dash (dashDistance 150, dashDuration 200ms, dashCooldown 800ms), and camera (cameraLerp 0.1, cameraZoom 1.0) from it every frame.
  3. Presets update sliders and physics together: clicking “BloodRayne Fast” (runSpeed 350, acceleration 1500, deceleration 1800, jumpVelocity -420, gravity 800, airControl 80%, dashDistance 200, dashCooldown 500ms, cameraLerp 0.08, cameraZoom 0.9), “Floaty Platformer”, “Tight and Precise”, or “Reset Defaults” moves every slider and updates the live readout immediately.
  4. Clipboard JSON export: the “Copy Values to Clipboard” button serializes the active config as formatted JSON so you can reuse your favorite feel in later prototypes.

If the plan sets velocity directly instead of using acceleration and deceleration ramps, steer it before approving:

Do not snap horizontal speed directly to top run speed; ramp up and slow down using the acceleration and deceleration sliders so turning and stopping feel tunable.

Once the plan covers all four checks, approve it and let the agent build index.html. When it works in the browser, ask your agent to save a Git checkpoint.

💡The presets are your starting baselines

“BloodRayne Fast” is a starting point for how your remake should feel. You will spend most of your time in this sandbox bouncing between presets, tweaking individual values, and jumping between platforms until the movement makes you smile. That is the job.


What you get

After the AI finishes, the project folder structure looks like this:

11-movement-camera-feel-lab/
index.html

Play it

Ask your agent to open or serve the movement sandbox in your browser:

Open index.html in my browser, or start a local preview server and share the link so I can test the movement sliders.

If you prefer to open it yourself from a terminal:

Terminal window
cd ~/retro-remake/11-movement-camera-feel-lab
open index.html # macOS (Linux: xdg-open index.html; WSL: explorer.exe . then double-click index.html)

Start by clicking “BloodRayne Fast” and running around the level. Jump between the platforms. Dash across the gap. Then start tweaking. Pull the gravity slider up — notice how the jump becomes snappy and short. Pull it down — now you are floating. Find the sweet spot where the jump feels powerful but committed.

If something is off

ProblemFollow-up prompt
Sliders don’t affect the gameDragging the sliders changes the numbers in the sidebar, but Rayne's movement in the game does not change. Make the game read every movement, jump, dash, and camera value live from the sliders without reloading.
Character slides on the ground like iceWhen I let go of the arrow keys, Rayne keeps sliding across the floor. Apply the deceleration slider value whenever no movement key is pressed so she slows to a clean stop.
Camera jumps instead of smoothingAdjusting the camera smoothing slider does not change how the camera follows Rayne. Apply the camera smoothing and zoom slider values live every frame so I can feel the difference between laggy and locked-on follow.
Dash goes the wrong distanceThe dash barely moves Rayne or teleports her off-screen. Make the dash cover the exact pixel distance set by the Dash Distance slider over 200ms, then return to normal run speed.

Deep dive

This sandbox is not just a toy. It is how professional game designers work. Here is why each parameter matters and how to think about tuning them.

Acceleration is the secret ingredient

Most people think run speed is what makes a game feel fast or slow. It is actually acceleration and deceleration. High acceleration means the character reaches top speed instantly — it feels responsive and snappy. Low acceleration means the character ramps up slowly — it feels heavy and deliberate. BloodRayne needs high acceleration (Rayne reacts instantly to player input) and high deceleration (she stops on a dime, no sliding). Compare this to a Mario game where Mario has low deceleration — he slides, and that sliding IS the game. For a combat game, sliding gets you killed.

Air control defines jump commitment

Air control at 0% means once you jump, your horizontal trajectory is locked — you are committed to the arc. Air control at 100% means you have full steering mid-air. BloodRayne should be somewhere around 60-80% — enough to adjust your landing, not so much that jumping feels like floating. This is a design decision about how punishing missed jumps should be.

Camera lerp creates feel without touching the character

A camera lerp of 0.1 means the camera moves 10% of the distance to its target each frame. The result: the camera lags slightly behind, creating a sense of momentum and speed. The player character actually runs “ahead” of the camera center, which subconsciously makes the player feel fast. Drop the lerp to 0.03 and suddenly the game feels cinematic and weighty. Push it to 0.5 and it feels like a security camera — locked on, clinical. The right value for BloodRayne is low (0.05-0.1), because Rayne should feel like she is outrunning the camera.

🔍The 'copy values' workflowclick to expand

When you find movement values that feel right, click “Copy Values to Clipboard.” This gives you a JSON object you can paste directly into the Combat Loop Prototype. This is intentional — the tuning sandbox and the combat prototype are separate so you can iterate on movement without worrying about enemy behavior, and vice versa. In the Playable Demo Assembly near the end of the module, the AI CLI will stitch these systems together using your tuned values.


Customize it

Add wall jumping

Add wall sliding at 40% gravity when pressing into a wall mid-air, and wall jumping at a 45-degree angle with 80% jump velocity, plus sliders for both multipliers.

Add double jump

Add a mid-air double jump at 70% of normal jump velocity with a slider for the multiplier (0.3 to 1.0) and a small availability dot under the player that resets on landing.

Add a speed trail particle system

Emit fading red square particles behind the player whenever horizontal speed exceeds a configurable threshold (default 250px/s), and add sliders for the speed threshold and particle lifetime.

Try it yourself

  1. Walk through the plan-mode conversation above and open index.html in your browser.
  2. Click each preset button and spend one minute with each. Which one feels closest to how you remember BloodRayne?
  3. Starting from the “BloodRayne Fast” preset, adjust three values to make it feel better to you. Write down what you changed and why.
  4. Find the minimum air control percentage where you can still reliably land on the small stepping-stone platforms. That is your lower bound.
  5. Set gravity to maximum and jump velocity to maximum. This is the “heavy and powerful” extreme. Now set both to minimum. This is the “floaty and light” extreme. BloodRayne lives somewhere between these — find it.
  6. Click “Copy Values to Clipboard” when you have values you like. Save them in a text file. You will use them in the Playable Demo Assembly.

The numbers do not lie, but they also do not matter until they feel right under your fingers. Trust your hands. Rayne would.


💡You own the feel

Movement feel is the thing players notice first and describe last. They will say “this game feels great” without being able to explain why. You now know why — it is acceleration curves, air control percentages, and camera lerp values. You have the sandbox to find the exact numbers that make YOUR BloodRayne remake feel right. Next lesson: enemy behaviors that are worth dodging.

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