jspsych-tangram 0.0.1

package/src/core/engine/validation/complete.ts

@@ -0,0 +1,102 @@
+// core/validate/complete.ts
+import type { Poly, Vec } from "@/core/domain/types";
+import { pointInPolygon } from "@/core/engine/geometry";
+import { CONFIG } from "@/core/config/config";
+
+/** AABB of one or more polys */
+function aabb(polys: Poly[]) {
+  let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+  for (const poly of polys) for (const p of poly) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+    if (p.x > maxX) maxX = p.x;
+    if (p.y > maxY) maxY = p.y;
+  }
+  return { minX, minY, maxX, maxY };
+}
+
+/** Cell centers over an AABB, aligned to GRID_PX centers (k + GRID_PX/2). */
+function cellCentersInAABB(minX: number, minY: number, maxX: number, maxY: number): Vec[] {
+  const GRID_PX = CONFIG.layout.grid.stepPx;
+  const x0 = Math.floor((minX - GRID_PX/2) / GRID_PX) * GRID_PX + GRID_PX/2;
+  const y0 = Math.floor((minY - GRID_PX/2) / GRID_PX) * GRID_PX + GRID_PX/2;
+  const out: Vec[] = [];
+  for (let y = y0; y <= maxY; y += GRID_PX) {
+    for (let x = x0; x <= maxX; x += GRID_PX) out.push({ x, y });
+  }
+  return out;
+}
+
+/** Build a set of grid centers that lie inside ANY of the polygons. */
+export function cellSetForPolys(polys: Poly[]): Set<string> {
+  if (!polys.length) return new Set();
+  const { minX, minY, maxX, maxY } = aabb(polys);
+  const centers = cellCentersInAABB(minX, minY, maxX, maxY);
+  const key = (p: Vec) => `${p.x},${p.y}`;
+  const S = new Set<string>();
+  center: for (const c of centers) {
+    for (const poly of polys) {
+      if (pointInPolygon(c, poly)) { S.add(key(c)); continue center; }
+    }
+  }
+  return S;
+}
+
+/** Anchors | Silhouette: complete iff silhouette cell set ⊆ piece cell set. */
+export function anchorsSilhouetteComplete(silPolys: Poly[], piecePolys: Poly[]): boolean {
+  if (!silPolys.length) return false;
+  const S = cellSetForPolys(silPolys);
+  if (S.size === 0) return false;
+  const P = cellSetForPolys(piecePolys);
+  if (P.size === 0) return false;
+  for (const k of S) if (!P.has(k)) return false;
+  return true;
+}
+
+// --- helpers for translation-invariant equality on the grid -----------------
+function stringSetToVecs(S: Set<string>): Vec[] {
+  const out: Vec[] = [];
+  for (const k of S) {
+    const [xs, ys] = k.split(",");
+    out.push({ x: Number(xs), y: Number(ys) });
+  }
+  return out;
+}
+
+function normalizeCells(S: Set<string>): Set<string> {
+  if (S.size === 0) return S;
+  const pts = stringSetToVecs(S);
+  let minX = Infinity,
+    minY = Infinity;
+  for (const p of pts) {
+    if (p.x < minX) minX = p.x;
+    if (p.y < minY) minY = p.y;
+  }
+  const N = new Set<string>();
+  for (const p of pts) N.add(`${p.x - minX},${p.y - minY}`);
+  return N;
+}
+
+function setsEqual(a: Set<string>, b: Set<string>): boolean {
+  if (a.size !== b.size) return false;
+  for (const k of a) if (!b.has(k)) return false;
+  return true;
+}
+
+/**
+ * Anchors | Workspace:
+ * complete iff the pieces form the sector's silhouette pattern up to a GRID_PX translation.
+ * (No rotation/mirror; exact coverage — no extra cells.)
+ */
+export function anchorsWorkspaceComplete(
+  silPolys: Poly[],
+  piecePolys: Poly[]
+): boolean {
+  if (!silPolys.length) return false;
+  const Sraw = cellSetForPolys(silPolys);
+  const Praw = cellSetForPolys(piecePolys);
+  if (Sraw.size === 0 || Praw.size === 0) return false;
+  const S = normalizeCells(Sraw);
+  const P = normalizeCells(Praw);
+  return setsEqual(S, P);
+}

