@jgengine/core 0.4.0 → 0.6.0

package/dist/world/water.d.ts

@@ -0,0 +1,27 @@
+import type { OceanEnvironmentDescriptor } from "./features.js";
+export type WaterNormal = readonly [number, number, number];
+export interface GerstnerWave {
+    direction: readonly [number, number];
+    wavelength: number;
+    amplitude: number;
+    steepness: number;
+    speed: number;
+}
+export interface WaterSurfaceConfig {
+    level?: number;
+    waveHeight?: number;
+    waveScale?: number;
+    waveSpeed?: number;
+    waves?: number;
+    choppiness?: number;
+}
+export interface WaterSurface {
+    readonly level: number;
+    readonly waves: readonly GerstnerWave[];
+    height(x: number, z: number, time: number): number;
+    normal(x: number, z: number, time: number): WaterNormal;
+    displace(x: number, z: number, time: number): readonly [number, number, number];
+}
+export declare function synthesizeWaves(config?: WaterSurfaceConfig): GerstnerWave[];
+export declare function waterSurface(config?: WaterSurfaceConfig): WaterSurface;
+export declare function waterSurfaceFromDescriptor(descriptor: OceanEnvironmentDescriptor, waves?: number): WaterSurface;

package/dist/world/water.js

@@ -0,0 +1,125 @@
+const GRAVITY = 9.81;
+const TWO_PI = Math.PI * 2;
+const AMPLITUDE_FALLOFF = 0.65;
+const WAVELENGTH_FALLOFF = 0.65;
+const DIRECTION_SPREAD = 0.62;
+function resolveConfig(config) {
+    return {
+        level: config.level ?? 0,
+        waveHeight: config.waveHeight ?? 1.2,
+        waveScale: config.waveScale ?? 18,
+        waveSpeed: config.waveSpeed ?? 0.55,
+        waves: config.waves ?? 4,
+        choppiness: config.choppiness ?? 1,
+    };
+}
+export function synthesizeWaves(config = {}) {
+    const resolved = resolveConfig(config);
+    const count = Math.max(0, Math.floor(resolved.waves));
+    if (count === 0 || resolved.waveHeight <= 0) {
+        return [];
+    }
+    let amplitudeSum = 0;
+    for (let i = 0; i < count; i += 1) {
+        amplitudeSum += AMPLITUDE_FALLOFF ** i;
+    }
+    const amplitudeUnit = resolved.waveHeight / amplitudeSum;
+    const waves = [];
+    for (let i = 0; i < count; i += 1) {
+        const amplitude = amplitudeUnit * AMPLITUDE_FALLOFF ** i;
+        const wavelength = resolved.waveScale * WAVELENGTH_FALLOFF ** i;
+        const k = TWO_PI / wavelength;
+        const angle = DIRECTION_SPREAD * (i % 2 === 0 ? 1 : -1) * Math.ceil(i / 2);
+        const direction = [Math.cos(angle), Math.sin(angle)];
+        const omega = Math.sqrt(GRAVITY * k) * resolved.waveSpeed;
+        const speed = omega / k;
+        const steepnessLimit = 1 / (k * amplitude * count);
+        const steepness = Math.min(1, Math.max(0, 0.4 * steepnessLimit));
+        waves.push({ direction, wavelength, amplitude, steepness, speed });
+    }
+    return waves;
+}
+export function waterSurface(config = {}) {
+    const resolved = resolveConfig(config);
+    const level = resolved.level;
+    const choppiness = resolved.choppiness;
+    const waves = synthesizeWaves(config);
+    const height = (x, z, time) => {
+        let y = level;
+        for (const wave of waves) {
+            const k = TWO_PI / wave.wavelength;
+            const omega = wave.speed * k;
+            const phase = k * (wave.direction[0] * x + wave.direction[1] * z) - omega * time;
+            y += wave.amplitude * Math.sin(phase);
+        }
+        return y;
+    };
+    const displace = (x, z, time) => {
+        let dx = x;
+        let dz = z;
+        let dy = level;
+        for (const wave of waves) {
+            const k = TWO_PI / wave.wavelength;
+            const omega = wave.speed * k;
+            const phase = k * (wave.direction[0] * x + wave.direction[1] * z) - omega * time;
+            const cosPhase = Math.cos(phase);
+            const q = wave.steepness;
+            dx += q * wave.amplitude * choppiness * wave.direction[0] * cosPhase;
+            dz += q * wave.amplitude * choppiness * wave.direction[1] * cosPhase;
+            dy += wave.amplitude * Math.sin(phase);
+        }
+        return [dx, dy, dz];
+    };
+    const normal = (x, z, time) => {
+        let tx = 1;
+        let ty = 0;
+        let tz = 0;
+        let bx = 0;
+        let by = 0;
+        let bz = 1;
+        for (const wave of waves) {
+            const k = TWO_PI / wave.wavelength;
+            const omega = wave.speed * k;
+            const phase = k * (wave.direction[0] * x + wave.direction[1] * z) - omega * time;
+            const cosPhase = Math.cos(phase);
+            const sinPhase = Math.sin(phase);
+            const wa = k * wave.amplitude;
+            const q = wave.steepness;
+            const dxWave = wave.direction[0];
+            const dzWave = wave.direction[1];
+            tx += -q * dxWave * dxWave * wa * choppiness * sinPhase;
+            ty += dxWave * wa * cosPhase;
+            tz += -q * dxWave * dzWave * wa * choppiness * sinPhase;
+            bx += -q * dxWave * dzWave * wa * choppiness * sinPhase;
+            by += dzWave * wa * cosPhase;
+            bz += -q * dzWave * dzWave * wa * choppiness * sinPhase;
+        }
+        let nx = by * tz - bz * ty;
+        let ny = bz * tx - bx * tz;
+        let nz = bx * ty - by * tx;
+        const lengthSq = nx * nx + ny * ny + nz * nz;
+        if (lengthSq === 0) {
+            return [0, 1, 0];
+        }
+        const inv = 1 / Math.sqrt(lengthSq);
+        nx *= inv;
+        ny *= inv;
+        nz *= inv;
+        if (ny < 0) {
+            nx = -nx;
+            ny = -ny;
+            nz = -nz;
+        }
+        return [nx, ny, nz];
+    };
+    return { level, waves, height, normal, displace };
+}
+export function waterSurfaceFromDescriptor(descriptor, waves) {
+    return waterSurface({
+        level: descriptor.level,
+        waveHeight: descriptor.waveHeight,
+        waveScale: descriptor.waveScale,
+        waveSpeed: descriptor.waveSpeed,
+        ...(waves === undefined ? {} : { waves }),
+    });
+}

