@guinetik/gcanvas 1.0.4 → 1.0.5

package/dist/gcanvas.es.js

@@ -5111,6 +5111,337 @@ _name = new WeakMap();
 _signature = new WeakMap();
 _coordinates = new WeakMap();
 let Tensor = _Tensor;
+const CONFIG$1 = {
+  tokens: {
+    // Supported operator aliases. Words are case-insensitive.
+    unaryNot: ["!", "~", "¬", "NOT"],
+    and: ["&", "∧", "AND"],
+    nand: ["NAND"],
+    or: ["|", "∨", "OR"],
+    nor: ["NOR"],
+    xor: ["^", "⊕", "XOR"],
+    xnor: ["XNOR"]
+  },
+  precedence: {
+    // Higher number = higher precedence
+    OR: 1,
+    NOR: 1,
+    XOR: 2,
+    XNOR: 2,
+    AND: 3,
+    NAND: 3,
+    NOT: 4
+  },
+  constants: {
+    true: ["1", "TRUE"],
+    false: ["0", "FALSE"]
+  }
+};
+function toBool(v) {
+  return Boolean(v);
+}
+function upper(s) {
+  return String(s).toUpperCase();
+}
+function tokenize(src) {
+  const out = [];
+  const s = String(src ?? "");
+  let i = 0;
+  const isWs = (c) => c === " " || c === "\n" || c === "	" || c === "\r";
+  const isAlpha = (c) => c >= "A" && c <= "Z" || c >= "a" && c <= "z" || c === "_";
+  const isAlnum = (c) => isAlpha(c) || c >= "0" && c <= "9";
+  while (i < s.length) {
+    const c = s[i];
+    if (isWs(c)) {
+      i++;
+      continue;
+    }
+    if (c === "(") {
+      out.push({ type: "lp", value: c });
+      i++;
+      continue;
+    }
+    if (c === ")") {
+      out.push({ type: "rp", value: c });
+      i++;
+      continue;
+    }
+    if (c === "!" || c === "~" || c === "¬" || c === "&" || c === "∧" || c === "|" || c === "∨" || c === "^" || c === "⊕") {
+      out.push({ type: "op", value: c });
+      i++;
+      continue;
+    }
+    if (isAlpha(c) || c >= "0" && c <= "9") {
+      let j = i + 1;
+      while (j < s.length && isAlnum(s[j])) j++;
+      const raw = s.slice(i, j);
+      const u = upper(raw);
+      if (CONFIG$1.constants.true.includes(u) || CONFIG$1.constants.false.includes(u)) {
+        out.push({ type: "const", value: u });
+      } else if (CONFIG$1.tokens.unaryNot.includes(u) || CONFIG$1.tokens.and.includes(u) || CONFIG$1.tokens.nand.includes(u) || CONFIG$1.tokens.or.includes(u) || CONFIG$1.tokens.nor.includes(u) || CONFIG$1.tokens.xor.includes(u) || CONFIG$1.tokens.xnor.includes(u)) {
+        out.push({ type: "op", value: u });
+      } else {
+        out.push({ type: "ident", value: raw });
+      }
+      i = j;
+      continue;
+    }
+    throw new Error(`[BooleanAlgebra] Unexpected character "${c}" at ${i}`);
+  }
+  return out;
+}
+function normalizeOperator(op) {
+  const u = upper(op);
+  if (CONFIG$1.tokens.unaryNot.map(upper).includes(u)) return "NOT";
+  if (CONFIG$1.tokens.and.map(upper).includes(u)) return "AND";
+  if (CONFIG$1.tokens.nand.map(upper).includes(u)) return "NAND";
+  if (CONFIG$1.tokens.or.map(upper).includes(u)) return "OR";
+  if (CONFIG$1.tokens.nor.map(upper).includes(u)) return "NOR";
+  if (CONFIG$1.tokens.xor.map(upper).includes(u)) return "XOR";
+  if (CONFIG$1.tokens.xnor.map(upper).includes(u)) return "XNOR";
+  throw new Error(`[BooleanAlgebra] Unknown operator "${op}"`);
+}
+function precedence(opName) {
+  return CONFIG$1.precedence[opName] ?? 0;
+}
+function parseTokens(tokens) {
+  let idx = 0;
+  const peek = () => tokens[idx];
+  const next = () => tokens[idx++];
+  function parsePrimary() {
+    const t = next();
+    if (!t) throw new Error("[BooleanAlgebra] Unexpected end of input");
+    if (t.type === "const") {
+      const u = upper(t.value);
+      return { type: "const", value: CONFIG$1.constants.true.includes(u) };
+    }
+    if (t.type === "ident") {
+      return { type: "var", name: t.value };
+    }
+    if (t.type === "lp") {
+      const expr = parseExpr(0);
+      const r = next();
+      if (!r || r.type !== "rp") {
+        throw new Error("[BooleanAlgebra] Missing closing ')'");
+      }
+      return expr;
+    }
+    if (t.type === "op") {
+      const opName = normalizeOperator(t.value);
+      if (opName !== "NOT") {
+        throw new Error(`[BooleanAlgebra] Unexpected binary operator "${t.value}"`);
+      }
+      return { type: "not", left: parsePrimary() };
+    }
+    throw new Error(`[BooleanAlgebra] Unexpected token "${t.type}"`);
+  }
+  function parseExpr(minPrec) {
+    let left = parsePrimary();
+    while (true) {
+      const t = peek();
+      if (!t || t.type !== "op") break;
+      const opName = normalizeOperator(t.value);
+      if (opName === "NOT") break;
+      const prec = precedence(opName);
+      if (prec < minPrec) break;
+      next();
+      const right = parseExpr(prec + 1);
+      const type = opName === "AND" ? "and" : opName === "OR" ? "or" : opName === "XOR" ? "xor" : opName === "NAND" ? "nand" : opName === "NOR" ? "nor" : "xnor";
+      left = { type, left, right };
+    }
+    return left;
+  }
+  const ast = parseExpr(0);
+  if (idx < tokens.length) {
+    throw new Error("[BooleanAlgebra] Unexpected trailing tokens");
+  }
+  return ast;
+}
+function evalAst(ast, env) {
+  switch (ast.type) {
+    case "const":
+      return Boolean(ast.value);
+    case "var": {
+      const v = (env == null ? void 0 : env[ast.name]) ?? false;
+      return toBool(v);
+    }
+    case "not":
+      return !evalAst(ast.left, env);
+    case "and":
+      return evalAst(ast.left, env) && evalAst(ast.right, env);
+    case "nand":
+      return !(evalAst(ast.left, env) && evalAst(ast.right, env));
+    case "or":
+      return evalAst(ast.left, env) || evalAst(ast.right, env);
+    case "nor":
+      return !(evalAst(ast.left, env) || evalAst(ast.right, env));
+    case "xor": {
+      const a = evalAst(ast.left, env);
+      const b = evalAst(ast.right, env);
+      return a && !b || !a && b;
+    }
+    case "xnor": {
+      const a = evalAst(ast.left, env);
+      const b = evalAst(ast.right, env);
+      return a === b;
+    }
+    default:
+      throw new Error(`[BooleanAlgebra] Unknown AST node type "${ast.type}"`);
+  }
+}
+function collectVars(ast, out) {
+  if (!ast) return;
+  if (ast.type === "var" && ast.name) out.add(ast.name);
+  if (ast.left) collectVars(ast.left, out);
+  if (ast.right) collectVars(ast.right, out);
+}
+function grayOrder(n) {
+  const size = 1 << n;
+  const out = new Array(size);
+  for (let i = 0; i < size; i++) {
+    out[i] = i ^ i >> 1;
+  }
+  return out;
+}
+class BooleanAlgebra {
+  /**
+   * Basic gates.
+   * @param {boolean|number} a
+   * @param {boolean|number} b
+   * @returns {boolean}
+   */
+  static and(a, b) {
+    return toBool(a) && toBool(b);
+  }
+  /**
+   * @param {boolean|number} a
+   * @param {boolean|number} b
+   * @returns {boolean}
+   */
+  static nand(a, b) {
+    return !(toBool(a) && toBool(b));
+  }
+  /**
+   * @param {boolean|number} a
+   * @param {boolean|number} b
+   * @returns {boolean}
+   */
+  static or(a, b) {
+    return toBool(a) || toBool(b);
+  }
+  /**
+   * @param {boolean|number} a
+   * @param {boolean|number} b
+   * @returns {boolean}
+   */
+  static nor(a, b) {
+    return !(toBool(a) || toBool(b));
+  }
+  /**
+   * @param {boolean|number} a
+   * @param {boolean|number} b
+   * @returns {boolean}
+   */
+  static xor(a, b) {
+    const aa = toBool(a);
+    const bb = toBool(b);
+    return aa && !bb || !aa && bb;
+  }
+  /**
+   * @param {boolean|number} a
+   * @param {boolean|number} b
+   * @returns {boolean}
+   */
+  static xnor(a, b) {
+    return toBool(a) === toBool(b);
+  }
+  /**
+   * @param {boolean|number} a
+   * @returns {boolean}
+   */
+  static not(a) {
+    return !toBool(a);
+  }
+  /**
+   * Parse an expression string into an AST.
+   *
+   * Supported operators:
+   * - NOT: `!`, `~`, `¬`, `NOT`
+   * - AND: `&`, `∧`, `AND`
+   * - OR: `|`, `∨`, `OR`
+   * - XOR: `^`, `⊕`, `XOR`
+   * - NAND/NOR/XNOR as words (case-insensitive)
+   *
+   * Constants: `0/1`, `false/true` (case-insensitive)
+   *
+   * @param {string} expr
+   * @returns {BooleanAst}
+   */
+  static parse(expr) {
+    return parseTokens(tokenize(expr));
+  }
+  /**
+   * Evaluate an expression string or AST against an environment.
+   * @param {string|BooleanAst} expr
+   * @param {BooleanEnv} env
+   * @returns {boolean}
+   */
+  static evaluate(expr, env = {}) {
+    const ast = typeof expr === "string" ? BooleanAlgebra.parse(expr) : expr;
+    return evalAst(ast, env);
+  }
+  /**
+   * Get sorted variable names used by an expression.
+   * @param {string|BooleanAst} expr
+   * @returns {string[]}
+   */
+  static variables(expr) {
+    const ast = typeof expr === "string" ? BooleanAlgebra.parse(expr) : expr;
+    const vars = /* @__PURE__ */ new Set();
+    collectVars(ast, vars);
+    return [...vars].sort((a, b) => a.localeCompare(b));
+  }
+  /**
+   * Gray-code ordering for n bits.
+   * @param {number} n
+   * @returns {number[]}
+   */
+  static grayCode(n) {
+    return grayOrder(n);
+  }
+  /**
+   * Build a truth table for an expression.
+   * @param {string|BooleanAst} expr
+   * @param {string[]} [variables] - Optional variable ordering. If omitted, derived from expression.
+   * @param {{ order?: "binary"|"gray" }} [options]
+   * @returns {{
+   *  variables: string[],
+   *  order: "binary"|"gray",
+   *  rows: Array<{ index: number, inputs: Record<string, boolean>, output: boolean }>
+   * }}
+   */
+  static truthTable(expr, variables, options = {}) {
+    const ast = typeof expr === "string" ? BooleanAlgebra.parse(expr) : expr;
+    const vars = variables && variables.length > 0 ? [...variables] : BooleanAlgebra.variables(ast);
+    const n = vars.length;
+    const size = 1 << n;
+    const order = options.order === "gray" ? "gray" : "binary";
+    const indices = order === "gray" ? grayOrder(n) : Array.from({ length: size }, (_, i) => i);
+    const rows = indices.map((idx) => {
+      const inputs = {};
+      for (let bit = 0; bit < n; bit++) {
+        const mask = 1 << n - 1 - bit;
+        inputs[vars[bit]] = Boolean(idx & mask);
+      }
+      return {
+        index: idx,
+        inputs,
+        output: evalAst(ast, inputs)
+      };
+    });
+    return { variables: vars, order, rows };
+  }
+}
 function flammEmbedding(r, rHorizon, M) {
   if (r <= rHorizon) return 0;
   return Math.sqrt(8 * M * (r - rHorizon));
@@ -16579,6 +16910,190 @@ class Sprite extends GameObject {
     return `[Sprite frames=${this.totalFrames} current=${this.currentFrame} playing=${this.isPlaying}]`;
   }
 }
