@vgai/editor 0.2.0 → 0.4.0-canary.20260715.0

package/template/src/scripts/main.ts

@@ -1,94 +0,0 @@
-/**
- * Default game script.
- *
- * When launched from the editor, loads the scene the user is editing.
- * When running standalone, loads the default scene from disk.
- *
- * If the scene matches a known example, delegates to that example's setup
- * function so gameplay systems (movement, camera, AI, etc.) are registered.
- */
-
-import type { GameAdapter } from '@engine/adapter';
-import { fromSetup } from '@engine/adapter';
-import type { EditorPreview, GameCleanup, GameContext } from '@engine/runtime/types';
-import { loadScene, loadSceneFromData } from '@engine/scene/scene-loader';
-import { applyScenePostProcessing } from '@engine/setup/setup-renderer';
-import { mountDefaultHud } from '../ui/mount-default-hud';
-import { componentRegistry, gameComponents } from './registry';
-
-const DEFAULT_SCENE = 'scenes/default.vscn.json';
-
-/** Exported for true HMR — play-mode swaps prototypes on live instances. */
-export const components = gameComponents;
-
-// HMR boundary — play-mode.ts handles script hot-reloading via custom events.
-// This prevents Vite from triggering full page reloads when component files change.
-if (import.meta.hot) {
-  import.meta.hot.accept();
-}
-
-export async function setup(ctx: GameContext, editor?: EditorPreview): Promise<GameCleanup> {
-  // Generic fallback: load the scene with the full component registry
-  // so ECS components are applied, but no gameplay systems are registered.
-  const loadOpts = {
-    scene: ctx.scene,
-    rapierWorld: ctx.rapierWorld,
-    rapier: ctx.rapier,
-    physics: ctx.physics,
-    audioListener: ctx.audio.listener,
-    componentRegistry,
-    componentManager: ctx.components,
-    // Required for runtime fidelity (P1.4): particles need the batched renderer,
-    // skybox/IBL needs the WebGLRenderer for PMREM.
-    particleRenderer: ctx.particles.batchedRenderer,
-    renderer: ctx.composer.getRenderer(),
-  };
-
-  // Set the INITIAL camera viewpoint BEFORE loading the scene, so that any
-  // scene-defined camera or SceneCamera component (which run during loadScene)
-  // takes precedence over the editor viewport camera. Generic scenes with no
-  // camera component keep this viewpoint.
-  if (editor?.viewportCamera) {
-    ctx.camera.position.fromArray(editor.viewportCamera.position);
-    ctx.camera.quaternion.fromArray(editor.viewportCamera.quaternion);
-  } else {
-    ctx.camera.position.set(3, 3, 3);
-    ctx.camera.lookAt(0, 0.5, 0);
-  }
-
-  const sceneInstance = editor
-    ? await loadSceneFromData(editor.sceneData, loadOpts)
-    : await loadScene(DEFAULT_SCENE, loadOpts);
-
-  // Apply scene-defined post-processing (bloom, vignette, DoF, …) if present.
-  if (sceneInstance.environment?.postProcessing) {
-    applyScenePostProcessing(
-      ctx.composer,
-      ctx.composer.getRenderer(),
-      ctx.scene,
-      ctx.camera,
-      sceneInstance.environment,
-    );
-  }
-
-  // Tick scene animations (GLTF mixers, etc.)
-  ctx.systems.add('postPhysics', (dt) => sceneInstance.update(dt));
-
-  // Default game HUD (C1, docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §9):
-  // ordinary React mounted through the existing `mountUI(ctx.uiContainer, ...)`
-  // overlay seam — see `../ui/DefaultHud.tsx`. Delete this line (and the HUD
-  // files under `../ui/`) if your game doesn't want it; it is not required by
-  // anything else in the template.
-  const unmountHud = mountDefaultHud(ctx.uiContainer);
-
-  return {
-    dispose() {
-      unmountHud();
-      sceneInstance.dispose();
-    },
-  };
-}
-
-/** This example as a {@link GameAdapter} — first-party is one implementer of
- *  the same interface an external game implements (no change to setup's body). */
-export const adapter: GameAdapter = fromSetup('default', setup);

package/template/src/ui/DefaultHud.tsx

