Build "Chernobyl Atlas," a premium interactive 3D exhibit using Three.js.

Research the intact Chernobyl power plant and RBMK reactor using public references. Model the buildings, lattice chimney, turbine hall, graphite stack, fuel channels, shielding, separator drums, pumps, and pipes.

Create three tabs:
— Power Block: a detailed model that disassembles layer by layer using scroll and a slider.
— Steam Circuit: an animated diagram connecting the reactor, turbine, condenser, and pumps.
— Reactor in Motion: a 3D cutaway with moving water and steam, spinning machinery, and playback controls.

Add independent system visibility toggles, adjustable part spacing, wireframe, transparency, section cuts, and short labels. Keep every layer easy to inspect and the camera freely rotatable, even at full disassembly.

Deliver the source and a standalone HTML file. Test all controls. Present it as an educational interpretation, not an exact engineering replica.

Build a beautiful, interactive 3D anatomy explorer using publicly available scientific datasets. Start with an external view that gradually becomes transparent as I zoom in, revealing the anatomy underneath.

Let me rotate the model, separate structures, select labeled regions, and toggle layers from a side panel. Add separate tabs for anatomy, connections, and individual cells, with animated signals and adjustable controls.

Use a modern, minimal interface with soft lighting, smooth transitions, subtle colors, and very little text. Include arrows and a short visual tutorial. Make it work on desktop and mobile.

Use real anatomical geometry where available, cite the sources, and clearly distinguish scientific data from illustrative animations. Build a working website.

Build me a graphics demo: isometric camera, voxel-ish art style with realistic shading and reflective wet floors, a character in an interesting scene. Fantasy setting (think Elden Ring, Diablo). Three.js in browser, >60fps. Don't download assets. Time limit of 1 hour. Controls: click to move the character, camera lazy-follows; drag to rotate camera; scroll to zoom in/out. No gameplay for now. World should feel alive: motion, animations, subtle environmental behaviors. Area around player should look expansive, but only allow movement in a limited space. No need to confirm the art with me or ask questions, just go!

A fully assembled figurine of a little girl playing with a robot, wearing a small worker’s cap, holding a tin robot in one hand and a remote control in the other, with a toolbox strapped around her waist. All accessories fully integrated into a standing pose, pure white background, professional studio lighting, high-detail 3D anime figurine display style. ar3:4

Build a beautiful, full-screen interactive koi pond using Three.js + WebGL. Use a top-down view with clear turquoise water, sunlight, animated caustics on the pond floor, and a convincing sense of depth.

Place an elegant translucent selection panel at the bottom with four koi varieties: Kohaku, Showa, Golden Ogon, and Platinum. Clicking a card releases that fish into the pond. Dragging a fish from its card lets the user choose exactly where to drop it.

Make each landing feel satisfying: a splash with droplets, a brief depression in the water surface, and expanding ripples. The fish should then dive beneath the surface. Use refraction and depth cues so the koi clearly look submerged.

Create detailed 3D koi with eyes, scales, fins, and flowing tails. Animate their bodies, tails, and fins together. Each fish should independently change direction and speed, turn smoothly near boundaries, and avoid other fish.

Let users touch and drag across the water to create ripples. Add rain and a movable whirlpool whose current affects the fish. Include Calm, Clear pond, and a control to hide the interface for screen recording.

Use Web Audio to create landing splashes, soft musical droplets, gentle swimming water sounds, rain, and a whirlpool sound. Enable audio through a Sound button, fade it smoothly when muted, and pause it when the browser tab is hidden.

Keep all labels and buttons in English. Make the layout responsive for mobile. Optimize rendering and animation for smooth performance with several dozen fish.

Deliver a complete, working website with polished visuals and functional interactions.

Model the Brooklyn Bridge and test tanks crossing from both directions.

Create a complete 3D demonstration video showing the entire process of building “Zen Realm · Ancient Temple,” from design to finished scene, and deliver the final MP4.

Visual requirements:
1080×1080 square format, a 45° top-down orthographic view, a miniature 2.5D cartoon-style 3D model, perfectly centered. Use a raised light-colored stone base, a solid teal-green background, soft refined textures, PBR materials, and gentle realistic lighting.

The scene includes:
a Chinese temple with double-eaved roofs, upturned glazed-tile eaves, teal-green roofs, golden ridgelines, vermilion columns, lattice doors and windows, a temple gate, a bell pavilion, an incense burner, stone lanterns, a stone-paved courtyard, pine trees, pink flowering trees, and a lotus pond.

The title “禅境·古寺” appears at the top in bold, bright warm-white Chinese lettering.

Video timeline, 64 seconds total:
0–8 seconds: Draw the floor plan stroke by stroke.
8–15 seconds: Raise the base and the buildings’ primary blockout forms.
15–24 seconds: Generate details such as columns, walls, doors, and windows.
24–32 seconds: Build the double-eaved roofs, tiles, and upturned corners.
32–41 seconds: Add the temple gate, courtyard, trees, and environmental details.
41–49 seconds: Gradually apply colors and PBR materials to the gray blockout.
49–54 seconds: Adjust the lighting, reflections, and soft shadows.
54–64 seconds: Slowly orbit around the finished scene, with subtle falling petals, incense smoke, and water ripples.

Use real 3D geometry and show the construction process continuously in the same shot. Display only brief stage labels; do not use PowerPoint-style explanation slides or add narration.

Use Three.js to generate the scene and animation, render frame by frame, then export a 30fps H.264 MP4 with FFmpeg. Check full playback, stage order, model integrity, and black frames.

Act as the game director, game designer, Unity engineer, 3D artist, UI/UX designer, technical artist, sound designer, and QA lead for this project.

Based on the following specifications, create a polished, fully playable 3D puzzle game for smartphones—not just a concept.

Do not stop halfway by presenting only a set of ideas.
Do not stop after creating only a design specification.
Create the actual project, code, scenes, UI, materials, game logic, sound controls, sensor processing, save system, and tests wherever possible.

Unless there is a serious contradiction, do not ask questions about unclear points. Make your own decisions to create the most engaging, high-quality game possible, and proceed with development.

Project Overview

Working title:

DEVICE

Genre:

Photorealistic 3D smartphone-interaction puzzle adventure

Platform:

Prioritize Android.
Structure the project so it can also support iOS where feasible.

Screen:

Portrait orientation, 9:16

Controls:

Designed to be playable primarily with one hand.
However, some puzzles use physical interactions with the smartphone itself, such as lifting, tilting, rotating, turning it face down, shaking, and holding it still.

The Game's Defining Feature

This is not a game played on a smartphone.

Make it a game that uses the smartphone itself as a puzzle device.

It must not be possible to complete the game using only touchscreen controls.

Use the smartphone’s built-in sensors, camera, microphone, vibration, speaker, device orientation, charging state, and other capabilities as the laws of physics within the game world.

However, do not make it merely a collection of sensor-function demos.

Design every feature so that it connects naturally within the same world and game system.

Worldbuilding

The player discovers a mysterious black cube-shaped device called “DEVICE” in an unidentified research facility.

The cube connects to the smartphone and detects the phone’s real-world state.

When the player tilts the smartphone, gravity inside DEVICE changes.

When the player rotates the device, the space itself rotates.

Real-world light, color, sound, direction, and movement flow into DEVICE.

At first, DEVICE appears to be nothing more than an experimental apparatus, but as the game progresses, it gradually begins to recognize the player’s presence.

In the latter half,

“the player is operating a smartphone”

and introduce a metapuzzle that makes use of this relationship itself.

Do not make it a horror game.
It may have an eerie atmosphere, unknown technology, and a sense of mystery, but its focus should be the joy of intellectual curiosity and discovery.

Visual quality

Top priority.

Use the most photorealistic 3D visuals possible for smartphones.

Avoid cheap-looking mobile game CG.

No cartoon-style visuals.

No low-poly look.

Minimize the use of flat placeholder assets outside the UI.

When using Unity, use URP optimized for mobile performance as the foundation,

• PBR materials
• Metallic/roughness workflows
• Normal maps
• Ambient occlusion
• Reflection probes
• Light probes
• High-quality shadows
• Soft shadows
• Bloom
• Color grading
• Screen-space effects
• Volumetric-looking light
• Depth of field only where needed
• Physically based glass
• Metal
• Wet floor
• Scratches
• Fingerprints
• Dust
• Fine surface irregularities
• Emissive materials
• Reflections
• Ambient sounds

and combine them.

The setting is a dark, high-end futuristic research facility.

Focus on black metal, glass, concrete, white illuminated lines, precision machinery, hydraulic components, and similar elements.

Do not make it completely dark; ensure that important objects can be recognized under natural-looking lighting.

As the symbol of the game, DEVICE must be created to an exceptionally high standard.

The DEVICE unit:

A cube approximately 20–30 cm across, made of black metal and glass.

Each face has a different mechanical structure.

The seams are extremely precise.

A faint white or bluish-white light leaks from inside.

The internal structure physically deforms, rotates, and unfolds in response to the player's actions.

Add tactile, click-like mechanical animations.

Basic Game Screen

DEVICE is positioned in the center of the portrait screen.

The player drags DEVICE to rotate it and inspect each face.

The surroundings are a research facility.

The camera is cinematic without compromising control.

Keep the basic UI minimal.

Do not display a large number of buttons at all times.

Prioritize the feeling of physically interacting with DEVICE itself.

Core Systems

Integrate the following as input systems within the same game world, rather than as separate minigames.

1. Touch

Tap
Double-tap
Long press
Drag
Swipe
Pinch
Two fingers
Three fingers
Multi-touch input

to enable.

Directly touch and operate DEVICE buttons, levers, rotary rings, dials, and other controls.

2. Gyroscope

Link the smartphone’s tilt to the gravity inside DEVICE.

Examples:

Move the metal ball inside to the goal using only tilt.

Tilt the liquid until it contacts the electrodes.

Adjust the angle of the light beam.

3. Accelerometer

Shake the device.

Stop it abruptly.

Detect a motion like a light tap.

However, do not require the user to shake the device too violently.

Take safety into consideration.

4. Device Orientation

Portrait
Landscape
Face Up
Face Down

and incorporate them into the game.

Create events that occur only when the smartphone is placed face down on a desk.

5. Camera

Bring colors from the real world into the game.

When the player points the camera at a red, blue, green, or other target, analyze the representative color around the center of the screen and send it to DEVICE as energy.

Do not send the images themselves to a server.

Process them on the device whenever possible.

Provide alternative controls for situations where the camera cannot be used.

6. Microphone

Volume
Duration
Basic frequency characteristics

Use these inputs.

Examples:

Blowing on the microphone
Speaking
Clapping
Remaining quiet for a set period of time

and so on.

Do not make voice recognition mandatory.

Do not store recorded audio.

7. Haptics / Vibration

Very important.

Create stages that convey information solely through vibrations, without displaying it on screen.

Examples:

The intervals between vibrations become shorter as the player approaches the target.

Different patterns for the left and right sides.

A code using short and long vibrations.

Provide an alternative visual indicator for devices with vibration disabled or unavailable.

8. Speaker

Use spatial audio to convey direction.

Do not require earphones.

Use pitch, rhythm, left-right panning, and similar properties as puzzle information.

9. Brightness

Use the ambient light sensor where available.

For devices without one, consider alternatives such as measuring brightness through the camera.

A mechanism that appears in dark environments.

A mechanism that charges when placed in a bright environment.

10. Compass

Retrieve the device's heading on supported devices.

Create puzzles that require the player to point the smartphone north, south, or in a specific direction.

If the required sensor is unavailable, switch to an alternative puzzle.

11. Charging Status

If the device can detect when charging begins,

Include an effect where connecting an actual charging cable supplies power to DEVICE.

However, always provide an alternative way to clear the puzzle for users who cannot perform this action.

12. Battery

If the battery level is available, use it for special events.

Do not design puzzles that become impossible to clear based on the battery level.

13. Time

You may use the current time for special puzzles or effects.

Do not design puzzles that can only be cleared at a specific time.

Do not force the player to wait.

Puzzle Design

Rather than mass-producing 100 shallow puzzles from the start,

first create around 20–30 highly polished stages.

Each stage must offer a different discovery.

Do not create stages that repeat the same interaction with only the numbers changed.

Chapter 1: TOUCH

Teach the game rules primarily through touch controls.

Touch DEVICE.
Rotate it.
Press it.
Pull it.
Open it.

Chapter 2: GRAVITY

Introduce the gyroscope and accelerometer.

The physical world inside DEVICE synchronizes with the real smartphone’s orientation.

Chapter 3: SENSE

Camera
Microphone
Light
Sound
Vibration

are introduced.

Chapter 4: OUTSIDE

A puzzle that directs the player’s attention beyond the screen.

Place the smartphone face down.
Keep it still.
Align its direction.
Capture the colors around it.

Chapter 5: DEVICE

Combine the rules learned so far.

The instructions displayed on screen are no longer always correct.

Example:

On screen,

SHAKE

is displayed.

However, shaking the device causes failure.

The correct solution is to keep it completely still.

In another puzzle,

MORE LIGHT

is displayed.

Raising the screen brightness does not trigger a response.

Clear it by letting real-world light into the camera.

In the final stage,

Touch
Device orientation
Gyroscope
Vibration
Sound
Real-world inputs

Turn it into a large-scale puzzle combining multiple elements, such as...

Representative stages that must be implemented

“Dark Maze”

The screen becomes almost completely dark.

The player cannot see their position.

Tilt the smartphone to move an invisible sphere.

The vibration becomes stronger and faster as the player approaches the exit.

Ultimately, reach the goal using only vibration feedback.

Audio assistance can also be enabled in the accessibility settings.

“DON'T LOOK”

DEVICE appears on the screen,

DON'T LOOK

is displayed.

The player places the smartphone face down.

When Face Down is detected, mechanical sounds play from inside DEVICE while it is out of view.

After a few seconds, turning the phone back over reveals that DEVICE has transformed.

“STEAL COLOR”

There is a colorless energy core inside DEVICE.

Use the camera to read real-world colors such as red, blue, and green.

The detected colors flow into DEVICE in real time as liquid energy.

“STAY STILL”

DEVICE is vibrating violently.

The player will initially want to shake the smartphone.

But the correct solution is to keep the device completely still.

When acceleration remains below a threshold for a set period, the device stabilizes and opens.

“POWER”

DEVICE comes to a complete stop.

On supported devices, starting to charge the smartphone sends electricity into DEVICE.

The metal wiring lights up in sequence, and the internal mechanism restarts.

Provide alternative controls as well.

Physics Inside DEVICE

Make active use of physics simulation.

Metal spheres
Liquid
Gravity
Magnets
Gears
Rails
Reflector
Laser
Rotating ring
Cylinder
Piston
Locking mechanism
Glass
Electrode
Cable

and similar components.

However, do not make it unstable by relying solely on physics simulation.

Use controlled physics for important puzzles to ensure deterministic results.

Presentation

Do not simply display the word “CLEAR” when the puzzle is solved.

DEVICE itself transforms to provide the answer.

Unlocking
Gear rotation
Internal glow
Metal panel separation
Fluid movement inside the glass
Mechanical arm deployment

Combine elements such as these.

At the moment the solution is found,

“I operated a huge precision machine”

create a sequence that conveys this sense of satisfaction.

Sound

Extremely important.

Don't just keep the BGM playing.

The hum of the research facility's air conditioning
Distant machinery
Servo sounds from inside DEVICE
Metallic clicks
Glass
Electricity
Magnetism
Low frequencies
Vibration

Layer these elements.

The sound changes depending on where the player touches DEVICE.

When using earphones, enhance positional audio.

UI

Integrate it into the game world as much as possible.

Don't line up cheap mobile-game-style buttons.

Menu:

CONTINUE
CHAPTERS
SETTINGS
ACCESSIBILITY
CREDITS

to some extent.

Present in-game hints on display devices inside DEVICE or as projected text.

Hint System

Don't display the answer immediately when the player gets stuck.

Hint 1:
A location to focus on.

Hint 2:
The smartphone feature to use.

Hint 3:
Nearly the solution.

in three stages.

Accessibility

Especially important for a game that makes extensive use of device sensors.

Implement the following:

Allow vibrations to be represented through sound or on-screen indicators.

Provide visual assistance for audio puzzles.

Provide color-vision assistance for color puzzles.

Do not require strenuous device movements.

Eliminate the need to shake the smartphone vigorously.

Provide alternative puzzles when the camera, microphone, or compass is unavailable.

Do not make the game impossible to progress if access to some sensors is denied.

Privacy

Do not transmit camera images, microphone audio, location data, or similar information to external servers.

Do not make GPS required for game progression.

Explain why each permission is needed immediately before requesting it.

Do not request unnecessary permissions.

Technical Setup

Use Unity 6 or later if possible, with C#.

Use URP for mobile.

Modularize the project.

Include at least the following structure:

SensorManager
PuzzleManager
GameStateManager
AudioManager
HapticsManager
PermissionManager
SaveManager
AccessibilityManager
DeviceCapabilityManager

Do not repeatedly call each smartphone feature directly from the Puzzle code.

Abstract them through systems such as SensorManager,

real-device sensors
simulated input for the Unity Editor
fallbacks for unsupported devices

so they can be switched between.

Sensor debugging

To enable development in the Unity Editor,

Developer Sensor Panel

Implement it.

With sliders and buttons,

Device tilt
Acceleration
Face Up / Face Down
Microphone volume
Ambient light
Compass
Charging ON/OFF
Battery
Vibration event
Camera sample color

Enable simulated input for these and similar inputs.

Make it possible to test the main puzzles without connecting a physical device.

Save

Chapter progress
Cleared stages
Hint usage
Settings
Accessibility
Collectibles

Save.

Allow the game to be safely paused even mid-stage.

Performance

Do not let photorealism make the game unplayable.

Target a configuration that can run on representative mid-range Android devices.

LOD
Occlusion Culling
GPU Instancing
Texture compression
Light baking
Reflection Probe
Real-time lighting only where needed
Object pooling
Reduce draw calls

Use, among other techniques.

Set the Quality settings to

LOW
MEDIUM
HIGH
ULTRA

Divide them into.

Target high-quality visuals on high-end devices.

Definition of done

Not just a prototype,

Title screen
Introduction
Tutorial
Multiple chapters
Multiple stages
Sensor input
3D presentation
Sound
Settings
Accessibility
Save system
Stage select
Ending

aim for a state where the game can be experienced from start to finish.

If possible, generate an actual Android build.

Even if APK/AAB generation is not possible due to build environment constraints,

finish with a complete project that can be opened in Unity and built as-is.

Development Guidelines

Do not switch to 2D or simplified UI just because it is easier.

Do not remove the game's core mechanics to save time.

For anything that cannot be sourced externally, create it yourself or generate it procedurally whenever possible.

If placeholders are necessary, do not fill the entire game with them.

In particular,

DEVICE
research facility
main puzzle device
lighting
materials
correct-answer effects

should be finished to a high standard.

Workflow

First, finalize the overall design in a short amount of time.

Then move on to production instead of continuing to explain.

1. Create the project
2. Basic 3D scene
3. Create DEVICE
4. Basic controls
5. Sensor abstraction
6. Puzzle framework
7. Implementing representative puzzles
8. Chapter construction
9. UI
10. Sound
11. Presentation
12. Saving
13. Accessibility
14. Optimization
15. Testing
16. Fixes
17. Build

Proceed in this order.

If some parts fail, do not stop the overall process; use alternative methods to maximize the quality of the finished game.

Final deliverables

The following should remain at the end:

・Complete game project
・Core source code
・Game scenes
• 3D Models and Materials
• UI
• Sound Settings
• Sensor System
• Puzzle System
• Save System
• Build Settings
• README
• Android Device Testing Procedure
• List of Smartphone Features Used
• Fallback Specifications for Unsupported Devices
• Known Issues

Do not stop after providing an explanation without creating the deliverables.

The priorities, in order, are:

1. Being fun
2. Making full use of the smartphone
3. Realism in the 3D world
4. The feeling of physically interacting with DEVICE
5. Making sense as a puzzle
6. Actually working

That is the order of priority.

Do not make it “a game that adds sensor features to an existing smartphone game”;

Complete a game that makes it feel as though the smartphone hardware exists for this game.

From this point on, begin actual development instead of stopping at a project description.

Also incorporate any areas above that can be further refined and any elements that would make the game more engaging, and create the 3D visuals realistically

Build a browser flight game called Skybound using Three.js. The player pilots a dragon through a field of floating islands, collecting rings for score. You'll need a 3D dragon model - use the Hyper3D Rodin MCP to generate it.

I want to print a picture frame on a 3D printer, but the printer is too small, so I’d like one that can be completed by joining separate parts. That sounds a bit boring, so use connectors to make it more interesting.

download 2,000 historical photographs and reference information around the fair and use all the information obtained to create a 3D reconstruction in Blender.

Build a kinetic sand table simulation. A ball must move through a bed of sand, leaving a visible trail, drawing complete geometric patterns, then smoothing the sand and starting a new and different pattern automatically. It must cycle through many different patterns without repeating. Everything about the look and the patterns is your choice.

Everything about the design is your decision: style, colors, mood, environment, camera, level of detail, and any extra touches. Do not ask me any questions, make every choice yourself and build the most impressive version you can in a single attempt.

Technical requirements: one single self-contained HTML file, no external models, images, sounds, or asset URLs of any kind (a JavaScript library from a CDN is fine). It must start running on its own the moment it loads, with no clicks needed, and run smoothly with no console errors.

Build a 3D origami animation. A flat square sheet must fold itself step by step into a recognizable origami figure, with each fold shown as an actual crease and rotation of the paper, then unfold back to flat and repeat. The figure it becomes and how the whole thing is presented are up to you.

Everything about the design is your decision: style, colors, mood, environment, camera, level of detail, and any extra touches. Do not ask me any questions, make every choice yourself and build the most impressive version you can in a single attempt.

Technical requirements: one single self-contained HTML file, no external models, images, sounds, or asset URLs of any kind (a JavaScript library from a CDN is fine). It must start running on its own the moment it loads, with no clicks needed, and run smoothly with no console errors.

