windsor-bot 0.1.6 → 0.1.7

package/dist/commands/sudoku.js

@@ -1,74 +1,106 @@
+import { readFile, unlink, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { Jimp, JimpMime, loadFont, measureText } from 'jimp';
 import { tryExecCommandFunction } from './util.js';
-function generateSudoku(difficulty) {
-    // Start with a solved grid
-    const base = [
-        [5, 3, 4, 6, 7, 8, 9, 1, 2],
-        [6, 7, 2, 1, 9, 5, 3, 4, 8],
-        [1, 9, 8, 3, 4, 2, 5, 6, 7],
-        [8, 5, 9, 7, 6, 1, 4, 2, 3],
-        [4, 2, 6, 8, 5, 3, 7, 9, 1],
-        [7, 1, 3, 9, 2, 4, 8, 5, 6],
-        [9, 6, 1, 5, 3, 7, 2, 8, 4],
-        [2, 8, 7, 4, 1, 9, 6, 3, 5],
-        [3, 4, 5, 2, 8, 6, 1, 7, 9],
-    ];
-    // Number of cells to remove based on difficulty
-    const removes = {
-        '': 35,
-        kid: 20,
-        easy: 35,
-        medium: 45,
-        hard: 55,
-    };
-    const toRemove = removes[difficulty] ?? 35;
-    // Shuffle positions and remove
-    const positions = Array.from({ length: 81 }, (_, i) => i);
-    for (let i = positions.length - 1; i > 0; i--) {
-        const j = Math.floor(Math.random() * (i + 1));
-        const tmp = positions[i];
-        positions[i] = positions[j];
-        positions[j] = tmp;
-    }
-    const grid = base.map(row => [...row]);
-    for (let i = 0; i < toRemove; i++) {
-        const pos = positions[i];
-        if (pos === undefined)
-            break;
-        const row = Math.floor(pos / 9);
-        const col = pos % 9;
-        if (grid[row])
-            grid[row][col] = 0;
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const SUDOKU_DIR = join(__dirname, '../../assets');
+const puzzleCache = new Map();
+const FONT_DIR = new URL('../../node_modules/@jimp/plugin-print/dist/fonts/open-sans/', import.meta.url).pathname;
+const SUDOKU_FONT = `${FONT_DIR}open-sans-32-black/open-sans-32-black.fnt`;
+const IMAGE_WIDTH = 560;
+const IMAGE_HEIGHT = 640;
+const GRID_SIZE = 504;
+const GRID_LEFT = (IMAGE_WIDTH - GRID_SIZE) / 2;
+const GRID_TOP = 98;
+const CELL_SIZE = GRID_SIZE / 9;
+async function loadSudokus(difficulty) {
+    let puzzles = puzzleCache.get(difficulty);
+    if (!puzzles) {
+        puzzles = readFile(join(SUDOKU_DIR, `sudoku-${difficulty}.txt`), 'utf8').then(contents => {
+            const lines = contents.split(/\r?\n/).filter(Boolean);
+            return lines.map((puzzle, index) => {
+                if (puzzle.length !== 81 || /[^.1-9]/.test(puzzle)) {
+                    throw new Error(`Invalid Sudoku puzzle at ${difficulty} asset line ${index + 1}`);
+                }
+                return Array.from({ length: 9 }, (_, row) => Array.from(puzzle.slice(row * 9, row * 9 + 9), cell => cell === '.' ? 0 : Number(cell)));
+            });
+        });
+        puzzleCache.set(difficulty, puzzles);
     }
-    return grid;
+    return puzzles;
 }
-function renderSudokuGrid(grid) {
-    const lines = [];
-    lines.push('┌───────┬───────┬───────┐');
+async function renderSudokuImage(grid, difficulty) {
+    const font = await loadFont(SUDOKU_FONT);
+    const image = new Jimp({ width: IMAGE_WIDTH, height: IMAGE_HEIGHT, color: 0xffffffff });
+    const title = `Sudoku - ${difficulty}`;
+    image.print({
+        font,
+        x: (IMAGE_WIDTH - measureText(font, title)) / 2,
+        y: 24,
+        text: title,
+    });
+    for (let row = 0; row < 10; row++) {
+        const thickness = row % 3 === 0 ? 4 : 1;
+        const y = Math.round(GRID_TOP + row * CELL_SIZE);
+        for (let offset = 0; offset < thickness; offset++) {
+            for (let x = GRID_LEFT; x <= GRID_LEFT + GRID_SIZE; x++) {
+                image.setPixelColor(0x000000ff, x, y + offset);
+            }
+        }
+    }
+    for (let col = 0; col < 10; col++) {
+        const thickness = col % 3 === 0 ? 4 : 1;
+        const x = Math.round(GRID_LEFT + col * CELL_SIZE);
+        for (let offset = 0; offset < thickness; offset++) {
+            for (let y = GRID_TOP; y <= GRID_TOP + GRID_SIZE; y++) {
+                image.setPixelColor(0x000000ff, x + offset, y);
+            }
+        }
+    }
     for (let row = 0; row < 9; row++) {
-        const cells = grid[row] ?? [];
-        const r1 = cells.slice(0, 3).map(c => c === 0 ? '·' : String(c)).join(' ');
-        const r2 = cells.slice(3, 6).map(c => c === 0 ? '·' : String(c)).join(' ');
-        const r3 = cells.slice(6, 9).map(c => c === 0 ? '·' : String(c)).join(' ');
-        lines.push(`│ ${r1} │ ${r2} │ ${r3} │`);
-        if (row === 2 || row === 5) {
-            lines.push('├───────┼───────┼───────┤');
+        const cells = grid[row];
+        if (!cells)
+            throw new Error(`Missing Sudoku row ${row + 1}`);
+        for (let col = 0; col < 9; col++) {
+            const value = cells[col];
+            if (value === undefined || value === 0)
+                continue;
+            const text = String(value);
+            const x = GRID_LEFT + col * CELL_SIZE + (CELL_SIZE - measureText(font, text)) / 2;
+            image.print({
+                font,
+                x,
+                y: GRID_TOP + row * CELL_SIZE + 9,
+                text,
+            });
         }
     }
-    lines.push('└───────┴───────┴───────┘');
-    return lines;
+    const imagePath = join(tmpdir(), `windsor-sudoku-${process.pid}-${Date.now()}.png`);
+    await writeFile(imagePath, await image.getBuffer(JimpMime.png));
+    return imagePath;
 }
 async function printSudokuWorker(args, ctx) {
     // !TODO: Implement good command parsing
     const difficulty = args;
     const diff = difficulty || 'easy';
-    const grid = generateSudoku(diff);
-    const gridLines = renderSudokuGrid(grid);
-    const job = {
-        urls: [],
-        header: `Sudoku (${diff})`,
-        lines: gridLines,
-    };
-    await ctx.printJob(job);
+    const puzzles = await loadSudokus(diff);
+    const grid = puzzles[Math.floor(Math.random() * puzzles.length)];
+    if (!grid)
+        throw new Error(`No Sudoku puzzles available for ${diff}`);
+    const imagePath = await renderSudokuImage(grid, diff);
+    try {
+        const job = {
+            urls: [],
+            lines: [],
+            iconPath: imagePath,
+        };
+        await ctx.printJob(job);
+    }
+    finally {
+        await unlink(imagePath);
+    }
     return {
         kind: "pass"
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "windsor-bot",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Self-hosted Discord bot automation for household list and todo printing",
   "type": "module",
   "main": "dist/index.js",