puzzles.js

/**
 * Puzzle Generator for Circuitle
 * Handles infinite puzzle generation and daily seeding
 */

const PuzzleGenerator = (function() {
  
  // Seedable RNG
  function mulberry32(a) {
    return function() {
      var t = a += 0x6D2B79F5;
      t = Math.imul(t ^ t >>> 15, t | 1);
      t ^= t + Math.imul(t ^ t >>> 7, t | 61);
      return ((t ^ t >>> 14) >>> 0) / 4294967296;
    }
  }

  const types = [
    'equivalent_r',
    'equivalent_c',
    'equivalent_l',
    'rc_time_constant',
    'rl_time_constant',
    'lc_oscillation',
    'capacitor_energy',
    'inductor_energy'
  ];

  function generate(seed) {
    const random = mulberry32(seed);
    const type = types[Math.floor(random() * types.length)];
    
    let puzzle = {
      type: type,
      id: seed,
      values: {},
      title: "",
      question: "",
      answer: 0,
      unit: ""
    };

    switch(type) {
      case 'equivalent_r':
        const r1 = Math.floor(random() * 90) + 10;
        const r2 = Math.floor(random() * 90) + 10;
        const iso = random() > 0.5;
        puzzle.values = { r1, r2, config: iso ? 'series' : 'parallel' };
        puzzle.title = iso ? "Series Resistors" : "Parallel Resistors";
        puzzle.question = "Find the equivalent resistance (R<sub>eq</sub>)";
        puzzle.answer = iso ? (r1 + r2) : (r1 * r2) / (r1 + r2);
        puzzle.unit = "Ω";
        break;

      case 'equivalent_c':
        const c1 = (Math.floor(random() * 15) + 1) * 10;
        const c2 = (Math.floor(random() * 15) + 1) * 10;
        const isoC = random() > 0.5;
        puzzle.values = { c1, c2, config: isoC ? 'parallel' : 'series' };
        puzzle.title = isoC ? "Parallel Capacitors" : "Series Capacitors";
        puzzle.question = "Find the equivalent capacitance (C<sub>eq</sub>)";
        puzzle.answer = isoC ? (c1 + c2) : (c1 * c2) / (c1 + c2);
        puzzle.unit = "μF";
        break;

      case 'equivalent_l':
        const l1 = (Math.floor(random() * 9) + 1) * 10;
        const l2 = (Math.floor(random() * 9) + 1) * 10;
        const isoL = random() > 0.5;
        puzzle.values = { l: l1, l2: l2, config: isoL ? 'series' : 'parallel' };
        puzzle.title = isoL ? "Series Inductors" : "Parallel Inductors";
        puzzle.question = "Find the equivalent inductance (L<sub>eq</sub>)";
        puzzle.answer = isoL ? (l1 + l2) : (l1 * l2) / (l1 + l2);
        puzzle.unit = "mH";
        break;

      case 'rc_time_constant':
        const rRC = Math.floor(random() * 9) + 1;
        const cRC = (Math.floor(random() * 9) + 1) * 10;
        puzzle.values = { r: rRC, c: cRC };
        puzzle.title = "RC Time Constant";
        puzzle.question = "Calculate the time constant (&tau; = RC)";
        puzzle.answer = (rRC * 1000) * (cRC / 1000000);
        puzzle.unit = "s";
        break;

      case 'rl_time_constant':
        const rRL = (Math.floor(random() * 5) + 1) * 10;
        const lRL = (Math.floor(random() * 5) + 1) * 100;
        puzzle.values = { r: rRL, l: lRL };
        puzzle.title = "RL Time Constant";
        puzzle.question = "Calculate the time constant (&tau; = L/R)";
        puzzle.answer = (lRL / 1000) / rRL; 
        puzzle.unit = "s";
        break;

      case 'lc_oscillation':
        const lLC = (Math.floor(random() * 10) + 1);
        const cLC = (Math.floor(random() * 10) + 1);
        puzzle.values = { l: lLC, c: cLC };
        puzzle.title = "LC Oscillation";
        puzzle.question = "Find the resonant frequency f = 1 / (2&pi;&radic;LC)";
        const L = lLC / 1000;
        const C = cLC / 1000000;
        puzzle.answer = 1 / (2 * Math.PI * Math.sqrt(L * C));
        puzzle.unit = "Hz";
        break;

      case 'capacitor_energy':
        const cE = (Math.floor(random() * 20) + 1) * 5;
        const vE = (Math.floor(random() * 12) + 1) * 2;
        puzzle.values = { c: cE, v: vE };
        puzzle.title = "Capacitor Energy";
        puzzle.question = "Energy stored in the capacitor (U = &frac12;CV&sup2;)";
        puzzle.answer = 0.5 * (cE / 1000000) * (vE * vE) * 1000;
        puzzle.unit = "mJ";
        break;

      case 'inductor_energy':
        const lE = (Math.floor(random() * 10) + 1) * 10;
        const iE = (Math.floor(random() * 5) + 1);
        puzzle.values = { l: lE, i: iE };
        puzzle.title = "Inductor Energy";
        puzzle.question = "Energy stored in the inductor (U = &frac12;LI&sup2;)";
        puzzle.answer = 0.5 * (lE / 1000) * (iE * iE) * 1000;
        puzzle.unit = "mJ";
        break;

      default:
        const rFallback = 100;
        puzzle.type = 'equivalent_r';
        puzzle.values = { r1: rFallback, r2: rFallback, config: 'series' };
        puzzle.title = "Simple Resistance";
        puzzle.answer = 200;
        puzzle.unit = "Ω";
    }

    return puzzle;
  }

  function getDailySeed() {
    const d = new Date();
    return d.getFullYear() * 10000 + (d.getMonth() + 1) * 100 + d.getDate();
  }

  return {
    generate,
    getDailySeed
  };
})();

window.PuzzleGenerator = PuzzleGenerator;