feat: XP foundation + waves + featured game + profile + leaderboard by total_xp

- 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
This commit is contained in:
2026-10-09 08:12:19 +00:00
parent a3f7d9521f
commit 84927b063f
13 changed files with 1800 additions and 278 deletions
+516
View File
@@ -0,0 +1,516 @@
"""
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())