Files
filwordspl-backend/routers/game.py
T

849 lines
37 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import json
from fastapi import APIRouter, Request, HTTPException
from auth import require_auth
from database import get_pool
router = APIRouter(prefix="/game", tags=["game"])
@router.get("/progress")
async def get_progress(request: Request):
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"""SELECT last_completed_level, current_level, last_completed_by_level
FROM users WHERE telegram_id = $1""",
telegram_id
)
if not user:
return {
"last_completed_level": 0,
"total_score": 0,
"current_level": "A1"
}
current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (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
# Очки из филвордов
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
telegram_id
)
# Очки из предложений
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1",
telegram_id
)
# Очки из квиза
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
)
# Очки из Bubble Words
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
)
total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0)
return {
"last_completed_level": last_completed,
"total_score": total_score,
"current_level": current_level
}
@router.get("/level/{level_number}")
async def get_level(request: Request, level_number: int):
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT app_language, current_level, last_completed_level, last_completed_by_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
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
# 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
# Ищем по level_number без created_by и без current_level.
# is_active = TRUE — чтобы черновики не показывались.
level = await conn.fetchrow("""
SELECT * FROM levels
WHERE level_number = $1
AND is_active = TRUE
LIMIT 1
""", level_number)
if not level:
raise HTTPException(404, "Level not found")
# 🔧 ФИКС (10.10.2026): доступ к уровню по user_seen_levels.
# Раньше проверяли level_number > last_completed + 1 — это ломало
# волновую выдачу, где уровни идут вперемешку (5×5 → 6×6 → ...).
# Теперь уровень доступен, если игрок получил его через /game/next
# (есть в user_seen_levels) или уже прошёл (completed_at IS NOT NULL).
# Проверка идёт ПОСЛЕ загрузки уровня, т.к. нужен level["id"].
already_completed = await conn.fetchval(
"SELECT 1 FROM user_progress WHERE user_id = $1 AND level_id = $2 AND completed_at IS NOT NULL",
telegram_id, level["id"]
)
seen = await conn.fetchval(
"SELECT 1 FROM user_seen_levels WHERE user_id = $1 AND level_id = $2",
telegram_id, level["id"]
)
if not seen and not already_completed:
raise HTTPException(403, "Level not available. Get it via /game/next.")
words = await conn.fetch(
"SELECT * FROM level_words WHERE level_id = $1", level["id"]
)
progress = await conn.fetchrow(
"SELECT * FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level["id"],
)
# 🔧 ФИКС (10.10.2026): wave_off_by_one —
# wave/pos хранятся в момент выдачи. Если NULL — fallback.
wave_pos = await conn.fetchrow(
"SELECT current_wave, current_position_in_wave FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
if wave_pos and wave_pos["current_wave"] and wave_pos["current_position_in_wave"]:
current_wave = int(wave_pos["current_wave"])
current_pos = int(wave_pos["current_position_in_wave"])
else:
global_level = await conn.fetchval(
"SELECT global_level_number FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
global_level = int(global_level or 1)
from services.waves import wave_for_level, level_in_wave
current_wave = wave_for_level(global_level)
current_pos = level_in_wave(global_level)
# 🔧 ОБНОВЛЕНО (09.10.2026): отдаём ВСЕ 4 перевода.
# Flutter сам выбирает, какой показать по context.lang.
# Старое поле 'translation' оставлено для совместимости (legacy).
word_list = []
for w in words:
legacy_translation = (
w.get(f"translation_{lang}", "")
or w.get("translation_en", "")
or ""
)
word_list.append({
"word_pl": w["word_pl"],
# Legacy (для старого Flutter)
"translation": legacy_translation,
# 🆕 Все переводы (Flutter сам выбирает)
"translation_ru": w.get("translation_ru") or "",
"translation_uk": w.get("translation_uk") or "",
"translation_en": w.get("translation_en") or "",
})
grid_letters = level["grid_letters"]
if isinstance(grid_letters, str):
grid_letters = json.loads(grid_letters)
word_paths = level["word_paths"]
if isinstance(word_paths, str):
word_paths = json.loads(word_paths)
# 🔧 ФИКС (25.09.2026): completed_detects_hint_row —
# раньше completed = progress is not None. Но hints.py создаёт
# строку при подсказке (score=0, completed_at=NULL) — это НЕ завершение.
# Теперь: completed = completed_at IS NOT NULL OR score > 0.
is_completed = (
progress is not None
and (
progress["completed_at"] is not None
or (progress["score"] or 0) > 0
)
)
# 🔧 ФИКС (10.10.2026): wave/pos из зафиксированных значений.
wave = current_wave
pos_in_wave = current_pos
return {
"level": {
"id": level["id"],
"level_number": level["level_number"],
"grid_size": level["grid_size"],
"grid_letters": grid_letters,
"word_paths": word_paths,
"level": level["level"],
},
"words": word_list,
"progress": {
"completed": is_completed,
"hints_used": progress["hints_used"] if progress else 0,
"score": progress["score"] if progress else 0,
},
# 🆕 (10.10.2026): волна и позиция в волне.
"wave": wave,
"position_in_wave": pos_in_wave,
"difficulty": user["difficulty"] or "medium",
}
@router.post("/check-word")
async def check_word(request: Request):
telegram_id, _ = await require_auth(request)
body = await request.json()
level_id = body.get("level_id")
selected_cells = body.get("cells", [])
if not level_id or not selected_cells:
raise HTTPException(400, "level_id and cells required")
pool = await get_pool()
found_word = None
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# perfect_streak считаем на СЕРВЕРЕ, не берём от клиента.
server_streak = 0
level_name = "A1"
async with pool.acquire() as conn:
level = await conn.fetchrow("SELECT * FROM levels WHERE id = $1", level_id)
if not level:
raise HTTPException(404, "Level not found")
level_name = level["level"] or "A1"
word_paths = level["word_paths"]
if isinstance(word_paths, str):
word_paths = json.loads(word_paths)
grid_letters = level["grid_letters"]
if isinstance(grid_letters, str):
grid_letters = json.loads(grid_letters)
selected_word = ''
for cell in selected_cells:
r, c = cell[0], cell[1]
try:
selected_word += grid_letters[r][c]
except (IndexError, TypeError):
continue
selected_word = selected_word.lower()
# 🔧 ФИКС (11.10.2026): word_matched_by_letters_only —
# раньше слово зачислялось только по буквам. Если те же буквы
# встречаются в другом месте сетки (например NOS вверху и внизу),
# сервер зачислял слово, хотя игрок собрал его не там.
# Теперь проверяем координаты: selected_cells должны точно
# совпасть с word_paths[word].
selected_path = [[int(cell[0]), int(cell[1])] for cell in selected_cells]
for word, path in word_paths.items():
if word.lower() != selected_word:
continue
expected_path = [[int(p[0]), int(p[1])] for p in path]
if selected_path == expected_path:
found_word = word
break
# 🔧 Серверный подсчёт streak
current_streak_row = await conn.fetchval(
"SELECT current_streak FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
)
current_streak = current_streak_row or 0
if found_word:
server_streak = current_streak + 1
await conn.execute("""
INSERT INTO user_progress (user_id, level_id, current_streak, level)
VALUES ($1, $2, $3, $4)
ON CONFLICT (user_id, level_id) DO UPDATE
SET current_streak = $3
""", telegram_id, level_id, server_streak, level_name)
else:
if current_streak > 0:
await conn.execute("""
INSERT INTO user_progress (user_id, level_id, current_streak, level)
VALUES ($1, $2, 0, $3)
ON CONFLICT (user_id, level_id) DO UPDATE
SET current_streak = 0
""", telegram_id, level_id, level_name)
# 🔧 Вызовы достижений ВНЕ блока
if found_word:
from routers.achievements import check_and_award_achievements
new_achievements = []
if server_streak >= 5:
ach = await check_and_award_achievements(telegram_id, "perfect_words", server_streak)
new_achievements.extend(ach)
return {
"status": "ok",
"found": True,
"word": found_word,
"server_streak": server_streak,
"new_achievements": new_achievements
}
return {"status": "ok", "found": False, "server_streak": 0, "reason": "wrong_path"}
@router.post("/complete-level")
async def complete_level(request: Request):
"""Завершение уровня с проверкой на читерство и выдачей достижений"""
telegram_id, _ = await require_auth(request)
body = await request.json()
level_id = body.get("level_id")
completion_time = body.get("completion_time")
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# perfect_streak больше НЕ берём от клиента. Читаем из user_progress.current_streak.
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# hints_used больше НЕ берём от клиента. Читаем из user_progress.hints_used.
if not level_id:
raise HTTPException(400, "level_id required")
# Защита от читерства: минимальное время 5 секунд
if completion_time is not None and completion_time < 5:
raise HTTPException(400, "Completion time too fast. Minimum 5 seconds required.")
pool = await get_pool()
# 🔧 ИСПРАВЛЕНО: все проверки и запись прогресса — внутри одного блока
# все данные для достижений собираем здесь, а сами вызовы делаем снаружи
already_completed = False
existing_score = 0
score = 0
levels_completed = 0
grand_total = 0
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# читаем server-side streak из БД ДО сброса в 0.
server_perfect_streak = 0
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# hints_used читаем из БД, не доверяем клиенту.
hints_used = 0
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
# 🆕 (11.10.2026): волновые счётчики для достижений.
waves_completed = 0
wordsearch_xp = 0
fast_streak = 0
no_hints_streak = 0
words_found = 0
# 🆕 (13.10.2026): итоги волны для модалки.
wave_completed = False
wave_points = 0
wave_max_points = 0
wave_medal_result = "none"
current_wave = 1
current_position_in_wave = 1
async with pool.acquire() as conn:
user = await conn.fetchrow(
"SELECT id, telegram_id, last_completed_level, current_level, difficulty FROM users WHERE telegram_id = $1",
telegram_id
)
if not user:
raise HTTPException(401, "User not registered")
difficulty = user["difficulty"] or "medium"
level = await conn.fetchrow(
"SELECT id, level_number, grid_size, level FROM levels WHERE id = $1", level_id
)
if not level:
raise HTTPException(404, "Level not found")
current_level_number = level["level_number"]
level_name = level["level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
# Уровни глобальные, поэтому убираем проверку «уровень принадлежит
# твоему current_level». Оставляем только проверку прогресса выше.
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
# Но hints.py создаёт строку при подсказке (score=0,
# completed_at=NULL) — это НЕ завершение. Тогда complete_level
# считал уровень пройденным и НЕ обновлял last_completed_level.
# Теперь: уже пройден только если completed_at IS NOT NULL
# ИЛИ score > 0.
existing_progress = await conn.fetchrow(
"SELECT score, completed_at FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
)
is_really_completed = (
existing_progress is not None
and (
existing_progress["completed_at"] is not None
or (existing_progress["score"] or 0) > 0
)
)
if is_really_completed:
already_completed = True
existing_score = existing_progress["score"]
else:
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# читаем server-side streak ДО сброса в 0.
server_perfect_streak = await conn.fetchval(
"SELECT current_streak FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
) or 0
# 🔧 НОВОЕ (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)
# 🆕 Штрафы (филворд):
# -20 за открытие списка слов (один раз за уровень)
# -20 за каждую подсказку
list_opened = bool(body.get("list_opened", False))
# 🔧 НОВОЕ (13.10.2026): на Hard подсказки и список слов недоступны.
if difficulty == "hard" and (hints_used > 0 or list_opened):
raise HTTPException(
status_code=400,
detail="Hints and word list are disabled on Hard difficulty"
)
# Очки в зависимости от сложности
if difficulty == "hard":
# Hard: фикс 110 (без подсказок и списка)
points = 110
else:
# Easy / Medium
bonus = 10 if hints_used == 0 else 0
penalty_hints = 20 * hints_used
penalty_list = 0 if difficulty == "easy" else 20 * (1 if list_opened else 0)
points = max(20, min(110, 100 - penalty_hints - penalty_list + bonus))
# Начисляем XP через единую функцию
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "wordsearch", points)
score = xp_result["points"] # для обратной совместимости
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
# раньше INSERT падал с unique violation, если строка user_progress
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
# Теперь UPSERT с ON CONFLICT DO UPDATE.
# hints_used уже прочитан из БД выше (не доверяем клиенту).
# 🆕 (13.10.2026): читаем session_number ДО записи, чтобы
# записать wave в user_progress (для подсчёта очков волны).
wave_row = await conn.fetchrow(
"SELECT session_number, session_level_number FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
session_number = int(wave_row["session_number"] or 1) if wave_row else 1
session_level_number = int(wave_row["session_level_number"] or 1) if wave_row else 1
await conn.execute("""
INSERT INTO user_progress
(user_id, level_id, completed_at, hints_used, score, level, current_streak, wave)
VALUES ($1, $2, NOW(), $3, $4, $5, 0, $6)
ON CONFLICT (user_id, level_id) DO UPDATE
SET completed_at = NOW(),
hints_used = $3,
score = $4,
level = $5,
current_streak = 0,
wave = $6
""", telegram_id, level_id, hints_used, score, level_name, session_number)
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Обновляем только users.last_completed_level — глобальный.
# last_completed_by_level (JSONB) остаётся в БД для совместимости,
# но больше не пишется.
await conn.execute("""
UPDATE users
SET last_completed_level = GREATEST(COALESCE(last_completed_level, 0), $2)
WHERE telegram_id = $1
""", telegram_id, current_level_number)
# 🔧 ФИКС (10.10.2026): game_next_reuse_active_level —
# уровень пройден → сбрасываем активный уровень, чтобы
# следующий /game/next выдал новый. Сбрасываем только если
# активный уровень совпадает с завершённым.
await conn.execute("""
UPDATE user_game_progress
SET current_level_id = NULL,
updated_at = NOW()
WHERE user_id = $1 AND current_level_id = $2
""", telegram_id, level_id)
# Собираем данные для достижений внутри блока
levels_completed = await conn.fetchval(
"SELECT COUNT(*) FROM user_progress WHERE user_id = $1",
telegram_id
) or 0
total_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
telegram_id
) or 0
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1",
telegram_id
) or 0
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = total_score + sentence_score + wordquiz_score + bubblewords_score
# 🆕 (11.10.2026): волновые счётчики.
words_in_level = await conn.fetchval(
"SELECT COUNT(*) FROM level_words WHERE level_id = $1", level_id
) or 0
# Пройдено волн = session_number - 1; если только что завершили
# 10-й уровень волны — волна пройдена (+1).
waves_completed = session_number - 1
if session_level_number == 10:
waves_completed += 1
# 🆕 (13.10.2026): итоги волны для модалки.
from services.waves import max_points_for_wave, wave_medal
wave_completed = (session_level_number == 10)
wave_points = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND wave = $2",
telegram_id, session_number,
) or 0
wave_max_points = max_points_for_wave()
wave_medal_result = wave_medal(wave_points, wave_max_points)
# XP филворда = сумма score по user_progress (уже посчитана как total_score).
wordsearch_xp = total_score
# Обновляем счётчики серий.
is_fast = completion_time is not None and int(completion_time) <= 30
await conn.execute("""
UPDATE user_game_progress
SET fast_streak = CASE WHEN $2 THEN COALESCE(fast_streak, 0) + 1 ELSE 0 END,
no_hints_streak = CASE WHEN $3 THEN COALESCE(no_hints_streak, 0) + 1 ELSE 0 END,
words_found = COALESCE(words_found, 0) + $4,
updated_at = NOW()
WHERE user_id = $1
""", telegram_id, is_fast, hints_used == 0, words_in_level)
counters = await conn.fetchrow(
"SELECT fast_streak, no_hints_streak, words_found FROM user_game_progress WHERE user_id = $1",
telegram_id,
)
fast_streak = int(counters["fast_streak"] or 0) if counters else 0
no_hints_streak = int(counters["no_hints_streak"] or 0) if counters else 0
words_found = int(counters["words_found"] or 0) if counters else 0
# Если уровень уже был пройден — просто возвращаем результат
if already_completed:
return {
"status": "ok",
"score": existing_score,
"already_completed": True,
"new_achievements": []
}
# 🔧 ИСПРАВЛЕНО: вызовы достижений ВНЕ блока async with pool.acquire()
from routers.achievements import check_and_award_achievements
new_achievements = []
ach = await check_and_award_achievements(telegram_id, "levels_completed", levels_completed)
new_achievements.extend(ach)
if hints_used == 0:
ach = await check_and_award_achievements(telegram_id, "no_hints_level", 1)
new_achievements.extend(ach)
if completion_time is not None and completion_time > 0:
if int(completion_time) <= 60:
ach = await check_and_award_achievements(telegram_id, "speed_level", 60)
new_achievements.extend(ach)
ach = await check_and_award_achievements(telegram_id, "total_score", grand_total)
new_achievements.extend(ach)
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# server_perfect_streak прочитан ВНУТРИ блока выше, ДО сброса в 0.
if server_perfect_streak >= 5:
ach = await check_and_award_achievements(telegram_id, "perfect_words", server_perfect_streak)
new_achievements.extend(ach)
# 🆕 (11.10.2026): волновые достижения.
ach = await check_and_award_achievements(telegram_id, "waves_completed", waves_completed)
new_achievements.extend(ach)
ach = await check_and_award_achievements(telegram_id, "wordsearch_xp", wordsearch_xp)
new_achievements.extend(ach)
if fast_streak >= 3:
ach = await check_and_award_achievements(telegram_id, "ws_speed_run", fast_streak)
new_achievements.extend(ach)
if no_hints_streak >= 10:
ach = await check_and_award_achievements(telegram_id, "ws_no_hints_streak", no_hints_streak)
new_achievements.extend(ach)
if words_found >= 1000:
ach = await check_and_award_achievements(telegram_id, "wordsearch_words", words_found)
new_achievements.extend(ach)
return {
"status": "ok",
"score": score,
"already_completed": False,
"new_achievements": new_achievements,
# 🆕 XP-поля
"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"],
# 🆕 (13.10.2026): итоги волны для модалки.
"wave_completed": wave_completed,
"wave_number": session_number,
"wave_points": wave_points,
"wave_max_points": wave_max_points,
"wave_medal": wave_medal_result,
}
# ============================================================
# 🆕 (08.10.2026): Волновая выдача уровня.
# ============================================================
@router.post("/next")
async def get_next_level(request: Request):
"""
Выдаёт следующий уровень по волновой структуре.
Логика:
1. Если есть активный уровень (выдан, но ещё не пройден) — возвращаем его.
2. Иначе смотрим user_game_progress.global_level_number.
3. Определяем волну и размер сетки через wave_plan.
4. Ищем непройденный уровень нужного размера (в user_seen_levels).
5. Помечаем как seen, обновляем user_game_progress, ставим current_level_id.
6. Возвращаем level_number.
🔧 ФИКС (10.10.2026): game_next_reuse_active_level —
раньше /game/next при каждом заходе выдавал НОВЫЙ уровень и
инкрементил global_level_number, даже если предыдущий не был пройден.
Из-за этого при повторном открытии Filwords уровень менялся
(5×5 → 6×6). Теперь сначала проверяем current_level_id:
если уровень выдан и ещё не пройден — возвращаем его же.
"""
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,
current_level_id, current_wave, current_position_in_wave
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
current_level_id = None
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)
current_level_id = row["current_level_id"]
from services.waves import wave_for_level, level_in_wave, grid_size_for
# 🔧 ФИКС (10.10.2026): сначала проверяем активный уровень.
# Если он выдан и ещё не пройден — возвращаем его же,
# не двигая счётчики и не помечая новый уровень как seen.
if current_level_id is not None:
active = await conn.fetchrow(
"""
SELECT id, level_number, grid_size
FROM levels
WHERE id = $1 AND is_active = TRUE
""",
current_level_id,
)
if active is not None:
done = await conn.fetchval(
"""
SELECT 1 FROM user_progress
WHERE user_id = $1 AND level_id = $2
AND (completed_at IS NOT NULL OR COALESCE(score, 0) > 0)
""",
telegram_id, active["id"],
)
if not done:
# 🔧 ФИКС (10.10.2026): off-by-one в reuse-ветке —
# global_level уже инкрементнут при первой выдаче,
# поэтому wave/pos считаем от зафиксированных значений
# current_wave / current_position_in_wave. Fallback —
# старый расчёт для записей без этих полей.
return {
"level_id": active["id"],
"level_number": active["level_number"],
"grid_size": active["grid_size"],
"wave": int(row["current_wave"]) if row["current_wave"] else wave_for_level(global_level),
"position_in_wave": int(row["current_position_in_wave"]) if row["current_position_in_wave"] else level_in_wave(global_level),
"session_number": session_number,
"session_level": session_level,
"global_level": global_level,
"reused": True,
}
# Уровень пройден или удалён/неактивен — сбрасываем активный.
await conn.execute(
"""
UPDATE user_game_progress
SET current_level_id = NULL, updated_at = NOW()
WHERE user_id = $1
""",
telegram_id,
)
# Определяем волну и размер
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 > 10:
next_session_level = 1
next_session += 1
# 🔧 ФИКС (10.10.2026): запоминаем выданный уровень как активный.
await conn.execute(
"""
UPDATE user_game_progress
SET global_level_number = $2,
session_number = $3,
session_level_number = $4,
current_level_id = $5,
current_wave = $6,
current_position_in_wave = $7,
updated_at = NOW()
WHERE user_id = $1
""",
telegram_id, next_global, next_session, next_session_level, level_id,
wave, pos_in_wave,
)
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,
"reused": False,
}