package/dist/world/wind.d.ts

@@ -0,0 +1,17 @@
+export type WindVector = readonly [number, number];
+export interface WindFieldConfig {
+    direction?: WindVector;
+    speed?: number;
+    gust?: number;
+    gustFrequency?: number;
+    turbulence?: number;
+    seed?: string | number;
+}
+export interface WindField {
+    readonly direction: WindVector;
+    readonly speed: number;
+    at(time: number): WindVector;
+    atPoint(x: number, z: number, time: number): WindVector;
+    strengthAt(x: number, z: number, time: number): number;
+}
+export declare function windField(config?: WindFieldConfig): WindField;

package/dist/world/wind.js

@@ -0,0 +1,40 @@
+import { fractalNoise, seedFrom, valueNoise } from "./terrain.js";
+const WIND_SEED_FALLBACK = 0x77696e64;
+function normalizeDirection(direction) {
+    const length = Math.hypot(direction[0], direction[1]);
+    if (length === 0)
+        return [1, 0];
+    return [direction[0] / length, direction[1] / length];
+}
+export function windField(config = {}) {
+    const direction = normalizeDirection(config.direction ?? [1, 0]);
+    const speed = config.speed ?? 1;
+    const gust = config.gust ?? 0;
+    const gustFrequency = config.gustFrequency ?? 0.15;
+    const turbulence = config.turbulence ?? 0;
+    const seed = seedFrom(config.seed, WIND_SEED_FALLBACK);
+    const at = (time) => {
+        const gustAmt = gust *
+            fractalNoise(time * gustFrequency, 0, {
+                seed,
+                frequency: 1,
+                octaves: 3,
+                lacunarity: 2,
+                persistence: 0.5,
+                ridged: false,
+            });
+        const magnitude = speed + gustAmt;
+        return [direction[0] * magnitude, direction[1] * magnitude];
+    };
+    const atPoint = (x, z, time) => {
+        const base = at(time);
+        const tx = valueNoise(x * 0.05 + time * 0.1, z * 0.05, seed);
+        const tz = valueNoise(z * 0.05, x * 0.05 - time * 0.1, seed + 101);
+        return [base[0] + turbulence * tx, base[1] + turbulence * tz];
+    };
+    const strengthAt = (x, z, time) => {
+        const [wx, wz] = atPoint(x, z, time);
+        return Math.hypot(wx, wz);
+    };
+    return { direction, speed, at, atPoint, strengthAt };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jgengine/core",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Genre-agnostic TypeScript game engine SDK: game runtime, state store, entity scene, combat, movement, inventory, economy, quests, multiplayer primitives.",
   "license": "AGPL-3.0-only",
   "type": "module",
@@ -10,7 +10,10 @@
     "url": "git+https://github.com/Noisemaker111/jgengine.git",
     "directory": "packages/core"
   },
-  "files": ["dist"],
+  "files": [
+    "dist",
+    "CHANGELOG.md"
+  ],
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",