@jgengine/shell 0.7.0 → 0.9.0

package/dist/environment/EnvironmentScene.js

@@ -1,75 +1,114 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useMemo } from "react";
-import { generateBuildingDistrict } from "@jgengine/core/world/buildings";
-import { resolveTerrainField } from "@jgengine/core/world/terrain";
-import { GeneratedBuilding } from "../structures/GeneratedBuilding.js";
+import { useMemo, useRef } from "react";
+import { useFrame } from "@react-three/fiber";
+import { useGameContext } from "@jgengine/react/provider";
+import { resolveBuildingPalette } from "@jgengine/core/world/buildings";
+import { resolveStructureBuildings } from "@jgengine/core/world/environmentSummary";
+import { createTerrainPaletteSampler, resolveEnvironmentField, resolveTerrainPalette, } from "@jgengine/core/world/terrain";
+import { GroundPad } from "./GroundPad.js";
+import { InstancedBuildings } from "../structures/GeneratedBuilding.js";
 import { GrassField } from "../terrain/GrassField.js";
-import { ProceduralGround } from "../terrain/ProceduralGround.js";
+import { CarvedTerrain } from "../terrain/CarvedTerrain.js";
 import { Ocean } from "../water/Ocean.js";
 import { RainField } from "../weather/RainField.js";
 import { SnowField } from "../weather/SnowField.js";
 import { WeatherUniformProvider } from "../weather/weatherUniforms.js";
