From 3570fe8425b6ff3e75d185ae4f3343a5f8d58eba Mon Sep 17 00:00:00 2001 From: tfrere Date: Fri, 21 Aug 2026 16:59:30 +0200 Subject: [PATCH] feat: Vite+React+MUI+R3F app shell in app/ (framework-agnostic game core, zustand bridge) Co-authored-by: Cursor --- Dockerfile | 15 + app/.gitignore | 2 + app/index.html | 21 + app/package-lock.json | 2052 +++++++++++++++++++++++++++ app/package.json | 25 + app/public/assets | 1 + app/public/policies | 1 + app/public/robot | 1 + app/src/App.jsx | 87 ++ app/src/game/arena.js | 235 +++ app/src/game/ball-actor.js | 102 ++ app/src/game/ball-visual.js | 149 ++ app/src/game/ceremony.js | 236 +++ app/src/game/constants.js | 74 + app/src/game/controls/controller.js | 188 +++ app/src/game/controls/gamepad.js | 153 ++ app/src/game/controls/keyboard.js | 116 ++ app/src/game/controls/touch.js | 180 +++ app/src/game/duck.js | 339 +++++ app/src/game/fx/demo-glitch.html | 140 ++ app/src/game/fx/demo-wireframe.html | 113 ++ app/src/game/fx/fx-glitch.js | 311 ++++ app/src/game/fx/fx-wireframe.js | 323 +++++ app/src/game/game.js | 1305 +++++++++++++++++ app/src/game/ghosts.js | 288 ++++ app/src/game/signed.js | 13 + app/src/game/stickers.js | 222 +++ app/src/game/variants.js | 319 +++++ app/src/main.jsx | 14 + app/src/scene/GameCanvas.jsx | 59 + app/src/store.js | 80 ++ app/src/theme.js | 25 + app/src/ui/BiosOverlay.jsx | 188 +++ app/src/ui/Hud.jsx | 317 +++++ app/src/ui/Overlays.jsx | 111 ++ app/src/ui/Preboot.jsx | 54 + app/src/ui/TitleMenu.jsx | 429 ++++++ app/src/ui/TouchOverlay.jsx | 128 ++ app/vite.config.js | 19 + 39 files changed, 8435 insertions(+) create mode 100644 Dockerfile create mode 100644 app/.gitignore create mode 100644 app/index.html create mode 100644 app/package-lock.json create mode 100644 app/package.json create mode 120000 app/public/assets create mode 120000 app/public/policies create mode 120000 app/public/robot create mode 100644 app/src/App.jsx create mode 100644 app/src/game/arena.js create mode 100644 app/src/game/ball-actor.js create mode 100644 app/src/game/ball-visual.js create mode 100644 app/src/game/ceremony.js create mode 100644 app/src/game/constants.js create mode 100644 app/src/game/controls/controller.js create mode 100644 app/src/game/controls/gamepad.js create mode 100644 app/src/game/controls/keyboard.js create mode 100644 app/src/game/controls/touch.js create mode 100644 app/src/game/duck.js create mode 100644 app/src/game/fx/demo-glitch.html create mode 100644 app/src/game/fx/demo-wireframe.html create mode 100644 app/src/game/fx/fx-glitch.js create mode 100644 app/src/game/fx/fx-wireframe.js create mode 100644 app/src/game/game.js create mode 100644 app/src/game/ghosts.js create mode 100644 app/src/game/signed.js create mode 100644 app/src/game/stickers.js create mode 100644 app/src/game/variants.js create mode 100644 app/src/main.jsx create mode 100644 app/src/scene/GameCanvas.jsx create mode 100644 app/src/store.js create mode 100644 app/src/theme.js create mode 100644 app/src/ui/BiosOverlay.jsx create mode 100644 app/src/ui/Hud.jsx create mode 100644 app/src/ui/Overlays.jsx create mode 100644 app/src/ui/Preboot.jsx create mode 100644 app/src/ui/TitleMenu.jsx create mode 100644 app/src/ui/TouchOverlay.jsx create mode 100644 app/vite.config.js diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..00689f0 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,15 @@ +# Build the Vite app, then serve the static bundle with nginx. +# HF Spaces docker SDK: the container must listen on app_port (8080); +# nginx-unprivileged listens on 8080 by default and runs as non-root, +# which is exactly what Spaces expects. + +FROM node:22-alpine AS build +WORKDIR /build +COPY app/package.json app/package-lock.json ./ +RUN npm ci +COPY app/ ./ +RUN npm run build + +FROM nginxinc/nginx-unprivileged:alpine +COPY --from=build /build/dist /usr/share/nginx/html +EXPOSE 8080 diff --git a/app/.gitignore b/app/.gitignore new file mode 100644 index 0000000..b947077 --- /dev/null +++ b/app/.gitignore @@ -0,0 +1,2 @@ +node_modules/ +dist/ diff --git a/app/index.html b/app/index.html new file mode 100644 index 0000000..e56e23e --- /dev/null +++ b/app/index.html @@ -0,0 +1,21 @@ + + + + + + Microduck + + + +
+ + + diff --git a/app/package-lock.json b/app/package-lock.json new file mode 100644 index 0000000..f2b2929 --- /dev/null +++ b/app/package-lock.json @@ -0,0 +1,2052 @@ +{ + "name": "app", + "version": "1.0.0", + "lockfileVersion": 3, + "requires": true, + "packages": { + "": { + "name": "app", + "version": "1.0.0", + "license": "ISC", + "dependencies": { + "@emotion/react": "^11.14.0", + "@emotion/styled": "^11.14.1", + "@mui/material": "^9.3.1", + "@react-three/fiber": "^9.7.0", + "react": "^19.2.8", + "react-dom": "^19.2.8", + "three": "^0.164.1", + "zustand": "^5.0.15" + }, + "devDependencies": { + "@vitejs/plugin-react": "^6.1.0", + "vite": "^8.2.2" + } + }, + "node_modules/@babel/code-frame": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.29.7.tgz", + "integrity": "sha512-Aup7aUOfpbAUg2ROOJN6Iw5f9DMBlzu0mIkm/malLQFN/YQgO48wCj0Kxa3sEHJvPVFg7siR+qRInwXd2qhQKw==", + "license": "MIT", + "dependencies": { + "@babel/helper-validator-identifier": "^7.29.7", + "js-tokens": "^4.0.0", + "picocolors": "^1.1.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/generator": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/generator/-/generator-7.29.8.tgz", + "integrity": "sha512-gZbepsdh3WDtgZKWL+vTPh71LSBrm/Y4/QDZBVCcYfmeTEEuoOYwlSy+G1StfJg+/Zy550u/3TATbm7qDbbMtg==", + "license": "MIT", + "dependencies": { + "@babel/parser": "^7.29.8", + "@babel/types": "^7.29.8", + "@jridgewell/gen-mapping": "^0.3.12", + "@jridgewell/trace-mapping": "^0.3.28", + "jsesc": "^3.0.2" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-globals": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-globals/-/helper-globals-7.29.7.tgz", + "integrity": "sha512-3nQVUAtvkKH9zahfWgw96Jc/uFOmjACE1kQz82E2lqWmHBgjzbNlsC22nuQTfahmWeQtTq5nQ/4Nnd2A1wj4zA==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-module-imports": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-module-imports/-/helper-module-imports-7.29.7.tgz", + "integrity": "sha512-ejHwrQQYcm9xnTivShn2IDOlIzInN34AXskvq9QicvCtEzq1Vzclu/tKF8Jq1Cg8JG2GL6/EmjgsCT7lXepE3g==", + "license": "MIT", + "dependencies": { + "@babel/traverse": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-string-parser": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-string-parser/-/helper-string-parser-7.29.7.tgz", + "integrity": "sha512-Pb5ijPrZ89GDH8223L4UP8i6QApWxs04RbPQJTeWDV0/keR2E36MeKnyr6LYmUUvqRRI+Iv87SuF1W6ErINzYw==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/helper-validator-identifier": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.29.7.tgz", + "integrity": "sha512-qehxGkRj55h/ff8EMaJ+cYhyaKlHIxqYDn682wQD7RNp9UujOQsHog2uS0r2vzr4pW+sXf90NeeayjcNaX3fFg==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/parser": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/parser/-/parser-7.29.8.tgz", + "integrity": "sha512-E8lTAYNB1KW+FH+VGJuZM1ioAx2E6oVlvQFRrf5P8ZZmsiJXYAD9vTFV7yyEURNzgh1dFqMZuO6tUwcARbqFCA==", + "license": "MIT", + "dependencies": { + "@babel/types": "^7.29.8" + }, + "bin": { + "parser": "bin/babel-parser.js" + }, + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@babel/runtime": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/runtime/-/runtime-7.29.7.tgz", + "integrity": "sha512-Nq8OhGWiZIZGV6hLHoyAKLLcJihP/xFeBMGJoUrxTX2psI8dCifzLhZISFb+VWS3wFMRDmCGw5R+dOySCqPLhw==", + "license": "MIT", + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/template": { + "version": "7.29.7", + "resolved": "https://registry.npmjs.org/@babel/template/-/template-7.29.7.tgz", + "integrity": "sha512-puq+Gf35oI24FeN11LkoUQFqv9uwNeWpxXZi/Ji3rRIoKAzKnxRaZ+Gkj0vKS9ZCiTESfng1N9LyOyXvo+m+Gg==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/parser": "^7.29.7", + "@babel/types": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/traverse": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/traverse/-/traverse-7.29.8.tgz", + "integrity": "sha512-I5z7H3bf/41ktsNVLtpN0wAa336HkqIHQ5BuPLEhTkt1jVSyZpeNKIzTgEWmlxjdg81R0IgUCcaE+Ok3NvrfZg==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.29.7", + "@babel/generator": "^7.29.8", + "@babel/helper-globals": "^7.29.7", + "@babel/parser": "^7.29.8", + "@babel/template": "^7.29.7", + "@babel/types": "^7.29.8", + "debug": "^4.3.1" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@babel/types": { + "version": "7.29.8", + "resolved": "https://registry.npmjs.org/@babel/types/-/types-7.29.8.tgz", + "integrity": "sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==", + "license": "MIT", + "dependencies": { + "@babel/helper-string-parser": "^7.29.7", + "@babel/helper-validator-identifier": "^7.29.7" + }, + "engines": { + "node": ">=6.9.0" + } + }, + "node_modules/@emotion/babel-plugin": { + "version": "11.13.5", + "resolved": "https://registry.npmjs.org/@emotion/babel-plugin/-/babel-plugin-11.13.5.tgz", + "integrity": "sha512-pxHCpT2ex+0q+HH91/zsdHkw/lXd468DIN2zvfvLtPKLLMo6gQj7oLObq8PhkrxOZb/gGCq03S3Z7PDhS8pduQ==", + "license": "MIT", + "dependencies": { + "@babel/helper-module-imports": "^7.16.7", + "@babel/runtime": "^7.18.3", + "@emotion/hash": "^0.9.2", + "@emotion/memoize": "^0.9.0", + "@emotion/serialize": "^1.3.3", + "babel-plugin-macros": "^3.1.0", + "convert-source-map": "^1.5.0", + "escape-string-regexp": "^4.0.0", + "find-root": "^1.1.0", + "source-map": "^0.5.7", + "stylis": "4.2.0" + } + }, + "node_modules/@emotion/cache": { + "version": "11.14.0", + "resolved": "https://registry.npmjs.org/@emotion/cache/-/cache-11.14.0.tgz", + "integrity": "sha512-L/B1lc/TViYk4DcpGxtAVbx0ZyiKM5ktoIyafGkH6zg/tj+mA+NE//aPYKG0k8kCHSHVJrpLpcAlOBEXQ3SavA==", + "license": "MIT", + "dependencies": { + "@emotion/memoize": "^0.9.0", + "@emotion/sheet": "^1.4.0", + "@emotion/utils": "^1.4.2", + "@emotion/weak-memoize": "^0.4.0", + "stylis": "4.2.0" + } + }, + "node_modules/@emotion/hash": { + "version": "0.9.2", + "resolved": "https://registry.npmjs.org/@emotion/hash/-/hash-0.9.2.tgz", + "integrity": "sha512-MyqliTZGuOm3+5ZRSaaBGP3USLw6+EGykkwZns2EPC5g8jJ4z9OrdZY9apkl3+UP9+sdz76YYkwCKP5gh8iY3g==", + "license": "MIT" + }, + "node_modules/@emotion/is-prop-valid": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@emotion/is-prop-valid/-/is-prop-valid-1.4.0.tgz", + "integrity": "sha512-QgD4fyscGcbbKwJmqNvUMSE02OsHUa+lAWKdEUIJKgqe5IwRSKd7+KhibEWdaKwgjLj0DRSHA9biAIqGBk05lw==", + "license": "MIT", + "dependencies": { + "@emotion/memoize": "^0.9.0" + } + }, + "node_modules/@emotion/memoize": { + "version": "0.9.0", + "resolved": "https://registry.npmjs.org/@emotion/memoize/-/memoize-0.9.0.tgz", + "integrity": "sha512-30FAj7/EoJ5mwVPOWhAyCX+FPfMDrVecJAM+Iw9NRoSl4BBAQeqj4cApHHUXOVvIPgLVDsCFoz/hGD+5QQD1GQ==", + "license": "MIT" + }, + "node_modules/@emotion/react": { + "version": "11.14.0", + "resolved": "https://registry.npmjs.org/@emotion/react/-/react-11.14.0.tgz", + "integrity": "sha512-O000MLDBDdk/EohJPFUqvnp4qnHeYkVP5B0xEG0D/L7cOKP9kefu2DXn8dj74cQfsEzUqh+sr1RzFqiL1o+PpA==", + "license": "MIT", + "peer": true, + "dependencies": { + "@babel/runtime": "^7.18.3", + "@emotion/babel-plugin": "^11.13.5", + "@emotion/cache": "^11.14.0", + "@emotion/serialize": "^1.3.3", + "@emotion/use-insertion-effect-with-fallbacks": "^1.2.0", + "@emotion/utils": "^1.4.2", + "@emotion/weak-memoize": "^0.4.0", + "hoist-non-react-statics": "^3.3.1" + }, + "peerDependencies": { + "react": ">=16.8.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@emotion/serialize": { + "version": "1.3.3", + "resolved": "https://registry.npmjs.org/@emotion/serialize/-/serialize-1.3.3.tgz", + "integrity": "sha512-EISGqt7sSNWHGI76hC7x1CksiXPahbxEOrC5RjmFRJTqLyEK9/9hZvBbiYn70dw4wuwMKiEMCUlR6ZXTSWQqxA==", + "license": "MIT", + "dependencies": { + "@emotion/hash": "^0.9.2", + "@emotion/memoize": "^0.9.0", + "@emotion/unitless": "^0.10.0", + "@emotion/utils": "^1.4.2", + "csstype": "^3.0.2" + } + }, + "node_modules/@emotion/sheet": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/@emotion/sheet/-/sheet-1.4.0.tgz", + "integrity": "sha512-fTBW9/8r2w3dXWYM4HCB1Rdp8NLibOw2+XELH5m5+AkWiL/KqYX6dc0kKYlaYyKjrQ6ds33MCdMPEwgs2z1rqg==", + "license": "MIT" + }, + "node_modules/@emotion/styled": { + "version": "11.14.1", + "resolved": "https://registry.npmjs.org/@emotion/styled/-/styled-11.14.1.tgz", + "integrity": "sha512-qEEJt42DuToa3gurlH4Qqc1kVpNq8wO8cJtDzU46TjlzWjDlsVyevtYCRijVq3SrHsROS+gVQ8Fnea108GnKzw==", + "license": "MIT", + "peer": true, + "dependencies": { + "@babel/runtime": "^7.18.3", + "@emotion/babel-plugin": "^11.13.5", + "@emotion/is-prop-valid": "^1.3.0", + "@emotion/serialize": "^1.3.3", + "@emotion/use-insertion-effect-with-fallbacks": "^1.2.0", + "@emotion/utils": "^1.4.2" + }, + "peerDependencies": { + "@emotion/react": "^11.0.0-rc.0", + "react": ">=16.8.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@emotion/unitless": { + "version": "0.10.0", + "resolved": "https://registry.npmjs.org/@emotion/unitless/-/unitless-0.10.0.tgz", + "integrity": "sha512-dFoMUuQA20zvtVTuxZww6OHoJYgrzfKM1t52mVySDJnMSEa08ruEvdYQbhvyu6soU+NeLVd3yKfTfT0NeV6qGg==", + "license": "MIT" + }, + "node_modules/@emotion/use-insertion-effect-with-fallbacks": { + "version": "1.2.0", + "resolved": "https://registry.npmjs.org/@emotion/use-insertion-effect-with-fallbacks/-/use-insertion-effect-with-fallbacks-1.2.0.tgz", + "integrity": "sha512-yJMtVdH59sxi/aVJBpk9FQq+OR8ll5GT8oWd57UpeaKEVGab41JWaCFA7FRLoMLloOZF/c/wsPoe+bfGmRKgDg==", + "license": "MIT", + "peerDependencies": { + "react": ">=16.8.0" + } + }, + "node_modules/@emotion/utils": { + "version": "1.4.2", + "resolved": "https://registry.npmjs.org/@emotion/utils/-/utils-1.4.2.tgz", + "integrity": "sha512-3vLclRofFziIa3J2wDh9jjbkUz9qk5Vi3IZ/FSTKViB0k+ef0fPV7dYrUIugbgupYDx7v9ud/SjrtEP8Y4xLoA==", + "license": "MIT" + }, + "node_modules/@emotion/weak-memoize": { + "version": "0.4.0", + "resolved": "https://registry.npmjs.org/@emotion/weak-memoize/-/weak-memoize-0.4.0.tgz", + "integrity": "sha512-snKqtPW01tN0ui7yu9rGv69aJXr/a/Ywvl11sUjNtEcRc+ng/mQriFL0wLXMef74iHa/EkftbDzU9F8iFbH+zg==", + "license": "MIT" + }, + "node_modules/@jridgewell/gen-mapping": { + "version": "0.3.13", + "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz", + "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==", + "license": "MIT", + "dependencies": { + "@jridgewell/sourcemap-codec": "^1.5.0", + "@jridgewell/trace-mapping": "^0.3.24" + } + }, + "node_modules/@jridgewell/resolve-uri": { + "version": "3.1.2", + "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz", + "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==", + "license": "MIT", + "engines": { + "node": ">=6.0.0" + } + }, + "node_modules/@jridgewell/sourcemap-codec": { + "version": "1.5.5", + "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.5.5.tgz", + "integrity": "sha512-cYQ9310grqxueWbl+WuIUIaiUaDcj7WOq5fVhEljNVgRfOUhY9fy2zTvfoqWsnebh8Sl70VScFbICvJnLKB0Og==", + "license": "MIT" + }, + "node_modules/@jridgewell/trace-mapping": { + "version": "0.3.31", + "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz", + "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==", + "license": "MIT", + "dependencies": { + "@jridgewell/resolve-uri": "^3.1.0", + "@jridgewell/sourcemap-codec": "^1.4.14" + } + }, + "node_modules/@mui/core-downloads-tracker": { + "version": "9.3.1", + "resolved": "https://registry.npmjs.org/@mui/core-downloads-tracker/-/core-downloads-tracker-9.3.1.tgz", + "integrity": "sha512-IAyAFNQbT7hysJ9HXphiOmWJF7G1OglzHanqCgvQgH9LA2ydxtmaTBDbcBqw6euZesyShiwvpvbnYO1GY1AyXQ==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mui-org" + } + }, + "node_modules/@mui/material": { + "version": "9.3.1", + "resolved": "https://registry.npmjs.org/@mui/material/-/material-9.3.1.tgz", + "integrity": "sha512-NahAEGIXqS1K0bA4th1jeFxBguS59NOcLbMA0vU+fSaPWKjtwGBGGHeTwlc9PSmzMjOZKceeFWESB8fVHr31hA==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.29.7", + "@mui/core-downloads-tracker": "^9.3.1", + "@mui/system": "^9.3.0", + "@mui/types": "^9.3.0", + "@mui/utils": "^9.3.0", + "@popperjs/core": "^2.11.8", + "@types/react-transition-group": "^4.4.12", + "clsx": "^2.1.1", + "csstype": "^3.2.3", + "prop-types": "^15.8.1", + "react-is": "^19.2.8", + "react-transition-group": "^4.4.5" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mui-org" + }, + "peerDependencies": { + "@emotion/react": "^11.5.0", + "@emotion/styled": "^11.3.0", + "@mui/material-pigment-css": "^9.3.0", + "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react-dom": "^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@emotion/react": { + "optional": true + }, + "@emotion/styled": { + "optional": true + }, + "@mui/material-pigment-css": { + "optional": true + }, + "@types/react": { + "optional": true + } + } + }, + "node_modules/@mui/private-theming": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/@mui/private-theming/-/private-theming-9.3.0.tgz", + "integrity": "sha512-ERvqk5pejf9aRnQcDILSWGtFmsEMiVxlQ4+xsVCjsEvmK0fV9BiVP/cQwAF5dwyDFbve4lTrlcgeFEecVzTNiA==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.29.7", + "@mui/utils": "^9.3.0", + "prop-types": "^15.8.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mui-org" + }, + "peerDependencies": { + "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react": "^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@mui/styled-engine": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/@mui/styled-engine/-/styled-engine-9.3.0.tgz", + "integrity": "sha512-x9+KYxhjoHYZ4nioxdKnvQWdw0RScbhoZfQ4tv3Db742683U3wlYSp6zV6Us78dMFnKnyTrPTkQKyutp14gnKA==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.29.7", + "@emotion/cache": "^11.14.0", + "@emotion/serialize": "^1.3.3", + "@emotion/sheet": "^1.4.0", + "csstype": "^3.2.3", + "prop-types": "^15.8.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mui-org" + }, + "peerDependencies": { + "@emotion/react": "^11.4.1", + "@emotion/styled": "^11.3.0", + "react": "^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@emotion/react": { + "optional": true + }, + "@emotion/styled": { + "optional": true + } + } + }, + "node_modules/@mui/system": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/@mui/system/-/system-9.3.0.tgz", + "integrity": "sha512-0l4LqHJxZj65xSrioniGsxm7VNoGXonPo203oZjhBUvIDPeBqRTb7Mqc45Qxs6sO6WGR7WE/9cJ6lb4lkvHkjg==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.29.7", + "@mui/private-theming": "^9.3.0", + "@mui/styled-engine": "^9.3.0", + "@mui/types": "^9.3.0", + "@mui/utils": "^9.3.0", + "clsx": "^2.1.1", + "csstype": "^3.2.3", + "prop-types": "^15.8.1" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mui-org" + }, + "peerDependencies": { + "@emotion/react": "^11.5.0", + "@emotion/styled": "^11.3.0", + "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react": "^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@emotion/react": { + "optional": true + }, + "@emotion/styled": { + "optional": true + }, + "@types/react": { + "optional": true + } + } + }, + "node_modules/@mui/types": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/@mui/types/-/types-9.3.0.tgz", + "integrity": "sha512-2JSxyfpEFWNUB2vKs/T1BvkfyNisMHWph8bLMj8T0uHwmLl/0qfAwQkfwMT6kxLXN9uIum9AEbECXU8er3amIg==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.29.7" + }, + "peerDependencies": { + "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@mui/utils": { + "version": "9.3.0", + "resolved": "https://registry.npmjs.org/@mui/utils/-/utils-9.3.0.tgz", + "integrity": "sha512-2HZdHwWJ6eB+7lVGSOHsByGw8jeRulT4g0NZ608Wb8Q57DE2jbNqrWPFuJsvkQQiBiTmlpvQL3i+/62zsiPrkw==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.29.7", + "@mui/types": "^9.3.0", + "@types/prop-types": "^15.7.15", + "clsx": "^2.1.1", + "prop-types": "^15.8.1", + "react-is": "^19.2.8" + }, + "engines": { + "node": ">=14.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/mui-org" + }, + "peerDependencies": { + "@types/react": "^17.0.0 || ^18.0.0 || ^19.0.0", + "react": "^17.0.0 || ^18.0.0 || ^19.0.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + } + } + }, + "node_modules/@oxc-project/types": { + "version": "0.146.0", + "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.146.0.tgz", + "integrity": "sha512-XC0QsnnhVe7sLIWmYmdPw7x5P0h4W8vUU3Nv1ySgWXtvCz8NizoAEpGXA0sOYoJQV2Rl13LgURAHQ5cI5ILCSA==", + "dev": true, + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/Boshen" + } + }, + "node_modules/@popperjs/core": { + "version": "2.11.8", + "resolved": "https://registry.npmjs.org/@popperjs/core/-/core-2.11.8.tgz", + "integrity": "sha512-P1st0aksCrn9sGZhp8GMYwBnQsbvAWsZAX44oXNNvLHGqAOcoVxmjZiohstwQ7SqKnbR47akdNi+uleWD8+g6A==", + "license": "MIT", + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/popperjs" + } + }, + "node_modules/@react-three/fiber": { + "version": "9.7.0", + "resolved": "https://registry.npmjs.org/@react-three/fiber/-/fiber-9.7.0.tgz", + "integrity": "sha512-EWm9FwcaOZQu/ExFW5rggoCMM1NJet5YbxVxKaOE+KSncrjU0Wx7017qSyGFvupviK89nMYGCWU3BIK4dI1clw==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.17.8", + "@types/webxr": "*", + "base64-js": "^1.5.1", + "buffer": "^6.0.3", + "its-fine": "^2.0.0", + "react-use-measure": "^2.1.7", + "scheduler": "^0.27.0", + "suspend-react": "^0.1.3", + "use-sync-external-store": "^1.4.0", + "zustand": "^5.0.3" + }, + "peerDependencies": { + "expo": ">=43.0", + "expo-asset": ">=8.4", + "expo-file-system": ">=11.0", + "expo-gl": ">=11.0", + "react": ">=19 <19.3", + "react-dom": ">=19 <19.3", + "react-native": ">=0.78", + "three": ">=0.156" + }, + "peerDependenciesMeta": { + "expo": { + "optional": true + }, + "expo-asset": { + "optional": true + }, + "expo-file-system": { + "optional": true + }, + "expo-gl": { + "optional": true + }, + "react-dom": { + "optional": true + }, + "react-native": { + "optional": true + } + } + }, + "node_modules/@rolldown/binding-android-arm-eabi": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm-eabi/-/binding-android-arm-eabi-1.2.5.tgz", + "integrity": "sha512-DLe/i+l8ynIBY7XEQ191TeZvCoowIGa18R+dIV30GW7DiOtp74i/xX8hs8GUjW5ARV7VZuie3d6AumSmCwbeRA==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-android-arm64": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-android-arm64/-/binding-android-arm64-1.2.5.tgz", + "integrity": "sha512-zXcwKlQApYAOELHd8PwKDFkagYF9Wy4e0RJ+0qnzl9Pjnpj75TEG8ufv40p2J7kCEfwZAsNiuzRIyNNMWT38ig==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-arm64": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-arm64/-/binding-darwin-arm64-1.2.5.tgz", + "integrity": "sha512-dK4QakI42nzWgJT5sm4y4y/O//D4OxM75/cH28RLV+nzIN9AY+YsbuUVrUTjlLjXR6vpyxFbSsbmNuJ6BP9sww==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-darwin-x64": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-darwin-x64/-/binding-darwin-x64-1.2.5.tgz", + "integrity": "sha512-fqSALaUu1Wjd1nK2uW2kJDWdLCc8lx1IcY+MTY26Aurfdx19anlzhqXOgCFbBFQnlFDTn4TC1/7Nz4Bl2mLP3A==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-freebsd-x64": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-freebsd-x64/-/binding-freebsd-x64-1.2.5.tgz", + "integrity": "sha512-/vCnNxlkxs9tKxNDcyWUePpJ/PgTzxIaVhoM5SmG8UV+GR/IcPam4VYxi7GIMo7PSDuNqlJqvprqii9NqqVCMw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm-gnueabihf": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm-gnueabihf/-/binding-linux-arm-gnueabihf-1.2.5.tgz", + "integrity": "sha512-abk0NLA519LxRCszmbE0jYKuQ9YPocOXTiOXOo6Yr+YAT95VH+PtqYAjOJvGKt3viEd/x4qzabAlwd5bHOOARg==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-gnu": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-1.2.5.tgz", + "integrity": "sha512-Y7eALiJ8lr0M2HH103Js+g7V34wf6snlpZLAsHI90uLhr3PVlNsbFVAXJC9d/V6BnPyKtpSwI+NcB/RLxsQxuA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-arm64-musl": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-arm64-musl/-/binding-linux-arm64-musl-1.2.5.tgz", + "integrity": "sha512-xMvZgnbZg4YVnR/AX2b3oOPDTFYJvUVaJg5FedA/LuvexAtXibZQej4cnTkw3rjsJ/ggUROB64TdtETiim+FYA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-ppc64-gnu": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-1.2.5.tgz", + "integrity": "sha512-GRjeqTUDHTo5GwntsLaAMcBahG3nlpjftXWZLN73HiYQlhwEowvarFgQnRnQZtIp4keXX7quXFbG38uPZBa2EA==", + "cpu": [ + "ppc64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-s390x-gnu": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-1.2.5.tgz", + "integrity": "sha512-vLNTR45F2Uwc8AufkNXPmB4VliaXs+FvcheEogIzOXzO4l+LzieXF5A/TWxLy5HtqpsRCHUfd0lPVrrdgXdLHQ==", + "cpu": [ + "s390x" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-gnu": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-gnu/-/binding-linux-x64-gnu-1.2.5.tgz", + "integrity": "sha512-Mgj59/HTuYeK9Gz2MA+mBWKnHsAgkBSec15ZMb1st3oIfFbX7gCjOae7GydHhzcyQi9Z/7M1QuN9bR3oFqF0jQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-linux-x64-musl": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-linux-x64-musl/-/binding-linux-x64-musl-1.2.5.tgz", + "integrity": "sha512-mY8AP0/ichsbhAxGnLa3d3+MwV0EfgrPND2bplI3Ym8T6R2pJ0N87bvrKVwNXmdy3jnr6eQBecdqx/HMknBmpA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-openharmony-arm64": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-openharmony-arm64/-/binding-openharmony-arm64-1.2.5.tgz", + "integrity": "sha512-8SLssA2oweAxyRgDp789ACfRb/3P+zNRJpzZxSizxF9m8NUDQ4+3xjo8ttjhVGGw6Qxb70oZiEtIjaKikCO7Yw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "openharmony" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-arm64-msvc": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-1.2.5.tgz", + "integrity": "sha512-vGbruD5zquhoc8D9SViXgN2FBJtNdTyQ4DtG+SWiEGlJiAzoKcZ2xp+xuXCffhubVdt0NJlTZqkeRuERy7g8Cw==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/binding-win32-x64-msvc": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/@rolldown/binding-win32-x64-msvc/-/binding-win32-x64-msvc-1.2.5.tgz", + "integrity": "sha512-e/SXpgISz+IoqVcSSI0rx/d/he8zqLex+/rCWpnHpmVfmPIUjag9H6P7zotf0gJHwPUhQxZ/mF8tr6acebT9yw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MIT", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": "^20.19.0 || >=22.12.0" + } + }, + "node_modules/@rolldown/pluginutils": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/@rolldown/pluginutils/-/pluginutils-1.0.1.tgz", + "integrity": "sha512-2j9bGt5Jh8hj+vPtgzPtl72j0yRxHAyumoo6TNfAjsLB04UtpSvPbPcDcBMxz7n+9CYB0c1GxQFxYRg2jimqGw==", + "dev": true, + "license": "MIT" + }, + "node_modules/@types/parse-json": { + "version": "4.0.2", + "resolved": "https://registry.npmjs.org/@types/parse-json/-/parse-json-4.0.2.tgz", + "integrity": "sha512-dISoDXWWQwUquiKsyZ4Ng+HX2KsPL7LyHKHQwgGFEA3IaKac4Obd+h2a/a6waisAoepJlBcx9paWqjA8/HVjCw==", + "license": "MIT" + }, + "node_modules/@types/prop-types": { + "version": "15.7.15", + "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz", + "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==", + "license": "MIT" + }, + "node_modules/@types/react": { + "version": "19.2.18", + "resolved": "https://registry.npmjs.org/@types/react/-/react-19.2.18.tgz", + "integrity": "sha512-AnzbBERsrLKtk2XSfTbYRLjQPdy116Sty4q+T+Bp3IC4l6jNBvreVPAHmpq9qhXQM7CXZPjLVmGMw9sy+hxQ3w==", + "license": "MIT", + "peer": true, + "dependencies": { + "csstype": "^3.2.2" + } + }, + "node_modules/@types/react-reconciler": { + "version": "0.28.9", + "resolved": "https://registry.npmjs.org/@types/react-reconciler/-/react-reconciler-0.28.9.tgz", + "integrity": "sha512-HHM3nxyUZ3zAylX8ZEyrDNd2XZOnQ0D5XfunJF5FLQnZbHHYq4UWvW1QfelQNXv1ICNkwYhfxjwfnqivYB6bFg==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*" + } + }, + "node_modules/@types/react-transition-group": { + "version": "4.4.12", + "resolved": "https://registry.npmjs.org/@types/react-transition-group/-/react-transition-group-4.4.12.tgz", + "integrity": "sha512-8TV6R3h2j7a91c+1DXdJi3Syo69zzIZbz7Lg5tORM5LEJG7X/E6a1V3drRyBRZq7/utz7A+c4OgYLiLcYGHG6w==", + "license": "MIT", + "peerDependencies": { + "@types/react": "*" + } + }, + "node_modules/@types/webxr": { + "version": "0.5.24", + "resolved": "https://registry.npmjs.org/@types/webxr/-/webxr-0.5.24.tgz", + "integrity": "sha512-h8fgEd/DpoS9CBrjEQXR+dIDraopAEfu4wYVNY2tEPwk60stPWhvZMf4Foo5FakuQ7HFZoa8WceaWFervK2Ovg==", + "license": "MIT" + }, + "node_modules/@vitejs/plugin-react": { + "version": "6.1.0", + "resolved": "https://registry.npmjs.org/@vitejs/plugin-react/-/plugin-react-6.1.0.tgz", + "integrity": "sha512-qd2BzUBehkov86WFhg0JkEFEYyCLG9uPCe6qWTY/kRlss9OvJrOF2UbIWT7p+8IzZHkEu0DNGHc4HSv+JdDLsw==", + "dev": true, + "license": "MIT", + "dependencies": { + "@rolldown/pluginutils": "^1.0.1" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "peerDependencies": { + "@rolldown/plugin-babel": "^0.1.7 || ^0.2.0", + "babel-plugin-react-compiler": "^1.0.0", + "oxc-transform-react": "^0.145.0", + "vite": "^8.0.0" + }, + "peerDependenciesMeta": { + "@rolldown/plugin-babel": { + "optional": true + }, + "babel-plugin-react-compiler": { + "optional": true + }, + "oxc-transform-react": { + "optional": true + } + } + }, + "node_modules/babel-plugin-macros": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/babel-plugin-macros/-/babel-plugin-macros-3.1.0.tgz", + "integrity": "sha512-Cg7TFGpIr01vOQNODXOOaGz2NpCU5gl8x1qJFbb6hbZxR7XrcE2vtbAsTAbJ7/xwJtUuJEw8K8Zr/AE0LHlesg==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.12.5", + "cosmiconfig": "^7.0.0", + "resolve": "^1.19.0" + }, + "engines": { + "node": ">=10", + "npm": ">=6" + } + }, + "node_modules/base64-js": { + "version": "1.5.1", + "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz", + "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT" + }, + "node_modules/buffer": { + "version": "6.0.3", + "resolved": "https://registry.npmjs.org/buffer/-/buffer-6.0.3.tgz", + "integrity": "sha512-FTiCpNxtwiZZHEZbcbTIcZjERVICn9yq/pDFkTl95/AxzD1naBctN7YO68riM/gLSDY7sdrMby8hofADYuuqOA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "MIT", + "dependencies": { + "base64-js": "^1.3.1", + "ieee754": "^1.2.1" + } + }, + "node_modules/callsites": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/callsites/-/callsites-3.1.0.tgz", + "integrity": "sha512-P8BjAsXvZS+VIDUI11hHCQEv74YT67YUi5JJFNWIqL235sBmjX4+qx9Muvls5ivyNENctx46xQLQ3aTuE7ssaQ==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/clsx": { + "version": "2.1.1", + "resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz", + "integrity": "sha512-eYm0QWBtUrBWZWG0d386OGAw16Z995PiOVo2B7bjWSbHedGl5e0ZWaq65kOGgUSNesEIDkB9ISbTg/JK9dhCZA==", + "license": "MIT", + "engines": { + "node": ">=6" + } + }, + "node_modules/convert-source-map": { + "version": "1.9.0", + "resolved": "https://registry.npmjs.org/convert-source-map/-/convert-source-map-1.9.0.tgz", + "integrity": "sha512-ASFBup0Mz1uyiIjANan1jzLQami9z1PoYSZCiiYW2FczPbenXc45FZdBZLzOT+r6+iciuEModtmCti+hjaAk0A==", + "license": "MIT" + }, + "node_modules/cosmiconfig": { + "version": "7.1.0", + "resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-7.1.0.tgz", + "integrity": "sha512-AdmX6xUzdNASswsFtmwSt7Vj8po9IuqXm0UXz7QKPuEUmPB4XyjGfaAr2PSuELMwkRMVH1EpIkX5bTZGRB3eCA==", + "license": "MIT", + "dependencies": { + "@types/parse-json": "^4.0.0", + "import-fresh": "^3.2.1", + "parse-json": "^5.0.0", + "path-type": "^4.0.0", + "yaml": "^1.10.0" + }, + "engines": { + "node": ">=10" + } + }, + "node_modules/cosmiconfig/node_modules/yaml": { + "version": "1.10.3", + "resolved": "https://registry.npmjs.org/yaml/-/yaml-1.10.3.tgz", + "integrity": "sha512-vIYeF1u3CjlhAFekPPAk2h/Kv4T3mAkMox5OymRiJQB0spDP10LHvt+K7G9Ny6NuuMAb25/6n1qyUjAcGNf/AA==", + "license": "ISC", + "engines": { + "node": ">= 6" + } + }, + "node_modules/csstype": { + "version": "3.2.3", + "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz", + "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==", + "license": "MIT" + }, + "node_modules/debug": { + "version": "4.4.3", + "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz", + "integrity": "sha512-RGwwWnwQvkVfavKVt22FGLw+xYSdzARwm0ru6DhTVA3umU5hZc28V3kO4stgYryrTlLpuvgI9GiijltAjNbcqA==", + "license": "MIT", + "dependencies": { + "ms": "^2.1.3" + }, + "engines": { + "node": ">=6.0" + }, + "peerDependenciesMeta": { + "supports-color": { + "optional": true + } + } + }, + "node_modules/detect-libc": { + "version": "2.1.2", + "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz", + "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==", + "dev": true, + "license": "Apache-2.0", + "engines": { + "node": ">=8" + } + }, + "node_modules/dom-helpers": { + "version": "5.2.1", + "resolved": "https://registry.npmjs.org/dom-helpers/-/dom-helpers-5.2.1.tgz", + "integrity": "sha512-nRCa7CK3VTrM2NmGkIy4cbK7IZlgBE/PYMn55rrXefr5xXDP0LdtfPnblFDoVdcAfslJ7or6iqAUnx0CCGIWQA==", + "license": "MIT", + "dependencies": { + "@babel/runtime": "^7.8.7", + "csstype": "^3.0.2" + } + }, + "node_modules/error-ex": { + "version": "1.3.4", + "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz", + "integrity": "sha512-sqQamAnR14VgCr1A618A3sGrygcpK+HEbenA/HiEAkkUwcZIIB/tgWqHFxWgOyDh4nB4JCRimh79dR5Ywc9MDQ==", + "license": "MIT", + "dependencies": { + "is-arrayish": "^0.2.1" + } + }, + "node_modules/es-errors": { + "version": "1.3.0", + "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz", + "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/escape-string-regexp": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz", + "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==", + "license": "MIT", + "engines": { + "node": ">=10" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/fdir": { + "version": "6.5.0", + "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz", + "integrity": "sha512-tIbYtZbucOs0BRGqPJkshJUYdL+SDH7dVM8gjy+ERp3WAUjLEFJE+02kanyHtwjWOnwrKYBiwAmM0p4kLJAnXg==", + "dev": true, + "license": "MIT", + "engines": { + "node": ">=12.0.0" + }, + "peerDependencies": { + "picomatch": "^3 || ^4" + }, + "peerDependenciesMeta": { + "picomatch": { + "optional": true + } + } + }, + "node_modules/find-root": { + "version": "1.1.0", + "resolved": "https://registry.npmjs.org/find-root/-/find-root-1.1.0.tgz", + "integrity": "sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==", + "license": "MIT" + }, + "node_modules/fsevents": { + "version": "2.3.3", + "resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.3.tgz", + "integrity": "sha512-5xoDfX+fL7faATnagmWPpbFtwh/R77WmMMqqHGS65C3vvB0YHrgF+B1YmZ3441tMj5n63k0212XNoJwzlhffQw==", + "dev": true, + "hasInstallScript": true, + "license": "MIT", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": "^8.16.0 || ^10.6.0 || >=11.0.0" + } + }, + "node_modules/function-bind": { + "version": "1.1.2", + "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz", + "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==", + "license": "MIT", + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/hasown": { + "version": "2.0.4", + "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.4.tgz", + "integrity": "sha512-T2UbfbBEF32wiepXIsMlTW9+dDYC6wMh/t/vYA4tuOMKqWz/n3vr1NFSxQiyP+zk2mXsoMA/i/7qV6LKut1t1A==", + "license": "MIT", + "dependencies": { + "function-bind": "^1.1.2" + }, + "engines": { + "node": ">= 0.4" + } + }, + "node_modules/hoist-non-react-statics": { + "version": "3.3.2", + "resolved": "https://registry.npmjs.org/hoist-non-react-statics/-/hoist-non-react-statics-3.3.2.tgz", + "integrity": "sha512-/gGivxi8JPKWNm/W0jSmzcMPpfpPLc3dY/6GxhX2hQ9iGj3aDfklV4ET7NjKpSinLpJ5vafa9iiGIEZg10SfBw==", + "license": "BSD-3-Clause", + "dependencies": { + "react-is": "^16.7.0" + } + }, + "node_modules/hoist-non-react-statics/node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==", + "license": "MIT" + }, + "node_modules/ieee754": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz", + "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==", + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/feross" + }, + { + "type": "patreon", + "url": "https://www.patreon.com/feross" + }, + { + "type": "consulting", + "url": "https://feross.org/support" + } + ], + "license": "BSD-3-Clause" + }, + "node_modules/import-fresh": { + "version": "3.3.1", + "resolved": "https://registry.npmjs.org/import-fresh/-/import-fresh-3.3.1.tgz", + "integrity": "sha512-TR3KfrTZTYLPB6jUjfx6MF9WcWrHL9su5TObK4ZkYgBdWKPOFoSoQIdEuTuR82pmtxH2spWG9h6etwfr1pLBqQ==", + "license": "MIT", + "dependencies": { + "parent-module": "^1.0.0", + "resolve-from": "^4.0.0" + }, + "engines": { + "node": ">=6" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/is-arrayish": { + "version": "0.2.1", + "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", + "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", + "license": "MIT" + }, + "node_modules/is-core-module": { + "version": "2.16.2", + "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.16.2.tgz", + "integrity": "sha512-evOr8xfXKxE6qSR0hSXL2r3sd7ALj8+7jQEUvPYcm5sgZFdJ+AYzT6yNmJenvIYQBgIGwfwz08sL8zoL7yq2BA==", + "license": "MIT", + "dependencies": { + "hasown": "^2.0.3" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/its-fine": { + "version": "2.0.0", + "resolved": "https://registry.npmjs.org/its-fine/-/its-fine-2.0.0.tgz", + "integrity": "sha512-KLViCmWx94zOvpLwSlsx6yOCeMhZYaxrJV87Po5k/FoZzcPSahvK5qJ7fYhS61sZi5ikmh2S3Hz55A2l3U69ng==", + "license": "MIT", + "dependencies": { + "@types/react-reconciler": "^0.28.9" + }, + "peerDependencies": { + "react": "^19.0.0" + } + }, + "node_modules/js-tokens": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", + "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", + "license": "MIT" + }, + "node_modules/jsesc": { + "version": "3.1.0", + "resolved": "https://registry.npmjs.org/jsesc/-/jsesc-3.1.0.tgz", + "integrity": "sha512-/sM3dO2FOzXjKQhJuo0Q173wf2KOo8t4I8vHy6lF9poUp7bKT0/NHE8fPX23PwfhnykfqnC2xRxOnVw5XuGIaA==", + "license": "MIT", + "bin": { + "jsesc": "bin/jsesc" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/json-parse-even-better-errors": { + "version": "2.3.1", + "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", + "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", + "license": "MIT" + }, + "node_modules/lightningcss": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss/-/lightningcss-1.33.0.tgz", + "integrity": "sha512-WkUDrojuJs0xkgGf2udWxa3yGBRxPtxUkB79i6aCZLRgc7PM8fZe9TosfPDcvEpQZbuFASnHYmRLBLUbmLOIIA==", + "dev": true, + "license": "MPL-2.0", + "dependencies": { + "detect-libc": "^2.0.3" + }, + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + }, + "optionalDependencies": { + "lightningcss-android-arm64": "1.33.0", + "lightningcss-darwin-arm64": "1.33.0", + "lightningcss-darwin-x64": "1.33.0", + "lightningcss-freebsd-x64": "1.33.0", + "lightningcss-linux-arm-gnueabihf": "1.33.0", + "lightningcss-linux-arm64-gnu": "1.33.0", + "lightningcss-linux-arm64-musl": "1.33.0", + "lightningcss-linux-x64-gnu": "1.33.0", + "lightningcss-linux-x64-musl": "1.33.0", + "lightningcss-win32-arm64-msvc": "1.33.0", + "lightningcss-win32-x64-msvc": "1.33.0" + } + }, + "node_modules/lightningcss-android-arm64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-android-arm64/-/lightningcss-android-arm64-1.33.0.tgz", + "integrity": "sha512-gEpRTalKdosp4Bb8qWtc2iOgE5SeIHlpS1up9bFq2wAyYhl1UdTObYiHe98zEM9SQvSoqQZ1IQD0JNpg3Ml5pg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "android" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-arm64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-arm64/-/lightningcss-darwin-arm64-1.33.0.tgz", + "integrity": "sha512-Sciaz8eenNTKn9b3t7+xr0ipTp9YxKQY4npwQ3mrRuL0BAVHBLyZxofhaKBAVtzmtRZ/zTyo0/to4B1uWG/Djg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-darwin-x64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-darwin-x64/-/lightningcss-darwin-x64-1.33.0.tgz", + "integrity": "sha512-Z5UPAxzrjlWNNyGy6i65cJzzvgJ5D3T6wMvs+gWpY9d7qRhANrxqAp6LhxIgZhWEw18RfJTGcRxjuLIBr+m8XQ==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "darwin" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-freebsd-x64": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-freebsd-x64/-/lightningcss-freebsd-x64-1.33.0.tgz", + "integrity": "sha512-QQM/Ti/hQajJwCY+RiWuCZ9sdtI/XQk7nDK5vC8kkdwixezOlDgvDx7+RT+QjK6FcFT4MpsuoBnHIo/O3StRRg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "freebsd" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm-gnueabihf": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm-gnueabihf/-/lightningcss-linux-arm-gnueabihf-1.33.0.tgz", + "integrity": "sha512-N7FVBe6iS24MlM6R/4RBTxGhQheZGs7tiQ9U32UtF75NzP5Q7xWPRqLBCKxlRQRk3rY1jCIPLzx7WzOhuUIRLQ==", + "cpu": [ + "arm" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-gnu": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-gnu/-/lightningcss-linux-arm64-gnu-1.33.0.tgz", + "integrity": "sha512-j2v/itmy4HlNxlc6voKXYgBqNi0Ng2LShg4z7GufpEgs05P+2suBVyi9I6YHq5uoVFx9ETin3eCEhLVyXGQnKg==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-arm64-musl": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-arm64-musl/-/lightningcss-linux-arm64-musl-1.33.0.tgz", + "integrity": "sha512-yiO5ROMuYQgXbC60yjZU5CYSFZGKXL0HFATXt9mHJn1+zW55oCtMI9NfcVhYLMFDL7gV7oBPon/EmMMGg2OvtQ==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-gnu": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-gnu/-/lightningcss-linux-x64-gnu-1.33.0.tgz", + "integrity": "sha512-ar+Ju7LmcN0Jo4FpL4hpFybwNG9/3A/Br5KW2n2jyODg3MEZXaDYADdemoNS+BDNfMgKvylJLj4S5tyRActuAg==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-linux-x64-musl": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-linux-x64-musl/-/lightningcss-linux-x64-musl-1.33.0.tgz", + "integrity": "sha512-RYiYbkokw0trfKqqzfF55lginwEPrD3OJDfTuJzFs1MK6iFnDenaz1fqLLtX4ITG3OktJQXOeTaw1awrBAlZPw==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "linux" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-arm64-msvc": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-arm64-msvc/-/lightningcss-win32-arm64-msvc-1.33.0.tgz", + "integrity": "sha512-1K+MPfLSFVpphzpdbfkhlWk6wBrTObBzS2T6db10PNOZgR9GoVsAWzwNyuhUYYbTp23j+4RrncfujZ4uAzXvwA==", + "cpu": [ + "arm64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lightningcss-win32-x64-msvc": { + "version": "1.33.0", + "resolved": "https://registry.npmjs.org/lightningcss-win32-x64-msvc/-/lightningcss-win32-x64-msvc-1.33.0.tgz", + "integrity": "sha512-OlEICDx/Xl0FqSp4bry8zFnCvGpig3Gl4gCquvYwHuqJKEC1+n9NgDniFvqHGmMv1ZkqDJrDqKKSykTDX+ehuA==", + "cpu": [ + "x64" + ], + "dev": true, + "license": "MPL-2.0", + "optional": true, + "os": [ + "win32" + ], + "engines": { + "node": ">= 12.0.0" + }, + "funding": { + "type": "opencollective", + "url": "https://opencollective.com/parcel" + } + }, + "node_modules/lines-and-columns": { + "version": "1.2.4", + "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", + "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", + "license": "MIT" + }, + "node_modules/loose-envify": { + "version": "1.4.0", + "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz", + "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==", + "license": "MIT", + "dependencies": { + "js-tokens": "^3.0.0 || ^4.0.0" + }, + "bin": { + "loose-envify": "cli.js" + } + }, + "node_modules/ms": { + "version": "2.1.3", + "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz", + "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==", + "license": "MIT" + }, + "node_modules/nanoid": { + "version": "3.3.18", + "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.18.tgz", + "integrity": "sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==", + "dev": true, + "funding": [ + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "bin": { + "nanoid": "bin/nanoid.cjs" + }, + "engines": { + "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1" + } + }, + "node_modules/object-assign": { + "version": "4.1.1", + "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz", + "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==", + "license": "MIT", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/parent-module": { + "version": "1.0.1", + "resolved": "https://registry.npmjs.org/parent-module/-/parent-module-1.0.1.tgz", + "integrity": "sha512-GQ2EWRpQV8/o+Aw8YqtfZZPfNRWZYkbidE9k5rpl/hC3vtHHBfGm2Ifi6qWV+coDGkrUKZAxE3Lot5kcsRlh+g==", + "license": "MIT", + "dependencies": { + "callsites": "^3.0.0" + }, + "engines": { + "node": ">=6" + } + }, + "node_modules/parse-json": { + "version": "5.2.0", + "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", + "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", + "license": "MIT", + "dependencies": { + "@babel/code-frame": "^7.0.0", + "error-ex": "^1.3.1", + "json-parse-even-better-errors": "^2.3.0", + "lines-and-columns": "^1.1.6" + }, + "engines": { + "node": ">=8" + }, + "funding": { + "url": "https://github.com/sponsors/sindresorhus" + } + }, + "node_modules/path-parse": { + "version": "1.0.7", + "resolved": "https://registry.npmjs.org/path-parse/-/path-parse-1.0.7.tgz", + "integrity": "sha512-LDJzPVEEEPR+y48z93A0Ed0yXb8pAByGWo/k5YYdYgpY2/2EsOsksJrq7lOHxryrVOn1ejG6oAp8ahvOIQD8sw==", + "license": "MIT" + }, + "node_modules/path-type": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/path-type/-/path-type-4.0.0.tgz", + "integrity": "sha512-gDKb8aZMDeD/tZWs9P6+q0J9Mwkdl6xMV8TjnGP3qJVJ06bdMgkbBlLU8IdfOsIsFz2BW1rNVT3XuNEl8zPAvw==", + "license": "MIT", + "engines": { + "node": ">=8" + } + }, + "node_modules/picocolors": { + "version": "1.1.1", + "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz", + "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==", + "license": "ISC" + }, + "node_modules/picomatch": { + "version": "4.0.5", + "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz", + "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==", + "dev": true, + "license": "MIT", + "peer": true, + "engines": { + "node": ">=12" + }, + "funding": { + "url": "https://github.com/sponsors/jonschlinkert" + } + }, + "node_modules/postcss": { + "version": "8.5.26", + "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.26.tgz", + "integrity": "sha512-u82N74LFzG8ca+dD8puPnplTXoGH4fTPpVGuIbt36G3qvNlkvfD0lEAZSxaly3KX8TS/L1A1gsCEmvKmBcVbkQ==", + "dev": true, + "funding": [ + { + "type": "opencollective", + "url": "https://opencollective.com/postcss/" + }, + { + "type": "tidelift", + "url": "https://tidelift.com/funding/github/npm/postcss" + }, + { + "type": "github", + "url": "https://github.com/sponsors/ai" + } + ], + "license": "MIT", + "dependencies": { + "nanoid": "^3.3.17", + "picocolors": "^1.1.1", + "source-map-js": "^1.2.1" + }, + "engines": { + "node": "^10 || ^12 || >=14" + } + }, + "node_modules/prop-types": { + "version": "15.8.1", + "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz", + "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==", + "license": "MIT", + "dependencies": { + "loose-envify": "^1.4.0", + "object-assign": "^4.1.1", + "react-is": "^16.13.1" + } + }, + "node_modules/prop-types/node_modules/react-is": { + "version": "16.13.1", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz", + "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==", + "license": "MIT" + }, + "node_modules/react": { + "version": "19.2.8", + "resolved": "https://registry.npmjs.org/react/-/react-19.2.8.tgz", + "integrity": "sha512-PWaYA1L/q9u2u7xYQi+Y3L3Yfnie7XyLeaJICV1MGD6LprsBxcAqGjYyr0eY3p+QdsA+x/Irkt4Qif8D63+Sbw==", + "license": "MIT", + "peer": true, + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/react-dom": { + "version": "19.2.8", + "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-19.2.8.tgz", + "integrity": "sha512-rVprimfGBG3DR+Tq0IQG2DT5PxKth1WIGDmj5yPmlzr4YBe7uyE+Du4oVqTDXZSHGGGXRtTJEGSSePyQCMBglQ==", + "license": "MIT", + "peer": true, + "dependencies": { + "scheduler": "^0.27.0" + }, + "peerDependencies": { + "react": "^19.2.8" + } + }, + "node_modules/react-is": { + "version": "19.2.8", + "resolved": "https://registry.npmjs.org/react-is/-/react-is-19.2.8.tgz", + "integrity": "sha512-s5un28nYxKJw5gvUHyW5PCC28CvBqLu9r3cWgzHT4Vo/5fqqkFcdRYsGcKf50WMPpjjFZS5d76fn3YCo2njKwQ==", + "license": "MIT" + }, + "node_modules/react-transition-group": { + "version": "4.4.5", + "resolved": "https://registry.npmjs.org/react-transition-group/-/react-transition-group-4.4.5.tgz", + "integrity": "sha512-pZcd1MCJoiKiBR2NRxeCRg13uCXbydPnmB4EOeRrY7480qNWO8IIgQG6zlDkm6uRMsURXPuKq0GWtiM59a5Q6g==", + "license": "BSD-3-Clause", + "dependencies": { + "@babel/runtime": "^7.5.5", + "dom-helpers": "^5.0.1", + "loose-envify": "^1.4.0", + "prop-types": "^15.6.2" + }, + "peerDependencies": { + "react": ">=16.6.0", + "react-dom": ">=16.6.0" + } + }, + "node_modules/react-use-measure": { + "version": "2.1.7", + "resolved": "https://registry.npmjs.org/react-use-measure/-/react-use-measure-2.1.7.tgz", + "integrity": "sha512-KrvcAo13I/60HpwGO5jpW7E9DfusKyLPLvuHlUyP5zqnmAPhNc6qTRjUQrdTADl0lpPpDVU2/Gg51UlOGHXbdg==", + "license": "MIT", + "peerDependencies": { + "react": ">=16.13", + "react-dom": ">=16.13" + }, + "peerDependenciesMeta": { + "react-dom": { + "optional": true + } + } + }, + "node_modules/resolve": { + "version": "1.22.12", + "resolved": "https://registry.npmjs.org/resolve/-/resolve-1.22.12.tgz", + "integrity": "sha512-TyeJ1zif53BPfHootBGwPRYT1RUt6oGWsaQr8UyZW/eAm9bKoijtvruSDEmZHm92CwS9nj7/fWttqPCgzep8CA==", + "license": "MIT", + "dependencies": { + "es-errors": "^1.3.0", + "is-core-module": "^2.16.1", + "path-parse": "^1.0.7", + "supports-preserve-symlinks-flag": "^1.0.0" + }, + "bin": { + "resolve": "bin/resolve" + }, + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/resolve-from": { + "version": "4.0.0", + "resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz", + "integrity": "sha512-pb/MYmXstAkysRFx8piNI1tGFNQIFA3vkE3Gq4EuA1dF6gHp/+vgZqsCGJapvy8N3Q+4o7FwvquPJcnZ7RYy4g==", + "license": "MIT", + "engines": { + "node": ">=4" + } + }, + "node_modules/rolldown": { + "version": "1.2.5", + "resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.2.5.tgz", + "integrity": "sha512-VD2IE5PUG4Oj8zz2VGykiYd5wbnjdIiSsNQb8Qu5B+noEp+A78mu2iVvpp27g8es14Tk9rofNs5Tku9iQCS4fA==", + "dev": true, + "license": "MIT", + "dependencies": { + "@oxc-project/types": "=0.146.0", + "@rolldown/pluginutils": "^1.0.0" + }, + "bin": { + "rolldown": "bin/cli.mjs" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "optionalDependencies": { + "@rolldown/binding-android-arm-eabi": "1.2.5", + "@rolldown/binding-android-arm64": "1.2.5", + "@rolldown/binding-darwin-arm64": "1.2.5", + "@rolldown/binding-darwin-x64": "1.2.5", + "@rolldown/binding-freebsd-x64": "1.2.5", + "@rolldown/binding-linux-arm-gnueabihf": "1.2.5", + "@rolldown/binding-linux-arm64-gnu": "1.2.5", + "@rolldown/binding-linux-arm64-musl": "1.2.5", + "@rolldown/binding-linux-ppc64-gnu": "1.2.5", + "@rolldown/binding-linux-s390x-gnu": "1.2.5", + "@rolldown/binding-linux-x64-gnu": "1.2.5", + "@rolldown/binding-linux-x64-musl": "1.2.5", + "@rolldown/binding-openharmony-arm64": "1.2.5", + "@rolldown/binding-win32-arm64-msvc": "1.2.5", + "@rolldown/binding-win32-x64-msvc": "1.2.5" + } + }, + "node_modules/scheduler": { + "version": "0.27.0", + "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.27.0.tgz", + "integrity": "sha512-eNv+WrVbKu1f3vbYJT/xtiF5syA5HPIMtf9IgY/nKg0sWqzAUEvqY/xm7OcZc/qafLx/iO9FgOmeSAp4v5ti/Q==", + "license": "MIT" + }, + "node_modules/source-map": { + "version": "0.5.7", + "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.5.7.tgz", + "integrity": "sha512-LbrmJOMUSdEVxIKvdcJzQC+nQhe8FUZQTXQy6+I75skNgn3OoQ0DZA8YnFa7gp8tqtL3KPf1kmo0R5DoApeSGQ==", + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/source-map-js": { + "version": "1.2.1", + "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz", + "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==", + "dev": true, + "license": "BSD-3-Clause", + "engines": { + "node": ">=0.10.0" + } + }, + "node_modules/stylis": { + "version": "4.2.0", + "resolved": "https://registry.npmjs.org/stylis/-/stylis-4.2.0.tgz", + "integrity": "sha512-Orov6g6BB1sDfYgzWfTHDOxamtX1bE/zo104Dh9e6fqJ3PooipYyfJ0pUmrZO2wAvO8YbEyeFrkV91XTsGMSrw==", + "license": "MIT" + }, + "node_modules/supports-preserve-symlinks-flag": { + "version": "1.0.0", + "resolved": "https://registry.npmjs.org/supports-preserve-symlinks-flag/-/supports-preserve-symlinks-flag-1.0.0.tgz", + "integrity": "sha512-ot0WnXS9fgdkgIcePe6RHNk1WA8+muPa6cSjeR3V8K27q9BB1rTE3R1p7Hv0z1ZyAc8s6Vvv8DIyWf681MAt0w==", + "license": "MIT", + "engines": { + "node": ">= 0.4" + }, + "funding": { + "url": "https://github.com/sponsors/ljharb" + } + }, + "node_modules/suspend-react": { + "version": "0.1.3", + "resolved": "https://registry.npmjs.org/suspend-react/-/suspend-react-0.1.3.tgz", + "integrity": "sha512-aqldKgX9aZqpoDp3e8/BZ8Dm7x1pJl+qI3ZKxDN0i/IQTWUwBx/ManmlVJ3wowqbno6c2bmiIfs+Um6LbsjJyQ==", + "license": "MIT", + "peerDependencies": { + "react": ">=17.0" + } + }, + "node_modules/three": { + "version": "0.164.1", + "resolved": "https://registry.npmjs.org/three/-/three-0.164.1.tgz", + "integrity": "sha512-iC/hUBbl1vzFny7f5GtqzVXYjMJKaTPxiCxXfrvVdBi1Sf+jhd1CAkitiFwC7mIBFCo3MrDLJG97yisoaWig0w==", + "license": "MIT", + "peer": true + }, + "node_modules/tinyglobby": { + "version": "0.2.17", + "resolved": "https://registry.npmjs.org/tinyglobby/-/tinyglobby-0.2.17.tgz", + "integrity": "sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==", + "dev": true, + "license": "MIT", + "dependencies": { + "fdir": "^6.5.0", + "picomatch": "^4.0.4" + }, + "engines": { + "node": ">=12.0.0" + }, + "funding": { + "url": "https://github.com/sponsors/SuperchupuDev" + } + }, + "node_modules/use-sync-external-store": { + "version": "1.6.0", + "resolved": "https://registry.npmjs.org/use-sync-external-store/-/use-sync-external-store-1.6.0.tgz", + "integrity": "sha512-Pp6GSwGP/NrPIrxVFAIkOQeyw8lFenOHijQWkUTrDvrF4ALqylP2C/KCkeS9dpUM3KvYRQhna5vt7IL95+ZQ9w==", + "license": "MIT", + "peerDependencies": { + "react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0" + } + }, + "node_modules/vite": { + "version": "8.2.2", + "resolved": "https://registry.npmjs.org/vite/-/vite-8.2.2.tgz", + "integrity": "sha512-cFKLV/PRgAUlIRm5WjMjJ86jrftzpqcgH+Us+DS8mI3CDNiH30Whrz8uHL3+MOLPAgqbMBAqWdAHAphOAM+z/Q==", + "dev": true, + "license": "MIT", + "peer": true, + "dependencies": { + "lightningcss": "^1.33.0", + "picomatch": "^4.0.5", + "postcss": "^8.5.26", + "rolldown": "~1.2.4", + "tinyglobby": "^0.2.17" + }, + "bin": { + "vite": "bin/vite.js" + }, + "engines": { + "node": "^20.19.0 || >=22.12.0" + }, + "funding": { + "url": "https://github.com/vitejs/vite?sponsor=1" + }, + "optionalDependencies": { + "fsevents": "~2.3.3" + }, + "peerDependencies": { + "@types/node": "^20.19.0 || >=22.12.0", + "@vitejs/devtools": "^0.4.0 || ^0.5.0", + "esbuild": "^0.27.0 || ^0.28.0", + "jiti": ">=1.21.0", + "less": "^4.0.0", + "sass": "^1.70.0", + "sass-embedded": "^1.70.0", + "stylus": ">=0.54.8", + "sugarss": "^5.0.0", + "terser": "^5.16.0", + "tsx": "^4.8.1", + "yaml": "^2.4.2" + }, + "peerDependenciesMeta": { + "@types/node": { + "optional": true + }, + "@vitejs/devtools": { + "optional": true + }, + "esbuild": { + "optional": true + }, + "jiti": { + "optional": true + }, + "less": { + "optional": true + }, + "sass": { + "optional": true + }, + "sass-embedded": { + "optional": true + }, + "stylus": { + "optional": true + }, + "sugarss": { + "optional": true + }, + "terser": { + "optional": true + }, + "tsx": { + "optional": true + }, + "yaml": { + "optional": true + } + } + }, + "node_modules/zustand": { + "version": "5.0.15", + "resolved": "https://registry.npmjs.org/zustand/-/zustand-5.0.15.tgz", + "integrity": "sha512-MpSEjRiBkA9crSYeOUH32rJC7SVqAbm0Fqcqge/bUi2PPoLcBWKOsG+C8mevmpr8TwXHBVkChbbJiyvkE+i/3A==", + "license": "MIT", + "engines": { + "node": ">=12.20.0" + }, + "peerDependencies": { + "@types/react": ">=18.0.0", + "immer": ">=9.0.6", + "react": ">=18.0.0", + "use-sync-external-store": ">=1.2.0" + }, + "peerDependenciesMeta": { + "@types/react": { + "optional": true + }, + "immer": { + "optional": true + }, + "react": { + "optional": true + }, + "use-sync-external-store": { + "optional": true + } + } + } + } +} diff --git a/app/package.json b/app/package.json new file mode 100644 index 0000000..2eae818 --- /dev/null +++ b/app/package.json @@ -0,0 +1,25 @@ +{ + "name": "microduck-sandbox", + "private": true, + "version": "1.0.0", + "type": "module", + "scripts": { + "dev": "vite", + "build": "vite build", + "preview": "vite preview" + }, + "dependencies": { + "@emotion/react": "^11.14.0", + "@emotion/styled": "^11.14.1", + "@mui/material": "^9.3.1", + "@react-three/fiber": "^9.7.0", + "react": "^19.2.8", + "react-dom": "^19.2.8", + "three": "^0.164.1", + "zustand": "^5.0.15" + }, + "devDependencies": { + "@vitejs/plugin-react": "^6.1.0", + "vite": "^8.2.2" + } +} diff --git a/app/public/assets b/app/public/assets new file mode 120000 index 0000000..41aef43 --- /dev/null +++ b/app/public/assets @@ -0,0 +1 @@ +../../assets \ No newline at end of file diff --git a/app/public/policies b/app/public/policies new file mode 120000 index 0000000..aae576c --- /dev/null +++ b/app/public/policies @@ -0,0 +1 @@ +../../policies \ No newline at end of file diff --git a/app/public/robot b/app/public/robot new file mode 120000 index 0000000..afbd639 --- /dev/null +++ b/app/public/robot @@ -0,0 +1 @@ +../../robot \ No newline at end of file diff --git a/app/src/App.jsx b/app/src/App.jsx new file mode 100644 index 0000000..f1cc288 --- /dev/null +++ b/app/src/App.jsx @@ -0,0 +1,87 @@ +// App shell: layers in z order - scene canvas (1), halftone (2), CRT (5), +// HUD + touch overlay (9-12), BIOS readout (20), title menu (30), preboot +// veil (40). Also owns the pre-game device detection (gamepad, touch) and +// the preboot -> title -> enter flow. +import { useEffect } from "react"; +import GameCanvas from "./scene/GameCanvas.jsx"; +import { Halftone, CrtOverlay } from "./ui/Overlays.jsx"; +import Hud from "./ui/Hud.jsx"; +import TouchOverlay from "./ui/TouchOverlay.jsx"; +import BiosOverlay from "./ui/BiosOverlay.jsx"; +import TitleMenu from "./ui/TitleMenu.jsx"; +import Preboot from "./ui/Preboot.jsx"; +import { useGame } from "./store.js"; +import { signed } from "./game/signed.js"; + +export default function App() { + useEffect(() => { + const params = new URLSearchParams(location.search); + + // Gamepad presence for the tutorial variant, before the game controller + // takes over polling (the game loop keeps mirroring it afterwards). + const pollPad = () => { + const gp = [...(navigator.getGamepads?.() ?? [])].find((p) => p && p.connected); + useGame.setState({ padConnected: !!gp }); + }; + window.addEventListener("gamepadconnected", pollPad); + window.addEventListener("gamepaddisconnected", pollPad); + pollPad(); + + // Touch detection, latching: (pointer: coarse) OR any real touch proves + // the device (DevTools device modes and hybrid laptops often fail the + // media query). __microduckTouched hands the proof to controls/touch.js + // which boots later. ?touch=1 forces the thumbs on any device. + const coarse = matchMedia("(pointer: coarse)"); + const armTouch = () => { + window.__microduckTouched = true; + useGame.setState({ touchMode: true }); + }; + const onCoarse = () => coarse.matches && armTouch(); + if (coarse.matches) armTouch(); + else coarse.addEventListener("change", onCoarse); + window.addEventListener("touchstart", armTouch, { once: true, passive: true }); + if (params.get("touch") === "1") armTouch(); + + // Preboot veil: hold the title page until its logo and the fonts are + // in (grey spinner meanwhile), capped so a broken asset can never wall + // the menu off. ?boot=1 skips the title entirely - testing hook. + if (params.get("boot") === "1") { + useGame.setState({ prebootDone: true, entered: true, menuOpen: false }); + } else { + const img = new Image(); + img.src = signed("./assets/duck-head-mark.webp"); + const imgReady = new Promise((res) => { + if (img.complete && img.naturalWidth) res(); + else { + img.addEventListener("load", res, { once: true }); + img.addEventListener("error", res, { once: true }); + } + }); + const fontsReady = document.fonts?.ready ?? Promise.resolve(); + const cap = new Promise((res) => setTimeout(res, 2500)); + Promise.race([Promise.all([imgReady, fontsReady]), cap]).then(() => { + useGame.setState({ prebootDone: true, menuOpen: true }); + }); + } + + return () => { + window.removeEventListener("gamepadconnected", pollPad); + window.removeEventListener("gamepaddisconnected", pollPad); + coarse.removeEventListener("change", onCoarse); + window.removeEventListener("touchstart", armTouch); + }; + }, []); + + return ( + <> + + + + + + + + + + ); +} diff --git a/app/src/game/arena.js b/app/src/game/arena.js new file mode 100644 index 0000000..cb42210 --- /dev/null +++ b/app/src/game/arena.js @@ -0,0 +1,235 @@ +// Arena visuals: the infinite Tron grid floor and the four wall grid +// planes, ported verbatim from the pre-React rl.js. Both carry a uReveal +// uniform for the entrance draw-in (driven by ceremony.js). +import * as THREE from "three"; +import { ARENA_HALF, ARENA_WALL_H, ARENA_WALL_T, GRID_SECTION } from "./constants.js"; + +// Infinite shader grid, ported from drei's : anti-aliased world-space +// lines at cell/section frequencies with a radial fade around the duck. +// Lines derive from world coordinates, so re-centering the mesh under the +// camera target every frame makes the grid effectively infinite without any +// visible swimming. +export function makeInfiniteGrid() { + const material = new THREE.ShaderMaterial({ + transparent: true, + depthWrite: false, + uniforms: { + uCell: { value: 0.1 }, + uSection: { value: GRID_SECTION }, + uCellColor: { value: new THREE.Color(0x8e8371) }, + uSectionColor: { value: new THREE.Color(0xffb366) }, + uFadeDist: { value: 3.0 }, + uFocus: { value: new THREE.Vector3() }, + // Entrance draw-in progress; 1 = steady state (branch skipped). + // Starts at 0: the world stays hidden behind the welcome modal and + // the BIOS readout until playBios cues startEntrance. + uReveal: { value: 0.0 }, + }, + vertexShader: /* glsl */ ` + varying vec3 vWorld; + void main() { + vec4 w = modelMatrix * vec4(position, 1.0); + vWorld = w.xyz; + gl_Position = projectionMatrix * viewMatrix * w; + } + `, + fragmentShader: /* glsl */ ` + varying vec3 vWorld; + uniform float uCell, uSection, uFadeDist, uReveal; + uniform vec3 uCellColor, uSectionColor, uFocus; + // Tron-style line: a thicker antialiased core plus a faint, much + // wider halo added on top (squared falloff keeps it a whisper of a + // glow rather than a bloom wash). + float lineProf(float g) { + float core = 1.0 - smoothstep(0.0, 1.8, g); + float halo = 1.0 - smoothstep(0.0, 7.0, g); + return core + halo * halo * 0.22; + } + float gridLine(vec2 p, float size) { + vec2 r = p / size; + vec2 g = abs(fract(r - 0.5) - 0.5) / fwidth(r); + return lineProf(min(g.x, g.y)); + } + // Entrance draw-in: one family of parallel lines, drawn line by line. + // id picks the line, "along" runs down its length. Each line waits + // out its own hashed delay, then extends from the origin outward with + // a hard front. Returns (mask, head): head marks the bright segment + // right behind the draw front while the line is still growing. + vec2 drawLine(float id, float along, float t0, float spread, float dur, float maxLen) { + float jit = fract(sin(id * 127.1) * 43758.5453); + float grow = clamp((uReveal - t0 - jit * spread) / dur, 0.0, 1.0); + float len = grow * maxLen; + float a = abs(along); + float mask = 1.0 - smoothstep(len - 0.05, len, a); + float head = (1.0 - smoothstep(0.0, 0.6, len - a)) * mask + * step(0.001, grow) * (1.0 - step(0.999, grow)); + return vec2(mask, head); + } + void main() { + float cell = gridLine(vWorld.xz, uCell); + // Section lattice shifted half a cell: with 5 sections across the + // 3 m arena (odd count) this centers a CELL on the origin and puts + // section lines exactly on the walls at +-1.5. + vec2 pSec = vWorld.xz + 0.5 * uSection; + float section = gridLine(pSec, uSection); + float d = distance(vWorld.xz, uFocus.xz); + float fade = pow(clamp(1.0 - d / uFadeDist, 0.0, 1.0), 1.6); + vec3 col = mix(uCellColor, uSectionColor, clamp(section, 0.0, 1.0)); + float alpha = min(max(section * 0.6, cell * 0.4) * fade, 1.0); + // Entrance: only the bright section lines get the line-by-line draw + // (staggered, with a hot draw head); the fine cells just fade in + // over the reveal's second half - drawing every small line reads as + // visual noise. lineProf(min(gx, gy)) == max of per-axis profiles + // (profile is monotonic) and the cell fade lands on exactly the + // steady-state cell term, so at uReveal 1 this branch equals the + // formula above exactly (and is skipped). + if (uReveal < 1.0) { + vec2 rs = pSec / uSection; + vec2 gs = abs(fract(rs - 0.5) - 0.5) / fwidth(rs); + // Const-x lines run along z and vice versa; the offset + // decorrelates the two families' hashed delays. + vec2 sx = drawLine(floor(rs.x + 0.5), vWorld.z, 0.00, 0.30, 0.35, 8.0); + vec2 sz = drawLine(floor(rs.y + 0.5) + 57.0, vWorld.x, 0.05, 0.30, 0.35, 8.0); + float secR = max(lineProf(gs.x) * sx.x, lineProf(gs.y) * sz.x); + float cellR = cell * smoothstep(0.5, 1.0, uReveal); + float headGlow = max(lineProf(gs.x) * sx.y, lineProf(gs.y) * sz.y); + col = mix(uCellColor, uSectionColor, clamp(secR, 0.0, 1.0)); + alpha = min(max(secR * 0.6, cellR * 0.4) * fade, 1.0); + // Bright draw head: a short white-hot tip sells the "drawing" read. + headGlow = clamp(headGlow, 0.0, 1.0); + col = mix(col, vec3(1.0, 0.86, 0.55), headGlow * 0.8); + alpha = min(alpha + headGlow * fade * 0.5, 1.0); + } + if (alpha < 0.004) discard; + gl_FragColor = vec4(col, alpha); + } + `, + }); + const mesh = new THREE.Mesh(new THREE.PlaneGeometry(30, 30), material); + mesh.rotation.x = -Math.PI / 2; + return mesh; +} + +// Arena walls, drawn in the same grid language as the floor: identical +// cell/section lines from world coordinates, same radial fade around the +// duck, plus a vertical fade toward the top edge so the walls read as a +// light enclosure instead of solid slabs. +function makeWallGridMaterial(alongX) { + return new THREE.ShaderMaterial({ + transparent: true, + depthWrite: false, + side: THREE.DoubleSide, + uniforms: { + uCell: { value: 0.1 }, + uSection: { value: GRID_SECTION }, + uCellColor: { value: new THREE.Color(0x8e8371) }, + uSectionColor: { value: new THREE.Color(0xffb366) }, + // Gentler radial fade than the floor: the walls sit 1.5+ m from the + // duck by construction and would vanish with the floor's 3 m fade. + uFadeDist: { value: 5.0 }, + uFocus: { value: new THREE.Vector3() }, + uWallH: { value: ARENA_WALL_H }, + uAlongX: { value: alongX ? 1.0 : 0.0 }, + // Entrance draw-in progress; 1 = steady state (branch skipped). + // Starts at 0, same as the floor grid: hidden until startEntrance. + uReveal: { value: 0.0 }, + }, + vertexShader: /* glsl */ ` + varying vec3 vWorld; + void main() { + vec4 w = modelMatrix * vec4(position, 1.0); + vWorld = w.xyz; + gl_Position = projectionMatrix * viewMatrix * w; + } + `, + fragmentShader: /* glsl */ ` + varying vec3 vWorld; + uniform float uCell, uSection, uFadeDist, uWallH, uAlongX, uReveal; + uniform vec3 uCellColor, uSectionColor, uFocus; + // Same Tron-style core + faint halo as the floor grid. + float lineProf(float g) { + float core = 1.0 - smoothstep(0.0, 1.8, g); + float halo = 1.0 - smoothstep(0.0, 7.0, g); + return core + halo * halo * 0.22; + } + float gridLine(vec2 p, float size) { + vec2 r = p / size; + vec2 g = abs(fract(r - 0.5) - 0.5) / fwidth(r); + return lineProf(min(g.x, g.y)); + } + // Same line-by-line draw as the floor grid (see its comments). + vec2 drawLine(float id, float along, float t0, float spread, float dur, float maxLen) { + float jit = fract(sin(id * 127.1) * 43758.5453); + float grow = clamp((uReveal - t0 - jit * spread) / dur, 0.0, 1.0); + float len = grow * maxLen; + float a = abs(along); + float mask = 1.0 - smoothstep(len - 0.05, len, a); + float head = (1.0 - smoothstep(0.0, 0.35, len - a)) * mask + * step(0.001, grow) * (1.0 - step(0.999, grow)); + return vec2(mask, head); + } + void main() { + // Wall surface coords: the in-plane horizontal world axis + height. + float h = mix(vWorld.z, vWorld.x, uAlongX); + vec2 p = vec2(h, vWorld.y); + float cell = gridLine(p, uCell); + // Horizontal axis shifted half a section to match the floor's odd + // lattice (vertical section lines meet the floor's at the base); + // the height axis keeps its base line at y = 0. + vec2 pSec = vec2(p.x + 0.5 * uSection, p.y); + float section = gridLine(pSec, uSection); + float d = distance(vWorld.xz, uFocus.xz); + float fade = pow(clamp(1.0 - d / uFadeDist, 0.0, 1.0), 1.6); + float vert = 1.0 - clamp(vWorld.y / uWallH, 0.0, 1.0); + vec3 col = mix(uCellColor, uSectionColor, clamp(section, 0.0, 1.0)); + float alpha = min(max(section * 0.9, cell * 0.6) * fade * (0.3 + 0.7 * vert), 1.0); + // Entrance: section lines only - horizontals zip out from the + // wall's center, verticals rise from the ground, each with a + // hashed delay; the fine cells fade in over the reveal's second + // half. Same steady-state equivalence argument as the floor grid. + if (uReveal < 1.0) { + vec2 rs = pSec / uSection; + vec2 gs = abs(fract(rs - 0.5) - 0.5) / fwidth(rs); + // Const-height lines run along h (grow from center outward); + // const-h lines run along y (grow up from the ground). + vec2 sh = drawLine(floor(rs.y + 0.5), p.x, 0.00, 0.30, 0.40, 2.0); + vec2 sv = drawLine(floor(rs.x + 0.5) + 31.0, p.y, 0.30, 0.30, 0.30, uWallH); + float secR = max(lineProf(gs.y) * sh.x, lineProf(gs.x) * sv.x); + float cellR = cell * smoothstep(0.5, 1.0, uReveal); + float headGlow = max(lineProf(gs.y) * sh.y, lineProf(gs.x) * sv.y); + col = mix(uCellColor, uSectionColor, clamp(secR, 0.0, 1.0)); + alpha = min(max(secR * 0.9, cellR * 0.6) * fade * (0.3 + 0.7 * vert), 1.0); + headGlow = clamp(headGlow, 0.0, 1.0); + col = mix(col, vec3(1.0, 0.86, 0.55), headGlow * 0.8); + alpha = min(alpha + headGlow * fade * 0.5, 1.0); + } + if (alpha < 0.004) discard; + gl_FragColor = vec4(col, alpha); + } + `, + }); +} + +// The four wall planes at their inner faces (three coords: MJCF x -> x, +// MJCF y -> -z). Returns the meshes plus their materials (the ceremony and +// the per-frame focus update both need the material list). +export function makeArenaWalls() { + const wallMats = []; + const wallMeshes = []; + const wallLen = 2 * (ARENA_HALF + ARENA_WALL_T); + const wallDefs = [ + { x: ARENA_HALF, z: 0, rotY: -Math.PI / 2, alongX: false }, + { x: -ARENA_HALF, z: 0, rotY: Math.PI / 2, alongX: false }, + { x: 0, z: ARENA_HALF, rotY: Math.PI, alongX: true }, + { x: 0, z: -ARENA_HALF, rotY: 0, alongX: true }, + ]; + for (const w of wallDefs) { + const mat = makeWallGridMaterial(w.alongX); + wallMats.push(mat); + const mesh = new THREE.Mesh(new THREE.PlaneGeometry(wallLen, ARENA_WALL_H), mat); + mesh.position.set(w.x, ARENA_WALL_H / 2, w.z); + mesh.rotation.y = w.rotY; + wallMeshes.push(mesh); + } + return { wallMats, wallMeshes }; +} diff --git a/app/src/game/ball-actor.js b/app/src/game/ball-actor.js new file mode 100644 index 0000000..62b1739 --- /dev/null +++ b/app/src/game/ball-actor.js @@ -0,0 +1,102 @@ +// Ball actor: physics stays in rl.js, this owns the mesh + wireframe FX. +// +// visual: +// hidden parked, mesh off +// live following qpos, optional appear scan playing +// ghost physics already parked; mesh frozen at last pose while the +// reverse scan peels it away +// +// spawn while live/ghost queues a pop: despawn finishes, then the caller +// places physics and appear()s. + +// Appear/disappear speed. The shared wireframe FX timeline lasts +// fx.TOTAL_S (0.9 s, tuned for the duck's ceremony); the ball plays the +// same timeline time-scaled to these snappier durations. +const BALL_APPEAR_S = 0.35; // spawn pop-in (scan up) +const BALL_DISAPPEAR_S = 0.25; // despawn/park peel-away (reverse scan) + +export function createBallActor({ THREE, scene, camera, renderer, fxModule, mesh, group }) { + const fx = fxModule.createWireframeFx(); + fx.init({ THREE, scene, root: group, camera, renderer, hidden: false }); + + let visual = "hidden"; // hidden | live | ghost + let ghost = null; + let pendingSpawn = false; + let fxPrev = null; + + function appear() { + visual = "live"; + ghost = null; + mesh.visible = true; + fx.start(); + fxPrev = performance.now(); + } + + function despawn({ cancelQueued = false, parkPhysics }) { + if (cancelQueued) pendingSpawn = false; + if (visual === "hidden") return; + if (visual === "live") { + ghost = { + pos: mesh.position.clone(), + quat: mesh.quaternion.clone(), + }; + visual = "ghost"; + } + parkPhysics(); + fx.startReverse(); + fxPrev = performance.now(); + } + + function queueRespawn() { + pendingSpawn = true; + } + + function poseFromQpos(qpos, adr) { + mesh.position.set(qpos[adr], qpos[adr + 1], qpos[adr + 2]); + mesh.quaternion.set(qpos[adr + 4], qpos[adr + 5], qpos[adr + 6], qpos[adr + 3]); + } + + function sync(qpos, adr, physicsLive) { + if (visual === "ghost" && ghost) { + mesh.visible = true; + mesh.position.copy(ghost.pos); + mesh.quaternion.copy(ghost.quat); + } else if (physicsLive) { + mesh.visible = true; + poseFromQpos(qpos, adr); + } else { + mesh.visible = false; + } + } + + function drive(onQueuedSpawn) { + if (fx.playing) { + const now = performance.now(); + if (fxPrev === null) fxPrev = now; + const dt = Math.min((now - fxPrev) / 1000, 0.25); + fxPrev = now; + // Time-scale the FX so the ball pops in/out at its own speed. + const speed = fx.TOTAL_S / (fx.reversing ? BALL_DISAPPEAR_S : BALL_APPEAR_S); + fx.update(dt * speed); + } + if (visual === "ghost" && fx.isDone()) { + mesh.visible = false; + visual = "hidden"; + ghost = null; + fx.restore(); + const queued = pendingSpawn; + pendingSpawn = false; + if (queued) onQueuedSpawn(); + } + } + + return { + appear, + despawn, + queueRespawn, + poseFromQpos, + sync, + drive, + get visual() { return visual; }, + }; +} diff --git a/app/src/game/ball-visual.js b/app/src/game/ball-visual.js new file mode 100644 index 0000000..0ecdea9 --- /dev/null +++ b/app/src/game/ball-visual.js @@ -0,0 +1,149 @@ +// Ball visuals: procedural soccer-ball texture + the render mesh, ported +// verbatim from the pre-React rl.js. +import * as THREE from "three"; +import { BALL_RADIUS } from "./constants.js"; + +// Soccer-ball look computed per pixel on the sphere itself, so there is +// no pole or seam special case by design. The truncated icosahedron is +// reconstructed as a spherical Voronoi diagram over 32 sites: the 12 +// icosahedron vertices (black pentagon centers, one sitting at each +// pole) and its 20 face centers (white hexagon centers). A pixel is +// black when its nearest site is a pentagon center and it sits clear of +// the cell boundary by a seam margin - which yields big flat-edged black +// pentagons separated from the white hexagons by thin seams, corners +// almost touching, exactly like the real panel layout. +function makeSoccerBallTexture(renderer) { + const W = 1024, H = 512; + const c = document.createElement("canvas"); + c.width = W; + c.height = H; + const ctx = c.getContext("2d"); + // 12 icosahedron vertices: 2 poles + two staggered rings of 5 at + // latitude +-atan(1/2) (~26.57 deg) - the pentagon centers. + const sites = []; + const addSite = (v, isPent) => { + const n = Math.hypot(v[0], v[1], v[2]); + sites.push({ x: v[0] / n, y: v[1] / n, z: v[2] / n, pent: isPent }); + }; + const verts = [[0, 0, 1], [0, 0, -1]]; + const latR = Math.atan(0.5), cr = Math.cos(latR), sr = Math.sin(latR); + for (let i = 0; i < 5; i++) { + const a = (i * 72 * Math.PI) / 180; + const b = ((i * 72 + 36) * Math.PI) / 180; + verts.push([cr * Math.cos(a), cr * Math.sin(a), sr]); + verts.push([cr * Math.cos(b), cr * Math.sin(b), -sr]); + } + for (const v of verts) addSite(v, true); + // 20 face centers (hexagon centers): normalized centroids of every + // mutually-adjacent vertex triple (adjacent pairs have dot = 1/sqrt(5)). + const adj = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2] > 0.3; + for (let i = 0; i < 12; i++) { + for (let j = i + 1; j < 12; j++) { + if (!adj(verts[i], verts[j])) continue; + for (let k = j + 1; k < 12; k++) { + if (adj(verts[i], verts[k]) && adj(verts[j], verts[k])) { + addSite([ + verts[i][0] + verts[j][0] + verts[k][0], + verts[i][1] + verts[j][1] + verts[k][1], + verts[i][2] + verts[j][2] + verts[k][2], + ], false); + } + } + } + } + // Seam half-width and anti-alias band, in radians of arc. + const SEAM = (1.6 * Math.PI) / 180; + const AA = (0.35 * Math.PI) / 180; + // Groove reach for the bump map: a touch wider than the painted seam so + // the recess shoulders catch light on both sides of the line. + const GROOVE = SEAM * 1.5; + const BG = [233, 231, 224], INK = [23, 23, 29], STITCH = [200, 197, 188]; + const img = ctx.createImageData(W, H); + const px = img.data; + // Height map sharing the same panel construction: seams become recessed + // grooves, plus a very fine leather/PVC grain over the whole surface. + const bc = document.createElement("canvas"); + bc.width = W; + bc.height = H; + const bctx = bc.getContext("2d"); + const bimg = bctx.createImageData(W, H); + const bpx = bimg.data; + for (let row = 0; row < H; row++) { + const lat = Math.PI / 2 - ((row + 0.5) / H) * Math.PI; + const cl = Math.cos(lat), sl = Math.sin(lat); + for (let col = 0; col < W; col++) { + const lon = ((col + 0.5) / W) * 2 * Math.PI - Math.PI; + const dx = cl * Math.cos(lon), dy = cl * Math.sin(lon), dz = sl; + let best = -2, second = -2, bestPent = false; + for (const s of sites) { + const d = dx * s.x + dy * s.y + dz * s.z; + if (d > best) { second = best; best = d; bestPent = s.pent; } + else if (d > second) second = d; + } + // Signed distance to the Voronoi cell boundary along the geodesic. + const halfGap = (Math.acos(Math.min(1, second)) - Math.acos(Math.min(1, best))) / 2; + // Black panel: inside a pentagon cell, clear of the seam margin. + const black = bestPent ? Math.min(1, Math.max(0, (halfGap - SEAM) / AA)) : 0; + // Subtle stitch line on every remaining cell boundary so the white + // hexagons read as panels too. + const stitch = Math.min(1, Math.max(0, 1 - halfGap / (SEAM * 0.6))) * (1 - black); + const o = (row * W + col) * 4; + for (let ch = 0; ch < 3; ch++) { + const base = BG[ch] + (STITCH[ch] - BG[ch]) * stitch; + px[o + ch] = base + (INK[ch] - base) * black; + } + px[o + 3] = 255; + // Bump: quadratic groove profile (soft shoulders, no golf-ball + // embossing) + grain noise. + const groove = Math.max(0, 1 - halfGap / GROOVE) ** 2; + const hgt = 205 - groove * 115 + (Math.random() - 0.5) * 14; + const h8 = Math.max(0, Math.min(255, hgt)); + bpx[o] = h8; bpx[o + 1] = h8; bpx[o + 2] = h8; + bpx[o + 3] = 255; + } + } + ctx.putImageData(img, 0, 0); + bctx.putImageData(bimg, 0, 0); + const finish = (canvas, srgb) => { + const tex = new THREE.CanvasTexture(canvas); + // The bump map stays linear; only the color map is sRGB. + if (srgb) tex.colorSpace = THREE.SRGBColorSpace; + // Texel footprints get extremely anamorphic near the UV poles; without + // anisotropy the cap edge visibly scallops at close range. + tex.anisotropy = renderer.capabilities.getMaxAnisotropy(); + return tex; + }; + return { map: finish(c, true), bumpMap: finish(bc, false) }; +} + +// Same Z-up -> Y-up trick as the duck rig: the group takes the axis fix, +// the mesh inside takes the raw MJCF free-joint pose. +export function createBallVisual(renderer) { + const group = new THREE.Group(); + group.rotation.x = -Math.PI / 2; + const tex = makeSoccerBallTexture(renderer); + const mesh = new THREE.Mesh( + // 48x32 segments: the coarser default makes the UV interpolation near + // the poles visibly scallop the round cap edge of the texture. + new THREE.SphereGeometry(BALL_RADIUS, 48, 32), + // Physical material for the waxed vintage-leather look: matte-ish base + // with a whisper of clearcoat so highlights ride the seam grooves. + new THREE.MeshPhysicalMaterial({ + map: tex.map, + bumpMap: tex.bumpMap, + bumpScale: 0.0012, + metalness: 0, + roughness: 0.55, + clearcoat: 0.2, + clearcoatRoughness: 0.35, + }), + ); + mesh.userData.meshName = "ball"; + // The 48x32 render sphere is far too dense for the wireframe scan (it + // reads as a solid glowing blob); the FX overlay uses this geodesic + // stand-in instead - 80 triangles, clean hologram lines. + mesh.userData.fxWireGeometry = new THREE.IcosahedronGeometry(BALL_RADIUS, 1); + mesh.visible = false; + group.add(mesh); + return { group, mesh }; +} diff --git a/app/src/game/ceremony.js b/app/src/game/ceremony.js new file mode 100644 index 0000000..1e6e4c2 --- /dev/null +++ b/app/src/game/ceremony.js @@ -0,0 +1,236 @@ +// Cutscene layer: page-load entrance and every later respawn. +// +// Physics (resetSim) snaps the duck to the stand keyframe; this module +// owns what the player sees around that snap. Two mutually exclusive +// timelines share the duck's wireframe FX: +// +// entrance (once) grid + walls draw in, then the duck scans up +// respawn (every kill / Space / loco switch) +// 0.00 duck clipped away, camera glides home from the kill view +// 0.80 camera almost settled -> duck scan-up cues +// 0.90 camera lands +// 1.70 scan done, inputs unlock +// +// rl.js injects the world (rig, grid, camera reset) and the lock/flash +// callbacks; this file never touches MuJoCo. + +export const CAM_RESET_S = 0.9; +export const RESPAWN_SCAN_AT = 0.8; // cue scan-up at 80% of the camera glide + +const ENTRANCE_GRID_S = 1.1; +const ENTRANCE_WALL_DELAY_S = 0.35; +const ENTRANCE_WALL_S = 0.9; +const ENTRANCE_FX_START_S = 0.6; + +const clamp01 = (x) => Math.min(Math.max(x, 0), 1); + +export function createCeremony({ + THREE, scene, camera, renderer, fx, + getRig, grid, wallMats, + syncRig, startCameraReset, + setLocked, flashReset, +}) { + const ENTRANCE_TOTAL_S = Math.max( + ENTRANCE_GRID_S, + ENTRANCE_WALL_DELAY_S + ENTRANCE_WALL_S, + ENTRANCE_FX_START_S + fx.TOTAL_S, + ); + + let fxRig = null; + let fxPrev = null; + // Decorative props (addPropFx): each owns a wireframe FX bound to its + // own root. They cue whenever the duck's scan cues (entrance and every + // respawn), offset by their stagger, and drive on their OWN clock so a + // late-finishing prop never extends the input lock or the ceremony's + // completion checks. + const props = []; // { fx, delayS, at, started, prev } + let entranceT0 = null; + let entranceFxCued = false; + let entranceDone = false; + let respawn = null; // { t0, scanCued } | null + let entranceFinishedResolve; + const entranceFinished = new Promise((r) => { entranceFinishedResolve = r; }); + + function bind() { + const rig = getRig(); + if (fxRig === rig) return; + fx.dispose(); + fx.init({ THREE, scene, rig, camera, renderer }); + rig.placer.traverse((o) => { + if (o.isMesh && !o.userData.meshName) o.userData.fxOverlay = true; + }); + fxRig = rig; + } + + function fxStart() { + bind(); + fx.start(); + fxPrev = performance.now(); + propsCue(); + } + function propsCue() { + const now = performance.now(); + for (const p of props) { + p.at = now + p.delayS * 1000; + p.started = false; + p.prev = null; + } + } + function propsHide() { + for (const p of props) { + p.fx.setProgress(0); + p.at = null; + p.started = false; + } + } + function propsFinish() { + for (const p of props) { + if (!p.started) p.fx.start(); + p.fx.update(1e3); + p.at = null; + } + } + // Deterministic screenshot/test hook (setFx): park every prop at the + // same scan progress as the duck, detached from the timed driver. + function propsSetProgress(v) { + for (const p of props) { + p.fx.setProgress(v); + p.at = null; + p.started = false; + } + } + function driveProps() { + const now = performance.now(); + for (const p of props) { + if (p.at === null || now < p.at) continue; + if (!p.started) { + p.fx.start(); + p.started = true; + p.prev = now; + continue; + } + if (p.fx.isDone()) continue; + const dt = Math.min((now - p.prev) / 1000, 0.25); + p.prev = now; + p.fx.update(dt); + } + } + function fxDrive() { + if (fxPrev === null || fx.isDone()) return; + const now = performance.now(); + const dt = Math.min((now - fxPrev) / 1000, 0.25); + fxPrev = now; + fx.update(dt); + } + function fxForceFinish() { + if (!fx.isDone()) fx.update(1e3); + } + + function startEntrance() { + if (entranceT0 !== null || entranceDone) return; + entranceT0 = performance.now(); + entranceFxCued = false; + grid.material.uniforms.uReveal.value = 0; + for (const m of wallMats) m.uniforms.uReveal.value = 0; + } + + function driveEntrance() { + if (entranceT0 === null) return; + const t = (performance.now() - entranceT0) / 1000; + grid.material.uniforms.uReveal.value = clamp01(t / ENTRANCE_GRID_S); + const wallR = clamp01((t - ENTRANCE_WALL_DELAY_S) / ENTRANCE_WALL_S); + for (const m of wallMats) m.uniforms.uReveal.value = wallR; + if (t >= ENTRANCE_FX_START_S && !entranceFxCued) { + entranceFxCued = true; + fxStart(); + } + fxDrive(); + if (t >= ENTRANCE_TOTAL_S) { + if (!fx.isDone() && t < ENTRANCE_TOTAL_S + 0.5) return; + fxForceFinish(); + entranceT0 = null; + entranceDone = true; + grid.material.uniforms.uReveal.value = 1; + for (const m of wallMats) m.uniforms.uReveal.value = 1; + setLocked(false); + entranceFinishedResolve(); + } + } + + function playRespawn() { + if (!entranceDone) return; + setLocked(true); + flashReset(); + bind(); + startCameraReset(); + syncRig(); + fx.setProgress(0); + propsHide(); + respawn = { t0: performance.now(), scanCued: false }; + } + + function driveRespawn() { + if (!respawn) return; + const u = (performance.now() - respawn.t0) / 1000 / CAM_RESET_S; + if (!respawn.scanCued && u >= RESPAWN_SCAN_AT) { + respawn.scanCued = true; + fxStart(); + } + if (respawn.scanCued) fxDrive(); + if (respawn.scanCued && fx.isDone()) { + respawn = null; + setLocked(false); + } + } + + function drive() { + driveEntrance(); + driveRespawn(); + driveProps(); + } + + function setReveal(floor, wall = floor) { + entranceT0 = null; + grid.material.uniforms.uReveal.value = floor; + for (const m of wallMats) m.uniforms.uReveal.value = wall; + } + + function setFx(p) { + entranceT0 = null; + respawn = null; + bind(); + if (p >= 1) { + fx.start(); + fxForceFinish(); + propsFinish(); + setLocked(false); + entranceFinishedResolve(); + } else { + fx.setProgress(p); + propsSetProgress(p); + } + } + + // Register a decorative prop's wireframe FX (already init'd on its own + // root, hidden). It materializes delayS after each duck scan cue. + function addPropFx(propFx, delayS = 0) { + props.push({ fx: propFx, delayS, at: null, started: false, prev: null }); + } + + // Boot hidden: clip parked below the feet from the first frame. + bind(); + + return { + CAM_RESET_S, + startEntrance, + playRespawn, + drive, + bind, + setReveal, + setFx, + addPropFx, + entranceFinished, + get entranceDone() { return entranceDone; }, + get respawnActive() { return respawn !== null; }, + }; +} diff --git a/app/src/game/constants.js b/app/src/game/constants.js new file mode 100644 index 0000000..1259f64 --- /dev/null +++ b/app/src/game/constants.js @@ -0,0 +1,74 @@ +// Shared sim constants, lifted verbatim from the pre-React rl.js. + +export const POLICY_DIR = "./policies"; +export const POLICIES = { + walk: `${POLICY_DIR}/BEST_alpha_walking.onnx`, + sitstand: `${POLICY_DIR}/BEST_alpha_sitstand.onnx`, + roll: `${POLICY_DIR}/roulade.onnx`, + // Blind one-shot kicks (the operator aims the robot, no ball in obs): + // the runtime swaps these in for a 0.5 s window, commands zeroed. + kickL: `${POLICY_DIR}/ball_kick_left.onnx`, + kickR: `${POLICY_DIR}/ball_kick_right.onnx`, + // Roller variant (lazy-loaded on first switch, never at boot): + // drive = velocity-tracking skating, crouch = one-shot crouch-glide + // driven by a phase encoding in the command slots (ground-pick style). + drive: `${POLICY_DIR}/BEST_roller.onnx`, + crouch: `${POLICY_DIR}/BEST_roller_crouch.onnx`, +}; + +// From the ONNX metadata (identical for all alpha policies) and the STAND +// keyframe in mjlab's scene_walk.xml. Order matches the actuators in +// the MJCF. +export const JOINT_NAMES = [ + "left_hip_yaw", "left_hip_roll", "left_hip_pitch", "left_knee", "left_ankle", + "neck_pitch", "head_pitch", "head_yaw", "head_roll", + "right_hip_yaw", "right_hip_roll", "right_hip_pitch", "right_knee", "right_ankle", +]; +export const DEFAULT_POSE = new Float32Array([ + 0, -0.08726646259971647, -0.457924, -0.004940, 0.452984, + 0.3490658503988659, 0.3490658503988659, 0, 0, + 0, 0.08726646259971647, 0.457924, 0.004940, -0.452984, +]); +export const NUM_JOINTS = 14; +export const OBS_SIZE = 61; +export const CMD_SIZE = 13; +export const ACTION_SCALE = 1.0; +export const TIMESTEP = 0.005; +export const DECIMATION = 4; +export const CTRL_DT = TIMESTEP * DECIMATION; // 50 Hz + +// Velocity command limits, same as infer_policy.py's keyboard mapping. +// No strafe input anymore: the lateral cmd slot stays zeroed for the obs. +export const VEL_FWD = 0.25, VEL_BACK = -0.2, VEL_ANG = 1.0; +// Roller mode limits, from the runtime's roller branch: asymmetric vx +// (0.6 push / 0.5 brake), no lateral. The real runtime launches rollers +// with --max-angular-vel 0.3: faster commanded turns tip the robot over, +// so the playground clamps wz the same way. +export const RVEL_FWD = 0.6, RVEL_BACK = -0.5, RVEL_ANG = 0.3; +// Crouch-glide one-shot: command = [cos(2pi*phase), sin(2pi*phase), 0], +// phase advancing at 1/CROUCH_PERIOD_S per second and the cycle exiting +// at 0.7 - exactly the runtime's ground-pick slot the policy was trained +// against (mjlab CROUCH_PERIOD = 5.0, cycle end 0.7 => 3.5 s gesture). +export const CROUCH_PERIOD_S = 5.0; +export const CROUCH_END_PHASE = 0.7; + +// Kickable ball: radius and parking spot (far away = hidden by default). +export const BALL_RADIUS = 0.05; +export const BALL_PARK_POS = "50 0 0.05"; + +// Square arena boxing the play area: static walls at +-ARENA_HALF keep +// the ball (and the duck) inside. Tall enough that neither steps over. +export const ARENA_HALF = 1.5; // inner half-size, m +export const ARENA_WALL_H = 0.25; +export const ARENA_WALL_T = 0.05; +// Section grid: 5 cells across the 3 m arena (ODD, so a true middle +// column/row of cells exists; the lattice is shifted half a cell in the +// shaders so the walls land exactly on section lines). +export const GRID_SECTION = (2 * ARENA_HALF) / 5; // 0.6 m +// Spawn: center of the middle section cell in the SECOND ROW FROM THE +// BACK wall. The duck faces +X (identity freejoint quat, walks toward +// local +X), so "back" is the -X wall: row centers sit at x = -1.2, +// -0.6, 0, 0.6, 1.2 -> second row is -0.6; middle column is y = 0. +// MJCF coordinates (three.js: x -> x, y -> -z). +export const SPAWN_X = -ARENA_HALF + 1.5 * GRID_SECTION; // -0.6 +export const SPAWN_Y = 0; diff --git a/app/src/game/controls/controller.js b/app/src/game/controls/controller.js new file mode 100644 index 0000000..23d80ea --- /dev/null +++ b/app/src/game/controls/controller.js @@ -0,0 +1,188 @@ +// Controller: the video-game-style input core. Aggregates pluggable input +// SOURCES (keyboard, gamepad, later touch) into one game-facing surface: +// +// - a continuous COMMAND: the [vx, vy, wz] twist the policy tracks, plus +// auxiliary analog AXES (jaw 0..1, camera-orbit rates -1..1); +// - discrete ACTIONS: edge-triggered events (roll, kicks, ball spawn...) +// dispatched to subscribers the moment a source fires them; +// - HUD support: per-source pressed-state snapshots and activity info so +// the hint keycaps can light up per physical control and per device. +// +// The game code (rl.js) instantiates the sources, registers them here, +// calls update(dt) once per render frame, reads getCommand()/getAxes() +// where it builds the policy observation, and subscribes its trigger +// functions with on(action, cb). +// +// ── Source interface contract ──────────────────────────────────────────── +// Every input source module (keyboard.js, gamepad.js, a future touch.js +// with a virtual joystick + buttons) implements: +// +// id Unique string ("keyboard", "gamepad", "touch"...). Action +// subscribers receive it as meta.source, so game code can +// attribute HUD flashes / keycap lighting to the right device. +// connected Boolean hardware presence. Keyboard: always true. Gamepad: +// a pad is currently reported by navigator.getGamepads(). +// command Float32Array(3) [vx, vy, wz], ALREADY scaled to the game's +// velocity limits (sources take a getVelocityLimits() callback +// returning [fwd, back, ang], so limits can change at runtime, +// e.g. the legs <-> rollers switch). Must be a stable array +// reference updated in place: getCommand() hands it out +// without copying, and the control loop reads it between +// render frames. +// axes { jaw, orbitX, orbitY } - auxiliary continuous channels. +// jaw in [0, 1] (mouth opening), orbit axes in [-1, 1] +// (camera orbit rate; the inertia/smoothing lives downstream +// in the camera code, sources report raw deflection). Stable +// object reference, updated in place. Channels a source does +// not drive stay 0. +// pressed Plain object of booleans (stable reference) mirroring which +// physical controls are currently down. HUD highlighting +// only - never game logic. +// isActive() Whether the source currently claims authority over the +// continuous command. Keyboard: any move key held. Gamepad: +// stick deflected, and it keeps the claim until its smoothed +// command settles back to ~zero. +// init() Attach event listeners / hardware hooks. Called by +// Controller.init(), NOT at construction (rl.js constructs +// the sources early but arms the listeners at the same point +// in the boot where they historically went live). +// dispose() Detach everything init() attached. +// poll(dt) Per-frame tick (dt in seconds, clamped by the caller). +// Read the hardware, update command/axes/pressed in place, +// and fire edge-triggered actions via this.onAction(name). +// onAction (name, meta?) => void, assigned by the Controller at +// registration. Sources may call it from poll() (gamepad +// button edges) or straight from event handlers (keyboard: +// keeps the historical press-to-effect latency). +// +// ── Arbitration ────────────────────────────────────────────────────────── +// Continuous command: sources are registered in PRIORITY order (first = +// highest). Each frame the first source reporting isActive() owns the +// twist; when none is active the LAST registered source's command is used +// as the fallback (it reads zero when idle). With [gamepad, keyboard] this +// reproduces the historical `padActive ? padCmd : velCmd` exactly: live +// sticks win over held keys, and the keyboard takes back over once the +// pad's smoothed command has settled. +// Aux axes are merged across ALL sources regardless of who owns the twist +// (the pad triggers drive the jaw even while walking on the keyboard): +// jaw = max over sources, orbit = largest-magnitude value per axis. +// +// ── Actions ────────────────────────────────────────────────────────────── +// roll one-shot roll (crouch-glide in roller mode; game decides) +// kickL, kickR one-shot kicks, explicit foot +// alternateKick one-shot kick, feet alternated by the game +// spawnBall pop / respawn the kickable ball +// sitToggle sit <-> stand (game gates it to legs mode) +// locoToggle legs <-> rollers switch +// chaseToggle chase camera on/off +// reset full sim reset (Space) +// walk back to the walk/run mode (pad DpadUp short press) +// quack chirp + jaw flap (pad RT edge, Schmitt-triggered) +// +// ── Input lock ─────────────────────────────────────────────────────────── +// setLocked(true) zeroes getCommand() - the twist gate used while the +// entrance/respawn ceremony plays. Discrete actions still dispatch: each +// game trigger applies its own lock policy (e.g. Space-reset and the +// chase-cam toggle historically work while locked, kicks don't). + +const ZERO_CMD = new Float32Array(3); + +export class Controller { + #sources = []; + #listeners = new Map(); // action -> Set(cb) + #locked = false; + #axes = { jaw: 0, orbitX: 0, orbitY: 0 }; + + constructor({ sources = [] } = {}) { + for (const s of sources) this.addSource(s); + } + + // Register in priority order (first registered wins arbitration ties). + addSource(source) { + source.onAction = (action, meta) => + this.#dispatch(action, { source: source.id, ...meta }); + this.#sources.push(source); + } + + // Read-only source list, for advanced per-source queries the merged view + // can't answer (e.g. "is ANY source commanding a turn right now?"). + get sources() { + return this.#sources; + } + + // Arm every source's listeners/hardware hooks. + init() { + for (const s of this.#sources) s.init?.(); + } + + dispose() { + for (const s of this.#sources) s.dispose?.(); + } + + // Per-frame tick: poll every source (they fire their edge actions from + // inside poll), then merge the aux axes. + update(dt) { + for (const s of this.#sources) s.poll?.(dt); + let jaw = 0, ox = 0, oy = 0; + for (const s of this.#sources) { + const a = s.axes; + if (!a) continue; + jaw = Math.max(jaw, a.jaw ?? 0); + if (Math.abs(a.orbitX ?? 0) > Math.abs(ox)) ox = a.orbitX; + if (Math.abs(a.orbitY ?? 0) > Math.abs(oy)) oy = a.orbitY; + } + this.#axes.jaw = jaw; + this.#axes.orbitX = ox; + this.#axes.orbitY = oy; + } + + setLocked(v) { + this.#locked = !!v; + } + + get locked() { + return this.#locked; + } + + // Merged continuous twist [vx, vy, wz] (see the arbitration notes above). + // Returns live source arrays without copying - treat as read-only. + getCommand() { + if (this.#locked) return ZERO_CMD; + for (const s of this.#sources) if (s.isActive()) return s.command; + const fallback = this.#sources[this.#sources.length - 1]; + return fallback ? fallback.command : ZERO_CMD; + } + + // Merged aux axes { jaw, orbitX, orbitY }, refreshed by update(). + getAxes() { + return this.#axes; + } + + // Any source claiming twist authority (HUD "user is driving" signal). + anyActive() { + return this.#sources.some((s) => s.isActive()); + } + + // Per-source pressed snapshots for HUD keycap highlighting: + // { keyboard: {...}, gamepad: {...} }. + getPressed() { + const out = {}; + for (const s of this.#sources) out[s.id] = s.pressed ?? {}; + return out; + } + + // Subscribe to a discrete action; cb(meta) with meta.source = source id. + // Returns an unsubscribe function. + on(action, cb) { + let set = this.#listeners.get(action); + if (!set) this.#listeners.set(action, (set = new Set())); + set.add(cb); + return () => set.delete(cb); + } + + #dispatch(action, meta) { + const set = this.#listeners.get(action); + if (!set) return; + for (const cb of set) cb(meta); + } +} diff --git a/app/src/game/controls/gamepad.js b/app/src/game/controls/gamepad.js new file mode 100644 index 0000000..fdec581 --- /dev/null +++ b/app/src/game/controls/gamepad.js @@ -0,0 +1,153 @@ +// Gamepad input source (see controller.js for the source interface +// contract). Same mapping as the robot runtime (microduck_runtime): +// +// Left stick vertical = vx (asymmetric fwd/back), horizontal = turn, +// EMA-smoothed like the runtime's cmd_alpha. +// Right stick camera orbit rate (reported raw in axes.orbitX/Y; the +// velocity smoothing / coasting lives downstream in the +// camera code). R3 toggles the chase cam. +// X roll (crouch-glide in roller mode - game decides) +// Y ball spawn/respawn +// RB / LB right / left kick +// DpadDown sit <-> stand +// DpadUp short press = back to run; HOLD ~1 s = legs <-> rollers +// (like the robot's 3 s hold, shortened for the web) +// RT / LT analog jaw (max of both); RT edge quacks through a +// Schmitt trigger (fire at >= 0.35, re-arm below 0.2 - a +// single threshold re-fires on jitter, which is how one +// squeeze used to quack several times). + +const PAD_DEADZONE = 0.15; +const PAD_ALPHA = 0.12; // EMA smoothing toward the stick target +const dz = (v) => (Math.abs(v) < PAD_DEADZONE ? 0 : v); + +// Standard-mapping button indices. +const BTN_X = 2, BTN_Y = 3, BTN_LB = 4, BTN_RB = 5, BTN_LT = 6, BTN_RT = 7; +const BTN_R3 = 11, BTN_DPAD_UP = 12, BTN_DPAD_DOWN = 13; + +const DPAD_UP_HOLD_MS = 1000; // hold-to-switch-loco duration + +export class GamepadSource { + id = "gamepad"; + connected = false; + command = new Float32Array(3); // [vx, 0, wz], EMA-smoothed + axes = { jaw: 0, orbitX: 0, orbitY: 0 }; + pressed = { + x: false, y: false, rb: false, lb: false, r3: false, + dpadDown: false, dpadUp: false, + }; + onAction = () => {}; // assigned by the Controller at registration + + #getVelocityLimits; + #active = false; // owns twist authority (stick input, until EMA settles) + #dpadUpAt = 0; // wall-clock of the current DpadUp press + #dpadUpFired = false; // latch: one loco switch per hold + #rtArmed = true; // Schmitt trigger state for the RT quack + + constructor({ getVelocityLimits }) { + this.#getVelocityLimits = getVelocityLimits; + } + + init() {} // poll-based: nothing to attach + dispose() {} + + isActive() { + return this.#active; + } + + poll() { + const prev = this.pressed; + const gp = [...(navigator.getGamepads?.() ?? [])].find((p) => p && p.connected); + this.connected = !!gp; + if (!gp) { + if (this.#active) { + this.#active = false; + this.command.fill(0); + this.axes.jaw = 0; + } + this.axes.orbitX = 0; + this.axes.orbitY = 0; + return; + } + const now = performance.now(); + + // Left stick only: vertical = forward/back, horizontal = turn. + // (No strafe; the right stick doesn't drive movement.) + const lx = dz(gp.axes[0] ?? 0), ly = dz(gp.axes[1] ?? 0); + const up = -ly; // browser sticks report up as -1 + const [limF, limB, limA] = this.#getVelocityLimits(); + const target = [ + up >= 0 ? up * limF : up * -limB, + 0, + -lx * limA, + ]; + for (let i = 0; i < 3; i++) this.command[i] += PAD_ALPHA * (target[i] - this.command[i]); + // Sticks grab command authority on first input, release when back at + // rest (then the keyboard takes over again through the Controller's + // arbitration). + const stickInput = lx !== 0 || ly !== 0; + if (stickInput) this.#active = true; + else if ( + this.#active && + Math.abs(this.command[0]) + Math.abs(this.command[1]) + Math.abs(this.command[2]) < 0.01 + ) { + this.#active = false; + this.command.fill(0); + } + + // Right stick: raw (deadzoned) orbit rate. Reported every frame - the + // downstream camera step needs the zeros too so a released stick + // coasts to a stop. + this.axes.orbitX = dz(gp.axes[2] ?? 0); + this.axes.orbitY = dz(gp.axes[3] ?? 0); + + // R3 (right stick click): chase-cam toggle, gamepad twin of KeyC. + const r3 = !!gp.buttons[BTN_R3]?.pressed; + if (r3 && !prev.r3) this.onAction("chaseToggle"); + prev.r3 = r3; + + const x = !!gp.buttons[BTN_X]?.pressed; + if (x && !prev.x) this.onAction("roll"); + prev.x = x; + + const y = !!gp.buttons[BTN_Y]?.pressed; + if (y && !prev.y) this.onAction("spawnBall"); + prev.y = y; + + const rb = !!gp.buttons[BTN_RB]?.pressed; + if (rb && !prev.rb) this.onAction("kickR"); + prev.rb = rb; + const lb = !!gp.buttons[BTN_LB]?.pressed; + if (lb && !prev.lb) this.onAction("kickL"); + prev.lb = lb; + + const dpadDown = !!gp.buttons[BTN_DPAD_DOWN]?.pressed; + if (dpadDown && !prev.dpadDown) this.onAction("sitToggle"); + prev.dpadDown = dpadDown; + + // DpadUp: short press = back to run; hold fires ONE loco switch. + const dpadUp = !!gp.buttons[BTN_DPAD_UP]?.pressed; + if (dpadUp && !prev.dpadUp) { + this.#dpadUpAt = now; + this.#dpadUpFired = false; + this.onAction("walk"); + } + if (dpadUp && !this.#dpadUpFired && now - this.#dpadUpAt >= DPAD_UP_HOLD_MS) { + this.#dpadUpFired = true; // latch: one switch per hold + this.onAction("locoToggle"); + } + prev.dpadUp = dpadUp; + + // Triggers drive the mouth (max of both); RT quacks on its + // Schmitt-triggered rising edge. + const rt = gp.buttons[BTN_RT]?.value ?? 0; + const lt = gp.buttons[BTN_LT]?.value ?? 0; + this.axes.jaw = Math.max(rt, lt); + if (this.#rtArmed && rt >= 0.35) { + this.onAction("quack"); + this.#rtArmed = false; + } else if (!this.#rtArmed && rt < 0.2) { + this.#rtArmed = true; + } + } +} diff --git a/app/src/game/controls/keyboard.js b/app/src/game/controls/keyboard.js new file mode 100644 index 0000000..510877e --- /dev/null +++ b/app/src/game/controls/keyboard.js @@ -0,0 +1,116 @@ +// Keyboard input source (see controller.js for the source interface +// contract). Hold-to-command movement keys plus one-shot action keys. +// +// e.code is the PHYSICAL key position, so one map covers QWERTY and AZERTY: +// arrows / WASD (ZQSD) run + turn. No strafe - vy stays 0. + +const KEYMAP = { + ArrowUp: "fwd", KeyW: "fwd", + ArrowDown: "back", KeyS: "back", + ArrowLeft: "turnl", KeyA: "turnl", + ArrowRight: "turnr", KeyD: "turnr", +}; + +// One-shot keys -> controller actions. Physical Q/E (A/E on AZERTY) are the +// explicit left / right kicks, mirroring the pad's LB / RB; F alternates. +const ACTION_KEYS = { + KeyB: "spawnBall", + KeyC: "chaseToggle", + KeyM: "locoToggle", + KeyR: "roll", + KeyQ: "kickL", + KeyE: "kickR", + KeyF: "alternateKick", +}; + +export class KeyboardSource { + id = "keyboard"; + connected = true; // a keyboard is always assumed present + command = new Float32Array(3); // [vx, 0, wz], scaled to velocity limits + axes = { jaw: 0, orbitX: 0, orbitY: 0 }; // keyboard drives none of these + pressed = { fwd: false, back: false, turnl: false, turnr: false }; + onAction = () => {}; // assigned by the Controller at registration + + #held = new Set(); + #getVelocityLimits; + // Limits snapshot so poll() only re-maps held keys when they actually + // change (the legs <-> rollers switch); event handlers do the live work. + #lims = [NaN, NaN, NaN]; + #onKeyDown = null; + #onKeyUp = null; + #onBlur = null; + + constructor({ getVelocityLimits }) { + this.#getVelocityLimits = getVelocityLimits; + } + + init() { + this.#onKeyDown = (e) => { + if (e.repeat) return; + // Space always resets, and must not scroll the page. + if (e.code === "Space") { + e.preventDefault(); + this.onAction("reset"); + return; + } + const action = ACTION_KEYS[e.code]; + if (action) { + this.onAction(action); + return; + } + const move = KEYMAP[e.code]; + if (!move) return; + e.preventDefault(); + this.#held.add(move); + this.#refresh(); + }; + this.#onKeyUp = (e) => { + const move = KEYMAP[e.code]; + if (!move) return; + this.#held.delete(move); + this.#refresh(); + }; + // Losing window focus drops every held key (keyup events are missed). + this.#onBlur = () => { + this.#held.clear(); + this.#refresh(); + }; + window.addEventListener("keydown", this.#onKeyDown); + window.addEventListener("keyup", this.#onKeyUp); + window.addEventListener("blur", this.#onBlur); + } + + dispose() { + window.removeEventListener("keydown", this.#onKeyDown); + window.removeEventListener("keyup", this.#onKeyUp); + window.removeEventListener("blur", this.#onBlur); + } + + // Claims twist authority while any movement key is held. + isActive() { + return this.#held.size > 0; + } + + // The command is event-driven (recomputed on keydown/keyup/blur, so a + // press lands the same tick, not on the next frame); poll only re-maps + // held keys onto fresh velocity limits after a locomotion switch. + poll() { + const [limF, limB, limA] = this.#getVelocityLimits(); + if (limF !== this.#lims[0] || limB !== this.#lims[1] || limA !== this.#lims[2]) { + this.#refresh(); + } + } + + #refresh() { + const lims = this.#getVelocityLimits(); + const [limF, limB, limA] = lims; + this.#lims = lims; + const held = this.#held; + this.command[0] = held.has("fwd") ? limF : held.has("back") ? limB : 0; + this.command[2] = held.has("turnl") ? limA : held.has("turnr") ? -limA : 0; + this.pressed.fwd = held.has("fwd"); + this.pressed.back = held.has("back"); + this.pressed.turnl = held.has("turnl"); + this.pressed.turnr = held.has("turnr"); + } +} diff --git a/app/src/game/controls/touch.js b/app/src/game/controls/touch.js new file mode 100644 index 0000000..906b696 --- /dev/null +++ b/app/src/game/controls/touch.js @@ -0,0 +1,180 @@ +// Touch input source (see controller.js for the source interface +// contract). Game Boy layout, two thumbs: +// +// Left thumb FLOATING analog stick: the lower-left quadrant of the +// screen (#touch-zone) is the grab area, and the stick base +// (#touch-stick) re-anchors under the finger wherever it +// lands - so the thumb never has to find a fixed circle - +// then snaps back to its resting spot on release. Vertical +// = vx (asymmetric fwd/back limits), horizontal = turn. The +// nub tracks the finger clamped to the base circle; the +// command is EMA-smoothed like the gamepad's so releases +// don't snap. +// Right thumb two round caps: A (#touch-a) fires alternateKick - the +// game alternates feet; B (#touch-b) quacks on press and +// holds the beak open (axes.jaw = 1) while held. +// +// The overlay DOM lives in index.html (#touch-ui); this module only wires +// pointer events to it. `connected` (mirrored onto body.touch-mode by +// rl.js, which is what actually shows the overlay) arms two ways: +// - (pointer: coarse) matches: phones/tablets, before any touch; +// - OR the first real touch anywhere: catches DevTools device modes and +// hybrid laptops the media query misses. Latching, like a gamepad. + +const TOUCH_ALPHA = 0.18; // EMA smoothing toward the stick target +const TOUCH_DEADZONE = 0.12; // normalized deflection ignored around center + +export class TouchSource { + id = "touch"; + connected = false; + command = new Float32Array(3); // [vx, 0, wz], EMA-smoothed + axes = { jaw: 0, orbitX: 0, orbitY: 0 }; + pressed = { stick: false, a: false, b: false }; + onAction = () => {}; // assigned by the Controller at registration + + #getVelocityLimits; + #active = false; // owns twist authority (stick engaged, until EMA settles) + #target = [0, 0]; // normalized deflection [x, right+] [y, up+] + #mq = null; + #onMq = null; + #disposers = []; + + constructor({ getVelocityLimits }) { + this.#getVelocityLimits = getVelocityLimits; + } + + init() { + this.#mq = window.matchMedia("(pointer: coarse)"); + // Latching: once a device has proven it can touch, keep the thumbs. + // __microduckTouched carries a touch seen by the title page before + // this module booted. + if (window.__microduckTouched) this.connected = true; + this.#onMq = () => { this.connected = this.connected || this.#mq.matches; }; + this.#mq.addEventListener("change", this.#onMq); + this.#onMq(); + const armTouch = () => { this.connected = true; }; + window.addEventListener("touchstart", armTouch, { once: true, passive: true }); + this.#disposers.push(() => window.removeEventListener("touchstart", armTouch)); + + const zone = document.getElementById("touch-zone"); + const stick = document.getElementById("touch-stick"); + const nub = stick?.querySelector(".nub"); + if (zone && stick && nub) this.#bindStick(zone, stick, nub); + + this.#bindButton("touch-a", "a", () => this.onAction("alternateKick")); + this.#bindButton("touch-b", "b", () => this.onAction("quack")); + } + + dispose() { + this.#mq?.removeEventListener("change", this.#onMq); + for (const off of this.#disposers) off(); + this.#disposers = []; + } + + isActive() { + return this.#active; + } + + poll() { + const [x, y] = this.#target; + const [limF, limB, limA] = this.#getVelocityLimits(); + const tvx = y >= 0 ? y * limF : y * -limB; + const twz = -x * limA; + this.command[0] += TOUCH_ALPHA * (tvx - this.command[0]); + this.command[2] += TOUCH_ALPHA * (twz - this.command[2]); + // Same authority rule as the gamepad sticks: grab on input, release + // once the smoothed command has settled back to ~zero. + if (this.pressed.stick) this.#active = true; + else if (this.#active && Math.abs(this.command[0]) + Math.abs(this.command[2]) < 0.01) { + this.#active = false; + this.command.fill(0); + } + // B holds the beak open; quack itself fired on the press edge. + this.axes.jaw = this.pressed.b ? 1 : 0; + } + + #on(el, type, fn) { + el.addEventListener(type, fn); + this.#disposers.push(() => el.removeEventListener(type, fn)); + } + + #bindStick(zone, stick, nub) { + let pointerId = null; + let center = null; // stick center while grabbed, zone-local px + const setFrom = (e) => { + const zr = zone.getBoundingClientRect(); + const R = stick.offsetWidth / 2; + const travel = R * 0.62; // max nub travel inside the base circle + let dx = e.clientX - zr.left - center.x; + let dy = e.clientY - zr.top - center.y; + const d = Math.hypot(dx, dy); + if (d > travel) { dx *= travel / d; dy *= travel / d; } + nub.style.transform = `translate(${dx}px, ${dy}px)`; + const nx = dx / travel, ny = -dy / travel; // up is +y + const mag = Math.hypot(nx, ny); + const live = mag >= TOUCH_DEADZONE; + this.#target[0] = live ? nx : 0; + this.#target[1] = live ? ny : 0; + }; + const release = () => { + pointerId = null; + center = null; + this.pressed.stick = false; + stick.classList.remove("live"); + nub.style.transform = ""; + // Back to the CSS resting spot until the next grab. + stick.style.left = ""; + stick.style.top = ""; + stick.style.bottom = ""; + this.#target[0] = 0; + this.#target[1] = 0; + }; + this.#on(zone, "pointerdown", (e) => { + e.preventDefault(); + pointerId = e.pointerId; + // Anchor the base exactly under the finger - a clamped anchor would + // start the stick with a phantom deflection near the zone edges. The + // circle clipping off-screen there is the standard floating-stick + // look, and it takes no pointer events anyway. + const zr = zone.getBoundingClientRect(); + const R = stick.offsetWidth / 2; + center = { x: e.clientX - zr.left, y: e.clientY - zr.top }; + stick.style.left = `${center.x - R}px`; + stick.style.top = `${center.y - R}px`; + stick.style.bottom = "auto"; + this.pressed.stick = true; + stick.classList.add("live"); + setFrom(e); // zero deflection at grab + // Last: capture can throw on exotic pointers and must not eat the + // press state above. + try { zone.setPointerCapture(e.pointerId); } catch {} + }); + this.#on(zone, "pointermove", (e) => { + if (e.pointerId === pointerId) setFrom(e); + }); + this.#on(zone, "pointerup", (e) => { + if (e.pointerId === pointerId) release(); + }); + this.#on(zone, "pointercancel", (e) => { + if (e.pointerId === pointerId) release(); + }); + } + + #bindButton(elId, key, fire) { + const el = document.getElementById(elId); + if (!el) return; + this.#on(el, "pointerdown", (e) => { + e.preventDefault(); + this.pressed[key] = true; + el.classList.add("down"); + fire(); // on the press edge, not the release: arcade latency + try { el.setPointerCapture(e.pointerId); } catch {} + }); + const release = () => { + this.pressed[key] = false; + el.classList.remove("down"); + }; + this.#on(el, "pointerup", release); + this.#on(el, "pointercancel", release); + } +} diff --git a/app/src/game/duck.js b/app/src/game/duck.js new file mode 100644 index 0000000..691af84 --- /dev/null +++ b/app/src/game/duck.js @@ -0,0 +1,339 @@ +// Standalone JS port of microduck_app's src/duck/kinematics.ts. +// Loads kinematics.json (built from the MJCF by build_kinematics.py) and +// builds an Object3D tree with one Group per body. Joints become per-body +// local rotations driven by setJointAngles / setJoint. + +import * as THREE from "three"; +import { STLLoader } from "three/addons/loaders/STLLoader.js"; +import { mergeVertices, toCreasedNormals } from "three/addons/utils/BufferGeometryUtils.js"; + +// Cache-busting version appended to every STL request. python http.server +// sends no Cache-Control, so browsers apply heuristic caching keyed on +// Last-Modified and can keep serving stale mesh bytes even after the files +// change on disk. Bump this whenever the mesh files are regenerated. +export const MESH_VERSION = "8"; + +// Default model directory: the complete mjlab export (converted from +// robot_walk.xml by tools/mjcf_to_kinematics.py). robot/v1.5/ and +// robot/alpha/ stay on disk for reference but the code no longer +// targets them. +export const MODEL_DIR = "./robot/mjlab"; + +// On a private HF Space, asset requests carry the ?__sign JWT (auth +// cookies may be blocked in the hub iframe). Identity everywhere else. +import { signed } from "./signed.js"; + +// Meshes fully occluded inside the shells at every demo camera angle, +// verified empirically by per-mesh pixel-diff (front 3/4, back, low +// front close-up): hiding each changes exactly 0 pixels. Skipped at +// load time so their bytes are never fetched. Load everything with +// `?all=1` for debugging. +const HIDDEN_MESHES = new Set([]); + +export async function loadKinematics(url) { + // Same cache-buster as the STLs: force-cache would otherwise keep + // serving a stale kinematics.json after the mesh list changes. + const r = await fetch(signed(`${url}?v=${MESH_VERSION}`), { cache: "force-cache" }); + if (!r.ok) throw new Error(`kinematics fetch ${r.status}`); + const k = await r.json(); + // Full-resolution meshes by default (the reduction will be redone + // interactively in Blender later). `?lite=1` opts into a decimated + // meshes-lite/ sibling if present. + if (new URLSearchParams(location.search).get("lite") === "1") { + k.mesh_dir = k.mesh_dir.replace(/\/meshes$/, "/meshes-lite"); + } + return k; +} + +// Materials are PBR (MeshStandardMaterial), same family as the Reachy +// mobile app's glb viewer. Optional silhouette outlines via three's +// OutlineEffect - see main.js. + +export async function buildRig(k, opts = {}) { + // placer holds world-space position + yaw (no axis-conversion). + const placer = new THREE.Group(); + placer.name = "duck_placer"; + // root applies the MJCF +Z up -> three.js +Y up convention fix. + const root = new THREE.Group(); + root.name = "duck_root"; + root.rotation.x = -Math.PI / 2; + placer.add(root); + + const bodies = new Map(); + const joints = new Map(); + const loader = new STLLoader(); + + // STL files carry per-facet normals, which shade as a faceted mess. + // Weld vertices, then rebuild normals with a crease angle: curved + // surfaces smooth out, machined edges stay hard - the cel look needs + // both. Two scale/attribute pitfalls here: + // - mergeVertices hashes ALL attributes, so the per-facet STL normals + // must be dropped first or coincident vertices never merge. + // - toCreasedNormals groups vertices on a fixed 0.01-unit hash grid. + // Our meshes are in meters, so that grid is 1 cm: normals of vertices + // up to a centimeter apart get averaged together, which shades like a + // heavily decimated mesh. Scaling to mm makes the grid 10 um. + const CREASE = Math.PI / 5; // 36 deg + const meshCache = new Map(); + const loadMesh = (name) => { + if (!meshCache.has(name)) { + meshCache.set( + name, + loader.loadAsync(signed(`${k.mesh_dir}/${name}?v=${MESH_VERSION}`)).then((raw) => { + raw.deleteAttribute("normal"); + const welded = mergeVertices(raw, 1e-4); + welded.scale(1000, 1000, 1000); + const display = toCreasedNormals(welded, CREASE); + display.scale(1e-3, 1e-3, 1e-3); + welded.scale(1e-3, 1e-3, 1e-3); + return { display, welded }; + }), + ); + } + return meshCache.get(name); + }; + + for (const b of k.bodies) { + const g = new THREE.Group(); + g.name = b.name; + g.position.set(b.pos[0], b.pos[1], b.pos[2]); + g.quaternion.set(b.quat[1], b.quat[2], b.quat[3], b.quat[0]); + bodies.set(b.name, g); + } + for (const b of k.bodies) { + const g = bodies.get(b.name); + if (b.parent && bodies.has(b.parent)) bodies.get(b.parent).add(g); + else root.add(g); + } + for (const b of k.bodies) { + if (!b.joint || (b.joint.type && b.joint.type !== "hinge")) continue; + const g = bodies.get(b.name); + joints.set(b.joint.name, { + body: g, + axis: new THREE.Vector3(...b.joint.axis).normalize(), + baseQuat: g.quaternion.clone(), + range: b.joint.range ?? null, + }); + } + + // Cache materials by their resolved PBR props so identical parts share + // one GPU material instance. + const matCache = new Map(); + // Optional (meshName, bodyName, rgba) -> material spec hook. A spec is + // { color: [r,g,b], roughness, metalness, opacity? }; plain rgba arrays + // are also accepted for backwards compat. + const materialForMesh = opts.materialForMesh ?? null; + const matFor = (spec) => { + const color = spec.color; + const roughness = spec.roughness ?? 0.5; + const metalness = spec.metalness ?? 0.0; + const opacity = spec.opacity ?? 1; + const key = `${color.join(",")}|${roughness}|${metalness}|${opacity}`; + const cached = matCache.get(key); + if (cached) return cached; + const m = new THREE.MeshStandardMaterial({ + color: new THREE.Color(...color), + roughness, + metalness, + transparent: opacity < 1, + opacity, + }); + matCache.set(key, m); + return m; + }; + const toSpec = (v, fallbackRgba) => { + if (!v) return { color: fallbackRgba.slice(0, 3), opacity: fallbackRgba[3] ?? 1 }; + if (Array.isArray(v)) return { color: v.slice(0, 3), opacity: v[3] ?? 1 }; + return v; + }; + + // Optional interior ink lines: hard edges above the threshold angle + // drawn as line segments, comic style. Cached per mesh file. + const inkOpts = opts.inkEdges ?? null; + const inkMat = inkOpts + ? new THREE.LineBasicMaterial({ + color: inkOpts.color ?? 0x0a0a0e, + transparent: true, + opacity: inkOpts.opacity ?? 0.55, + }) + : null; + const edgeCache = new Map(); + const edgesFor = (name, welded) => { + if (!edgeCache.has(name)) { + edgeCache.set(name, new THREE.EdgesGeometry(welded, inkOpts.threshold ?? 40)); + } + return edgeCache.get(name); + }; + + const pending = []; + const loadAll = new URLSearchParams(location.search).get("all") === "1"; + // The MJCF lists a few geoms twice with identical transforms (visual + + // collision copies of power_support, soles, legs); drawing both would + // only z-fight, so exact duplicates are skipped. + const seenGeoms = new Set(); + for (const b of k.bodies) { + const g = bodies.get(b.name); + if (!g) continue; + for (const geom of b.geoms) { + if (geom.type && geom.type !== "mesh") continue; + if (!geom.mesh) continue; + if (!loadAll && HIDDEN_MESHES.has(geom.mesh)) continue; + const dupKey = `${b.name}|${geom.mesh}|${geom.pos}|${geom.quat}`; + if (seenGeoms.has(dupKey)) continue; + seenGeoms.add(dupKey); + pending.push( + loadMesh(geom.mesh).then(({ display, welded }) => { + const rgba = geom.color + ? [geom.color[0], geom.color[1], geom.color[2], geom.color[3] ?? 1] + : [0.85, 0.85, 0.85, 1]; + const spec = toSpec(materialForMesh?.(geom.mesh, b.name, rgba), rgba); + const m = new THREE.Mesh(display, matFor(spec)); + // Mesh filename tag so callers can re-skin materials in place + // (survives cloneRig: Object3D.copy deep-copies userData). + m.userData.meshName = geom.mesh; + if (geom.pos) m.position.set(...geom.pos); + if (geom.quat) m.quaternion.set(geom.quat[1], geom.quat[2], geom.quat[3], geom.quat[0]); + g.add(m); + if (inkMat) { + const lines = new THREE.LineSegments(edgesFor(geom.mesh, welded), inkMat); + lines.position.copy(m.position); + lines.quaternion.copy(m.quaternion); + g.add(lines); + } + }), + ); + } + } + await Promise.all(pending); + + const rig = { placer, root, bodies, joints }; + setupJawPivot(rig); + return rig; +} + +// ── Jaw hinge ─────────────────────────────────────────────────────────── +// The mjlab model has no passive jaw joints: jaw.stl / jaw_soft.stl are +// rigid geoms of the head body (named "jaw_soft" in the MJCF, it carries +// the head_roll joint). The quack re-creates the hinge in JS: both jaw +// meshes are reparented into a "jaw_pivot" group +// whose origin sits on the rear top edge of their combined bounding box +// (the physical hinge line), and setJawOpen rotates that pivot about the +// robot's left-right axis so the beak tip swings down. +const JAW_MESH_NAMES = new Set(["jaw.stl", "jaw_soft.stl"]); +export const JAW_MAX_OPEN = 0.32; // rad at openness 1 + +function setupJawPivot(rig) { + const meshes = []; + rig.root.traverse((o) => { + if (o.isMesh && JAW_MESH_NAMES.has(o.userData.meshName)) meshes.push(o); + }); + if (!meshes.length) return; + const body = meshes[0].parent; + // The placer is still untransformed right after buildRig, so world + // coords == placer coords here: robot forward is +X, up is +Y. + rig.placer.updateWorldMatrix(true, true); + const box = new THREE.Box3(); + for (const m of meshes) box.expandByObject(m); + const hingeW = new THREE.Vector3(box.min.x, box.max.y, (box.min.z + box.max.z) / 2); + // +angle about -Z rotates the +X beak tip toward -Y (down). + const axisW = new THREE.Vector3(0, 0, -1); + const bodyQuatInv = body.getWorldQuaternion(new THREE.Quaternion()).invert(); + const hingeL = body.worldToLocal(hingeW.clone()); + const axisL = axisW.applyQuaternion(bodyQuatInv).normalize(); + const pivot = new THREE.Group(); + pivot.name = "jaw_pivot"; + pivot.position.copy(hingeL); + // Plain array so Object3D.copy's JSON userData clone preserves it. + pivot.userData.jawAxis = axisL.toArray(); + body.add(pivot); + for (const m of meshes) { + m.position.sub(hingeL); + pivot.add(m); + } +} + +// Open the beak: 0 = closed, 1 = fully open (JAW_MAX_OPEN rad). The pivot +// is resolved lazily by name so clones from cloneRig work transparently. +const _jawAxis = new THREE.Vector3(); +export function setJawOpen(rig, open) { + if (rig._jawPivot === undefined) { + rig._jawPivot = rig.placer.getObjectByName("jaw_pivot") ?? null; + } + const pivot = rig._jawPivot; + if (!pivot) return; + _jawAxis.fromArray(pivot.userData.jawAxis); + pivot.quaternion.setFromAxisAngle(_jawAxis, JAW_MAX_OPEN * open); +} + +// Set one named joint, clamped to its MJCF range when known. +export function setJoint(rig, name, angle) { + const j = rig.joints.get(name); + if (!j) return; + let a = angle; + if (j.range) a = Math.min(j.range[1], Math.max(j.range[0], a)); + const rot = _q.setFromAxisAngle(j.axis, a); + j.body.quaternion.copy(j.baseQuat).multiply(rot); +} +const _q = new THREE.Quaternion(); + +export function applyPose(rig, pose) { + for (const [name, ang] of Object.entries(pose)) setJoint(rig, name, ang); +} + +// Deep-clone a built rig without re-parsing the STL files: Object3D.clone +// shares geometry and materials, so N clones cost almost nothing on top of +// the first buildRig. The bodies/joints maps are rebuilt by looking up the +// cloned nodes by name (body names are unique in the MJCF). +export function cloneRig(rig) { + const placer = rig.placer.clone(true); + const root = placer.getObjectByName("duck_root"); + const bodies = new Map(); + for (const name of rig.bodies.keys()) { + bodies.set(name, placer.getObjectByName(name)); + } + const joints = new Map(); + for (const [name, j] of rig.joints) { + joints.set(name, { + body: placer.getObjectByName(j.body.name), + axis: j.axis, // read-only, safe to share + baseQuat: j.baseQuat.clone(), + range: j.range, + }); + } + return { placer, root, bodies, joints }; +} + +// Ground using the whole rig's bounding box (sitting pose folds the legs +// under the trunk, so the feet are not the lowest point). +const _box = new THREE.Box3(); +export function groundFullBody(rig, floorY = 0) { + rig.placer.updateWorldMatrix(true, true); + _box.setFromObject(rig.placer); + if (!Number.isFinite(_box.min.y)) return 0; + rig.placer.position.y += floorY - _box.min.y; + return floorY - _box.min.y; +} + +// "SIT" keyframe. The mjlab model shares alpha's conventions (same +// onshape-to-robot pipeline): neck_pitch range max is 1.0472, so +// neck_pitch sits just under it (headroom for the breathing oscillation, +// +-0.025) and head_pitch compensates to keep the head level-ish with a +// slight upward tilt toward the camera. NOTE: head_pitch sign is +// inverted vs v1.5 (positive = head down), so the compensation is +// positive here (verified visually). +export const SITTING_POSE = { + left_hip_yaw: 0.0, + left_hip_roll: 0.0, + left_hip_pitch: -0.5236, + left_knee: 1.0472, + left_ankle: 0.0, + neck_pitch: 1.02, + head_pitch: 0.9, + head_yaw: 0.0, + head_roll: 0.0, + right_hip_yaw: 0.0, + right_hip_roll: 0.0, + right_hip_pitch: 0.5236, + right_knee: -1.0472, + right_ankle: 0.0, +}; diff --git a/app/src/game/fx/demo-glitch.html b/app/src/game/fx/demo-glitch.html new file mode 100644 index 0000000..91b790d --- /dev/null +++ b/app/src/game/fx/demo-glitch.html @@ -0,0 +1,140 @@ + + + + + + fx demo - glitch materialization + + + + +
+ +
loading rig...
+ + + diff --git a/app/src/game/fx/demo-wireframe.html b/app/src/game/fx/demo-wireframe.html new file mode 100644 index 0000000..24d7dbb --- /dev/null +++ b/app/src/game/fx/demo-wireframe.html @@ -0,0 +1,113 @@ + + + + + + FX demo - holographic wireframe scan-up + + + + +
+
+ FX: HOLOGRAPHIC WIREFRAME SCAN-UP
+ +
+ + + diff --git a/app/src/game/fx/fx-glitch.js b/app/src/game/fx/fx-glitch.js new file mode 100644 index 0000000..085e500 --- /dev/null +++ b/app/src/game/fx/fx-glitch.js @@ -0,0 +1,311 @@ +// Cyberpunk 2077-style glitch materialization for the Microduck rig. +// +// The duck appears as stacked horizontal slices that flicker in and out +// with random screen-space horizontal offsets, converging to their true +// position. Chromatic aberration is faked with two additive silhouette +// ghosts (cyan / orange) offset left-right, digital noise blocks flash +// emissive or invert the surface colour, and a final warm flash "snaps" +// everything crisp. +// +// Implementation: onBeforeCompile injections on CACHED clones of the rig +// materials (same pattern and same program-cache trap as the entrance +// dissolve in rl.js: clones are cached per original material and reused +// on every replay, each with a unique customProgramCacheKey, otherwise +// three.js would reuse a compiled program without re-binding uniforms). +// All uniforms are shared singleton objects so one JS write per frame +// drives every material. + +export const name = "glitch"; + +const DURATION = 1.15; // seconds +const TICK_HZ = 30; // discrete glitch update rate (digital feel) +const SLICES = 24; + +// ── Shared uniforms (one instance drives all cloned materials) ────────── +const uP = { value: 0 }; // progress 0..1 (0 = invisible) +const uSeed = { value: 0 }; // discrete tick, drives all hashes +const uAmp = { value: 0 }; // slice offset amplitude (view-space meters) +const uFlash = { value: 0 }; // final snap flash intensity +const uGhostOff = { value: 0 }; // RGB-split ghost separation (meters) +const uB = { value: null }; // vec4(minY, height, sliceH, 0) world bounds + +let T = null; // injected THREE namespace +let rigRef = null; +let playing = false; +let scrubbed = false; +let done = true; +let elapsed = 0; + +// Deterministic JS-side hash, mirrors the GLSL one. +const jhash = (n) => { + const s = Math.sin(n * 127.1 + 311.7) * 43758.5453; + return s - Math.floor(s); +}; + +// ── GLSL injection ────────────────────────────────────────────────────── +const GLSL_HELPERS = /* glsl */ ` +varying vec3 vGlW; +uniform float uGlP, uGlSeed; +uniform vec4 uGlB; +float glHash2(vec2 q) { return fract(sin(dot(q, vec2(127.1, 311.7))) * 43758.5453); } +vec3 glHash3(vec2 q) { return vec3(glHash2(q), glHash2(q + 17.17), glHash2(q + 31.3)); } +`; + +function injectGlitch(shader, { signU = null, ghost = false } = {}) { + shader.uniforms.uGlP = uP; + shader.uniforms.uGlSeed = uSeed; + shader.uniforms.uGlAmp = uAmp; + shader.uniforms.uGlFlash = uFlash; + shader.uniforms.uGlGhostOff = uGhostOff; + shader.uniforms.uGlSign = signU ?? { value: 0 }; + shader.uniforms.uGlB = uB; + + shader.vertexShader = shader.vertexShader + .replace( + "#include ", + "#include \n" + GLSL_HELPERS + "uniform float uGlAmp, uGlSign, uGlGhostOff;\n", + ) + .replace( + "#include ", + /* glsl */ `#include +vec4 glWp = modelMatrix * vec4(transformed, 1.0); +vGlW = glWp.xyz; +if (uGlP < 1.0) { + float glSid = floor((glWp.y - uGlB.x) / uGlB.z); + // Fraction of moving slices shrinks as p rises: convergence. + float glMove = step(0.25 + 0.62 * uGlP, glHash2(vec2(glSid * 1.71 + 4.2, uGlSeed + 13.0))); + float glOff = (glHash2(vec2(glSid, uGlSeed)) - 0.5) * 2.0 * uGlAmp * glMove; + // Occasional whole-body frame jump for one tick. + if (glHash2(vec2(uGlSeed, 3.17)) > 0.86) { + glOff += (glHash2(vec2(uGlSeed, 9.91)) - 0.5) * 3.0 * uGlAmp; + } + glOff += uGlSign * uGlGhostOff; + // View-space X = screen-horizontal, the classic spawn-glitch axis. + mvPosition.x += glOff; + gl_Position = projectionMatrix * mvPosition; +}`, + ); + + const sliceDiscard = /* glsl */ ` +float glEdge = 0.0, glInvAmt = 0.0; +vec3 glAddC = vec3(0.0); +if (uGlP < 1.0) { + float glSid = floor((vGlW.y - uGlB.x) / uGlB.z); + float glH = glHash2(vec2(glSid, uGlSeed + 0.7)); + float glVis = smoothstep(0.02, 0.82, uGlP) * 1.35; + // Two-three full-silhouette pre-flashes right at the start. + float glPre = (uGlP > 0.015 && uGlP < 0.14 && glHash2(vec2(uGlSeed, 7.7)) > 0.72) ? 1.0 : 0.0; + glVis = max(glVis, glPre); + if (glH > glVis) discard; + glEdge = max(glPre * 0.7, (1.0 - smoothstep(0.0, 0.3, glVis - glH)) * (1.0 - uGlP)); +${ghost ? "" : /* glsl */ ` + // Digital noise blocks: world-space rectangular patches, re-seeded per + // tick. Some invert the surface colour, most flash emissive. + vec2 glBq = floor((vGlW.xy + vec2(vGlW.z * 0.7, vGlW.z * 0.3)) * 52.0 + + vec2(uGlSeed * 0.373, uGlSeed * 0.719)); + vec3 glBh = glHash3(glBq + uGlSeed); + float glBGate = (1.0 - uGlP) * 0.16; + if (glBh.x > 1.0 - glBGate) { + if (glBh.y < 0.3) glInvAmt = 1.0; + else glAddC += (glBh.z < 0.6 ? vec3(0.15, 1.3, 1.5) + : (glBh.z < 0.85 ? vec3(1.4) : vec3(1.6, 0.5, 0.06))) * (0.7 + glBh.y); + } + // Faint rolling scanline shimmer. + glAddC += vec3(0.05, 0.3, 0.35) * (1.0 - uGlP) * 0.18 + * step(0.6, fract(vGlW.y * 150.0 - uGlSeed * 0.21)); +`} +}`; + + const emissiveOut = ghost + ? "" // ghosts are pre-tinted additive silhouettes, no extra emissive + : /* glsl */ ` +gl_FragColor.rgb = mix(gl_FragColor.rgb, vec3(1.1) - gl_FragColor.rgb, glInvAmt); +gl_FragColor.rgb += glAddC; +gl_FragColor.rgb += glEdge * vec3(0.25, 1.15, 1.35); +gl_FragColor.rgb += uGlFlash * vec3(1.25, 0.7, 0.35);`; + + shader.fragmentShader = shader.fragmentShader + .replace( + "#include ", + "#include \n" + GLSL_HELPERS + "uniform float uGlFlash;\n", + ) + .replace("#include ", "#include " + sliceDiscard) + .replace("#include ", "#include " + emissiveOut); +} + +// ── Material clones (cached, never disposed between replays) ──────────── +const clones = new Map(); // original material uuid -> glitch clone +let cloneNonce = 0; +let saved = null; // Array<[mesh, originalMat, cloneMat]> while active + +function cloneFor(orig) { + let m = clones.get(orig.uuid); + if (m) return m; + m = orig.clone(); + m.onBeforeCompile = (shader) => injectGlitch(shader); + const key = `microduck-glitch-${cloneNonce++}`; + m.customProgramCacheKey = () => key; + m.needsUpdate = true; + clones.set(orig.uuid, m); + return m; +} + +function applyGlitchMats() { + if (saved) return; + saved = []; + rigRef.placer.traverse((o) => { + if (!o.isMesh || o.userData.glGhost) return; + const orig = o.material; + const m = cloneFor(orig); + saved.push([o, orig, m]); + o.material = m; + }); +} + +function restoreMats() { + if (!saved) return; + for (const [mesh, orig, clone] of saved) { + if (mesh.material === clone) mesh.material = orig; + } + saved = null; +} + +// ── RGB-split ghosts ──────────────────────────────────────────────────── +// Two additive unlit silhouette copies of every rig mesh (cyan right, +// orange left), sharing the slice-discard shader so their outline always +// matches the sliced duck. Added as children of each mesh: they inherit +// the full kinematic transform for free. +let ghostMats = []; +let ghostMeshes = []; + +function makeGhostMat(r, g, b, sign) { + const m = new T.MeshBasicMaterial({ + transparent: true, + opacity: 0, + depthWrite: false, + blending: T.AdditiveBlending, + }); + m.color.setRGB(r, g, b); + const signU = { value: sign }; + m.onBeforeCompile = (shader) => injectGlitch(shader, { signU, ghost: true }); + m.customProgramCacheKey = () => `microduck-glitch-ghost-${sign > 0 ? "r" : "l"}`; + return m; +} + +function buildGhosts() { + ghostMats = [makeGhostMat(0.0, 1.1, 1.3, +1), makeGhostMat(1.3, 0.35, 0.02, -1)]; + const hosts = []; + rigRef.placer.traverse((o) => { + if (o.isMesh && !o.userData.glGhost) hosts.push(o); + }); + for (const mesh of hosts) { + for (const mat of ghostMats) { + const gm = new T.Mesh(mesh.geometry, mat); + gm.userData.glGhost = true; + gm.renderOrder = 2; + gm.frustumCulled = false; + gm.visible = false; + mesh.add(gm); + ghostMeshes.push(gm); + } + } +} + +function setGhostsVisible(v) { + for (const gm of ghostMeshes) gm.visible = v; +} + +// ── Deterministic per-progress uniform state ──────────────────────────── +// Everything derives from p alone (tick included), so setProgress(p) gives +// reproducible frames for debugging/screenshots. +function setUniformsFor(p) { + uP.value = p; + const tick = Math.floor(p * DURATION * TICK_HZ); + uSeed.value = tick; + const h = uB.value.y; // duck height + const gate = 0.35 + 0.65 * jhash(tick + 3.7); + uAmp.value = p < 0.92 ? h * 0.3 * Math.pow(1 - p, 1.3) * gate : 0; + uGhostOff.value = + p > 0.04 && p < 0.9 ? (0.06 + 0.3 * jhash(tick + 11.1)) * (1 - p) * h : 0; + uFlash.value = p > 0.86 ? 1.5 * Math.exp(-16 * (p - 0.86) * DURATION) : 0; + const ghostOp = + p > 0.04 && p < 0.9 ? (0.05 + 0.32 * (1 - p)) * (0.4 + 0.6 * jhash(tick + 5.5)) : 0; + for (const m of ghostMats) m.opacity = ghostOp; +} + +function finish() { + uP.value = 1; + uFlash.value = 0; + setGhostsVisible(false); + restoreMats(); + playing = false; + done = true; +} + +// ── Public interface ──────────────────────────────────────────────────── +export function init({ THREE, scene, rig, camera, renderer }) { + T = THREE; + rigRef = rig; + rig.placer.updateWorldMatrix(true, true); + const box = new T.Box3().setFromObject(rig.placer); + const minY = box.min.y; + const height = Math.max(1e-3, box.max.y - minY); + uB.value = new T.Vector4(minY, height, height / SLICES, 0); + buildGhosts(); + // Duck starts invisible: p=0 discards every fragment. + uP.value = 0; + applyGlitchMats(); + done = true; + playing = false; +} + +export function start() { + applyGlitchMats(); + setGhostsVisible(true); + elapsed = 0; + playing = true; + scrubbed = false; + done = false; + setUniformsFor(0); +} + +export function update(dt, t) { + if (!playing || scrubbed) return; + elapsed += dt; + const p = Math.min(1, elapsed / DURATION); + setUniformsFor(p); + if (p >= 1) finish(); +} + +export function isDone() { + return done; +} + +export function dispose() { + restoreMats(); + for (const gm of ghostMeshes) gm.parent?.remove(gm); + ghostMeshes = []; + for (const m of ghostMats) m.dispose(); + ghostMats = []; + for (const m of clones.values()) m.dispose(); + clones.clear(); + playing = false; + done = true; + rigRef = null; +} + +// Debug hook: freeze the effect at an exact progress value (deterministic, +// used by the demo page for mid-effect screenshots). start() resumes +// normal playback. +export function setProgress(p) { + scrubbed = true; + if (p >= 1) { + finish(); + return; + } + playing = true; + done = false; + applyGlitchMats(); + setGhostsVisible(true); + setUniformsFor(Math.max(0, p)); +} diff --git a/app/src/game/fx/fx-wireframe.js b/app/src/game/fx/fx-wireframe.js new file mode 100644 index 0000000..064307b --- /dev/null +++ b/app/src/game/fx/fx-wireframe.js @@ -0,0 +1,323 @@ +// Holographic wireframe scan-up materialization effect. +// +// Sequence (~0.9 s, reversible): +// 1. An invisible scan height rises from the floor through the target; +// the boundary reads on the surface itself (bright wireframe band +// right under the scan height - no standalone disc geometry). +// 2. Below the scan line the target shows as a flickering additive +// wireframe hologram (scanline stripes, brightness boost near the +// scan line). +// 3. A second, fainter "solidify" line trails behind: fragments below +// it render the real PBR materials (world-Y clip injected via +// onBeforeCompile), with a hot edge right at the line. Once it +// clears the top the original materials are restored directly. +// +// Played backwards, the same timeline de-materializes (solid peel -> +// hologram -> gone). Used for the ball despawn; the duck only ever +// materializes. +// +// createWireframeFx() returns an independent instance (duck and ball +// scan at the same time without sharing uniforms). The module-level +// named exports wrap a singleton so demo-wireframe.html is unchanged. +// +// Instance interface: +// init({ THREE, scene, rig | root, camera, renderer, hidden? }) +// start() / startReverse() / update(dt) / isDone() / restore() / dispose() +// Extra: setProgress(p), playing, reversing, TOTAL_S. + +export const name = "wireframe"; + +// ── Timeline (seconds) ────────────────────────────────────────────────── +const SCAN_S = 0.6; // wireframe scan line: floor -> top +const SOLID_DELAY_S = 0.3; // solidify line starts this long after the scan +const SOLID_S = 0.6; // solidify line: floor -> top +export const TOTAL_S = SOLID_DELAY_S + SOLID_S; // 0.9 + +const clamp01 = (x) => Math.min(Math.max(x, 0), 1); +// Ease-out only: the rise starts at full speed the instant the scan cues +// (a smoothstep ease-in reads as a stall near the feet) and lands softly. +const ease = (x) => 1 - (1 - x) * (1 - x); + +// Deterministic pseudo-random flicker so setProgress(p) captures are +// reproducible (no Math.random). +const hash = (x) => { + const s = Math.sin(x * 127.1) * 43758.5453; + return s - Math.floor(s); +}; +const flickerAt = (time) => { + let f = 0.82 + 0.18 * hash(Math.floor(time * 60) + 0.5); + if (hash(Math.floor(time * 24) + 7.7) < 0.12) f *= 0.5; // dropouts + return f; +}; + +// Unique customProgramCacheKey values across every instance: a fresh +// clone of the same source material would otherwise reuse the compiled +// program without re-running onBeforeCompile, leaving clip uniforms +// unbound (see the dissolve comment in rl.js). +let clipNonce = 0; + +const BOTTOM_PAD = 0.025; + +export function createWireframeFx() { + // Per-instance uniforms: duck and ball must not share a scan height. + const uScanY = { value: -1e3 }; + const uSolidY = { value: -1e3 }; + const uFlicker = { value: 1 }; + const uTime = { value: 0 }; + + let ctx = null; // { THREE, scene, root, camera, renderer } + let t = 0; + let dir = 1; // +1 materialize, -1 dematerialize + let playing = false; + let finished = false; + + let minY = 0; + let spanY = 0.3; + + const clipClones = new Map(); + let clipSaved = null; // Array<[mesh, originalMat, cloneMat]> while active + + let wireMat = null; + let wireMeshes = []; + + const isTargetMesh = (o) => o.isMesh && !o.userData.fxOverlay; + + function clipCloneFor(orig) { + let m = clipClones.get(orig.uuid); + if (m) return m; + m = orig.clone(); + m.onBeforeCompile = (shader) => { + shader.uniforms.uFxSolidY = uSolidY; + shader.vertexShader = shader.vertexShader + .replace("#include ", "#include \nvarying vec3 vFxW;") + .replace( + "#include ", + "#include \nvFxW = (modelMatrix * vec4(transformed, 1.0)).xyz;", + ); + shader.fragmentShader = shader.fragmentShader + .replace( + "#include ", + "#include \nvarying vec3 vFxW;\nuniform float uFxSolidY;", + ) + .replace( + "#include ", + /* glsl */ `#include +float fxEdge = 0.0; +if (vFxW.y > uFxSolidY) discard; +fxEdge = 1.0 - smoothstep(0.002, 0.018, uFxSolidY - vFxW.y);`, + ) + .replace( + "#include ", + /* glsl */ `#include +gl_FragColor.rgb += fxEdge * vec3(0.95, 0.32, 0.05);`, + ); + }; + const key = `microduck-fx-wireframe-${clipNonce++}`; + m.customProgramCacheKey = () => key; + m.needsUpdate = true; + clipClones.set(orig.uuid, m); + return m; + } + + function applyClipMaterials() { + if (clipSaved) return; + clipSaved = []; + ctx.root.traverse((o) => { + if (!isTargetMesh(o)) return; + const orig = o.material; + const clone = clipCloneFor(orig); + clipSaved.push([o, orig, clone]); + o.material = clone; + }); + } + + function restoreClipMaterials() { + if (!clipSaved) return; + for (const [mesh, orig, clone] of clipSaved) { + if (mesh.material === clone) mesh.material = orig; + } + clipSaved = null; + } + + function makeWireMaterial(THREE) { + return new THREE.ShaderMaterial({ + uniforms: { uScanY, uSolidY, uFlicker, uTime }, + vertexShader: /* glsl */ ` + varying vec3 vW; + void main() { + vec4 wp = modelMatrix * vec4(position, 1.0); + vW = wp.xyz; + gl_Position = projectionMatrix * viewMatrix * wp; + }`, + fragmentShader: /* glsl */ ` + uniform float uScanY, uSolidY, uFlicker, uTime; + varying vec3 vW; + void main() { + if (vW.y > uScanY || vW.y < uSolidY) discard; + float lead = 1.0 - smoothstep(0.0, 0.06, uScanY - vW.y); + float tail = smoothstep(0.0, 0.018, vW.y - uSolidY); + float stripes = 0.7 + 0.3 * sin(vW.y * 900.0 - uTime * 45.0); + vec3 c = vec3(1.0, 0.34, 0.06) * (0.55 + 1.6 * lead); + float a = (0.10 + 0.40 * lead) * stripes * tail * uFlicker; + gl_FragColor = vec4(c, a); + }`, + wireframe: true, + transparent: true, + blending: THREE.AdditiveBlending, + depthWrite: false, + depthTest: true, + }); + } + + function buildWireOverlays(THREE, root) { + wireMat = makeWireMaterial(THREE); + root.traverse((o) => { + if (!isTargetMesh(o)) return; + // Child of the source mesh with identity transform so the overlay + // follows whatever pose the caller writes (duck joints or ball qpos). + // userData.fxWireGeometry substitutes a coarser geometry for the + // wireframe pass only (the ball's render sphere is too dense to read + // as a hologram); the solidify clip still runs on the real mesh. + const w = new THREE.Mesh(o.userData.fxWireGeometry ?? o.geometry, wireMat); + w.userData.fxOverlay = true; + w.renderOrder = 5; + w.visible = false; + o.add(w); + wireMeshes.push(w); + }); + } + + function applyAt(time) { + const scanP = ease(clamp01(time / SCAN_S)); + const solidP = ease(clamp01((time - SOLID_DELAY_S) / SOLID_S)); + uFlicker.value = flickerAt(time); + uTime.value = time; + + const jitter = scanP > 0 && scanP < 1 ? (hash(time * 41.3) - 0.5) * 0.02 * spanY : 0; + uScanY.value = minY + spanY * scanP + jitter; + uSolidY.value = minY + spanY * solidP; + + const wiresOn = time > 0 && solidP < 1; + for (const w of wireMeshes) w.visible = wiresOn; + } + + function finish() { + // Forward: restore the real materials (fully solid). Reverse: leave + // the clip parked at t=0 (fully hidden) so restoring wouldn't flash + // the solid mesh for a frame; the caller hides the object then + // restore()s. + if (dir > 0) restoreClipMaterials(); + else applyAt(0); + for (const w of wireMeshes) w.visible = false; + finished = true; + playing = false; + } + + function computeRange() { + const { THREE, root } = ctx; + root.updateWorldMatrix(true, true); + const box = new THREE.Box3().setFromObject(root); + minY = Math.min(box.min.y, 0) - BOTTOM_PAD; + spanY = Math.max(box.max.y - minY, 0.04) * 1.06; + } + + function arm(nextDir, resetT) { + dir = nextDir; + if (resetT) t = nextDir > 0 ? 0 : TOTAL_S; + finished = false; + computeRange(); + applyClipMaterials(); + applyAt(t); + playing = true; + } + + function init({ THREE, scene, rig, root, camera, renderer, hidden = true }) { + const target = root ?? rig.placer; + ctx = { THREE, scene, root: target, camera, renderer }; + computeRange(); + buildWireOverlays(THREE, target); + t = 0; + dir = 1; + finished = false; + playing = false; + if (hidden) { + applyClipMaterials(); + applyAt(0); + } + } + + function start() { + // Mid-reverse: keep the current t and turn around. Fresh play: from 0. + arm(1, !playing); + } + + function startReverse() { + arm(-1, !playing); + } + + function update(dt) { + if (!playing || finished) return; + t += dir * dt; + if (dir > 0 && t >= TOTAL_S) { + t = TOTAL_S; + applyAt(t); + finish(); + return; + } + if (dir < 0 && t <= 0) { + t = 0; + applyAt(t); + finish(); + return; + } + applyAt(t); + } + + function isDone() { + return finished; + } + + function setProgress(p) { + playing = false; + finished = false; + dir = 1; + computeRange(); + applyClipMaterials(); + t = clamp01(p) * TOTAL_S; + applyAt(t); + } + + function restore() { + restoreClipMaterials(); + } + + function dispose() { + restoreClipMaterials(); + for (const w of wireMeshes) w.parent?.remove(w); + wireMeshes = []; + wireMat?.dispose(); + wireMat = null; + ctx = null; + playing = false; + finished = false; + } + + return { + init, start, startReverse, update, isDone, setProgress, restore, dispose, + get playing() { return playing; }, + get reversing() { return playing && dir < 0; }, + TOTAL_S, + }; +} + +// Singleton for the duck (and the isolated demo page). New callers that +// need a second scan (the ball) go through createWireframeFx(). +const singleton = createWireframeFx(); +export const init = (...a) => singleton.init(...a); +export const start = (...a) => singleton.start(...a); +export const startReverse = (...a) => singleton.startReverse(...a); +export const update = (...a) => singleton.update(...a); +export const isDone = (...a) => singleton.isDone(...a); +export const setProgress = (...a) => singleton.setProgress(...a); +export const restore = (...a) => singleton.restore(...a); +export const dispose = (...a) => singleton.dispose(...a); diff --git a/app/src/game/game.js b/app/src/game/game.js new file mode 100644 index 0000000..ad0cc8f --- /dev/null +++ b/app/src/game/game.js @@ -0,0 +1,1305 @@ +// Microduck RL playground core: the REAL trained policies, not a procedural +// waddle. Framework-agnostic port of the pre-React rl.js. +// +// Physics runs in MuJoCo compiled to WebAssembly (the official +// @mujoco/mujoco bindings), stepping the same MJCF the policies were +// trained on (apirrone/mjlab_microduck). The controller is one of the +// exported ONNX checkpoints from apirrone/microduck_runtime, executed with +// onnxruntime-web at 50 Hz (timestep 0.005 s, decimation 4) - exactly the +// loop from mjlab_microduck/scripts/infer_policy.py. +// +// Obs layout (61D, "new-cmd-obs" flavor, from the ONNX metadata): +// [base_ang_vel(3), projected_gravity(3), joint_pos(14), joint_vel(14), +// last_action(14), command(13)] +// +// Integration contract with the React shell: +// - bootGame({ scene, camera, renderer }) is called once from inside the +// R3F canvas; it loads everything, wires inputs and starts the 50 Hz +// control loop. +// - frame(dt) is called by R3F's useFrame every animation frame; it does +// everything the old rAF loop did EXCEPT renderer.render (R3F renders). +// - UI state flows out through the zustand store (throttled), UI intents +// flow back in through gameApi. + +import * as THREE from "three"; +import { OrbitControls } from "three/addons/controls/OrbitControls.js"; +import { GLTFLoader } from "three/addons/loaders/GLTFLoader.js"; +import { signed } from "./signed.js"; +import { + POLICIES, JOINT_NAMES, DEFAULT_POSE, NUM_JOINTS, OBS_SIZE, CMD_SIZE, + ACTION_SCALE, TIMESTEP, DECIMATION, CTRL_DT, + VEL_FWD, VEL_BACK, VEL_ANG, RVEL_FWD, RVEL_BACK, RVEL_ANG, + CROUCH_PERIOD_S, CROUCH_END_PHASE, + BALL_RADIUS, BALL_PARK_POS, ARENA_HALF, SPAWN_X, SPAWN_Y, +} from "./constants.js"; +import { + buildRig, cloneRig, loadKinematics, setJoint, setJawOpen, MODEL_DIR, MESH_VERSION, +} from "./duck.js"; +import { + VARIANTS, VARIANT_NAMES, materialHookFor, DEFAULT_VARIANT, applyVariant, specToHex, +} from "./variants.js"; +import { Controller } from "./controls/controller.js"; +import { KeyboardSource } from "./controls/keyboard.js"; +import { GamepadSource } from "./controls/gamepad.js"; +import { TouchSource } from "./controls/touch.js"; +import * as fx from "./fx/fx-wireframe.js"; +import { createCeremony, CAM_RESET_S } from "./ceremony.js"; +import { createBallActor } from "./ball-actor.js"; +import { initGhosts } from "./ghosts.js"; +import { makeInfiniteGrid, makeArenaWalls } from "./arena.js"; +import { createBallVisual } from "./ball-visual.js"; +import { useGame, gameApi, bootLine, bootNote, bootHalt } from "../store.js"; + +// Physics + inference runtimes stay on the CDN, exactly like the pre-Vite +// app: mujoco.js resolves its .wasm sidecar relative to its own URL, and +// onnxruntime fetches its wasm from wasmPaths - neither ever touches the +// bundle. @vite-ignore keeps Rollup's static analysis out of it. +const MUJOCO_URL = "https://cdn.jsdelivr.net/npm/@mujoco/mujoco@3.11.0/mujoco.js"; +const ORT_URL = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.27.0/dist/ort.min.mjs"; + +// Colour dot shown per variant in the quickbar. Variants can force theirs +// with a `swatch` spec (purple does: its head is warm gray but its +// identity is the purple accents). +const SWATCH_SLOT = { classic: "feet", charcoal: "headDome", purple: "feet", blue: "facePlate" }; +export const VARIANT_SWATCHES = Object.fromEntries( + VARIANT_NAMES.map((name) => { + const v = VARIANTS[name]; + return [name, specToHex(v.swatch ?? v[SWATCH_SLOT[name] ?? "bodyShell"])]; + }), +); + +let bootStarted = false; + +export async function bootGame({ scene, camera, renderer }) { + if (bootStarted) return; + bootStarted = true; + try { + await boot({ scene, camera, renderer }); + } catch (err) { + console.error("[game] boot failed", err); + bootHalt(err?.message || String(err)); + } +} + +async function boot({ scene, camera, renderer }) { + const setStore = useGame.setState; + const store = useGame.getState; + + bootNote("Microduck BIOS v1.0"); + bootLine("MEMORY CHECK")("640K OK"); + bootLine("DUCK FIRMWARE")("PRESENT"); + + // Surface async boot failures in the BIOS halt screen. Gated on the boot + // still being in flight: post-boot async noise (ghost relay hiccups, + // audio autoplay rejections...) must NOT cue the halt screen. + const bootGuard = (e, msg) => { + if (!store().bootDone && !store().bootFailed) bootHalt(msg); + }; + window.addEventListener("unhandledrejection", (e) => { + console.error("[game] unhandled rejection", e.reason); + bootGuard(e, e.reason?.message || String(e.reason)); + }); + window.addEventListener("error", (e) => { + console.error("[game] window error", e.message); + bootGuard(e, e.message); + }); + + // Halting at the failure site: a rejected await inside this async boot + // would otherwise only surface through the caller's catch. + const traced = (label, p) => { + const done = bootLine(label); + return p.then( + (v) => { done("OK"); return v; }, + (err) => { + done("FAILED"); + console.error(`[game] ${label} FAILED`, err); + bootHalt(err?.message || String(err)); + throw err; + }, + ); + }; + + // ── Runtimes (CDN) ────────────────────────────────────────────────── + const [{ default: loadMujocoFactory }, ort] = await traced( + "RUNTIME MODULES", + Promise.all([ + import(/* @vite-ignore */ MUJOCO_URL), + import(/* @vite-ignore */ ORT_URL), + ]), + ); + ort.env.wasm.wasmPaths = "https://cdn.jsdelivr.net/npm/onnxruntime-web@1.27.0/dist/"; + ort.env.wasm.numThreads = 1; // static hosting sends no COOP/COEP headers + + // ── MJCF preparation ──────────────────────────────────────────────── + // robot_allcollisions.xml is what infer_policy.py's scene.xml includes: + // it carries body/shell collision geoms that robot_walk.xml lacks, which + // the sitstand policy needs (a sit rests the trunk on the ground). + // Visual meshes are irrelevant to the dynamics: every body carries an + // explicit , and visual geoms have contype=0 conaffinity=0. + // Stripping them means the MuJoCo VFS only needs the ~10 meshes + // referenced by collision geoms. Works for both variants. + async function buildPhysicsXml(xmlFile) { + const src = await (await fetch(signed(`${MODEL_DIR}/${xmlFile}`))).text(); + const doc = new DOMParser().parseFromString(src, "text/xml"); + for (const g of [...doc.querySelectorAll('geom[class="visual"]')]) g.remove(); + const usedMeshes = new Set( + [...doc.querySelectorAll("geom[mesh]")].map((g) => g.getAttribute("mesh")), + ); + for (const m of [...doc.querySelectorAll("asset > mesh")]) { + const name = m.getAttribute("name") ?? m.getAttribute("file").replace(/\.stl$/i, ""); + if (!usedMeshes.has(name)) m.remove(); + } + const root = doc.documentElement; + const el = (tag, attrs) => { + const e = doc.createElement(tag); + for (const [k, v] of Object.entries(attrs)) e.setAttribute(k, v); + return e; + }; + root.appendChild(el("option", { timestep: String(TIMESTEP) })); + doc.querySelector("worldbody").appendChild( + el("geom", { name: "floor", type: "plane", size: "0 0 0.05", pos: "0 0 0" }), + ); + // Arena walls: four static boxes (no joints, so no qpos/keyframe + // impact); default contype/conaffinity collides with ball and duck. + const ht = 0.05 / 2, hh = 0.25 / 2; + const off = ARENA_HALF + ht, span = ARENA_HALF + 0.05; + const walls = [ + { name: "wall_px", pos: `${off} 0 ${hh}`, size: `${ht} ${span} ${hh}` }, + { name: "wall_nx", pos: `${-off} 0 ${hh}`, size: `${ht} ${span} ${hh}` }, + { name: "wall_py", pos: `0 ${off} ${hh}`, size: `${span} ${ht} ${hh}` }, + { name: "wall_ny", pos: `0 ${-off} ${hh}`, size: `${span} ${ht} ${hh}` }, + ]; + for (const w of walls) { + doc.querySelector("worldbody").appendChild( + el("geom", { name: w.name, type: "box", pos: w.pos, size: w.size }), + ); + } + // Kickable ball: a light free sphere (beach-ball feel). MuJoCo has no + // restitution parameter - the bounce comes from solref damping < 1, and + // the rolling-friction term makes it come to rest. Appended AFTER the + // robot body so the trunk freejoint stays first in qpos. + const ballBody = el("body", { name: "ball", pos: BALL_PARK_POS }); + ballBody.appendChild(el("freejoint", { name: "ball_freejoint" })); + // condim 6 enables the torsional + rolling friction components; with + // the default condim 3 a rolling ball never decelerates. + ballBody.appendChild(el("geom", { + name: "ball_geom", type: "sphere", size: String(BALL_RADIUS), + mass: "0.03", friction: "0.4 0.01 0.003", solref: "0.03 0.4", condim: "6", + })); + doc.querySelector("worldbody").appendChild(ballBody); + // STAND keyframe from mjlab's scene_walk.xml. qpos must cover every + // joint in document order: the 14 actuated hinges take DEFAULT_POSE by + // name, anything else (the roller variant's passive wheels) starts at + // zero. The ball's 7 free-joint values MUST be appended or nq won't + // match; parked 50 m away = effectively absent. + const qposFree = `${SPAWN_X} ${SPAWN_Y} 0.12 1 0 0 0`; + const poseByName = new Map(JOINT_NAMES.map((n, i) => [n, DEFAULT_POSE[i]])); + const qposJoints = [...doc.querySelectorAll("body > joint")] + .map((j) => poseByName.get(j.getAttribute("name")) ?? 0) + .join(" "); + const pose14 = Array.from(DEFAULT_POSE).join(" "); + const kf = doc.createElement("keyframe"); + kf.appendChild(el("key", { + name: "STAND", + qpos: `${qposFree} ${qposJoints} ${BALL_PARK_POS} 1 0 0 0`, + ctrl: pose14, + })); + root.appendChild(kf); + const meshFiles = [...doc.querySelectorAll("asset > mesh")].map((m) => m.getAttribute("file")); + return { xml: new XMLSerializer().serializeToString(doc), meshFiles }; + } + + // ── Boot physics + policy in parallel with the render rig ──────────── + const [mujoco, { xml, meshFiles }, k] = await Promise.all([ + traced("MUJOCO WASM", loadMujocoFactory()), + traced("PHYSICS MJCF", buildPhysicsXml("robot_allcollisions.xml")), + traced("KINEMATICS", loadKinematics(`${MODEL_DIR}/kinematics.json`)), + ]); + + const doneMeshes = bootLine("MESH ASSETS"); + const vfs = new mujoco.MjVFS(); + // One shared VFS for both variants; already-loaded files are skipped so + // the roller lazy-load only fetches its 5 new meshes. + const vfsFiles = new Set(); + async function addMeshesToVfs(files) { + await Promise.all( + files.map(async (f) => { + if (vfsFiles.has(f)) return; + vfsFiles.add(f); + // Same cache-busted URL as duck.js so the browser reuses the render + // meshes instead of downloading the collision subset a second time. + const buf = await (await fetch(signed(`${MODEL_DIR}/meshes/${f}?v=${MESH_VERSION}`), { cache: "force-cache" })).arrayBuffer(); + // meshdir="assets" in the MJCF, so the compiler looks up "assets/". + vfs.addBuffer(`assets/${f}`, new Uint8Array(buf)); + }), + ); + } + try { + await addMeshesToVfs(meshFiles); + } catch (err) { + doneMeshes("FAILED"); + bootHalt(err?.message || String(err)); + throw err; + } + doneMeshes(`${meshFiles.length} FILES`); + + const sessions = {}; + // Always boot on the classic (orange) colourway; the quickbar re-skins live. + let currentVariant = DEFAULT_VARIANT; + const rigPromise = (async () => { + const doneRig = bootLine("RENDER RIG"); + try { + const builtRig = await buildRig(k, { materialForMesh: materialHookFor(VARIANTS[currentVariant]) }); + doneRig("OK"); + return builtRig; + } catch (err) { + doneRig("FAILED"); + bootHalt(err?.message || String(err)); + throw err; + } + })(); + // Boot policies with a live [n/5] counter on the BIOS line. + const donePolicies = bootLine("LOADING POLICIES"); + const sessionOpts = { executionProviders: ["wasm"] }; + let policiesLoaded = 0; + const bootPolicy = (url) => + ort.InferenceSession.create(signed(url), sessionOpts).then((s) => { + donePolicies.progress(`${++policiesLoaded}/5`); + return s; + }); + try { + [sessions.walk, sessions.sitstand, sessions.roll, sessions.kickL, sessions.kickR] = + await Promise.all([ + bootPolicy(POLICIES.walk), + bootPolicy(POLICIES.sitstand), + bootPolicy(POLICIES.roll), + bootPolicy(POLICIES.kickL), + bootPolicy(POLICIES.kickR), + ]); + } catch (err) { + donePolicies("FAILED"); + bootHalt(err?.message || String(err)); + throw err; + } + donePolicies("5/5"); + + const doneCompile = bootLine("COMPILING PHYSICS"); + let model, data; + try { + model = mujoco.MjModel.from_xml_string(xml, vfs); + data = new mujoco.MjData(model); + } catch (err) { + doneCompile("FAILED"); + bootHalt(err?.message || String(err)); + throw err; + } + doneCompile("COMPILED"); + + // Addresses resolved once per compiled variant. qpos/qvel/sensordata + // views are re-read at each use: the WASM heap can grow and detach + // earlier TypedArray views. + const JOINT_SET = new Set(JOINT_NAMES); + function resolveAddrs(model, kin) { + return { + qposAdr: JOINT_NAMES.map((n) => model.jnt(n).qposadr), + dofAdr: JOINT_NAMES.map((n) => model.jnt(n).dofadr), + gyroAdr: model.sensor("imu_ang_vel").adr, + trunkId: mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_BODY.value, "trunk_base"), + standKeyId: mujoco.mj_name2id(model, mujoco.mjtObj.mjOBJ_KEY.value, "STAND"), + ballQposAdr: model.jnt("ball_freejoint").qposadr, + ballDofAdr: model.jnt("ball_freejoint").dofadr, + // Unactuated hinges (the roller variant's 4 passive wheels): not in + // the obs or ctrl, but synced to the render rig so the wheels spin. + extraJoints: kin.bodies + .filter((b) => b.joint && b.joint.type === "hinge" && !JOINT_SET.has(b.joint.name)) + .map((b) => ({ name: b.joint.name, adr: model.jnt(b.joint.name).qposadr })), + }; + } + // Active-variant address block, swapped wholesale by activateLoco. + let { qposAdr, dofAdr, gyroAdr, trunkId, standKeyId, ballQposAdr, ballDofAdr, extraJoints } = + resolveAddrs(model, k); + + // Locomotion variants stay resident once built (model + data + rig + + // addresses); legs is registered when its render rig resolves below. + const locos = {}; + let loco = "legs"; // "legs" | "rollers" + const velLims = () => (loco === "rollers" + ? [RVEL_FWD, RVEL_BACK, RVEL_ANG] + : [VEL_FWD, VEL_BACK, VEL_ANG]); + + const lastAction = new Float32Array(NUM_JOINTS); + const obs = new Float32Array(OBS_SIZE); + const cmd = new Float32Array(CMD_SIZE); // [vx, vy, wz, head(4), body(6)] + // Input controller: keyboard + gamepad + touch sources merged into one + // continuous command + discrete action surface, in priority order. + const kbSource = new KeyboardSource({ getVelocityLimits: () => velLims() }); + const padSource = new GamepadSource({ getVelocityLimits: () => velLims() }); + const touchSource = new TouchSource({ getVelocityLimits: () => velLims() }); + // Keyboard last: it reads zero when idle, so it doubles as the fallback. + const controller = new Controller({ sources: [padSource, touchSource, kbSource] }); + // Right-stick camera state, read by the telemetry before the camera-orbit + // section below has evaluated. + let padOrbitLive = false; + // Robot input gate: twist commands, mode changes, rolls, kicks and ball + // spawns all stay inert until the entrance sequence has fully played out. + let inputLocked = true; + let ceremony = null; + let ball = null; + let stickers = null; // comic popups, currently disabled + + let mode = "walk"; // "walk" | "sitstand" | "roll" | "kickL" | "kickR" | "crouch" + let sitFlag = 0; + const isKick = () => mode === "kickL" || mode === "kickR"; + // Local-only kickable ball: false while parked at the keyframe spot + // (mesh hidden), true once popped in front of the duck. + let ballActive = false; + + // The twist the policy actually receives. Mid-roll every movement input + // is ignored (zero twist) until the roll hands back to walk on its own. + const ZERO_CMD = new Float32Array(3); + function effectiveCmd() { + if (inputLocked || mode === "roll" || mode === "crouch" || isKick() || postKickLock > 0) + return ZERO_CMD; + return controller.getCommand(); + } + let rollRun = null; + let crouchRun = null; + let kickRun = null; + let KICK_STEPS = 25; + // Post-kick grace: keep commands zeroed for a beat after the kick window + // hands back to walk. Step-counted like everything else. + const POST_KICK_LOCK_STEPS = 20; // 0.4 s at 50 Hz + let postKickLock = 0; + + // Pending mode-transition timers (sit hand-over, stand-up hand-back). + let sitTimer = null; + let standTimer = null; + let fallenSince = null; + function clearModeTimers() { + clearTimeout(sitTimer); sitTimer = null; + clearTimeout(standTimer); standTimer = null; + } + + function resetSim() { + // Single reset path: Space, fall-kill, failed roll, loco switch. + clearModeTimers(); + rollRun = null; + kickRun = null; + crouchRun = null; + postKickLock = 0; + fallenSince = null; + mode = "walk"; + mujoco.mj_resetDataKeyframe(model, data, standKeyId); + mujoco.mj_forward(model, data); + lastAction.fill(0); + sitFlag = 0; + // Park the ball in physics immediately; if it was on screen, the + // reverse scan peels it away at its last pose. A queued B-respawn is + // cancelled: a reset means no ball. + ball?.despawn({ cancelQueued: true, parkPhysics: parkBallPhysics }); + ballActive = false; + syncButtons(); + ceremony?.playRespawn(); + } + resetSim(); + + function parkBallPhysics() { + const qpos = data.qpos, qvel = data.qvel; + qpos[ballQposAdr] = 50; + qpos[ballQposAdr + 1] = 0; + qpos[ballQposAdr + 2] = BALL_RADIUS; + qpos[ballQposAdr + 3] = 1; + qpos[ballQposAdr + 4] = 0; + qpos[ballQposAdr + 5] = 0; + qpos[ballQposAdr + 6] = 0; + for (let i = 0; i < 6; i++) qvel[ballDofAdr + i] = 0; + mujoco.mj_forward(model, data); + ballActive = false; + } + + // Pop / respawn the ball ~0.35 m in front of the duck, with a small + // random heading + distance jitter. If the ball is already on screen, + // peel it away first (reverse scan) and pop the new one when that + // finishes - same appear/disappear pair as the duck's wireframe ceremony. + function spawnBall(opts = {}) { + if (inputLocked && !opts.fromQueue) return; + if (!ball) return; + if (ball.visual !== "hidden") { + ball.queueRespawn(); + ball.despawn({ parkPhysics: parkBallPhysics }); + return; + } + const qpos = data.qpos, qvel = data.qvel; + const yaw = Math.atan2( + 2 * (qpos[3] * qpos[6] + qpos[4] * qpos[5]), + 1 - 2 * (qpos[5] * qpos[5] + qpos[6] * qpos[6]), + ); + const heading = yaw + (Math.random() - 0.5) * 0.7; + const dist = 0.35 + (Math.random() - 0.5) * 0.1; + const lim = ARENA_HALF - BALL_RADIUS - 0.05; + const clamp = (v) => Math.min(lim, Math.max(-lim, v)); + qpos[ballQposAdr] = clamp(qpos[0] + Math.cos(heading) * dist); + qpos[ballQposAdr + 1] = clamp(qpos[1] + Math.sin(heading) * dist); + qpos[ballQposAdr + 2] = BALL_RADIUS + 0.02; + qpos[ballQposAdr + 3] = 1; + qpos[ballQposAdr + 4] = 0; + qpos[ballQposAdr + 5] = 0; + qpos[ballQposAdr + 6] = 0; + for (let i = 0; i < 6; i++) qvel[ballDofAdr + i] = 0; + mujoco.mj_forward(model, data); + ballActive = true; + // Snap the mesh to the new pose BEFORE the scan starts: the FX + // recomputes its bbox from the live mesh. + ball.poseFromQpos(qpos, ballQposAdr); + ball.appear(); + stickers?.pop("spawn"); + } + + // ── Observation ───────────────────────────────────────────────────── + const _q = new THREE.Quaternion(); + const _g = new THREE.Vector3(); + + function buildObs() { + const qpos = data.qpos, qvel = data.qvel, sens = data.sensordata; + let i = 0; + for (let a = 0; a < 3; a++) obs[i++] = sens[gyroAdr + a]; + // projected gravity: world -z rotated into the trunk frame + const xq = data.body(trunkId).xquat; // [w, x, y, z] + _q.set(xq[1], xq[2], xq[3], xq[0]).conjugate(); + _g.set(0, 0, -1).applyQuaternion(_q); + obs[i++] = _g.x; obs[i++] = _g.y; obs[i++] = _g.z; + for (let j = 0; j < NUM_JOINTS; j++) obs[i++] = qpos[qposAdr[j]] - DEFAULT_POSE[j]; + for (let j = 0; j < NUM_JOINTS; j++) obs[i++] = qvel[dofAdr[j]]; + for (let j = 0; j < NUM_JOINTS; j++) obs[i++] = lastAction[j]; + // command: walking/drive use the twist; sitstand uses cmd[0] as the + // posture flag; the crouch-glide one-shot carries its phase encoding in + // the vel slots (ground-pick convention: [cos, sin, 0]). + cmd.fill(0, 0, 3); + if (mode === "sitstand") { + cmd[0] = sitFlag; + } else if (mode === "crouch" && crouchRun) { + const a = 2 * Math.PI * crouchRun.phase; + cmd[0] = Math.cos(a); + cmd[1] = Math.sin(a); + } else { + const c = effectiveCmd(); + cmd[0] = c[0]; cmd[1] = c[1]; cmd[2] = c[2]; + } + for (let c = 0; c < CMD_SIZE; c++) obs[i++] = cmd[c]; + return obs; + } + + // The ONNX session for the current mode: in the roller variant the main + // velocity mode runs the drive (skating) policy instead of the walker. + const activeSession = () => + sessions[loco === "rollers" && mode === "walk" ? "drive" : mode]; + + // ── Control loop (50 Hz, async because ONNX inference is async) ────── + let ctrlHz = 0; + + // Dead pose: walk/sitstand have no get-up skill, so a kill here is just + // a resetSim. "fallen" = trunk tilted past ~60 deg or sunk below the + // floor. NaN/Inf is a solver explosion: no grace, reset on the spot. + function poseIsDead() { + const z = data.qpos[2]; + const gz = obs[5]; // projected gravity z, from the last obs + if (!Number.isFinite(z) || !Number.isFinite(gz)) return "exploded"; + if (gz > -0.5 || z < 0.02) return "fallen"; + return null; + } + + async function controlStep() { + const feeds = { obs: new ort.Tensor("float32", buildObs(), [1, OBS_SIZE]) }; + const out = await activeSession().run(feeds); + const act = out.actions.data; + lastAction.set(act); + const ctrl = data.ctrl; + for (let j = 0; j < NUM_JOINTS; j++) ctrl[j] = DEFAULT_POSE[j] + act[j] * ACTION_SCALE; + for (let s = 0; s < DECIMATION; s++) mujoco.mj_step(model, data); + + const death = poseIsDead(); + if (death === "exploded") { + resetSim(); + } else if (death === "fallen") { + const now = performance.now(); + const graceMs = mode === "roll" ? 5000 : 1000; + fallenSince ??= now; + if (now - fallenSince > graceMs) resetSim(); + } else { + fallenSince = null; + } + + // Ball respawn watchdog: outside the arena bounds means "escaped + // through a solver glitch", bring it back near the duck. + if (ballActive) { + const q = data.qpos; + const escaped = + Math.abs(q[ballQposAdr]) > ARENA_HALF + 0.1 || + Math.abs(q[ballQposAdr + 1]) > ARENA_HALF + 0.1; + if (escaped) spawnBall(); + } + + if (postKickLock > 0 && mode === "walk") postKickLock--; + + // One-shot kick: fixed 0.5 s window like the robot runtime, then + // straight back to walking. lastAction is NOT zeroed on either swap. + if (isKick() && kickRun) { + kickRun.steps++; + if (kickRun.steps >= KICK_STEPS) { + kickRun = null; + mode = "walk"; + postKickLock = POST_KICK_LOCK_STEPS; + syncButtons(); + } + } + + // Crouch-glide one-shot: advance the trained phase clock and hand back + // to the drive policy at the runtime's cycle end. + if (mode === "crouch" && crouchRun) { + crouchRun.phase += CTRL_DT / CROUCH_PERIOD_S; + if (crouchRun.phase >= CROUCH_END_PHASE) { + crouchRun = null; + mode = "walk"; + syncButtons(); + } + } + + // One-shot roll, step-counted like the robot runtime: hand back to + // walking once the trunk has tipped over and is upright again, or + // after a hard window if the roll never initiated. + if (mode === "roll" && rollRun) { + rollRun.steps++; + if (obs[5] > -0.3) rollRun.tipped = true; + const upright = obs[5] < -0.85; + const done = rollRun.tipped && upright && rollRun.steps >= 40; + const expired = rollRun.steps >= 150; // 3 s, roll should long be over + if (done || expired) { + rollRun = null; + mode = "walk"; + lastAction.fill(0); + // Timed out mid-roll: don't hand a tipped duck to the walking + // policy (it has no get-up skill). + if (!upright) resetSim(); + syncButtons(); + } + } + } + + let running = true; + (async function controlLoop() { + let next = performance.now(); + let count = 0, hzT0 = next; + while (running) { + await controlStep(); + count++; + const now = performance.now(); + if (now - hzT0 > 500) { + ctrlHz = (count * 1000) / (now - hzT0); + count = 0; hzT0 = now; + } + next += CTRL_DT * 1000; + const wait = next - performance.now(); + if (wait > 0) await new Promise((r) => setTimeout(r, wait)); + else next = performance.now(); // fell behind: don't spiral + } + })(); + + // ── Scene wiring (grid, walls, rig, ball, jukebox) ─────────────────── + // The grid/walls carry ceremony-driven uReveal uniforms and per-frame + // focus updates, so the game owns them; lights and environment live in + // the R3F layer. + const grid = makeInfiniteGrid(); + scene.add(grid); + const { wallMats, wallMeshes } = makeArenaWalls(); + for (const m of wallMeshes) scene.add(m); + + let rig = await rigPromise; + scene.add(rig.placer); + let trunkGroup = rig.bodies.get("trunk_base"); + locos.legs = { + model, data, rig, trunkGroup, + qposAdr, dofAdr, gyroAdr, trunkId, standKeyId, ballQposAdr, ballDofAdr, extraJoints, + }; + + // ── Locomotion variant switching (legs <-> rollers) ────────────────── + // The roller stack (XML + 5 extra meshes + kinematics + 2 ONNX policies) + // is lazy-loaded on the first switch, then kept resident. + let rollersLoading = null; + function ensureRollers() { + rollersLoading ??= (async () => { + const [{ xml: rXml, meshFiles: rMeshFiles }, rk] = await Promise.all([ + buildPhysicsXml("robot_allcollisions_rollers.xml"), + loadKinematics(`${MODEL_DIR}/kinematics_rollers.json`), + ]); + const [rRig, sDrive, sCrouch] = await Promise.all([ + buildRig(rk, { materialForMesh: materialHookFor(VARIANTS[currentVariant]) }), + ort.InferenceSession.create(signed(POLICIES.drive), sessionOpts), + ort.InferenceSession.create(signed(POLICIES.crouch), sessionOpts), + addMeshesToVfs(rMeshFiles), + ]); + sessions.drive = sDrive; + sessions.crouch = sCrouch; + const rModel = mujoco.MjModel.from_xml_string(rXml, vfs); + const rData = new mujoco.MjData(rModel); + locos.rollers = { + model: rModel, data: rData, rig: rRig, trunkGroup: rRig.bodies.get("trunk_base"), + ...resolveAddrs(rModel, rk), + }; + })(); + return rollersLoading; + } + + function activateLoco(name) { + const L = locos[name]; + loco = name; + scene.remove(rig.placer); + ({ model, data, rig, trunkGroup, qposAdr, dofAdr, gyroAdr, trunkId, + standKeyId, ballQposAdr, ballDofAdr, extraJoints } = L); + // The rig may have been built (or last shown) under another colourway. + applyVariant(rig, currentVariant); + scene.add(rig.placer); + setStore({ loco: name }); + resetSim(); + } + + let locoSwitching = false; + async function setLoco(name, { force = false } = {}) { + if (name !== "legs" && name !== "rollers") return; + if (loco === name || locoSwitching) return; + if (!force && (inputLocked || rollRun || kickRun || crouchRun || standTimer)) return; + locoSwitching = true; + setStore({ locoSwitching: true }); + try { + if (name === "rollers" && !locos.rollers) { + setStore({ rollersLoading: true }); + await ensureRollers(); + } + activateLoco(name); + } catch (e) { + rollersLoading = null; + console.error("[game] roller switch failed", e); + } finally { + setStore({ rollersLoading: false, locoSwitching: false }); + locoSwitching = false; + } + } + + async function toggleLoco() { + const next = loco === "legs" ? "rollers" : "legs"; + setStore({ locoWant: next }); + await setLoco(next); + } + + // Quickbar loco intent: reconcile locoWant -> actual, retrying until the + // game allows the switch (mid-roll, respawn ceremony, ...). Replaces the + // old index.html reconciler that polled window.rl. + let locoReconciler = null; + function reconcileLoco() { + const want = store().locoWant; + if (want === loco) { + if (locoReconciler) { clearInterval(locoReconciler); locoReconciler = null; } + return; + } + if (want === "rollers") ensureRollers().catch(() => {}); + if (!locoSwitching) setLoco(want); + locoReconciler ??= setInterval(reconcileLoco, 250); + } + useGame.subscribe((s) => s.locoWant, reconcileLoco); + + // ── Cutscenes (entrance + respawn) ────────────────────────────────── + ceremony = createCeremony({ + THREE, scene, camera, renderer, fx, + getRig: () => rig, + grid, wallMats, + syncRig, startCameraReset, + setLocked: (v) => { + inputLocked = v; + controller.setLocked(v); + // A ball is always in play: pop one the moment the entrance or a + // respawn ceremony hands control back. + if (!v && ball && !ballActive) spawnBall({ fromQueue: true }); + }, + flashReset: () => {}, + }); + + const { group: ballGroup, mesh: ballMesh } = createBallVisual(renderer); + scene.add(ballGroup); + ball = createBallActor({ + THREE, scene, camera, renderer, fxModule: fx, mesh: ballMesh, group: ballGroup, + }); + + // ── Jukebox prop (decorative corner dressing, no physics) ──────────── + // assets/props/jukebox.glb carries two meshes exported from Blender: the + // ~39k-tri render mesh and a 500-tri "jukebox_wire" stand-in used only by + // the hologram pass (same fxWireGeometry escape hatch as the ball). It + // materializes with the duck's ceremony, staggered a beat behind, and + // replays on every respawn. + const JUKEBOX_H = 0.42; // target height, m + const JUKEBOX_MARGIN = 0.24; // center distance from each wall inner face + let jukeboxGroup = null; + try { + const gltf = await new GLTFLoader().loadAsync( + signed(`./assets/props/jukebox.glb?v=1`), + ); + const jukebox = gltf.scene; + const jukeWire = jukebox.getObjectByName("jukebox_wire"); + jukeWire.removeFromParent(); + const jukeBox3 = new THREE.Box3().setFromObject(jukebox); + const jukeScale = JUKEBOX_H / (jukeBox3.max.y - jukeBox3.min.y); + jukebox.scale.setScalar(jukeScale); + jukebox.position.y = -jukeBox3.min.y * jukeScale; + jukebox.traverse((o) => { + if (o.isMesh) o.userData.fxWireGeometry = jukeWire.geometry; + }); + const jukeGroup = new THREE.Group(); + jukeGroup.add(jukebox); + // Back corner, behind the spawn (the duck faces +X), angled toward the + // center of the arena so the front panel reads from the play area. + jukeGroup.position.set( + -(ARENA_HALF - JUKEBOX_MARGIN), 0, -(ARENA_HALF - JUKEBOX_MARGIN), + ); + jukeGroup.rotation.y = Math.PI / 4; + scene.add(jukeGroup); + jukeboxGroup = jukeGroup; + const jukeFx = fx.createWireframeFx(); + jukeFx.init({ THREE, scene, root: jukeGroup, camera, renderer, hidden: true }); + ceremony.addPropFx(jukeFx, 0.25); + } catch (err) { + // Decorative only: a missing/broken GLB must never halt the boot. + console.warn("[game] jukebox prop disabled:", err); + } + + // ── Camera: orbit controls + chase cam + reset glide ───────────────── + const controls = new OrbitControls(camera, renderer.domElement); + controls.target.set(SPAWN_X, 0, -SPAWN_Y); // orbit around the spawn cell + controls.enableDamping = true; + controls.dampingFactor = 0.08; + controls.minDistance = 0.25; + controls.maxDistance = 3; + controls.maxPolarAngle = Math.PI / 2 - 0.03; + + // Chase cam (default ON): each frame the camera eases toward a point + // behind the duck's heading at the current orbit distance, while the + // orbit target keeps easing to the trunk in syncRig. Implemented by + // overwriting camera.position AFTER controls.update() so we never fight + // OrbitControls' own spherical bookkeeping. + let chaseCam = true; + const CHASE_PITCH = 0.42; // rad above horizontal, keeps the floor in view + const CHASE_EASE = 0.05; + const _chasePos = new THREE.Vector3(); + const _chaseDir = new THREE.Vector3(); + // During one-shot rolls and kicks the trunk tumbles: hold the last + // healthy yaw for the whole one-shot. + let chaseHeldYaw = 0; + // Heading hysteresis (Schmitt trigger): the walking gait wiggles the + // trunk yaw ~±14 deg per step; two-layer EMA + engage/release thresholds + // keep the camera steady while walking straight but responsive on turns. + let chaseYawSmooth = 0; + let chaseYawFollow = 0; + let chaseYawTracking = false; + const CHASE_YAW_SMOOTH_EASE = 0.04; + const CHASE_YAW_ENGAGE = 0.17; + const CHASE_YAW_RELEASE = 0.03; + const CHASE_YAW_EASE = 0.10; + const CHASE_YAW_EASE_TURN = 0.5; + const wrapPi = (a) => Math.atan2(Math.sin(a), Math.cos(a)); + function updateChaseCam() { + // Reset glide: one clean tween from wherever the camera is back to the + // home framing. Runs instead of the chase logic and hands control back + // to it on landing. + if (camResetT0 !== null) { + if (!chaseCam) { camResetT0 = null; return; } + const t = (performance.now() - camResetT0) / 1000 / CAM_RESET_S; + const e = t >= 1 ? 1 : t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2; + camera.position.lerpVectors(_camFrom, _camTo, e); + controls.target.lerpVectors(_tgtFrom, _tgtTo, e); + camera.lookAt(controls.target); + if (t >= 1) camResetT0 = null; + return; + } + if (!chaseCam) return; + const qpos = data.qpos; + let rawYaw; + if (mode === "roll" || isKick()) { + rawYaw = chaseHeldYaw; + } else { + rawYaw = Math.atan2( + 2 * (qpos[3] * qpos[6] + qpos[4] * qpos[5]), + 1 - 2 * (qpos[5] * qpos[5] + qpos[6] * qpos[6]), + ); + chaseHeldYaw = rawYaw; + } + // "turning" reads the raw per-source wz commands (not the locked/merged + // view) so an intentional turn engages on the first frame. + const turning = controller.sources.some((s) => Math.abs(s.command[2]) > 0.05); + chaseYawSmooth = wrapPi( + chaseYawSmooth + + wrapPi(rawYaw - chaseYawSmooth) * (turning ? CHASE_YAW_EASE_TURN : CHASE_YAW_SMOOTH_EASE), + ); + const yawErr = wrapPi(chaseYawSmooth - chaseYawFollow); + if (turning || Math.abs(yawErr) > CHASE_YAW_ENGAGE) chaseYawTracking = true; + if (chaseYawTracking) { + chaseYawFollow = wrapPi( + chaseYawFollow + yawErr * (turning ? CHASE_YAW_EASE_TURN : CHASE_YAW_EASE), + ); + if (!turning && Math.abs(yawErr) < CHASE_YAW_RELEASE) chaseYawTracking = false; + } + const yaw = chaseYawFollow; + const dist = camera.position.distanceTo(controls.target); + const horiz = dist * Math.cos(CHASE_PITCH); + const vert = dist * Math.sin(CHASE_PITCH); + // Duck forward in MJCF is (cos yaw, sin yaw, 0); Z-up -> Y-up maps it + // to three-space (cos yaw, 0, -sin yaw). Behind = minus that. + _chasePos.set( + controls.target.x - Math.cos(yaw) * horiz, + controls.target.y + vert, + controls.target.z + Math.sin(yaw) * horiz, + ); + camera.position.lerp(_chasePos, CHASE_EASE); + // Re-project onto the orbit sphere: lerping between two points at the + // same radius cuts the chord, which would slowly zoom the camera in + // during large swings. + _chaseDir.copy(camera.position).sub(controls.target); + const len = _chaseDir.length(); + if (len > 1e-6) camera.position.copy(controls.target).addScaledVector(_chaseDir, dist / len); + camera.lookAt(controls.target); + } + renderer.domElement.addEventListener("pointerdown", () => { chaseCam = false; }); + + // Camera reset glide (owned by the respawn ceremony): back to the + // page-load framing - the chase cam's ideal point behind the duck's + // spawn heading, at the boot orbit distance. + const CAM_HOME_DIST = camera.position.distanceTo(controls.target); + let camResetT0 = null; + const _camFrom = new THREE.Vector3(), _camTo = new THREE.Vector3(); + const _tgtFrom = new THREE.Vector3(), _tgtTo = new THREE.Vector3(); + function startCameraReset() { + const qpos = data.qpos; + const yaw = Math.atan2( + 2 * (qpos[3] * qpos[6] + qpos[4] * qpos[5]), + 1 - 2 * (qpos[5] * qpos[5] + qpos[6] * qpos[6]), + ); + chaseHeldYaw = yaw; + chaseYawSmooth = yaw; + chaseYawFollow = yaw; + chaseYawTracking = false; + _tgtTo.set(qpos[0], qpos[2], -qpos[1]); // trunk at spawn, MJCF -> three + const horiz = CAM_HOME_DIST * Math.cos(CHASE_PITCH); + const vert = CAM_HOME_DIST * Math.sin(CHASE_PITCH); + _camTo.set( + _tgtTo.x - Math.cos(yaw) * horiz, + _tgtTo.y + vert, + _tgtTo.z + Math.sin(yaw) * horiz, + ); + _camFrom.copy(camera.position); + _tgtFrom.copy(controls.target); + camResetT0 = performance.now(); + chaseCam = true; // reset always re-attaches the chase cam + } + + // Pause: while the menu is up over a live game, keys belong to the menu. + const setInputLock = (v) => { inputLocked = v; controller.setLocked(v); }; + useGame.subscribe( + (s) => s.menuOpen, + (open) => { + if (!ceremony.entranceDone) return; + if (open) setInputLock(true); + else if (!ceremony.respawnActive) setInputLock(false); + }, + ); + + // The rig's root already applies the MJCF Z-up -> three Y-up fix, so the + // trunk group can take the freejoint pose in raw MJCF coordinates. + const _target = new THREE.Vector3(); + const _follow = new THREE.Vector3(); + function syncRig() { + const qpos = data.qpos; + trunkGroup.position.set(qpos[0], qpos[1], qpos[2]); + trunkGroup.quaternion.set(qpos[4], qpos[5], qpos[6], qpos[3]); + for (let j = 0; j < NUM_JOINTS; j++) setJoint(rig, JOINT_NAMES[j], qpos[qposAdr[j]]); + // Passive hinges (roller wheels): purely visual, driven straight from qpos. + for (const ej of extraJoints) setJoint(rig, ej.name, qpos[ej.adr]); + // Ball: live follows qpos; ghost freeze is owned by the ball actor. + if (ball) ball.sync(qpos, ballQposAdr, ballActive); + // Follow cam: ease the orbit target toward the trunk and translate the + // camera by the same delta, so the camera-to-duck distance and viewing + // angle stay constant while the duck walks. Paused while the reset + // glide owns the camera. + if (camResetT0 === null) { + _target.set(qpos[0], qpos[2], -qpos[1]); + _follow.copy(_target).sub(controls.target); + // Horizontal follow at the usual rate; vertical much slower so the + // per-step gait bob doesn't nod the frame. + _follow.x *= 0.06; + _follow.z *= 0.06; + _follow.y *= 0.015; + controls.target.add(_follow); + camera.position.add(_follow); + } + // Keep the grid plane (and its fade center) under the action; the wall + // grids share the same radial fade focus. + grid.position.set(controls.target.x, 0, controls.target.z); + grid.material.uniforms.uFocus.value.copy(controls.target); + for (const m of wallMats) m.uniforms.uFocus.value.copy(controls.target); + } + + // ── Quack: jaw + chirp ──────────────────────────────────────────────── + // The jaw isn't a MuJoCo joint (duck.js re-creates the hinge in JS), so + // this is purely cosmetic and can't upset the policy. Voice banks from + // the robot runtime: each colourway gets its own bank and every quack + // draws a random chirp take from it. + const QUACK_MS = 480; + let quackAt = -Infinity; + let padJaw = 0; + const CHIRP_TAKES = "abcdefghijkl"; + const VOICE_BANK = { classic: "duck1", charcoal: "duck2", purple: "duck3", blue: "duck4" }; + const chirpCache = new Map(); + function playChirp() { + const bank = VOICE_BANK[currentVariant] ?? "duck1"; + const take = CHIRP_TAKES[(Math.random() * CHIRP_TAKES.length) | 0]; + const url = signed(`./assets/voices/${bank}/chirp_${take}.wav`); + let a = chirpCache.get(url); + if (!a) { + a = new Audio(url); + a.volume = 0.7; + chirpCache.set(url, a); + } + a.currentTime = 0; + a.play().catch(() => {}); + } + const quackLoud = () => { + quackAt = performance.now(); + playChirp(); + stickers?.pop("quack"); + }; + function jawOpenNow() { + const t = (performance.now() - quackAt) / QUACK_MS; + const flap = t >= 0 && t < 1 ? Math.sin(Math.PI * t) : 0; + return Math.max(flap, padJaw); + } + function syncJaw() { + setJawOpen(rig, jawOpenNow()); + } + + // ── Telemetry (throttled into the store) ───────────────────────────── + // FPS EMA is per-frame; the store write is 4 Hz so React re-renders + // stay far away from frame rate. Odometer integrates horizontal trunk + // travel; teleport-sized jumps (resets, loco swaps) don't count. + let fpsEma = 60; + let fpsLastT = performance.now(); + let odoM = 0; + let odoX = null, odoY = null; + let telemetryLastPush = 0; + function renderTelemetry() { + const now = performance.now(); + const dtF = (now - fpsLastT) / 1000; + fpsLastT = now; + if (dtF > 0 && dtF < 0.5) fpsEma += (1 / dtF - fpsEma) * 0.05; + const stepD = (odoX === null) ? 0 : Math.hypot(data.qpos[0] - odoX, data.qpos[1] - odoY); + if (stepD < 0.05) odoM += stepD; // plausible per-frame travel only + odoX = data.qpos[0]; + odoY = data.qpos[1]; + if (now - telemetryLastPush < 250) return; + telemetryLastPush = now; + setStore({ + telemetry: { + fps: Math.round(fpsEma), + ctrlHz: Math.round(ctrlHz), + speed: Math.hypot(data.qvel[0], data.qvel[1]), + odo: odoM, + peers: ghosts?.peerCount() ?? 0, + }, + }); + } + + // ── Right-stick camera orbit (inertia downstream of the controller) ── + // The stick steers an angular VELOCITY that eases toward the stick's + // target rate, so pushing ramps up gently and releasing coasts to a stop + // over ~0.3 s. Vertical is flight-style inverted. + const PAD_ORBIT_SPEED = 2.4; // rad/s at full deflection + const PAD_ORBIT_SMOOTH = 8; // 1/s response rate (~95% in 0.37 s) + const padOrbitVel = { az: 0, el: 0 }; + const _padSph = new THREE.Spherical(); + const _padOff = new THREE.Vector3(); + function padOrbitStep(rx, ry, dt) { + padOrbitLive = rx !== 0 || ry !== 0; + if (padOrbitLive) chaseCam = false; // detach, same as a mouse grab + const k = 1 - Math.exp(-PAD_ORBIT_SMOOTH * dt); + padOrbitVel.az += (rx * PAD_ORBIT_SPEED - padOrbitVel.az) * k; + padOrbitVel.el += (-ry * PAD_ORBIT_SPEED * 0.75 - padOrbitVel.el) * k; + if (chaseCam) { padOrbitVel.az = 0; padOrbitVel.el = 0; return; } + if (Math.abs(padOrbitVel.az) < 1e-3 && Math.abs(padOrbitVel.el) < 1e-3) return; + _padOff.copy(camera.position).sub(controls.target); + _padSph.setFromVector3(_padOff); + _padSph.theta -= padOrbitVel.az * dt; + _padSph.phi += padOrbitVel.el * dt; + _padSph.phi = Math.min(controls.maxPolarAngle, Math.max(0.08, _padSph.phi)); + _padSph.makeSafe(); + camera.position.setFromSpherical(_padSph).add(controls.target); + camera.lookAt(controls.target); + } + + // Multiplayer ghosts, initialised asynchronously at the end of the boot. + let ghosts = null; + + // ── Per-frame drive, called by R3F's useFrame ──────────────────────── + let padWasConnected = null; + let touchWasConnected = null; + function frame(dt) { + controller.update(dt); + padJaw = controller.getAxes().jaw; + if (padSource.connected !== padWasConnected) { + padWasConnected = padSource.connected; + setStore({ padConnected: padSource.connected }); + } + if (touchSource.connected !== touchWasConnected) { + touchWasConnected = touchSource.connected; + setStore({ touchMode: touchSource.connected }); + } + // Camera orbit runs every frame while a pad is present (the coasting + // needs the zero-deflection frames too); without a pad, park the state. + if (padSource.connected) { + padOrbitStep(controller.getAxes().orbitX, controller.getAxes().orbitY, dt); + } else { + padOrbitLive = false; + padOrbitVel.az = 0; + padOrbitVel.el = 0; + } + syncRig(); + syncJaw(); + ghosts?.update(); + controls.update(); + updateChaseCam(); + ceremony.drive(); + ball.drive(() => spawnBall({ fromQueue: true })); + renderTelemetry(); + } + + // ── Input wiring: arm the controller sources, bind actions ─────────── + controller.init(); + + // Keyboard F alternates kicking feet; only advance the alternation on + // kicks that actually launched (triggerKick reports that). + let kbKickFoot = "left"; + const srcTag = (source) => (source === "gamepad" ? "pad" : "kb"); + + controller.on("reset", () => resetSim()); + controller.on("spawnBall", () => spawnBall()); + controller.on("chaseToggle", () => { chaseCam = !chaseCam; }); + controller.on("locoToggle", () => toggleLoco()); + controller.on("roll", ({ source }) => triggerRoll(srcTag(source))); + controller.on("kickL", ({ source }) => triggerKick("left", srcTag(source))); + controller.on("kickR", ({ source }) => triggerKick("right", srcTag(source))); + controller.on("alternateKick", ({ source }) => { + if (triggerKick(kbKickFoot, srcTag(source))) { + kbKickFoot = kbKickFoot === "left" ? "right" : "left"; + } + }); + controller.on("sitToggle", () => { + if (loco !== "legs") return; // sitting is a legs-only skill + const sitting = mode === "sitstand" && sitFlag === 1; + setMode(sitting ? "walk" : "sit"); + }); + // Pad DpadUp short press: straight back to running (ignored mid-roll / + // mid-crouch: those hand back to walk on their own). + controller.on("walk", () => { + if (mode !== "walk" && mode !== "roll" && mode !== "crouch") setMode("walk"); + }); + controller.on("quack", () => quackLoud()); + + function setMode(next, { force = false } = {}) { + if (!force && inputLocked) return; + // No policy switching mid-roll or mid-kick: both end on their own and + // return to walk - switching now would floor the duck. + if ((mode === "roll" && rollRun) || (isKick() && kickRun) || (mode === "crouch" && crouchRun)) return; + if (next === "sit" && loco === "rollers") return; + clearModeTimers(); + rollRun = null; + crouchRun = null; + if (next !== "sit") { + // Leaving a sit: let the sitstand policy stand the duck back up first. + if (mode === "sitstand" && sitFlag === 1) { + sitFlag = 0; + standTimer = setTimeout(() => { + standTimer = null; + mode = next; + lastAction.fill(0); + syncButtons(); + }, 2000); + syncButtons(); + return; + } + mode = next; + lastAction.fill(0); + } else { + // Hand over gently: hold the stand under the sitstand policy for a + // moment before commanding the sit, or the abrupt session switch + // knocks the duck over. + mode = "sitstand"; + sitFlag = 0; + lastAction.fill(0); + sitTimer = setTimeout(() => { + sitTimer = null; + if (mode === "sitstand") { sitFlag = 1; syncButtons(); } + }, 800); + } + syncButtons(); + } + + // One roll, then straight back to running. lastAction is deliberately + // NOT zeroed: the runtime keeps one continuous action history across + // policy switches, and the roll initiates more reliably mid-gait. + function triggerRoll(source = "kb") { + if (loco === "rollers") return triggerCrouch(source); + if (inputLocked || mode !== "walk" || standTimer) return; + clearModeTimers(); + mode = "roll"; + sitFlag = 0; + rollRun = { steps: 0, tipped: false }; + syncButtons(); + stickers?.pop("roll"); + } + + // Roller-only one-shot: crouch, glide low, stand back up (phase-driven). + function triggerCrouch(source = "kb") { + if (inputLocked || mode !== "walk" || locoSwitching) return; + clearModeTimers(); + mode = "crouch"; + crouchRun = { phase: 0 }; + syncButtons(); + stickers?.pop("roll"); + } + + // One blind kick (the duck can't see any ball - it's a scripted boot). + // Returns whether the kick actually launched so the keyboard's foot + // alternation only advances on real kicks. + function triggerKick(foot, source = "kb") { + if (loco === "rollers") return false; + if (inputLocked || mode !== "walk" || standTimer) return false; + clearModeTimers(); + mode = foot === "left" ? "kickL" : "kickR"; + sitFlag = 0; + kickRun = { steps: 0 }; + syncButtons(); + stickers?.pop("kick"); + return true; + } + + function syncButtons() { + const sitting = mode === "sitstand" && sitFlag === 1; + const label = + mode === "roll" ? "Roll" + : mode === "crouch" ? "Crouch" + : isKick() ? "Kick" + : sitting ? "Sit" + : loco === "rollers" ? "Drive" + : "Run"; + if (store().modeLabel !== label) setStore({ modeLabel: label }); + if (store().ballActive !== ballActive) setStore({ ballActive }); + } + + // ── Public surface for the React UI ────────────────────────────────── + Object.assign(gameApi, { + frame, + setVariant: (name) => { + if (!VARIANTS[name] || name === currentVariant) return; + currentVariant = name; + applyVariant(rig, name); + setStore({ variant: name }); + }, + requestLoco: (name) => { + if (name !== "legs" && name !== "rollers") return; + setStore({ locoWant: name }); + reconcileLoco(); + }, + resetSim, + spawnBall: () => spawnBall(), + startEntrance: () => ceremony.startEntrance(), + }); + + // Deterministic hooks for automated verification (rAF pauses in + // background tabs, and the control loop is async). + window.rl = { + get model() { return model; }, + get data() { return data; }, + mujoco, camera, controls, + get mode() { return mode; }, + get sitFlag() { return sitFlag; }, + buildObs, cmd, + velCmd: kbSource.command, lastAction, resetSim, + controller, kbSource, padSource, + spawnBall, triggerKick, triggerRoll, sessions, ort, + get loco() { return loco; }, + get locoSwitching() { return locoSwitching; }, + toggleLoco, setLoco, ensureRollers, + triggerCrouch, + get crouchPhase() { return crouchRun?.phase ?? null; }, + get kickSteps() { return KICK_STEPS; }, + set kickSteps(v) { KICK_STEPS = v; }, + get ballActive() { return ballActive; }, + get ballQposAdr() { return ballQposAdr; }, + get chaseCam() { return chaseCam; }, + set chaseCam(v) { chaseCam = !!v; }, + get jukebox() { return jukeboxGroup; }, + get camResetActive() { return camResetT0 !== null; }, + get respawnActive() { return ceremony?.respawnActive ?? false; }, + get camPose() { + return { + pos: camera.position.toArray(), + target: controls.target.toArray(), + }; + }, + get chaseYaw() { return { follow: chaseYawFollow, smooth: chaseYawSmooth, held: chaseHeldYaw, tracking: chaseYawTracking }; }, + padOrbitStep, + jawOpenNow, + step: async (n = 1) => { for (let i = 0; i < n; i++) await controlStep(); }, + render: () => { syncRig(); renderer.render(scene, camera); }, + frame: (dt = 1 / 60) => frame(dt), + get ghosts() { return ghosts; }, + get inputLocked() { return inputLocked; }, + entrance: { + start: () => ceremony.startEntrance(), + setReveal: (floor, wall) => ceremony.setReveal(floor, wall), + setFx: (p) => ceremony.setFx(p), + }, + }; + + // Boot complete: the sim/HUD go live immediately. The BIOS readout (if + // the user already waddled in, or when they do) sees bootDone and closes + // with READY. + fade on its own. + setStore({ bootDone: true }); + + // ── Multiplayer ghosts (WebRTC, serverless signaling) ──────────────── + // Broadcast this duck's pose and render up to 3 other visitors live as + // translucent ducks. Fire-and-forget: any failure just means no ghosts. + const r3 = (x) => Math.round(x * 1000) / 1000; + try { + // Ghosts only join once the entrance has fully played: the world (and + // this duck) must stay hidden until then, translucent peers included. + await ceremony.entranceFinished; + ghosts = await initGhosts({ + scene, rig, cloneRig, setJoint, setJawOpen, applyVariant, + jointNames: JOINT_NAMES, + // Ghost rig per locomotion flag: peers in roller mode clone the + // roller rig once this tab has built it, and fall back to the leg + // rig until then. Known v1 limitation, documented in the README. + getRigFor: (l) => (l && locos.rollers ? locos.rollers.rig : locos.legs.rig), + getLocalState: () => { + const qpos = data.qpos; + const j = new Array(NUM_JOINTS); + for (let i = 0; i < NUM_JOINTS; i++) j[i] = r3(qpos[qposAdr[i]]); + return { + p: [r3(qpos[0]), r3(qpos[1]), r3(qpos[2]), r3(qpos[3]), r3(qpos[4]), r3(qpos[5]), r3(qpos[6])], + j, + w: r3(jawOpenNow()), + v: currentVariant, + l: loco === "rollers" ? 1 : 0, + }; + }, + }); + if (ghosts.room) ghosts.room.onPeerJoin = () => stickers?.pop("hi"); + } catch (e) { + window.__ghostErr = String((e && e.stack) || e); + console.warn("ghosts disabled:", e); + } +} diff --git a/app/src/game/ghosts.js b/app/src/game/ghosts.js new file mode 100644 index 0000000..36bf7cf --- /dev/null +++ b/app/src/game/ghosts.js @@ -0,0 +1,288 @@ +// Live multiplayer ghosts: every open tab of the sandbox broadcasts its +// duck state over WebRTC and renders the other visitors as translucent +// ducks. There is no backend - this is a static Space - so peer discovery +// uses Trystero's serverless signaling over public Nostr relays. Payloads +// are tiny (22 floats + a variant name at SEND_HZ), and at most MAX_GHOSTS +// ghosts are instantiated regardless of how many peers are in the room. +// +// This module deliberately imports nothing from duck.js / variants.js: +// on the private Space those need the ?__sign JWT that only rl.js knows +// how to append, so all rig helpers arrive through init parameters. + +const TRYSTERO_URL = "https://esm.run/trystero@0.25.3/nostr"; +const APP_ID = "microduck-sandbox"; +const ROOM = "lobby"; +const MAX_GHOSTS = 3; +const SEND_HZ = 15; +const GHOST_OPACITY = 0.35; +// Snapshot interpolation: each ghost renders INTERP_DELAY_MS in the past, +// lerping between the two buffered snapshots that bracket the render time +// (timed by local ARRIVAL, so no clock sync and no payload change - old +// clients interoperate). This replaces the old exponential chase toward +// the latest packet, whose move-then-stall rhythm read as micro-stutter. +// The delay absorbs network jitter; past the newest snapshot the ghost +// holds pose, so a background-throttled 1 Hz sender degrades into slow +// discrete steps instead of teleports. Nobody synchronizes on ghosts, so +// the added latency is invisible. +const INTERP_DELAY_MS = 150; +const BUF_MAX = 40; // snapshots kept per ghost (~2.5 s at 15 Hz) +// Idle visitors stay invisible: a ghost is only shown once its peer has +// strayed from the pose of its first state message (everyone spawns at +// the arena center). Once revealed it stays visible for the whole peer +// session, so a reset teleporting the duck back to center doesn't blink +// the ghost out. +const REVEAL_DIST = 0.2; // m, horizontal distance from spawn +const REVEAL_YAW = 0.4; // rad (~23deg), turning in place also reveals + +// state.p is raw MuJoCo qpos[0..6]: [x, y, z, qw, qx, qy, qz], Z-up. +const yawOf = (p) => + Math.atan2(2 * (p[3] * p[6] + p[4] * p[5]), 1 - 2 * (p[5] * p[5] + p[6] * p[6])); +const hasMoved = (spawn, p) => { + const dx = p[0] - spawn.x, dy = p[1] - spawn.y; + if (dx * dx + dy * dy > REVEAL_DIST * REVEAL_DIST) return true; + const dyaw = yawOf(p) - spawn.yaw; + return Math.abs(Math.atan2(Math.sin(dyaw), Math.cos(dyaw))) > REVEAL_YAW; +}; + +export async function initGhosts(env) { + const noop = { update() {}, peerCount: () => 0, ghostCount: () => 0, debug: () => [], mapDots: () => [] }; + let room; + try { + const { joinRoom } = await import(/* @vite-ignore */ TRYSTERO_URL); + room = joinRoom({ appId: APP_ID }, ROOM); + } catch (e) { + console.warn("ghosts disabled (signaling unavailable):", e); + return noop; + } + + const { scene, cloneRig, setJoint, setJawOpen, applyVariant, jointNames, getLocalState } = env; + // Locomotion-variant rig source: state.l 1 = rollers, 0/absent = legs + // (old clients never send it). Falls back to the leg rig when the local + // tab hasn't built the roller rig yet - known v1 limitation. + const rigFor = (l) => (env.getRigFor ? env.getRigFor(l ?? 0) : env.rig); + // trystero 0.25 (backed by @trystero-p2p): makeAction returns + // { send, onMessage, onReceiveProgress } where onMessage is a SETTER - + // the receive handler is registered by assignment, not by calling it. + const act = room.makeAction("s"); + // send() rejects when a peer's channel drops mid-transfer; that peer will + // be swept anyway, so failures are non-events. + const sendState = (data) => act.send(data).catch(() => {}); + + // Ghosts share geometry with the local rig (cloneRig), but get their own + // transparent material clones so repainting them never touches the + // visitor's own duck (variants.js caches materials globally). + // + // Rendering: a ghost reads as ONE translucent shell, not ~70 individually + // transparent meshes (through which every internal motor/PCB used to show). + // Classic depth-prepass silhouette, kept inside the transparent pass so the + // grid floor/walls (transparent ShaderMaterials at renderOrder 0) still + // draw behind ghosts instead of being depth-rejected: + // PREPASS (renderOrder 1): every ghost mesh duplicated as a color-less + // twin (colorWrite off, depthWrite on) -> the depth buffer ends up + // holding the nearest ghost surface per pixel. + // BEAUTY (renderOrder 2): the real meshes, transparent + depthWrite off; + // the default LessEqual depth test then rejects everything except the + // fragment matching the prepass depth, so internals and back shell + // layers are skipped and each pixel is shaded exactly once. + // Orders are shared by all ghosts (not per-ghost pairs): every beauty pass + // tests against every ghost's prepass depth, so overlapping ghosts occlude + // each other like solids instead of double-blending. + const PREPASS_ORDER = 1; + const BEAUTY_ORDER = 2; + const ghostify = (rig) => { + // Collect first: twins are added below and must not be re-traversed. + const meshes = []; + rig.root.traverse((o) => { if (o.isMesh) meshes.push(o); }); + const cache = new Map(); + let depthMat = null; + for (const o of meshes) { + // Materialization-FX wire overlays cloned along with the local rig: + // drop them, they share the LIVE scan shader material and would + // flash on this ghost every time the local duck re-materializes. + if (o.userData.fxOverlay) { o.parent?.remove(o); continue; } + if (o.userData.ghostPrepass) continue; // twin from a previous ghostify + let m = cache.get(o.material.uuid); + if (!m) { + m = o.material.clone(); + m.transparent = true; + m.opacity = GHOST_OPACITY; + m.depthWrite = false; + cache.set(o.material.uuid, m); + } + o.material = m; + o.renderOrder = BEAUTY_ORDER; + if (!o.userData.hasGhostTwin) { + if (!depthMat) { + // Depth-only material: cloned (no THREE import here) and muted. + // transparent stays true so the twin sorts into the transparent + // pass, after the grid but before the beauty meshes. + depthMat = m.clone(); + depthMat.colorWrite = false; + depthMat.depthWrite = true; + } + // Twin as an identity-transform child: follows joints for free. No + // userData.meshName, so applyVariant never repaints it. + const twin = new o.constructor(o.geometry, depthMat); + twin.renderOrder = PREPASS_ORDER; + twin.userData.ghostPrepass = true; + o.userData.hasGhostTwin = true; + o.add(twin); + } + } + }; + + const ghosts = new Map(); // peerId -> ghost + // Interpolation snapshot: the pose parts of a state message, stamped + // with the local arrival time. + const snapOf = (state) => ({ p: state.p, j: state.j, w: state.w ?? 0, at: performance.now() }); + const makeGhost = (state) => { + const rig = cloneRig(rigFor(state.l)); + applyVariant(rig, state.v); + ghostify(rig); + scene.add(rig.placer); + const trunk = rig.bodies.get("trunk_base"); + // Snap straight to the first received pose: no fly-in from the origin. + trunk.position.set(state.p[0], state.p[1], state.p[2]); + trunk.quaternion.set(state.p[4], state.p[5], state.p[6], state.p[3]); + return { + rig, trunk, buf: [snapOf(state)], + variant: state.v, loco: state.l ?? 0, + }; + }; + + const removeGhost = (peerId) => { + const g = ghosts.get(peerId); + if (!g) return; + scene.remove(g.rig.placer); + const seen = new Set(); + g.rig.root.traverse((o) => { + if (o.isMesh && !seen.has(o.material.uuid)) { + seen.add(o.material.uuid); + o.material.dispose(); + } + }); + ghosts.delete(peerId); + }; + + // Handler signature in this build: (payload, context) where context is + // { peerId } - NOT the bare peerId string of classic trystero. + act.onMessage = (state, { peerId }) => { + let g = ghosts.get(peerId); + if (!g) { + if (ghosts.size >= MAX_GHOSTS) return; // room stays open, rendering capped + // Nostr relays replay recent events, so states from already-dead + // sessions can arrive right after joining: only ghost live peers. + if (!(peerId in room.getPeers())) return; + g = makeGhost(state); + // Idle-visitor gate: remember where this peer first appeared and keep + // its rig invisible until it strays from there (see hasMoved above). + g.spawn = { x: state.p[0], y: state.p[1], yaw: yawOf(state.p) }; + g.revealed = false; + g.rig.placer.visible = false; + ghosts.set(peerId, g); + g.lastSeen = performance.now(); + return; + } + g.lastSeen = performance.now(); + g.buf.push(snapOf(state)); + if (g.buf.length > BUF_MAX) g.buf.shift(); + if (!g.revealed && hasMoved(g.spawn, state.p)) { + g.revealed = true; // latched for the rest of this peer session + g.rig.placer.visible = true; + } + // Peer switched legs <-> rollers: rebuild its ghost on the other rig + // (cheap - cloneRig shares geometry). The snapshot buffer carries over + // so the interpolated motion stays continuous across the swap. + if ((state.l ?? 0) !== g.loco) { + const { lastSeen, spawn, revealed, buf } = g; + removeGhost(peerId); + g = makeGhost(state); + Object.assign(g, { lastSeen, spawn, revealed, buf }); + g.rig.placer.visible = revealed; + ghosts.set(peerId, g); + return; + } + if (state.v !== g.variant) { + g.variant = state.v; + applyVariant(g.rig, state.v); + ghostify(g.rig); + } + }; + + // Same setter-style registration as onMessage. + room.onPeerLeave = (peerId) => removeGhost(peerId); + + // Graceful exit so other tabs drop this ghost immediately... + window.addEventListener("pagehide", () => { + try { room.leave(); } catch {} + }); + // ...and a staleness sweep for peers that vanished without leaving + // (crashed tab, dropped connection): 5 s without a state packet means + // the peer is gone, not just lagging (even background-throttled tabs + // still send at ~1 Hz). + const STALE_MS = 5000; + + // Broadcast + stale sweep on setInterval (not rAF) so both keep running + // in occluded tabs. + setInterval(() => { + const s = getLocalState(); + if (s) sendState(s); + const now = performance.now(); + for (const [peerId, g] of [...ghosts]) { + if (now - g.lastSeen > STALE_MS) removeGhost(peerId); + } + }, 1000 / SEND_HZ); + + // Scratch THREE.Quaternions without importing three: slerp needs real + // instances, cloned here from any node of the already-built local rig. + const _qa = env.rig.placer.quaternion.clone(); + const _qb = env.rig.placer.quaternion.clone(); + return { + room, + peerCount: () => Object.keys(room.getPeers()).length, + ghostCount: () => ghosts.size, + // Minimap feed: revealed ghosts' arena positions in raw MJCF coords + // (trunk.position is set from qpos before the root's Z-up fix). + mapDots: () => + [...ghosts.values()] + .filter((g) => g.revealed) + .map((g) => ({ x: g.trunk.position.x, y: g.trunk.position.y })), + debug: () => [...ghosts.values()].map((g) => { + let meshes = 0, visible = 0, op = null, twins = 0; + g.rig.root.traverse((o) => { + if (!o.isMesh) return; + if (o.userData.ghostPrepass) { twins++; return; } + meshes++; if (o.visible) visible++; op ??= o.material.opacity; + }); + const w = g.trunk.getWorldPosition(g.trunk.position.clone()); + return { p: g.trunk.position.toArray(), world: w.toArray(), inScene: !!g.rig.placer.parent, revealed: g.revealed, meshes, visible, twins, op, v: g.variant }; + }), + update() { + const renderT = performance.now() - INTERP_DELAY_MS; + for (const g of ghosts.values()) { + const buf = g.buf; + // Drop snapshots fully in the past; keep [0] and [1] bracketing + // renderT (or the two newest, if renderT has caught up). + while (buf.length > 2 && buf[1].at <= renderT) buf.shift(); + const a = buf[0]; + const b = buf.length > 1 ? buf[1] : a; + // Clamped: before the segment -> a, past the newest -> hold b. + const span = b.at - a.at; + const u = span > 0 ? Math.min(1, Math.max(0, (renderT - a.at) / span)) : 1; + // Trunk pose in raw MJCF coords: the cloned root applies Z-up -> Y-up. + g.trunk.position.set( + a.p[0] + (b.p[0] - a.p[0]) * u, + a.p[1] + (b.p[1] - a.p[1]) * u, + a.p[2] + (b.p[2] - a.p[2]) * u, + ); + _qa.set(a.p[4], a.p[5], a.p[6], a.p[3]); // THREE order x,y,z,w + _qb.set(b.p[4], b.p[5], b.p[6], b.p[3]); + g.trunk.quaternion.copy(_qa.slerp(_qb, u)); + for (let i = 0; i < jointNames.length; i++) { + setJoint(g.rig, jointNames[i], a.j[i] + (b.j[i] - a.j[i]) * u); + } + setJawOpen(g.rig, a.w + (b.w - a.w) * u); + } + }, + }; +} diff --git a/app/src/game/signed.js b/app/src/game/signed.js new file mode 100644 index 0000000..7c59a06 --- /dev/null +++ b/app/src/game/signed.js @@ -0,0 +1,13 @@ +// Private HF Space auth: the hub iframe URL carries a ?__sign JWT, but +// subresource requests normally rely on a *.static.hf.space cookie that +// browsers often block inside the iframe (third-party cookie blocking), +// which 401s every same-origin fetch. Appending the JWT to each request +// authenticates them regardless of cookie policy. No-op locally. +// +// Only ASSET requests (meshes, policies, XML, audio, images) go through +// this now: application code ships in the Vite bundle, which the page load +// itself already authenticated. +const HF_SIGN = new URLSearchParams(location.search).get("__sign"); + +export const signed = (url) => + HF_SIGN ? `${url}${url.includes("?") ? "&" : "?"}__sign=${encodeURIComponent(HF_SIGN)}` : url; diff --git a/app/src/game/stickers.js b/app/src/game/stickers.js new file mode 100644 index 0000000..79ad61d --- /dev/null +++ b/app/src/game/stickers.js @@ -0,0 +1,222 @@ +// Comic sticker popups: on notable game events (kick, quack, roll, ball +// spawn, ghost peer joining) a die-cut sticker or a comic onomatopoeia pops +// at a semi-random spot on screen, overshoots in, then fades out. Pure +// CSS animations, no dependencies. +// +// Fully self-contained and OPTIONAL: this module owns its DOM layer and its +//