504 lines
20 KiB
Python
504 lines
20 KiB
Python
import random
|
||
import hashlib # 🔧 НОВОЕ: импорт hashlib для стабильного хэширования
|
||
import json
|
||
from fastapi import APIRouter, Request, HTTPException
|
||
from auth import require_auth
|
||
from database import get_pool
|
||
|
||
router = APIRouter(prefix="/bubblewords", tags=["bubblewords"])
|
||
|
||
|
||
def split_word_into_parts(word: str, forbidden_parts: set = None) -> list:
|
||
"""Разбивает польское слово на части по 1-3 буквы.
|
||
forbidden_parts — части, которые уже заняты другими словами на уровне.
|
||
Если не удалось найти уникальное разбиение — добавляет суффикс с индексом слова."""
|
||
if forbidden_parts is None:
|
||
forbidden_parts = set()
|
||
|
||
n = len(word)
|
||
attempts = 0
|
||
max_attempts = 50 # Увеличиваем попытки
|
||
|
||
while attempts < max_attempts:
|
||
parts = []
|
||
i = 0
|
||
|
||
while i < n:
|
||
remaining = n - i
|
||
|
||
if remaining == 1:
|
||
parts.append(word[i:])
|
||
i += 1
|
||
elif remaining == 2:
|
||
if random.random() < 0.4:
|
||
parts.append(word[i:i+1])
|
||
parts.append(word[i+1:])
|
||
else:
|
||
parts.append(word[i:])
|
||
i += 2
|
||
elif remaining == 3:
|
||
choice = random.choice([1, 2, 3])
|
||
if choice == 1:
|
||
parts.append(word[i:i+1])
|
||
parts.append(word[i+1:])
|
||
elif choice == 2:
|
||
parts.append(word[i:i+2])
|
||
parts.append(word[i+2:])
|
||
else:
|
||
parts.append(word[i:])
|
||
i += 3
|
||
elif remaining == 4:
|
||
choice = random.choice([(2, 2), (1, 3), (3, 1), (1, 1, 2), (2, 1, 1)])
|
||
for size in choice:
|
||
parts.append(word[i:i+size])
|
||
i += size
|
||
elif remaining == 5:
|
||
choice = random.choice([(2, 3), (3, 2), (2, 2, 1), (2, 1, 2)])
|
||
for size in choice:
|
||
parts.append(word[i:i+size])
|
||
i += size
|
||
elif remaining == 6:
|
||
choice = random.choice([(3, 3), (2, 2, 2), (3, 2, 1), (2, 3, 1)])
|
||
for size in choice:
|
||
parts.append(word[i:i+size])
|
||
i += size
|
||
else:
|
||
size = random.choice([2, 3])
|
||
if i + size > n:
|
||
size = n - i
|
||
parts.append(word[i:i+size])
|
||
i += size
|
||
|
||
# Проверяем конфликт
|
||
conflict = False
|
||
for part in parts:
|
||
if part in forbidden_parts:
|
||
conflict = True
|
||
break
|
||
|
||
if not conflict:
|
||
return parts
|
||
|
||
attempts += 1
|
||
|
||
# Если за 50 попыток не нашли уникальное разбиение —
|
||
# разбиваем слово ПО БУКВАМ и добавляем суффикс с хешем слова
|
||
# Такой суффикс гарантированно уникален для каждого слова
|
||
# 🔧 ИСПРАВЛЕНО: заменён hash() на hashlib.md5 для стабильности между запусками
|
||
word_hash = hashlib.md5(word.encode('utf-8')).hexdigest()[:4] # Берём первые 4 символа MD5
|
||
unique_parts = []
|
||
for idx, letter in enumerate(word):
|
||
unique_parts.append(f"{letter}.{word_hash}.{idx}")
|
||
|
||
return unique_parts
|
||
|
||
|
||
@router.get("/next")
|
||
async def get_next_bubble_level(request: Request):
|
||
"""Выдаёт слова и их части для уровня пузырей с фильтрацией по уровню."""
|
||
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, 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"
|
||
|
||
progress = await conn.fetchrow(
|
||
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
|
||
telegram_id
|
||
)
|
||
current_bubble_level = (progress["levels_completed"] if progress else 0) + 1
|
||
|
||
# Количество слов по сложности
|
||
difficulty = user["difficulty"] if "difficulty" in user.keys() else "medium"
|
||
num_words = {"easy": 3, "medium": 4, "hard": 5}.get(difficulty, 4)
|
||
|
||
# 🔧 ФИКС (30.09.2026): csv_words_source —
|
||
# источник слов переехал с level_words (старая схема level_id IS NULL)
|
||
# на csv_words (level_code). Один источник — CSV-база.
|
||
words = await conn.fetch("""
|
||
SELECT word_pl, translation_ru, translation_uk, translation_en
|
||
FROM csv_words
|
||
WHERE level_code = $1
|
||
ORDER BY RANDOM()
|
||
LIMIT $2
|
||
""", current_level, num_words)
|
||
|
||
if len(words) < 2:
|
||
raise HTTPException(404, "Not enough words")
|
||
|
||
translation_field = f"translation_{lang}"
|
||
|
||
result_words = []
|
||
all_parts = []
|
||
forbidden_parts = set()
|
||
|
||
for w in words:
|
||
word_pl = w["word_pl"]
|
||
parts = split_word_into_parts(word_pl, forbidden_parts)
|
||
translation = w.get(translation_field) or w.get("translation_en") or word_pl
|
||
|
||
result_words.append({
|
||
"word_pl": word_pl,
|
||
"translation": translation,
|
||
"parts": parts,
|
||
})
|
||
|
||
for part in parts:
|
||
forbidden_parts.add(part)
|
||
all_parts.append({
|
||
"text": part,
|
||
"word_pl": word_pl,
|
||
})
|
||
|
||
random.shuffle(all_parts)
|
||
|
||
# 🔧 НОВОЕ (14.10.2026): сохраняем состояние уровня для подсказок
|
||
# и сбрасываем счётчики подсказок/списка при новом уровне.
|
||
level_state = [
|
||
{
|
||
"word_pl": w["word_pl"],
|
||
"translation": w["translation"],
|
||
"parts": w["parts"],
|
||
}
|
||
for w in result_words
|
||
]
|
||
await conn.execute("""
|
||
INSERT INTO bubble_words_progress
|
||
(user_id, levels_completed, total_score, level,
|
||
current_hints_used, current_list_opened, current_level_words, hinted_words)
|
||
VALUES ($1, 0, 0, $2, 0, 0, $3::jsonb, '{}')
|
||
ON CONFLICT (user_id) DO UPDATE
|
||
SET current_hints_used = 0,
|
||
current_list_opened = 0,
|
||
current_level_words = $3::jsonb,
|
||
hinted_words = '{}'
|
||
""", telegram_id, current_level, json.dumps(level_state))
|
||
|
||
return {
|
||
"words": result_words,
|
||
"bubbles": all_parts,
|
||
"level": current_bubble_level,
|
||
"difficulty": user["difficulty"] or "medium",
|
||
}
|
||
|
||
|
||
@router.post("/first-part-hint")
|
||
async def first_part_hint(request: Request):
|
||
"""Подсказка «первая часть слова» — возвращает первый пузырь одного из несобранных слов.
|
||
|
||
🔧 НОВОЕ (14.10.2026): аналог GET /hints/first-letter/{level_id} из филворда.
|
||
Лимит 3 подсказки, штраф −20 (учитывается в /complete через current_hints_used).
|
||
Hard — запрещено (400).
|
||
"""
|
||
telegram_id, _ = await require_auth(request)
|
||
body = await request.json()
|
||
found_words = set(body.get("found_words", []) or [])
|
||
|
||
pool = await get_pool()
|
||
async with pool.acquire() as conn:
|
||
user = await conn.fetchrow(
|
||
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||
)
|
||
if not user:
|
||
raise HTTPException(401, "User not registered")
|
||
|
||
difficulty = user["difficulty"] or "medium"
|
||
if difficulty == "hard":
|
||
raise HTTPException(400, "Hints are disabled on Hard difficulty")
|
||
|
||
progress = await conn.fetchrow(
|
||
"SELECT current_hints_used, current_level_words, hinted_words "
|
||
"FROM bubble_words_progress WHERE user_id = $1",
|
||
telegram_id
|
||
)
|
||
if not progress:
|
||
raise HTTPException(404, "No active level")
|
||
|
||
hints_used = progress["current_hints_used"] or 0
|
||
if hints_used >= 3:
|
||
raise HTTPException(400, "All hints used")
|
||
|
||
raw = progress["current_level_words"]
|
||
if isinstance(raw, str):
|
||
level_words = json.loads(raw) if raw else []
|
||
else:
|
||
level_words = raw or []
|
||
|
||
raw_hinted = progress["hinted_words"]
|
||
if isinstance(raw_hinted, str):
|
||
hinted = set(json.loads(raw_hinted)) if raw_hinted else set()
|
||
else:
|
||
hinted = set(raw_hinted or [])
|
||
|
||
# Слова, которые ещё не собраны и которым ещё не давали подсказку
|
||
candidates = [
|
||
w for w in level_words
|
||
if w.get("word_pl") not in found_words and w.get("word_pl") not in hinted
|
||
]
|
||
|
||
if not candidates:
|
||
raise HTTPException(400, "All words already hinted")
|
||
|
||
chosen = random.choice(candidates)
|
||
word_pl = chosen["word_pl"]
|
||
parts = chosen.get("parts") or []
|
||
first_part = parts[0] if parts else word_pl
|
||
|
||
new_hints = hints_used + 1
|
||
new_hinted = sorted(hinted | {word_pl})
|
||
|
||
await conn.execute("""
|
||
UPDATE bubble_words_progress
|
||
SET current_hints_used = $2,
|
||
hinted_words = $3
|
||
WHERE user_id = $1
|
||
""", telegram_id, new_hints, new_hinted)
|
||
|
||
return {
|
||
"word_pl": word_pl,
|
||
"first_part": first_part,
|
||
"hints_used_total": new_hints,
|
||
}
|
||
|
||
|
||
@router.post("/show-words")
|
||
async def show_words(request: Request):
|
||
"""Подсказка «показать слова» — возвращает все загаданные слова с переводами.
|
||
|
||
🔧 НОВОЕ (14.10.2026): аналог show-words из филворда.
|
||
Easy — без лимита. Medium — 1 раз (−20). Hard — запрещено (400).
|
||
"""
|
||
telegram_id, _ = await require_auth(request)
|
||
|
||
pool = await get_pool()
|
||
async with pool.acquire() as conn:
|
||
user = await conn.fetchrow(
|
||
"SELECT difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||
)
|
||
if not user:
|
||
raise HTTPException(401, "User not registered")
|
||
|
||
difficulty = user["difficulty"] or "medium"
|
||
if difficulty == "hard":
|
||
raise HTTPException(400, "Word list is disabled on Hard difficulty")
|
||
|
||
progress = await conn.fetchrow(
|
||
"SELECT current_list_opened, current_level_words "
|
||
"FROM bubble_words_progress WHERE user_id = $1",
|
||
telegram_id
|
||
)
|
||
if not progress:
|
||
raise HTTPException(404, "No active level")
|
||
|
||
list_opened = progress["current_list_opened"] or 0
|
||
|
||
# Medium — список можно открыть только 1 раз
|
||
if difficulty == "medium" and list_opened >= 1:
|
||
raise HTTPException(400, "Word list already used on Medium difficulty")
|
||
|
||
raw = progress["current_level_words"]
|
||
if isinstance(raw, str):
|
||
level_words = json.loads(raw) if raw else []
|
||
else:
|
||
level_words = raw or []
|
||
|
||
words = [
|
||
{"word_pl": w.get("word_pl"), "translation": w.get("translation")}
|
||
for w in level_words
|
||
]
|
||
|
||
# Инкремент счётчика для Easy и Medium (Hard сюда не доходит)
|
||
new_list_opened = list_opened + 1
|
||
await conn.execute("""
|
||
UPDATE bubble_words_progress
|
||
SET current_list_opened = $2
|
||
WHERE user_id = $1
|
||
""", telegram_id, new_list_opened)
|
||
|
||
return {
|
||
"words": words,
|
||
"list_opened_total": new_list_opened,
|
||
}
|
||
|
||
|
||
@router.post("/complete")
|
||
async def complete_bubble_level(request: Request):
|
||
"""Завершение уровня пузырей, начисление XP и проверка достижений.
|
||
|
||
🔧 НОВОЕ (08.10.2026): XP-система.
|
||
Штрафы:
|
||
-1 за открытие списка слов (один раз за уровень)
|
||
-1 за каждое неправильно собранное слово (макс 3)
|
||
-1 если time_ms > 60 сек
|
||
Минимум 1 звезда.
|
||
"""
|
||
telegram_id, _ = await require_auth(request)
|
||
body = await request.json()
|
||
words_count = body.get("words_count", 3)
|
||
completion_time = body.get("completion_time")
|
||
wrong_words = int(body.get("wrong_words", 0) or 0)
|
||
|
||
pool = await get_pool()
|
||
async with pool.acquire() as conn:
|
||
user_exists = await conn.fetchval(
|
||
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
|
||
)
|
||
if not user_exists:
|
||
raise HTTPException(401, "User not registered")
|
||
|
||
user = await conn.fetchrow(
|
||
"SELECT current_level, difficulty FROM users WHERE telegram_id = $1", telegram_id
|
||
)
|
||
current_level = user["current_level"] or "A1"
|
||
difficulty = user["difficulty"] or "medium"
|
||
|
||
# Читаем серверные счётчики (не из body)
|
||
progress = await conn.fetchrow(
|
||
"SELECT current_hints_used, current_list_opened "
|
||
"FROM bubble_words_progress WHERE user_id = $1",
|
||
telegram_id
|
||
)
|
||
hints_used = (progress["current_hints_used"] if progress else 0) or 0
|
||
hints_used = min(max(0, hints_used), 3)
|
||
list_opened = (progress["current_list_opened"] if progress else 0) or 0
|
||
|
||
# 🔧 НОВОЕ (14.10.2026): очки по формуле филворда.
|
||
# Hard — фикс 150. Easy/Medium — 100 − 20×hints − 20×list + bonus.
|
||
if difficulty == "hard":
|
||
if hints_used > 0 or list_opened:
|
||
raise HTTPException(
|
||
status_code=400,
|
||
detail="Hints and word list are disabled on Hard difficulty"
|
||
)
|
||
points = 150
|
||
else:
|
||
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, "bubbles", points)
|
||
score = xp_result["points"]
|
||
|
||
# 🔧 НОВОЕ (15.10.2026): флаги для накопления серий.
|
||
no_hints_clean = 1 if (hints_used == 0 and not list_opened) else 0
|
||
perfect_clean = 1 if (hints_used == 0 and not list_opened and wrong_words == 0) else 0
|
||
|
||
await conn.execute("""
|
||
INSERT INTO bubble_words_progress
|
||
(user_id, levels_completed, total_score, level,
|
||
current_hints_used, current_list_opened, current_level_words, hinted_words,
|
||
words_collected, no_hints_streak, perfect_streak)
|
||
VALUES ($1, 1, $2, $3, 0, 0, '[]'::jsonb, '{}', $4, $5, $6)
|
||
ON CONFLICT (user_id) DO UPDATE
|
||
SET levels_completed = bubble_words_progress.levels_completed + 1,
|
||
total_score = bubble_words_progress.total_score + $2,
|
||
level = $3,
|
||
current_hints_used = 0,
|
||
current_list_opened = 0,
|
||
current_level_words = '[]'::jsonb,
|
||
hinted_words = '{}',
|
||
words_collected = COALESCE(bubble_words_progress.words_collected, 0) + $4,
|
||
no_hints_streak = CASE WHEN $5 = 1
|
||
THEN COALESCE(bubble_words_progress.no_hints_streak, 0) + 1 ELSE 0 END,
|
||
perfect_streak = CASE WHEN $6 = 1
|
||
THEN COALESCE(bubble_words_progress.perfect_streak, 0) + 1 ELSE 0 END
|
||
""", telegram_id, score, current_level, words_count, no_hints_clean, perfect_clean)
|
||
|
||
# 🔧 НОВОЕ (15.10.2026): читаем актуальные счётчики для проверки достижений.
|
||
stats = await conn.fetchrow("""
|
||
SELECT words_collected, no_hints_streak, perfect_streak, total_score
|
||
FROM bubble_words_progress WHERE user_id = $1
|
||
""", telegram_id)
|
||
words_collected = stats["words_collected"] or 0
|
||
no_hints_streak = stats["no_hints_streak"] or 0
|
||
perfect_streak = stats["perfect_streak"] or 0
|
||
bubble_total_score = stats["total_score"] or 0
|
||
|
||
# Данные для достижений
|
||
total_levels = await conn.fetchval(
|
||
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
|
||
telegram_id
|
||
) or 0
|
||
|
||
achievements_to_check = [
|
||
("bubble_levels", total_levels),
|
||
("total_score", xp_result["total_xp"]),
|
||
]
|
||
if hints_used == 0:
|
||
achievements_to_check.append(("bubble_no_hints", 1))
|
||
if completion_time is not None and 0 < completion_time <= 45:
|
||
achievements_to_check.append(("bubble_speed_45", 45))
|
||
if completion_time is not None and 0 < completion_time <= 30:
|
||
achievements_to_check.append(("bubble_speed_30", 30))
|
||
|
||
# 🔧 НОВОЕ (15.10.2026): триггеры новых достижений.
|
||
# bubble_words — всего слов собрано
|
||
achievements_to_check.append(("bubble_words", words_collected))
|
||
|
||
# bubble_streak — серия без подсказок (если > 0)
|
||
if no_hints_streak > 0:
|
||
achievements_to_check.append(("bubble_streak", no_hints_streak))
|
||
|
||
# bubble_xp — XP в пузырях (total_score — очки именно пузырей)
|
||
achievements_to_check.append(("bubble_xp", bubble_total_score))
|
||
|
||
# bubble_speed_15 — быстрее 15 сек
|
||
if completion_time is not None and 0 < completion_time <= 15:
|
||
achievements_to_check.append(("bubble_speed_15", 15))
|
||
|
||
# bubble_speed_10 — быстрее 10 сек
|
||
if completion_time is not None and 0 < completion_time <= 10:
|
||
achievements_to_check.append(("bubble_speed_10", 10))
|
||
|
||
# Достижения — вне транзакции
|
||
from routers.achievements import check_and_award_achievements
|
||
new_achievements = []
|
||
for ach_type, value in achievements_to_check:
|
||
ach = await check_and_award_achievements(telegram_id, ach_type, value)
|
||
new_achievements.extend(ach)
|
||
|
||
return {
|
||
"status": "ok",
|
||
"score": score,
|
||
"completion_time": completion_time,
|
||
"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"],
|
||
}
|
||
|
||
|
||
@router.get("/progress")
|
||
async def get_bubble_progress(request: Request):
|
||
"""Статистика пользователя в Bubble Words"""
|
||
telegram_id, _ = await require_auth(request)
|
||
|
||
pool = await get_pool()
|
||
async with pool.acquire() as conn:
|
||
progress = await conn.fetchrow(
|
||
"SELECT levels_completed, total_score FROM bubble_words_progress WHERE user_id = $1",
|
||
telegram_id
|
||
)
|
||
|
||
return {
|
||
"levels_completed": progress["levels_completed"] if progress else 0,
|
||
"total_score": progress["total_score"] if progress else 0,
|
||
} |