+class SpriteSheet extends Sprite {
+  /**
+   * Creates a new SpriteSheet
+   * @param {Game} game - The game instance
+   * @param {Object} options - Configuration options
+   * @param {string} options.src - URL/path to the spritesheet image
+   * @param {number} options.frameWidth - Width of each frame in pixels
+   * @param {number} options.frameHeight - Height of each frame in pixels
+   * @param {number} options.columns - Number of columns in the spritesheet
+   * @param {number} options.rows - Number of rows in the spritesheet
+   * @param {number} [options.frameCount] - Total frames (defaults to columns * rows)
+   * @param {number} [options.startFrame=0] - First frame index to use
+   * @param {number} [options.frameRate=12] - Frames per second
+   * @param {boolean} [options.loop=true] - Whether to loop the animation
+   * @param {boolean} [options.autoPlay=false] - Whether to start playing automatically
+   * @param {boolean} [options.smoothing=false] - Image smoothing (false for pixel art)
+   */
+  constructor(game, options = {}) {
+    super(game, {
+      frameRate: options.frameRate || 12,
+      loop: options.loop !== void 0 ? options.loop : true,
+      autoPlay: false,
+      // Don't autoplay until loaded
+      ...options
+    });
+    this._src = options.src;
+    this._frameWidth = options.frameWidth;
+    this._frameHeight = options.frameHeight;
+    this._columns = options.columns;
+    this._rows = options.rows;
+    this._frameCount = options.frameCount || options.columns * options.rows;
+    this._startFrame = options.startFrame || 0;
+    this._smoothing = options.smoothing !== void 0 ? options.smoothing : false;
+    this._autoPlayAfterLoad = options.autoPlay || false;
+    this._loaded = false;
+    this._loading = false;
+    this._image = null;
+    this._frameCanvases = [];
+    this.width = this._frameWidth;
+    this.height = this._frameHeight;
+  }
+  /**
+   * Static factory method that creates and loads a SpriteSheet
+   * @param {Game} game - The game instance
+   * @param {Object} options - Configuration options (same as constructor)
+   * @returns {Promise<SpriteSheet>} Loaded SpriteSheet instance
+   */
+  static async create(game, options) {
+    const sheet = new SpriteSheet(game, options);
+    await sheet.load();
+    return sheet;
+  }
+  /**
+   * Loads the spritesheet image and creates frame shapes
+   * @returns {Promise<SpriteSheet>} This instance for chaining
+   */
+  async load() {
+    if (this._loaded || this._loading) {
+      return this;
+    }
+    this._loading = true;
+    try {
+      this._image = await this._loadImage(this._src);
+      await this._sliceFrames();
+      this._loaded = true;
+      this._loading = false;
+      if (this._autoPlayAfterLoad) {
+        this.play();
+      }
+      return this;
+    } catch (error) {
+      this._loading = false;
+      console.error("SpriteSheet.load failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Loads an image from a URL
+   * @private
+   * @param {string} src - Image URL
+   * @returns {Promise<HTMLImageElement>}
+   */
+  _loadImage(src) {
+    return new Promise((resolve, reject) => {
+      const img = new Image();
+      img.onload = () => resolve(img);
+      img.onerror = (e) => reject(new Error(`Failed to load image: ${src}`));
+      img.src = src;
+    });
+  }
+  /**
+   * Slices the spritesheet into individual frame canvases
+   * @private
+   */
+  async _sliceFrames() {
+    const { _image: img, _frameWidth: fw, _frameHeight: fh, _columns: cols } = this;
+    this.clearFrames();
+    this._frameCanvases = [];
+    for (let i = this._startFrame; i < this._startFrame + this._frameCount; i++) {
+      const col = i % cols;
+      const row = Math.floor(i / cols);
+      const sx = col * fw;
+      const sy = row * fh;
+      const frameCanvas = document.createElement("canvas");
+      frameCanvas.width = fw;
+      frameCanvas.height = fh;
+      const ctx = frameCanvas.getContext("2d");
+      ctx.imageSmoothingEnabled = this._smoothing;
+      ctx.drawImage(img, sx, sy, fw, fh, 0, 0, fw, fh);
+      this._frameCanvases.push(frameCanvas);
+      const frameShape = new ImageShape(frameCanvas, {
+        width: fw,
+        height: fh,
+        anchor: "center",
+        smoothing: this._smoothing
+      });
+      this.addFrame(frameShape);
+    }
+  }
+  /**
+   * Gets whether the spritesheet is loaded
+   * @returns {boolean}
+   */
+  get loaded() {
+    return this._loaded;
+  }
+  /**
+   * Gets whether the spritesheet is currently loading
+   * @returns {boolean}
+   */
+  get loading() {
+    return this._loading;
+  }
+  /**
+   * Gets the frame width
+   * @returns {number}
+   */
+  get frameWidth() {
+    return this._frameWidth;
+  }
+  /**
+   * Gets the frame height
+   * @returns {number}
+   */
+  get frameHeight() {
+    return this._frameHeight;
+  }
+  /**
+   * Gets the number of columns in the spritesheet
+   * @returns {number}
+   */
+  get columns() {
+    return this._columns;
+  }
+  /**
+   * Gets the number of rows in the spritesheet
+   * @returns {number}
+   */
+  get rows() {
+    return this._rows;
+  }
+  /**
+   * Override update to skip if not loaded
+   * @param {number} dt - Delta time
+   */
+  update(dt) {
+    if (!this._loaded) return;
+    super.update(dt);
+  }
+  /**
+   * Override draw to skip if not loaded
+   */
+  draw() {
+    if (!this._loaded) return;
+    super.draw();
+  }
+  /**
+   * Creates a string representation
+   * @returns {string}
+   */
+  toString() {
+    return `[SpriteSheet src="${this._src}" frames=${this._frameCount} loaded=${this._loaded}]`;
+  }
+}
 class Text extends GameObjectShapeWrapper {
   /**
    * Create a Text component
@@ -25473,6 +25988,7 @@ export {
   Arc,
   Arrow,
   BezierShape,
+  BooleanAlgebra,
   Button,
   Camera2D,
   Camera3D,
@@ -25559,6 +26075,7 @@ export {
   Sphere,
   Sphere3D,
   Sprite,
+  SpriteSheet,
   Square,
   Star,
   StateMachine,