package/src/core/engine/validation/face-to-face.ts

@@ -0,0 +1,217 @@
+/**
+ * Face-to-Face Attachment Validation for Prep Mode
+ * 
+ * Validates that pieces in prep mode attach to existing pieces by sharing
+ * at least 1 anchor unit of edge contact. Uses discrete unit segments
+ * for precise edge detection.
+ */
+
+import type { Piece, Vec, Blueprint } from "../../domain/types";
+import { CONFIG } from "../../config/config";
+import { boundsOfBlueprint } from "../geometry";
+
+export interface EdgeAttachmentResult {
+  isAttached: boolean;
+  attachedPieceIds: string[];
+  sharedEdgeLength: number; // In anchor units
+}
+
+export interface UnitSegment {
+  a: Vec;
+  b: Vec;
+}
+
+/**
+ * Convert a polygon edge into unit-length segments
+ * Each segment represents a discrete coordinate unit along the edge
+ */
+function edgeToUnitSegments(start: Vec, end: Vec, gridSize: number): UnitSegment[] {
+  const segments: UnitSegment[] = [];
+  
+  // Convert to grid coordinates
+  const startGrid = {
+    x: Math.round(start.x / gridSize),
+    y: Math.round(start.y / gridSize)
+  };
+  const endGrid = {
+    x: Math.round(end.x / gridSize),
+    y: Math.round(end.y / gridSize)
+  };
+  
+  const dx = endGrid.x - startGrid.x;
+  const dy = endGrid.y - startGrid.y;
+  
+  if (dx === 0 && dy === 0) return []; // Zero-length edge
+  
+  const steps = Math.max(Math.abs(dx), Math.abs(dy));
+  const stepX = dx / steps;
+  const stepY = dy / steps;
+  
+  for (let i = 0; i < steps; i++) {
+    const aX = Math.round(startGrid.x + i * stepX);
+    const aY = Math.round(startGrid.y + i * stepY);
+    const bX = Math.round(startGrid.x + (i + 1) * stepX);
+    const bY = Math.round(startGrid.y + (i + 1) * stepY);
+    segments.push({ 
+      a: { x: aX, y: aY }, 
+      b: { x: bX, y: bY } 
+    });
+  }
+  
+  return segments;
+}
+
+
+
+/**
+ * Get all unit segments for a piece (all edges broken down into unit-length segments)
+ * Uses the same coordinate system as piecePolysAt for consistency with visual rendering
+ */
+function getPieceUnitSegments(
+  piece: Piece, 
+  getBlueprint: (id: string) => Blueprint | undefined,
+  getPrimitive: (kind: string) => any,
+  gridSize: number
+): UnitSegment[] {
+  const blueprint = getBlueprint(piece.blueprintId);
+  if (!blueprint?.shape) return [];
+  
+  // Calculate offset using same logic as piecePolysAt
+  const bb = boundsOfBlueprint(blueprint, getPrimitive);
+  const ox = piece.pos.x - bb.min.x;
+  const oy = piece.pos.y - bb.min.y;
+  
+  const allSegments: UnitSegment[] = [];
+  
+  // Translate polygons and convert edges to unit segments
+  for (const poly of blueprint.shape) {
+    const translatedPoly = poly.map((vertex: Vec) => ({
+      x: vertex.x + ox,
+      y: vertex.y + oy
+    }));
+    
+    for (let i = 0; i < translatedPoly.length; i++) {
+      const current = translatedPoly[i];
+      const next = translatedPoly[(i + 1) % translatedPoly.length];
+      
+      if (!current || !next) continue;
+      
+      allSegments.push(...edgeToUnitSegments(current, next, gridSize));
+    }
+  }
+  
+  return allSegments;
+}
+
+/**
+ * Main face-to-face attachment validation function
+ */
+export function checkFaceToFaceAttachment(
+  piece: Piece,
+  existingPieces: Piece[],
+  getBlueprint: (id: string) => Blueprint | undefined,
+  getPrimitive: (kind: string) => any
+): EdgeAttachmentResult {
+  if (existingPieces.length === 0) {
+    return { isAttached: true, attachedPieceIds: [], sharedEdgeLength: 0 };
+  }
+  
+  const gridSize = CONFIG.layout.grid.stepPx;
+  const newPieceSegments = getPieceUnitSegments(piece, getBlueprint, getPrimitive, gridSize);
+  
+  if (newPieceSegments.length === 0) {
+    return { isAttached: false, attachedPieceIds: [], sharedEdgeLength: 0 };
+  }
+  
+  let totalSharedLength = 0;
+  const attachedPieceIds: string[] = [];
+  
+  // Check against each existing piece
+  for (const existingPiece of existingPieces) {
+    const existingSegments = getPieceUnitSegments(existingPiece, getBlueprint, getPrimitive, gridSize);
+    
+    // Find shared segments (undirected edge matching)
+    const sharedSegments = newPieceSegments.filter(newSeg => 
+      existingSegments.some(existingSeg => 
+        // Check if segments share the same endpoints (identical or reversed)
+        (newSeg.a.x === existingSeg.a.x && newSeg.a.y === existingSeg.a.y &&
+         newSeg.b.x === existingSeg.b.x && newSeg.b.y === existingSeg.b.y) ||
+        (newSeg.a.x === existingSeg.b.x && newSeg.a.y === existingSeg.b.y &&
+         newSeg.b.x === existingSeg.a.x && newSeg.b.y === existingSeg.a.y)
+      )
+    );
+    
+    if (sharedSegments.length > 0) {
+      totalSharedLength += sharedSegments.length;
+      attachedPieceIds.push(existingPiece.id);
+    }
+  }
+  
+  return {
+    isAttached: totalSharedLength >= 1,
+    attachedPieceIds,
+    sharedEdgeLength: totalSharedLength
+  };
+}
+
+/**
+ * Check if removing a piece would disconnect the remaining pieces in a sector
+ * Uses graph connectivity to ensure all remaining pieces stay connected
+ */
+export function wouldRemovalDisconnectSector(
+  pieceToRemove: Piece,
+  allPiecesInSector: Piece[],
+  getBlueprint: (id: string) => Blueprint | undefined,
+  getPrimitive: (kind: string) => any
+): boolean {
+  // If there are 0 or 1 pieces remaining, no disconnection possible
+  if (allPiecesInSector.length <= 2) return false;
+  
+  const remainingPieces = allPiecesInSector.filter(p => p.id !== pieceToRemove.id);
+  if (remainingPieces.length <= 1) return false;
+  
+  // Build adjacency graph of remaining pieces
+  const adjacencyMap = new Map<string, string[]>();
+  
+  // Initialize adjacency map
+  for (const piece of remainingPieces) {
+    adjacencyMap.set(piece.id, []);
+  }
+  
+  // Check all pairs of remaining pieces for connectivity
+  for (let i = 0; i < remainingPieces.length; i++) {
+    for (let j = i + 1; j < remainingPieces.length; j++) {
+      const piece1 = remainingPieces[i];
+      const piece2 = remainingPieces[j];
+      
+      if (!piece1 || !piece2) continue;
+      
+      const result = checkFaceToFaceAttachment(piece1, [piece2], getBlueprint, getPrimitive);
+      if (result.isAttached) {
+        adjacencyMap.get(piece1.id)!.push(piece2.id);
+        adjacencyMap.get(piece2.id)!.push(piece1.id);
+      }
+    }
+  }
+  
+  // Check if graph is connected using DFS
+  const visited = new Set<string>();
+  const startPiece = remainingPieces[0];
+  
+  if (!startPiece) return false;
+  
+  function dfs(pieceId: string) {
+    if (visited.has(pieceId)) return;
+    visited.add(pieceId);
+    
+    const neighbors = adjacencyMap.get(pieceId) || [];
+    for (const neighborId of neighbors) {
+      dfs(neighborId);
+    }
+  }
+  
+  dfs(startPiece.id);
+  
+  // If we visited all pieces, the graph is connected
+  return visited.size !== remainingPieces.length;
+}

package/src/core/index.ts

@@ -0,0 +1,3 @@
+// re-export the bits you want public from "Core"
+export * from "./domain/types";
+export { BaseGameController } from "./engine/state/BaseGameController";