Files
filwordspl-backend/routers/bubblewords.py

510 lines
21 KiB
Python
Raw Permalink Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import 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 — фикс 110. 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 = 110
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 hints_used == 0 and not list_opened and wrong_words == 0:
achievements_to_check.append(("bubble_perfect", 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_no_mistakes — уровень без ошибок
if wrong_words == 0:
achievements_to_check.append(("bubble_no_mistakes", 1))
# 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_perfect_streak — серия идеальных (если > 0)
if perfect_streak > 0:
achievements_to_check.append(("bubble_perfect_streak", perfect_streak))
# Достижения — вне транзакции
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,
}