295 lines
11 KiB
Python
295 lines
11 KiB
Python
import random
|
|
import hashlib # 🔧 НОВОЕ: импорт hashlib для стабильного хэширования
|
|
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 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
|
|
|
|
# Прогрессия по количеству слов на уровне
|
|
if current_bubble_level <= 10:
|
|
num_words = random.choice([3, 4])
|
|
elif current_bubble_level <= 25:
|
|
num_words = random.choice([5, 6])
|
|
else:
|
|
num_words = random.choice([7, 8])
|
|
|
|
# 🔧 ФИКС (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)
|
|
|
|
return {
|
|
"words": result_words,
|
|
"bubbles": all_parts,
|
|
"level": current_bubble_level,
|
|
}
|
|
|
|
|
|
@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")
|
|
list_opened = bool(body.get("list_opened", False))
|
|
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"
|
|
|
|
# Читаем серверный hints_used
|
|
hints_used = await conn.fetchval(
|
|
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1",
|
|
telegram_id
|
|
) or 0
|
|
hints_used = min(max(0, hints_used), 3)
|
|
|
|
# 🆕 Расчёт звёзд
|
|
# Старт 5. Штрафы: hints(1) + wrong_words(до 3) + time(1)
|
|
time_penalty = 1 if (completion_time and completion_time > 60) else 0
|
|
wrong_penalty = min(max(0, wrong_words), 3)
|
|
hint_penalty = 1 if hints_used > 0 else 0
|
|
list_penalty = 1 if list_opened else 0
|
|
stars = max(1, 5 - time_penalty - wrong_penalty - hint_penalty - list_penalty)
|
|
|
|
# Начисляем XP
|
|
from services.xp import award_xp
|
|
xp_result = await award_xp(conn, telegram_id, "bubbles", stars)
|
|
score = xp_result["points"]
|
|
|
|
await conn.execute("""
|
|
INSERT INTO bubble_words_progress (user_id, levels_completed, total_score, level, current_hints_used)
|
|
VALUES ($1, 1, $2, $3, 0)
|
|
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
|
|
""", telegram_id, score, current_level)
|
|
|
|
# Данные для достижений
|
|
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 stars == 5:
|
|
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))
|
|
if completion_time is not None and 0 < completion_time <= 30:
|
|
achievements_to_check.append(("bubble_speed_30", 30))
|
|
|
|
# Достижения — вне транзакции
|
|
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-поля
|
|
"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"],
|
|
}
|
|
|
|
|
|
@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,
|
|
} |