""" generate_levels.py — генератор уровней филвордов (word search). 🔧 НОВОЕ (07.10.2026): Первая версия. Порт алгоритма с JS (filword-gen.js): слова-змейки, 4 направления (вверх/вниз/влево/вправо), без диагоналей. Поле n×n полностью заполнено, слова не пересекаются. 🔧 ОБНОВЛЕНО (09.10.2026): пересоздание 5–8. • GRID_SIZES = [5, 6, 7, 8] — 4×4, 9×9, 10×10 не трогаем. • LEVELS_PER_SIZE — dict: {5: 25, 6: 50, 7: 200, 8: 300}. • Перед генерацией удаляем все уровни размеров 5–8. Логика: 1. Читает все слова из csv_words (A1+A2+B1), DISTINCT по word_pl. Фильтр: длина 3..10 Unicode-символов. 2. Группирует по длине. 3. Для каждого размера n в [5, 6, 7, 8]: - удаляет существующие уровни этого размера; - генерирует LEVELS_PER_SIZE[n] уровней; - level_number — сквозной, начиная с MAX(level_number)+1 из БД; - level = 'common' (не A1/A2/B1); - game_type = 'wordsearch'; - is_active = TRUE; - created_by = NULL (автогенерированный). 4. Сохраняет в levels + level_words. 🔧 ФИКС (07.10.2026): random_start_cell — раньше solve() всегда начинал с клетки (0,0), из-за чего во всех уровнях первое слово было "прибито" к верхнему левому углу. Теперь старт — случайная свободная клетка. Запуск: cd ~/filwordspl/backend source venv/bin/activate python scripts/generate_levels.py Требования: Python 3.12, asyncpg. Пишет прогресс в stdout. ON CONFLICT DO NOTHING на уровнях. Не трогает уровни с created_by IS NOT NULL. """ import asyncio import logging import random import sys from pathlib import Path # Разрешаем запуск из scripts/ — добавляем корень backend в sys.path. BACKEND_ROOT = Path(__file__).resolve().parent.parent if str(BACKEND_ROOT) not in sys.path: sys.path.insert(0, str(BACKEND_ROOT)) from database import get_pool # noqa: E402 logger = logging.getLogger(__name__) # ============ Конфигурация ============ # 🔧 ОБНОВЛЕНО (09.10.2026): пересоздаём только размеры 5–8. # 4×4, 9×9, 10×10 не трогаем. GRID_SIZES = [5, 6, 7, 8] # 🔧 ОБНОВЛЕНО (09.10.2026): своё количество уровней на каждый размер. LEVELS_PER_SIZE = {5: 25, 6: 50, 7: 200, 8: 300} LEVEL_NAME = "common" GAME_TYPE = "wordsearch" MIN_WORD_LEN = 3 MAX_WORD_LEN = 10 # Максимальное количество попыток и шагов на один бэктрекинг. MAX_STEPS = 20000 ATTEMPTS = 200 # Диапазон seed (воспроизводимость). SEED_BASE = 20261007 # Пул слов из БД: все треки, все уровни. WORD_LEVELS = ("A1", "A2", "B1") # ============ Утилиты ============ def shuffle(arr: list, rnd: random.Random) -> list: """Fisher-Yates shuffle (как в JS).""" for i in range(len(arr) - 1, 0, -1): j = rnd.randrange(i + 1) arr[i], arr[j] = arr[j], arr[i] return arr def word_length(word: str) -> int: """Длина слова в Unicode-символах (ą, ł, ś и т.д. = 1 буква).""" return len(word) def group_by_length(words: list[str]) -> dict[int, list[str]]: """Группирует слова по длине. Возвращает {len: [words]}.""" res: dict[int, list[str]] = {} seen = set() for raw in words: w = raw.strip().upper() if not w or w in seen: continue seen.add(w) ln = word_length(w) res.setdefault(ln, []).append(w) return res # ============ Ядро: разбиение поля на змейки ============ def partition_grid( n: int, available: dict[int, int], rnd: random.Random, max_steps: int = MAX_STEPS, attempts: int = ATTEMPTS, ) -> list[list[list[int]]] | None: """ ШАГ 1. Разбивает n×n поле на пути-змейки. available: {длина: сколько слов такой длины доступно} Возвращает массив путей [[[r,c], ...], ...] или None. """ lengths = [ln for ln, cnt in available.items() if cnt > 0 and ln >= 2] if not lengths: return None max_len = max(lengths) total = n * n # ok[s] = можно ли набрать s клеток допустимыми длинами. ok = [False] * (total + 1) ok[0] = True for s in range(1, total + 1): ok[s] = any(s >= ln and ok[s - ln] for ln in lengths) if not ok[total]: return None dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)] for _attempt in range(attempts): grid = [[-1] * n for _ in range(n)] left = dict(available) paths: list[list[list[int]]] = [] steps = [0] # список, чтобы менять из вложенных функций def is_free(r: int, c: int) -> bool: return 0 <= r < n and 0 <= c < n and grid[r][c] == -1 def free_count(r: int, c: int) -> int: return sum(1 for dr, dc in dirs if is_free(r + dr, c + dc)) def regions_ok() -> bool: """Каждая связная область свободных клеток делится допустимыми длинами.""" seen = [[False] * n for _ in range(n)] for r0 in range(n): for c0 in range(n): if not is_free(r0, c0) or seen[r0][c0]: continue size = 0 stack = [(r0, c0)] seen[r0][c0] = True while stack: y, x = stack.pop() size += 1 for dr, dc in dirs: a, b = y + dr, x + dc if is_free(a, b) and not seen[a][b]: seen[a][b] = True stack.append((a, b)) if not ok[size]: return False return True def solve() -> bool: # 🔧 ФИКС (07.10.2026): random_start_cell — # раньше всегда начинали с (0,0) → все уровни с верхнего левого угла. # Теперь — случайная свободная клетка. free_cells = [ (r, c) for r in range(n) for c in range(n) if is_free(r, c) ] if not free_cells: return True # всё поле покрыто start = rnd.choice(free_cells) grid[start[0]][start[1]] = len(paths) target = lengths[rnd.randrange(len(lengths))] if extend([list(start)], target): return True grid[start[0]][start[1]] = -1 return False def extend(path: list[list[int]], target: int) -> bool: steps[0] += 1 if steps[0] > max_steps: return False ln = len(path) r, c = path[-1] def try_close() -> bool: if not (left.get(ln, 0) > 0): return False left[ln] -= 1 paths.append([list(p) for p in path]) if regions_ok() and solve(): return True paths.pop() left[ln] += 1 return False if ln >= target and try_close(): return True if ln >= max_len: return False # Соседи: сначала те, у которых меньше свободных соседей. nbs = [] for dr, dc in dirs: a, b = r + dr, c + dc if is_free(a, b): k = free_count(a, b) + rnd.random() * 1.5 nbs.append(((a, b), k)) nbs.sort(key=lambda x: x[1]) for (a, b), _ in nbs: grid[a][b] = len(paths) path.append([a, b]) if extend(path, target): return True path.pop() grid[a][b] = -1 if steps[0] > max_steps: return False if ln < target and try_close(): return True return False if solve(): return paths return None # ============ Ядро: строит уровень ============ def build_level( n: int, words_by_len: dict[int, list[str]], rnd: random.Random, ) -> dict | None: """ ШАГ 2. Разбивает поле и вписывает слова в змейки. Возвращает {size, letters: List[List[str]], words: [{word, cells}], } или None, если не удалось. """ available = {ln: len(words) for ln, words in words_by_len.items()} # Доступные длины ограничиваем 2..n*n, чтобы partition_grid не падал. max_cells = n * n available = {ln: cnt for ln, cnt in available.items() if 2 <= ln <= max_cells} if not available: return None paths = partition_grid(n, available, rnd) if not paths: return None pools: dict[int, list[str]] = {ln: shuffle(list(words), rnd) for ln, words in words_by_len.items()} letters = [[""] * n for _ in range(n)] words_out: list[dict] = [] for p in paths: pool = pools.get(len(p), []) if not pool: # Не должно случаться: partition_grid согласован с available. return None w = pool.pop() for i, ch in enumerate(w): r, c = p[i] letters[r][c] = ch words_out.append({"word": w, "cells": p}) return {"size": n, "letters": letters, "words": words_out} # ============ БД ============ # 🔧 НОВОЕ (09.10.2026): удаляем только уровни размеров 5–8. async def delete_levels_for_sizes(pool, sizes: list[int]) -> int: """Удаляет уровни указанных размеров. Возвращает число удалённых уровней.""" async with pool.acquire() as conn: async with conn.transaction(): deleted = await conn.fetchval(""" WITH del AS ( DELETE FROM levels WHERE grid_size = ANY($1::int[]) RETURNING 1 ) SELECT COUNT(*) FROM del """, sizes) return int(deleted or 0) async def fetch_words(pool) -> list[str]: """ Возвращает все слова из csv_words (A1+A2+B1), DISTINCT по word_pl. Фильтр: длина 3..10 Unicode-символов. """ async with pool.acquire() as conn: rows = await conn.fetch(""" SELECT DISTINCT word_pl FROM csv_words WHERE level_code = ANY($1::text[]) """, list(WORD_LEVELS)) raw_words = [r["word_pl"] for r in rows] # Фильтр по длине. filtered: list[str] = [] seen = set() for w in raw_words: if not w: continue wu = w.strip().upper() if not wu or wu in seen: continue ln = word_length(wu) if MIN_WORD_LEN <= ln <= MAX_WORD_LEN: filtered.append(wu) seen.add(wu) return filtered async def fetch_translations(pool, words: list[str]) -> dict[str, dict[str, str]]: """ Возвращает переводы: {word_pl: {ru, uk, en}}. Берём первую строку по каждому слову (DISTINCT). """ if not words: return {} async with pool.acquire() as conn: rows = await conn.fetch(""" SELECT DISTINCT ON (word_pl) word_pl, translation_ru, translation_uk, translation_en FROM csv_words WHERE level_code = ANY($1::text[]) AND word_pl = ANY($2::text[]) ORDER BY word_pl """, list(WORD_LEVELS), words) return { r["word_pl"]: { "ru": r["translation_ru"] or "", "uk": r["translation_uk"] or "", "en": r["translation_en"] or "", } for r in rows } async def fetch_max_level_number(pool) -> int: """Возвращает MAX(level_number) из levels или 0.""" async with pool.acquire() as conn: val = await conn.fetchval("SELECT COALESCE(MAX(level_number), 0) FROM levels") return int(val or 0) async def save_level( pool, level_number: int, grid_size: int, letters: list[list[str]], words: list[dict], translations: dict[str, dict[str, str]], ) -> bool: """ Сохраняет уровень в levels + level_words. level = 'common', game_type = 'wordsearch', is_active = TRUE, created_by = NULL. ON CONFLICT DO NOTHING на levels (UNIQUE (level, level_number)). Возвращает True, если уровень реально создан. """ import json as _json word_paths = {w["word"]: w["cells"] for w in words} async with pool.acquire() as conn: async with conn.transaction(): row = await conn.fetchrow(""" INSERT INTO levels (level_number, grid_size, game_type, level, grid_letters, word_paths, is_active, created_by, created_at) VALUES ($1, $2, $3, $4, $5, $6, TRUE, NULL, NOW()) ON CONFLICT (level, level_number) DO NOTHING RETURNING id """, level_number, grid_size, GAME_TYPE, LEVEL_NAME, _json.dumps(letters), _json.dumps(word_paths), ) if not row: return False level_id = row["id"] # level_words — вставляем построчно. for w in words: word_pl = w["word"] trans = translations.get(word_pl, {}) await conn.execute(""" INSERT INTO level_words (level_id, word_pl, translation_ru, translation_uk, translation_en, level) VALUES ($1, $2, $3, $4, $5, $6) """, level_id, word_pl, trans.get("ru", ""), trans.get("uk", ""), trans.get("en", ""), LEVEL_NAME, ) return True # ============ Main ============ async def main() -> None: logging.basicConfig( level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s", datefmt="%H:%M:%S", ) logger.info("=== Генерация уровней филвордов ===") pool = await get_pool() # 1. Слова logger.info("Читаю слова из csv_words...") all_words = await fetch_words(pool) logger.info(f"Всего слов 3..10 букв: {len(all_words)}") if not all_words: logger.error("Нет слов для генерации. Проверь csv_words.") return words_by_len = group_by_length(all_words) logger.info("Распределение по длинам:") for ln in sorted(words_by_len.keys()): logger.info(f" длина {ln}: {len(words_by_len[ln])} слов") # 2. MAX(level_number) max_level_number = await fetch_max_level_number(pool) logger.info(f"MAX(level_number) в БД: {max_level_number}") # 3. Переводы (берём все нужные слова сразу, чтобы не дёргать БД внутри цикла) logger.info("Читаю переводы...") translations = await fetch_translations(pool, all_words) logger.info(f"Переводов: {len(translations)}") # 4. 🔧 НОВОЕ (09.10.2026): удаляем старые уровни размеров 5–8 # (прогресс по ним неважен). logger.info(f"Удаляю старые уровни размеров {GRID_SIZES}...") deleted = await delete_levels_for_sizes(pool, GRID_SIZES) logger.info(f"Удалено уровней: {deleted}") # 5. Генерация next_level_number = max_level_number + 1 created_total = 0 stats_by_size: dict[int, dict[str, int]] = {} for n in GRID_SIZES: stats_by_size[n] = {"created": 0, "failed": 0} logger.info(f"\n--- Размер поля {n}×{n} ---") # Проверим, хватает ли длин: на n×n нужны длины из words_by_len. # Слова длиннее n*n невозможны — отсекаем. candidate_lengths = [ln for ln in words_by_len.keys() if ln <= n * n] if not candidate_lengths: logger.warning(f"Размер {n}: нет слов подходящей длины, пропускаю") continue # 🔧 ОБНОВЛЕНО (09.10.2026): своё количество уровней на размер. levels_count = LEVELS_PER_SIZE.get(n, 0) if levels_count <= 0: logger.warning(f"Размер {n}: LEVELS_PER_SIZE = 0, пропускаю") continue for i in range(levels_count): seed = SEED_BASE + next_level_number rnd = random.Random(seed) # Копия words_by_len с только подходящими длинами. wbl = {ln: list(words_by_len[ln]) for ln in candidate_lengths} level_data = build_level(n, wbl, rnd) if level_data is None: stats_by_size[n]["failed"] += 1 logger.warning(f" [{i+1}/{levels_count}] размер {n}: не удалось сгенерировать") # level_number НЕ инкрементим — попробуем следующий seed. # Но чтобы не залипнуть, тоже увеличиваем счётчик. next_level_number += 1 continue # Сохраняем saved = await save_level( pool, next_level_number, level_data["size"], level_data["letters"], level_data["words"], translations, ) if saved: stats_by_size[n]["created"] += 1 created_total += 1 logger.info( f" [{i+1}/{levels_count}] уровень #{next_level_number} " f"({n}×{n}) слов: {len(level_data['words'])}" ) else: logger.warning(f" [{i+1}/{levels_count}] уровень #{next_level_number} — конфликт, пропущен") next_level_number += 1 # 6. Итоги logger.info("\n=== Итого ===") logger.info(f"Создано уровней всего: {created_total}") for n in GRID_SIZES: st = stats_by_size.get(n, {"created": 0, "failed": 0}) logger.info(f" {n}×{n}: создано {st['created']}, не удалось {st['failed']}") logger.info(f"Следующий свободный level_number: {next_level_number}") if __name__ == "__main__": asyncio.run(main())