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
+206 -70
View File
@@ -27,23 +27,12 @@ async def get_progress(request: Request):
current_level = user["current_level"] or "A1"
# 🔧 ФИКС (30.09.2026): progress_uses_per_level —
# возвращаем last_completed_level для ТЕКУЩЕГО уровня языка,
# а не глобальный счётчик (который смешивал A1+A2+B1).
last_by_level = user["last_completed_by_level"] or {}
if isinstance(last_by_level, str):
try:
import json as _json
last_by_level = _json.loads(last_by_level)
except Exception:
last_by_level = {}
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Раньше возвращали last_completed_for_current из per-level JSONB,
# но уровни теперь глобальные (level = 'common').
# Возвращаем users.last_completed_level — единый глобальный прогресс.
last_completed = user["last_completed_level"] or 0
last_completed_for_current = (
last_by_level.get(current_level, 0)
if isinstance(last_by_level, dict)
else 0
)
# Очки из филвордов
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
@@ -71,8 +60,7 @@ async def get_progress(request: Request):
total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0)
return {
"last_completed_level": last_completed_for_current,
"last_completed_by_level": last_by_level,
"last_completed_level": last_completed,
"total_score": total_score,
"current_level": current_level
}
@@ -93,42 +81,26 @@ async def get_level(request: Request, level_number: int):
lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик (без per-level).
# Уровни глобальные (level = 'common'), поэтому прогресс —
# users.last_completed_level. last_completed_by_level оставлен
# в БД для совместимости, но больше не используется здесь.
last_completed = user["last_completed_level"] or 0
# 🔧 ФИКС (30.09.2026): last_completed_by_level —
# используем per-level счётчик. Fallback на last_completed_level (старый).
last_completed_by_level = user["last_completed_by_level"] or {}
if isinstance(last_completed_by_level, str):
try:
import json as _json
last_completed_by_level = _json.loads(last_completed_by_level)
except Exception:
last_completed_by_level = {}
last_completed = last_completed_by_level.get(current_level, 0) if isinstance(last_completed_by_level, dict) else 0
# Проверяем, что уровень доступен (не дальше следующего за пройденным)
if level_number > 1 and level_number > last_completed + 1:
raise HTTPException(403, "Level not available yet. Complete previous level first.")
# 🔧 ФИКС (29.09.2026): приоритет ручным уровням.
# Если есть уровень, созданный вручную (created_by IS NOT NULL) —
# показываем его. Иначе — fallback на авто (created_by IS NULL).
# 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
# Ищем по level_number без created_by и без current_level.
# is_active = TRUE — чтобы черновики не показывались.
level = await conn.fetchrow("""
SELECT * FROM levels
WHERE level = $1 AND level_number = $2
AND created_by IS NOT NULL
WHERE level_number = $1
AND is_active = TRUE
LIMIT 1
""", current_level, level_number)
# Fallback на авто, если ручного нет
if not level:
level = await conn.fetchrow("""
SELECT * FROM levels
WHERE level = $1 AND level_number = $2
AND created_by IS NULL
LIMIT 1
""", current_level, level_number)
""", level_number)
if not level:
raise HTTPException(404, "Level not found")
@@ -312,6 +284,8 @@ async def complete_level(request: Request):
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# hints_used читаем из БД, не доверяем клиенту.
hints_used = 0
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
async with pool.acquire() as conn:
user = await conn.fetchrow(
@@ -330,9 +304,10 @@ async def complete_level(request: Request):
current_level_number = level["level_number"]
level_name = level["level"] or "A1"
# Проверяем, что уровень принадлежит текущему уровню пользователя
if level_name != (user["current_level"] or "A1"):
raise HTTPException(403, "This level does not belong to your current level")
# 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
# Уровни глобальные, поэтому убираем проверку «уровень принадлежит
# твоему current_level». Оставляем только проверку прогресса выше.
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
@@ -365,19 +340,41 @@ async def complete_level(request: Request):
telegram_id, level_id
) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# читаем hints_used из БД, не доверяем клиенту.
# 🔧 НОВОЕ (08.10.2026): XP-система.
# Читаем hints_used и list_opened из БД (не доверяем клиенту).
hints_used = await conn.fetchval(
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
) or 0
hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10)
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# сбрасываем current_streak в 0 при завершении уровня.
#
# 🆕 Штрафы (филворд):
# -1 за открытие списка слов (один раз за уровень)
# -1 за использование подсказки (один раз за уровень)
# -1 за превышение времени
list_opened = bool(body.get("list_opened", False))
# Лимит времени по размеру сетки
grid_size = level["grid_size"]
time_limits = {5: 45, 6: 60, 7: 90, 8: 120}
time_limit = time_limits.get(grid_size, 60)
completion_time_val = completion_time or 0
time_penalty = 1 if (completion_time_val > time_limit) else 0
hint_penalty = 1 if hints_used > 0 else 0
list_penalty = 1 if list_opened else 0
stars = max(
1,
5 - time_penalty - hint_penalty - list_penalty
)
# Начисляем XP через единую функцию
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "wordsearch", stars)
score = xp_result["points"] # для обратной совместимости
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
# раньше INSERT падал с unique violation, если строка user_progress
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
@@ -395,22 +392,15 @@ async def complete_level(request: Request):
current_streak = 0
""", telegram_id, level_id, hints_used, score, level_name)
# 🔧 ФИКС (30.09.2026): last_completed_by_level —
# обновляем per-level счётчик (JSONB) + старый last_completed_level.
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Обновляем только users.last_completed_level — глобальный.
# last_completed_by_level (JSONB) остаётся в БД для совместимости,
# но больше не пишется.
await conn.execute("""
UPDATE users
SET last_completed_level = GREATEST(last_completed_level, $2),
last_completed_by_level = jsonb_set(
COALESCE(last_completed_by_level, '{}'::jsonb),
ARRAY[$3::text],
to_jsonb(GREATEST(
COALESCE((last_completed_by_level->>$3)::int, 0),
$2
)),
true
)
SET last_completed_level = GREATEST(COALESCE(last_completed_level, 0), $2)
WHERE telegram_id = $1
""", telegram_id, current_level_number, level_name)
""", telegram_id, current_level_number)
# Собираем данные для достижений внутри блока
levels_completed = await conn.fetchval(
@@ -471,8 +461,154 @@ async def complete_level(request: Request):
new_achievements.extend(ach)
return {
"status": "ok",
"status": "ok",
"score": score,
"already_completed": False,
"new_achievements": new_achievements
"new_achievements": new_achievements,
# 🆕 XP-поля
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
}
# ============================================================
# 🆕 (08.10.2026): Волновая выдача уровня.
# ============================================================
@router.post("/next")
async def get_next_level(request: Request):
"""
Выдаёт следующий уровень по волновой структуре.
Логика:
1. Смотрим user_game_progress.global_level_number.
2. Определяем волну и размер сетки через wave_plan.
3. Ищем непройденный уровень нужного размера (в user_seen_levels).
4. Помечаем как seen, обновляем user_game_progress.
5. Возвращаем level_number.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
# Читаем или создаём прогресс
row = await conn.fetchrow(
"""
SELECT global_level_number, session_number, session_level_number
FROM user_game_progress WHERE user_id = $1
""",
telegram_id,
)
if row is None:
await conn.execute(
"""
INSERT INTO user_game_progress
(user_id, global_level_number, session_number, session_level_number)
VALUES ($1, 1, 1, 1)
ON CONFLICT (user_id) DO NOTHING
""",
telegram_id,
)
global_level = 1
session_number = 1
session_level = 1
else:
global_level = int(row["global_level_number"] or 1)
session_number = int(row["session_number"] or 1)
session_level = int(row["session_level_number"] or 1)
# Определяем волну и размер
from services.waves import wave_for_level, level_in_wave, grid_size_for
wave = wave_for_level(global_level)
pos_in_wave = level_in_wave(global_level)
grid_size = grid_size_for(global_level)
# Ищем непройденный уровень нужного размера
# Исключаем те, что уже в user_seen_levels
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND l.id NOT IN (
SELECT level_id FROM user_seen_levels WHERE user_id = $2
)
ORDER BY RANDOM()
LIMIT 1
""",
grid_size, telegram_id,
)
# Fallback: если непройденных нет, берём самый давно виденный
if level is None:
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
JOIN user_seen_levels usl ON usl.level_id = l.id
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND usl.user_id = $2
ORDER BY usl.seen_at ASC
LIMIT 1
""",
grid_size, telegram_id,
)
if level is None:
raise HTTPException(404, "No levels available for this grid size")
level_id = level["id"]
level_number = level["level_number"]
# Помечаем как seen (обновляем seen_at если уже был)
await conn.execute(
"""
INSERT INTO user_seen_levels (user_id, level_id, seen_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id, level_id) DO UPDATE
SET seen_at = NOW()
""",
telegram_id, level_id,
)
# Обновляем прогресс
next_global = global_level + 1
next_session_level = session_level + 1
next_session = session_number
if next_session_level > 20:
next_session_level = 1
next_session += 1
await conn.execute(
"""
UPDATE user_game_progress
SET global_level_number = $2,
session_number = $3,
session_level_number = $4,
updated_at = NOW()
WHERE user_id = $1
""",
telegram_id, next_global, next_session, next_session_level,
)
return {
"level_id": level_id,
"level_number": level_number,
"grid_size": grid_size,
"wave": wave,
"position_in_wave": pos_in_wave,
"session_number": session_number,
"session_level": session_level,
"global_level": global_level,
}