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 # Проверяем, что уровень доступен (не дальше следующего за пройденным) if level_number > 1 and level_number > last_completed + 1: raise HTTPException(403, "Level not available yet. Complete previous level first.") # 🔧 ОБНОВЛЕНО (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") 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"], ) # 🔧 ОБНОВЛЕНО (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 ) ) 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, }, } @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() for word in word_paths.keys(): if word.lower() == selected_word: 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} @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 async with pool.acquire() as conn: user = await conn.fetchrow( "SELECT id, telegram_id, last_completed_level, current_level FROM users WHERE telegram_id = $1", telegram_id ) if not user: raise HTTPException(401, "User not registered") 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) # 🆕 Штрафы (филворд): # -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 (юзер взял подсказку → уровень не завершится). # Теперь 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 # Если уровень уже был пройден — просто возвращаем результат 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) return { "status": "ok", "score": score, "already_completed": False, "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. Если есть активный уровень (выдан, но ещё не пройден) — возвращаем его. 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 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: return { "level_id": active["id"], "level_number": active["level_number"], "grid_size": active["grid_size"], "wave": wave_for_level(global_level), "position_in_wave": 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 > 20: 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, updated_at = NOW() WHERE user_id = $1 """, telegram_id, next_global, next_session, next_session_level, level_id, ) 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, }