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 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, } @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 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)) # Очки: база 100, −20 за каждую подсказку, −20 за список слов, # +10 если без подсказок. # Формула: max(20, min(110, 100 - 20*hints_used - 20*list_opened + bonus)) bonus = 10 if hints_used == 0 else 0 points = max(20, min(110, 100 - 20 * hints_used - 20 * (1 if list_opened else 0) + 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 уже прочитан из БД выше (не доверяем клиенту). await conn.execute(""" INSERT INTO user_progress (user_id, level_id, completed_at, hints_used, score, level, current_streak) VALUES ($1, $2, NOW(), $3, $4, $5, 0) ON CONFLICT (user_id, level_id) DO UPDATE SET completed_at = NOW(), hints_used = $3, score = $4, level = $5, current_streak = 0 """, telegram_id, level_id, hints_used, score, level_name) # 🔧 ОБНОВЛЕНО (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 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 # Пройдено волн = session_number - 1; если только что завершили # 10-й уровень волны — волна пройдена (+1). waves_completed = session_number - 1 if session_level_number == 10: waves_completed += 1 # 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"], } # ============================================================ # 🆕 (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, }