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:
@@ -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())
|
||||
Reference in New Issue
Block a user