windsor-bot 0.1.7 → 0.1.8

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: "🧠"
 };