@@ -1,40 +0,0 @@
-import { useState } from 'react';
-import { Button } from './Button';
-import { Panel } from './Panel';
-
-export interface DefaultHudProps {
-  /** Panel title — plain prop, no VGAI binding-expression language. */
-  title: string;
-}
-
-/**
- * The template's default game HUD (C1,
- * docs/AI-NATIVE-AUTHORING-IMPLEMENTATION-SPEC.md §9 "Make React the
- * Template Default" / §5.1 React UI Contract): ordinary React — a plain
- * `.tsx` component driven by props and a `useState` hook, normal inline
- * styling (no CSS files), no `UINode`/Scene UI binding language.
- *
- * Mounted through the existing overlay seam — `mountUI(ctx.uiContainer, ...)`
- * — by `mount-default-hud.tsx`, called from `../scripts/main.ts`'s `setup()`.
- * Replace or delete this component freely; it exists to prove (and
- * demonstrate) the React-HUD-by-default path, not to be load-bearing
- * gameplay UI.
- */
-export function DefaultHud({ title }: DefaultHudProps) {
-  const [paused, setPaused] = useState(false);
-
-  return (
-    <Panel title={title} position="top-left">
-      <div
-        data-testid="default-hud-status"
-        style={{ color: paused ? '#dd3d3d' : '#3ddc65', fontSize: 12 }}
-      >
-        {paused ? 'Paused' : 'Running'}
-      </div>
-      <Button
-        label={paused ? 'Resume' : 'Pause'}
-        onClick={() => setPaused((wasPaused) => !wasPaused)}
-      />
-    </Panel>
-  );
-}

package/template/src/ui/game-state.tsx

@@ -1,37 +0,0 @@
-/**
- * Thin re-export of the engine-published state bridge (D-Z5,
- * `docs/WAVE3-ADAPTER-PLUMBING-DESIGN.md` §D-Z5) — `GameProvider`/`useGame`/
- * `useGameState`/`useWorldObservation` now live canonically at
- * `@engine/react/game-state` (`packages/engine/src/react/game-state.tsx`,
- * the spec this file used to BE before D-Z5; see that module's doc comment
- * for the full implementation and the context-identity rule it documents).
- *
- * This file KEEPS EXISTING on purpose — every scaffolded project still has
- * `src/ui/game-state.tsx`, so:
- *   - `packages/editor/vite-plugin-react-world-provider.ts`'s virtual module
- *     (`export { GameProvider } from '/@fs/<root>/src/ui/game-state.tsx'`)
- *     keeps working byte-for-byte — it re-exports from THIS file, which now
- *     re-exports from the engine, but the file it points at (and the
- *     identity `useGame()` resolves against) is unchanged.
- *   - a react-world entry's own relative `import { useGameState } from
- *     './ui/game-state'` keeps resolving here too — both routes still
- *     converge on ONE module instance (this file), which itself resolves the
- *     engine's `@engine/react/game-state` exactly once, so `createContext()`
- *     runs exactly once per project. No context split.
- *
- * Adoption of the engine module is an OPTION, not a migration: existing
- * projects that already have their OWN full copy of this file (their own
- * `createContext`) are untouched by this change — only NEW projects
- * scaffolded from the template get this canonical re-export. A project that
- * wants a customized bridge can still replace this file with its own full
- * implementation, exactly as before.
- */
-
-export {
-  GameProvider,
-  requireWorldObserver,
-  shallow,
-  useGame,
-  useGameState,
-  useWorldObservation,
-} from '@engine/react/game-state';

package/template/src/ui/mount-default-hud.tsx

@@ -1,19 +0,0 @@
-import { DefaultHud } from './DefaultHud';
-import { mountUI } from './mount-ui';
-
-/**
- * Mounts the template's default React HUD into the shared UI overlay
- * (`ctx.uiContainer` — `pointer-events:none`; `Panel`/`Button` inside opt
- * back in via `pointer-events:auto`, so the game canvas keeps receiving
- * pointer events everywhere except the HUD's own controls) and returns an
- * unmount function. Kept as its own `.tsx` module so `../scripts/main.ts` —
- * the game SETUP script, not a component — never needs JSX syntax itself.
- *
- * Usage (see `../scripts/main.ts`):
- *   const unmountHud = mountDefaultHud(ctx.uiContainer);
- *   // ... later, in the returned GameCleanup:
- *   //   dispose() { unmountHud(); sceneInstance.dispose(); }
- */
-export function mountDefaultHud(container: HTMLDivElement): () => void {
-  return mountUI(container, <DefaultHud title="Game Status" />);
-}

package/template/src/ui/mount-ui.ts

@@ -1,15 +0,0 @@
-import type { ReactNode } from 'react';
-import { createRoot } from 'react-dom/client';
-
-/**
- * Mount a React element into a container div and return a cleanup function.
- *
- * Usage in example dispose():
- *   const unmount = mountUI(ctx.uiContainer, <MyHUD />);
- *   return { dispose: unmount };
- */
-export function mountUI(container: HTMLDivElement, element: ReactNode): () => void {
-  const root = createRoot(container);
-  root.render(element);
-  return () => root.unmount();
-}

