- services/xp.py: award_xp, level_for, RANKS (48), featured_game - services/waves.py: wave_plan, grid_size_for, wave_medal - routers/featured.py: GET /featured (игра дня ×1.5) - routers/users.py: POST /set-nickname, POST /set-avatar - routers/app_auth.py: /auth/me с XP-полями (level, rank_key, rank_name, xp) - routers/game.py: award_xp + 3 штрафа + POST /game/next (волны) - routers/wordquiz.py: award_xp + серии в choose_progress - routers/bubblewords.py: award_xp + 4 штрафа - routers/sentences.py: award_xp по длине предложения - routers/leaderboard.py: сортировка по total_xp, XP-поля в ответе - database.py: миграции user_profile, xp_log, choose_progress, user_seen_levels, user_game_progress, wave_results, bubble_levels, user_word_stats - main.py: подключение routers/featured Проверено: - /auth/me отдаёт level=1, rank_00, xp_in_level - /featured отдаёт wordsearch + seconds_left - /game/complete-level начисляет XP через award_xp - xp_log, user_profile заполняются - /game/next выдаёт уровень по волнам - /leaderboard сортирует по total_xp
516 lines
18 KiB
Python
516 lines
18 KiB
Python
"""
|
||
generate_levels.py — генератор уровней филвордов (word search).
|
||
|
||
🔧 НОВОЕ (07.10.2026): Первая версия.
|
||
Порт алгоритма с JS (filword-gen.js): слова-змейки,
|
||
4 направления (вверх/вниз/влево/вправо), без диагоналей.
|
||
Поле n×n полностью заполнено, слова не пересекаются.
|
||
|
||
Логика:
|
||
1. Читает все слова из csv_words (A1+A2+B1), DISTINCT по word_pl.
|
||
Фильтр: длина 3..10 Unicode-символов.
|
||
2. Группирует по длине.
|
||
3. Для каждого размера n в [4, 5, 6, 7, 8, 9, 10]:
|
||
- генерирует 100 уровней;
|
||
- 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__)
|
||
|
||
# ============ Конфигурация ============
|
||
|
||
LEVELS_PER_SIZE = 215
|
||
GRID_SIZES = [4, 5, 6, 7, 8, 9, 10]
|
||
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}
|
||
|
||
|
||
# ============ БД ============
|
||
|
||
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. Генерация
|
||
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
|
||
|
||
for i in range(LEVELS_PER_SIZE):
|
||
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_PER_SIZE}] размер {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_PER_SIZE}] уровень #{next_level_number} "
|
||
f"({n}×{n}) слов: {len(level_data['words'])}"
|
||
)
|
||
else:
|
||
logger.warning(f" [{i+1}/{LEVELS_PER_SIZE}] уровень #{next_level_number} — конфликт, пропущен")
|
||
|
||
next_level_number += 1
|
||
|
||
# 5. Итоги
|
||
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()) |