Qwen3.8-Flash-Nextをメイカーフェアで見たので試す

env:
  CUDA_VISIBLE_DEVICES=0,1
  GGML_CUDA_GRAPH_OPT=1
  LLAMA_ARG_CHAT_TEMPLATE_KWARGS={"reasoning_effort":"medium"}

llama-server
  -m Qwen3.8-Flash-Next-UD-Q4_K_XL-00001-of-00004.gguf
  --mmproj mmproj-F16.gguf --no-mmproj-offload
  -fit off -ngl 99 -ts 30,18 --lazy-mode off --load-mode mlock
  -ot "blk\.([0-9]|1[0-9])\.ffn_.*_exps\.=CPU,per_layer_token_embd\.weight=CPU"
  -fa on -t 8 -c 131072 -ctk q8_0 -ctv q8_0 -np 1
  --jinja --reasoning on --reasoning-preserve
  --temp 1.0 --top-p 0.95 --top-k 20 --min-p 0.0 --presence-penalty 0.0 --repeat-penalty 1.0

# One-shot prompt — procedural 3D browser game

---

You are a senior graphics engineer and technical artist. Build a complete, polished, playable 3D browser game as **a small set of ES modules** rooted at `game.html`. Do not ask questions, do not stop to explain, do not leave anything unfinished.

### Hard constraints

1. **No build step.** No npm, no bundler, no transpiler, no framework. The only thing needed to play is a static file server, because ES modules cannot be imported over `file://`:
   ```
   python3 -m http.server 8000    # then open http://localhost:8000/game.html
   ```
   Put that command in a two-line `README.md` next to `game.html`. Everything else must work from a cold `git clone` with no install.
2. **Three.js only.** Load it as an ES module through an import map in `game.html`, so every module can `import * as THREE from 'three'`:
   ```html
   <script type="importmap">
   { "imports": {
       "three": "https://unpkg.com/three@0.168.0/build/three.module.js",
       "three/addons/": "https://unpkg.com/three@0.168.0/examples/jsm/"
   }}
   </script>
   ```
   No other libraries. No CSS files — the small HUD stylesheet lives in a `<style>` block in `game.html`.
3. **Zero external assets.** No `.glb`/`.gltf`/`.obj`/`.fbx`, no image files, no audio files, no icon fonts. *Every* visual and audible element must be generated in code at runtime:
   - **Geometry:** primitives plus hand-built `BufferGeometry` (vertices/normals/UVs/vertex-colors written by JS), merged and instanced.
   - **Textures:** `CanvasTexture` / `DataTexture` painted procedurally, plus custom GLSL in `ShaderMaterial` and `onBeforeCompile` patches.
   - **Audio:** WebAudio API only — oscillators, noise buffers, filters, envelopes. Engine hum, pickup chime, boost whoosh, crash thud.
   - **Randomness:** a seeded PRNG (mulberry32/xorshift) so the world is reproducible from a seed constant.
4. **No placeholders.** No `TODO`, no stub functions, no "implement later", no commented-out fallbacks. Ship the whole game.
5. **Performance:** target a locked 60 fps at 1080p on integrated graphics. Use `InstancedMesh` for repeated props, pool particles, pre-allocate vectors, and allocate nothing inside the render loop. Cap `renderer.setPixelRatio(Math.min(devicePixelRatio, 2))`. Keep the shadow map at 1024 with a tight frustum. Dispose geometry/materials for chunks you recycle.
6. **Robustness:** clamp delta time, handle window resize, pause on `visibilitychange`, and never throw in the animation loop. The game must survive 10 minutes of continuous play without leaks or slowdown.

### File layout — build these files, in this order

Every file is a standalone ES module with a small, explicit export surface. **Hard cap: 250 lines per file.** If a module is heading past that, split it rather than letting it grow — a file that has to be re-read in full to change one thing is a failure of this layout.

