@dreamboard-games/sdk 0.5.0-alpha.5 → 0.5.0-alpha.7

package/dist/index.js

@@ -1,8 +1,11 @@
 import {
   AmbiguousTargetError,
+  GESTURE_THRESHOLDS,
   createGameInstance,
+  createGestureRecognizer,
+  isSameDropTarget,
   runtimeFeatures
-} from "./chunk-7RGMPJQG.js";
+} from "./chunk-HZPKKBEG.js";
 import {
   BoardStaticProjectionSchema,
   CancelInteractionCommandSchema,
@@ -52,12 +55,11 @@ import {
   encodeCanonicalPluginRuntimeJson
 } from "./chunk-K75F5UIJ.js";
 import {
-  inputValueKey,
   requireLookup
 } from "./chunk-3JXUL4VN.js";
 
 // src/package-set.ts
-var DREAMBOARD_SDK_VERSION = true ? "0.5.0-alpha.5" : "0.0.0-development";
+var DREAMBOARD_SDK_VERSION = true ? "0.5.0-alpha.7" : "0.0.0-development";
 var DREAMBOARD_SDK_PACKAGES = {
   "@dreamboard-games/sdk": DREAMBOARD_SDK_VERSION
 };
@@ -751,6 +753,14 @@ function createRuntimeDragFeature(context) {
         const cardInputs = inputs.filter(
           (input) => input.getDomain().type === "cardTarget" && (!options?.input || input.key === options.input) && input.getIsEligible(cardId)
         );
+        if (!inputs.some((input) => input.getDomain().type === "boardTarget"))
+          return cardInputs.map(
+            (cardInput) => Object.freeze({
+              kind: "interaction",
+              interactionKey: candidate.key,
+              cardInputKey: cardInput.key
+            })
+          );
         return cardInputs.flatMap(
           (cardInput) => inputs.flatMap((input) => {
             const domain = input.getDomain();
@@ -784,9 +794,6 @@ function createRuntimeDragFeature(context) {
     );
     return resolved;
   }
-  function sameTarget(left, right) {
-    return left.kind === right.kind && left.valueKind === right.valueKind && inputValueKey(left.value) === inputValueKey(right.value) && (left.valueKind !== "board-id" || right.valueKind === "board-id" && left.boardId === right.boardId) && left.interactionKey === right.interactionKey && left.cardInputKey === right.cardInputKey && left.inputKey === right.inputKey;
-  }
   function cancel() {
     if (active) update(null);
   }
@@ -805,7 +812,7 @@ function createRuntimeDragFeature(context) {
       getDropTargets: () => dropTargets,
       setDropTarget(target) {
         if (!active || disposed) return;
-        if (target && !targets().some((candidate) => sameTarget(candidate, target))) {
+        if (target && !targets().some((candidate) => isSameDropTarget(candidate, target))) {
           update({ ...active, target: null });
           return;
         }
@@ -813,7 +820,9 @@ function createRuntimeDragFeature(context) {
       },
       drop() {
         const finished = active;
-        const eligible = finished?.target && targets().some((target) => sameTarget(target, finished.target));
+        const eligible = finished?.target && targets().some(
+          (target) => isSameDropTarget(target, finished.target)
+        );
         cancel();
         if (!disposed && finished?.target && eligible)
           context.routeCardDrop(finished.cardId, finished.target);
@@ -1036,6 +1045,173 @@ function panZoomFeature(game, context, options = {}) {
     }
   };
 }
+
+// src/headless/features/origins.ts
+var isHidden = (cardId) => cardId.startsWith("hidden:");
+var hiddenCount = (zones, zone) => zones[zone]?.cardIds.filter(isHidden).length ?? 0;
+function singleOrigin(departures, count) {
+  const origin = departures[0];
+  return origin && departures.length >= count && departures.every(
+    (card) => card.zone === origin.zone && card.hidden === origin.hidden
+  ) ? Object.freeze(origin) : null;
+}
+function findCardOrigins(previous, next, mover) {
+  const shownBefore = /* @__PURE__ */ new Map();
+  for (const [zone, { cardIds }] of Object.entries(previous))
+    for (const cardId of cardIds)
+      if (!isHidden(cardId)) shownBefore.set(cardId, zone);
+  const shownNow = new Set(
+    Object.values(next).flatMap(
+      ({ cardIds }) => cardIds.filter((cardId) => !isHidden(cardId))
+    )
+  );
+  let left = Object.entries(previous).flatMap(([zone, { cardIds }]) => [
+    ...cardIds.filter((cardId) => !isHidden(cardId) && !shownNow.has(cardId)).map(() => ({ zone, hidden: false })),
+    ...Array.from(
+      {
+        length: Math.max(
+          0,
+          hiddenCount(previous, zone) - hiddenCount(next, zone)
+        )
+      },
+      () => ({ zone, hidden: true })
+    )
+  ]);
+  const origins = /* @__PURE__ */ new Map();
+  const shownArrivals = [];
+  const hiddenArrivals = [];
+  for (const [zone, { cardIds }] of Object.entries(next)) {
+    for (const cardId of cardIds) {
+      if (isHidden(cardId)) continue;
+      const from = shownBefore.get(cardId);
+      if (from === void 0) shownArrivals.push(cardId);
+      else if (from !== zone)
+        origins.set(cardId, Object.freeze({ zone: from, hidden: false }));
+    }
+    const hidden = cardIds.filter(isHidden);
+    const before = hiddenCount(previous, zone);
+    hiddenArrivals.push(
+      ...Array.from(
+        { length: Math.max(0, hidden.length - before) },
+        (_, index) => before === 0 ? hidden[index] : null
+      )
+    );
+  }
+  if (left.some(
+    (card) => !card.hidden && hiddenCount(previous, card.zone) > 0 && hiddenCount(next, card.zone) > 0
+  ))
+    return origins;
+  const hiddenLeft = left.filter((card) => card.hidden);
+  if (shownArrivals.length) {
+    const origin = singleOrigin(hiddenLeft, shownArrivals.length);
+    if (origin) {
+      for (const cardId of shownArrivals) origins.set(cardId, origin);
+      left = [
+        ...left.filter((card) => !card.hidden),
+        ...hiddenLeft.slice(shownArrivals.length)
+      ];
+    } else if (hiddenLeft.length) {
+      return origins;
+    } else if (mover !== null) {
+      const origin2 = Object.freeze({ player: mover, hidden: true });
+      for (const cardId of shownArrivals) origins.set(cardId, origin2);
+    }
+  }
+  const hiddenOrigin = singleOrigin(left, hiddenArrivals.length) ?? (left.length === 0 && mover !== null ? Object.freeze({ player: mover, hidden: true }) : null);
+  if (hiddenOrigin) {
+    for (const cardId of hiddenArrivals)
+      if (cardId !== null) origins.set(cardId, hiddenOrigin);
+  }
+  return origins;
+}
+function moverOf(snapshot) {
+  const active = snapshot.frame.flow.activePlayers;
+  return active.length === 1 && active[0] !== snapshot.me ? active[0] : null;
+}
+function originsFeature(game) {
+  let frame = game.snapshot;
+  let source = game.getOptions().source;
+  let origins = /* @__PURE__ */ new Map();
+  function sync() {
+    const next = game.snapshot;
+    const nextSource = game.getOptions().source;
+    if (next?.version === frame?.version && next?.me === frame?.me && nextSource === source)
+      return;
+    origins = frame && next && next.me === frame.me && nextSource === source ? findCardOrigins(
+      frame.frame.zones,
+      next.frame.zones,
+      next.version === frame.version + 1 ? moverOf(frame) : null
+    ) : /* @__PURE__ */ new Map();
+    frame = next;
+    source = nextSource;
+  }
+  const unsubscribe = game.subscribe(sync);
+  return {
+    card: {
+      getOrigin() {
+        sync();
+        return origins.get(this.id) ?? null;
+      }
+    },
+    dispose: unsubscribe
+  };
+}
+
+// src/headless/fan.ts
+var RADIANS = Math.PI / 180;
+function fanLayout({
+  count,
+  width,
+  cardWidth,
+  cardHeight,
+  step = cardWidth * 0.6,
+  minStep = cardWidth * 0.25,
+  angle = 5,
+  maxSpread = 30
+}) {
+  if (count < 1) return { cards: [], width: 0, height: 0 };
+  const gaps = count - 1;
+  const delta = gaps ? Math.min(angle, maxSpread / gaps) * RADIANS : 0;
+  const edge = gaps * delta / 2;
+  const span = delta ? 2 * Math.sin(edge) / delta : gaps;
+  const ends = cardWidth * Math.cos(edge) + cardHeight * Math.sin(edge);
+  const spacing = span ? Math.max(minStep, Math.min(step, (width - ends) / span)) : 0;
+  const radius = delta ? spacing / delta : 0;
+  const centres = Array.from({ length: count }, (_, index) => {
+    if (!delta) return { theta: 0, x: (index - gaps / 2) * spacing, y: 0 };
+    const theta = (index - gaps / 2) * delta;
+    return {
+      theta,
+      x: radius * Math.sin(theta),
+      y: radius * (1 - Math.cos(theta))
+    };
+  });
+  const halfHeight = (theta) => cardHeight / 2 * Math.cos(theta) + cardWidth / 2 * Math.abs(Math.sin(theta));
+  const top = Math.min(
+    ...centres.map((card) => card.y - halfHeight(card.theta))
+  );
+  const bottom = Math.max(
+    ...centres.map((card) => card.y + halfHeight(card.theta))
+  );
+  const fanWidth = spacing * span + ends;
+  return {
+    cards: centres.map((card) => ({
+      x: card.x + (fanWidth - cardWidth) / 2,
+      y: card.y - top - cardHeight / 2,
+      rotate: card.theta / RADIANS
+    })),
+    width: fanWidth,
+    height: bottom - top
+  };
+}
+function liftFanCard(card, distance) {
+  const theta = card.rotate * RADIANS;
+  return {
+    x: card.x + distance * Math.sin(theta),
+    y: card.y - distance * Math.cos(theta),
+    rotate: card.rotate
+  };
+}
 export {
   AmbiguousTargetError,
   AuthAcceptedFrameSchema,
@@ -1049,6 +1225,7 @@ export {
   DREAMBOARD_SDK_PACKAGES,
   DREAMBOARD_SDK_PACKAGE_SET,
   DREAMBOARD_SDK_VERSION,
+  GESTURE_THRESHOLDS,
   GameEventDetailSchema,
   GameEventSchema,
   GameOutcomeSchema,
@@ -1085,16 +1262,20 @@ export {
   canonicalizePluginRuntimeJson,
   computePluginActionSetVersion,
   createGameInstance,
+  createGestureRecognizer,
   createPluginProtocolEnvelopeSchema,
   digestPluginCommandRequest,
   digestPluginGameplayFrame,
   digestPluginRuntimeJson,
   dragFeature,
   encodeCanonicalPluginRuntimeJson,
+  fanLayout,
   handFeature,
   hostSource,
   iframeSource,
+  liftFanCard,
   materializePluginGameplayFrame,
+  originsFeature,
   panZoomFeature,
   parseHostToPluginEnvelope,
   parsePluginGameplayFrame,