@aethervtt/shard-input 0.0.1

package/dist/plugin.js

@@ -0,0 +1,270 @@
+import { defineResource, defineSystem, First, ShardError } from "@aethervtt/shard-core";
+import { definePlugin, Time } from "@aethervtt/shard-runtime";
+import {
+  GAMEPAD_AXES,
+  GAMEPAD_BUTTONS,
+  GamepadsState,
+  KeyboardState,
+  MouseState,
+  TouchesState
+} from "./devices.js";
+import * as pluginModule from "./plugin.js";
+const Keyboard = defineResource("input/Keyboard", {
+  description: "Keys by KeyboardEvent.code."
+});
+const Mouse = defineResource("input/Mouse", {
+  description: "Mouse buttons, position, delta, wheel."
+});
+const Gamepads = defineResource("input/Gamepads", {
+  description: "Connected gamepads (standard mapping)."
+});
+const Touches = defineResource("input/Touches", {
+  description: "Active touches."
+});
+const InputQueue = defineResource("input/Queue", {
+  description: "Raw input buffer: live source, injected events, recording, replay."
+});
+function devices(world) {
+  return {
+    keyboard: world.resource(Keyboard),
+    mouse: world.resource(Mouse),
+    gamepads: world.resource(Gamepads),
+    touches: world.resource(Touches)
+  };
+}
+function apply(world, d, e) {
+  switch (e.type) {
+    case "key":
+      d.keyboard.set(e.code, e.pressed);
+      break;
+    case "mouse-button":
+      d.mouse.set(e.button, e.pressed);
+      break;
+    case "mouse-move":
+      d.mouse.position[0] = e.x;
+      d.mouse.position[1] = e.y;
+      d.mouse.delta[0] += e.dx;
+      d.mouse.delta[1] += e.dy;
+      break;
+    case "wheel":
+      d.mouse.wheel[0] += e.dx;
+      d.mouse.wheel[1] += e.dy;
+      break;
+    case "touch": {
+      if (e.phase === "start") {
+        d.touches.active.set(e.id, { id: e.id, position: [e.x, e.y], start: [e.x, e.y] });
+        d.touches.started.push(e.id);
+      } else if (e.phase === "move") {
+        const t = d.touches.active.get(e.id);
+        if (t) {
+          t.position[0] = e.x;
+          t.position[1] = e.y;
+        }
+      } else {
+        d.touches.active.delete(e.id);
+        d.touches.captured.delete(e.id);
+        d.touches.ended.push(e.id);
+      }
+      break;
+    }
+    case "text":
+      d.keyboard.typed += e.text;
+      break;
+    case "gamepad": {
+      const pad = d.gamepads.slot(e.index);
+      pad.connected = e.connected;
+      for (let i = 0; i < GAMEPAD_BUTTONS.length; i++) {
+        const v = e.buttons[i] ?? 0;
+        pad.buttonValues[i] = v;
+        pad.set(GAMEPAD_BUTTONS[i], v > 0.5);
+      }
+      for (let i = 0; i < GAMEPAD_AXES.length; i++) {
+        const v = e.axes[i] ?? 0;
+        pad.axisValues[i] = i % 2 === 1 ? -v : v;
+      }
+      break;
+    }
+    case "focus":
+      if (!e.focused) {
+        d.keyboard.releaseAll();
+        d.mouse.releaseAll();
+        d.touches.active.clear();
+        d.touches.captured.clear();
+      }
+      break;
+    case "action": {
+      const dot = e.name.lastIndexOf(".");
+      const mapName = e.name.slice(0, dot);
+      const map = world.resource(InputQueue).maps.find((m) => m.name === mapName);
+      if (!map) {
+        throw new ShardError(
+          "input/unknown-action",
+          `No action map "${mapName}" for injected "${e.name}"`,
+          {
+            hint: 'Use "<map name>.<action>", e.g. "game/Controls.jump".'
+          }
+        );
+      }
+      map.inject(e.name.slice(dot + 1), e.pressed, e.value);
+      break;
+    }
+  }
+}
+const InputContext = defineResource("input/Context", {
+  description: "The active input context: action maps of other contexts report nothing. UI sets 'ui' while a node has focus, so gameplay actions don't fire while typing.",
+  init: () => ({ active: "game" })
+});
+const updateInput = defineSystem({
+  name: "input/update",
+  description: "Applies this frame's raw input to devices.",
+  run: (_, world) => {
+    const q = world.resource(InputQueue);
+    const d = devices(world);
+    d.keyboard.beginFrame();
+    d.mouse.beginFrame();
+    d.gamepads.beginFrame();
+    d.touches.beginFrame();
+    const events = q.scratch;
+    events.length = 0;
+    if (q.replay) {
+      for (const e of q.replay.frames.get(q.replay.frame) ?? []) events.push(e);
+      q.replay.frame++;
+      q.source?.drain([]);
+      if (q.replay.frame >= q.replay.length) q.replay = void 0;
+    } else {
+      q.source?.drain(events);
+    }
+    for (const e of q.pending) events.push(e);
+    q.pending.length = 0;
+    for (const e of events) apply(world, d, e);
+    if (q.recording) q.recording.push(events.map((e) => ({ ...e })));
+  }
+});
+const updateActions = defineSystem({
+  name: "input/actions",
+  description: "Updates action maps from device state, in the active input context.",
+  run: (_, world) => {
+    const q = world.resource(InputQueue);
+    const d = devices(world);
+    const context = world.resource(InputContext).active;
+    const now = world.resource(Time).elapsed * 1e3;
+    for (const map of q.maps) map.update(d, now, context);
+  }
+});
+function inputPlugin(options = {}) {
+  return definePlugin({
+    name: "input",
+    provides: [pluginModule],
+    dependencies: ["core/time"],
+    build(app) {
+      const queue = {
+        source: options.source,
+        pending: [],
+        scratch: [],
+        maps: [],
+        recording: void 0,
+        replay: void 0
+      };
+      app.insertResource(Keyboard, new KeyboardState()).insertResource(Mouse, new MouseState()).insertResource(Gamepads, new GamepadsState()).insertResource(Touches, new TouchesState()).insertResource(InputQueue, queue);
+      app.world.initResource(InputContext);
+      for (const map of options.actions ?? []) addActions(app.world, map);
+      app.addSystems(First, updateInput, updateActions.after(updateInput));
+    }
+  });
+}
+function addActions(world, map) {
+  const state = map.create();
+  world.insertResource(map.resource, state);
+  const maps = world.resource(InputQueue).maps;
+  const i = maps.findIndex((m) => m.name === map.name);
+  if (i === -1) maps.push(state);
+  else maps[i] = state;
+  return state;
+}
+function rebindAction(world, action, bindings) {
+  const dot = action.lastIndexOf(".");
+  const mapName = action.slice(0, dot);
+  const map = world.resource(InputQueue).maps.find((m) => m.name === mapName);
+  if (dot === -1 || !map) {
+    throw new ShardError("input/unknown-action", `No action map "${mapName}" for "${action}"`, {
+      hint: 'Use "<map name>.<action>", e.g. "game/Controls.jump".'
+    });
+  }
+  map.rebind(action.slice(dot + 1), bindings);
+}
+function injectInput(world, input) {
+  const q = world.resource(InputQueue);
+  if ("type" in input) q.pending.push(input);
+  else if ("key" in input) q.pending.push({ type: "key", code: input.key, pressed: input.pressed });
+  else if ("mouse" in input)
+    q.pending.push({ type: "mouse-button", button: input.mouse, pressed: input.pressed });
+  else
+    q.pending.push({
+      type: "action",
+      name: input.action,
+      pressed: input.pressed,
+      value: input.value
+    });
+}
+function startRecording(world) {
+  world.resource(InputQueue).recording = [];
+}
+function stopRecording(world) {
+  const q = world.resource(InputQueue);
+  const frames = q.recording ?? [];
+  q.recording = void 0;
+  const lines = [JSON.stringify({ frames: frames.length })];
+  frames.forEach((events, f) => {
+    if (events.length > 0) lines.push(JSON.stringify({ f, e: events }));
+  });
+  return lines.join("\n");
+}
+function startReplay(world, recording) {
+  const [header, ...lines] = recording.split("\n").filter(Boolean);
+  const length = JSON.parse(header ?? "{}").frames ?? 0;
+  const frames = /* @__PURE__ */ new Map();
+  for (const line of lines) {
+    const { f, e } = JSON.parse(line);
+    frames.set(f, e);
+  }
+  world.resource(InputQueue).replay = { frames, frame: 0, length };
+}
+function describeInput(world) {
+  const q = world.resource(InputQueue);
+  return {
+    source: q.source ? "live" : "none (headless)",
+    recording: q.recording !== void 0,
+    replaying: q.replay !== void 0,
+    keysHeld: world.resource(Keyboard).held(),
+    gamepads: world.resource(Gamepads).connected().length,
+    touches: world.resource(Touches).active.size,
+    context: world.resource(InputContext).active,
+    pointerCaptured: world.resource(Mouse).captured,
+    actionMaps: q.maps.map((m) => ({
+      name: m.name,
+      enabled: m.enabled,
+      context: m.context,
+      live: m.live,
+      values: m.snapshot(),
+      rebindings: m.rebindings()
+    }))
+  };
+}
+export {
+  Gamepads,
+  InputContext,
+  InputQueue,
+  Keyboard,
+  Mouse,
+  Touches,
+  addActions,
+  describeInput,
+  injectInput,
+  inputPlugin,
+  rebindAction,
+  startRecording,
+  startReplay,
+  stopRecording,
+  updateActions,
+  updateInput
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@aethervtt/shard-input",
+  "version": "0.0.1",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@aethervtt/shard-core": "0.0.1",
+    "@aethervtt/shard-platform": "0.0.1",
+    "@aethervtt/shard-runtime": "0.0.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aethervtt/shard.git",
+    "directory": "packages/input"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "shard": {
+    "buildSha": "d6c5c6aef4675575c878b02cf2c8f738b4190229"
+  }
+}