@aethervtt/shard-physics 0.0.1

package/dist/methods.js

@@ -0,0 +1,131 @@
+import { defineSchema, findComponent, t } from "@aethervtt/shard-core";
+import { CharacterState, PhysicsRange } from "./components.js";
+import { createRayHit, Physics } from "./world.js";
+function scenePath(world, entity) {
+  const member = findComponent("scene/SceneMember");
+  if (!member || entity < 0 || !world.isAlive(entity)) return null;
+  const v = world.tryGet(entity, member);
+  return v?.path || null;
+}
+function hitJson(world, hit) {
+  return {
+    entity: hit.entity,
+    path: scenePath(world, hit.entity),
+    body: hit.body >= 0 ? hit.body : null,
+    bodyPath: hit.body >= 0 ? scenePath(world, hit.body) : null,
+    distance: hit.distance,
+    point: Array.from(hit.point),
+    normal: Array.from(hit.normal)
+  };
+}
+function ready(world) {
+  return world.resource(Physics);
+}
+const filterFields = {
+  mask: t.u16({ default: 65535, description: "Only colliders in these layers (bitmask)." }),
+  exclude: t.entity({ description: "Skip this entity\u2019s colliders (and its body\u2019s)." }),
+  sensors: t.bool({ description: "Include sensors." })
+};
+function options(p, maxDistance) {
+  const exclude = p.exclude;
+  return {
+    maxDistance,
+    mask: p.mask,
+    exclude: exclude !== null && exclude !== void 0 && exclude >= 0 ? exclude : void 0,
+    sensors: p.sensors
+  };
+}
+const physicsMethods = [
+  {
+    name: "physics.raycast",
+    description: "Casts a ray against physics colliders: the nearest hit (or every hit with all) with collider entity and scene path, body, point, normal, and distance. Sees the state after the last physics step.",
+    params: defineSchema("physics/RaycastParams", {
+      origin: t.vec3({ required: true }),
+      direction: t.vec3({ required: true }),
+      maxDistance: t.f32({ min: 0, description: "Ignore hits past this (0: no limit)." }),
+      all: t.bool({ description: "Every collider along the ray, nearest first." }),
+      ...filterFields
+    }),
+    handler: ({ world }, p) => {
+      const physics = ready(world);
+      const o = options(p, p.maxDistance || void 0);
+      if (p.all) {
+        const hits = physics.raycastAll(p.origin, p.direction, o);
+        return { hits: hits.map((h) => hitJson(world, h)) };
+      }
+      const hit = createRayHit();
+      const found = physics.raycast(p.origin, p.direction, o, hit);
+      return { hits: found ? [hitJson(world, hit)] : [] };
+    }
+  },
+  {
+    name: "physics.overlap",
+    description: "Colliders overlapping a point, or a ball, cuboid, or capsule placed at a position: their entities and scene paths.",
+    params: defineSchema("physics/OverlapParams", {
+      position: t.vec3({ required: true }),
+      shape: t.enum(["point", "ball", "cuboid", "capsule"]),
+      radius: t.f32({ default: 0.5, min: 0 }),
+      halfExtents: t.vec3({ default: [0.5, 0.5, 0.5], min: 0 }),
+      halfHeight: t.f32({ default: 0.5, min: 0 }),
+      rotation: t.quat(),
+      ...filterFields
+    }),
+    handler: ({ world }, p) => {
+      const physics = ready(world);
+      const found = [];
+      const visit = (entity) => {
+        found.push({ entity, path: scenePath(world, entity) });
+        return true;
+      };
+      const o = options(p);
+      if (p.shape === "point") physics.overlapPoint(p.position, o, visit);
+      else {
+        physics.overlapShape(
+          {
+            shape: p.shape,
+            radius: p.radius,
+            halfExtents: p.halfExtents,
+            halfHeight: p.halfHeight
+          },
+          p.position,
+          p.rotation,
+          o,
+          visit
+        );
+      }
+      return { colliders: found };
+    }
+  },
+  {
+    name: "physics.describe",
+    description: "Physics state: dimension, gravity, bodies by kind and how many sleep, colliders by shape, joints, contact pairs, colliders waiting for a mesh, bodies parked out of range (large worlds) and the range, the last step time, and every character controller with its state (grounded, ground, velocity, up).",
+    params: defineSchema("physics/DescribeParams", {}),
+    handler: ({ world }) => {
+      const physics = ready(world);
+      return {
+        dimension: physics.dim,
+        gravity: physics.config.gravity,
+        interpolate: physics.config.interpolate,
+        paused: physics.config.paused,
+        range: world.tryResource(PhysicsRange)?.radius ?? null,
+        ...physics.describe(),
+        characters: [...physics.characters.keys()].map((entity) => {
+          const s = world.get(entity, CharacterState);
+          return {
+            entity,
+            path: scenePath(world, entity),
+            grounded: s.grounded,
+            groundEntity: s.groundEntity,
+            groundPath: s.groundEntity === null ? null : scenePath(world, s.groundEntity),
+            velocity: s.velocity,
+            up: s.up,
+            airTime: s.airTime
+          };
+        })
+      };
+    }
+  }
+];
+export {
+  physicsMethods
+};

package/dist/plugin.d.ts

@@ -0,0 +1,13 @@
+import { type World } from '@aethervtt/shard-core';
+import { type Plugin } from '@aethervtt/shard-runtime';
+import { Physics, PhysicsWorld } from './world.js';
+export { Physics };
+/** Physics sync and step run in this set, in FixedUpdate. Move bodies before it. */
+export declare const PhysicsSystems: import("@aethervtt/shard-core").SystemSetDef;
+/** The physics world, or `physics/not-ready` before the plugin's `ready` step. */
+export declare function physics(world: World): PhysicsWorld;
+/** 3D rigid bodies, colliders, joints, and scene queries (Rapier). */
+export declare const physics3dPlugin: Plugin;
+/** 2D rigid bodies, colliders, joints, and scene queries in the XY plane (Rapier 2D). */
+export declare const physics2dPlugin: Plugin;
+export declare const collidersOverlay: import("@aethervtt/shard-render").OverlayDef;