codext4fn-afk/roblox-video-replicate

Roblox: recreate what's in a reference video

The user's bar is "exactly like the video". They reject invented effects or mechanics, stiff animation, and flourishes that aren't in the clip. Everything here keeps you anchored to the reference and verifying against it — not against your memory of it.

Tools: Roblox Studio MCP (execute_luau, search_asset, insert_asset, upload_image, screen_capture, start_stop_play, user_keyboard_input, user_mouse_input, get_console_output, multi_edit), Blender MCP (execute_blender_code — frame extraction and VFX authoring), PowerShell/Bash.

0. Ground rules

• Reproduce only what the video shows. Ambiguous? Look at more frames; still unclear? Ask — don't fill gaps with your own ideas.
• Textures/images: don't draw your own. Use the Creator Store first. If nothing is close, author the asset in Blender from the reference (§4) and tell the user that's what you did.
• Default trigger is a key press (ask which if unspecified).
• No unrequested flourishes (spins, cartoon flips). The user explicitly hated them.
• Copy mechanics, feel and effects — not another game's branding, names, UI art or ripped assets, and don't clone a whole existing game. If asked to make a game identical to another, recreate the specific mechanics/effects shown and say so.

1. Extract and study the frames

1. Render frames through Blender (ffmpeg is usually absent): send scripts/extract_frames.py to execute_blender_code with VIDEO/OUT set. It uses a throwaway scene and leaves the user's .blend untouched. On Windows keep OUT short (MAX_PATH).
2. scripts/contact_sheet.ps1 -Dir <OUT> → 4×4 labeled sheets. Read all sheets, then open single frames at every cut, impact, UI change and input. For fast mechanics use STEP = 1 around the moment you're measuring.
3. Decide what you're building: VFX/cutscene, gameplay system, or both (most combat moves are both: a system that decides what happens + VFX that shows it).
4. Write the spec before building — it's what you verify against later:
   • Beat sheet (VFX): one line per beat with time (frame/fps), camera, every effect (shape, color, texture, size, lifetime, count), each character's pose, post-processing.
   • System spec (mechanics): inputs, states and transitions, timings (windup/active/recovery/cooldown in frames), distances and speeds (measured against the ~5-stud R15 body), numbers shown on screen, UI and its animations, what other players see. See references/systems.md.

2. Inspect the place

search_game_tree + quick dumps of Lighting, StarterPlayer, ReplicatedStorage, ServerScriptService. Reuse the user's existing frameworks (combat modules, remotes, data stores, UI kits) instead of building parallel ones; match their code style.

3. Assets from the Creator Store

• search_asset (scope creator_store, priceFilter: free) with 3–5 phrasings per element. Compare candidates visually: scripts/asset_sheet.ps1 builds a labeled thumbnail sheet to read next to the reference frames.
• A Decal asset id is not the image id: resolve with game:GetObjects("rbxassetid://"..id)[1].Texture (Edit datamodel) before using it in particles/GUIs.
• Free models often contain backdoors. After inserting a Model, list every LuaSourceContainer; keep only what you need and destroy the rest.
• Real avatars as dummies/enemies: Players:CreateHumanoidModelFromUserId(Players:GetUserIdFromNameAsync(name)) works from Edit. Anchor the HRP, put the feet on the floor, strip scripts except Animate.

4. When to build VFX in Blender

Default to Roblox-native effects (particles, beams, trails, parts, GUIs) — cheap, tweakable, rendered live. Go to Blender when the reference shows something natives can't approximate well:

Reference shows	Blender output	Into Roblox via
thick 3D slash crescents, twisted spirals, shockwave domes, spikes, ground fractures with depth	mesh with UVs (+ gradient/noise texture)	EditableMesh built from exported data, or 3D Importer
hand-drawn/anime smoke, fire, explosions, energy bursts, impact frames	rendered flipbook sprite sheet (transparent PNG)	upload_image → ParticleEmitter flipbook / ImageLabel
complex textures (noise trails, gradient ramps, swirl maps)	rendered PNG	upload_image → Beam/Trail/Texture

Read references/blender_vfx.md for the pipeline (scene setup, flipbook render + grid packing, mesh export to Luau, localhost upload, EditableMesh builder, animating meshes in the timeline).

5. Build

• VFX / cutscenes: one client ModuleScript driven by a timeline (events, camera shots, per-frame updaters, timeline-time delays, warp zones, pause) with a cleanup stack, plus keyframed bodies for caster and target. Copy the skeleton in references/engine.md.
• Systems: server-authoritative — the client sends intent via a RemoteEvent, the server validates (cooldown, state, range, rate limit) and applies the outcome, clients render feedback. Folder layout and per-system recipes in references/systems.md.
• Both: the server decides hits/damage/state and fires clients; each client plays the VFX module. Keep timings in one shared config so mechanics and visuals stay in sync.

6. Animation that feels alive

Static poses read as "buns". What works:

• Keyframe tracks, not poses — dozens of keys per character; each key = pose + overrides + easing into it.
• Every attack: anticipation (Quad.In) → strike (Exponential.Out, 40–70 ms) → overshoot (Quad) → settle (Sine.InOut). Every hit on a target: recoil key + decaying shake impulse.
• Additive life every frame: breathing, slow noise drift on all joints, hit-shake, tremble.
• Give targets a performance (startle, recoils, stagger, grounded collapse: knees, hands, side). No somersaults unless the clip has them.
• Match story beats to the clip's cuts; ask about pacing and use TimeWarp zones to slow sections.

7. Verify against the reference

• Playtest. Timelines: step with PauseAt and screenshot each beat beside the matching reference frame. Systems: drive inputs with user_keyboard_input / user_mouse_input, read state from both Client and Server datamodels, and measure timings (os.clock) and distances against the spec — numbers, not impressions.
• Debug camera at Enum.RenderPriority.Last.Value; clear particles/disable beams & GUIs while paused to see bodies.
• execute_luau runs in its own VM: require gives a separate module instance — observe game state (attributes, anchoring, CameraType), not module fields.
• Finish with a real input, then confirm cleanup/restoration and a clean get_console_output.

8. Gotchas

Read references/gotchas.md before building — invisible 1-segment beams, dark-halo flares, DepthOfField smear, Expo vs Exponential, joint transforms only rendering when written in PreSimulation, AnimationConstraint rigs, body-size scaling + floor clamp, terrain water depth, overlays reflected in water, networking pitfalls, and more.

9. Report

What each beat/mechanic now does (timestamped or per state), which assets were used (store ids, Blender-made assets and their uploaded ids), anything that couldn't be matched and why, where the tunables live (config modules, Cutscene.Poses/Tracks, TimeWarp), and a reminder to save the place (Ctrl+S).