```
game.html                     shell only: import map, <canvas>, HUD markup, <style>, <script type="module" src="./src/main.js">
README.md                     the two-line run command
src/
  config.js                   CONFIG: speed curve, spawn density, bloom, palette, seed, camera springs. Every tunable, no magic numbers elsewhere.
  rng.js                      mulberry32 + randRange/randInt/pick/shuffle, all taking an explicit rng
  noise.js                    value or simplex noise + fBm, written from scratch, seeded from rng.js
  audio.js                    AudioEngine class: init on first gesture, engineHum/chime/whoosh/thud, master gain, mute
  input.js                    keyboard + mouse steering, normalized axes {steer, lift, boost}, pause/restart edges
  procedural/geometry.js      BufferGeometry factories: hovercraft, crystal spire, pylon, ring gate, orb, debris
  procedural/textures.js      CanvasTexture/DataTexture painters: terrain detail, gate emissive, star sprite, grain
  procedural/materials.js     shared ShaderMaterials + the onBeforeCompile rim-light patch
  world/terrain.js            heightfield chunk geometry from fBm, valley carving, sampleHeight(x,z) used by physics
  world/props.js              instanced spires/pylons/gates/orbs/debris, seeded placement, per-chunk add/remove
  world/streaming.js          chunk pool: spawn ahead, recycle behind, dispose. Owns terrain.js + props.js.
  world/sky.js                gradient skydome, twinkling Points starfield, FogExp2 wiring
  player/craft.js             craft transform, hover physics, banking, boost/shield state
  player/trail.js             ribbon BufferGeometry strip with fading gradient
  player/collision.js         terrain and prop collision queries, returns typed hit events
  fx/particles.js             pooled additive Points bursts, speed lines, scanline pulse
  fx/post.js                  EffectComposer, UnrealBloomPass, custom vignette/aberration/grain ShaderPass, boost+impact response
  fx/camera.js                spring-damped chase camera, speed FOV, banking roll, shake, hit-stop
  ui/hud.js                   shield/boost bars, rolling score counter, combo, floating score popups
  ui/screens.js               title / paused / game-over cards
  game.js                     state machine (Title→Playing→Paused→GameOver), scoring, wiring modules together
  main.js                     bootstrap: renderer, scene, module construction, resize, the single rAF loop
```

Rules for the split:

- **Dependencies flow one way**, roughly down the list above. No circular imports. If two modules need to talk, `game.js` mediates.
- **No globals.** `CONFIG` is imported, not attached to `window`. Modules export classes or factory functions and are constructed in `main.js`.
- Each file starts with a 2–4 line header comment: what it owns and what it exports.
- Shared math helpers (clamp, lerp, damp, easing) go in `src/util.js` — not copy-pasted.

### Build in milestones, and report after each

Write the files milestone by milestone, and after each milestone print one line saying what now works. Do not write all 20 files silently and then declare victory.

- **M1 — it moves:** `game.html`, `config.js`, `util.js`, `rng.js`, `noise.js`, `world/terrain.js`, `world/streaming.js`, `player/craft.js`, `fx/camera.js`, `main.js`. A craft flies over endless streaming terrain with a chase camera. Untextured is fine here.
- **M2 — it's a game:** `input.js`, `world/props.js`, `player/collision.js`, `ui/hud.js`, `ui/screens.js`, `game.js`. Gates, orbs, shields, score, pause, game over, restart.
- **M3 — it's beautiful:** `world/sky.js`, `procedural/*`, `fx/post.js`, `fx/particles.js`, `player/trail.js`. Bloom, fog, palette, emissive neon, particles, trail.
- **M4 — it sounds right:** `audio.js`, wired into `game.js`.

The game must be runnable at the end of every milestone — never leave it in a broken intermediate state.

### The game — "NEON DRIFT"

An endless hover-racer skimming through a procedurally generated neon canyon at night.

- **World:** an infinite corridor built from streaming terrain chunks. Generate the canyon heightfield with your own fBm value/simplex noise (implement the noise yourself), carving a navigable valley down the middle whose width and curvature vary with distance. Recycle chunks ahead/behind the player — never grow the scene graph unbounded.
- **Props:** instanced crystal spires along the canyon walls, glowing boundary pylons, floating ring gates, and drifting debris. All from procedural geometry, varied by seeded noise in scale/rotation/hue.
- **Player craft:** a low-poly hovercraft assembled in code from beveled primitives, with an emissive underglow, banking animation, and a ribbon trail (a dynamically updated `BufferGeometry` strip with a fading gradient).
- **Loop:** fly forward, speed ramps up over time. Pass through ring gates for points and a combo multiplier; collect energy orbs to refill the boost meter; clipping a wall or a spire costs shield. Three shields, then game over. Score = distance × combo + gate bonuses.
- **Controls:** `A`/`D` or `←`/`→` to steer, `W`/`S` to raise/lower altitude, `Shift` or `Space` to boost, `P` to pause, `R` to restart. Also support mouse steering. Show the controls on the title screen.
- **States:** Title → Playing → Paused → Game Over → restart, all handled cleanly by one state machine in `game.js`.