Using Blender MCP, unwrap the selected “headless model containing clothing, hands, and feet” and rebake its existing textures at 4K.

The goal is to preserve the original appearance and create UVs whose structure is easy to read and repaint later, like clothing patterns. Work like a human artist, following this order: observe → design seams → unwrap by region → correct distortion → arrange → bake.

1. Preserve the original data
Save a copy under a new name before starting. Keep the old UVs, images, and materials, and create a new UV map named “UV\_Final.”
Do not change the shape, topology, vertex order, weights, shape keys, or rig.

2. Inspect the model and design seams
Inspect the model from every direction with the original texture displayed and the wireframe visible. Identify the clothing parts and the actual seam locations.
For clothing, follow the pattern structure of the bodice, sleeves, collar, and other parts, opening the mesh along areas such as side seams and the inside of sleeves. Place seams on the skin, hands, and feet in less noticeable areas such as the inner or side surfaces, and arrange them so the spaces between the fingers can be opened without undue strain.
Do not mistake wrinkles or printed designs for seams, and do not create unnecessary fragmented islands.

3. Unwrap by region and correct distortion
Unwrap each region separately instead of processing the entire model as one piece.
Using a checker texture with text that references UV\_Final and the Stretch display, check for stretching, compression, twisting, flipping, and overlaps.
Add or clear seams according to the cause of each problem, adjust with tools such as Pin and Relax, and check again. Do not simply repeat the same automatic unwrap; preserve regions that have already been improved.
Do not treat a full-model automatic subdivision with Smart UV Project as the finished result.

4. Align grain, texel density, and placement
For clothing, use the fabric grain of each piece as a guide and align its primary vertical direction with the V direction of the UVs. Do not forcibly reshape curved patterns into rectangles.
Match the texel density relative to real-world size, and orient the pieces so corresponding left and right sides are easy to identify.
Then pack them into the 0–1 space while maintaining their orientation and relative scale. Do not overlap left and right pieces or rotate them arbitrarily.
For 4K, use an initial margin of 16 px around the bake, at least 32 px between islands, and at least 16 px from the image borders.

5. Bake from the old UVs to the new UVs at 4K
Explicitly set the original texture references to use the old UVs, set UV\_Final as the bake target, and transfer them to a new 4096×4096 image.
Activate the bake-target image node in each material, perform a test bake, and then run the final bake.
For the base color, use only Diffuse Color or Emit. Do not bake in new lighting, shadows, or AO. Preserve the shading drawn in the original images.
Transfer existing maps such as alpha as needed. Rebake tangent-space normals based on the new UVs rather than treating them as simple color transfers.

6. Verify the result by comparing old and new versions
Apply the new UVs and baked images, then compare the full model and details under the same display conditions as the original.
Check the placement, color, transparency, and seam continuity of patterns. Correct collapsed or overlapping UVs, missing unwraps, and bake artifacts such as black spots, gaps, and bleeding.
Judge completion by the inspection results, not by how many times the model was unwrapped.

Save completed.blend, the 4K images, the UV layout, and reference images showing the seams, checker texture, and final appearance. Briefly report the main corrections made.
Do not stop at explaining the plan; complete the work while inspecting the actual images.

> lock the spec (TZ-gta-slice.md)

prompt: "Build a playable 3D browser slice. Do not change this spec once it is locked. District and clip first. Controls after."

> the stack (Vite, vanilla TypeScript, Three.js, cannon-es, Web Audio)

prompt: "Stack is fixed. Vite. vanilla TypeScript. Three.js. cannon-es. Web Audio. One browser URL."

> the frame (sunset over the water, wet asphalt, palms)

prompt: "One shore district. Sunset over the water. Wet asphalt. Palms. Hold the frame on light and camera, not poly count. No default gray light. No naked cubes."

> the three (one scene, one car, about 20 seconds)

prompt: "Keep the three in one scene. They talk. Then they sit in one car. About 20 seconds. Quality over extra switches."

> the cut (15 to 20 seconds, keep it smooth)

prompt: "If it lags, cut the clip to 15 to 20 seconds. Keep it smooth. If the frame drops, cut pedestrians, not the light."

> the sound (human voices, pad under the lines, car rumble)

prompt: "Voices must sound human, not robot. Quiet pad under the lines, never over them. When they sit, low car rumble, not a saw. No radio hiss."

reimagine Peach’s Castle in 3D and create a fly-by video.

Build a model railway with at least three trains running at the same time on a shared track layout that includes junctions and signals. The trains must switch tracks and stop at signals on their own so they never collide, without any input from the user. The layout, the setting, and the look of everything are up to you. Everything about the design is your decision: style, colors, mood, environment, camera, level of detail, and any extra touches. Do not ask me any questions, make every choice yourself and build the most impressive version you can in a single attempt. Technical requirements: one single self-contained HTML file, no external models, images, sounds, or asset URLs of any kind (a JavaScript library from a CDN is fine). It must start running on its own the moment it loads, with no clicks needed, and run smoothly with no console errors.

A small 3D obstacle course with a character, moving barriers, collectible objects, and a simple goal area.

Build an interactive 3D scene featuring a samurai in a forest, with camera controls, cinematic lighting, environmental details, and a clean presentation.

Could you create a conifer with 200 polygons or fewer?

build a 3D world full of very high skyscrapers

CHARACTER REGISTRY:
Exactly one adult male mountain warrior.
He has a compact, broad and extremely powerful build. He wears an original dark gunmetal suit of medieval fantasy plate armor: enclosed pointed helmet, layered shoulder plates, articulated arm protection, heavy gauntlets, reinforced breastplate, leather waist panels, dark trousers, steel greaves and heavy armored boots. His armor is weathered, scratched and wet from the storm.
He carries exactly one enormous two-handed warhammer. It has one long reinforced dark-metal shaft and one heavy symmetrical rectangular hammer head. The weapon remains the same length, shape and weight throughout. He controls it with both hands during jumps, climbing and striking.
Exactly one colossal organic humanoid giant, more than thirty times the warrior’s height. It has immense muscular shoulders, extremely long arms, huge humanlike hands, coarse charcoal-gray skin, visible pores and scars, a heavy brow, broad nose, powerful jaw and long tangled black hair. It is an organic living titan—not a statue, robot, machine or stone golem.
No additional warriors, giants or background armies.
ENVIRONMENT:
A windswept highland battlefield beneath a violent blue-gray thunderstorm. The uneven ground is covered with dark wet soil, flattened grass and thousands of small pale flowers. Strong wind bends the grass and flowers in irregular waves.
A ruined medieval fortress stands on a distant hill at screen-left. Broken towers remain visible through low drifting fog. Lightning intermittently illuminates the fortress and storm clouds.
The giant occupies the battlefield’s screen-right side. The warrior begins in the center foreground, running toward the giant. Preserve this geography and screen direction throughout every cut.
CHRONOLOGICAL ACTION AND CAMERA:
0.00–3.30 — CHARGE TOWARD THE GIANT
Begin immediately with a low rear tracking shot, close behind the armored warrior as he runs powerfully through the wet field toward the colossal giant.
He carries the warhammer horizontally across his body with both hands. The heavy hammer head remains toward screen-right while the lower shaft extends toward screen-left. His boots compress the wet ground with every step, throwing soil, crushed flowers and droplets backward only after physical contact.
The giant’s legs and enormous right hand enter from the upper-right side of the frame. The giant bends down and extends its open hand toward the charging warrior, intending to scoop him from the ground.
The fingers move independently with believable joints and weight. The giant does not instantly grab or teleport the warrior.
Camera movement remains low, fast and smooth, emphasizing the extreme difference in scale. The ruined fortress stays visible on the distant screen-left horizon.
3.30–5.80 — LEAP ONTO THE GIANT’S HAND
As the giant’s open hand sweeps low across the warrior’s path, the warrior plants his right boot firmly into the ground. His knee compresses, hips lower and rear leg drives upward.
He performs one powerful forward jump.
Use controlled cinematic slow motion as he rises in front of the giant’s separated fingers. His legs tuck slightly beneath him while both hands raise the same warhammer above his shoulders for balance.
The warrior lands with both boots on the back of the giant’s middle and ring fingers. Show clear physical contact: boots touch skin, knees absorb impact, the giant’s flesh compresses slightly and the warrior’s armor reacts to the landing.
The giant begins lifting its hand toward its face. The warrior does not float or hang in empty air.
Use a dramatic low-angle crane that travels upward beneath the warrior, with the enormous hand filling the background.
5.80–9.00 — RUNNING UP THE ARM
Return to fast natural action.
As the giant raises its arm, the warrior runs from the fingers across the back of the hand and onto the wrist. His footfalls alternate correctly and visibly grip the uneven moving surface.
The giant rotates its wrist and attempts to shake him loose. The warrior lowers his center of gravity, widens his stance and keeps the hammer close to his torso until the arm stabilizes.
He then accelerates along the giant’s forearm toward the elbow. Each step follows the arm’s changing angle; his boots do not slide through the skin.
Camera tracks beside and slightly below him, rising along the length of the giant’s arm. Near parts of the arm cross the foreground quickly while the giant’s head and distant fortress move more slowly, creating powerful parallax and scale.
9.00–12.00 — CLIMB TO THE SHOULDER
The warrior reaches the upper arm as it rises steeply toward the giant’s shoulder.
He hooks one forearm and the warhammer shaft against a natural ridge of muscle for leverage, plants his right boot, pushes through his leg and pulls himself onto the shoulder in one connected climbing action.
The giant turns its head toward him. Its eye tracks the warrior, its brow tightens and its jaw opens in a deep nonverbal roar. Hair and skin move from the rotation of its head.
The warrior remains attached to the shoulder through real hand and boot contact. He climbs diagonally across the upper shoulder toward the base of the giant’s neck.
Use a close side-tracking shot that keeps the complete warrior, warhammer and giant’s facial profile readable in the same frame.
12.00–15.00 — FULL HAMMER STRIKE TO THE JAW
The warrior reaches a stable position on the giant’s sloped shoulder near its neck.
He plants his left boot forward and braces his right boot behind it. Both feet visibly press against the giant’s skin. He rotates his hips away from the target and draws the warhammer backward with both hands.
Show the complete preparation before impact:
feet plant → knees compress → hips load → torso rotates → shoulders draw the hammer backward → arms guide the heavy hammer head into its starting position.
At 13.00 seconds, the warrior releases one complete horizontal two-handed swing toward the giant’s jaw.
The power travels continuously from his legs through his hips, torso, shoulders and arms. The hammer head follows one clear uninterrupted arc. It does not jump positions or touch the face before the swing is complete.
At 14.00 seconds, enter explicit ultra slow motion for the decisive contact.
The rectangular hammer head strikes the side of the giant’s lower jaw with its broad striking face—not the shaft or handle. Show skin and cheek tissue compressing around the impact, the giant’s jaw shifting sideways, loose hair whipping outward and a radial burst of rain, dust and skin debris.
The warrior’s arms resist the sudden deceleration. His shoulders recoil while his body continues through a controlled follow-through.
No blood, exposed tissue, gore or dismemberment.
15.00–17.30 — GIANT RECOIL AND WARRIOR FALL
Return immediately to natural speed.
The giant’s head snaps sideways from the impact. Its upper body recoils and the struck shoulder drops sharply. This sudden downward movement removes the warrior’s footing and throws him away from the giant.
The warrior falls toward the battlefield while retaining the same warhammer with both hands. He does not float or perform an additional jump.
Cut to a ground-level side view. His boots contact first, his knees collapse under the momentum and he rolls once across one shoulder. The hammer head strikes the soil beside him and digs a shallow trench, throwing wet earth and pale flowers outward.
The giant’s huge face descends into the upper-right portion of the frame as it struggles to regain balance. It does not crush or intersect the warrior.
17.30–20.00 — RECOVERY AND FINAL STANDOFF
The warrior stops his roll in a low kneeling position.
He plants the warhammer head into the soil, grips the shaft with both hands and uses it as support to rise steadily to one knee. He then pulls the hammer free and brings the shaft horizontally across his shoulders in a prepared defensive posture.
The giant lowers its enormous head toward him, jaw visibly bruised from the strike but still conscious and threatening. Its breath disturbs the grass, flowers, fog and loose leather panels on the warrior’s armor.
The warrior remains motionless only for a brief determined beat while his breathing and armor retain subtle natural movement.
A lightning strike illuminates the ruined fortress at screen-left, outlining both figures and confirming their immense difference in scale.
End exactly at 20.00 seconds on a low wide composition: the warrior kneeling in the flower-covered foreground with the warhammer ready, the giant’s face looming above him and the distant fortress visible through the storm.
Do not fade to black. No freeze frame, title or end card.
ACTION-PHYSICS LOCK:
Every action must follow readable physical causality:
Running: foot contact → weight transfer → rear-leg push → next step.
Jump: planted foot → knee compression → leg extension → airborne trajectory → landing contact → knee absorption.
Climbing: hand or weapon support → planted boot → body-weight transfer → upward pull.
Hammer strike: stable feet → hip loading → torso rotation → shoulder drive → continuous hammer path → broad hammer-face contact → resistance → follow-through.
Fall: lost footing caused by the giant’s recoil → gravity-driven descent → boot contact → knee collapse → shoulder roll → recovery.
The warrior never teleports between the ground, hand, arm or shoulder. The giant never moves the warrior without direct physical contact or a visible force.
MOTION-SPEED RULES:
0.00–3.30: fast natural running speed.
3.30–5.80: controlled cinematic slow motion for the jump and landing.
5.80–13.90: natural fast action.
13.90–15.00: explicit ultra slow motion only for the hammer’s final approach, contact and immediate deformation.
15.00–20.00: clear return to natural speed.
Do not apply global slow motion. Do not allow slow-motion characters to hover.
LIGHTING AND COLOR:
Maintain a cold steel-blue, charcoal-gray and desaturated silver storm grade. Lightning provides brief cold-white directional illumination. Wet armor receives narrow silver highlights, while the giant’s dark skin remains detailed and readable.
The pale flowers provide restrained warm ivory contrast without making the scene colorful. Preserve deep atmospheric fog around the distant fortress. Lightning exposure changes must be brief and must not erase character anatomy or hide missing actions.
AUDIO:
Only synchronized diegetic environmental and action sound effects. Absolutely no background music or score.
Include storm wind, distant thunder, armor movement, heavy running footfalls, disturbed soil, bending grass, the giant’s nonverbal breathing and roar, the rush of its hand, the warrior’s jump, boots contacting skin, climbing impacts, warhammer movement, one deep metallic hammer impact, the giant’s recoil, falling air, armor striking soil, the hammer head hitting the ground and a final nearby lightning crack.
No dialogue, narration, spoken words, chants, lyrics or intelligible language.
CONTINUITY AND FAILURE PREVENTION:
Exactly one warrior, one giant and one warhammer throughout.
The warrior climbs the giant once and performs exactly one decisive hammer strike.
The warhammer never duplicates, changes size, floats, bends, passes through either body or switches hands without visible motion.
The giant remains the same organic humanoid creature in every shot. No robotic features, stone transformation, duplicated hands, extra fingers or changing face.
Preserve the warrior’s armor, helmet, proportions and damage throughout.
Preserve the giant’s right-hand-to-right-arm-to-shoulder route so the climbing geography remains physically possible.
No fused hands, extra limbs, reversed joints, sliding boots, intersecting bodies, teleportation or unsupported hovering.
The hammer’s broad head—not its shaft—must visibly contact the giant’s jaw after the complete swing.
No blood, gore, exposed tissue, crushed human body or dismemberment.
No live-action appearance, recognizable franchise characters, subtitles, captions, logos, UI, playback overlays, permanent black bars or watermarks.
Any background music or musical score is a failed generation.
music=0; no_music=1; strict_no_music=1; audio=diegetic_only.

create hotel corridor scene

build an interactive volcanic island with flowing lava and boats that flee.

Interactive panel. Left: schematic nervous system of [organism], clickable regions. Right: procedurally rigged 3D [organism]. Clicking a region triggers a 2.5 second motor response. Dark UI, telemetry for speed and heading.

3D Apple style heart emoji and smiling emoji

Everything I can see should be reachable. Keep the distances real, then make travel work through scale and speed. I want to fly from space into a planet’s atmosphere and down to the ground. Planets can be as large as Earth, so we’ll need procedural terrain and a chunked renderer.

[Prepare First]
・Worldbuilding reference images for the environment you want to create (exterior views, rooms, etc.)
・Canonical character images (such as front, side, and back views)
　*The character cannot be recreated without images. Please attach them.

[Prompt]
Using the attached images, I will design your world and game character as a professional-quality, fully animated 3D environment and game character.

① Inspect the attached images to identify the shapes, colors, and design details of the house and character
　↓
② Generate 3D models from the images in Tripo (use three full-body images—front, back, and side—with the same aspect ratio)
　↓
③ Import the models into Blender and adjust the placement and scale of each part
　↓
④ Set up an automatic rig and add character-specific animations, such as walking and swaying
　↓
⑤ If a decision is required, such as using a paid asset, ask me for confirmation before proceeding
　↓
⑥ Document the work completed, any blockers, and the locations of all assets in enough detail for another AI to reproduce the process

Given the room photo I provided, use Blender MCP to build an interactive 3D scene and render it into a demo video. Include articulated object motion (hinges, doors, drawers) and use sensible camera moves to show these effects.

/goal Develop a PC version of Splatoon. Recreate the graphics in full.

I want you to build a completely realistic HD 3D render model in blender, then build interactive web experience so I can walk within the apartment, and choose tile options.

All characters, background extras, and the station environment share a clearly digitally sculpted, high-end AAA fantasy game CGI look. Character close-ups must retain polished game-character faces, clearly defined braided hair strands, and stylized realistic skin; they must not become live-action actors, cosplay, ordinary gameplay, 2D animation, or cel-shaded art. Keep the supernatural fight in a modern underground station; do not change the setting to a medieval castle, snowy mountains, or a boxing ring. The palette is desaturated cool teal-gray, deep charcoal black, blue-gray scales, and cool-white light strips, with small areas of yellow guardrails, red signal lights, bronze goggle frames, verdigris-green shoulder armor, and ochre-red waistbands. The eyes' honey-gold glow and the brief purple flash when striking a pillar appear only at their specified moments; do not tint the entire film purple.

Environment: a spacious, dim underground railway station with a sunken central track area, rails, and ballast, and platforms raised on both sides. Platform edges have glass-and-metal safety barriers with yellow vertical frames. The floors have yellow safety lines, gray tile, and drainage grates. Thick white round columns support the low ceiling. Continuous cool-white strip lights and circular lamps run overhead, with small red signal lights receding into the distance. Dozens of adult passengers in ordinary light- and dark-colored coats are scattered beside columns or behind barriers. Startled by the fight, they retreat, crouch, and raise their arms for protection, remaining background extras at all times: they do not join the fight, become main characters, or share identical faces. No train enters the station. Signs contain only blurred geometric color blocks with no readable text.

The two fighters remain fixed. A, the goggle-wearing warrior, is a tall, lean, athletic adult man with warm deep-brown skin, defined cheekbones and jawline, and short black close-cropped braids gathered into a short braid knot at the back of his head. A narrow bronze-framed, smoke-gray flip-up goggle visor is fixed across his forehead. It normally covers his eyes, leaving the bridge of his nose and mouth visible. He wears a gray-blue sleeveless crossover-neck combat top, a dark brown waist sash, charcoal-black trousers, and dark brown low-top boots. Both forearms are wrapped in gray cloth. His fingers remain exposed and his hands are always empty: no cape, handheld weapons, or readable insignia. His expression is calm and his movements are agile and decisive. Only in the specified shot does he briefly raise the visor edge with his right hand, revealing one bright honey-gold eye, then lower the visor back over his eyes. This is the same physical visor fixed to his forehead throughout; it must not turn into cloth strips or disappear.

B, the scaled ridged beast, is a muscular bipedal humanoid creature taller and broader than A. Coarse dark blue-gray scales cover its broad chest, back, and limbs, while finer gray-blue scales cover its abdomen. It has a broad, flat lizard-like head, a short blunt snout, a heavy jaw, two deep amber eyes, and short, blunt teeth. It has no human hair, mask, or branch-like protrusions. Thick natural verdigris-green armor plates grow from B's left shoulder to left forearm, with a row of short, blunt bone fins fixed along the top of the left shoulder. The right arm retains lighter gray-blue coarse scales; never swap the left and right sides. The fins and armor plates are part of the body, and there are no flowers on the shoulder. B wears loose dark-brown wide-leg fighting trousers, an ochre-red fabric belt with two narrow hanging tails, and dark-brown cloth wrapped around the ankles. Its broad feet are scaled, with clearly defined soles suitable for bracing against a wall. It has no tail, wings, extra arms, long horns, sword, spear, shield, or handheld props. B is a large beast that can move through a normal station, maintaining a stable scale relative to A and the passengers; it must not swell into a skyscraper-sized giant.

0.00–3.70 seconds: Enter the confrontation on the very first frame. A brief low-angle shot close to the tracks shows B rapidly stepping forward, then cuts to a medium shot behind A as B charges from the front, raises a leg, rotates its hips, and throws a head-height spinning side kick. A bends his knees, lowers his head, and tilts his torso aside as the kick passes above his short black braids. B plants its foot and turns back, while A immediately rises. Cut to a clearly Dutch-angled, low track-level wide two-shot. A raises a knee and follows with a high side kick; B lowers its head and shoulders to evade it, and A retracts the leg, returning it to a supporting stance. Cut back to a close follow shot over A's shoulder. B catches up with a continuous series of swinging punches. A avoids them with short head slips, shoulder dips, and turns, letting the punches skim past his face. Do not have A stand still while B repeatedly swings at him. Ceiling light strips whip through the frame with directional motion trails, while the spatial relationship between the bodies remains clear.