package/vite-plugin-react-world-provider.ts

@@ -1,81 +0,0 @@
-/**
- * Vite plugin: a tiny synthetic ES module that STATICALLY re-exports
- * `GameProvider` from a given project's `src/ui/game-state.tsx`
- * (T6.2 slice 3 finding — see `packages/editor/src/adapter-resolver.ts`'s
- * `loadProjectGameProvider` doc comment for the full mechanism this closes).
- *
- * The problem this solves: `resolveDefaultReactAdapter` needs `GameProvider`
- * from the SAME `game-state.tsx` module instance a react world's entry
- * module's OWN static relative import (`import { useGameState } from
- * './src/ui/game-state'`) resolves to — otherwise `<GameProvider>`
- * and `useGameState`'s `useGame()` read/write DIFFERENT `createContext()`
- * objects and `useGame()` throws "no Game in context" even though
- * `<GameProvider>` genuinely wraps the tree. `adapter-resolver.ts` cannot
- * import `game-state.tsx` directly with a hand-built runtime `/@fs/` string
- * (`import(/* @vite-ignore *\/ computedPath)`) and expect it to land on the
- * SAME module: verified empirically (T6.2 slice 3's AC e2e, and this
- * plugin's own doc history) that Vite's dev server treats a raw dynamic
- * `/@fs/` fetch differently from its own rewrite of a STATIC relative
- * import found while transforming a `.tsx` file — the two request URLs
- * diverge (a query-string difference observed in practice), and since
- * browser ES module identity is per-exact-URL, that is enough to produce
- * TWO separate module instances even though both point at the identical
- * file on disk.
- *
- * The fix: make the resolver's own request for `GameProvider` go through
- * the SAME transform-time static-import rewrite Vite already applies to a
- * react-world entry's own relative import, by asking Vite to transform a
- * SYNTHETIC module whose body is nothing but a literal, static
- * `export { GameProvider } from '/@fs/<projectRoot>/src/ui/
- * game-state.tsx';` — that specifier is resolved by the SAME plugin
- * machinery (Vite's own `resolveId`) an entry module's static import goes
- * through, so both converge on the identical final module.
- */
-import type { Plugin } from 'vite';
-
-/** The dynamic-import-facing URL prefix (`?root=<projectRoot>` query). */
-export const REACT_WORLD_PROVIDER_PATH = '/__vgai-game-provider';
-
-const VIRTUAL_ID_PREFIX = '\0vgai-game-provider:';
-
-/** Build the dynamic-import specifier `adapter-resolver.ts` uses. */
-export function reactWorldProviderImportSpecifier(projectRoot: string): string {
-  return `${REACT_WORLD_PROVIDER_PATH}?root=${encodeURIComponent(projectRoot)}`;
-}
-
-export function reactWorldProviderPlugin(): Plugin {
-  return {
-    name: 'vgai-react-world-provider',
-    resolveId(id) {
-      if (id.startsWith(REACT_WORLD_PROVIDER_PATH)) {
-        const query = id.slice(REACT_WORLD_PROVIDER_PATH.length);
-        return VIRTUAL_ID_PREFIX + query;
-      }
-      return undefined;
-    },
-    load(id) {
-      if (!id.startsWith(VIRTUAL_ID_PREFIX)) return undefined;
-      const query = id.slice(VIRTUAL_ID_PREFIX.length);
-      const params = new URLSearchParams(query.startsWith('?') ? query.slice(1) : query);
-      const projectRoot = params.get('root');
-      if (!projectRoot) {
-        throw new Error(
-          `vgai-react-world-provider: missing \`?root=\` (got id "${id}") — ` +
-            'reactWorldProviderImportSpecifier() should always supply it.',
-        );
-      }
-      // Windows roots arrive as 'C:\…' — no leading slash and backslashed.
-      // Normalize to Vite's canonical '/@fs/C:/…' form; the bare-concat form
-      // degenerates to '/@fsC:\…', which Vite cannot serve. POSIX roots
-      // (leading '/') keep the original concat shape.
-      const rootUrlPath = projectRoot.replace(/\\/g, '/');
-      const gameStatePath = `/@fs${rootUrlPath.startsWith('/') ? '' : '/'}${rootUrlPath}/src/ui/game-state.tsx`;
-      // A LITERAL static specifier — Vite's own import-analysis rewrites this
-      // the SAME way it rewrites a react-world entry's own relative import
-      // to the same file (both are static specifiers processed by the same
-      // resolver at transform time), which is what makes the two converge on
-      // one module instance.
-      return `export { GameProvider } from ${JSON.stringify(gameStatePath)};\n`;
-    },
-  };
-}