@aethervtt/shard-physics 0.0.1

package/dist/components.d.ts

@@ -0,0 +1,155 @@
+import { type Entity } from '@aethervtt/shard-core';
+export declare const BODY_KINDS: readonly ['dynamic', 'fixed', 'kinematic-position', 'kinematic-velocity'];
+export type BodyKind = (typeof BODY_KINDS)[number];
+export declare const RigidBody: import("@aethervtt/shard-core").ComponentDef<{
+    readonly kind: import("@aethervtt/shard-core").FieldType<"dynamic" | "fixed" | "kinematic-position" | "kinematic-velocity", "u8">;
+    readonly gravityScale: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly linearDamping: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly angularDamping: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly ccd: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly canSleep: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly dominance: import("@aethervtt/shard-core").FieldType<number, "i8">;
+    readonly lockTranslation: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly lockRotation: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+}>;
+export declare const Velocity: import("@aethervtt/shard-core").ComponentDef<{
+    readonly linear: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly angular: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+}>;
+/**
+ * A body the physics world set aside because it is farther than `PhysicsRange.radius` from the
+ * floating origin (spec 0040). It isn't in Rapier: it doesn't move, collide, or show up in queries.
+ * It keeps its Transform and comes back, with this velocity, when the origin gets close again.
+ *
+ * Saved with the scene (the default): for a body without a Velocity component, this is the only
+ * record of how it was moving, so a ship parked mid-flight keeps flying after a load.
+ */
+export declare const PhysicsParked: import("@aethervtt/shard-core").ComponentDef<{
+    readonly linear: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly angular: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+}>;
+export declare const SHAPES: readonly ['ball', 'cuboid', 'capsule', 'cylinder', 'cone', 'convex', 'trimesh', 'heightfield', 'segment', 'polyline'];
+export type Shape = (typeof SHAPES)[number];
+export declare const Collider: import("@aethervtt/shard-core").ComponentDef<{
+    readonly shape: import("@aethervtt/shard-core").FieldType<"ball" | "capsule" | "cone" | "convex" | "cuboid" | "cylinder" | "heightfield" | "polyline" | "segment" | "trimesh", "u8">;
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly halfExtents: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly halfHeight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly mesh: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").AssetRef<"Mesh"> | null, "object">;
+    readonly points: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3[], "object">;
+    readonly heightfield: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").InferFields<{
+        rows: import("@aethervtt/shard-core").FieldType<number, "u16">;
+        cols: import("@aethervtt/shard-core").FieldType<number, "u16">;
+        heights: import("@aethervtt/shard-core").FieldType<number[], "object">;
+    }>, "object">;
+    readonly friction: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly restitution: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly density: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly sensor: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly layers: import("@aethervtt/shard-core").FieldType<number, "u16">;
+    readonly mask: import("@aethervtt/shard-core").FieldType<number, "u16">;
+    readonly events: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly forceThreshold: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export declare const ExternalForce: import("@aethervtt/shard-core").ComponentDef<{
+    readonly force: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly torque: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+}>;
+export declare const ExternalImpulse: import("@aethervtt/shard-core").ComponentDef<{
+    readonly impulse: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly torque: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+}>;
+export declare const Mass: import("@aethervtt/shard-core").ComponentDef<{
+    readonly mass: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export declare const GravitySource: import("@aethervtt/shard-core").ComponentDef<{
+    readonly strength: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly range: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly falloff: import("@aethervtt/shard-core").FieldType<"constant" | "inverse-square", "u8">;
+}>;
+export declare const JOINT_KINDS: readonly ['fixed', 'revolute', 'prismatic', 'spherical', 'rope'];
+export declare const Joint: import("@aethervtt/shard-core").ComponentDef<{
+    readonly kind: import("@aethervtt/shard-core").FieldType<"fixed" | "prismatic" | "revolute" | "rope" | "spherical", "u8">;
+    readonly other: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly anchor: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly otherAnchor: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly axis: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly limits: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec2, "f32">;
+    readonly motorVelocity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly motorFactor: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export declare const CharacterIntent: import("@aethervtt/shard-core").ComponentDef<{
+    readonly move: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly jump: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}>;
+export declare const CharacterState: import("@aethervtt/shard-core").ComponentDef<{
+    readonly grounded: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+    readonly groundNormal: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly groundEntity: import("@aethervtt/shard-core").FieldType<number | null, "f64">;
+    readonly velocity: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly up: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly airTime: import("@aethervtt/shard-core").FieldType<number, "f32">;
+}>;
+export declare const CharacterController: import("@aethervtt/shard-core").ComponentDef<{
+    readonly radius: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly height: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly stepHeight: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly maxSlope: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly snapDistance: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly up: import("@aethervtt/shard-core").FieldType<"fixed" | "gravity", "u8">;
+    readonly fixedUp: import("@aethervtt/shard-core").FieldType<import("@aethervtt/shard-core").Vec3, "f32">;
+    readonly gravity: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly jumpSpeed: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly airControl: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly pushForce: import("@aethervtt/shard-core").FieldType<number, "f32">;
+    readonly layers: import("@aethervtt/shard-core").FieldType<number, "u16">;
+    readonly mask: import("@aethervtt/shard-core").FieldType<number, "u16">;
+    readonly alignRotation: import("@aethervtt/shard-core").FieldType<boolean, "u8">;
+}>;
+export interface CharacterGroundEventData {
+    entity: Entity;
+    /** true: landed. false: left the ground (jumped or walked off). */
+    grounded: boolean;
+}
+export declare const CharacterGroundEvent: import("@aethervtt/shard-core").EventDef<CharacterGroundEventData>;
+/** App-wide physics settings. */
+export declare const PhysicsConfig: import("@aethervtt/shard-core").ResourceDef<PhysicsConfigValue>;
+/**
+ * With grids (spec 0040), bodies farther than `radius` from the floating origin are parked
+ * (PhysicsParked): out of Rapier, so f32 precision loss far away can't make them jitter or fall
+ * through the ground. They resume within 0.95 × radius, so an origin at the edge doesn't flip them.
+ */
+export declare const PhysicsRange: import("@aethervtt/shard-core").ResourceDef<PhysicsRangeValue>;
+export interface PhysicsRangeValue {
+    /** Bodies farther than this from the origin (m) are parked. */
+    radius: number;
+}
+export interface PhysicsConfigValue {
+    /** m/s². In 2D, x and y are used. */
+    gravity: [number, number, number];
+    /** Solver iterations per step (Rapier's default is 4). */
+    iterations: number;
+    /** Blend Transforms between steps by FixedTime.alpha, for smooth motion on fast displays. */
+    interpolate: boolean;
+    /** Skip stepping (bodies keep their state). */
+    paused: boolean;
+}
+export interface CollisionEventData {
+    kind: 'started' | 'stopped';
+    /** The collider entities. */
+    a: Entity;
+    b: Entity;
+    /** Their bodies (the collider's entity or ancestor with RigidBody; -1 for fixed colliders). */
+    bodyA: Entity;
+    bodyB: Entity;
+    sensor: boolean;
+}
+export declare const CollisionEvent: import("@aethervtt/shard-core").EventDef<CollisionEventData>;
+export interface ContactForceEventData {
+    a: Entity;
+    b: Entity;
+    /** Total contact force magnitude, N. */
+    force: number;
+}
+export declare const ContactForceEvent: import("@aethervtt/shard-core").EventDef<ContactForceEventData>;

package/dist/components.js

@@ -0,0 +1,340 @@
+import { defineComponent, defineEvent, defineResource, t } from "@aethervtt/shard-core";
+import { Transform } from "@aethervtt/shard-transform";
+const BODY_KINDS = ["dynamic", "fixed", "kinematic-position", "kinematic-velocity"];
+const RigidBody = defineComponent(
+  "physics/RigidBody",
+  {
+    kind: t.enum(BODY_KINDS, {
+      description: "dynamic: moved by forces and contacts. fixed: never moves. kinematic-position: follows its Transform. kinematic-velocity: moves by its Velocity."
+    }),
+    gravityScale: t.f32({ default: 1, description: "Multiplies gravity for this body." }),
+    linearDamping: t.f32({ min: 0, description: "Slows linear motion over time (1/s)." }),
+    angularDamping: t.f32({ min: 0, description: "Slows rotation over time (1/s)." }),
+    ccd: t.bool({
+      description: "Continuous collision detection: fast bodies (bullets) do not tunnel."
+    }),
+    canSleep: t.bool({
+      default: true,
+      description: "Stops simulating the body while it rests."
+    }),
+    dominance: t.i8({
+      min: -127,
+      max: 127,
+      description: "Higher dominance pushes lower without being pushed back."
+    }),
+    lockTranslation: t.vec3({
+      min: 0,
+      max: 1,
+      description: "Per axis: 1 locks movement along that world axis."
+    }),
+    lockRotation: t.vec3({
+      min: 0,
+      max: 1,
+      description: "Per axis: 1 locks rotation around that axis. In 2D, z locks rotation."
+    })
+  },
+  {
+    description: "A physics body. Colliders on this entity and on descendants without their own body make its shape. Moves the entity\u2019s Transform.",
+    requires: [Transform]
+  }
+);
+const Velocity = defineComponent(
+  "physics/Velocity",
+  {
+    linear: t.vec3({ unit: "m/s", description: "World-space linear velocity." }),
+    angular: t.vec3({ unit: "rad/s", description: "World-space angular velocity (2D: z)." })
+  },
+  {
+    description: "A body\u2019s velocity. Written by physics each step; writing it sets the body\u2019s velocity."
+  }
+);
+const PhysicsParked = defineComponent(
+  "physics/PhysicsParked",
+  {
+    linear: t.vec3({ unit: "m/s", description: "Linear velocity when it was parked." }),
+    angular: t.vec3({ unit: "rad/s", description: "Angular velocity when it was parked (2D: z)." })
+  },
+  {
+    description: "Out of physics range: removed from the simulation until the origin comes back within PhysicsRange.radius. Added and removed by physics."
+  }
+);
+const SHAPES = [
+  "ball",
+  "cuboid",
+  "capsule",
+  "cylinder",
+  "cone",
+  "convex",
+  "trimesh",
+  "heightfield",
+  "segment",
+  "polyline"
+];
+const Collider = defineComponent(
+  "physics/Collider",
+  {
+    shape: t.enum(SHAPES, {
+      description: "ball: radius. cuboid: halfExtents. capsule, cylinder, cone: radius and halfHeight (along Y). convex and trimesh: mesh or points. heightfield: heightfield and halfExtents. segment and polyline (2D): points or mesh."
+    }),
+    radius: t.f32({ default: 0.5, min: 0, unit: "m" }),
+    halfExtents: t.vec3({
+      default: [0.5, 0.5, 0.5],
+      min: 0,
+      unit: "m",
+      description: "cuboid: half size per axis. heightfield: half width (x), height scale (y), half depth (z)."
+    }),
+    halfHeight: t.f32({
+      default: 0.5,
+      min: 0,
+      unit: "m",
+      description: "Half the length of a capsule\u2019s middle, or half a cylinder\u2019s or cone\u2019s height."
+    }),
+    mesh: t.handle("Mesh", {
+      description: "convex, trimesh, and polyline: the mesh whose vertices make the shape."
+    }),
+    points: t.list(t.vec3, {
+      description: "convex, polyline, and segment without a mesh: points in local space (2D reads x and y)."
+    }),
+    heightfield: t.struct(
+      {
+        rows: t.u16({ description: "Samples along Z." }),
+        cols: t.u16({ description: "Samples along X." }),
+        heights: t.list(t.f32, {
+          description: "rows \xD7 cols heights, row by row, scaled by halfExtents.y."
+        })
+      },
+      { description: "heightfield: the height samples." }
+    ),
+    friction: t.f32({ default: 0.5, min: 0 }),
+    restitution: t.f32({ min: 0, description: "Bounciness: 0 stops, 1 bounces back fully." }),
+    density: t.f32({
+      default: 1,
+      min: 0,
+      unit: "kg/m\xB3",
+      description: "Mass from volume. Ignored when the body has Mass."
+    }),
+    sensor: t.bool({ description: "Detects overlaps without colliding." }),
+    layers: t.u16({
+      default: 1,
+      description: "Bitmask: the collision layers this collider is in."
+    }),
+    mask: t.u16({
+      default: 65535,
+      description: "Bitmask: the layers it collides with. Both sides must accept each other."
+    }),
+    events: t.bool({ description: "Send CollisionEvent when contacts start and stop." }),
+    forceThreshold: t.f32({
+      min: 0,
+      unit: "N",
+      description: "Send ContactForceEvent when the contact force exceeds this (0: never)."
+    })
+  },
+  {
+    description: "A collision shape. Uses the entity\u2019s world transform (scale included). Without a RigidBody on it or an ancestor, it is fixed.",
+    requires: [Transform]
+  }
+);
+const ExternalForce = defineComponent(
+  "physics/ExternalForce",
+  {
+    force: t.vec3({ unit: "N", description: "World-space force applied every step." }),
+    torque: t.vec3({ unit: "N\xB7m" })
+  },
+  { description: "A continuous force on the body, e.g. thrust. Set to zero to stop." }
+);
+const ExternalImpulse = defineComponent(
+  "physics/ExternalImpulse",
+  {
+    impulse: t.vec3({ unit: "N\xB7s", description: "Applied once at the next step, then zeroed." }),
+    torque: t.vec3({ unit: "N\xB7m\xB7s" })
+  },
+  { description: "A one-off push: a jump, an explosion, a hit." }
+);
+const Mass = defineComponent(
+  "physics/Mass",
+  { mass: t.f32({ default: 1, min: 0, unit: "kg", description: "The body\u2019s total mass." }) },
+  { description: "Sets a body\u2019s mass directly instead of from collider density." }
+);
+const GravitySource = defineComponent(
+  "physics/GravitySource",
+  {
+    strength: t.f32({
+      default: 9.81,
+      unit: "m/s\xB2",
+      description: "Acceleration toward this entity at `radius` (at any distance if constant)."
+    }),
+    radius: t.f32({
+      default: 1,
+      min: 0,
+      unit: "m",
+      description: "Surface radius; inverse-square falloff is 1 here."
+    }),
+    range: t.f32({ min: 0, unit: "m", description: "No pull beyond this distance (0: no limit)." }),
+    falloff: t.enum(["inverse-square", "constant"])
+  },
+  {
+    description: "Point gravity toward the entity (a planet). Pulls dynamic bodies and sets character up (CharacterController up: gravity).",
+    requires: [Transform]
+  }
+);
+const JOINT_KINDS = ["fixed", "revolute", "prismatic", "spherical", "rope"];
+const Joint = defineComponent(
+  "physics/Joint",
+  {
+    kind: t.enum(JOINT_KINDS),
+    other: t.entity({ description: "The body this one is jointed to." }),
+    anchor: t.vec3({ unit: "m", description: "Joint point in this body\u2019s local space." }),
+    otherAnchor: t.vec3({ unit: "m", description: "Joint point in the other body\u2019s local space." }),
+    axis: t.vec3({
+      default: [0, 1, 0],
+      description: "revolute: hinge axis. prismatic: slide axis (local to this body)."
+    }),
+    limits: t.vec2({
+      description: "revolute (rad), prismatic (m): [min, max], off when equal. rope: [_, max length]."
+    }),
+    motorVelocity: t.f32({ description: "revolute, prismatic: drive at this speed (0: off)." }),
+    motorFactor: t.f32({ default: 1, min: 0, description: "How hard the motor drives." })
+  },
+  { description: "Connects this entity\u2019s body to another body." }
+);
+const CharacterIntent = defineComponent(
+  "physics/CharacterIntent",
+  {
+    move: t.vec3({
+      unit: "m/s",
+      description: "Desired walking velocity in the character\u2019s frame: x right, -z forward (y is ignored; jump instead)."
+    }),
+    jump: t.bool({
+      description: "Jump at the next step on the ground. The controller clears it when the jump happens."
+    })
+  },
+  { description: "What a character wants to do, written by games, input, or AI each frame." }
+);
+const CharacterState = defineComponent(
+  "physics/CharacterState",
+  {
+    grounded: t.bool({ readonly: true, description: "Standing on walkable ground." }),
+    groundNormal: t.vec3({
+      default: [0, 1, 0],
+      readonly: true,
+      description: "Normal of the ground under the character (up while airborne)."
+    }),
+    groundEntity: t.entity({
+      readonly: true,
+      description: "The body (or fixed collider) the character stands on."
+    }),
+    velocity: t.vec3({ unit: "m/s", readonly: true, description: "World-space velocity." }),
+    up: t.vec3({ default: [0, 1, 0], readonly: true, description: "The character\u2019s up." }),
+    airTime: t.f32({ unit: "s", readonly: true, description: "Seconds since last grounded." })
+  },
+  { description: "What the character controller did at the last step. Read-only." }
+);
+const CharacterController = defineComponent(
+  "physics/CharacterController",
+  {
+    radius: t.f32({ default: 0.35, min: 0, unit: "m", description: "Capsule radius." }),
+    height: t.f32({
+      default: 1.8,
+      min: 0,
+      unit: "m",
+      description: "Total capsule height, centered on the entity."
+    }),
+    stepHeight: t.f32({
+      default: 0.3,
+      min: 0,
+      unit: "m",
+      description: "Tallest step it walks up (0: none)."
+    }),
+    maxSlope: t.f32({
+      default: 45,
+      min: 0,
+      max: 90,
+      unit: "deg",
+      description: "Steepest slope it walks up and stands on; steeper ones it slides down."
+    }),
+    snapDistance: t.f32({
+      default: 0.2,
+      min: 0,
+      unit: "m",
+      description: "Stays on the ground over drops this small, e.g. walking down steps (0: off)."
+    }),
+    up: t.enum(["fixed", "gravity"], {
+      description: "fixed: up is fixedUp and gravity pulls along -fixedUp. gravity: up points away from the strongest GravitySource (or against physics/Config gravity when none reaches)."
+    }),
+    fixedUp: t.vec3({ default: [0, 1, 0], description: "Up when up is fixed." }),
+    gravity: t.f32({
+      default: 9.81,
+      min: 0,
+      unit: "m/s\xB2",
+      description: "Fall acceleration when up is fixed."
+    }),
+    jumpSpeed: t.f32({ default: 5, min: 0, unit: "m/s", description: "Upward speed of a jump." }),
+    airControl: t.f32({
+      default: 0.3,
+      min: 0,
+      max: 1,
+      description: "Steering in the air: the share of the way to the intended velocity per 1/60 s (0: none, 1: as on ground)."
+    }),
+    pushForce: t.f32({
+      default: 200,
+      min: 0,
+      unit: "N",
+      description: "Push on dynamic bodies it walks into, never faster than it walks."
+    }),
+    layers: t.u16({ default: 1, description: "Bitmask: the collision layers the capsule is in." }),
+    mask: t.u16({ default: 65535, description: "Bitmask: the layers it collides with." }),
+    alignRotation: t.bool({
+      default: true,
+      description: "Turn the entity so its +Y matches up, keeping its heading."
+    })
+  },
+  {
+    description: "A kinematic capsule that walks by CharacterIntent: slides along walls, climbs steps and slopes, snaps to the ground, jumps, pushes bodies, rides platforms. No RigidBody or Collider on the same entity.",
+    requires: [Transform, CharacterIntent, CharacterState]
+  }
+);
+const CharacterGroundEvent = defineEvent(
+  "physics/CharacterGroundEvent",
+  { description: "A character landed or left the ground." }
+);
+const PhysicsConfig = defineResource("physics/Config", {
+  description: "Gravity, solver iterations, and render interpolation. Set before the first step or at any time.",
+  init: () => ({
+    gravity: [0, -9.81, 0],
+    iterations: 4,
+    interpolate: false,
+    paused: false
+  })
+});
+const PhysicsRange = defineResource("physics/Range", {
+  description: "How far from the floating origin bodies simulate (m). Farther ones are parked until the origin comes near. Only used when the world has a Grid.",
+  init: () => ({ radius: 2e4 })
+});
+const CollisionEvent = defineEvent("physics/CollisionEvent", {
+  description: "Contacts starting and stopping between colliders with events: true (either side). Sensors report overlaps."
+});
+const ContactForceEvent = defineEvent("physics/ContactForceEvent", {
+  description: "Contact force above a collider\u2019s forceThreshold (hits, crashes)."
+});
+export {
+  BODY_KINDS,
+  CharacterController,
+  CharacterGroundEvent,
+  CharacterIntent,
+  CharacterState,
+  Collider,
+  CollisionEvent,
+  ContactForceEvent,
+  ExternalForce,
+  ExternalImpulse,
+  GravitySource,
+  JOINT_KINDS,
+  Joint,
+  Mass,
+  PhysicsConfig,
+  PhysicsParked,
+  PhysicsRange,
+  RigidBody,
+  SHAPES,
+  Velocity
+};

package/dist/gravity.d.ts

@@ -0,0 +1,17 @@
+import type { Query } from '@aethervtt/shard-core';
+/**
+ * Gravity sources packed for per-body sampling: 6 floats each (position, strength, radius, and
+ * range, stored as -range - 1 for constant falloff). Filled once per step.
+ */
+export interface GravitySources {
+    data: Float64Array;
+    count: number;
+}
+export declare const createGravitySources: () => GravitySources;
+/** Packs every source in the query (entities with GravitySource and GlobalTransform). */
+export declare function gatherGravitySources(query: Query, out: GravitySources): void;
+/**
+ * Gravity at a point into out[0..2]: the sum of every source's pull, or with `strongest` only the
+ * strongest one's (a character's down). out[3] is the returned vector's length.
+ */
+export declare function sampleGravity(sources: GravitySources, dim: 2 | 3, px: number, py: number, pz: number, strongest: boolean, out: Float64Array): void;

package/dist/gravity.js

@@ -0,0 +1,73 @@
+import { GlobalTransform } from "@aethervtt/shard-transform";
+import { GravitySource } from "./components.js";
+const createGravitySources = () => ({
+  data: new Float64Array(6 * 8),
+  count: 0
+});
+function gatherGravitySources(query, out) {
+  let n = 0;
+  for (let t = 0; t < query.tables.length; t++) {
+    const table = query.tables[t];
+    const m = table.column(GlobalTransform, "matrix");
+    const strength = table.column(GravitySource, "strength");
+    const radius = table.column(GravitySource, "radius");
+    const range = table.column(GravitySource, "range");
+    const falloff = table.column(GravitySource, "falloff");
+    for (let row = 0; row < table.count; row++) {
+      if ((n + 1) * 6 > out.data.length) {
+        const grown = new Float64Array(out.data.length * 2);
+        grown.set(out.data);
+        out.data = grown;
+      }
+      const d = out.data;
+      d[n * 6] = m[row * 12 + 3];
+      d[n * 6 + 1] = m[row * 12 + 7];
+      d[n * 6 + 2] = m[row * 12 + 11];
+      d[n * 6 + 3] = strength[row];
+      d[n * 6 + 4] = radius[row];
+      d[n * 6 + 5] = falloff[row] === 1 ? -range[row] - 1 : range[row];
+      n++;
+    }
+  }
+  out.count = n;
+}
+function sampleGravity(sources, dim, px, py, pz, strongest, out) {
+  let fx = 0;
+  let fy = 0;
+  let fz = 0;
+  let best = 0;
+  const d = sources.data;
+  for (let i = 0; i < sources.count; i++) {
+    const dx = d[i * 6] - px;
+    const dy = d[i * 6 + 1] - py;
+    const dz = dim === 3 ? d[i * 6 + 2] - pz : 0;
+    const dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (dist < 1e-6) continue;
+    const packed = d[i * 6 + 5];
+    const constant = packed < 0;
+    const range = constant ? -packed - 1 : packed;
+    if (range > 0 && dist > range) continue;
+    const r = d[i * 6 + 4];
+    const accel = constant ? d[i * 6 + 3] : d[i * 6 + 3] * (r * r / (dist * dist));
+    if (strongest) {
+      if (accel <= best) continue;
+      best = accel;
+      fx = dx / dist * accel;
+      fy = dy / dist * accel;
+      fz = dz / dist * accel;
+    } else {
+      fx += dx / dist * accel;
+      fy += dy / dist * accel;
+      fz += dz / dist * accel;
+    }
+  }
+  out[0] = fx;
+  out[1] = fy;
+  out[2] = fz;
+  out[3] = Math.sqrt(fx * fx + fy * fy + fz * fz);
+}
+export {
+  createGravitySources,
+  gatherGravitySources,
+  sampleGravity
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { characterSystem } from './character.js';
+export { BODY_KINDS, type BodyKind, CharacterController, CharacterGroundEvent, type CharacterGroundEventData, CharacterIntent, CharacterState, Collider, CollisionEvent, type CollisionEventData, ContactForceEvent, type ContactForceEventData, ExternalForce, ExternalImpulse, GravitySource, JOINT_KINDS, Joint, Mass, PhysicsConfig, type PhysicsConfigValue, PhysicsParked, PhysicsRange, type PhysicsRangeValue, RigidBody, SHAPES, type Shape, Velocity, } from './components.js';
+export { physicsMethods } from './methods.js';
+export { Physics, PhysicsSystems, physics, physics2dPlugin, physics3dPlugin } from './plugin.js';
+export { type BodyRecord, CHARACTER_OFFSET, type CharacterRecord, createRayHit, loadRapier, type PhysicsStats, PhysicsWorld, type QueryOptions, type QueryShape, type RayHit, } from './world.js';

package/dist/index.js

@@ -0,0 +1,64 @@
+import { characterSystem } from "./character.js";
+import {
+  BODY_KINDS,
+  CharacterController,
+  CharacterGroundEvent,
+  CharacterIntent,
+  CharacterState,
+  Collider,
+  CollisionEvent,
+  ContactForceEvent,
+  ExternalForce,
+  ExternalImpulse,
+  GravitySource,
+  JOINT_KINDS,
+  Joint,
+  Mass,
+  PhysicsConfig,
+  PhysicsParked,
+  PhysicsRange,
+  RigidBody,
+  SHAPES,
+  Velocity
+} from "./components.js";
+import { physicsMethods } from "./methods.js";
+import { Physics, PhysicsSystems, physics, physics2dPlugin, physics3dPlugin } from "./plugin.js";
+import {
+  CHARACTER_OFFSET,
+  createRayHit,
+  loadRapier,
+  PhysicsWorld
+} from "./world.js";
+export {
+  BODY_KINDS,
+  CHARACTER_OFFSET,
+  CharacterController,
+  CharacterGroundEvent,
+  CharacterIntent,
+  CharacterState,
+  Collider,
+  CollisionEvent,
+  ContactForceEvent,
+  ExternalForce,
+  ExternalImpulse,
+  GravitySource,
+  JOINT_KINDS,
+  Joint,
+  Mass,
+  Physics,
+  PhysicsConfig,
+  PhysicsParked,
+  PhysicsRange,
+  PhysicsSystems,
+  PhysicsWorld,
+  RigidBody,
+  SHAPES,
+  Velocity,
+  characterSystem,
+  createRayHit,
+  loadRapier,
+  physics,
+  physics2dPlugin,
+  physics3dPlugin,
+  physicsMethods
+};

package/dist/methods.d.ts

@@ -0,0 +1,2 @@
+import type { AppMethod } from '@aethervtt/shard-runtime';
+export declare const physicsMethods: AppMethod[];