-const DEFAULT_TERRAIN_FREQUENCY = 0.03;
-function TerrainGround({ terrain }) {
-    return (_jsx(ProceduralGround, { terrain: {
-            size: [terrain.bounds.w, terrain.bounds.d],
-            height: terrain.height,
-            seed: terrain.seed,
-            moundScale: terrain.frequency ?? DEFAULT_TERRAIN_FREQUENCY,
-            octaves: terrain.octaves,
-            ridged: terrain.ridged,
-            baseOffset: terrain.baseHeight,
-        }, colors: terrain.waterLevel === undefined ? undefined : { waterlineHeight: terrain.waterLevel } }));
+function TerrainGround({ terrain, field, center, }) {
+    const palette = useMemo(() => resolveTerrainPalette(terrain), [terrain]);
+    const paletteAt = useMemo(() => {
+        if (terrain.materialRegions === undefined || terrain.materialRegions.length === 0)
+            return undefined;
+        const sampler = createTerrainPaletteSampler(terrain);
+        if (center === undefined)
+            return sampler;
+        return (x, z) => sampler(x - center[0], z - center[1]);
+    }, [terrain, center]);
+    const colors = useMemo(() => ({
+        low: palette.low,
+        high: palette.high,
+        ...(terrain.waterLevel === undefined ? {} : { waterline: palette.waterline, waterlineHeight: terrain.waterLevel }),
+    }), [palette, terrain.waterLevel]);
+    const size = useMemo(() => [terrain.bounds.w, terrain.bounds.d], [terrain.bounds]);
+    const heightRange = useMemo(() => {
+        const base = terrain.baseHeight ?? 0;
+        const swing = terrain.height * 1.2;
+        return [base - swing, base + swing];
+    }, [terrain.baseHeight, terrain.height]);
+    return (_jsx(CarvedTerrain, { field: field, size: size, segments: terrain.segments, colors: colors, heightRange: heightRange, paletteAt: paletteAt, center: center, roughness: 0.94 }));
+}
+function areaCenter(area) {
+    return area.position ?? [0, 0];
 }
 function Vegetation({ grass, field }) {
-    return (_jsx(GrassField, { area: [grass.area.w, grass.area.d], density: grass.density, seed: grass.seed, bladeHeight: grass.bladeHeight, bladeWidth: grass.bladeWidth, heightAt: field.sampleHeight, colorBase: grass.colors[0], colorTip: grass.colors[grass.colors.length - 1], wind: { strength: grass.windStrength } }));
+    const [cx, cz] = areaCenter(grass.area);
+    const heightAt = useMemo(() => cx === 0 && cz === 0
+        ? field.sampleHeight
+        : (x, z) => field.sampleHeight(x + cx, z + cz), [cx, cz, field]);
+    const area = useMemo(() => [grass.area.w, grass.area.d], [grass.area.w, grass.area.d]);
+    const wind = useMemo(() => ({ strength: grass.windStrength }), [grass.windStrength]);
+    const colorBase = grass.colors[0];
+    const colorTip = grass.colors[grass.colors.length - 1];
+    return (_jsx("group", { position: [cx, 0, cz], children: _jsx(GrassField, { area: area, density: grass.density, seed: grass.seed, bladeHeight: grass.bladeHeight, bladeWidth: grass.bladeWidth, heightAt: heightAt, colorBase: colorBase, colorTip: colorTip, wind: wind, frustumCulled: true }) }));
 }
 function weatherVolume(area) {
     return [area.w, area.h ?? 60, area.d];
 }
 function Precipitation({ weather }) {
+    const [cx, cz] = areaCenter(weather.area);
     if (weather.kind === "rain") {
-        return (_jsx(RainField, { density: weather.density, speed: weather.speed, length: weather.dropLength, color: weather.color, wind: [weather.wind[0], 0, weather.wind[1]], volume: weatherVolume(weather.area) }));
+        return (_jsx("group", { position: [cx, 0, cz], children: _jsx(RainField, { density: weather.density, speed: weather.speed, length: weather.dropLength, color: weather.color, wind: [weather.wind[0], 0, weather.wind[1]], volume: weatherVolume(weather.area) }) }));
     }
-    return (_jsx(SnowField, { density: weather.density, speed: weather.speed, size: weather.flakeSize, sway: weather.drift, color: weather.color, wind: [weather.wind[0], 0, weather.wind[1]], volume: weatherVolume(weather.area) }));
+    return (_jsx("group", { position: [cx, 0, cz], children: _jsx(SnowField, { density: weather.density, speed: weather.speed, size: weather.flakeSize, sway: weather.drift, color: weather.color, wind: [weather.wind[0], 0, weather.wind[1]], volume: weatherVolume(weather.area) }) }));
 }
 function Weather({ weather }) {
     return (_jsx(WeatherUniformProvider, { children: weather.map((entry, index) => (_jsx(Precipitation, { weather: entry, index: index }, `${entry.kind}-${index}`))) }));
 }
+function oceanConfig(ocean) {
+    return {
+        size: ocean.bounds.w,
+        depth: ocean.bounds.d,
+        amplitude: ocean.waveHeight,
+        speed: ocean.waveSpeed,
+        waveScale: ocean.waveScale,
+        color: { shallow: ocean.color },
+    };
+}
+function useOceanConfig(ocean) {
+    return useMemo(() => oceanConfig(ocean), [ocean.bounds.w, ocean.bounds.d, ocean.waveHeight, ocean.waveSpeed, ocean.color]);
+}
+function DynamicWater({ ocean }) {
+    const ctx = useGameContext();
+    const groupRef = useRef(null);
+    const [x, z] = ocean.position ?? [0, 0];
+    const config = useOceanConfig(ocean);
+    useFrame(() => {
+        if (groupRef.current !== null)
+            groupRef.current.position.y = ocean.levelAt(ctx.time.now());
+    });
+    return (_jsx("group", { ref: groupRef, position: [0, ocean.level, 0], children: _jsx(Ocean, { position: [x, 0, z], config: config }) }));
+}
 function Water({ ocean }) {
-    return (_jsx(Ocean, { "position-y": ocean.level, config: {
-            size: Math.max(ocean.bounds.w, ocean.bounds.d),
-            amplitude: ocean.waveHeight,
-            speed: ocean.waveSpeed,
-            color: { shallow: ocean.color },
-        } }));
+    const [x, z] = ocean.position ?? [0, 0];
+    const config = useOceanConfig(ocean);
+    if (ocean.levelAt !== undefined) {
+        return _jsx(DynamicWater, { ocean: ocean });
+    }
+    return _jsx(Ocean, { position: [x, ocean.level, z], config: config });
 }
-function Structures({ structures }) {
-    const buildings = useMemo(() => {
-        const columns = Math.max(1, Math.ceil(Math.sqrt(structures.count)));
-        const rows = Math.max(1, Math.ceil(structures.count / columns));
-        const spacing = structures.spacing;
-        const origin = [
-            -((columns - 1) * (structures.footprint.w + spacing)) / 2,
-            -((rows - 1) * (structures.footprint.d + spacing)) / 2,
-        ];
-        return generateBuildingDistrict({
-            rows,
-            columns,
-            origin,
-            lotSize: structures.footprint,
-            streetWidth: spacing,
-            floorRange: structures.stories,
-            base: { floorHeight: structures.storyHeight },
-            ...(structures.seed === undefined ? {} : { seed: structures.seed }),
-        }).slice(0, structures.count);
-    }, [structures]);
-    return (_jsx(_Fragment, { children: buildings.map((building) => (_jsx(GeneratedBuilding, { building: building }, building.id))) }));
+function Structures({ structures, field }) {
+    const placements = useMemo(() => resolveStructureBuildings(structures).map((building) => ({
+        building,
+        position: [0, field.sampleHeight(building.center[0], building.center[1]), 0],
+    })), [structures, field]);
+    const palette = useMemo(() => resolveBuildingPalette(structures.style, structures.palette), [structures.style, structures.palette]);
+    return _jsx(InstancedBuildings, { buildings: placements, palette: palette });
 }
 export function EnvironmentScene({ feature }) {
-    const field = useMemo(() => resolveTerrainField(feature.terrain), [feature.terrain]);
+    const field = useMemo(() => resolveEnvironmentField(feature), [feature]);
     const vegetation = feature.vegetation ?? [];
     const water = feature.water ?? [];
     const structures = feature.structures ?? [];
-    return (_jsxs(_Fragment, { children: [feature.terrain !== undefined ? _jsx(TerrainGround, { terrain: feature.terrain }) : null, water.map((ocean, index) => (_jsx(Water, { ocean: ocean }, `ocean-${index}`))), structures.map((entry, index) => (_jsx(Structures, { structures: entry }, `structures-${index}`))), vegetation.map((grass, index) => (_jsx(Vegetation, { grass: grass, field: field }, `grass-${index}`))), feature.weather !== undefined && feature.weather.length > 0 ? (_jsx(Weather, { weather: feature.weather })) : null] }));
+    const pads = feature.pads ?? [];
+    const islands = feature.islands ?? [];
+    return (_jsxs(_Fragment, { children: [feature.terrain !== undefined ? _jsx(TerrainGround, { terrain: feature.terrain, field: field }) : null, islands.map((entry, index) => (_jsx(TerrainGround, { terrain: entry, field: field, center: entry.origin }, `island-${index}`))), water.map((ocean, index) => (_jsx(Water, { ocean: ocean }, `ocean-${index}`))), structures.map((entry, index) => (_jsx(Structures, { structures: entry, field: field }, `structures-${index}`))), pads.map((entry, index) => (_jsx(GroundPad, { pad: entry, field: field }, `pad-${index}`))), vegetation.map((grass, index) => (_jsx(Vegetation, { grass: grass, field: field }, `grass-${index}`))), feature.weather !== undefined && feature.weather.length > 0 ? (_jsx(Weather, { weather: feature.weather })) : null] }));
 }

package/dist/environment/GroundPad.d.ts

@@ -0,0 +1,7 @@
+import type { PadEnvironmentDescriptor } from "@jgengine/core/world/features";
+import type { TerrainField } from "@jgengine/core/world/terrain";
+export interface GroundPadProps {
+    pad: PadEnvironmentDescriptor;
+    field: TerrainField;
+}
+export declare function GroundPad({ pad, field }: GroundPadProps): import("react").JSX.Element;

package/dist/environment/GroundPad.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { PAD_THICKNESS, resolvePadMeshY, resolvePadShape } from "./groundPadMath.js";
+export function GroundPad({ pad, field }) {
+    const [x, z] = pad.center;
+    const groundHeight = field.sampleHeight(x, z);
+    const meshY = resolvePadMeshY(groundHeight, pad);
+    const shape = resolvePadShape(pad.size);
+    if (shape.circular) {
+        return (_jsxs("mesh", { position: [x, meshY, z], receiveShadow: true, children: [_jsx("cylinderGeometry", { args: [shape.radius, shape.radius, PAD_THICKNESS, 32] }), _jsx("meshStandardMaterial", { color: pad.color, roughness: 0.9 })] }));
+    }
+    return (_jsxs("mesh", { position: [x, meshY, z], rotation: [0, pad.rotationY ?? 0, 0], receiveShadow: true, children: [_jsx("boxGeometry", { args: [shape.width, PAD_THICKNESS, shape.depth] }), _jsx("meshStandardMaterial", { color: pad.color, roughness: 0.9 })] }));
+}

package/dist/environment/daylightCycle.d.ts

@@ -0,0 +1,26 @@
+export interface DaylightCycleConfig {
+    horizonColor?: string;
+    zenithColor?: string;
+    sunIntensity?: number;
+    ambientIntensity?: number;
+}
+export interface DaylightState {
+    sunPosition: [number, number, number];
+    sunIntensity: number;
+    ambientIntensity: number;
+    skyTop: string;
+    skyBottom: string;
+    background: string;
+}
+export declare const DEFAULT_DAY_SUN_INTENSITY = 1;
+export declare const DEFAULT_DAY_AMBIENT_INTENSITY = 0.6;
+export declare const DEFAULT_DAY_SKY_TOP = "#3fa4f2";
+export declare const DEFAULT_DAY_SKY_BOTTOM = "#e3f4ff";
+export declare const SKY_PRESET_DAY_FRACTION: Record<"day" | "dusk" | "night", number>;
+export declare function lerpHexColor(a: string, b: string, t: number): string;
+/**
+ * Samples the daylight cycle at a point in the day (0 = midnight, 0.25 = dawn, 0.5 = noon, 0.75 = dusk),
+ * lerping sun position/intensity, ambient intensity, and sky colors through a dawn/day/dusk/night
+ * keyframe table. `config` overrides the noon (peak-day) colors and intensities only.
+ */
+export declare function daylightStateAt(dayFraction: number, config?: DaylightCycleConfig): DaylightState;

package/dist/environment/daylightCycle.js

@@ -0,0 +1,116 @@
+const NIGHT_SUN_INTENSITY = 0.02;
+const NIGHT_AMBIENT_INTENSITY = 0.08;
+const NIGHT_SKY_TOP = "#02030a";
+const NIGHT_SKY_BOTTOM = "#05070f";
+const DAWN_SUN_INTENSITY = 0.45;
+const DAWN_AMBIENT_INTENSITY = 0.3;
+const DAWN_SKY_TOP = "#3c5a82";
+const DAWN_SKY_BOTTOM = "#ffb37a";
+const DUSK_SUN_INTENSITY = 0.45;
+const DUSK_AMBIENT_INTENSITY = 0.3;
+const DUSK_SKY_TOP = "#4a3a5c";
+const DUSK_SKY_BOTTOM = "#ff8a5c";
+export const DEFAULT_DAY_SUN_INTENSITY = 1;
+export const DEFAULT_DAY_AMBIENT_INTENSITY = 0.6;
+export const DEFAULT_DAY_SKY_TOP = "#3fa4f2";
+export const DEFAULT_DAY_SKY_BOTTOM = "#e3f4ff";
+const SUN_DISTANCE = 200;
+const SUN_DEPTH_RATIO = 0.4;
+export const SKY_PRESET_DAY_FRACTION = {
+    night: 0,
+    day: 0.5,
+    dusk: 0.75,
+};
+function clamp01(value) {
+    return value < 0 ? 0 : value > 1 ? 1 : value;
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function hexToRgb(hex) {
+    const clean = hex.startsWith("#") ? hex.slice(1) : hex;
+    const value = parseInt(clean, 16);
+    return [(value >> 16) & 255, (value >> 8) & 255, value & 255];
+}
+function clampByte(value) {
+    return Math.max(0, Math.min(255, Math.round(value)));
+}
+function rgbToHex(rgb) {
+    return `#${rgb.map((channel) => clampByte(channel).toString(16).padStart(2, "0")).join("")}`;
+}
+export function lerpHexColor(a, b, t) {
+    const [ar, ag, ab] = hexToRgb(a);
+    const [br, bg, bb] = hexToRgb(b);
+    return rgbToHex([lerp(ar, br, t), lerp(ag, bg, t), lerp(ab, bb, t)]);
+}
+function buildKeyframes(config) {
+    const night = {
+        t: 0,
+        sunIntensity: NIGHT_SUN_INTENSITY,
+        ambientIntensity: NIGHT_AMBIENT_INTENSITY,
+        skyTop: NIGHT_SKY_TOP,
+        skyBottom: NIGHT_SKY_BOTTOM,
+    };
+    const dawn = {
+        t: 0.25,
+        sunIntensity: DAWN_SUN_INTENSITY,
+        ambientIntensity: DAWN_AMBIENT_INTENSITY,
+        skyTop: DAWN_SKY_TOP,
+        skyBottom: DAWN_SKY_BOTTOM,
+    };
+    const day = {
+        t: 0.5,
+        sunIntensity: config.sunIntensity ?? DEFAULT_DAY_SUN_INTENSITY,
+        ambientIntensity: config.ambientIntensity ?? DEFAULT_DAY_AMBIENT_INTENSITY,
+        skyTop: config.zenithColor ?? DEFAULT_DAY_SKY_TOP,
+        skyBottom: config.horizonColor ?? DEFAULT_DAY_SKY_BOTTOM,
+    };
+    const dusk = {
+        t: 0.75,
+        sunIntensity: DUSK_SUN_INTENSITY,
+        ambientIntensity: DUSK_AMBIENT_INTENSITY,
+        skyTop: DUSK_SKY_TOP,
+        skyBottom: DUSK_SKY_BOTTOM,
+    };
+    const midnight = { ...night, t: 1 };
+    return [night, dawn, day, dusk, midnight];
+}
+function wrapFraction(dayFraction) {
+    return ((dayFraction % 1) + 1) % 1;
+}
+function segmentAt(wrapped, keyframes) {
+    for (let index = 0; index < keyframes.length - 1; index += 1) {
+        const from = keyframes[index];
+        const to = keyframes[index + 1];
+        if (wrapped >= from.t && wrapped <= to.t) {
+            const span = to.t - from.t;
+            const localT = span <= 0 ? 0 : clamp01((wrapped - from.t) / span);
+            return { from, to, localT };
+        }
+    }
+    const last = keyframes[keyframes.length - 1];
+    return { from: last, to: last, localT: 0 };
+}
+/**
+ * Samples the daylight cycle at a point in the day (0 = midnight, 0.25 = dawn, 0.5 = noon, 0.75 = dusk),
+ * lerping sun position/intensity, ambient intensity, and sky colors through a dawn/day/dusk/night
+ * keyframe table. `config` overrides the noon (peak-day) colors and intensities only.
+ */
+export function daylightStateAt(dayFraction, config = {}) {
+    const wrapped = wrapFraction(dayFraction);
+    const keyframes = buildKeyframes(config);
+    const { from, to, localT } = segmentAt(wrapped, keyframes);
+    const sunIntensity = lerp(from.sunIntensity, to.sunIntensity, localT);
+    const ambientIntensity = lerp(from.ambientIntensity, to.ambientIntensity, localT);
+    const skyTop = lerpHexColor(from.skyTop, to.skyTop, localT);
+    const skyBottom = lerpHexColor(from.skyBottom, to.skyBottom, localT);
+    const angle = (wrapped - 0.25) * 2 * Math.PI;
+    const elevation = Math.sin(angle);
+    const azimuth = Math.cos(angle);
+    const sunPosition = [
+        azimuth * SUN_DISTANCE,
+        elevation * SUN_DISTANCE,
+        SUN_DISTANCE * SUN_DEPTH_RATIO,
+    ];
+    return { sunPosition, sunIntensity, ambientIntensity, skyTop, skyBottom, background: skyBottom };
+}

package/dist/environment/groundPadMath.d.ts

@@ -0,0 +1,13 @@
+import type { PadEnvironmentDescriptor, PadSize } from "@jgengine/core/world/features";
+export declare const PAD_THICKNESS = 0.1;
+export type PadShape = {
+    circular: true;
+    radius: number;
+} | {
+    circular: false;
+    width: number;
+    depth: number;
+};
+export declare function resolvePadShape(size: PadSize): PadShape;
+export declare function resolvePadSurfaceY(groundHeight: number, pad: Pick<PadEnvironmentDescriptor, "height" | "elevation">): number;
+export declare function resolvePadMeshY(groundHeight: number, pad: Pick<PadEnvironmentDescriptor, "height" | "elevation">): number;

package/dist/environment/groundPadMath.js

@@ -0,0 +1,10 @@
+export const PAD_THICKNESS = 0.1;
+export function resolvePadShape(size) {
+    return "radius" in size ? { circular: true, radius: size.radius } : { circular: false, width: size[0], depth: size[1] };
+}
+export function resolvePadSurfaceY(groundHeight, pad) {
+    return pad.elevation ?? groundHeight + pad.height;
+}
+export function resolvePadMeshY(groundHeight, pad) {
+    return resolvePadSurfaceY(groundHeight, pad) - PAD_THICKNESS / 2;
+}

package/dist/environment/index.d.ts

@@ -1 +1,4 @@
+export { Daylight, SkyDaylight, SkyDome, TimeOfDayDaylight, type DaylightProps, type SkyDaylightProps, type SkyDomeProps, type TimeOfDayDaylightProps, } from "./Daylight.js";
 export { EnvironmentScene, type EnvironmentSceneProps } from "./EnvironmentScene.js";
+export { daylightStateAt, lerpHexColor, SKY_PRESET_DAY_FRACTION, type DaylightCycleConfig, type DaylightState, } from "./daylightCycle.js";
+export { resolveSkyLightOwnership, skyEmitsLights, type SkyLightOwnership, } from "./skyLightingPolicy.js";

package/dist/environment/index.js

@@ -1 +1,4 @@
+export { Daylight, SkyDaylight, SkyDome, TimeOfDayDaylight, } from "./Daylight.js";
 export { EnvironmentScene } from "./EnvironmentScene.js";
+export { daylightStateAt, lerpHexColor, SKY_PRESET_DAY_FRACTION, } from "./daylightCycle.js";
+export { resolveSkyLightOwnership, skyEmitsLights, } from "./skyLightingPolicy.js";

package/dist/environment/skyLightingPolicy.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Policy for composing sky backdrops with `PlayableGame.lighting`:
+ * - authored lighting present → sky renders dome + fog only; lights stay game-owned
+ * - no authored lighting → sky may emit its default sun/hemisphere with the dome
+ * Time-of-day never rewrites configured lights; it only drives sky colors/fog (and
+ * sky-owned lights when the game did not author lighting).
+ */
+export type SkyLightOwnership = "authored" | "sky-default";
+export declare function resolveSkyLightOwnership(hasAuthoredLighting: boolean): SkyLightOwnership;
+export declare function skyEmitsLights(ownership: SkyLightOwnership): boolean;

package/dist/environment/skyLightingPolicy.js

@@ -0,0 +1,6 @@
+export function resolveSkyLightOwnership(hasAuthoredLighting) {
+    return hasAuthoredLighting ? "authored" : "sky-default";
+}
+export function skyEmitsLights(ownership) {
+    return ownership === "sky-default";
+}

package/dist/input/mouseLook.d.ts

@@ -0,0 +1,27 @@
+export interface MouseLookOptions {
+    /** Radians of look per pixel of mouse movement; default `0.0024`. */
+    sensitivity?: number;
+    /** Pitch clamp in radians; default `1.15`. */
+    maxPitch?: number;
+    /** Request pointer lock on click (skipped on coarse-pointer/touch devices); default `true`. */
+    pointerLock?: boolean;
+    initialYaw?: number;
+    initialPitch?: number;
+}
+export interface MouseLookAim {
+    yaw: number;
+    pitch: number;
+}
+/**
+ * The analog mouse-look service chase/orbit-cam games hand-rolled (#282.8) — pointer-lock
+ * lifecycle plus delta accumulation into a yaw/pitch aim, decoupled from the first-person rig.
+ * Attach it to the canvas, read `aim()` from `onTick`/`useFrame`, dispose on unmount.
+ */
+export interface MouseLookTracker {
+    aim(): MouseLookAim;
+    setAim(yaw: number, pitch: number): void;
+    /** True while pointer lock is held on the tracked element. */
+    locked(): boolean;
+    dispose(): void;
+}
+export declare function createMouseLookTracker(element: HTMLElement, options?: MouseLookOptions): MouseLookTracker;

package/dist/input/mouseLook.js

@@ -0,0 +1,35 @@
+export function createMouseLookTracker(element, options = {}) {
+    const sensitivity = options.sensitivity ?? 0.0024;
+    const maxPitch = options.maxPitch ?? 1.15;
+    const pointerLock = options.pointerLock ?? true;
+    let yaw = options.initialYaw ?? 0;
+    let pitch = options.initialPitch ?? 0;
+    const requestLock = () => {
+        if (!pointerLock)
+            return;
+        if (window.matchMedia?.("(pointer: coarse)").matches)
+            return;
+        if (document.pointerLockElement !== element)
+            void element.requestPointerLock?.();
+    };
+    const onMove = (event) => {
+        if (pointerLock && document.pointerLockElement !== element)
+            return;
+        yaw -= event.movementX * sensitivity;
+        pitch = Math.max(-maxPitch, Math.min(maxPitch, pitch - event.movementY * sensitivity));
+    };
+    element.addEventListener("click", requestLock);
+    window.addEventListener("mousemove", onMove);
+    return {
+        aim: () => ({ yaw, pitch }),
+        setAim(nextYaw, nextPitch) {
+            yaw = nextYaw;
+            pitch = Math.max(-maxPitch, Math.min(maxPitch, nextPitch));
+        },
+        locked: () => document.pointerLockElement === element,
+        dispose() {
+            element.removeEventListener("click", requestLock);
+            window.removeEventListener("mousemove", onMove);
+        },
+    };
+}

package/dist/materialOverride.d.ts

@@ -0,0 +1,6 @@
+import * as THREE from "three";
+import type { ModelMaterialOverride } from "@jgengine/core/game/playableGame";
+export interface MaterialOverrideOptions {
+    clone?: boolean;
+}
+export declare function applyMaterialOverride(root: THREE.Object3D, override: ModelMaterialOverride, options?: MaterialOverrideOptions): void;

package/dist/materialOverride.js

@@ -0,0 +1,28 @@
+import * as THREE from "three";
+export function applyMaterialOverride(root, override, options) {
+    const clone = options?.clone !== false;
+    root.traverse((node) => {
+        const mesh = node;
+        if (!mesh.isMesh)
+            return;
+        mesh.material = Array.isArray(mesh.material)
+            ? mesh.material.map((material) => overrideOne(material, override, clone))
+            : overrideOne(mesh.material, override, clone);
+    });
+}
+function overrideOne(material, override, clone) {
+    if (!(material instanceof THREE.MeshStandardMaterial))
+        return material;
+    const target = clone ? material.clone() : material;
+    if (override.color !== undefined)
+        target.color.set(override.color);
+    if (override.metalness !== undefined)
+        target.metalness = override.metalness;
+    if (override.roughness !== undefined)
+        target.roughness = override.roughness;
+    if (override.emissive !== undefined)
+        target.emissive.set(override.emissive);
+    if (override.emissiveIntensity !== undefined)
+        target.emissiveIntensity = override.emissiveIntensity;
+    return target;
+}

package/dist/multiplayer.d.ts

@@ -1,16 +1,23 @@
 import type { GameDefinition } from "@jgengine/core/game/defineGame";
-import { type WsBackend } from "@jgengine/ws/createWsBackend";
-export type ShellMultiplayer = {
-    gameId: string;
-    userId: string;
-    backend: WsBackend;
-    feedActions: string[];
-};
-export declare function resolveShellMultiplayer(args: {
+import type { MultiplayerSession } from "@jgengine/core/runtime/transport";
+export type ShellMultiplayer = MultiplayerSession;
+export declare const DEFAULT_FEED_ACTIONS: string[];
+export declare function randomPlayerId(): string;
+export type ResolveShellMultiplayerArgs = {
     game: GameDefinition;
     gameId: string;
     url?: string;
     userId?: string;
     force?: boolean;
     feedActions?: string[];
-}): ShellMultiplayer | null;
+};
+export declare function resolveShellMultiplayer(args: ResolveShellMultiplayerArgs): ShellMultiplayer | null;
+export declare function resolvePeerShellMultiplayer(args: {
+    gameId: string;
+    role: "host" | "join";
+    room?: string;
+    userId?: string;
+    feedActions?: string[];
+}): Promise<ShellMultiplayer & {
+    close: () => void;
+}>;

package/dist/multiplayer.js

@@ -1,21 +1,71 @@
+import { adapterOf } from "@jgengine/core/runtime/adapter";
 import { createWsBackend } from "@jgengine/ws/createWsBackend";
-function adapterKind(multiplayer) {
-    if (typeof multiplayer !== "object" || multiplayer === null)
-        return null;
-    const direct = multiplayer.kind;
-    if (typeof direct === "string")
-        return direct;
-    const nested = multiplayer.adapter?.kind;
-    return typeof nested === "string" ? nested : null;
+import { announcePeerHost, broadcastChannelSignaling, createPeerGuest, createPeerHost, joinPeerSession, } from "@jgengine/ws/peer";
+export const DEFAULT_FEED_ACTIONS = ["entity.died"];
+const DEFAULT_WS_URL = "ws://localhost:8080/ws";
+export function randomPlayerId() {
+    return `player-${Math.random().toString(36).slice(2, 10)}`;
+}
+function lanUrl(adapter) {
+    const hasWindow = typeof window !== "undefined";
+    const scheme = hasWindow && window.location.protocol === "https:" ? "wss" : "ws";
+    const hostname = hasWindow ? window.location.hostname : "localhost";
+    const port = adapter.port ?? 8080;
+    const path = adapter.path ?? "/ws";
+    return `${scheme}://${hostname}:${port}${path}`;
+}
+function buildWsMultiplayer(args) {
+    return {
+        gameId: args.gameId,
+        userId: args.userId,
+        backend: createWsBackend({ url: args.url, userId: args.userId }),
+        feedActions: args.feedActions,
+    };
 }
 export function resolveShellMultiplayer(args) {
-    if (args.force !== true && adapterKind(args.game.multiplayer) !== "ws")
+    const userId = args.userId ?? randomPlayerId();
+    const feedActions = args.feedActions ?? DEFAULT_FEED_ACTIONS;
+    const build = (url) => buildWsMultiplayer({ gameId: args.gameId, userId, feedActions, url });
+    if (args.force === true)
+        return build(args.url ?? DEFAULT_WS_URL);
+    const adapter = adapterOf(args.game.multiplayer);
+    if (adapter === null)
         return null;
-    const userId = args.userId ?? `player-${Math.random().toString(36).slice(2, 10)}`;
+    if (adapter.kind === "ws")
+        return build(args.url ?? adapter.url ?? DEFAULT_WS_URL);
+    if (adapter.kind === "lan")
+        return build(args.url ?? lanUrl(adapter));
+    return null;
+}
+export async function resolvePeerShellMultiplayer(args) {
+    const userId = args.userId ?? randomPlayerId();
+    const feedActions = args.feedActions ?? DEFAULT_FEED_ACTIONS;
+    const signaling = broadcastChannelSignaling(args.room ?? `jg-p2p-${args.gameId}`);
+    if (args.role === "host") {
+        const peerHost = createPeerHost({ userId });
+        const stopAnnouncing = announcePeerHost(peerHost, signaling);
+        return {
+            gameId: args.gameId,
+            userId,
+            backend: peerHost.backend,
+            feedActions,
+            close: () => {
+                stopAnnouncing();
+                signaling.close();
+                peerHost.close();
+            },
+        };
+    }
+    const guest = createPeerGuest({ userId });
+    const backend = await joinPeerSession(guest, signaling);
     return {
         gameId: args.gameId,
         userId,
-        backend: createWsBackend({ url: args.url ?? "ws://localhost:8080/ws", userId }),
-        feedActions: args.feedActions ?? ["entity.died"],
+        backend,
+        feedActions,
+        close: () => {
+            signaling.close();
+            guest.close();
+        },
     };
 }