### Visual direction — this must look genuinely impressive

Treat this as a showcase piece. A functional but flat-looking result is a failure.

- **Rendering setup:** `ACESFilmicToneMapping` with exposure ~1.1, `SRGBColorSpace` output, `antialias: true`.
- **Post-processing:** `EffectComposer` + `RenderPass` + `UnrealBloomPass` (strength ~0.8, radius 0.5, threshold 0.85), plus a custom `ShaderPass` doing vignette + subtle chromatic aberration + a faint film grain. Push bloom and aberration up briefly on boost and impact.
- **Sky:** a procedural gradient skydome via `ShaderMaterial` (deep indigo → magenta horizon), a `Points` starfield with per-star twinkle in the shader, and `FogExp2` whose color matches the horizon so geometry dissolves into the sky instead of popping.
- **Lighting:** cool `HemisphereLight` for ambient fill, one warm key `DirectionalLight` with soft shadows (PCFSoft), and emissive materials doing the heavy lifting for the neon look. Add a rim-light term via `onBeforeCompile` so silhouettes glow against the fog.
- **Color:** a tight, deliberate palette — cyan/magenta/violet accents on near-black terrain, with vertex-color gradients driven by height and distance. No default gray materials, no pure `0xffffff` surfaces.
- **Motion & juice:** spring-damped chase camera; FOV widening from 65° to 85° with speed; camera roll on banking; screen shake and a 60 ms hit-stop on impact; radial speed-lines and a scanline pulse during boost; additive `Points` particle bursts for gate passes and pickups; floating score popups; everything eased, nothing linear.
- **UI:** a minimal HTML/CSS overlay in a monospace font — thin glowing bars for shield and boost, score with a rolling counter, combo multiplier that scales and fades. Title and game-over cards with backdrop blur and a soft neon border. Restrained, layout-stable, no text jitter.

### Code quality

- A single `CONFIG` object in `config.js` holding every tunable (speed curve, spawn density, bloom, palette, seed) so the feel can be tuned in one place.
- Short comments explaining the non-obvious parts: noise setup, chunk recycling, the shader patches.
- Consistent naming across modules; no dead exports.

### Build priority (if you must cut scope, cut from the bottom)

1. It runs and is playable end to end, with no console errors.
2. Procedural terrain streaming + collision + scoring + game-over/restart.
3. Post-processing, sky, fog, lighting, palette.
4. Particles, trails, camera juice, HUD polish.
5. Audio.

### Definition of done — verify each before you finish

- [ ] Every relative import (`from './...'`, `from '../...'`) resolves to a file that actually exists on disk. Check this mechanically — grep every import specifier out of every source file and confirm each resolved path exists — before trusting anything else below. A single unresolved import breaks the entire module graph silently in the browser (no exception is thrown), so this check comes first.
- [ ] `python3 -m http.server` + `http://localhost:8000/game.html` plays with no console errors or warnings. Verify this by actually loading `game.html` itself through its real `<script type="module">` entry point and the real import map — in a real or headless browser — not by hand-assembling a Node.js test harness that imports individual modules with stubbed globals or mocked dependencies. A test that stubs out the module you're trying to verify proves nothing about it.
- [ ] If you verify headlessly via the Chrome DevTools Protocol, enable the `Log` and `Network` domains in addition to `Console` and `Runtime`. Broken module imports (404s, CORS failures) surface only through `Log.entryAdded` / `Network.responseReceived`, not through `Console.messageAdded` (obsolete, never fires on modern Chrome) or `Runtime.exceptionThrown` (fetch/resolution failures aren't thrown exceptions).
- [ ] No external asset file is referenced anywhere.
- [ ] No source file exceeds 250 lines; no circular imports.
- [ ] The world is endless and memory-stable; frame rate holds after minutes of play.
- [ ] Collisions, shields, scoring, pause, and restart all work.
- [ ] Bloom, fog, sky, shadows, particles, and trails are all visibly present.
- [ ] Nothing in any file is a stub.

Write the files, then finish with a short summary of the module map and anything worth tuning first.