sa2kit 3.0.0 → 3.2.0

package/dist/business/index.js

@@ -1,581 +0,0 @@
-'use strict';
-
-var React = require('react');
-
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
-
-var React__default = /*#__PURE__*/_interopDefault(React);
-
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/business/bubbleShooter/index.ts
-var bubbleShooter_exports = {};
-__export(bubbleShooter_exports, {
-  DEFAULT_BUBBLE_SHOOTER_CONFIG: () => DEFAULT_BUBBLE_SHOOTER_CONFIG,
-  createEmptyGrid: () => createEmptyGrid,
-  createInitialGrid: () => createInitialGrid,
-  findAttachSlot: () => findAttachSlot,
-  findCollisionSlot: () => findCollisionSlot,
-  getBoardHeight: () => getBoardHeight,
-  getBoardWidth: () => getBoardWidth,
-  getBubbleDiameter: () => getBubbleDiameter,
-  getBubblePosition: () => getBubblePosition,
-  getNearestSlot: () => getNearestSlot,
-  getNeighbors: () => getNeighbors,
-  getRowStep: () => getRowStep,
-  hasAnyBubble: () => hasAnyBubble,
-  hasReachedDangerLine: () => hasReachedDangerLine,
-  isValidSlot: () => isValidSlot,
-  pickRandomColor: () => pickRandomColor,
-  resolveMatches: () => resolveMatches,
-  webUI: () => web_exports
-});
-
-// src/business/bubbleShooter/logic/game.ts
-var slotKey = (row, col) => `${row}:${col}`;
-var cloneGrid = (grid) => grid.map((row) => [...row]);
-var DEFAULT_BUBBLE_SHOOTER_CONFIG = {
-  rows: 12,
-  cols: 8,
-  initialRows: 5,
-  bubbleRadius: 16,
-  topOffset: 18,
-  palette: ["#fb7185", "#60a5fa", "#34d399", "#fbbf24", "#a78bfa"],
-  launchSpeed: 440,
-  minMatchCount: 3
-};
-var getBubbleDiameter = (config) => config.bubbleRadius * 2;
-var getRowStep = (config) => Math.round(config.bubbleRadius * 1.73);
-var getBoardWidth = (config) => {
-  return getBubbleDiameter(config) * config.cols + config.bubbleRadius;
-};
-var getBoardHeight = (config) => {
-  return config.topOffset + getRowStep(config) * (config.rows + 1) + config.bubbleRadius;
-};
-var createEmptyGrid = (config) => {
-  return Array.from({ length: config.rows }, () => Array.from({ length: config.cols }, () => null));
-};
-var createInitialGrid = (config) => {
-  const grid = createEmptyGrid(config);
-  for (let row = 0; row < config.initialRows; row += 1) {
-    for (let col = 0; col < config.cols; col += 1) {
-      const color = config.palette[Math.floor(Math.random() * config.palette.length)] || config.palette[0] || "#60a5fa";
-      const targetRow = grid[row];
-      if (targetRow) {
-        targetRow[col] = color;
-      }
-    }
-  }
-  return grid;
-};
-var pickRandomColor = (palette) => {
-  return palette[Math.floor(Math.random() * palette.length)] || "#60a5fa";
-};
-var getBubblePosition = (row, col, config) => {
-  const diameter = getBubbleDiameter(config);
-  const rowStep = getRowStep(config);
-  const x = config.bubbleRadius + col * diameter + (row % 2 === 1 ? config.bubbleRadius : 0);
-  const y = config.topOffset + config.bubbleRadius + row * rowStep;
-  return { x, y };
-};
-var isValidSlot = (slot, config) => {
-  return slot.row >= 0 && slot.row < config.rows && slot.col >= 0 && slot.col < config.cols;
-};
-var getNeighbors = (slot, config) => {
-  const evenDirections = [
-    { row: -1, col: -1 },
-    { row: -1, col: 0 },
-    { row: 0, col: -1 },
-    { row: 0, col: 1 },
-    { row: 1, col: -1 },
-    { row: 1, col: 0 }
-  ];
-  const oddDirections = [
-    { row: -1, col: 0 },
-    { row: -1, col: 1 },
-    { row: 0, col: -1 },
-    { row: 0, col: 1 },
-    { row: 1, col: 0 },
-    { row: 1, col: 1 }
-  ];
-  const directions = slot.row % 2 === 0 ? evenDirections : oddDirections;
-  return directions.map((direction) => ({ row: slot.row + direction.row, col: slot.col + direction.col })).filter((candidate) => isValidSlot(candidate, config));
-};
-var getNearestSlot = (x, y, config) => {
-  const rowStep = getRowStep(config);
-  const diameter = getBubbleDiameter(config);
-  const row = Math.max(0, Math.min(config.rows - 1, Math.round((y - config.topOffset - config.bubbleRadius) / rowStep)));
-  const rowOffset = row % 2 === 1 ? config.bubbleRadius : 0;
-  const col = Math.max(0, Math.min(config.cols - 1, Math.round((x - config.bubbleRadius - rowOffset) / diameter)));
-  return { row, col };
-};
-var hasAdjacentBubble = (row, col, grid, config) => {
-  if (row === 0) {
-    return true;
-  }
-  return getNeighbors({ row, col }, config).some((neighbor) => {
-    const targetRow = grid[neighbor.row];
-    return Boolean(targetRow?.[neighbor.col]);
-  });
-};
-var findAttachSlot = (x, y, grid, config, preferred) => {
-  const candidates = [];
-  if (preferred && isValidSlot(preferred, config)) {
-    candidates.push(preferred, ...getNeighbors(preferred, config));
-  }
-  const nearest = getNearestSlot(x, y, config);
-  candidates.push(nearest, ...getNeighbors(nearest, config));
-  const uniqueCandidates = Array.from(
-    new Map(candidates.map((slot) => [slotKey(slot.row, slot.col), slot])).values()
-  );
-  let best = null;
-  let bestDistance = Number.POSITIVE_INFINITY;
-  uniqueCandidates.forEach((slot) => {
-    const targetRow = grid[slot.row];
-    if (!targetRow || targetRow[slot.col] || !hasAdjacentBubble(slot.row, slot.col, grid, config)) {
-      return;
-    }
-    const position = getBubblePosition(slot.row, slot.col, config);
-    const dx = position.x - x;
-    const dy = position.y - y;
-    const distance = dx * dx + dy * dy;
-    if (distance < bestDistance) {
-      bestDistance = distance;
-      best = slot;
-    }
-  });
-  return best;
-};
-var findCollisionSlot = (x, y, grid, config) => {
-  const threshold = (config.bubbleRadius * 2 - 1) ** 2;
-  for (let row = 0; row < config.rows; row += 1) {
-    for (let col = 0; col < config.cols; col += 1) {
-      const targetRow = grid[row];
-      if (!targetRow?.[col]) {
-        continue;
-      }
-      const position = getBubblePosition(row, col, config);
-      const dx = position.x - x;
-      const dy = position.y - y;
-      if (dx * dx + dy * dy <= threshold) {
-        return { row, col };
-      }
-    }
-  }
-  return null;
-};
-var collectGroup = (start, grid, config, color) => {
-  const queue = [start];
-  const visited = /* @__PURE__ */ new Set();
-  const group = [];
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current) {
-      continue;
-    }
-    const key = slotKey(current.row, current.col);
-    if (visited.has(key)) {
-      continue;
-    }
-    visited.add(key);
-    const currentColor = grid[current.row]?.[current.col];
-    if (currentColor !== color) {
-      continue;
-    }
-    group.push(current);
-    getNeighbors(current, config).forEach((neighbor) => {
-      const neighborKey = slotKey(neighbor.row, neighbor.col);
-      if (!visited.has(neighborKey)) {
-        queue.push(neighbor);
-      }
-    });
-  }
-  return group;
-};
-var collectTopConnected = (grid, config) => {
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [];
-  for (let col = 0; col < config.cols; col += 1) {
-    if (grid[0]?.[col]) {
-      queue.push({ row: 0, col });
-    }
-  }
-  while (queue.length > 0) {
-    const current = queue.shift();
-    if (!current) {
-      continue;
-    }
-    const key = slotKey(current.row, current.col);
-    if (visited.has(key)) {
-      continue;
-    }
-    if (!grid[current.row]?.[current.col]) {
-      continue;
-    }
-    visited.add(key);
-    getNeighbors(current, config).forEach((neighbor) => {
-      const neighborKey = slotKey(neighbor.row, neighbor.col);
-      if (!visited.has(neighborKey)) {
-        queue.push(neighbor);
-      }
-    });
-  }
-  return visited;
-};
-var resolveMatches = (grid, placed, config) => {
-  const nextGrid = cloneGrid(grid);
-  const placedColor = nextGrid[placed.row]?.[placed.col];
-  if (!placedColor) {
-    return { grid: nextGrid, removed: 0, matched: 0, dropped: 0 };
-  }
-  const group = collectGroup(placed, nextGrid, config, placedColor);
-  let matched = 0;
-  if (group.length >= config.minMatchCount) {
-    group.forEach((slot) => {
-      const targetRow = nextGrid[slot.row];
-      if (targetRow?.[slot.col]) {
-        targetRow[slot.col] = null;
-        matched += 1;
-      }
-    });
-  }
-  let dropped = 0;
-  if (matched > 0) {
-    const topConnected = collectTopConnected(nextGrid, config);
-    for (let row = 0; row < config.rows; row += 1) {
-      for (let col = 0; col < config.cols; col += 1) {
-        const targetRow = nextGrid[row];
-        if (targetRow?.[col] && !topConnected.has(slotKey(row, col))) {
-          targetRow[col] = null;
-          dropped += 1;
-        }
-      }
-    }
-  }
-  return {
-    grid: nextGrid,
-    matched,
-    dropped,
-    removed: matched + dropped
-  };
-};
-var hasAnyBubble = (grid) => {
-  return grid.some((row) => row.some(Boolean));
-};
-var hasReachedDangerLine = (grid, config, dangerRowOffset = 2) => {
-  const limitRow = Math.max(0, config.rows - dangerRowOffset);
-  for (let row = limitRow; row < config.rows; row += 1) {
-    const targetRow = grid[row];
-    if (targetRow?.some(Boolean)) {
-      return true;
-    }
-  }
-  return false;
-};
-
-// src/business/bubbleShooter/ui/web/index.ts
-var web_exports = {};
-__export(web_exports, {
-  BubbleShooterBoard: () => BubbleShooterBoard_default,
-  BubbleShooterGamePage: () => BubbleShooterGamePage_default
-});
-var clampAim = (angle) => {
-  const minAngle = -Math.PI + 0.15;
-  const maxAngle = -0.15;
-  return Math.max(minAngle, Math.min(maxAngle, angle));
-};
-var drawCircle = (context, x, y, radius, color) => {
-  context.beginPath();
-  context.arc(x, y, radius, 0, Math.PI * 2);
-  context.fillStyle = color;
-  context.fill();
-  context.strokeStyle = "rgba(15, 23, 42, 0.15)";
-  context.lineWidth = 1;
-  context.stroke();
-};
-var normalizeConfig = (input) => {
-  return {
-    ...DEFAULT_BUBBLE_SHOOTER_CONFIG,
-    ...input,
-    palette: input?.palette?.length ? input.palette : DEFAULT_BUBBLE_SHOOTER_CONFIG.palette
-  };
-};
-var BubbleShooterBoard = ({ config: inputConfig, className }) => {
-  const config = React.useMemo(() => normalizeConfig(inputConfig), [inputConfig]);
-  const boardWidth = React.useMemo(() => getBoardWidth(config), [config]);
-  const boardHeight = React.useMemo(() => getBoardHeight(config), [config]);
-  const shooterX = boardWidth / 2;
-  const shooterY = boardHeight - config.bubbleRadius - 12;
-  const canvasRef = React.useRef(null);
-  const rafRef = React.useRef(null);
-  const lastTsRef = React.useRef(0);
-  const [grid, setGrid] = React.useState(() => createInitialGrid(config));
-  const [status, setStatus] = React.useState("ready");
-  const [score, setScore] = React.useState(0);
-  const [shots, setShots] = React.useState(0);
-  const [aimAngle, setAimAngle] = React.useState(-Math.PI / 2);
-  const [currentColor, setCurrentColor] = React.useState(() => pickRandomColor(config.palette));
-  const [nextColor, setNextColor] = React.useState(() => pickRandomColor(config.palette));
-  const [projectile, setProjectile] = React.useState(null);
-  const gridRef = React.useRef(grid);
-  const currentColorRef = React.useRef(currentColor);
-  const nextColorRef = React.useRef(nextColor);
-  const statusRef = React.useRef(status);
-  React.useEffect(() => {
-    gridRef.current = grid;
-  }, [grid]);
-  React.useEffect(() => {
-    currentColorRef.current = currentColor;
-  }, [currentColor]);
-  React.useEffect(() => {
-    nextColorRef.current = nextColor;
-  }, [nextColor]);
-  React.useEffect(() => {
-    statusRef.current = status;
-  }, [status]);
-  const restart = React.useCallback(() => {
-    setGrid(createInitialGrid(config));
-    setScore(0);
-    setShots(0);
-    setStatus("ready");
-    setProjectile(null);
-    setAimAngle(-Math.PI / 2);
-    setCurrentColor(pickRandomColor(config.palette));
-    setNextColor(pickRandomColor(config.palette));
-    lastTsRef.current = 0;
-  }, [config]);
-  React.useEffect(() => {
-    restart();
-  }, [restart]);
-  const settleProjectile = React.useCallback(
-    (x, y, preferredSlot) => {
-      const working = gridRef.current.map((row) => [...row]);
-      const attach = findAttachSlot(x, y, working, config, preferredSlot);
-      if (!attach) {
-        setProjectile(null);
-        setStatus("lost");
-        return;
-      }
-      const rowData = working[attach.row];
-      if (!rowData || rowData[attach.col]) {
-        setProjectile(null);
-        setStatus("lost");
-        return;
-      }
-      rowData[attach.col] = currentColorRef.current;
-      const resolved = resolveMatches(working, attach, config);
-      setGrid(resolved.grid);
-      setProjectile(null);
-      setShots((prev) => prev + 1);
-      if (resolved.removed > 0) {
-        setScore((prev) => prev + resolved.matched * 10 + resolved.dropped * 15);
-      }
-      const hasBubbleLeft = hasAnyBubble(resolved.grid);
-      if (!hasBubbleLeft) {
-        setStatus("won");
-      } else if (hasReachedDangerLine(resolved.grid, config)) {
-        setStatus("lost");
-      } else {
-        setStatus("ready");
-      }
-      const nextCurrent = nextColorRef.current;
-      const nextQueued = pickRandomColor(config.palette);
-      setCurrentColor(nextCurrent);
-      setNextColor(nextQueued);
-    },
-    [config]
-  );
-  React.useEffect(() => {
-    if (status !== "shooting") {
-      return;
-    }
-    const step = (timestamp) => {
-      if (statusRef.current !== "shooting") {
-        lastTsRef.current = 0;
-        return;
-      }
-      const previousTs = lastTsRef.current || timestamp;
-      const deltaSec = Math.min((timestamp - previousTs) / 1e3, 0.05);
-      lastTsRef.current = timestamp;
-      let shouldContinue = true;
-      setProjectile((prev) => {
-        if (!prev || statusRef.current !== "shooting") {
-          shouldContinue = false;
-          return prev;
-        }
-        let nextX = prev.x + prev.vx * deltaSec;
-        const nextY = prev.y + prev.vy * deltaSec;
-        let nextVx = prev.vx;
-        if (nextX <= config.bubbleRadius) {
-          nextX = config.bubbleRadius;
-          nextVx = Math.abs(nextVx);
-        } else if (nextX >= boardWidth - config.bubbleRadius) {
-          nextX = boardWidth - config.bubbleRadius;
-          nextVx = -Math.abs(nextVx);
-        }
-        if (nextY <= config.topOffset + config.bubbleRadius) {
-          shouldContinue = false;
-          settleProjectile(nextX, config.topOffset + config.bubbleRadius, getNearestSlot(nextX, nextY, config));
-          return null;
-        }
-        const collision = findCollisionSlot(nextX, nextY, gridRef.current, config);
-        if (collision) {
-          shouldContinue = false;
-          settleProjectile(nextX, nextY, collision);
-          return null;
-        }
-        return {
-          ...prev,
-          x: nextX,
-          y: nextY,
-          vx: nextVx
-        };
-      });
-      if (shouldContinue) {
-        rafRef.current = window.requestAnimationFrame(step);
-      } else {
-        rafRef.current = null;
-        lastTsRef.current = 0;
-      }
-    };
-    rafRef.current = window.requestAnimationFrame(step);
-    return () => {
-      if (rafRef.current) {
-        window.cancelAnimationFrame(rafRef.current);
-        rafRef.current = null;
-      }
-      lastTsRef.current = 0;
-    };
-  }, [boardWidth, config, settleProjectile, status]);
-  const shoot = React.useCallback(() => {
-    if (status !== "ready") {
-      return;
-    }
-    const vx = Math.cos(aimAngle) * config.launchSpeed;
-    const vy = Math.sin(aimAngle) * config.launchSpeed;
-    setProjectile({
-      x: shooterX,
-      y: shooterY - config.bubbleRadius,
-      vx,
-      vy,
-      color: currentColor
-    });
-    setStatus("shooting");
-  }, [aimAngle, config.bubbleRadius, config.launchSpeed, currentColor, shooterX, shooterY, status]);
-  const updateAimFromPointer = React.useCallback(
-    (event) => {
-      const canvas = canvasRef.current;
-      if (!canvas || status !== "ready") {
-        return;
-      }
-      const rect = canvas.getBoundingClientRect();
-      const x = event.clientX - rect.left;
-      const y = event.clientY - rect.top;
-      const rawAngle = Math.atan2(y - shooterY, x - shooterX);
-      setAimAngle(clampAim(rawAngle));
-    },
-    [shooterX, shooterY, status]
-  );
-  const handlePointerDown = (event) => {
-    event.currentTarget.setPointerCapture(event.pointerId);
-    updateAimFromPointer(event);
-  };
-  const handlePointerUp = (event) => {
-    updateAimFromPointer(event);
-    shoot();
-    event.currentTarget.releasePointerCapture(event.pointerId);
-  };
-  React.useEffect(() => {
-    const canvas = canvasRef.current;
-    if (!canvas) {
-      return;
-    }
-    const context = canvas.getContext("2d");
-    if (!context) {
-      return;
-    }
-    const gradient = context.createLinearGradient(0, 0, 0, boardHeight);
-    gradient.addColorStop(0, "#f8fafc");
-    gradient.addColorStop(1, "#e2e8f0");
-    context.fillStyle = gradient;
-    context.fillRect(0, 0, boardWidth, boardHeight);
-    context.fillStyle = "rgba(148, 163, 184, 0.2)";
-    context.fillRect(0, shooterY - config.bubbleRadius * 1.3, boardWidth, 2);
-    for (let row = 0; row < config.rows; row += 1) {
-      for (let col = 0; col < config.cols; col += 1) {
-        const color = grid[row]?.[col];
-        if (!color) {
-          continue;
-        }
-        const position = getBubblePosition(row, col, config);
-        drawCircle(context, position.x, position.y, config.bubbleRadius - 0.5, color);
-      }
-    }
-    const aimLength = config.bubbleRadius * 9;
-    const aimX = shooterX + Math.cos(aimAngle) * aimLength;
-    const aimY = shooterY + Math.sin(aimAngle) * aimLength;
-    context.strokeStyle = "rgba(71, 85, 105, 0.75)";
-    context.lineWidth = 2;
-    context.setLineDash([4, 6]);
-    context.beginPath();
-    context.moveTo(shooterX, shooterY);
-    context.lineTo(aimX, aimY);
-    context.stroke();
-    context.setLineDash([]);
-    drawCircle(context, shooterX, shooterY, config.bubbleRadius - 0.5, currentColor);
-    if (projectile) {
-      drawCircle(context, projectile.x, projectile.y, config.bubbleRadius - 0.5, projectile.color);
-    }
-    drawCircle(context, boardWidth - config.bubbleRadius * 1.6, shooterY, config.bubbleRadius * 0.72, nextColor);
-    context.fillStyle = "#334155";
-    context.font = "12px sans-serif";
-    context.textAlign = "right";
-    context.fillText("Next", boardWidth - config.bubbleRadius * 0.5, shooterY - config.bubbleRadius * 1.05);
-    if (status === "won" || status === "lost") {
-      context.fillStyle = "rgba(15, 23, 42, 0.48)";
-      context.fillRect(0, 0, boardWidth, boardHeight);
-      context.fillStyle = "#ffffff";
-      context.font = "bold 26px sans-serif";
-      context.textAlign = "center";
-      context.fillText(status === "won" ? "You Win!" : "Game Over", boardWidth / 2, boardHeight / 2);
-    }
-  }, [aimAngle, boardHeight, boardWidth, config, currentColor, grid, nextColor, projectile, shooterX, shooterY, status]);
-  return /* @__PURE__ */ React__default.default.createElement("div", { className }, /* @__PURE__ */ React__default.default.createElement("div", { style: { display: "flex", gap: 16, marginBottom: 10, flexWrap: "wrap", color: "#334155" } }, /* @__PURE__ */ React__default.default.createElement("span", null, "\u72B6\u6001\uFF1A", status === "ready" ? "\u5F85\u53D1\u5C04" : status === "shooting" ? "\u53D1\u5C04\u4E2D" : status === "won" ? "\u80DC\u5229" : "\u5931\u8D25"), /* @__PURE__ */ React__default.default.createElement("span", null, "\u5206\u6570\uFF1A", score), /* @__PURE__ */ React__default.default.createElement("span", null, "\u53D1\u5C04\u6B21\u6570\uFF1A", shots)), /* @__PURE__ */ React__default.default.createElement(
-    "canvas",
-    {
-      ref: canvasRef,
-      width: boardWidth,
-      height: boardHeight,
-      onPointerMove: updateAimFromPointer,
-      onPointerDown: handlePointerDown,
-      onPointerUp: handlePointerUp,
-      style: {
-        width: "100%",
-        maxWidth: boardWidth,
-        borderRadius: 12,
-        border: "1px solid #cbd5e1",
-        boxShadow: "0 8px 28px rgba(15, 23, 42, 0.12)",
-        touchAction: "none",
-        cursor: status === "ready" ? "crosshair" : "default",
-        display: "block"
-      }
-    }
-  ), /* @__PURE__ */ React__default.default.createElement("div", { style: { marginTop: 10, display: "flex", gap: 10 } }, /* @__PURE__ */ React__default.default.createElement("button", { type: "button", onClick: restart, style: { padding: "8px 12px" } }, "\u91CD\u65B0\u5F00\u59CB")));
-};
-var BubbleShooterBoard_default = BubbleShooterBoard;
-var BubbleShooterGamePage = ({
-  config,
-  title = "\u6CE1\u6CE1\u9F99",
-  description = "\u57FA\u7840\u7248\uFF1A\u7784\u51C6\u3001\u53D1\u5C04\u3001\u8FDE\u6D88\u3001\u60AC\u7A7A\u6389\u843D\u3002"
-}) => {
-  return /* @__PURE__ */ React__default.default.createElement("section", null, /* @__PURE__ */ React__default.default.createElement("h2", null, title), /* @__PURE__ */ React__default.default.createElement("p", { style: { color: "#64748b" } }, description), /* @__PURE__ */ React__default.default.createElement(BubbleShooterBoard_default, { config }));
-};
-var BubbleShooterGamePage_default = BubbleShooterGamePage;
-
-exports.bubbleShooter = bubbleShooter_exports;
-//# sourceMappingURL=index.js.map
-//# sourceMappingURL=index.js.map