windsor-bot 0.1.6 → 0.1.8

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/dist/commands/wordsearch.js

@@ -1,104 +1,126 @@
+import { readdir, readFile, unlink, writeFile } from 'fs/promises';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { tmpdir } from 'os';
+import { Jimp, JimpMime, loadFont, measureText } from 'jimp';
 import { tryExecCommandFunction } from './util.js';
-const THEMES = [
-    {
-        name: 'Animals',
-        words: ['CAT', 'DOG', 'BIRD', 'FISH', 'LION', 'BEAR', 'FROG', 'DUCK', 'WOLF', 'DEER'],
-    },
-    {
-        name: 'Fruits',
-        words: ['APPLE', 'MANGO', 'GRAPE', 'PEACH', 'PLUM', 'PEAR', 'LIME', 'KIWI', 'FIG', 'DATE'],
-    },
-    {
-        name: 'Colors',
-        words: ['RED', 'BLUE', 'GREEN', 'PINK', 'GOLD', 'TEAL', 'CORAL', 'TAN', 'IVORY', 'NAVY'],
-    },
-    {
-        name: 'Space',
-        words: ['STAR', 'MOON', 'SUN', 'MARS', 'EARTH', 'VENUS', 'COMET', 'ORBIT', 'NOVA', 'RING'],
-    },
-    {
-        name: 'Food',
-        words: ['PIZZA', 'TACO', 'SOUP', 'CAKE', 'RICE', 'BREAD', 'PASTA', 'SALAD', 'CHIP', 'PIE'],
-    },
-];
-const SIZE = 15;
-function makeGrid() {
-    return Array.from({ length: SIZE }, () => Array(SIZE).fill(''));
-}
-const DIRECTIONS = [
-    [0, 1], [1, 0], [1, 1], [1, -1],
-    [0, -1], [-1, 0], [-1, -1], [-1, 1],
-];
-function placeWord(grid, word) {
-    const shuffledDirs = [...DIRECTIONS].sort(() => Math.random() - 0.5);
-    for (const [dr, dc] of shuffledDirs) {
-        for (let attempt = 0; attempt < 30; attempt++) {
-            const row = Math.floor(Math.random() * SIZE);
-            const col = Math.floor(Math.random() * SIZE);
-            let fits = true;
-            for (let i = 0; i < word.length; i++) {
-                const r = row + dr * i;
-                const c = col + dc * i;
-                if (r < 0 || r >= SIZE || c < 0 || c >= SIZE) {
-                    fits = false;
-                    break;
-                }
-                const cell = grid[r]?.[c];
-                if (cell && cell !== word[i]) {
-                    fits = false;
-                    break;
-                }
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PUZZLE_DIR = join(__dirname, '../../assets/wordsearches');
+const FONT_DIR = new URL('../../node_modules/@jimp/plugin-print/dist/fonts/open-sans/', import.meta.url).pathname;
+const WORDSEARCH_FONT = `${FONT_DIR}open-sans-32-black/open-sans-32-black.fnt`;
+const IMAGE_WIDTH = 560;
+const IMAGE_HEIGHT = 600;
+const GRID_SIZE = 510;
+const GRID_LEFT = (IMAGE_WIDTH - GRID_SIZE) / 2;
+const GRID_TOP = 68;
+const CELL_SIZE = GRID_SIZE / 15;
+let puzzlesPromise;
+async function loadPuzzles() {
+    const files = (await readdir(PUZZLE_DIR)).filter(file => file.endsWith('.txt')).sort();
+    const puzzles = [];
+    for (const file of files) {
+        const text = await readFile(join(PUZZLE_DIR, file), 'utf8');
+        const lines = text.split(/\r?\n/);
+        let theme = '';
+        let words = [];
+        let grid = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i]?.trim() ?? '';
+            if (line.startsWith('THEME ')) {
+                theme = line.slice('THEME '.length).trim();
+            }
+            else if (line.startsWith('WORDS ')) {
+                words = line.slice('WORDS '.length).split(',').filter(Boolean);
             }
-            if (fits) {
-                for (let i = 0; i < word.length; i++) {
-                    const r = row + dr * i;
-                    const c = col + dc * i;
-                    if (grid[r])
-                        grid[r][c] = word[i];
+            else if (line === 'GRID') {
+                const gridLines = [];
+                for (let j = i + 1; j < lines.length; j++) {
+                    const row = lines[j]?.trim() ?? '';
+                    if (row === 'END')
+                        break;
+                    if (row)
+                        gridLines.push(row);
                 }
-                return true;
+                grid = gridLines;
+                break;
             }
         }
+        if (!theme || words.length === 0 || grid.length === 0) {
+            throw new Error(`Invalid wordsearch asset: ${file}`);
+        }
+        puzzles.push({ theme, words, grid });
     }
-    return false;
+    if (puzzles.length === 0)
+        throw new Error('No wordsearch assets found');
+    return puzzles;
 }
-const LETTERS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
-function fillGrid(grid) {
-    for (let r = 0; r < SIZE; r++) {
-        for (let c = 0; c < SIZE; c++) {
-            if (!grid[r]?.[c]) {
-                if (grid[r])
-                    grid[r][c] = LETTERS[Math.floor(Math.random() * 26)] ?? 'A';
-            }
+async function renderWordsearchImage(puzzle) {
+    const font = await loadFont(WORDSEARCH_FONT);
+    const image = new Jimp({ width: IMAGE_WIDTH, height: IMAGE_HEIGHT, color: 0xffffffff });
+    const title = `Word Search - ${puzzle.theme}`;
+    image.print({
+        font,
+        x: (IMAGE_WIDTH - measureText(font, title)) / 2,
+        y: 22,
+        text: title,
+    });
+    const rows = puzzle.grid.map(row => row.split(/\s+/));
+    if (rows.length !== 15 || rows.some(row => row.length !== 15)) {
+        throw new Error(`Invalid ${puzzle.theme} wordsearch grid`);
+    }
+    for (let row = 0; row <= 15; row++) {
+        const y = Math.round(GRID_TOP + row * CELL_SIZE);
+        for (let x = GRID_LEFT; x <= GRID_LEFT + GRID_SIZE; x++) {
+            image.setPixelColor(0x000000ff, x, y);
         }
     }
-}
-function renderGrid(grid) {
-    return grid.map(row => row.join(' '));
+    for (let col = 0; col <= 15; col++) {
+        const x = Math.round(GRID_LEFT + col * CELL_SIZE);
+        for (let y = GRID_TOP; y <= GRID_TOP + GRID_SIZE; y++) {
+            image.setPixelColor(0x000000ff, x, y);
+        }
+    }
+    for (let row = 0; row < 15; row++) {
+        const cells = rows[row];
+        if (!cells)
+            throw new Error(`Missing wordsearch row ${row + 1}`);
+        for (let col = 0; col < 15; col++) {
+            const text = cells[col];
+            if (!text)
+                throw new Error(`Missing wordsearch cell ${row + 1},${col + 1}`);
+            image.print({
+                font,
+                x: GRID_LEFT + col * CELL_SIZE + (CELL_SIZE - measureText(font, text)) / 2,
+                y: GRID_TOP + row * CELL_SIZE + 1,
+                text,
+            });
+        }
+    }
+    const imagePath = join(tmpdir(), `windsor-wordsearch-${process.pid}-${Date.now()}.png`);
+    await writeFile(imagePath, await image.getBuffer(JimpMime.png));
+    return imagePath;
 }
 async function printWordsearchWorker(_args, ctx) {
-    const theme = THEMES[Math.floor(Math.random() * THEMES.length)];
-    if (!theme)
-        throw new Error('No themes available');
-    const grid = makeGrid();
-    const placed = [];
-    for (const word of theme.words) {
-        if (placeWord(grid, word))
-            placed.push(word);
+    puzzlesPromise ??= loadPuzzles();
+    const puzzles = await puzzlesPromise;
+    const puzzle = puzzles[Math.floor(Math.random() * puzzles.length)];
+    if (!puzzle)
+        throw new Error('No wordsearch puzzle available');
+    const imagePath = await renderWordsearchImage(puzzle);
+    try {
+        const job = {
+            urls: [],
+            lines: [
+                'Find these words:',
+                puzzle.words.join('  '),
+            ],
+            iconPath: imagePath,
+        };
+        await ctx.printJob(job);
+    }
+    finally {
+        await unlink(imagePath);
     }
-    fillGrid(grid);
-    const lines = [
-        ...renderGrid(grid),
-        '',
-        'Find these words:',
-        placed.join('  '),
-    ];
-    const job = {
-        urls: [],
-        header: `Word Search: ${theme.name}`,
-        lines,
-    };
-    await ctx.printJob(job);
     return {
         kind: "pass"
     };

package/dist/reactions.js

@@ -1,5 +1,6 @@
 export const Reaction = {
     ok: "✅",
     what: "❓",
-    fail: "❌"
+    fail: "❌",
+    thinking: "🧠"
 };