849 lines
37 KiB
Python
849 lines
37 KiB
Python
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,
|
||
}
|