3.70–6.40 seconds: B's light gray-blue right fist extends toward A's face again. A catches the wrist and forearm with an open hand; the point of contact must be visible. The camera moves close to A's calm profile, then follows as he pivots his feet, rotates his hips and shoulders, and quickly moves into a low full-body angle. A keeps hold of the same right arm, pulls B off its base, and swings it up along the side of his body. Both of B's feet leave the ground, with the ochre-red belt and wide trousers lagging behind from inertia. At the highest point of the swing, use only a very brief ultra slow motion, then return to high speed. After completing the rotation, A releases B. B flips down headfirst along the same arc, shoulder and back striking the track bed as ballast and dust burst from the contact point. The low camera follows the fall and shakes briefly. B rolls with the momentum and props up its torso, keeping all four limbs intact. No severed arm, contactless telekinetic throw, or standing up from nowhere.

6.40–9.20 seconds: B is still recovering low to the ground when A has already pushed off and leapt in. From behind B, the camera tilts upward to show A rotating his hips and extending his leg in midair. Briefly slow motion at the apex, then as A descends, drive a lateral flying kick into B's head and shoulder. B raises both arms to block and is forced off balance. A follows immediately after landing; do not have him land and wait. The camera closes in quickly as it follows A's descent and arcs around the side, alternating slightly tilted over-the-shoulder and facial close-ups. A slips past B's returning arm, punches the torso with a short strike, then uses an open palm to push the side of B's face, turning B's head aside only after contact and in the direction of the push. The palm, face, and forearm must remain separate and clearly defined. B's left-shoulder bone fins rotate with the same-side shoulder armor and torso.

9.20–11.20 seconds: Using the space created by the facial push, A turns and retracts his leg, then drives a powerful side kick forward. The sole contacts B's abdomen to lower chest. B's torso folds first, then both feet leave the ground as it flies upward and sideways toward the platform. The camera follows B skimming over the platform edge. B's upper back and shoulder slam into a white column. The column cracks outward from the contact point, shedding pale fragments and dust, and B slides down the column onto the platform floor. After retracting his leg, A leaps from the track area onto the same platform and closes in. After the cut, he appears in a continuous position beside that column, not teleported to another station. Passengers scatter to both sides. The column is damaged but does not collapse completely.

11.20–12.80 seconds: Cut to a close-up of B's face after the impact. It lifts its head and turns to search for A, with the left-shoulder verdigris armor plates and short bone fins still present. Quickly shift to a close composition on opposite sides of the same column: B occupies the right foreground, while A stands behind and to the left beside the column, wearing a slight cold smile but saying nothing. A raises the edge of the bronze-framed visor with his right hand, revealing one bright honey-gold eye and looking directly at B for a very brief moment. He lowers the visor with his right hand so it covers his eyes again, simultaneously preparing to evade. Do not leave a pause for nonexistent dialogue or animate a speaking mouth.

12.80–13.80 seconds: B turns its shoulder and swings its light gray-blue right fist toward A's position. Before the fist arrives, A quickly sidesteps around behind the column. The fist hits the solid white column, producing a compact purple energy flash at the moment of contact. Cracks extend, debris falls, and the brief purple light immediately disappears. The close-up first shows the fist pressing into the column surface, then quickly widens to reveal that B has missed and A has already moved around to the side. It remains the same previously damaged column. Do not turn A into purple smoke or let the fist pass through a body.

13.80–16.00 seconds: In a low, tilted wide shot, A crouches in front and to the side of the column and makes a brief beckoning gesture. B turns and charges. A pushes off and completes one continuous back handspring: first arching backward, sending both feet up over his head, then tucking through the inverted phase to evade B's sweeping arm. The camera tilts upward with the body; briefly slow motion during the inverted phase as the light strips slant across the background. A continues the same rotation, brings both feet back beneath his body, and lands in the open platform space behind B, bending his knees to absorb the landing. His clothing hem and short rear braids settle with the inertia. Frightened passengers dodge in the background; they are not additional attackers. A is not knocked away and does not repeat flips in midair to pad the duration.

16.00–18.50 seconds: As soon as A stands, B turns and catches up with a broad swing toward the side of A's head. A first leans back, then ducks under B's light gray-blue right arm as it passes overhead. He controls the forearm with both hands, steps into the front of B's body, and turns his back while lowering his center of gravity. A guides B's arm over his shoulder and uses B's continued forward momentum to complete a shoulder throw. B's hips rotate over the fulcrum, both feet leave the ground, and its back lands on the platform tiles as broken tile and dust spread along the floor. The camera pulls from a tight shoulder shot to a low medium-wide shot, clearly showing the rotation and landing. A remains standing and releases B to the ground. B immediately rolls, props itself up, bends its legs, and rises. A turns toward it and continues the pressure, linking the recovery to the pursuit without a long pause for standing dialogue.

18.50–20.65 seconds: B rushes back into close range. A strikes first with a short straight punch toward the side of the face, retracts to guard his chest, then lowers his body and punches toward the abdomen and ribs. B raises an arm to block one strike and counters with a heavy horizontal sweep. A stays inside B's chest and shoulder line, dips his head to evade, uses his forearm to knock aside the retracting punch, and follows with compact short punches contacting the jaw and upper chest. The camera makes fast, small movements around the two fighters' shoulders. Heads and bodies recoil only after actual contact. Complete this section as a continuous exchange of attacks, blocks, parries, and counters; do not show them taking turns throwing punches into empty space, failing to react, or keeping both fists pressed together.

20.65–21.85 seconds: Cut directly to a clear overhead shot. The two fighters move around the same small patch of floor tiles. A's black short braids and bronze visor frame, along with B's left-shoulder verdigris armor plates and ochre-red belt, remain fixed identifying features. B's broad arm sweeps past A's side. A hunches his shoulder and slips inside the arm, changing foot position one step at a time. One hand knocks aside B's forearm while the other punches into the chest and abdomen, then retracts as A adjusts position with B's rotation. Fallen tiles and the drainage grate remain in their original positions. Use the overhead shot to show the close-quarters attack-and-defense route; do not add a double or third fighter.

21.85–24.00 seconds: Cut back to a tight shot over B's shoulder. A continues a series of short alternating high and low punches while slipping his head away from B's arm swinging down from above. The wrapped forearms and gray-blue scaled arm cross, but their boundaries remain clear. The camera follows A's punches driving forward. At two strong contact points, add only a few frames of high-contrast black-and-white exposure flashes with dimensional impact contours, then immediately return to the original cool blue-gray AAA CGI look. Do not cut to comic-book art, text, or a 2D illustration. The final straight punch clearly compresses B's abdomen inward. Its torso folds, and the arm swinging down from above loses forward direction with the torso. A's feet remain planted, with force traveling through the legs, hips, and shoulder into the fist. The fist does not pass through the body.

24.00–28.00 seconds: Immediately continue with the aftermath of the same heavy abdominal strike. Both of B's feet leave the ground as it flies backward. The camera tracks rapidly along the station's long axis, low and close to the platform edge, sweeping past white columns, yellow frames, glass barriers, and startled crowds. Background lines stretch with speed. B's blue-gray scaled body, dark-brown trousers, ochre-red belt, and left-shoulder verdigris armor plates remain recognizable throughout. Use long-axis wide shots, rapid cuts with columns brushing past the foreground, and low upward-looking close-ups to show B rotating through the inertia and extending its arms to regain balance. Debris it kicks up travels along the same flight direction over the tracks. B then crashes through a section of the platform's glass-and-metal safety barrier. The glass breaks upon body contact and the metal frame bends. B continues through the opening into the track area, then cut to a wide shot facing the track-side wall. This remains one continuous flight caused by the preceding abdominal strike: do not add an off-screen kick, second launch, or passengers being knocked away. Do not duplicate A behind every column.

28.00–30.00 seconds: Use a locked-off lateral medium-wide shot. A dark-gray vertical track wall fills the left side of the frame, with the opposite platform and passengers behind the barriers in the right background. Long light strips point into the depths of the station. B rotates in the air until its feet face the wall. Both soles clearly contact the vertical wall. B bends its knees and tucks its abdomen into a compact crouch, scraping a small amount of wall dust from beneath its feet. It then slowly extends its knees in ultra slow motion, rotating its torso outward as its body gradually approaches horizontal. The soles remain braced against the wall. The ochre-red belt, wide trousers, and small fragments continue moving, showing the continuous process of contact, compression, and loading. This is not a back-first wall impact, a frozen hover, or standing on a horizontally overturned surface.

End exactly at 30.00 seconds with B still braced against the wall with both feet, its body opening outward in active motion. Do not add a complete wall-kick counterattack, landing, death, or victor/defeat resolution. No black screen, fade-out, or end card.

Pacing and continuity: preserve the sequence of rapid pursuit, close-range evasion, throws, flips, flying kicks, pillar impacts, overhead short strikes, and movement across the platforms. Shorten observation and nonexistent dialogue pauses. Use localized slow motion only at the highest point of the swing, the airborne evasion, and the final wall brace; explicitly use ultra slow motion for the final wall-brace phase. Normal exchanges must remain fast and fluid. Do not use global slow motion or freeze frames to pad the duration. Keep A's black short braids, deep-brown skin, bronze-framed visor, gray-blue sleeveless top, and wrapped forearms consistent. Clearly show the visor's covered and uncovered states before and after the eye reveal. Keep B's left-side verdigris armor plates and short bone fins, right-side gray-blue scaled arm, broad lizard-like head, dark-brown trousers, and ochre-red belt consistent. The fins must not fall off, switch sides, or become weapons. A fighter who is knocked down must contact the ground before recovering support. An active jump must begin with a push-off. A hit-driven flight must begin with contact. Wall braking must begin with the soles contacting the wall, followed by knee flexion. Every movement must retain weight, inertia, and direction. Background passengers continue making varied, natural evasive movements while maintaining clear spatial separation from the fighters; they must not merge with them or suddenly enter punch and kick paths. Damaged column surfaces, fallen tiles, and the broken barrier remain damaged in later shots.

No additional weapons, extra limbs, blood spray, or dismemberment.

Strictly prohibit background music: at no point may the film generate background music, a score, a music track, melody, rhythmic percussion, choir, song, sustained musical tone, or tonal atmospheric bed. Allow only diegetic audio synchronized with the visuals and physically belonging to the scene: underground-station ventilation and room reverberation, footfalls and foot scrapes, clothing and ochre-red belt movement, punches and kicks cutting through the air, dull impacts from actual contact, nonverbal breathing and brief grunts of pain, rolling ballast, cracking concrete, shattering glass, bending metal barrier frames, passengers' retreating footsteps, a brief non-melodic electrical crackle from the purple-light impact, and the final friction of soles braced against the wall with falling wall dust. No dialogue, narration, intelligible shouted words, songs, subtitles, or captions. Do not use pulsing sounds, orchestral hits, melodic sound design, or rhythmic effects to fill the absence of music. Do not arrange the combination punches, footsteps, or breaking glass into drumbeats, and do not extend ventilation noise into a musical sustained tone. Any background music or score is a failed result. music=0; no_music=1; strict_no_music=1; audio=diegetic_only; no title, readable station name, logo, interface, player controls, or watermark.

You are a Senior Creative WebGL & Three.js Developer. Your task is to build a complete, production-ready, interactive 3D scene contained entirely within a single standalone HTML file (index.html) using Three.js + webgl

### 1. Visual Theme & Art Direction

- Atmosphere: Deep night forest, cozy glowing campfire, solitary weary knight resting at the campsite (Dark Souls bonfire / classic retro RPG aesthetic).
- Aesthetic: 3D Pixel Art / Voxel / Low-Poly aesthetic.
- Shading & Post-Processing: Integrate Three.js post-processing (RenderPixelatedPass or an equivalent low-resolution pixelation/dithering effect) to achieve an authentic 16-bit/32-bit retro look.

### 2. Scene Geometry & Assets (100% Procedural — No External .gltf/.obj Files)

All assets must be constructed procedurally using Three.js geometric primitives (BoxGeometry, CylinderGeometry, etc.) and basic materials so the file runs locally without CORS issues.

1. Forest Environment:

   - Ground: Dark stylized terrain with procedural voxel stones, mushrooms, and low-poly foliage.
   - Trees: Procedural pine/spruce or blocky canopy trees surrounding the clearing to create depth and seclusion.
   - Sky & Lighting: Deep midnight sky with flickering voxel stars and a cool moonlight DirectionalLight casting soft shadows.
   - Depth: THREE.FogExp2 with a dark atmospheric color to blend the horizon.

2. Campfire:

   - Stone circle surrounding smoldering logs and procedural ember embers.
   - Fire System: Animated pixelated particles (Points or pulsing voxel meshes) rising upward.
   - Dynamic Lighting: Warm orange-red PointLight with continuous, natural flicker logic (using Math.sin, noise, or pseudo-random variations).

3. The Knight:

   - Hierarchical scene graph (groups for head, torso, upper/lower arms, legs, cape, and sword) built from voxelized primitives.
   - Visual details: Slotted helmet, chest armor, pauldrons, gauntlets, and a sheath/sword.
   - Pivot points must be aligned correctly at joints (shoulders, elbows, hips, knees) for clean procedural rotation animations.

### 3. Interactive Knight State Machine

Implement smooth procedural animations using linear interpolation (lerp) or trigonometric curves inside the render loop for the following selectable states:

- Sit by Fire (Default Idle): Sits cross-legged or crouched, subtle breathing cycles, warming hands near the flames.
- Add Firewood: Knight stands up, retrieves a log, and tosses it onto the fire. The fire visibly flares up, expands its light radius temporarily, and emits a burst of sparks.
- Sword Practice: Stands up, draws the sword, executes a clean 3-part attack/parry routine, and returns to a combat guard stance.
- Look into the Distance: Walks to the edge of the clearing, plants the sword into the ground, and stares out into the dark while the cape sways.
- Sleep: Lies down on a bedroll beside the fire; floating animated pixel "Z z z" particles rise from the helmet.
- Roast Meat: Holds a stick with food over the flame; emits subtle procedural smoke/steam particles.

### 4. Camera System

Provide preset camera switches with smooth transition interpolation (lerping position and target):

- Cozy Close-up: Medium shot focusing on the knight and the firelight.
- Isometric RPG: Classic high 45-degree tactical overview of the clearing.
- Cinematic Ground: Low-angle dramatic shot looking upward at the knight against the starry sky and pine canopies.
- Free Orbit: Seamless switch to standard OrbitControls for interactive inspection.

### 5. UI & Audio

- UI Style: Retro 8-bit/16-bit RPG HUD layout using semi-transparent dark frames with pixelated borders and an embedded Google Font (e.g., 'Press Start 2P').
- Bottom Panel: Interactive action buttons triggering each knight state.
- Top-Right Panel: Camera angle switcher buttons.
- Firewood Counter: Tracks logs added and current fire intensity.
- Sound (Web Audio API): Procedurally synthesized fire crackle and ambient night breeze/crickets, with a mute/unmute toggle button.

### 6. Technical Specifications

- Single, self-contained index.html file.
- Use ES Modules loaded via CDN (https://t.co/W8o3SZwkCj or unpkg).
- Modular, well-commented code structure (initScene, buildEnvironment, buildKnight, buildCampfire, setupUI, setupAudio, animate).
- Fully responsive window resize handler updating camera aspect ratio and pixelation pass resolution.

Add a maintenance chain to the handrail!

Create a racing game

Create a 3D escape game that can be played in a browser. The objective is to escape from a sealed research facility, and the game should take about 5–10 minutes to play. Include mechanisms such as keys and switches, make the controls and objectives easy to understand, and ensure the game can be completed from start to finish. Package everything in a single HTML file so it can be played simply by opening it in a browser.

I told Astra to CAD itself a body.

# Monster Block — rebuild specification

## 1. Project goal

Build a playable browser game called Monster Block. Let the player choose a toy monster, enter a miniature city, and destroy as many buildings as possible in 45 seconds. Moving, clawing buildings, throwing cars, and chaining demolitions must produce immediate feedback. Finish with a score, a title, a retry action, and a challenge link that lets a friend play the same block. Provide English and Simplified Chinese interfaces and keyboard and touch controls.

## 2. Visual style

Create a warm tabletop diorama on a thick square platform against a cream background. Use low-detail pastel buildings, small dark teal windows, pale roof rims, broad muted green-grey roads, zebra crossings, rounded trees, tiny cars, and warm soft shadows. The building palette includes terracotta, mustard, dusty teal, rose, blue-grey, cream, and sage. Materials should look like matte painted toys rather than shiny metal.

Use a high three-quarter perspective camera, not a flat overhead camera. The reference camera starts at (35, 37, 41), looks toward (0, 0.4, 0), and uses a 38-degree field of view on wide screens, 44 degrees on intermediate screens, and 51 degrees on narrow screens. During play, smoothly follow the monster while keeping nearby targets visible. Light the scene with a warm hemisphere light, a soft shadow-casting directional light, and a cool fill light.

Use condensed bold display typography for large English headings and a readable sans-serif for instructions. Combine dark green text, cream surfaces, orange play actions, and yellow Tripo creation actions. On the homepage, make Play and Create with Tripo equally prominent. In the pause dialog, place a dark green Tripo card with three character thumbnails and a yellow creation button above the outlined Resume button. Keep help text comfortably readable on phones.

Use short, input-triggered effects: claw swipes, brief building recoil, distinct hit and demolition impacts, expanding stomp rings, small debris bursts, score popups, combo changes, and a restrained directional camera jolt. Lift a grabbed car into the hand over about 220 ms. Honor reduced-motion preferences by removing shake, debris bursts, and UI scaling while retaining scores, target cues, and destruction outcomes.

## 3. World and scene

Place 16 destructible buildings in a 4-by-4 grid. Use block spacing 10.4, block centers at -1.5, -0.5, 0.5, and 1.5 times that spacing, and five avenues along each axis. The platform is 52.6 units wide. Buildings have two to five floors, varied footprints, roof details, occasional awnings, and small HOTEL or NOODS signs. Generate the layout deterministically from a seed.

Place 12 cars along the roads and one guaranteed throwable yellow car near the initial play position. Include trees around building plots and platform edges, four corner lamps, lane markings, and a central crossing. Start the monster in a clear avenue at (0, 0.2, 10.4); use a foreground idle position at z=20.8 for the homepage.

The same block parameter must reproduce the same building layout. When absent, derive the block seed from the UTC date. A beat parameter supplies a friend's target score. Keep the selected block when retrying. Random debris need not be deterministic.

## 4. Asset inventory

Maintain stable asset IDs and separate visual models from gameplay collision proxies.

- munch: Munch / 阿猛, the default green dinosaur. Preserve the original rounded snout, cream belly and horns, orange back spikes, short arms, large feet, and long tail. Load /assets/monster-animated.glb and normalize its height to 5.6 units. Retain /assets/monster.glb as a static fallback.
- bongo: Bongo / 橘拳, an orange toy gorilla with oversized fists and a broad body. Load /assets/bongo-animated.glb and normalize its height to 4.5 units.
- bolt: Bolt / 蓝电, a blue toy robot with chunky limbs and a friendly silhouette. Load /assets/bolt-animated.glb and normalize its height to 4.9 units.
- Each character has a matching preview PNG and idle, run, and slash clips. Preserve the actual three selectable characters; switching must update both the preview and the model used in the next round.
- city_building: procedural reusable building groups, with separately tracked health, collider bounds, hit recoil, and demolition state. Their roof rims, bases, and awnings belong to the collision envelope.
- city_car: reusable procedural throwable cars. Keep held, airborne, and destroyed states separate. Three cars carry yellow Tripo branding.
- city_decor: procedural trees, lamps, sidewalks, signs, and road paint. Keep this lightweight and reuse geometry and materials.
- tripo_scenery: one rooftop logo sculpture, two rooftop signs, one workshop storefront, and three branded cars. Construct these from the supplied Tripo logo and procedural meshes. These are scene decorations, not additional API-generated models or gameplay power-ups.

The three character models are the priority Tripo assets. Reuse the supplied generated and rigged GLBs when available. For a new character, generate a matching toy-style model, check rig suitability, bind it, create idle/run/slash animations, and validate its proportions before adding it to the roster. Do not call generation APIs when a player starts a round. Character uploads and automatic import of a player's own creations are outside this version.

## 5. Gameplay and feedback

Support WASD or arrow keys for movement, held Space for repeated claw attacks, E to grab a nearby car and E again to throw it, R to stomp, and Escape to pause. Provide a virtual joystick and separate attack, grab/throw, and stomp buttons on touchscreens. Clear held inputs when pausing or losing focus.

Use these rules:

- A round lasts 45 seconds. Buildings have floor count plus one health, giving 3–6 health.
- A claw hit deals 1 damage, with a 0.42-second attack interval.
- A stomp deals 3 damage to each building in range and has a 7-second cooldown.
- A thrown car deals 4 damage to buildings in its impact area and awards 75 base points for the throw impact.
- A building hit awards 20 times the current multiplier. A demolition adds round(180 + building height × 50) times the multiplier after incrementing the demolition combo.
- Demolishing again within 3.5 seconds continues the combo. Ordinary hits do not extend this window. The multiplier is min(5, 1 + floor(combo / 2)).
- Clearing all 16 buildings ends the round and awards ceil(seconds remaining) × 100. Otherwise, end when time reaches zero and prevent further scoring.

There are no enemies, boss fights, player health, or death penalties. The challenge is choosing routes, using cars and stomps efficiently, and maintaining a demolition combo. Show the remaining time, score, buildings destroyed, multiplier, and stomp cooldown. Make unavailable actions understandable without blocking movement. Distinguish an empty swing from a successful hit through sound and visual feedback.

Resolve movement and rotation against each character's sampled animated footprint, including arms and tail. Check against full building bounds with a small clearance. The monster must be able to attack from a legal standing position. Allow movement through a plot after its building is demolished. Avoid trapping the player at corners or letting a turn sweep the tail through an intact building.

Pause the timer and input on Escape, the pause button, window blur, and hidden tabs. Provide Resume, Retry, and Home flows. End with the score, demolition count, best combo, a playful title, and a same-map challenge link. Provide a downloadable 1080-by-1350 scorecard and, where MediaRecorder is supported, a recording of the round in a supported MP4 or WebM format. Use native sharing when available and a clipboard fallback for challenge links. Never present a browser-computed score as a secure competitive leaderboard.

## 6. Technical implementation

Use Three.js, TypeScript, and Vite with a static dist build. Keep world generation, rules, collision, characters, rendering, audio, recording, analytics, and UI in separate modules. Bundle fonts and required decoder assets locally. Use instancing for repeated windows and road markings and reuse materials and geometry. Cap render pixel ratio at 1.65. Bound temporary effects and dispose of their resources on completion or reset.

Use GLTFLoader, skeletal animation mixers, and the supplied GLB clips. Normalize each model around a centered ground pivot. The reference exports face +X; rotate the visual pivot by -90 degrees around Y to align with the game's +Z forward direction. Evaluate idle before displaying the loaded model and keep animated feet near the ground. Use a visible procedural fallback if loading fails; expose the failure honestly. Guard asynchronous character selection so an older load cannot replace the latest selection.

Keep character collision data independent from render meshes and rebake sampled footprints when changing the character or animations. Test both translation and rotation near walls. Preserve stable keyboard/touch input, responsive dialogs, localized copy, focus behavior, muted audio controls, reduced motion, and WebGL recovery behavior.

Link Tripo creation actions to https://www.tripo3d.ai/ with utm_source=monster_block, utm_medium=referral, utm_campaign=monster_block_game, and a placement-specific utm_content: header_logo, hero_create, pause_create, result_create, or footer_logo. Open these actions in a separate tab and pause active play first. Explain that Tripo creates 3D assets; do not promise automatic import into this game.

Preserve the existing Pageview and PostHog event integration when supported by the hosting policy. Use only public browser ingestion configuration in the static build. Keep generation, CMS, deployment, and personal analytics credentials outside source and build artifacts. Record page entry, character selection, play, first actions, round results, retry, sharing/export, and outbound Tripo clicks without treating clicks as verified signups or payments.

## 7. Done criteria

Deliver runnable source, local assets, a production static build, and clear install/start/build instructions. Verify all three character selections, a full timed round, building destruction, grabbing and throwing, stomp cooldown, combo expiry, pause/resume, retry, and end-of-round scoring. Verify the original dinosaur remains selectable and that all three characters can move and turn near buildings without visible penetration or getting stuck.

Check English and Chinese layouts at desktop and narrow mobile widths, including readable help copy, touch controls, pause actions, and result sharing. Verify Tripo CTA destinations and UTM placement values, scorecard export, and recording fallback behavior. Test the deployed page and its actual CMS iframe environment for model loading, input, external links, and downloads. Report browser or device limitations instead of claiming universal support or a measured stable frame rate without evidence.

Have the dexterous hand perform pen spinning. Use Isaac Lab for reinforcement learning with the Sharpa hand, and create the pen’s 3D mesh from scratch. Deliver the trained policy and a visualization video. You may freely search online and download papers and other required resources.

Create a single-file HTML/JS 3D game (Three.js) that can be played directly in the browser, with a warm, low-poly but polished indie game style, evoking the feel of a Ghibli seaside town combined with the smoothness of Zelda's mine cart tracks.
【Core Gameplay】  The player drives a retro aerial tram, traveling between islands floating above a sea of clouds and the ocean surface.  - The track is a continuous 3D railway, featuring straight sections, uphill slopes, downhill slopes, elevated curves, and long bridges across the sea  - Controls: W to accelerate (Power), S to brake (Brake), left and right for fine-tuning or switching the view  - Real-time display: speed in km/h, number of passengers on board (e.g., 12/16 aboard), road conditions (Steady / Crosswind)  - Passenger comfort system: sudden acceleration, hard braking, taking corners too fast, and crosswinds all reduce "leg comfort"; arriving at the destination smoothly earns bonus points (e.g., +75 at arrival)  - Streak: driving too bumpily will trigger the message "Streak broken. Find your balance to rebuild your tips."  - Arrive at the station, open the doors for passengers to get on and off. On the platform, there are townsfolk queuing up, with subtitles such as "Doors opening - Mango Tide," "Please wait…"     [World and Stations]  At least two routes/two islands:  1. Saltlight Terminus  2. Mango Tide  The island is a rocky island floating above the clouds, with small Mediterranean/Southern European-style houses with red-tiled roofs, a lighthouse, a dock, green trees, streetlights, and warm yellow windows at night. In the distance, there are more floating islands and circling orbits. The sky is a blue-purple gradient from dusk to night, with stars and thick clouds, and below is azure seawater.     [Tram Exterior]  Retro tram: dark green body, wood-colored chassis, curved glass windows, roof luggage, green awning/vine decorations, and various passengers sitting inside. While moving, there is a slight swaying motion and a sense of track sounds (which can be conveyed with simple sound effects or visual cues).     [Scene 2: Workshop Modification]  Switch to the top-down isometric view of the workshop "Cloudworks / Oliver Cloudworks / Oliver's home island."  Players can swap parts for the tram, with an interface like an upgrade pop-up:  - Hearth leaves — Lifting the old part  - Little Companion — Preparing the tram  Progress bar + "Sit back and watch the workshop."  Changes to the tram's appearance after modification (e.g., green roof, added luggage rack, lanterns, vines), then it drives out of the workshop, subtitles "All aboard." / "Next stop: the Coastal Line."     [UI]  Clean modern casual game UI: destination and currency/streak in the top-left, speed bar and Power/Brake buttons at the bottom, comfort progress bar connecting the two station names. No clutter, don't make it horror or cyberpunk.     [Technical Requirements]  - Single file or minimal files, Three.js  - Use curves for the track (CatmullRom, etc.) so the tram follows the rails, camera follows with a slight rail feel  - Simple physics feel: acceleration inertia, braking deceleration, body roll when cornering  - On mobile, try to also support tap to accelerate/brake  - Readable code, with comments, playable as soon as it's opened.

Build a photorealistic 3D world. Surprise me.

Use Three.js to develop a highly faithful 3D interactive watch model of an IWC Schaffhausen timepiece. Requirements: 1) The dial structure must be highly precise, with every mechanical component individually rendered and clearly distinguishable; 2) The watch face must use a sapphire glass material with realistic transparency, refraction, and reflection effects; 3) The minute hand and second hand must be correct hands that follow real timekeeping logic, with automatic continuous hand-sweep animation; 4) Support disassembly and reassembly of the watch, with each part able to be separated and viewed individually; 5) The overall level of detail must be extremely high, closely matching the structure and proportions of a real watch, with realistic material textures for screws, metal parts, and other components, and fine craftsmanship. Please ensure the model runs smoothly in the browser and interacts naturally.

a galaxy from real orbital physics, 320,000 stars, one flight through it, 30 seconds

Build a complete photorealistic 3D environment. Surprise me.

Use three.js to build a 3D interactive display of an aircraft engine on a webpage.
Please refer to Jigspace's interaction design philosophy to achieve a realistic model with near 1:1 high-fidelity restoration, fully preserving material and texture details such as metal, pipelines, and blades. Interactive features must include: step-by-step disassembly animation, exploded view of components, and part descriptions and principle explanations triggered by click or hover.
Overall, it must support smooth camera control and friendly human-computer interaction, ensuring a smooth experience on the web that fully showcases the engine's structure and working principles.

Photorealistic cinematic single take, 10 seconds, 16:9, 24fps, locked-off camera, no cuts.
A ginger-and-white tabby cat (white muzzle, chest and paws, orange tabby stripes with an "M" on the forehead) sits upright, dead center, facing the lens in a rigid martial-arts posture — flat, stoic, unimpressed stare, eyes half-lidded, mouth closed, head never moving. It wears a black hachimaki headband tied low across the brow, knot at the back, ears sticking up above the band.
Setting: traditional Japanese temple courtyard — warm wooden pillars, eaves and railings — melted into creamy golden-hour bokeh. 85mm lens, f/1.8, extremely shallow depth of field, focus locked on the cat's eyes. Warm 3500K grade, soft key light from front-right, gently filled shadows, fine film grain.
ACTION: a bare human arm drives in from frame left, open palm thrusting fast at the cat's face with strong motion blur; the cat calmly lifts its right front paw and parries, intercepting the palm and killing the strike's momentum — it blocks, it doesn't slap. The arm sweeps horizontally across the cat's face in a blur, then a second hand chops down from the right; the cat deflects each one with a short minimal paw block, body and head completely still, eyes never leaving the lens. The hands are the aggressors — the cat is purely reactive and unbothered. The hands feint in and out from both sides; the cat slides into a two-paw boxing guard at chest height, paws curled, elbows in, and holds it, waiting. It snaps out quick blurred single-paw counters, kung-fu style, catching the incoming hands mid-air, head still locked forward. Finally it drives its right paw straight into the lens, pink pad facing camera, until the paw fills the frame as a soft out-of-focus foreground shape — the face stays razor sharp behind it, cold stare intact.
Motion: natural speed, real motion blur on the flying hands and the fast paw blocks. Defensive, minimal, economical cat movement — it barely moves, the hands do all the work and fail. No camera movement, no zoom, no text.
NEGATIVE: extra limbs, fused/mutated paws, extra fingers, distorted face, headband merging into fur, plastic skin, oversaturated color, text, subtitles, logo, watermark, cuts, camera shake, playful/celebratory body language, high-five gesture.
SHORT VERSION:
Ginger-and-white tabby cat in a black hachimaki headband sits in a sunlit Japanese temple courtyard, deadpan stare at camera, 85mm f/1.8 shallow DOF, golden hour, film grain. Human hands chop and thrust in fast at its face from both sides in motion blur — the cat calmly parries each strike with a minimal paw block, never moving its head. It drops into a two-paw kung-fu guard, throws fast blurred counters, then drives its paw into the lens until the pad fills the frame. Locked-off single take, 10s, 16:9, 24fps, photorealistic, no text.
Catatan kecil dari frame: tangannya dominan masuk dari kiri (chop descending + sweep horizontal), kontak terjadi di wrist/palm — bukan paw-to-paw. Guard dua paw ada di ~4.0-5.6s, counter blur di 5.6-8s, finish paw ke lensa 8-10s. your job is to make 3d mashed with blender mcp and make 10s 24fps output amd render it to super realistic scene with pixverse cli using seedance 2.5 as video model generation
AGENT STEPS: Check Blender MCP, PixVerse CLI authentication, model capabilities, and available credits. Disclose estimated costs and obtain spending approval before paid generation. Turn the prompt into a timed beat sheet, build lightweight 3D meshes and animation through official Blender MCP, render a motion-reference MP4, and inspect framing, motion, contacts, duration, and frame rate. Generate and inspect a separate appearance-reference image before submitting the video. Use the image to guide identity, style, and lighting, and the Blender video to guide movement and timing. After generation, download the result, verify technical specs, inspect key frames, report deviations honestly, and calculate actual credit usage. Preserve originals; never silently switch models or regenerate.
PIXVERSE CALL: Use pixverse create image with gpt-image-2.0 to create the appearance reference at the confirmed aspect ratio, 1080p, high detail. Then use pixverse create reference with the confirmed video model, passing both --images and --videos to combine the appearance image with the Blender motion reference. For Seedance 2.5, use --model seedance-2.5 --task-type auto, the confirmed duration/aspect ratio, and --quality 1080p --count 1. Verify current capabilities before submission, use unique idempotency keys, and track completion through pixverse task status / pixverse task wait.
FINAL OUTPUT: Return the completed video at the confirmed aspect ratio and duration, targeting 1080p and 24fps, plus the appearance-reference image, Blender .blend project, and motion-reference MP4. Provide absolute local paths or downloadable URLs. Keep the final report format: Video, Gambar referensi, Blender mesh + animasi, Check, Look, and Kredit terpakai. Report actual resolution, frame rate, frame count, duration, visual deviations, image/video credit costs, total spent, remaining balance, and whether any regeneration occurred.

3d model of Waymo Jaguar i-Pace using three js

Build a single HTML file with a 3D scene showing a small sailboat moving across open water, with native steering and a course that navigates around two visible islands, similar to the comparison "boat game" demos seen in recent model tests.

Functional requirements:

A water surface rendered as an animated wave mesh (procedural water shader, moving waves, light reflections that shift with viewing angle, a wake trail behind the boat), not a flat, static texture.
A sailboat model built from simple shapes (hull, mast, sail filled by the wind), with visible bobbing and slight tilting on the waves, synchronized with the motion of the water beneath it.
Two distinct islands placed at different points in the scene, each with simple terrain shaping (a rise, a beach, optionally vegetation) and a shadow cast onto the water around it.
The boat should follow a route that genuinely avoids both islands (never clipping through their silhouette or crossing through the land), turning smoothly rather than snapping between angles.
The camera follows the boat with a slight lag (smoothed camera follow), giving the impression of a dynamic chase rather than a rigidly attached top down view.
A gradient sky (e.g. sunset or daytime blue, model's choice) with a sun or light reflection on the water, directionally consistent with the shadows on the islands.

Technical requirements:

A single .html file, three.js from cdnjs is allowed, no other external assets or textures, all water and terrain generated procedurally in code/shader.
The route around the islands can be a pre-planned path (e.g. a Bezier curve threading between the islands) or simple steering that reacts to position, model's choice, but no collision with land is allowed.
The animation must run smoothly for at least 20 seconds, looping or continuous, minimum 30fps on a typical laptop, canvas resolution capped to window size with a devicePixelRatio no higher than 1.5 to avoid overloading hidpi screens.

Judged primarily on whether the water looks convincingly like a fluid in motion (not a texture with animated UV offset), whether the boat genuinely reacts to the waves, and whether the route around the islands reads as intentional navigation rather than a random near miss.

create a 3d model of wall-e in three.js.

create Verdant - an interactive 3D diorama built with Three.js + WebGL

A lush island with roaming dinosaurs, a waterfall, and a cutaway lagoon with a swimming marine reptile. Feed the herd, hatch a baby dinosaur, and take the camera underwater

Adjust the tide, wind, and time of day, or bring in tropical rain while relaxing music plays

Everything runs right in your browser, in a single HTML file

I want to build an interactive 3D Sun model website using Three.js.

First, please write a Python script that can be run directly in Blender to create a highly realistic 3D model of the Sun. The model should be based on the Sun's real physical and visual characteristics, including its spherical shape, surface texture, color, plasma-like appearance, solar granulation, and glowing atmosphere. It should not look like a simple orange sphere. Please use appropriate materials, shaders, textures, and lighting effects to create a realistic solar appearance.

Then, write the complete website code using Three.js. The Sun should occupy approximately 80% of the main visual area. Users should be able to rotate the Sun, move the view, and zoom in and out. The scene should include realistic lighting and glowing effects to make the Sun look dynamic and three-dimensional.

Add a zoom-in button that allows users to get closer to the Sun and observe its surface details.

The website should also include informative content about the Sun and its role in the solar system. The overall background should be a realistic cosmic galaxy/space environment.

In addition, add a button that opens an interactive internal anatomy view of the Sun. This view should show the major layers of the Sun, such as the core, radiative zone, convection zone, photosphere, chromosphere, and corona. Each layer should have a corresponding label and a short text description. Ideally, users should be able to interact with the diagram and select different layers to view their information.

Please make the website visually impressive, scientifically informative, and fully interactive, with a modern space-themed UI.

Build a complete, production-quality browser racing game called Spline Rush using the latest Three.js (WebGPURenderer + TSL where possible). 100% procedural: no external models, textures, audio files or fonts. Everything generated in code at runtime.

CORE GAME
- 6 unique tracks with elevation, banking, tunnels, hairpins, named corners and distinct biomes (coastal day, mountain dusk, desert sunset, forest rain, night city neon, high-speed oval).
- Championship mode (qualifying + 3 races), Time Trial with ghosts, Quick Race.
- 8 AI opponents with personality, racing line, braking points, overtaking and defending.
- Best lap records, sector times, live event feed, replay camera.
- Garage: 5 parametric cars with clearcoat + metal-flake paint, panel gaps, working lights, animated suspension, damage states.

GRAPHICS TARGET (Ultra, worthy of RTX 5090 at 4K)
Renderer: THREE.WebGPURenderer. Physically based pipeline.
Lighting:
- Rayleigh/Mie physically based sky + starfield + moon + dynamic sun that drives a full day/night cycle.
- Cascaded shadow maps (4 cascades, stable texel snapping, high-res).
- IBL via PMREM updated with time of day.
- Volumetric fog + god rays + heat haze.
Materials:
- MeshPhysicalMaterial / TSL nodes: clearcoat, anisotropy, transmission on glass, metal-flake paint, wet-road shader that reacts to rain.
Post-processing chain (RenderPipeline / TSL or postprocessing library):
GTAO or high-quality SSAO → SSR → bloom (Karis) → motion blur (velocity) → DOF → god rays → auto-exposure → color grading + film grain + vignette → SMAA or TAA.
Effects:
- GPU particle pools: tyre smoke, sparks, dust, rain spray, grass/gravel kick-up, heat distortion.
- Skid marks that persist and fade.
- Dynamic wetness and puddle reflections when raining.

PHYSICS & FEEL
- Fixed-step 120 Hz simulation.
- Raycast or strut suspension, load transfer, combined-slip tyres, ABS/TC, surface types (asphalt, kerb, grass, gravel, wet).
- Camera: cinematic chase + hood + onboard with motion and collision shake.

AUDIO
- Fully synthesised Web Audio: multi-layer engine by RPM/load, wind, tyre screech, kerb rumble, crowd, dynamic music.

QUALITY SYSTEM
- Presets: Low / Medium / High / Ultra.
- Ultra assumes RTX 5090-class GPU: 4K, high shadow maps, max particles, all post effects on, no aggressive LOD.
- Adaptive quality that can drop effects if frame time exceeds target.

Start with a playable first version (one track, one car, basic lighting), then iterate feature-by-feature exactly as requested. Keep everything in a single clean HTML/JS (or Vite) project that runs locally. Comment major systems. Make it look expensive, not cute.

Create a detailed, interactive 3D scene of a modern helicopter in a single HTML file using Three.js and WebGL. Build genuine 3D geometry that can be viewed from every angle, not an image.

Visual style:
A premium aviation design presentation with a light gray studio background, a circular display platform, soft shadows, and realistic reflections.
Helicopter:

A smooth, streamlined fuselage inspired by light twin-engine helicopters such as the H145.
A white body with a dark navy underside and blue accent stripe.
Curved, tinted cockpit windows with reflections and carefully fitted window seals.
Side doors, handles, panel seams, rivets, boarding steps, and antennas.
Two engine housings with air intakes, ventilation grilles, and exhaust outlets.
A five-bladed main rotor with a detailed hub, attachment hardware, and pitch-control linkages.
A tapered tail boom, stabilizers, and a shrouded tail rotor with a genuine opening through its housing.
Curved landing skids attached to the fuselage with structural supports.
Navigation lights and a blinking beacon.
All components must connect physically. Avoid floating parts, gaps between sections, rotor blades intersecting the fuselage, or windows hovering above the body.

Interactions:

Mouse drag to orbit, scroll to zoom, and touch controls.
Start and stop both rotors with gradual acceleration and deceleration.
Adjustable rotor speed.
Hover mode: smoothly lift off the platform, gently sway in the air, and land softly when disabled.
Automatic camera orbit.
Front, side, and tail camera presets.
Reset camera and fullscreen controls.
Three liveries: glacier blue and white, rescue orange, and graphite.
Interface:

Top left: a small “AERONAUT / OBJECT STUDIES” label and a large “Horizon 05.” heading.
Right side: a compact panel with specifications, helicopter status, livery selection, and rotor speed.
Bottom: controls and interaction hints.
Restrained typography, thin borders, and generous whitespace. Keep the helicopter unobstructed.
All interface text in English.
Technical requirements:

Generate the geometry procedurally without downloading a prebuilt helicopter model.
Use PBR materials, a studio reflection environment, and soft shadows.
Make animation independent of frame rate.
Reuse geometry and materials where appropriate, and cap pixel ratio for performance.
Support desktop and mobile layouts, keeping the full rotor span visible in the initial view.
If possible, embed dependencies in the HTML so the file works offline.
Display a helpful fallback message if WebGL is unavailable.
Before finishing, inspect the model from every side, test every control, and check for console errors. Pay particular attention to the silhouette, structural connections, glazing, and rotor mechanisms.

Deliver the working HTML file, not just an explanation.

Create a compelling 3D artwork centered on Tokyo Tower, along with an approximately 30-second video for posting on X.

You are the production director. Create the necessary subtasks and commission the research and production work. Take responsibility for defining the brief, managing progress, reviewing deliverables, requesting revisions, and compiling the final package.

【What to create】
Create Tokyo Tower in a way that conveys its height from a ground-level, upward-looking view and the fine detail of its steel framework from close up.
Provide both daytime and nighttime versions: show the structure and paint during the day, and the beauty of the illumination at night.

The work should make viewers feel that Tokyo Tower has been carefully studied. Research and reproduce distinctive details—not just the tower’s overall shape, but also the way its legs flare outward, the arrangement of its steel framework, the observatories, and the buildings at its base. Keep the surrounding city focused enough to convey the tower’s scale and sense of place.

【Production process】
・Research official references and photographs, then determine which features to reproduce and set their priorities.
・Based on that research, provide specific production instructions for each subtask.
・Review an actual 3D preview early on and adjust the form, composition, and brightness.
・Review the finished images and video yourself, identify anything that feels off or incomplete, and request revisions.
・Make independent decisions about detailed technical choices and shot structure, and carry the project through to completion.

Do not substitute a background made from pasted photographs or generated images. Express the scene using actual 3D geometry and camera movement. Record both verified facts and areas inferred due to insufficient reference material.

【Video】
Approximately 30 seconds. Combine an upward-looking ground-level view, close-ups of the steel framework and observatories, and a wide shot that shows the entire tower. Also show the transition between day and night.
Decide on the exact timing and shot breakdown based on the completed model, choosing the structure that presents it most effectively.

【Deliverables】
・Editable Blender files
・MP4 video for posting on X
・Preview images showing the full scene and details in both day and night settings
・A short draft post
・A README documenting asset sources, the scope of the reproduction, and verification results

Build Bubble Bay, a playable Three.js water-balloon arena with the familiar big-headed, short-bodied, exposed-face costume-character style of classic bubble games. Default to detailed Tripo models with an obvious Three.js geometry comparison switch that preserves the match. Use three new characters: Langya, Shantao and Tuanli. Follow the supplied new character concept/model references, preserving their silhouettes, faces, colors and outfits.

Langya is a lively human boy in a turquoise hood with one connected sideways wave crest, orange collar/cuffs, navy shorts and turquoise shoes with orange soles. Shantao is a small human girl with a dark-plum bob, a peach-pink bonnet with three short petal ornaments on each side, mint jacket, plum short overalls and pale-yellow boots. Tuanli is a chubby human boy with a broad pear-shaped body, a caramel round padded cap with cream face trim, teal short jacket, cream lower belly and navy boots. All show warm skin-colored child faces with simple dark oval eyes and tiny smiles. These are children in newly designed costumes; do not turn them into literal aquatic creatures or reuse the prior recognizable character outfits. Generate each separately through Tripo CLI with explicit tripo-p2 and independent front/back images, then bind valid biped skeletons and skins. Idle/run/jump must drive actual joints; inspect motion, correct headgear/shoe/body weighting and keep provenance accurate. If motions are locally authored, identify them as such.

Localized names: 浪芽 / 랑야 / Langya, 珊桃 / 산타오 / Shantao, 团栗 / 퇀리 / Tuanli. Starting capacity/range/speed levels: 1/1/6, 1/2/5, 2/1/4; caps: 6/7/9, 6/7/8, 9/8/8. Convert speed to 0.25 + level*0.8 world units per second; tiles are 2 units. Choosing a character assigns the other two as distinct rivals with matching profiles. Keep the same gameplay hit radius regardless of the chubby visual silhouette.

Offer 15x13 Pirate/Patrit14 by default and Village10. Preserve recognizable gold deck, yellow cargo, wooden crates, four cannons and central mast; the village has four colored housing districts, a central road, hedges and toy blocks. Use publisher maps as reference, construct runtime artwork yourself, and document small route openings needed for continuous 3D movement and AI escape. Provide bright materials, shadows, ocean scenery, clear camera follow and overview.

One player faces two cooperating AI rivals. WASD/arrows move, F places a 2.5-second bubble, Space jumps onto real platforms, Shift dashes, Q/E orbits, V changes view and Escape pauses. Cross-shaped water respects obstacles, breaks the first soft block and chains bubbles. Implement trapping, escape, enemy captures, respawns, a selectable target of 3, 6, 9 or 12 captures (default 6), or 180-second scoring, result and retry. Touch joystick and action buttons must work simultaneously.

Use six generated Tripo pickups: balloon, range potion, roller skate, throwing glove, kick boot and rescue needle. Crates drop an item 85% of the time. Conditional item weights: 30/30/30/2.5/3.5/4 percent. Gloves add three throws, capped at six. G throws a nearby bubble up to four tiles over cover, preserving its owner and original fuse, reserving its landing and showing an arc. A bubble expiring in flight lands and explodes. K slides bubbles until blocked without resetting the fuse. X uses a rescue needle, starting at one and capped at three. Show inventory and available controls clearly.

Chinese, English and Korean UI: mainland-China IANA timezones select Chinese, Korea/North Korea select Korean, all others including Hong Kong/Macao/Taiwan select English. Manual choice always wins. Upload only embedded-texture, standard uncompressed, genuinely skinned GLB up to 40 MB and 150k triangles. Validate bones, joints and weights, reject static models, use embedded animations where present, and provide basic joint motion for recognized humanoids without clips. Unrecognized skeletons need animations. Explain rigging versus animation plainly, provide a 90-degree orientation adjustment, process locally in-browser, and assign stable balanced stats by file hash.

Use exactly https://studio.tripo3d.ai/?utm_source=satellite_invite&utm_medium=bubble-bay&utm_campaign=create-character for the creation CTA. Credit jared linking to https://x.com/jaredliu_bravo .

Integrate 13 ElevenLabs sound effects with normalization, short decay, distance/pan, polyphony limits, volume and mute: place, burst, crate, pickup, rare, throw, land, trap, rescue, jump, victory, defeat, kick. Create two original instrumental tracks with ElevenLabs music_v2_5, 90 seconds each, matching the nautical pirate map and sunny neighborhood. Normalize them to a restrained -20 LUFS target and crossfade loop boundaries. Give music its own volume control, change tracks by map, fade on pause and honor master mute. Do not reproduce the original game soundtrack.

Keep independent source, dependencies, tests and asset provenance outside the CMS platform apps. Bundle same-origin static resources and MIT notices. Verify actual desktop and touch gameplay, upload variants, languages and visual switching in Ego Lite. Create an immutable review version attached to existing CMS Web Page 12; preserve the existing live release while review is pending. Publish only with truthful source and asset-rights clearance, then verify the public URL, model hashes and behavior. Preserve history and distinguish saved CMS records, previews and public releases.

Load model assets with visible progress, at most three concurrent downloads, a 30-second idle timeout and two attempts. Preserve successful downloads on retry. Hide the entire Tripo / Three.js tab switch until all models are ready, then reveal it. Do not label procedural loading placeholders as loaded Tripo models.


Use a close perspective follow camera that starts outside the spawn facing the arena center. Preserve Q/E orbit, mouse drag pitch and V overview. Keep a compact scoreboard at the top, the mode switch at the upper left, and brief notices near the bottom. Hide joystick and large touch actions on mouse desktops, retaining small rare-item controls; support compact simultaneous touch actions on narrow screens. Add an animated wave shader with teal depth variation, organic sandy islets with curved palms and rocks, subtle wood grain and grass textures. Enclose each trapped character in a size-aware translucent bubble with an iridescent Fresnel rim, gentle float, small bubbles and ground ripples. Verify posed skin vertices fit, reset lift on rescue, and check resource disposal after repeated switching. Avoid expensive scene-wide transmission passes for the water membrane; cap narrow-screen pixel ratio at 1.5.


Provide visible Follow / Overview camera controls and V switching. In Overview, support zoom from 100 to 300 percent using +/− buttons, the mouse wheel and two-finger pinch, with bounded map dragging and Fit map reset. Preserve zoom and the live match when switching camera or rendering versions. Keep compact, non-overlapping rare-item controls in Chinese, English and Korean.

Create a tower defense game like Sir, We Have Orc Problems.

Hello. Please design the best possible 3D model using Blender of a two-story suburban house, interior and everything included.

build a 3D kart racer in a single HTML file.

Create a 3d animation that runs completely in browser. The animation features a medieval castle, sitting on top of a hill that is located on large forest. Do not add any keyboard controls, just make the camera spin around the castle so that we see it from all sides. On top of the castle tower there should be a flag that waves in the wind.

The output should contain index.html file that when executed shows the castle and starts the looping animation.

This is a comparison experiment. Implement and complete the following web app with the exact same specifications in your working directory. Name it “Orbit Lab.” Use Three.js 0.186.0 and load the core library and OrbitControls at the same version (either via a CDN import map or npm is fine). There is no need to publish or deploy it.

Requirements:
1. Represent 3D models of the Sun, Earth, and Moon using procedural geometry and materials. Do not use external images or 3D assets. Use the Sun as a point light so that the lighting on Earth and the Moon is visible as the camera moves.
2. Animate Earth’s orbit and rotation, its axial tilt, and the Moon’s orbit using delta time. Visualize the tilt of the orbital plane and display orbit lines for Earth and the Moon. The scale and speed may be exaggerated for educational purposes.
3. Generate a reproducible starfield background using a seeded random number generator. Use OrbitControls for rotation and zoom. Clicking a celestial body must change its selected state and the information panel.
4. Include play/pause, a speed slider, an orbit-line visibility toggle, camera focus controls for the Sun, Earth, and Moon, and a button to restore the initial state. Play/pause and reset must also work from the keyboard.
5. Make the interface usable on smartphone-width screens, provide a message for browsers without WebGL support, handle resizing, and cap the pixel ratio to avoid excessive rendering load.
6. Add startup instructions and controls to the README. If possible, launch the app and verify that it works; if not, clearly state why. In the completion report, briefly list the files created, implemented features, and verification results.

Do not ask questions during the process. Make reasonable decisions and implement everything through to completion.

Create an interactive 3D medieval European-style castle that can be operated in a browser. Include a moat, drawbridge, towers, stone walls, flags, a forest, and day/night switching.
This is a benchmark, so prioritize the visual quality of the 3D model and push the appearance as far as possible.

Create a web app with an interactive 3D chessboard for studying the main chess gambits. Include move animations, controls to move forward and back, variations, and explanations of the ideas behind each opening.

create a visually interesting shader that can run in twigl-dot-app make it like an infinite city of solarpunk roads and towers with a visible breeze running continuously

build a first-person burger simulator.

Do not reference any other file or previous work. This task must be fully original and not built as a cheat from any other work here.

Create a single html file of a live campfire in the desert. It is night time and the stars are visible. there are log stumps set up as seats around the fire. no people are in the shot. different wildlife may periodically come into view and out.

noises should also match the scene and be of high quality.
Make everything hyper realistic

name the file (based on model)

make yourself, codex in threejs using voxels, make everything from scratch, dont use any skills

Create a beautiful, interactive 3D gummy citrus slice using WebGPU. Deliver the complete experience in one standalone HTML file with embedded JavaScript and WGSL shaders.

This must be a real-time 3D simulation, not a video, image, or looping animation.

APPEARANCE

Create a thick, semicircular orange slice with translucent, juicy flesh, eight distinct segments, delicate internal membranes, tiny bubbles, a pale pith layer, and a soft orange rind.

Make it look like premium gummy candy: saturated color, glossy highlights, light passing through the flesh, convincing refraction, and soft contact shadows. Avoid excessive bloom, washed-out colors, or a hard plastic appearance.

Use a warm, light studio background and a clean editorial interface with generous whitespace. Add the large italic serif title “Citrus Jelly.” Keep controls compact and the slice clearly visible.

SOFT-BODY PHYSICS

The jelly feel is the most important part.

- Grab any part of the slice with a mouse or finger.
- Pull, lift, stretch, twist, and release it.
- Make deformation local: pulling one edge should stretch nearby flesh while the rest follows naturally.
- After release, the slice should wobble, overshoot, and gradually recover its original shape.
- Include gravity, inertia, damping, ground collisions, and soft bouncing.
- Preserve volume approximately and prevent the mesh from collapsing or turning inside out.
- Make the rind slightly firmer than the flesh.
- Internal segments, membranes, and bubbles must follow the deformation without floating outside the body.

Use a stable volumetric soft-body solver, such as a tetrahedral mesh with XPBD constraints. Do not imitate softness by scaling or rotating the entire object.

CONTROLS

Include three color presets: Orange, Lemon, and Ruby.

Add:
- Firmness slider.
- Internal damping slider.
- “Give it a nudge” button.
- Reset button.
- Quarter-speed checkbox.
- Show mesh checkbox.
- Pause/resume button.

Display small live readouts for mass, percentage of rest volume, and kinetic energy.

TECHNICAL REQUIREMENTS

Use genuine WebGPU rendering with WGSL shaders. Generate all geometry and visual details procedurally, without imported models or image files.

Keep simulation updates independent of rendering frame rate. Support desktop and touch devices. Show a clear fallback message if WebGPU is unavailable.

Test strong dragging, repeated releases, all controls, and narrow screens. Fix unstable physics, broken geometry, and visual artifacts before delivering the finished HTML.

The result should feel like a tiny, tactile candy experiment that is genuinely satisfying to play with.

Create “Northbound” - a beautiful, interactive 3D journey through a Nordic fjord aboard a detailed Viking longship.

Build a genuine real-time scene using Three.js and WebGL, delivered as a single standalone HTML file. This must be an explorable browser experience, not a pre-rendered video or a flat illustration.

VISUAL DIRECTION

Aim for a polished, cinematic environment with realistic materials, natural proportions, and restrained colors. Avoid a cartoon or low-poly appearance.

A wooden longship travels through deep green-blue water between towering cliffs, dense forests, waterfalls, and small Nordic settlements. Use atmospheric perspective, subtle mist, soft shadows, and convincing depth. Compose beautiful views throughout the journey, not just from the initial camera position.

THE LONGSHIP

Construct a detailed, watertight hull with overlapping wooden planks, visible grain, ribs, benches, and a continuous interior.
Add a carved dragon prow, striped cloth sail, mast, ropes, shields, supplies, and warm lanterns.
Include proportionate Viking passengers and rowers with layered clothing, believable seated poses, and hands positioned near their oars.
Keep every component physically connected. No floating passengers, intersecting accessories, or visible gaps through the hull.
Animate subtle buoyancy, pitch, and roll. The sail should respond gently to the wind.

WATER AND ROWING

Make the water a central visual feature.

Use a custom shader with planar reflections, refraction, Fresnel highlights, depth-dependent absorption, visible shallow areas, and layered surface ripples. Reflections must respond correctly to the moving camera and changing lighting.

Create a believable wake behind the ship.

Animate a complete rowing cycle: blades enter the water, pull backward, lift out, and return above the surface. Coordinate this with the rowers’ movement.

Generate ripples, foam, and small droplets at the actual blade-water contact points. Trails must remain in world space and gradually dissipate. Avoid effects appearing while the blades are in the air.

ENVIRONMENT AND MATERIALS

Use detailed terrain, irregular rock formations, natural tree silhouettes, branching trunks, and individual leaf or needle clusters.

Use PBR materials with normal and roughness maps for wood, stone, and ground. You may embed appropriately licensed textures; include attribution where required.

Ensure the underwater terrain continues beneath the surface. No bright seams, shoreline gaps, floating vegetation, or trees obstructing the navigable route.

CONTROLS

A/D or arrow keys: steer left and right.
W/S: adjust speed.
Mouse drag: look around.
Provide follow, orbit, and cinematic camera modes.
Include an optional automatic journey mode.
Add pause, reset, fullscreen, and hide-interface controls.
Support touch steering and speed controls on mobile.
Prevent the ship from passing through land and rocks.

ATMOSPHERE AND INTERFACE

Provide three smoothly transitioning lighting presets: Morning, Overcast, and Moonlight.

Add optional ambient water, wind, birds, and rowing sounds. Audio must begin only after user interaction.

Design a minimal editorial interface: “Northbound.” in an elegant serif typeface, subtle chapter labels, and a compact translucent control bar. Keep the scenery unobstructed.

PERFORMANCE AND DELIVERY

Use instancing, sensible geometry budgets, distance-based detail, and appropriately sized reflection targets. Adapt rendering quality to the device instead of promising a fixed frame rate.

Deliver one HTML file with scripts and required assets embedded so it can open directly in a modern browser.

Test steering, camera modes, lighting transitions, and rowing. Inspect the ship from multiple angles and check the shoreline from low viewpoints. Fix geometry intersections, reflection artifacts, excessive glare, and console errors before considering the scene finished.

Prioritize convincing water, a beautifully constructed longship, and a cohesive environment over adding more objects.

I want you to create me a misty, rainy, autumn-like mysterious atmosphere, nostalgic experience in an explorable Three.js in a single html/css/js file.

Build a browser experience in Three.js called STILLWATER.  Tone: a moonlit swamp you get lost in. Not a game with enemies. Not photoreal Unreal. A quiet, expensive-looking web world where the water reflections are the feature. People should stare at the water for an unhealthy amount of time.  SETTING - Location title: THE DEEP SWAMP - Time on the HUD: 19:26 - First named place: Heron bend - Tagline under the place name: "Leave a little room for the wild." - Discovery toast when you arrive: "Discovered: Heron bend"  WORLD A flooded cypress swamp at moonrise / late dusk. - Tall knobby-kneed trees standing in black-green water - Spanish moss hanging in long strands - Lily pads clustered along the banks - Narrow winding channel that opens into a wider bend - Thick volumetric fog, teal-green distance, purple-pink cloudy sky - A bright moon with a long broken reflection path on the water - A few birds crossing the sky - Warm cabin light from the boat punching through the gloom  WATER (do not cheap out) This is the hero. - Real-time reflections of trees, moon, fog and boat lights - Gentle swell, not ocean waves - Lily pads that sit on the surface and bob - Shoreline foam / dark tannin water near roots - Screen-space or planar reflections good enough that the moon path feels cinematic - Keep 60fps. LOD the trees, instanced foliage.  BOAT A small weathered cabin skiff / workboat. - Hull number 86 on the stern - White cabin, dark blue hull, warm interior lamps - Idle drift through the channel, optional slow guided tour - HUD speed around 15.9 KNOTS - Mode label: GUIDED DRIFT Player can look around. Boat can be followed from a cinematic chase / side orbit.  CAMERA - Start on a three-quarter of the boat in the trees - Drift behind the stern down the moonlit lane - Occasional side slide past a foreground trunk - Drag to look - Optional PHOTO MODE Feel like a nature documentary, not an FPS.  UI — editorial, not gamey Top-left: small mark + STILLWATER Top-center: THE DEEP SWAMP / 19:26, a compass heading (e.g. 314°) Top-right: quiet utility icons Bottom-left:   EXPLORING STILLWATER   Heron bend   Leave a little room for the wild.   15.9 KNOTS    GUIDED DRIFT Bottom-right: PHOTO MODE, fps, Pause Center-bottom: small toast "Discovered: Heron bend" Tiny hint row: shaders / water / drag to look / photos / wildlife  Look: dark filmic grade, muted greens, magenta clouds, one moon highlight. Taste over realism. No bloated debug GUI.  TECH Three.js in the browser. Procedural / instanced nature. Custom water shader. Fog. Soft shadows or baked-looking dusk lighting. No asset-store swamp pack if you can author it.  DO NOT add combat, inventory, jump scares, or a treasure hunt. Something can lurk underwater later — not now.

THE TASK
Build a golden-hour Roman battlefield set piece in Blender from the supplied concept image.  Generation is allowed. You may generate 3D models for the environment and its parts with the available generation tools (Tripo on https://t.co/JV0K8OtuWC) and assemble them. Everything must still form one coherent scene: matched scale, consistent materials, and unified lighting.  Requirements: Use bump maps on the ground and keep the ground highly detailed.
Create a circular empty spot on the ground with large boulders around it to form a 1v1 arena.
Render everything realistically.
Create assets procedurally where possible.
Create a skybox for golden-hour sky.
Use harsh shadows.
Reuse objects (flags, banners, helms, rocks, etc.). Export a GLB for every object and reuse those assets.
Match the supplied image as closely and accurately as possible.
TIMELAPSE REQUIREMENT
While you build, save a viewport screenshot into a numbered timelapse/ folder after every meaningful addition (each new object, modifier pass, material step, and lighting step, in order).  When the work is finished, assemble those frames into a timelapse video at 2 fps (0.5 s per frame) so the full build can be watched from start to finish. Deliver the timelapse video with the main files.
DELIVERABLES
The .blend file, with camera and viewport set so the view exactly matches the original image.
The build timelapse video.

Create an interactive 3D scene called “Pitaya Jelly” — a dragon fruit half made of soft, translucent jelly. Build the entire project in a single HTML file using genuine WebGPU rendering and WGSL shaders. Do not use premade models or image assets.

APPEARANCE

A large dragon fruit half resting cut-side up on a light studio surface.
Rich raspberry-pink skin, a thin pale inner rind, and pearly white flesh.
Approximately 250 tiny black seeds distributed naturally across the flesh.
12–14 fleshy peel petals around the fruit, transitioning from pink bases to green tips.
A glossy, wet surface with light refraction, small internal bubbles, and a soft contact shadow.
The material should look like soft gummy candy, not rigid plastic. Preserve saturated colors without blown-out highlights.

PHYSICS AND INTERACTION

Implement genuine soft-body deformation using a volumetric mesh with elastic connections and volume-preserving constraints, such as XPBD.
Users can grab the flesh with a mouse or finger, stretch it, and release it.
Deformation should concentrate around the grabbed point rather than simply translating the entire object.
After release, the fruit should wobble, jiggle, and gradually recover its original shape.
Make the peel petals individually draggable. They should be softer than the flesh, bending and springing back while remaining attached to the fruit.
Seeds must follow the deforming surface without floating away or sinking into the flesh.
Keep the simulation stable during strong pulls, with floor contact and protection against inverted elements.

VISUAL DESIGN

Use a minimal, light-themed studio interface with an editorial aesthetic: generous whitespace, thin borders, restrained controls, and no unnecessary decoration.

Top left:
“MATERIAL STUDIES / NO. 019”
A large italic serif heading on two lines:
“Pitaya Jelly.”

Below it:
“A little wild.”
“A little sweet.”
“A very soft dragon.”
On the right, add a floating panel titled “THE SPECIMEN” containing:

Density badge: ρ 1.04 g/cm³.
Three presets:
Pearl — white flesh and pink skin.
Ruby — raspberry-colored flesh and pink skin.
Gold — pale flesh and golden skin.
Firmness and Internal damping sliders with visible values.
“Give it a nudge” and “Reset” buttons.

“¼ speed” and “Show mesh” checkboxes.

A “Pause” button.
Also include:
A fullscreen button with an exit option.
A “WEBGPU · LIVE” status indicator.
Live readouts for mass, percentage of rest volume, and kinetic energy.
A short interaction hint: “Pull the flesh. Tug a petal. Let go.”
A collapsible “Inside the experiment” section explaining the implementation accurately.
TECHNICAL REQUIREMENTS
Deliver one self-contained file named pitaya-jelly-webgpu.html.

Use actual WebGPU rendering, not a Canvas 2D imitation.

Build all geometry procedurally.
Use thickness-aware refraction, Fresnel reflections, and soft studio lighting.
Use a fixed simulation timestep for consistent behavior.
Support desktop and touch interaction with a responsive layout.
Avoid expensive geometry reconstruction or shader compilation during dragging.

Show a clear fallback message when WebGPU is unavailable.

Verify dragging, release, shape recovery, presets, reset, pause, fullscreen, and mobile layout.
The main priorities are convincing jelly-like behavior, beautiful materials, and satisfying interaction. The result should feel like a polished, playable material experiment.

Create an outfit for VRChat

Create a guinea pig in Blender

Build a detailed voxel-style Japanese garden in Three.js, with a pagoda, tiny villagers, a flying dragon and interactive details.

Design and create a very creative, elaborate, and detailed voxel art scene of a intricate ship sailing through the ocean inside of a bottle. Include waves and realistic physics, with the whole scene encapsulated inside of the bottle. Make the scene impressive and varied and use colorful voxels, modeled physics, and interesting props / landscapes all encapsulated inside of the bottle. Use WebGL and whatever libraries to get this done but make sure I can paste it all into a single HTML file and open it in Chrome

A forest with a lake in the center. In the middle of the lake, an abandoned house. Around the lake, a flower-filled French village. Paths connecting the important points.

build a Super Heavy booster catch in Blender using only Python. no downloaded models, no textures, no HDRIs, everything generated by code

i want you to create an interactive 3d render of how light travels through a camera lens and gets to the sensor. make the demo use a beautiful mountain scape with waterfalls and beautiful green grass

Create “Melon Jelly” — a polished, interactive 3D watermelon jelly slice that runs directly in the browser using genuine WebGPU and WGSL shaders.
Deliver a single, self-contained HTML file with embedded JavaScript and CSS. This must be an actual interactive 3D simulation, not a static render, video, or 2D imitation.
THE WATERMELON
Create a thick, rounded triangular watermelon wedge with:
Translucent ruby-red jelly flesh.
A pale, slightly translucent layer between the flesh and rind.
A glossy green outer rind with irregular dark-green stripes.

Individually modeled dark seeds embedded in both exposed sides.
Softly rounded corners and an appealing, substantial thickness.
Make it look like an expensive gummy candy photographed in a studio. It should feel juicy, soft, and almost edible. Keep the colors rich without overexposing the highlights.
SOFT-BODY PHYSICS
Use a volumetric soft-body simulation, such as a tetrahedral mesh with XPBD elastic and volume-preservation constraints.
The user must be able to:
Grab the tip, a corner, the flesh, or the rind.
Stretch, bend, lift, and gently twist the slice.

Release it and watch it wobble before gradually settling.
The slice must visibly deform locally, not simply move or scale as one rigid object. Make the rind slightly firmer than the flesh while keeping the whole slice flexible.
Preserve volume reasonably during stretching. Prevent inverted elements, explosive motion, and permanent collapse. Use a fixed simulation timestep and bounded substeps for stability.
After release, the motion should decay naturally — no instant snapping back and no endless oscillation.
Keep seeds attached to the deforming flesh. They must move and rotate with the surface rather than float independently or remain fixed in space.
Include ground contact, gentle friction, and soft bouncing. Avoid visible floor penetration.
RENDERING
Use native WebGPU with WGSL shaders.
Include:
Thickness-dependent light absorption.
Refraction through the jelly.

Fresnel reflections and glossy highlights.
Soft transmitted light through thin edges.
Subtle internal details and a few tiny air bubbles.

Soft contact shadows beneath the slice.
A light, neutral studio background.
The flesh, pale rind, and green skin should have distinct material responses. Avoid making everything look like clear glass or opaque plastic.
Keep the slice large and easy to inspect, with a three-quarter camera angle that reveals the flesh, seeds, and thickness.
INTERFACE
Use a minimal editorial layout with generous whitespace, thin borders, restrained controls, and no decorative UI gradients.
Top left:
“MATERIAL STUDIES / NO. 009”
A large italic serif heading split across two lines: “Melon” and “Jelly.”
Small caption:
“A slice of summer.”
“A little wobble.”
“Too soft to share.”
Top right:
A small status indicator showing “WEBGPU · LIVE” when the renderer is running.

Right-side panel:
“THE SPECIMEN”
Three coordinated watermelon-inspired color presets.
Firmness slider with its current value.
Internal damping slider with its current value.
“Give it a nudge” and “Reset” buttons.
“¼ speed” and “Show mesh” checkboxes.

Pause / Resume button.
Bottom left:
A short hint explaining that the slice can be grabbed and stretched.
Live mass, relative volume, and kinetic-energy readouts derived from the simulation. Clearly describe illustrative units or approximate values where appropriate.
Bottom right:

A collapsible “Inside the experiment” section briefly explaining the physics and rendering.
BEHAVIOR AND PERFORMANCE
Support both mouse and touch input. Use pointer capture so dragging remains reliable when the pointer leaves the object.
Make the layout work on desktop and mobile without controls covering the slice.
Reuse buffers and avoid rebuilding geometry or compiling shaders during dragging. Keep interaction smooth and responsive.
Respect reduced-motion preferences. If WebGPU is unavailable, display a clear explanation instead of silently substituting a fake renderer.
VALIDATION
Test dragging from several locations, strong stretches, repeated releases, ground collisions, all sliders, presets, pause, reset, and slow motion.
Check that the model returns to a stable resting shape, seeds stay attached, the mesh remains intact, and there are no rendering errors.
Prioritize the quality of the jelly response and lighting. The result should be something people want to keep grabbing and playing with.

Create a Genshin-like game and a tool for editing its terrain.

Design one 3D-printable J-hook for a strength test.
The hook hangs from an 8 mm steel bar. An 8 mm pin sits in the bill and we hang weight from that pin. I want the highest breaking load I can get without the bar or the pin slipping out.
Rules:
- One printed part. No screws, inserts, glue, or extra pieces.
- Must clip onto the bar and the pin by hand. No closed rings.
- Pin seats 40 mm apart, center to center.
- PLA. Max 35 g as printed.
- Must fit 80 x 60 x 25 mm.
- The pin should have to lift at least 10 mm to come out. If it can roll out the side, that design is invalid.
Give me:
1. A short explanation of the shape.
2. A complete OpenSCAD file I can compile and export to STL for Bambu Studio.
No STL text. No G-code. OpenSCAD only. If the first idea would slip off, replace it in the same answer.

I want you to create an interactive educational 3d represenation how CRISPR DNA technology works. You can choose what ever technology you want as long as its clear readable and has a dna strand, you can see a full work of gene editing and what each piece is, I should be able to select any relevant part of it and learn something

Build a fullscreen, responsive Three.js boat ride set in a narrow jungle waterway. Use a third-person camera following an empty wooden rowboat with a pointed bow, broad sides, flat stern, visible floorboards and seats, no oars, a dry interior, and a hull slightly submerged in the water. Let users steer with WASD or arrow keys and touch controls. Make the scene nocturnal and mystical: dense, varied, realistic dark-green trees on both banks, subtle wind, a detailed full moon, and broken moonlight reflected across animated water. Use convincing moving waves, distorted reflections of the boat and trees, and a wake that follows the boat’s traveled path and fades naturally no fixed glowing marks or hard circular borders. Add a weather toggle for moonlit night, warm dawn, and overcast rain; in rain mode, show falling drops and small, short-lived impact ripples shaped by the water’s waves. Add optional, subtle water, jungle, and rain ambience. Keep the interface minimal. Verify the visuals, controls, audio, counter, and all three weather modes on desktop and mobile.

Build a detailed sports car that transforms into a humanoid robot, with an x-ray mode and interactive exploded view

Create a local HTML/CSS/JS file using Three.js. Make a highly detailed 3D model of a human eye that looks like a macro photograph of a real eye. Everything must be created from scratch.

Build "Time, Undone." - a single self-contained HTML file (embedded JS and CSS) running a genuine WebGPU + WGSL interactive 3D mechanical watch that takes itself apart as you scroll, while it keeps running. No 3D engine libraries; all geometry is generated in code. This is issue No. 01 of a series about objects everyone has seen from the outside and almost no one has seen from the inside.
THE OBJECT
An original, unbranded, hand-wound mechanical watch in a round 40 mm case, with a classic Swiss-lever movement about 30 mm across.
Layout: centre hours and minutes; small seconds sub-dial at 6 o'clock; crown at 3 o'clock.
Dial: silver-opaline with a fine guilloché sunburst, applied polished indices, dauphine hands, a railroad minute track.
Case: front sapphire crystal and a display caseback, so the movement is visible from behind.
No brand names, logos or real calibre names anywhere. Call it "Calibre 01".
THE MECHANISM (must be internally correct, not decorative)
Beat rate 28,800 vph (4 Hz balance).
Build a real going train with consistent tooth counts:mainspring barrel 96 teeth → centre pinion 12; the centre wheel turns once an hour and carries the minute hand;
centre wheel 80 → third pinion 10;
third wheel 75 → fourth pinion 10; the fourth wheel turns once a minute and carries the small seconds hand;
fourth wheel 84 → escape pinion 7;
escape wheel 20 teeth, turning once every 5 s.

Motion works under the dial: cannon pinion 12 → minute wheel 36; minute pinion 10 → hour wheel 40 (12:1).
Keyless works: crown, stem, crown wheel, ratchet wheel, click with spring.
Escapement: escape wheel, pallet fork with two ruby pallet stones and banking pins, balance wheel with hairspring and impulse roller.
Structure: mainplate, barrel bridge, train bridge, balance cock, ruby jewel bearings, blued screws.
Gears: watch-style cycloidal tooth profiles, spoked wheel crossings, pinions with leaves, arbors and pivots. Centre distances are derived from a common module so every pair meshes visibly correctly when assembled.
Motion, driven from ONE master clock:the balance oscillates as θ(t) = A·sin(2π·4·t), with amplitude A around 270° at full power;
at each beat, the pallet fork flicks between its banking pins and the escape wheel advances half a tooth in a short eased impulse, then locks;
every other wheel steps exactly by its ratio from the escape wheel;
the seconds hand ticks 8 times per second; the minute and hour hands follow the train.
On load, set the hands to the viewer's local time.

Power: a power reserve of about 44 h that drains in real time.Amplitude falls from 290° to 180° as the reserve empties; at 0 the watch stops, the balance settling rather than freezing.
Winding raises the reserve, with visible ratchet and click motion and a soft click sound (Web Audio, muted until the first user interaction).

The mechanism keeps running in every exploded state: wheels spin in mid-air, the balance keeps beating, the seconds hand keeps ticking.
THE EXPLODE (scroll-driven, with stops)
Page scroll maps to a progress value from 0 to 1, split into seven chapters. Each chapter eases into a resting "stop" where scroll briefly settles (a soft snap, never a hard lock). The camera moves smoothly between chapters.
Chapters:
I. The case: front 3/4 view, assembled.
II. The dial: the crystal and bezel lift away; the hands and dial rise.
III. Motion works: the wheels under the dial separate.
IV. The bridges: the watch turns over to show the back; the caseback lifts; the bridges and the balance cock rise, with their screws floating just above their holes.
V. The going train: barrel, centre, third and fourth wheels spread upward along their own axes like a technical drawing.
VI. The escapement: escape wheel, pallet fork and balance separate a little further, and the camera closes in.
VII. The heart: a macro view of the beating balance and hairspring, with the full exploded column behind.
Every part moves along a clear axis, mostly its own arbor axis or straight up from the plate. Parts that belong together stay together. Nothing intersects during the explode, and nothing leaves the frame.
Thin hairline leader lines with small caps labels appear for the main parts at each stop, and fade between stops.
INTERACTION
Scroll (wheel, trackpad, touch swipe) drives the explode.
Dragging on empty space turns the watch within limits; it eases back when released.
Hovering a part outlines it softly with its name.
Clicking a part:the part is highlighted, other parts dim to about 35%, and the camera eases to frame it;
a card opens beside it, joined by a hairline leader. The card shows: name; role in one or two plain sentences; one precise fact (for example: "Escape wheel · 20 teeth · one turn every 5 s"); and one live value (current speed, angle, or beats so far).
Esc, a close button, or clicking empty space returns.

Dragging the crown sideways winds the watch (a tactile ratchet), when the crown is visible.
Pointer capture, mouse and touch. Picking by an object-ID render pass or exact ray tests; no approximate bounding spheres.
RENDERING (real metals, macro-photography feel — not a cartoon)
Physically based materials, with a procedural studio environment (large softboxes, a strip light and a dim warm fill) for reflections.
Finishes:Côtes de Genève stripes on the bridges (anisotropic brushed specular aligned to the stripes);
perlage (circular graining) on the mainplate;
mirror-polished bevels (anglage) catching bright edge highlights;
thin-film heat-blued screws and hands;
ruby jewels that are translucent red with internal sparkle;
rhodium-plated steel parts;
sapphire crystals with faint blue-violet reflections and a slight edge thickness.

Case in the selected gold.
Highlights: controlled bloom on specular highlights only; small star glints on jewels and polished edges that appear as the light or the watch moves. Glamour, not glitter.
Soft contact shadows, gentle ambient occlusion, subtle depth of field that follows the focused part.
Filmic tonemap with no clipped highlights; 4x MSAA or equivalent.
Background: pale porcelain white with a soft vignette, like a seamless photo studio. Not yellow, not cream.
UI (aristocratic, editorial, generous whitespace)
Fonts: "Bodoni Moda" for display and numerals, "Jost" for UI text (Google Fonts, with serif and sans fallbacks). Small caps labels with 0.16em tracking; tabular numerals.
Colours:ink #1B1A17 on the porcelain background;
hairlines 1px at 15% ink;
the accent follows the selected gold.

No gradients on UI elements, no heavy shadows, no emoji.
Top-left:kicker "OBJECTS, OPENED / NO. 01";
large Bodoni heading on two lines, "Time," / "Undone.";
three caption lines in Bodoni italic: "Wound by hand." "Opened by scroll." "Nothing is hidden."

Top-right: status "WEBGPU · LIVE" with a small dot.
Left edge, vertically centred: the chapter index "I. The case", "II. The dial", "III. Motion works", "IV. The bridges", "V. The going train", "VI. The escapement", "VII. The heart".The current chapter is highlighted, with a hairline progress rule; clicking a chapter scrolls to it.

Right panel "THE MOVEMENT":three case presets: White gold, Yellow gold, Rose gold, with small metal swatches;
live readouts: Beat rate "28,800 vph", Power reserve (h, with a thin bar), Amplitude (°), Beats since opened;
buttons "Wind the crown" and "Set to local time";
checkboxes "¼ speed" and "Trace the power". Trace the power makes a slow line of light flow along the energy path: mainspring → barrel → centre → third → fourth → escape wheel → pallet fork → balance, with each part glowing as it passes;
a Pause/Resume button.

Bottom-left hint: "Scroll to take it apart. Click any part to meet it. Drag to turn it."
Bottom-right: a collapsible "How it works", with a short, accurate explanation of the going train, the escapement, the balance and the power reserve, plus a short note on how this page renders it.
Mobile: the canvas fills the top about 65% of the screen, and the chapter index becomes a horizontal row of Roman numerals. The panel flows below; part cards become a bottom sheet. Nothing covers the watch.
ENGINEERING
Build all geometry once at start-up. Instance repeated parts (screws, jewels, teeth where useful). Update only transforms per frame; no shader compilation or buffer rebuilds during interaction.
Animation time comes from one clock with ¼-speed scaling. Pause freezes the mechanism, not the UI.
Respect prefers-reduced-motion: instant chapter transitions, no camera flights, no glints animation.
If WebGPU is unavailable, show a clear, well-designed explanation. No fake fallback renderer.
Handle device loss. Cap the pixel ratio at 2. Aim for 60 fps on a laptop and a smooth experience on a recent phone.
VALIDATE BEFORE DELIVERING
In code, assert the train ratios: the seconds hand turns once per 60 s, the minute hand once per 3600 s, the hour hand once per 12 h, the escape wheel once per 5 s. Log the check to the console.
Every meshing pair is at the correct centre distance and visibly meshed when assembled.
No part intersects another at any explode progress; no z-fighting.
Scroll stops, chapter jumps, part picking, cards, winding, presets, trace-the-power, pause, ¼ speed and the mobile layout all work.
Card texts are horologically accurate.
No console errors.

Using blender mcp. Make me a realistic 3d model of the: Lockheed Martin F-22 Raptor (US only). Then create me 60 second mp4 of it flying around in Godot that I can upload to X.

Build a cinematic, photorealistic, beautifully textured rocket launch scene using Three.js

A Blender render of the Golden Gate Bridge.  A sweeping, extreme low-angle shot from the surface of San Francisco Bay, looking up at the colossal, intricate steel-truss towers piercing the foggy morning sky. The expansive roadway stretches across the span with countless tiny, detailed vehicles, highlighting the bridge's grand, imposing scale against the rugged coastal headlands.

Write a complete, executable Python script using Blender's bpy module to create a 3D Minion character, set up a 360-degree turntable camera animation, and render a 5-second 1:1 video.
Animation & Render Specifications:

Frame Rate & Duration: Set frame rate to 30 fps and render frame range from frame 1 to 150 (exactly 5 seconds).
Aspect Ratio: Set render resolution to 1080x1080 pixels (1:1 square ratio).
Camera Turntable Animation:Animate the camera (or an empty controller object parented to the camera) to perform a seamless 360-degree rotation around the Minion over the 150 frames.
Set keyframe interpolation to LINEAR to ensure smooth, constant-speed rotation.

Output Settings: Set output format to FFmpeg video (H.264 / MP4 container).
Technical Requirements & Model Structure:
Base Body:Create a capsule-like mesh for the main body (yellow material, subsurface scattering/roughness ~0.3).
Add sparse, thin strands of black hair on top of the head.

Goggles & EyesBuild dual-lens goggles using extruded cylinders/toruses.
Goggle Frame Material: Metallic (~0.9), Roughness (~0.2) to simulate brushed aluminum/metal.
Add a black elastic strap wrapping around the body.
Generate two eyeball meshes inside the frame (white sclera, brown iris, shiny pupil).

Clothing - Overalls:Model the denim overalls using separate mesh geometry or extruded body segments.
Material: Blue denim color, higher roughness (~0.6).
Include shoulder straps and a front pocket on the chest.

Appendages & DetailsAdd arms and legs with black gloved hands and black shoes.
Use Mirror Modifier (bpy.ops.object.modifier_add(type='MIRROR')) where applicable (e.g., eyes, goggles frame, arms, straps, legs) to ensure symmetry and clean code.

Lighting & Scene:Place a three-point lighting setup (Key, Fill, Rim lights) parented to the camera or placed uniformly so the lighting stays consistent during rotation.
Set render engine to Cycles or EEVEE with a clean studio background.
Ensure all materials are created using Nodes (use_nodes = True).

Return ONLY valid Python code inside a markdown block with no surrounding text or markdown explanations.

Recreate this scene in Isaac Sim for the purposes of manipulation policy evaluation. Don't use Manifold.

{
  "task": "build the pyramids in 3D. rotate the camera",
  "video": { "duration": "15s", "ratio": "16:9", "layout": "split screen, 1 model per side" },
  "scene": "golden miniature diorama, tilt-shift, dark dusk lighting, smooth carved pyramid, temple, small pyramids, cracked plaza, contour terrain",
  "animation": "pyramid morphs in from base to tip, no workers, no ramps, no blocks",
  "camera": "continuous 150 degree orbit, synced on both sides",
  "overlay": "model name + timer only"
}

Now, I want you to make a 3D game where I'm ducking asteroids, using the arrow keys to move around, and I'm using space to boost.

1. Project goal
Build Battle City 3D, a browser tank-defense game inspired by the 1985 Famicom classic. The player drives a tank, destroys a wave of 20 enemies, collects supplies and protects the eagle headquarters. Reconstruct the current perspective-3D version shown in the reference media, including an endless seeded campaign and 35 selectable classic layouts. Preserve the readable arcade rules while giving tanks, walls and scenery genuine depth.

2. Visual style
Use a Three.js PerspectiveCamera with a 60-degree field of view. The default battlefield view sits behind and above the player, around 13 world units away at elevation 0.43 radians. Smoothly follow position and a point ahead of the tank; never rotate the camera automatically when the tank turns. Offer a higher tactical view, manual drag orbit and wheel zoom. Use the four cardinal map axes for movement and firing. After orbiting, map directional keys to the nearest cardinal direction relative to the camera; never turn keyboard input into diagonal movement. Render the chassis heading immediately to match the shot direction, and calibrate projectile and muzzle-flash height to the actual cannon of each model.
Use grounded tracked tanks, metallic turrets, terracotta bricks, dark steel blocks, blue water, low foliage and reflective ice. Continue the ground beyond the playable area into trees, ruined buildings and haze. Use warm directional light, soft shadows, ambient fill, ACES tone mapping and restrained muzzle flashes, recoil, sparks and bouncing debris. Snow changes the ground and tree palette; industrial stages favor steel and ruined buildings.
Frame the game with a dark olive command interface, warm yellow primary action, score, shared lives, remaining enemy icons, stage name and radar. Put the large Tripo 3D / Three.js model switch above the battlefield, showing the selected mode and a rotating tank preview. Use a localized illustrated supply guide and timed-effect indicators. Keep the playfield and essential touch controls visible on narrow screens.

3. World and scenes
Represent the battlefield as a 26 by 26 tile grid, with a tank collision half-width of 0.72. Place the eagle at (13,25), surrounded by a destructible U-shaped brick defense. Player spawns are (9,25) and (17,25); enemy gates are (1,1), (13,1) and (25,1).
Provide two campaigns: all 35 classic layouts with their 20-enemy wave tables, and an endless seed-based generator cycling grass, snow and industrial biomes. Generate connected corridors wide enough for the full chassis, with passable connections between player spawns, enemy gates and pickup locations. Add staggered central steel cover to prevent a direct spawn-to-eagle firing lane while retaining cross-street access. Allow selecting the starting biome or classic stage and rerolling a random map. Carry the run seed, score, lives and surviving players' upgrades into the next stage.
Brick is destructible; steel blocks ordinary shells and tanks; water blocks tanks but allows shells to pass; foliage conceals enemy models; ice reduces traction. Keep the distant environment decorative, separate from gameplay collision.

4. Asset inventory
Use these stable, independently replaceable 3D model slots. Prioritize the player, enemy, heavy tank and eagle, then all ten supply models. Ground each asset at its lowest point and normalize its facing, center and scale. Reuse templates instead of loading a model per enemy.
- player: a mustard-yellow tracked tank with a readable turret and forward cannon; used by player tanks, with a separate ring color for the second player.
- enemy: a compact tracked enemy tank, reused with distinct tints for basic, fast and powerful variants.
- heavy: a visibly heavier armored tank, separate from the standard enemy mesh, with four visible armor segments above it.
- eagle: a metallic golden eagle statue on the headquarters pedestal.
- pickup-star: a gold five-point upgrade star.
- pickup-helmet: a protective military helmet for temporary shielding.
- pickup-clock: a readable clock for freezing enemy movement.
- pickup-shovel: a shovel for headquarters reinforcement.
- pickup-life: a miniature tank representing one extra life.
- pickup-grenade: a hand grenade for destroying active enemies.
- pickup-ammo: an ammunition box for rapid fire.
- pickup-repair: a repair toolbox for restoring armor.
- pickup-magnet: a horseshoe magnet for ranged pickup collection.
- pickup-boost: an energy battery for a temporary speed boost.
- environment-building: a weathered ruined apartment building, Tripo P2.0, requested budget 1,800 triangles.
- environment-tree: an irregular pine with visible trunk, Tripo P2.0, requested budget 1,100 triangles.
- environment-bush: a low leafy shrub and grass tufts, Tripo P2.0, requested budget 650 triangles.
Display supplies as rotating, hovering collectible models with colored rings and matching guide thumbnails. Render repeated buildings, trees and bushes with shared geometry/material instances. Ground the building and tree roots; bury the shrub base slightly to blend with terrain. Add snow on upward-facing surfaces in snow stages. Keep tile walls, water, ice, projectile meshes, UI, lights, particles and collision proxies procedural. Animate water with world-space flowing waves, changing normals and small surface displacement, continuous across adjacent tiles. The Tripo version uses 17 generated models; the comparison version switches both tanks and environment to code-built geometry with the same rules and collisions. Both are rendered with Three.js.

5. Gameplay and feedback
Support solo and local two-player co-op with a shared pool of three lives. Solo uses WASD or arrow keys and Space/J to fire. In co-op, player one uses WASD and Space/J; player two uses arrows and Enter/Numpad 0. P/Escape pauses; C changes camera; 1/2 selects model mode. On touchscreens, allow holding a directional pad and fire button simultaneously, release input on pointer cancellation, and expose pause, resume, next-stage and retry actions without scrolling.
Player speed is 4.2 units per second, or 6.3 with boost. Enemies include basic, fast, powerful and heavy types; heavy tanks have four hit points and survive the first three unshielded hits. Use four concurrent enemies in solo and six in co-op, with staggered spawning. Killing a type awards 100, 200, 300 or 400 points; collecting any supply gives 500 points. Clear a stage after 20 enemy defeats. Lose when the eagle is destroyed or the shared lives are exhausted with no surviving player. Offer immediate retry, explicit next-stage progression and a locally saved best score.
Implement all ten supplies: star upgrades through three levels (faster shells, two simultaneous shells, then steel-breaking shells); helmet shields for 12 seconds; clock freezes enemies for 9 seconds; shovel reinforces the base for 16 seconds; mini tank adds one life; grenade destroys active enemies; ammunition grants 14 seconds of rapid fire with up to four active shells; repair adds two hit points capped at three; magnet collects visible supplies within five units for 20 seconds; boost lasts 12 seconds. Supply models last 25 seconds and appear at reachable locations, with a shuffled deck to vary types. Magnet collection must respect solid obstacles.
Use collected NES-style samples for the 4.333-second stage opening, firing, driving and idling, brick/steel impacts, enemy/player explosions, supply appearance and collection, extra life, armor hit, ice, pause and game over. The current project uses 15 OGG cues from JustoSenka/BattleCity, commit 3a07004ba8e53baea74ff70d2ecc22b017eb9b20. Preserve their attribution and repository license notice; describe them as collected remake audio, without claiming a bit-perfect hardware capture. Unlock audio on user gesture, calibrate sample gains, provide volume/mute, and synchronize sounds to events. Do not add unrelated continuous battle music.

6. Technical implementation
Use TypeScript, Three.js 0.180.0 and Vite 7, with an isolated package.json and lockfile. Keep the simulation independent of rendering, stepping at 120 Hz. Use solid chassis AABBs, axis-separated motion, boundary and tank separation, and continuous nearest-contact shell sweeps, including relative-motion collision between opposing shells. Shells originate at the chassis and sweep forward to prevent point-blank wall clipping. Add ice acceleration/deceleration and gravity with damped bounces for debris. These are arcade ground physics, not a suspension simulator.
Load same-origin GLB assets through GLTFLoader. Keep collision proxies independent of asset geometry. The current runtime uses quantized attributes and WebP textures (1024 px for vehicles/base; 512 px for supplies and environment), without geometry simplification or a WASM decoder. Limit loading to four workers, use hash-versioned URLs and 256 KiB ranges with a 20-second timeout and up to three attempts per range. Unlock play after the four core models and audio are ready; load supplies and environment assets in the background and only spawn supply types whose models are ready. Switching model mode preserves gameplay state.
Provide English, simplified Chinese, Japanese and Korean UI. Select a default from device language, except zh-TW, zh-HK, zh-MO and zh-Hant default to English; persist explicit language choices. Support keyboard, desktop pointer and multitouch, and pause on focus loss. Keep all assets, credits and reproducible scripts local to the source project, and ship a static dist directory with no private credentials or runtime backend dependency.

7. Completion criteria
Deliver editable source, asset provenance and license notices, an npm development/build workflow and a playable static preview. Verify the default Tripo scene, the model comparison, all biomes, a heavy tank taking four hits, every supply effect, pause/resume, defeat/retry and stage progression. Test 1,000 seeded maps for chassis-width connectivity and safe spawns, plus all classic maps, wall tunneling, diagonal shots, tank separation, ice momentum, camera-relative input at multiple yaws, and state-preserving mode switches. Validate localized UI and narrow-screen two-finger controls without claiming physical-device testing when only emulation was used. Compare actual start and combat frames with the reference images/video; confirm all 17 models and 15 audio cues load. Publish through the existing CMS Web Page workflow and verify the final public page, rather than treating a saved CMS record as a completed deployment.

1. Project goal
Build Crazy Tanks — Wild Tides, a playable, genuinely three-dimensional turn-based artillery game on a tropical island. The player aims a small tank, reads the wind, times a charge from zero, and reshapes the battlefield with shells. Support solo against AI and local pass-and-play, with a default three-tank free-for-all and an optional two-tank duel. The last surviving tank wins. Use the current reference gameplay and screenshots as the visual target.

2. Visual style
Use a perspective camera and freely orbitable 3D geometry, not flat sprites or a fixed side view. Create a sunny, miniature diorama with rounded jade, coral-orange and blue-violet tanks, creamy sand, pale green grass, turquoise reflective water, soft shadows and a light atmospheric distance haze. Preserve the three tanks' distinct silhouettes and matching barrels. Use a compact cream round/armor panel above the battlefield and a dark teal rounded control deck below it. Gold marks the reference power and firing action; mint marks actual charge and friendly status. Keep the Tripo / Three.js appearance switch prominent at the top, defaulting to Tripo assets. Switching appearances must preserve the match and physics state. Use thin, evenly spaced teal screen-space dashes and a restrained landing circle; do not reflect aiming graphics in the water.

3. World and scene
Use a destructible height-field island approximately 260 by 184 metres, surrounded by ocean at a fixed sea level. Place the starting tanks far apart on stable ground; distribute rocks, palms, cacti and collectible supply crates. Smaller decorative islands provide background depth and never substitute for the destructible main terrain. Blasts deform the surface and can dig below sea level. Keep shoreline color and foam in a single water surface to avoid overlapping planes and flicker. Project tank numbers from world positions every rendered frame. Provide full-trajectory, tank, orbit and tactical overhead views. The trajectory view must fit the firing tank, arc and estimated landing into the space between the HUD and control deck. Before each shot, show the firing tank for about 0.8 seconds, linger at the muzzle, then follow the projectile. Manual camera interaction cancels cinematic following.

4. Asset inventory
Use stable model slots and keep replacement models individually addressable:
- jade-body: rounded green shield-like tracked hull; the player's default body. jade-cannon: matching jade barrel with a dark bore and gold accents, articulated independently.
- ember-body: coral-orange pointed armored hull with a low mechanical profile. ember-cannon: its longer matching orange barrel and dark muzzle.
- bolt-body: blue-violet industrial tracked hull with angular plated armor. bolt-cannon: matching thick blue barrel.
- shell: a brass artillery projectile with a dark tapered tip and cyan accent. Reuse it with weapon-specific tint and scale.
- crate: a yellow armored supply box with cyan marking and reinforced corners; collect it for 20 armor, capped at 100.
- rock: warm rounded sandstone cluster; repeat at varied scale and use a separate collision proxy.
- palm: curved trunk and layered green fronds; repeat as island vegetation.
- cactus: compact green cactus with small flowering details; repeat on dry terrain.
- islet: a rounded grassy background island with pale rock/sand edges; repeat beyond the arena.
Prioritize the three matching body/barrel pairs, followed by shell/crate and environmental props. Keep terrain deformation, ocean, foam, fire, smoke, shockwaves, debris, aim graphics, lighting, UI and collision proxies procedural. Matching body and barrel parts share one design reference and scale. Place the barrel pivot at its mechanical joint, align its forward axis to +X, and use the visible muzzle as the physical launch point. Tank bodies conform to slopes using quaternions; turret aim remains a world-space direction. Preserve source PBR textures and UV seams. Keep full-resolution downloadable models separate from optimized game runtime copies; references and file provenance must identify the actual generation source.

5. Gameplay and feedback
Each living tank receives 18 metres of movement when its turn starts. WASD and the movement pad move relative to the screen; arrow keys and the aiming pad adjust bearing and elevation. Sliders provide bearing, 10–80 degree elevation and 0–100 reference power. Selecting a rival only faces it; it must not solve the shot.
The teal arc estimates the chosen reference power with NO wind. Keep that reference and its gold marker fixed while charging. Hold Fire, Space, or Enter on the focused Fire button to start actual power at 0 every time; increase by 18 percentage points per second, hold at 100, and fire exactly once on release using the actual power at that instant. A quick tap fires a weak shot. The gold band within 3 percentage points is visual feedback only, with no snapping or hidden correction. Cancel on pointer cancellation, window blur or loss of visibility. Lock movement, target and aim changes during a charge. Range-input keyboard controls must not also turn the turret. Zero power represents the lowest launch speed, not a stationary shell.
The arrow and visible drifting wind streaks show where wind pushes the shell. Label wind strength and metres per second; clicking the wind card explains it. Wind blowing left means the player should aim somewhat right. Stronger wind and longer airtime cause greater drift. Wind stays constant during a shot and changes each turn. Never compensate the player preview automatically. Predict terrain landing approximately; do not promise tank/rock collisions, cluster splitting or ricochets in the preview.
Provide six payloads: unlimited HE; a cluster round that splits into five descending submunitions; Seismic with a crater up to 28 metres across and 13 deep; a ricochet round that bounces twice; one Cataclysm round per tank with a crater up to 46 metres across and 22 deep; and Incendiary that leaves a 12-metre-radius fire zone. Fire deals 8 damage at each of six action endings; moving outside avoids damage and overlapping zones do not stack. Seawater extinguishes flames. An entire tank, including its raised barrel, fully below the water is eliminated immediately. Show the real damage, armor loss, terrain collapse, water splash and elimination outcome.
Use layered fireballs, expanding shock rings, emissive sparks, ballistic fragments, dust and smoke with restrained camera shake. Use the provided original ElevenLabs music and cannon, impact, ricochet, heavy blast, fire and splash sounds. Include sound toggle, pause/resume, instructions, replay and return to menu. During projectile flight or AI turns, offer Back to my turn: run the same fixed-step simulation quickly and preserve all damage, terrain and hazard outcomes. Never skip a local friend's input turn.

6. Technical implementation
Use Three.js with ES modules and Vite, local bundled fonts, Web Audio for effects and an HTML audio element for looping music. Keep resources on the same origin and support a static build. Use a perspective renderer with antialiasing, practical shadow and postprocessing budgets, and proper disposal of transient geometry/materials. Distinguish model decoration from gameplay collision.
Keep deterministic physics independent of rendering, with metre/second units, gravity 9.81 m/s² and a 1/120-second fixed step. Use continuous swept collisions for high-speed projectiles against ground, water, tanks and rocks; apply blast impulses and gravity to displaced tanks. Derive launch positions from the actual tank-specific barrel transform. Normal playback and fast-forward must call the same simulation updates. Damage and wind response are stylized game rules, not an engineering blast simulator.
Support Chinese, English, Japanese and Korean UI. Choose from device language initially; Hong Kong, Macau, Taiwan and Traditional Chinese devices default to English. Remember explicit choices and allow a visible language selector. Use responsive desktop, portrait phone and short landscape layouts, scrollable short-screen menus, comfortable touch targets, collapsible panels and no overlapping controls. Do not require keyboard input on touch devices. Keep development-only state mutation and aiming helpers out of production.

7. Completion criteria
Deliver an editable standalone source project, lockfile, npm dev/build instructions and a working static preview. Match the current screenshots and gameplay video, including the cream status panel, gold fixed reference marker, zero-start live charge and fully 3D tank/island presentation. Verify first launch, model loading, a complete turn cycle, each payload's behavior, pause, replay and a real win/loss outcome. Confirm appearance switching preserves state and keyboard/touch cancellation does not fire. At a clear no-wind test shot, releasing at reference power should land close to the reference circle; opposite crosswinds must visibly shift the actual shell while leaving that circle unchanged. Check 30/60/144 Hz behavior, high-speed collision, deep craters, fire expiry, complete submersion elimination and equality of normal/fast-forward turn outcomes. Inspect desktop and narrow layouts in all four languages; identify browser emulation separately from physical-device testing. Validate the hosted page and linked media, not only the local build.

# ODD ARMS — Your idea. Your hero.

## 1. Goal
Keep all game UI in English (add Japanese as an optional language switch).
Build a complete three-minute browser survival game in the "auto-attack horde" genre: the player picks a toy-sized hero and two wonderfully weird weapons, then survives 180 seconds of monster swarms on a craftsman's workbench. Weapons attack automatically; the player only moves, dashes, collects crystals, picks upgrades and fires a charged nova. The hook is personal: players can create their own hero or weapon in Tripo, download the GLB and drop it into the game. Use https://odd-arms.tripo.page/ and the supplied references for the finished result. Credit Deniffer at https://x.com/lumina__team.

## 2. Visual direction
Frame the game as a miniature toy diorama seen from a fixed three-quarter top-down camera that follows the hero. The playfield is a deep navy cutting mat with a faint grid and printed "ODD ARMS" corner marks, laid on a warm wooden desk. The desk rim is crowded with oversized craft props (thread spools, ornate brass-rosette boxes, a leather tool roll, a brass desk lamp, a wooden toy train, toy parts) so the arena reads as a real tabletop. Use warm key light from the lamp side, soft ambient fill, contact shadows and gentle bloom; characters are glossy, chunky, collectible-figure style with saturated colours.

UI: cream-white rounded cards with navy text and a coral-orange accent, a heavy condensed display font for headlines ("LET'S MAKE SOME TROUBLE.") and a clean condensed sans for body. In battle: health card top-left, streak counter under it, "SURVIVE THE WEIRD" countdown top-centre, wave label + sound + settings + Pause top-right, defeated count right, level/XP pill bottom-centre, three weapon chips (orbit / returning / shooter with levels) bottom-left, controls + dash cooldown bottom-right, "Q NOVA READY!" pill above it. Juice: damage numbers, crits, squash-and-stretch enemies, knockback, pop particles, light camera shake (disable shake when prefers-reduced-motion is set).

## 3. World
One square arena, clamp the hero to ±23 units on both axes. The cutting mat fills the play area; the desk and props sit outside the clamp as scenery only (no collision). The arena starts empty and fills from the edges: enemies spawn on a ring 12–16 units from the hero (8–11 in the first second) and walk straight at the hero. Every 22 seconds a surge spawns a full circle of enemies at radius 13. Red warning circles appear under the hero's current position (first at 28 s, then every max(4.4, 9 − t/50) s) and explode after 2 s.

## 4. Asset inventory
Prepare stable model slots; every slot must load a single GLB, be centred, auto-scaled to a target height, and fall back to a simple placeholder if loading fails.

Heroes (10, `hero:<id>`), each a chunky toy figure with a distinct silhouette:
- `cat` Astro Cat — orange tabby in a white space suit and glass helmet. HP 100, speed 6.8, magnet ×1.35, dash cooldown 2.4 s.
- `frog` Frog Fighter — green frog in red boxing gloves. HP 130, speed 6.8, dash damage 135.
- `shroom` Mushroom Hero — red-cap mushroom with a small cape. HP 90, speed 7.6, dash 1.8 s.
- `capybara` Chill Capybara — relaxed hot-spring capybara. HP 160, speed 5.8, magnet ×1.15, dash 3 s, dash damage 110.
- `ramen` Ramen Ronin — samurai carrying a steaming ramen bowl. HP 105, speed 7.2, dash 2.2 s, dash damage 120.
- `penguin` Office Penguin — penguin in a shirt and tie. HP 80, speed 7.1, dash 1.5 s, dash damage 75.
- `axolotl` Axolotl — pink axolotl explorer. HP 85, speed 7.3, magnet ×1.6, dash damage 75.
- `avocado` Avo Boxer — avocado boxer with a seed core. HP 120, speed 6.4, dash 2.1 s, dash damage 130.
- `robot` Clockwork Bot — wind-up tin robot with a key. HP 115, speed 6.2, dash 2.8 s, dash damage 165.
- `snail` Snail Knight — knightly snail carrying its house-sized shell. HP 190, speed 5.2, magnet ×1.2, dash 3.2 s, dash damage 120.
Default dash damage is 90 when not listed.

Weapons (12, `weapon:<id>`), grouped by attack slot:
- Orbit: `sardine` Sardine Chainsaw (3 fish, radius 2.9, dmg 1, speed 1.2); `cactus` Cactus Club (2 clubs, radius 3.3, dmg 1.65, speed 0.78, hit radius 1.25, knockback 1.5); `plunger` Plunger Patrol (4 plungers, radius 2.25, dmg 0.85, speed 1.5).
- Returning: `banana` Banana Blades (2, dmg 1, speed 1.25); `pizza` Pizza Cutter (1 large disc, dmg 1.5, speed 0.82, hit radius 1.65); `croissant` Croissant Blades (3, dmg 0.75, speed 1.45); `boomerang` Boomerang (1, dmg 1.15, speed 1.6); `donut-disc` Donut Disc (1, dmg 1.5, speed 0.9, hit radius 1.3).
- Shooter: `duck` Duck Rocket (homing, splash 2, interval 0.42 s); `toaster` Angry Toaster (3-shot piercing fan, dmg 0.7); `teapot` Raging Teapot (2 slow shots, splash 2.8, interval 0.8 s); `bubble-gun` Bubble Gun (2 piercing bubbles, dmg 0.45, interval 0.3 s).
Default loadout: Astro Cat, Banana Blades, Angry Toaster; orbit weapon is unlocked at the first upgrade.

Enemies (3, `enemy:<id>`), wind-up toy monsters: `red-chomper` (red round biting toy, basic, 30 HP base, speed 2.35), `spring-rabbit` (yellow spring-legged rabbit, fast, 23 HP base, speed 3.5), `crown-bear` (large patchwork bear with a crown, tank, 130 HP base, speed 1.7, appears after 60 s at 17%, drops 3 XP).

Scene props (`prop:<id>`): workbench desk, cutting mat frame and corner plates, desk lamp, toy train, thread spools, ornate rosette boxes, tool roll, toy parts tray. Keep the mat, grid, crystals, projectiles, warning circles, particles, lights and UI procedural.

## 5. Gameplay and feedback
Flow: Character → Loadout (one returning + one shooter) → Ready (3D turntable preview of hero with chosen weapons, drag to rotate) → "Let's play". Each onboarding step shows only that category with description, playstyle and weakness text. Remember the last loadout.

Controls: WASD/arrows to move; Space dashes in the move direction (speed ×3.7, brief invulnerability, damages enemies within 2 units once per dash); Q fires a nova when energy is 100 (radius 11, 200 damage, strong knockback, pulls in crystals); 1/2/3 or click to choose upgrades; Esc to pause; auto-pause on window blur. Mobile: left virtual joystick (analog), right Dash and Nova buttons with cooldown/charge rings, multi-touch so the joystick and buttons work together; upgrades sit above the joystick in portrait and between thumbs in landscape.

Rules: enemy HP = base × (1 + t/260) × 1.3. Spawn interval max(0.18, 0.52 − 0.0016·t) s, cap 180 enemies. Contact damage 9 (18 from the bear) with 0.85 s invulnerability after a hit. Every kill adds 2 energy and drops a crystal; every 9th hit per weapon crits ×1.7. 25-kill streak triggers a 5 s frenzy (attack speed ×1.65, 13 s cooldown); taking damage resets the streak. XP to level: 20, then round(need × 1.4 + 10). Level-ups never pause the game: they queue as non-blocking choice cards. The first upgrade offers the three orbit weapons; afterwards offer three of: Orbit overload (+1 orbiter up to 7, +22% damage), Another round (faster, longer, stronger returns), Full blast (faster fire, +20% damage, more projectiles), Live a little (+10% speed, +30 HP). Every choice heals 8 HP.

End: survive 180 s → "Beautifully weird. You made it."; HP 0 → "That was a glorious mess." Both show enemies defeated, best streak and time survived, with Run it back / Change loadout and the create-your-own prompt.

Make it yours: from the loadout, pause and result screens, "Create my hero / weapon in Tripo" opens https://studio.tripo3d.ai/ in a new tab; "Import GLB" loads a local .glb (≤15 MB, embedded textures only, parsed in-browser, never uploaded), centres and scales it, and swaps only the look of the selected hero or weapon while keeping its stats. Show clear errors for invalid files and keep the original model.

Compare models: a header toggle "Tripo3D ⇄ Simple3D (Blender)" swaps every hero, weapon, enemy and prop to a matching simple-primitive set without resetting the run. Load the whole alternate set before swapping; if any file fails, keep the current set.

## 6. Technical implementation
Vite + vanilla JavaScript + Three.js with GLTFLoader, RoomEnvironment lighting and ACES tone mapping. Keep the simulation in a pure, fixed-timestep module with an injectable random source so full runs can be simulated in tests; the renderer only reads state. Cache each GLB once and clone for instances; use instancing or LODs for repeated ornaments. Cap pixel ratio (1.5 on mobile, drop to 1 during dense waves), refresh shadows at most 30 times per second and update HUD text only when values change. Separate collision (simple circles) from visual meshes. Bundle fonts, models and textures same-origin so the build is a static folder. Target desktop and phone browsers, 320 px wide and up, including landscape phones and safe areas. Model complexity should follow on-screen size; no hard polygon limit.

## 7. Done when
- The full flow works: onboarding, battle to win and to loss, pause/resume, restart with the same loadout, change loadout.
- All 10 heroes and 12 weapons load and behave per the numbers above; a 180 s run with any loadout finishes without errors.
- Keyboard and touch controls both work, including joystick plus Dash at the same time.
- GLB import replaces the chosen hero or weapon look and rejects bad files gracefully.
- Tripo3D / Simple3D toggle swaps all models mid-run.
- Opening, mid-battle and result screens match the references; provide runnable source, the start command and a static production build.

1. Project goal
Create TITANIC — THE LAST LIGHT: an interactive, 264-second cinematic voyage from the ship’s final sunset through collision, evacuation and sinking to a dawn memorial. Visitors watch a directed film, explore its moving 3D world, jump to a chapter, save a still or download the complete movie. Present it as an artistic interpretation, without claiming forensic accuracy or official affiliation.

2. Visual direction
Use a restrained cinematic palette: warm cream and amber ship lights against deep Atlantic blue, followed by a dark star-lit night and cool dawn. Render a perspective scene with a 2.39:1 movie composition, soft bloom, subtle grain and vignette. Use depth of field for character portraits and dawn, while keeping distress-rocket particles sharp. Give the ocean a deep-blue body colour, world-space swells, smaller mipmapped ripple normals and Fresnel reflections; warm sunset colour belongs mainly in reflected light. Use hull-attached wake ribbons following the same ocean displacement, with soft ends and broken foam. Wrap panorama textures horizontally without a fract discontinuity to prevent vertical sky seams and reflected streaks. Avoid orange shallow-water shading, tiny uniform ripples and glowing circular foam decals. Remove hidden overlapping roof top faces to prevent depth fighting; use a camera near plane appropriate to the shot distance. During sinking, dim window light monotonically rather than adding high-frequency flicker. Use a quiet serif title, bilingual English/Chinese controls and a narrow timeline along the bottom.

3. World, geography and camera edit
Use one continuous coordinate system with a 269-metre vessel, bow facing +X, and an iceberg fixed at (275, 0, 57). The vessel advances, contacts the iceberg at 96.727 seconds, coasts to a stop, then sinks in fore and aft sections. Keep the iceberg present through the ending and visible in the dawn composition. Retain six chapters beginning at 0, 63, 110, 163, 211 and 241 seconds.

Build 23 deliberate shots. The bow embrace spans 29–61 seconds: an establishing approach, a close double portrait, a view from behind toward the sea and an oblique portrait. Place Rose in front and Jack behind her at the forward tip, both facing out over the bow. Maintain sunset lighting through the sequence. From 127–158 seconds, use three shots attached to a lifeboat’s actual world transform: departure from the boat deck, a closer view of passengers and suspension ropes, and approach to the water. Follow with wide evacuation, listing, fracture and sinking shots. At dawn show the surviving boats with the iceberg in the distance, then a restrained memorial title.

4. Asset inventory
- titanic-vessel: build the 269-metre primary structure in Blender with continuous well decks, a closed forecastle, layered promenades, four hollow raked buff funnels, black upper hull and red lower hull. Use real circular rims for 864 portholes and frames for 360 windows. Restrict emission to actual glazing materials. Batch materials and split at x=-32 for sinking. Add masts, rigging, davits, falls, bronze propellers and rudder. Generate a P2 companionway with teak doors and brass details, normalize it and reuse it twice on the authored deck. Preserve node transforms when assembling the GLB.
- atlantic-iceberg: one irregular, eroded blue-white iceberg, with layered frost, roughness variation, a subdued normal map and a convincing waterline. It remains a fixed geographical object.
- lifeboat: one White Star rowing lifeboat with a white wooden shell, dark gunwale, benches and oars, instanced across sixteen independently moving boats.
- bow-embrace: an isolated double-character asset inspired by the requested 1997 film costumes and pose: Rose with auburn hair, navy/ivory clothing and a patterned shawl, arms extended; Jack immediately behind in a dark coat and ivory shirt. Generate clean full-figure reference images before conversion to H v3.1, keeping each figure’s head, neck, shoulders and clothing coherent. Refine Rose with a separate close-up reference and H facial-detail donor: register eyes, nose, lips and chin, transfer local shape and colour to the continuous full-figure mesh, and blend and retouch the UV transition. For Jack, generate a clean portrait with natural skin colour and defined eyes and lips. Keep its complete head and upper neck, fit gaze and scale to the H body, conform the lower neck and weld both boundary loops. Bake and retouch the narrow neck transition without flattening facial detail. Correct stance and hand contact in Blender. Inspect front, side and rear views for dark smears, texture seams, holes, cut edges and garment intersections. Give skin and cloth separate shading. Preserve natural base expressions with restrained body and cloth movement; do not imply a facial animation rig unless one is actually implemented.
- seated-woman and seated-man: separate adult passenger models in 1912 clothing and pale cork life jackets, seated with bent knees and hands on their laps. Share geometry and materials across boats; vary placement and orientation slightly. Use reversible per-boat instance counts for boarding.

Use Blender for the primary vessel, Tripo P2.0 for the deck companionway, iceberg, boats and seated passengers, and H v3.1 for the two complete hero figures and close-up portrait refinements. Keep the ocean, sky blend, stars, lighting, smoke, distress rockets, foam, spray and debris as scene effects. Supply lighter web model variants with compressed textures and retain detailed source assets for editing. Use the same approved optimized hero pair for the website and offline film export.

5. Playback and feedback
Show real loading progress for essential ship, boat, sky and sea-normal assets. Enable the opening button when the first scene is ready; defer the other models and music. If a required character or iceberg model is late, hold at its scene boundary and resume when it is ready rather than silently skipping its shot. Audio begins after user interaction.

The timeline must support forward/backward seeking and rapid drags without resetting to zero. Preserve play/pause and mute state while seeking; do not let the old audio clock overwrite the requested position. Serve byte ranges for MP3 and MP4. Chapter navigation includes direct entries for the bow embrace at 29 seconds and lifeboat lowering at 127 seconds; these restore the director’s camera while preserving playback state.

Exploration allows orbit, drag and zoom while the world, vessel and soundtrack continue. Follow vessel translation without snapping the viewing direction. Pause remains independent; returning to the film preserves current time. Space plays/pauses, arrows jump ten seconds, M toggles sound, E toggles exploration and F opens fullscreen. Support touch orbit/pinch and timeline tapping.

Boats start empty. Passengers board in staggered groups after 112 seconds and finish before each boat descends. Ropes run between moving davits and the actual boat attachment points, then disappear after release. Backward seeking restores earlier occupancy and rope states. Collision must coordinate hull/camera vibration, ice chips, scraping spray and a steel/ice sound transient. Distress rockets use white burning stars, short individual trails, gravity, drag and fading smoke. Sinking disturbances are irregular, wave-following patches that decay gradually; distribute spray along the stern’s true waterline, never from a remote point fountain.

6. Technical implementation and deliverables
Use Vite, JavaScript modules and Three.js with deterministic time-based animation. Separate camera/timeline, vessel assets, characters, environment, effects and scene readiness. Share the same time model for web playback, seeking and offline capture. Keep web rendering within an explicit pixel, reflection and shadow budget; defer heavier ambient occlusion to the offline profile. Compile and decode assets without a long blocking startup prewarm. Host scripts, models, images, fonts and audio on the same origin and keep secrets out of the static build.

Use an original score and paid ElevenLabs Foley: a complete natural whistling firework take split at its actual airburst into an ascending flight and a sharp bang with crackling tail, steel/ice contact and scrape, lifeboat ropes and water contact, hull strain/fracture, and stern water displacement. Export source WAV files, retain prompts/history IDs, and edit them into timed cues. Align launches at 119, 151 and 183 seconds, with the airbursts 3.15 seconds later. Retain the original burst attack and briefly duck the orchestral score. Keep quiet sea, wind and engine ambience beneath the mix. The reference film soundtrack is not included without authorization for both the public website and downloadable film. Document actual asset and sound sources rather than describing a fallback as a service-generated asset.

Provide a deterministic export of 6,336 frames at 3840×2160 and 24 fps with three temporal samples, burned-in English titles and a 2.39:1 letterboxed image. Encode a 4K H.264/AAC master and a 1080p web edition below 100 MiB, both 264 seconds with 48 kHz stereo audio. Preserve optional Chinese/English subtitles, the audio master and editable source. Publish the static build through the existing CMS Web Pages hosting, without adding a platform application or a per-page Worker.

7. Acceptance
Inspect the opening, both character portraits, collision, distress rockets, all three lowering shots, fracture, stern disappearance and dawn. Check that the iceberg does not vanish at 244 seconds, the sea reads as deep blue, the sinking has no regular white rings, characters remain present in their authored shots, and boat ropes/passengers stay aligned throughout lowering. Test delayed model loading, forward/backward seeking, quick scrubbing, pause/mute, dynamic exploration, direct close-up entries and touch emulation. Verify every exported frame, fully decode both films, compare the actual browser download with the delivered file, and verify the public build and CMS association. Distinguish browser mobile emulation from testing on a physical phone.

# AKARI — Nagoya Light Atlas

## 1. Goal
Build a complete Japanese-first browser game in which an abstract flame makes seven timed jumps, lighting a miniature Nagoya before the Aichi–Nagoya Asian Games, 19 September–4 October 2026. Match the current two-map opening edition at https://akari-nagoya-rooftop-relay.tripo.page/ and the supplied visual references. The earlier generic rooftop scene is not the target.

## 2. Visual direction
Use an elevated three-quarter atlas view, midnight navy background, warm ivory Japanese serif headlines, fine gold lines and restrained grain. On desktop, reserve the left third for the opening invitation and frame two raised map tiles on the right; on phones, reframe the map above the controls. Begin with dim, desaturated buildings and teal waterways. Success restores greens, turquoise copper roofs, warm windows and gold route lights. Keep the flame and next target readable. Use soft shadows, atmospheric depth and controlled bloom; avoid white glare. Match the Japanese opening headline, landmark labels and slim editorial header/footer visible in the reference.

## 3. World
The larger northwest tile covers Meijo Park, Nagoya Castle, Aichi International Arena, Hisaya-odori Park, MIRAI TOWER and Oasis 21. The southeast tile covers the City Museum, Mizuho-dori, Mizuho Park and its athletic stadium, with Yamazaki River east of the stadium. Add low modern neighbourhoods, park trees, road markings, riverbanks and warm light fixtures; reserve castle architecture for the castle.

Chapter 1: Meijo Park → Sotobori/Hisaya-odori → Hisaya-odori Park → Oasis 21, three jumps. Make a clearly signposted, non-playable chapter transfer to the City Museum. Chapter 2: City Museum → Mizuho-dori → Mizuho Undojo Nishi → toward Mizuho Park → South Plaza, four jumps. Never draw the transfer as a continuous street or count it as a jump. Save progress at the second chapter. The maps use different scales with distances compressed for play. Explain this briefly in About, alongside the historical relay dates, 22 August and 16 September 2026; they are not upcoming event invitations. Cite https://www.aichi-nagoya2026.org/ja/torch-relay/ and https://www.nagoyajo.city.nagoya.jp/guide/kinshachi/. Use original ornaments and an abstract flame rather than an official mascot or emblem.

## 4. Asset inventory
Use these stable replacement slots in priority order; retain the same layout and collision proxies in both visual modes:
- `shachi`: antique polished-gold roof ornament with a tiger-like head, curved scaled carp body and upward curling tail; repeat on the castle.
- `castle`: ivory Nagoya-inspired keep, dark timber, stepped turquoise hip-and-gable roofs and stone foundation.
- `mizuho`: broad oval athletic stadium, pale open-centre roof and rhythmic supports; keep the running track and green field visible through the centre.
- `arena`: low contemporary arena with a broad roof and warm vertical facade fins, north of the park axis.
- `tower`: slender silver lattice observation tower with a box-like deck and antenna.
- `oasis`: elongated oval turquoise glass/water canopy on slim pale supports.
- `midrise`: restrained modern Japanese neighbourhood building; reuse with varied height and orientation, including simple museum massing.
- `tree`: compact mature park tree with a brown trunk and layered green crown; instance throughout both tiles.
Keep terrain, roads, water, track markings, jump markers, abstract flame, light trails, fireworks and UI procedural. Each model must be a complete isolated object; preserve open passages and the stadium centre. Track every listed slot, including repeated background assets.

## 5. Gameplay and reward
Hold pointer/touch or Space to charge; release to jump automatically toward the next marker. Use deterministic delta-time physics: distance = 1.8 + 7 × charge, charge reflects between 0 and 1, and the arc adds 4 × t × (1 − t) × 3.6 to interpolated height. The charge cycle speeds up from about 1.42 to 0.92 seconds per direction. Derive the trajectory, green safe zone and gold perfect zone from the same calculation: error ≤0.36 is perfect; ≤1.15 is safe, with 0.28 extra forgiveness for the first two jumps.

A safe landing gives 100 points; perfect gives 200 × consecutive multiplier, capped at ×4. A prompt follow-up within 2.35 seconds adds 50; reset combo after a safe landing, chapter transfer or 3.4 seconds of waiting. Each success sends a light wave through the district, illuminates windows and adds lanterns. Show seven-step progress, score, combo and best. Misses restart quickly; after the transfer restore the chapter checkpoint. Provide pause, restart, hidden-tab recovery and optional sound after interaction.

After the final jump, reveal both illuminated maps with a 4.6-second pullback and bounded fireworks. Show rank S for seven perfect landings, A for four or more, otherwise B. Include replay, same-camera before/after city views and a real 1800×1200 PNG poster with title, dates, score and independent-project credit.

## 6. Implementation
Use Vite, TypeScript and Three.js; separate geography, pure physics/scoring, scene, effects, model registry, Japanese/English localization and UI. Japanese remains the default regardless of prompt language; persist the language switch. Bundle fonts and assets locally. Use GLTFLoader and per-slot normalization; keep the last working model after an invalid import. Preserve score, checkpoint, camera and lighting when comparing simple and imported visuals. Instance trees/buildings, merge compatible static geometry, cap DPR and bound particles. Evaluate actual frame time and model complexity instead of rejecting a model just for exceeding a triangle target. Use Blender only if a returned asset needs mesh cleanup, pivot repair or an open stadium centre; preserve its original file.

## 7. Acceptance
Deliver runnable source, lockfile, development/build commands and a static build. Verify seven jumps across both chapters, transfer/checkpoint recovery, miss/retry, scoring, touch input, pause, Japanese/English persistence, all slot fallbacks and actual poster export. Compare settled opening and finale screenshots against the current two-map reference. Report measured performance and tests actually performed. The following shared workflow governs model generation and return.

# ODYSSEY — The Cyclops’ Island

## 1. Goal
Build a complete isometric escape game inspired by Book IX of the Odyssey. As Odysseus, lead three crew members to steal cave supplies, survive Polyphemus pursuing and striking you, and escape aboard a Greek ship. All game UI is English. Use https://cyclops-island.tripo.page/ and the supplied references; retain Jared’s attribution and the inspiration from Jason Chew’s Odyssey island concept.

## 2. Visual direction
Compose a richly textured Mediterranean tabletop island, about 25 world units across, in a deep teal Aegean sea. Use an orthographic three-quarter camera near (19,31,34), warm limestone, sage olive trees, terracotta cloth, bronze armour and cream parchment. Apply ACES tone mapping, warm directional shadows, atmospheric depth, restrained bloom, vignette and grain. Keep danger markers readable beneath the effects.

Use local Cormorant Garamond-style serif titles and DM Sans-style UI. Top left: an Ω seal, ODYSSEY / AN INTERACTIVE MYTH, BOOK IX and The Cyclops’ Island. A prominent cream comparison card at upper right says “One island. Two worlds.” with Tripo World and Original controls. Bottom left: mission stage, three hearts, stamina and crew count. Show boss state above, a small compass/minimap below, visible camera controls and concise input hints. On phones, compact decorative copy and separate mission, boss, comparison and Dodge controls.

## 3. World
A winding pale-sand path leads north from a southern landing beach through olive groves to a limestone cave. The giant sleeps near the cave; Odysseus and crew begin on the southern path. Put a red-sailed wooden ship southwest by the jetty. Surround the coast with irregular boulders, grass, cypresses and turquoise shallows. Animate sea ripples, shoreline foam, trees, firelight, birds and ship bobbing. Ocean motion must remain correct when the camera rotates.

## 4. Asset inventory
Prepare replacement slots in this order:
- `odysseus`: bearded Greek adventurer, bronze Corinthian helmet with crimson crest, weathered chest armour, ivory tunic, terracotta cape, sandals, small shield and sheathed sword. Reuse for three crew with independent skeletons and animation phases.
- `polyphemus`: burly giant with exactly one central eye, tan olive skin, curly dark hair/beard, fur/leather loincloth, thick bare feet and a wooden club; full body in a neutral riggable pose.
- `ship`: narrow dark-walnut hull, raised prow, bronze ram, mast, terracotta-red sail, rope rigging and side oars; no water or display base.
- `olive`: gnarled gray-brown trunk, spreading roots and irregular sage canopy; reuse about 25 times.
- `cave`: broad freestanding weathered limestone arch with a genuinely open passage, chunky rocks and sparse moss; build the dark interior separately.
- `cypress`: slender tapered Mediterranean tree with dense dark-green foliage.
- `boulder`: irregular warm limestone coastal rock; reuse with varied scale and rotation.
Keep terrain, path, water, grass, supply markers, combat telegraphs, particles and UI procedural. Track each slot and preserve the gameplay map while replacing its appearance.

## 5. Escape encounter
Use camera-relative WASD/arrows and click/tap-to-move with radius-aware A* navigation. Crew follow loosely; player and giant respect terrain, boundaries and obstacles at their different sizes. Shift sprints, Space or the large touch button dodges, E takes nearby supplies, P pauses, Q/R rotate and F follows the hero. Support drag/pan, right-drag/rotate, scroll/zoom and touch pinch. During pursuit, click-to-move sprints while stamina permits.

Stage 1: approach the cave; proximity and noisy sprinting raise suspicion and may wake the giant. Stage 2: collect supplies only at close range, always waking him. Stage 3: survive inside the marked jetty radius of about 2.7 units near (-0.8,8.7) for 11 accumulated seconds while crew board; leaving pauses progress.

Give three health and 100 stamina. Starting speeds: walk 2.35, sprint 4.15 and giant run 3.4 units/second. The giant must chase into 3.6-unit range before attacking. Use sleeping, waking, chasing, windup, impact, recovery and terminal states. Ground Breaker locks the player’s position at the start of a 1.12-second windup, shows a radius-2.45 circle and strikes once; the target must not follow the player. Every third slam releases a clearly marked charged expanding shockwave; damage follows the moving ring edge.

Dodge lasts about 0.34 seconds, costs 24 stamina and has a 1.25-second cooldown, brief invulnerability and valid-ground clamping. Sprint drains stamina; rest restores it. Hits cause knockback, hurt feedback and temporary immunity. Defeat resets all actors, timers, effects and mission state. Escape stops damage and opens a replay summary. Pause freezes simulation, animation and effects. Tune boarding to require several dodges, including a charged attack.

## 6. Implementation and animation
Use Vite, Three.js and JavaScript ES modules for world, navigation, encounter, actors, effects, audio and UI. Bundle all runtime assets locally in a static build. Initial articulated models must walk/run, sleep/wake, dodge and visibly wind up/strike. For skinned replacements use AnimationMixer, actual clip names, short crossfades and SkeletonUtils.clone for separate crew skeletons. Prevent doubled root motion and foot sliding. Synchronize the giant’s downward strike with gameplay impact; static imports must not be reported as animated. Keep a working articulated fallback when necessary. Use Blender only for required rig, pivot, clip or mesh repairs.

Synchronize orange/gold telegraphs, impact flash, ground cracks, dust, sparks, falling rock fragments, expanding rings, brief light and camera shake. Add dodge trails and optional gesture-activated synthesized audio. Pool effects, instance scenery and measure frame time. Normalize imports with grounded feet/roots and unchanged collision proxies. Compare preserves positions, mission, health, stamina, camera and animation state; failed imports retain working models. Include a discreet Change hero control and local model import with per-slot status.

## 7. Acceptance
Deliver source, lockfile, npm development/build commands and static output. Verify obstacle navigation, early wake, close-range collection, pursuit before attack, locked targets, timed strikes, dodge immunity, shockwave-edge damage, defeat/reset and a successful escape. Check independent crew animation, all slot fallbacks, state-preserving comparison, desktop/mobile layout and loading errors. Compare settled screenshots to the reference and report actual performance. Use the shared workflow below for model generation and return.