From 84927b063f25016a3324b7fd5c7509b4c516094c Mon Sep 17 00:00:00 2001 From: Drobysh Date: Fri, 9 Oct 2026 08:12:19 +0000 Subject: [PATCH] feat: XP foundation + waves + featured game + profile + leaderboard by total_xp MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - services/xp.py: award_xp, level_for, RANKS (48), featured_game - services/waves.py: wave_plan, grid_size_for, wave_medal - routers/featured.py: GET /featured (игра дня ×1.5) - routers/users.py: POST /set-nickname, POST /set-avatar - routers/app_auth.py: /auth/me с XP-полями (level, rank_key, rank_name, xp) - routers/game.py: award_xp + 3 штрафа + POST /game/next (волны) - routers/wordquiz.py: award_xp + серии в choose_progress - routers/bubblewords.py: award_xp + 4 штрафа - routers/sentences.py: award_xp по длине предложения - routers/leaderboard.py: сортировка по total_xp, XP-поля в ответе - database.py: миграции user_profile, xp_log, choose_progress, user_seen_levels, user_game_progress, wave_results, bubble_levels, user_word_stats - main.py: подключение routers/featured Проверено: - /auth/me отдаёт level=1, rank_00, xp_in_level - /featured отдаёт wordsearch + seconds_left - /game/complete-level начисляет XP через award_xp - xp_log, user_profile заполняются - /game/next выдаёт уровень по волнам - /leaderboard сортирует по total_xp --- database.py | 189 ++++++++++++++ main.py | 2 + routers/app_auth.py | 112 +++++--- routers/bubblewords.py | 74 +++--- routers/featured.py | 36 +++ routers/game.py | 276 +++++++++++++++----- routers/leaderboard.py | 272 +++++++++++-------- routers/sentences.py | 38 ++- routers/users.py | 84 +++++- routers/wordquiz.py | 110 +++++--- scripts/generate_levels.py | 516 +++++++++++++++++++++++++++++++++++++ services/waves.py | 64 +++++ services/xp.py | 305 ++++++++++++++++++++++ 13 files changed, 1800 insertions(+), 278 deletions(-) create mode 100644 routers/featured.py create mode 100644 scripts/generate_levels.py create mode 100644 services/waves.py create mode 100644 services/xp.py diff --git a/database.py b/database.py index be399eb..1cb57d8 100644 --- a/database.py +++ b/database.py @@ -1335,6 +1335,195 @@ async def init_db(): """) logger.info("Table auth_identities initialized (Pleily)") + # ============================================================ + # 🔧 НОВОЕ (08.10.2026): XP-фундамент Pleily. + # user_profile, xp_log, choose_progress, user_seen_levels, + # user_game_progress, wave_results, bubble_levels, + # user_seen_bubble_levels, user_word_stats. + # + расширение sentences (tokens, alt_orders, word_count). + # ============================================================ + + # ---------- user_profile ---------- + await conn.execute(""" + CREATE TABLE IF NOT EXISTS user_profile ( + user_id BIGINT PRIMARY KEY + REFERENCES users(telegram_id) ON DELETE CASCADE, + nickname TEXT, + avatar_id INTEGER DEFAULT 0, + total_xp INTEGER DEFAULT 0, + weekly_xp INTEGER DEFAULT 0, + week_started_at DATE DEFAULT CURRENT_DATE, + updated_at TIMESTAMP DEFAULT NOW() + ) + """) + await conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_user_profile_weekly + ON user_profile(weekly_xp DESC) + """) + logger.info("Table user_profile initialized (XP)") + + # ---------- xp_log ---------- + await conn.execute(""" + CREATE TABLE IF NOT EXISTS xp_log ( + id BIGSERIAL PRIMARY KEY, + user_id BIGINT NOT NULL + REFERENCES users(telegram_id) ON DELETE CASCADE, + game TEXT NOT NULL, + stars INTEGER NOT NULL, + base_points INTEGER NOT NULL, + multiplier NUMERIC(3,2) NOT NULL DEFAULT 1.0, + points INTEGER NOT NULL, + created_at TIMESTAMP DEFAULT NOW() + ) + """) + await conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_xp_log_user_date + ON xp_log(user_id, created_at DESC) + """) + logger.info("Table xp_log initialized (XP)") + + # ---------- choose_progress (серии в "Выбери слово") ---------- + await conn.execute(""" + CREATE TABLE IF NOT EXISTS choose_progress ( + user_id BIGINT PRIMARY KEY + REFERENCES users(telegram_id) ON DELETE CASCADE, + current_streak INTEGER DEFAULT 0, + best_streak INTEGER DEFAULT 0, + updated_at TIMESTAMP DEFAULT NOW() + ) + """) + logger.info("Table choose_progress initialized") + + # ---------- user_seen_levels (филворд: какие уровни видел) ---------- + await conn.execute(""" + CREATE TABLE IF NOT EXISTS user_seen_levels ( + user_id BIGINT NOT NULL + REFERENCES users(telegram_id) ON DELETE CASCADE, + level_id INTEGER NOT NULL + REFERENCES levels(id) ON DELETE CASCADE, + seen_at TIMESTAMP DEFAULT NOW(), + PRIMARY KEY (user_id, level_id) + ) + """) + await conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_user_seen_levels_user + ON user_seen_levels(user_id, seen_at DESC) + """) + logger.info("Table user_seen_levels initialized") + + # ---------- user_game_progress (сессии филворда) ---------- + await conn.execute(""" + CREATE TABLE IF NOT EXISTS user_game_progress ( + user_id BIGINT PRIMARY KEY + REFERENCES users(telegram_id) ON DELETE CASCADE, + session_number INTEGER DEFAULT 1, + session_level_number INTEGER DEFAULT 1, + global_level_number INTEGER DEFAULT 1, + time_limit_seconds INTEGER, + updated_at TIMESTAMP DEFAULT NOW() + ) + """) + logger.info("Table user_game_progress initialized") + + # ---------- wave_results (итоги волны) ---------- + await conn.execute(""" + CREATE TABLE IF NOT EXISTS wave_results ( + id BIGSERIAL PRIMARY KEY, + user_id BIGINT NOT NULL + REFERENCES users(telegram_id) ON DELETE CASCADE, + wave_number INTEGER NOT NULL, + stars_earned INTEGER DEFAULT 0, + medal TEXT DEFAULT 'none', + completed_at TIMESTAMP DEFAULT NOW(), + UNIQUE (user_id, wave_number) + ) + """) + await conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_wave_results_user + ON wave_results(user_id, wave_number DESC) + """) + logger.info("Table wave_results initialized") + + # ---------- bubble_levels ---------- + await conn.execute(""" + CREATE TABLE IF NOT EXISTS bubble_levels ( + id BIGSERIAL PRIMARY KEY, + word_ids INTEGER[] NOT NULL, + difficulty INTEGER DEFAULT 1, + created_at TIMESTAMP DEFAULT NOW() + ) + """) + logger.info("Table bubble_levels initialized") + + # ---------- user_seen_bubble_levels ---------- + await conn.execute(""" + CREATE TABLE IF NOT EXISTS user_seen_bubble_levels ( + user_id BIGINT NOT NULL + REFERENCES users(telegram_id) ON DELETE CASCADE, + bubble_level_id BIGINT NOT NULL + REFERENCES bubble_levels(id) ON DELETE CASCADE, + seen_at TIMESTAMP DEFAULT NOW(), + PRIMARY KEY (user_id, bubble_level_id) + ) + """) + logger.info("Table user_seen_bubble_levels initialized") + + # ---------- user_word_stats (повторение слов) ---------- + await conn.execute(""" + CREATE TABLE IF NOT EXISTS user_word_stats ( + user_id BIGINT NOT NULL + REFERENCES users(telegram_id) ON DELETE CASCADE, + word_pl TEXT NOT NULL, + correct INTEGER DEFAULT 0, + wrong INTEGER DEFAULT 0, + last_seen_at TIMESTAMP DEFAULT NOW(), + PRIMARY KEY (user_id, word_pl) + ) + """) + await conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_user_word_stats_user + ON user_word_stats(user_id, last_seen_at DESC) + """) + logger.info("Table user_word_stats initialized") + + # ---------- sentences: tokens, alt_orders, word_count ---------- + for col_name, col_type in ( + ("tokens", "JSONB DEFAULT '[]'::jsonb"), + ("alt_orders", "JSONB DEFAULT '[]'::jsonb"), + ("word_count", "INTEGER DEFAULT 0"), + ): + col_exists = await conn.fetchval(""" + SELECT 1 FROM information_schema.columns + WHERE table_name = 'sentences' AND column_name = $1 + """, col_name) + if not col_exists: + await conn.execute( + f"ALTER TABLE sentences ADD COLUMN {col_name} {col_type}" + ) + logger.info(f"Added {col_name} column to sentences") + + # Backfill: word_count для существующих предложений + await conn.execute(""" + UPDATE sentences + SET word_count = array_length( + regexp_split_to_array(trim(sentence_pl), '\\s+'), 1 + ) + WHERE word_count = 0 OR word_count IS NULL + """) + logger.info("Backfilled sentences.word_count") + + # ---------- Backfill: user_profile для существующих юзеров ---------- + await conn.execute(""" + INSERT INTO user_profile (user_id, total_xp, weekly_xp) + SELECT u.telegram_id, 0, 0 + FROM users u + WHERE NOT EXISTS ( + SELECT 1 FROM user_profile p WHERE p.user_id = u.telegram_id + ) + ON CONFLICT (user_id) DO NOTHING + """) + logger.info("Backfilled user_profile for existing users") + await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level_number ON sentences(level, sentence_number)") # Оставляем score-индексы (не дубли) await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)") diff --git a/main.py b/main.py index f8f9ce3..9f2d0f3 100644 --- a/main.py +++ b/main.py @@ -15,6 +15,7 @@ from routers import users, game, hints, leaderboard, sentences, achievements, wo from routers import lectures, admin_auth, admin_wordsearch, admin_users from routers import admin_ai # 🔧 НОВОЕ from routers import app_auth # 🆕 Pleily auth +from routers import featured as featured_router # 🔧 НОВОЕ (08.10.2026) from routers.sentences import init_sentences from routers.achievements import init_achievements from routers.learning_data import init_learning_data @@ -375,6 +376,7 @@ app.include_router(admin_wordsearch.router) app.include_router(admin_users.router) app.include_router(admin_ai.router) # 🔧 НОВОЕ app.include_router(app_auth.router) # 🆕 Pleily +app.include_router(featured_router.router) # 🔧 НОВОЕ (08.10.2026) # ============ Базовые эндпоинты ============ diff --git a/routers/app_auth.py b/routers/app_auth.py index 0d1b629..cd28db1 100644 --- a/routers/app_auth.py +++ b/routers/app_auth.py @@ -18,6 +18,12 @@ Telegram-юзеры сохраняют свои положительные teleg - DELETE /me — удаление аккаунта (Apple требует) 🔧 НОВОЕ (07.10.2026): pleily_auth — первая версия. +🔧 ФИКС (07.10.2026): device_id_in_users — + теперь device_id пишется и в users.device_id, и в auth_identities. + Это нужно для SQL-запросов по device_id (админка, миграции). +🔧 НОВОЕ (08.10.2026): auth_me_xp_fields — + в /auth/me добавлены XP-поля: level, rank_key, rank_name, + xp_in_level, xp_needed, total_xp, weekly_xp, weekly_rank. """ import logging import uuid @@ -97,11 +103,14 @@ async def _create_app_user(conn, device_id: str) -> int: uid_row = await conn.fetchrow("SELECT nextval('app_user_id_seq') AS uid") uid = uid_row["uid"] - # Создаём юзера в users + # 🔧 ФИКС (07.10.2026): device_id_in_users — + # раньше device_id сохранялся только в auth_identities, + # а в users.device_id был NULL. Теперь — в обоих местах. + # Это нужно для SQL-запросов по device_id (админка, миграции). await conn.execute(""" - INSERT INTO users (telegram_id, username, source) - VALUES ($1, $2, 'app') - """, uid, f"app_user_{abs(uid)}") + INSERT INTO users (telegram_id, username, source, device_id) + VALUES ($1, $2, 'app', $3) + """, uid, f"app_user_{abs(uid)}", device_id) # Создаём identity await conn.execute(""" @@ -174,45 +183,78 @@ async def auth_device(request: Request): @router.get("/me") async def auth_me(request: Request): """ - Возвращает данные текущего Pleily-юзера. Для тестов и отладки. - - Требует Authorization: Bearer . + Текущий юзер + XP-поля. + + 🔧 НОВОЕ (08.10.2026): добавлены level, rank_key, rank_name, + xp_in_level, xp_needed, total_xp, weekly_xp. """ - user_id, _username = await require_auth(request) + telegram_id, _ = await require_auth(request) pool = await get_pool() async with pool.acquire() as conn: - row = await conn.fetchrow(""" - SELECT telegram_id, username, source, app_language, current_level, created_at + user = await conn.fetchrow( + """ + SELECT telegram_id, username, app_language, current_level, + source, device_id, apple_id, created_at FROM users WHERE telegram_id = $1 - """, user_id) + """, + telegram_id, + ) + if not user: + raise HTTPException(401, "User not found") - if not row: - raise HTTPException(404, "User not found") + profile = await conn.fetchrow( + """ + SELECT nickname, avatar_id, total_xp, weekly_xp, week_started_at + FROM user_profile WHERE user_id = $1 + """, + telegram_id, + ) - # Получаем identities юзера (для диагностики) - identities_rows = await conn.fetch(""" - SELECT provider, provider_uid, created_at - FROM auth_identities WHERE user_id = $1 - ORDER BY created_at - """, user_id) + # Weekly rank + weekly_rank = await conn.fetchval( + """ + SELECT COUNT(*) + 1 + FROM user_profile + WHERE weekly_xp > COALESCE(( + SELECT weekly_xp FROM user_profile WHERE user_id = $1 + ), 0) + """, + telegram_id, + ) - return { - "user_id": row["telegram_id"], - "username": row["username"], - "source": row["source"], - "app_language": row["app_language"], - "current_level": row["current_level"], - "created_at": row["created_at"].isoformat() if row["created_at"] else None, - "identities": [ - { - "provider": r["provider"], - "provider_uid": r["provider_uid"], - "created_at": r["created_at"].isoformat() if r["created_at"] else None, - } - for r in identities_rows - ], - } + # Считаем уровень + from services.xp import level_for, rank_for + + total_xp = int(profile["total_xp"]) if profile else 0 + weekly_xp = int(profile["weekly_xp"]) if profile else 0 + level, xp_in_level, xp_needed, rank_key = level_for(total_xp) + + lang = (user["app_language"] or "ru").lower() + if lang not in ("pl", "ru", "uk", "en"): + lang = "ru" + + return { + "user_id": user["telegram_id"], + "username": user["username"], + "nickname": profile["nickname"] if profile else None, + "avatar_id": int(profile["avatar_id"]) if profile and profile["avatar_id"] is not None else 0, + "app_language": user["app_language"], + "current_level": user["current_level"], + "source": user["source"], + "device_id": str(user["device_id"]) if user["device_id"] else None, + "apple_id": user["apple_id"], + "created_at": user["created_at"].isoformat() if user["created_at"] else None, + # --- XP --- + "total_xp": total_xp, + "weekly_xp": weekly_xp, + "level": level, + "rank_key": rank_key, + "rank_name": rank_for(level, lang), + "xp_in_level": xp_in_level, + "xp_needed": xp_needed, + "weekly_rank": int(weekly_rank) if weekly_rank else 0, + } @router.delete("/me") diff --git a/routers/bubblewords.py b/routers/bubblewords.py index ccae11a..0bc4899 100644 --- a/routers/bubblewords.py +++ b/routers/bubblewords.py @@ -171,13 +171,21 @@ async def get_next_bubble_level(request: Request): @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") - # 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords — - # hints_used больше НЕ берём от клиента. Читаем из bubble_words_progress.current_hints_used. + 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: @@ -187,19 +195,29 @@ async def complete_bubble_level(request: Request): if not user_exists: raise HTTPException(401, "User not registered") - # Получаем current_level пользователя current_level = await conn.fetchval( "SELECT current_level FROM users WHERE telegram_id = $1", telegram_id ) or "A1" - # 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords — - # читаем серверный hints_used. + # Читаем серверный 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) - score = max(10, 100 - hints_used * 10) + + # 🆕 Расчёт звёзд + # Старт 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) @@ -211,42 +229,26 @@ async def complete_bubble_level(request: Request): current_hints_used = 0 """, telegram_id, score, current_level) - # 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_bubblewords — - # вызовы достижений вынесены за async with pool.acquire() (паттерн game.py). + # Данные для достижений total_levels = await conn.fetchval( "SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1", telegram_id ) or 0 - wordsearch_score = await conn.fetchval( - "SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL", - telegram_id - ) or 0 - sentence_score = await conn.fetchval( - "SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL", - 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 = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score achievements_to_check = [ ("bubble_levels", total_levels), - ("total_score", grand_total), + ("total_score", xp_result["total_xp"]), ] if hints_used == 0: achievements_to_check.append(("bubble_no_hints", 1)) - if score == 100: + if stars == 5: achievements_to_check.append(("bubble_perfect", 1)) - if completion_time is not None and completion_time > 0 and int(completion_time) <= 45: + 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)) - # 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire() + # Достижения — вне транзакции from routers.achievements import check_and_award_achievements new_achievements = [] for ach_type, value in achievements_to_check: @@ -258,6 +260,18 @@ async def complete_bubble_level(request: Request): "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"], } diff --git a/routers/featured.py b/routers/featured.py new file mode 100644 index 0000000..a6b5e1b --- /dev/null +++ b/routers/featured.py @@ -0,0 +1,36 @@ +"""GET /featured — игра дня + обратный отсчёт.""" +from fastapi import APIRouter, Request + +from auth import require_auth +from services.xp import featured_game, featured_seconds_left, GAMES + +router = APIRouter(tags=["featured"]) + +# 🆕 Игры, которые реально работают в приложении. +# Пока не подключим все 4 — фильтруем. +PLAYABLE_GAMES = {"wordsearch"} # потом добавим choose, sentence, bubbles + + +@router.get("/featured") +async def get_featured(request: Request): + """ + Возвращает игру дня (глобально для всех) и секунды до смены. + + 🔧 (08.10.2026): если игра дня ещё не подключена в приложении — + отдаём ближайшую играбельную (для UI-подсказки ×1.5). + """ + await require_auth(request) + + game = featured_game() + # Если featured не играбельная — отдаём первую играбельную + if game not in PLAYABLE_GAMES: + playable = [g for g in GAMES if g in PLAYABLE_GAMES] + if playable: + game = playable[0] + + return { + "game": game, + "seconds_left": featured_seconds_left(), + "multiplier": 1.5, + "is_actually_featured": game == featured_game(), + } \ No newline at end of file diff --git a/routers/game.py b/routers/game.py index 7e746a7..6c4a092 100644 --- a/routers/game.py +++ b/routers/game.py @@ -27,23 +27,12 @@ async def get_progress(request: Request): current_level = user["current_level"] or "A1" - # 🔧 ФИКС (30.09.2026): progress_uses_per_level — - # возвращаем last_completed_level для ТЕКУЩЕГО уровня языка, - # а не глобальный счётчик (который смешивал A1+A2+B1). - last_by_level = user["last_completed_by_level"] or {} - if isinstance(last_by_level, str): - try: - import json as _json - last_by_level = _json.loads(last_by_level) - except Exception: - last_by_level = {} + # 🔧 ОБНОВЛЕНО (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 - last_completed_for_current = ( - last_by_level.get(current_level, 0) - if isinstance(last_by_level, dict) - else 0 - ) - # Очки из филвордов wordsearch_score = await conn.fetchval( "SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1", @@ -71,8 +60,7 @@ async def get_progress(request: Request): total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0) return { - "last_completed_level": last_completed_for_current, - "last_completed_by_level": last_by_level, + "last_completed_level": last_completed, "total_score": total_score, "current_level": current_level } @@ -93,42 +81,26 @@ async def get_level(request: Request, level_number: int): 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 - # 🔧 ФИКС (30.09.2026): last_completed_by_level — - # используем per-level счётчик. Fallback на last_completed_level (старый). - last_completed_by_level = user["last_completed_by_level"] or {} - if isinstance(last_completed_by_level, str): - try: - import json as _json - last_completed_by_level = _json.loads(last_completed_by_level) - except Exception: - last_completed_by_level = {} - - last_completed = last_completed_by_level.get(current_level, 0) if isinstance(last_completed_by_level, dict) else 0 - # Проверяем, что уровень доступен (не дальше следующего за пройденным) if level_number > 1 and level_number > last_completed + 1: raise HTTPException(403, "Level not available yet. Complete previous level first.") - # 🔧 ФИКС (29.09.2026): приоритет ручным уровням. - # Если есть уровень, созданный вручную (created_by IS NOT NULL) — - # показываем его. Иначе — fallback на авто (created_by IS NULL). + # 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные). + # Ищем по level_number без created_by и без current_level. + # is_active = TRUE — чтобы черновики не показывались. level = await conn.fetchrow(""" SELECT * FROM levels - WHERE level = $1 AND level_number = $2 - AND created_by IS NOT NULL + WHERE level_number = $1 + AND is_active = TRUE LIMIT 1 - """, current_level, level_number) - - # Fallback на авто, если ручного нет - if not level: - level = await conn.fetchrow(""" - SELECT * FROM levels - WHERE level = $1 AND level_number = $2 - AND created_by IS NULL - LIMIT 1 - """, current_level, level_number) + """, level_number) if not level: raise HTTPException(404, "Level not found") @@ -312,6 +284,8 @@ async def complete_level(request: Request): # 🔧 ФИКС (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( @@ -330,9 +304,10 @@ async def complete_level(request: Request): current_level_number = level["level_number"] level_name = level["level"] or "A1" - # Проверяем, что уровень принадлежит текущему уровню пользователя - if level_name != (user["current_level"] or "A1"): - raise HTTPException(403, "This level does not belong to your current level") + # 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'. + # Уровни глобальные, поэтому убираем проверку «уровень принадлежит + # твоему current_level». Оставляем только проверку прогресса выше. + # (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.) # 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row — # раньше already_completed = True при ЛЮБОЙ строке user_progress. @@ -365,19 +340,41 @@ async def complete_level(request: Request): telegram_id, level_id ) or 0 - # 🔧 ФИКС (24.09.2026): client_controlled_hints_game — - # читаем hints_used из БД, не доверяем клиенту. + # 🔧 НОВОЕ (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) - score = max(10, 100 - hints_used * 10) - - # 🔧 ФИКС (23.09.2026): client_controlled_achievement_values — - # сбрасываем current_streak в 0 при завершении уровня. - # + # 🆕 Штрафы (филворд): + # -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 (юзер взял подсказку → уровень не завершится). @@ -395,22 +392,15 @@ async def complete_level(request: Request): current_streak = 0 """, telegram_id, level_id, hints_used, score, level_name) - # 🔧 ФИКС (30.09.2026): last_completed_by_level — - # обновляем per-level счётчик (JSONB) + старый last_completed_level. + # 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress. + # Обновляем только users.last_completed_level — глобальный. + # last_completed_by_level (JSONB) остаётся в БД для совместимости, + # но больше не пишется. await conn.execute(""" UPDATE users - SET last_completed_level = GREATEST(last_completed_level, $2), - last_completed_by_level = jsonb_set( - COALESCE(last_completed_by_level, '{}'::jsonb), - ARRAY[$3::text], - to_jsonb(GREATEST( - COALESCE((last_completed_by_level->>$3)::int, 0), - $2 - )), - true - ) + SET last_completed_level = GREATEST(COALESCE(last_completed_level, 0), $2) WHERE telegram_id = $1 - """, telegram_id, current_level_number, level_name) + """, telegram_id, current_level_number) # Собираем данные для достижений внутри блока levels_completed = await conn.fetchval( @@ -471,8 +461,154 @@ async def complete_level(request: Request): new_achievements.extend(ach) return { - "status": "ok", + "status": "ok", "score": score, "already_completed": False, - "new_achievements": new_achievements + "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. Смотрим user_game_progress.global_level_number. + 2. Определяем волну и размер сетки через wave_plan. + 3. Ищем непройденный уровень нужного размера (в user_seen_levels). + 4. Помечаем как seen, обновляем user_game_progress. + 5. Возвращаем level_number. + """ + 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 + 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 + 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) + + # Определяем волну и размер + from services.waves import wave_for_level, level_in_wave, grid_size_for + 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 + + await conn.execute( + """ + UPDATE user_game_progress + SET global_level_number = $2, + session_number = $3, + session_level_number = $4, + updated_at = NOW() + WHERE user_id = $1 + """, + telegram_id, next_global, next_session, next_session_level, + ) + + 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, } \ No newline at end of file diff --git a/routers/leaderboard.py b/routers/leaderboard.py index 9822b45..d928178 100644 --- a/routers/leaderboard.py +++ b/routers/leaderboard.py @@ -10,7 +10,18 @@ LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"] @router.get("") async def get_leaderboard(request: Request, limit: int = 50): - """Рейтинг игроков — быстрое чтение из кэша""" + """ + Рейтинг игроков. + + 🔧 ОБНОВЛЕНО (08.10.2026): XP-фундамент. + + Сортировка: total_xp DESC → total_score DESC. + weekly_xp в БД остаётся, но больше НЕ используется в сортировке. + Legacy-поля (total_score, wordsearch_score, ...) сохранены для Mini App. + + Новые поля в каждой строке: total_xp, level, rank_key, rank_name, + xp_in_level, xp_needed, avatar_id. + """ telegram_id, _ = await require_auth(request) if limit < 1: @@ -28,17 +39,39 @@ async def get_leaderboard(request: Request, limit: int = 50): current_level = user["current_level"] or "A1" - # Быстрое чтение из MATERIALIZED VIEW + # 🆕 Топ-N: matview + LEFT JOIN user_profile для XP. + # 🔧 ОБНОВЛЕНО (08.10.2026): сортировка по total_xp (weekly_xp убран). rows = await conn.fetch(""" - SELECT * FROM leaderboard_cache - ORDER BY total_score DESC + SELECT + lc.*, + COALESCE(p.weekly_xp, 0) AS weekly_xp, + COALESCE(p.total_xp, 0) AS total_xp, + COALESCE(p.avatar_id, 0) AS avatar_id, + u.app_language + FROM leaderboard_cache lc + LEFT JOIN user_profile p ON p.user_id = lc.telegram_id + LEFT JOIN users u ON u.telegram_id = lc.telegram_id + ORDER BY COALESCE(p.total_xp, 0) DESC, + lc.total_score DESC, + lc.telegram_id ASC LIMIT $1 """, limit) - leaderboard = [] - for i, row in enumerate(rows): - leaderboard.append({ - "rank": i + 1, + # Импорт XP-хелперов + from services.xp import level_for, rank_for + + def _serialize_row(row, rank_num): + """Собирает строку рейтинга с legacy + XP-полями.""" + weekly_xp = int(row["weekly_xp"] or 0) + total_xp = int(row["total_xp"] or 0) + level, xp_in_level, xp_needed, rank_key = level_for(total_xp) + lang = (row.get("app_language") or "ru").lower() + if lang not in ("pl", "ru", "uk", "en"): + lang = "ru" + + return { + # Legacy (Mini App) + "rank": rank_num, "telegram_id": row["telegram_id"], "username": row["username"] or f"Player{row['telegram_id']}", "total_score": row["total_score"], @@ -50,100 +83,131 @@ async def get_leaderboard(request: Request, limit: int = 50): "bubble_levels_completed": row["bubble_levels_completed"], "levels_completed": 0, "sentences_completed": 0, - }) + # 🆕 XP (Pleily) + "weekly_xp": weekly_xp, # оставлен для legacy Mini App + "total_xp": total_xp, + "level": level, + "rank_key": rank_key, + "rank_name": rank_for(level, lang), + "xp_in_level": xp_in_level, + "xp_needed": xp_needed, + "avatar_id": int(row["avatar_id"] or 0), + "app_language": lang, + } - # 🔧 ФИКС (25.09.2026): leaderboard_rank_wrong_for_uncached_user — - # если пользователя нет в leaderboard_cache, подзапрос вернёт NULL, - # и COUNT(*) + 1 = 1 (юзер видит себя первым, хотя у него 0 очков). - # Теперь: если user нет в кэше — считаем его место по количеству - # записей с total_score > 0 + 1 (в конец списка). - my_total_in_cache = await conn.fetchval(""" - SELECT total_score FROM leaderboard_cache WHERE telegram_id = $1 - """, telegram_id) + leaderboard = [ + _serialize_row(row, rank_num=i + 1) + for i, row in enumerate(rows) + ] - if my_total_in_cache is None: - # Пользователя нет в кэше — считаем по количеству с > 0 - user_rank = await conn.fetchval(""" - SELECT COUNT(*) + 1 FROM leaderboard_cache - WHERE total_score > 0 - """) or 1 - else: - user_rank = await conn.fetchval(""" - SELECT COUNT(*) + 1 FROM leaderboard_cache - WHERE total_score > $1 - """, my_total_in_cache) - - # Персональная статистика пользователя + # ============ Мой ранг ============ + # Читаем мои XP + legacy-статистику. my_row = await conn.fetchrow(""" - SELECT * FROM leaderboard_cache WHERE telegram_id = $1 + SELECT + lc.*, + COALESCE(p.weekly_xp, 0) AS weekly_xp, + COALESCE(p.total_xp, 0) AS total_xp, + COALESCE(p.avatar_id, 0) AS avatar_id, + u.app_language + FROM leaderboard_cache lc + LEFT JOIN user_profile p ON p.user_id = lc.telegram_id + LEFT JOIN users u ON u.telegram_id = lc.telegram_id + WHERE lc.telegram_id = $1 """, telegram_id) - if my_row: + # Если юзера нет в matview — пробуем только user_profile. + if not my_row: + my_profile = await conn.fetchrow(""" + SELECT + p.weekly_xp, p.total_xp, p.avatar_id, + u.username, u.app_language, u.current_level + FROM user_profile p + JOIN users u ON u.telegram_id = p.user_id + WHERE p.user_id = $1 + """, telegram_id) + + if my_profile: + my_weekly_xp = int(my_profile["weekly_xp"] or 0) + my_total_xp = int(my_profile["total_xp"] or 0) + my_avatar_id = int(my_profile["avatar_id"] or 0) + my_username = my_profile["username"] + my_lang = (my_profile["app_language"] or "ru").lower() + else: + my_weekly_xp = 0 + my_total_xp = 0 + my_avatar_id = 0 + my_username = None + my_lang = "ru" + + # 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp). + my_position = await conn.fetchval(""" + SELECT COUNT(*) + 1 + FROM user_profile + WHERE total_xp > $1 + """, my_total_xp) or 1 + + # Legacy-статистика (для совместимости с Mini App) + my_wordsearch = await conn.fetchval( + "SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL", + telegram_id + ) or 0 + my_sentence = await conn.fetchval( + "SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL", + telegram_id + ) or 0 + my_wordquiz = await conn.fetchval( + "SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1", + telegram_id + ) or 0 + my_words_guessed = await conn.fetchval( + "SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1", + telegram_id + ) or 0 + my_bubblewords = await conn.fetchval( + "SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1", + telegram_id + ) or 0 + my_bubble_levels = await conn.fetchval( + "SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1", + telegram_id + ) or 0 + my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords + my_wordsearch_levels = 0 + my_sentences_completed = 0 + my_avatar_id_final = my_avatar_id + my_username_final = my_username + my_lang_final = my_lang + else: + my_weekly_xp = int(my_row["weekly_xp"] or 0) + my_total_xp = int(my_row["total_xp"] or 0) + my_avatar_id_final = int(my_row["avatar_id"] or 0) + my_username_final = my_row["username"] + my_lang_final = (my_row["app_language"] or "ru").lower() my_wordsearch = my_row["wordsearch_score"] my_sentence = my_row["sentence_score"] my_wordquiz = my_row["wordquiz_score"] my_words_guessed = my_row["words_guessed"] my_bubblewords = my_row["bubblewords_score"] my_bubble_levels = my_row["bubble_levels_completed"] - else: - my_wordsearch = 0 - my_sentence = 0 - my_wordquiz = 0 - my_words_guessed = 0 - my_bubblewords = 0 - my_bubble_levels = 0 + my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords - # Считаем НАПРЯМУЮ из основных таблиц - my_wordsearch_levels = await conn.fetchval( - "SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL", - telegram_id - ) or 0 + # 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp). + my_position = await conn.fetchval(""" + SELECT COUNT(*) + 1 + FROM user_profile + WHERE total_xp > $1 + """, my_total_xp) or 1 - my_sentences_completed = await conn.fetchval( - "SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL", - telegram_id - ) or 0 - - # Если пользователя нет в кэше — считаем очки из основных таблиц - if not my_row: - my_wordsearch = await conn.fetchval( - "SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL", + my_wordsearch_levels = await conn.fetchval( + "SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL", + telegram_id + ) or 0 + my_sentences_completed = await conn.fetchval( + "SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL", telegram_id ) or 0 - my_sentence = await conn.fetchval( - "SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL", - telegram_id - ) or 0 - - my_wordquiz = await conn.fetchval( - "SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1", - telegram_id - ) or 0 - - my_words_guessed = await conn.fetchval( - "SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1", - telegram_id - ) or 0 - - my_bubblewords = await conn.fetchval( - "SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1", - telegram_id - ) or 0 - - my_bubble_levels = await conn.fetchval( - "SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1", - telegram_id - ) or 0 - - my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords - my_position = user_rank or 1 - - # 🔧 ФИКС N+1 (19.09.2026): 48 запросов → 5. - # Было: цикл по 6 уровням × 8 запросов = 48 round-trip к БД. - # Стало: 5 агрегированных запросов + сборка level_stats в Python. - - # 1. Справочники (не зависят от юзера) — одним запросом + # ============ level_stats (legacy для Mini App) ============ ref_row = await conn.fetchrow(""" SELECT (SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels, @@ -160,11 +224,8 @@ async def get_leaderboard(request: Request, limit: int = 50): (SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent """) - # 2. Очки и прогресс по всем уровням сразу — 4 запроса с GROUP BY ws_rows = await conn.fetch(""" - SELECT level, - COALESCE(SUM(score), 0) AS score, - COUNT(*) AS completed + SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL GROUP BY level @@ -172,9 +233,7 @@ async def get_leaderboard(request: Request, limit: int = 50): ws_by_level = {r["level"]: r for r in ws_rows} s_rows = await conn.fetch(""" - SELECT level, - COALESCE(SUM(score), 0) AS score, - COUNT(*) AS completed + SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL GROUP BY level @@ -183,23 +242,19 @@ async def get_leaderboard(request: Request, limit: int = 50): wq_rows = await conn.fetch(""" SELECT level, COALESCE(total_score, 0) AS score - FROM word_quiz_progress - WHERE user_id = $1 + FROM word_quiz_progress WHERE user_id = $1 """, telegram_id) wq_by_level = {r["level"]: r for r in wq_rows} bw_rows = await conn.fetch(""" SELECT level, COALESCE(total_score, 0) AS score - FROM bubble_words_progress - WHERE user_id = $1 + FROM bubble_words_progress WHERE user_id = $1 """, telegram_id) bw_by_level = {r["level"]: r for r in bw_rows} - # 3. Собираем level_stats в Python — без единого запроса level_stats = {} for lvl in LEVELS: lvl_lower = lvl.lower() - ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0 ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0 s_score = s_by_level.get(lvl, {}).get("score", 0) or 0 @@ -209,7 +264,6 @@ async def get_leaderboard(request: Request, limit: int = 50): total_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0 total_sentences = ref_row[f"{lvl_lower}_sent"] or 0 - total_items = total_ws_levels + total_sentences completed_items = ws_completed + s_completed progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0 @@ -223,15 +277,20 @@ async def get_leaderboard(request: Request, limit: int = 50): "bubblewords_score": bw_score, } - # 🔧 ИСПРАВЛЕНО: вызов достижений ВНЕ блока async with pool.acquire() + # Достижения from routers.achievements import check_and_award_achievements if my_position <= 3: await check_and_award_achievements(telegram_id, "rank_reached", my_position) + # ============ Мой ранг (XP) ============ + my_level, my_xp_in_level, my_xp_needed, my_rank_key = level_for(my_total_xp) + my_rank_name = rank_for(my_level, my_lang_final) + return { "leaderboard": leaderboard, "current_level": current_level, "my_rank": { + # Legacy "rank": my_position, "telegram_id": telegram_id, "total_score": my_total, @@ -243,6 +302,17 @@ async def get_leaderboard(request: Request, limit: int = 50): "words_guessed": my_words_guessed, "bubblewords_score": my_bubblewords, "bubble_levels_completed": my_bubble_levels, + # 🆕 XP + "username": my_username_final, + "weekly_xp": my_weekly_xp, # оставлен для legacy Mini App + "total_xp": my_total_xp, + "level": my_level, + "rank_key": my_rank_key, + "rank_name": my_rank_name, + "xp_in_level": my_xp_in_level, + "xp_needed": my_xp_needed, + "avatar_id": my_avatar_id_final, + "app_language": my_lang_final, }, "level_stats": level_stats, } diff --git a/routers/sentences.py b/routers/sentences.py index 9539351..1a29a3a 100644 --- a/routers/sentences.py +++ b/routers/sentences.py @@ -160,6 +160,8 @@ async def check_sentence(request: Request): raise HTTPException(400, "Too many words") pool = await get_pool() + # 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp. + xp_result = None async with pool.acquire() as conn: user_exists = await conn.fetchval( "SELECT 1 FROM users WHERE telegram_id = $1", telegram_id @@ -207,12 +209,28 @@ async def check_sentence(request: Request): if is_correct: word_count = len(correct_words_original) + + # 🆕 Расчёт звёзд для "Составь предложение" + # Старт 5. Штрафы: + # -1 за каждую неверную проверку (клиент шлёт wrong_checks) + # -1 если time > лимита (по длине: 3-4 → 30с, 5-6 → 45с, 7-8 → 60с) + wrong_checks = int(body.get("wrong_checks", 0) or 0) + if word_count <= 4: - score = 50 + time_limit = 30 elif word_count <= 6: - score = 75 + time_limit = 45 else: - score = 100 + time_limit = 60 + + time_penalty = 1 if (completion_time and completion_time > time_limit) else 0 + wrong_penalty = min(max(0, wrong_checks), 3) + stars = max(1, 5 - wrong_penalty - time_penalty) + + # Начисляем XP + from services.xp import award_xp + xp_result = await award_xp(conn, telegram_id, "sentence", stars) + score = xp_result["points"] await conn.execute( """INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level) @@ -267,7 +285,19 @@ async def check_sentence(request: Request): "correct_words": [normalize_word_for_display(w) for w in correct_words_original], "already_completed": False, "score": score, - "new_achievements": new_achievements + "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"], } return { diff --git a/routers/users.py b/routers/users.py index 2c7c9e1..2bcd524 100644 --- a/routers/users.py +++ b/routers/users.py @@ -103,4 +103,86 @@ async def set_level(request: Request): return { "status": "ok", "level": level, - } \ No newline at end of file + } + + +# ============================================================ +# 🆕 (08.10.2026): профиль — ник + аватар +# ============================================================ + +import re as _re + + +_FORBIDDEN_WORDS = { + "admin", "administrator", "root", "moderator", "mod", + "pleily", "filwords", "support", "help", "system", + "хуй", "пизда", "блядь", "сука", "ебать", + "kurwa", "chuj", "pizda", "jebac", + "fuck", "shit", "bitch", "ass", +} + +_NICKNAME_RE = _re.compile(r'^[\w\s\.\-]+$', flags=_re.UNICODE) + + +def _clean_nickname(raw: str) -> str: + if not raw: + raise HTTPException(400, "Nickname is required") + nick = raw.strip() + if len(nick) < 2: + raise HTTPException(400, "Nickname must be at least 2 characters") + if len(nick) > 20: + raise HTTPException(400, "Nickname must be at most 20 characters") + lower = nick.lower() + for bad in _FORBIDDEN_WORDS: + if bad in lower: + raise HTTPException(400, "Nickname contains forbidden words") + if not _NICKNAME_RE.match(nick): + raise HTTPException(400, "Nickname contains invalid characters") + return nick + + +@router.post("/set-nickname") +async def set_nickname(request: Request): + """Сохранить ник пользователя. Body: {"nickname": "Oleg"}""" + user_id, _ = await require_auth(request) + body = await request.json() + nickname = _clean_nickname(body.get("nickname", "")) + + pool = await get_pool() + async with pool.acquire() as conn: + existing = await conn.fetchval( + "SELECT user_id FROM user_profile WHERE nickname = $1 AND user_id != $2", + nickname, user_id, + ) + if existing: + raise HTTPException(409, "Nickname already taken") + + await conn.execute(""" + INSERT INTO user_profile (user_id, nickname, updated_at) + VALUES ($1, $2, NOW()) + ON CONFLICT (user_id) DO UPDATE + SET nickname = $2, updated_at = NOW() + """, user_id, nickname) + + return {"status": "ok", "nickname": nickname} + + +@router.post("/set-avatar") +async def set_avatar(request: Request): + """Сохранить аватар. Body: {"avatar_id": 3}""" + user_id, _ = await require_auth(request) + body = await request.json() + avatar_id = body.get("avatar_id") + if not isinstance(avatar_id, int) or avatar_id < 0 or avatar_id > 7: + raise HTTPException(400, "avatar_id must be 0..7") + + pool = await get_pool() + async with pool.acquire() as conn: + await conn.execute(""" + INSERT INTO user_profile (user_id, avatar_id, updated_at) + VALUES ($1, $2, NOW()) + ON CONFLICT (user_id) DO UPDATE + SET avatar_id = $2, updated_at = NOW() + """, user_id, avatar_id) + + return {"status": "ok", "avatar_id": avatar_id} \ No newline at end of file diff --git a/routers/wordquiz.py b/routers/wordquiz.py index 35b2e21..3f00169 100644 --- a/routers/wordquiz.py +++ b/routers/wordquiz.py @@ -126,19 +126,26 @@ async def get_next_quiz(request: Request): @router.post("/check") async def check_quiz_answer(request: Request): - """Проверяет ответ, начисляет очки и проверяет достижения""" + """Проверяет ответ, начисляет XP и проверяет достижения. + + 🔧 НОВОЕ (08.10.2026): XP-система + серии. + Штрафы: + -1 за каждый неверный выбор (макс 3) + -1 если time_ms > 30 сек + Минимум 1 звезда. + Серия: correct_streak (best_streak хранится в choose_progress). + """ telegram_id, _ = await require_auth(request) body = await request.json() correct_polish = body.get("correct_polish", "") user_answer = body.get("answer", "") completion_time = body.get("completion_time") - # 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz — - # mistakes больше НЕ берём от клиента. Считаем на сервере. + # 🆕 wrong_count приходит с клиента для UI, но мы считаем на сервере + # 🔧 ФИКС: current_mistakes — серверный счётчик if not correct_polish or not user_answer: raise HTTPException(400, "correct_polish and answer required") - # Защита от читерства: минимальное время 1 секунда if completion_time is not None and completion_time < 1: return { "correct": False, @@ -147,25 +154,23 @@ async def check_quiz_answer(request: Request): } is_correct = user_answer.strip().lower() == correct_polish.strip().lower() - + pool = await get_pool() async with pool.acquire() as conn: + # Читаем серверный streak и mistakes current_streak = await conn.fetchval( "SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1", telegram_id ) or 0 - # 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz — - # читаем серверный current_mistakes. mistakes = await conn.fetchval( "SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1", telegram_id ) or 0 - + if is_correct: current_streak += 1 else: current_streak = 0 - # 🔧 Инкрементим mistakes на сервере await conn.execute(""" INSERT INTO word_quiz_progress (user_id, current_mistakes) VALUES ($1, 1) @@ -173,14 +178,29 @@ async def check_quiz_answer(request: Request): SET current_mistakes = word_quiz_progress.current_mistakes + 1 """, telegram_id) mistakes += 1 - + + xp_result = None + score = 0 + if is_correct: - score = max(10, 50 - (mistakes * 20)) - # 🔧 Сбрасываем mistakes при правильном ответе + # 🆕 Расчёт звёзд для "Выбери слово" + # Старт 5 звёзд. Штрафы: + # -1 за каждый неверный (макс 3) + # -1 если time > 30 сек + time_penalty = 1 if (completion_time and completion_time > 30) else 0 + wrong_penalty = min(mistakes, 3) + stars = max(1, 5 - wrong_penalty - time_penalty) + + # Начисляем XP + from services.xp import award_xp + xp_result = await award_xp(conn, telegram_id, "choose", stars) + score = xp_result["points"] + + # Сбрасываем mistakes + обновляем серию await conn.execute(""" UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1 """, telegram_id) - + await conn.execute(""" INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak) VALUES ($1, 1, $2, $3) @@ -189,43 +209,35 @@ async def check_quiz_answer(request: Request): total_score = word_quiz_progress.total_score + $2, correct_streak = $3 """, telegram_id, score, current_streak) - - # 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_wordquiz — - # вызовы достижений вынесены за async with pool.acquire() (паттерн game.py). + + # 🆕 Обновляем best_streak в choose_progress + await conn.execute(""" + INSERT INTO choose_progress (user_id, current_streak, best_streak) + VALUES ($1, $2, $2) + ON CONFLICT (user_id) DO UPDATE + SET current_streak = $2, + best_streak = GREATEST(choose_progress.best_streak, $2), + updated_at = NOW() + """, telegram_id, current_streak) + + # Собираем данные для достижений total_guessed = await conn.fetchval( "SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1", telegram_id ) or 0 - wordsearch_score = await conn.fetchval( - "SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL", - telegram_id - ) or 0 - sentence_score = await conn.fetchval( - "SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL", - 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 = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score achievements_to_check = [ ("quiz_guessed", total_guessed), - ("total_score", grand_total), + ("total_score", xp_result["total_xp"]), ] if current_streak >= 10: achievements_to_check.append(("quiz_perfect_streak", current_streak)) if mistakes == 0: achievements_to_check.append(("quiz_no_mistakes", 1)) - if completion_time is not None and completion_time > 0 and int(completion_time) <= 3: + if completion_time is not None and 0 < completion_time <= 3: achievements_to_check.append(("quiz_speed", 3)) else: - # При 3 ошибках — начисляем утешительные 10 очков + # При 3 ошибках — утешительный XP (10) if mistakes >= 3: await conn.execute(""" INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes) @@ -242,7 +254,7 @@ async def check_quiz_answer(request: Request): SET correct_streak = $2 """, telegram_id, current_streak) - # 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire() + # Достижения — вне транзакции if is_correct: from routers.achievements import check_and_award_achievements new_achievements = [] @@ -255,6 +267,20 @@ async def check_quiz_answer(request: Request): "score": score, "correct_streak": current_streak, "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"], + # 🆕 Серия для UI + "streak_best": (await _get_best_streak(telegram_id)), } return { @@ -264,6 +290,16 @@ async def check_quiz_answer(request: Request): } +async def _get_best_streak(telegram_id: int) -> int: + """Возвращает best_streak пользователя из choose_progress.""" + pool = await get_pool() + async with pool.acquire() as conn: + return await conn.fetchval( + "SELECT best_streak FROM choose_progress WHERE user_id = $1", + telegram_id + ) or 0 + + @router.get("/progress") async def get_quiz_progress(request: Request): """Статистика пользователя в квизе""" diff --git a/scripts/generate_levels.py b/scripts/generate_levels.py new file mode 100644 index 0000000..9035a6b --- /dev/null +++ b/scripts/generate_levels.py @@ -0,0 +1,516 @@ +""" +generate_levels.py — генератор уровней филвордов (word search). + +🔧 НОВОЕ (07.10.2026): Первая версия. + Порт алгоритма с JS (filword-gen.js): слова-змейки, + 4 направления (вверх/вниз/влево/вправо), без диагоналей. + Поле n×n полностью заполнено, слова не пересекаются. + +Логика: + 1. Читает все слова из csv_words (A1+A2+B1), DISTINCT по word_pl. + Фильтр: длина 3..10 Unicode-символов. + 2. Группирует по длине. + 3. Для каждого размера n в [4, 5, 6, 7, 8, 9, 10]: + - генерирует 100 уровней; + - level_number — сквозной, начиная с MAX(level_number)+1 из БД; + - level = 'common' (не A1/A2/B1); + - game_type = 'wordsearch'; + - is_active = TRUE; + - created_by = NULL (автогенерированный). + 4. Сохраняет в levels + level_words. + +🔧 ФИКС (07.10.2026): random_start_cell — + раньше solve() всегда начинал с клетки (0,0), из-за чего во всех + уровнях первое слово было "прибито" к верхнему левому углу. + Теперь старт — случайная свободная клетка. + +Запуск: + cd ~/filwordspl/backend + source venv/bin/activate + python scripts/generate_levels.py + +Требования: + Python 3.12, asyncpg. + Пишет прогресс в stdout. + ON CONFLICT DO NOTHING на уровнях. + Не трогает уровни с created_by IS NOT NULL. +""" + +import asyncio +import logging +import random +import sys +from pathlib import Path + +# Разрешаем запуск из scripts/ — добавляем корень backend в sys.path. +BACKEND_ROOT = Path(__file__).resolve().parent.parent +if str(BACKEND_ROOT) not in sys.path: + sys.path.insert(0, str(BACKEND_ROOT)) + +from database import get_pool # noqa: E402 + +logger = logging.getLogger(__name__) + +# ============ Конфигурация ============ + +LEVELS_PER_SIZE = 215 +GRID_SIZES = [4, 5, 6, 7, 8, 9, 10] +LEVEL_NAME = "common" +GAME_TYPE = "wordsearch" +MIN_WORD_LEN = 3 +MAX_WORD_LEN = 10 + +# Максимальное количество попыток и шагов на один бэктрекинг. +MAX_STEPS = 20000 +ATTEMPTS = 200 + +# Диапазон seed (воспроизводимость). +SEED_BASE = 20261007 + +# Пул слов из БД: все треки, все уровни. +WORD_LEVELS = ("A1", "A2", "B1") + + +# ============ Утилиты ============ + +def shuffle(arr: list, rnd: random.Random) -> list: + """Fisher-Yates shuffle (как в JS).""" + for i in range(len(arr) - 1, 0, -1): + j = rnd.randrange(i + 1) + arr[i], arr[j] = arr[j], arr[i] + return arr + + +def word_length(word: str) -> int: + """Длина слова в Unicode-символах (ą, ł, ś и т.д. = 1 буква).""" + return len(word) + + +def group_by_length(words: list[str]) -> dict[int, list[str]]: + """Группирует слова по длине. Возвращает {len: [words]}.""" + res: dict[int, list[str]] = {} + seen = set() + for raw in words: + w = raw.strip().upper() + if not w or w in seen: + continue + seen.add(w) + ln = word_length(w) + res.setdefault(ln, []).append(w) + return res + + +# ============ Ядро: разбиение поля на змейки ============ + +def partition_grid( + n: int, + available: dict[int, int], + rnd: random.Random, + max_steps: int = MAX_STEPS, + attempts: int = ATTEMPTS, +) -> list[list[list[int]]] | None: + """ + ШАГ 1. Разбивает n×n поле на пути-змейки. + + available: {длина: сколько слов такой длины доступно} + Возвращает массив путей [[[r,c], ...], ...] или None. + """ + lengths = [ln for ln, cnt in available.items() if cnt > 0 and ln >= 2] + if not lengths: + return None + max_len = max(lengths) + total = n * n + + # ok[s] = можно ли набрать s клеток допустимыми длинами. + ok = [False] * (total + 1) + ok[0] = True + for s in range(1, total + 1): + ok[s] = any(s >= ln and ok[s - ln] for ln in lengths) + if not ok[total]: + return None + + dirs = [(1, 0), (-1, 0), (0, 1), (0, -1)] + + for _attempt in range(attempts): + grid = [[-1] * n for _ in range(n)] + left = dict(available) + paths: list[list[list[int]]] = [] + steps = [0] # список, чтобы менять из вложенных функций + + def is_free(r: int, c: int) -> bool: + return 0 <= r < n and 0 <= c < n and grid[r][c] == -1 + + def free_count(r: int, c: int) -> int: + return sum(1 for dr, dc in dirs if is_free(r + dr, c + dc)) + + def regions_ok() -> bool: + """Каждая связная область свободных клеток делится допустимыми длинами.""" + seen = [[False] * n for _ in range(n)] + for r0 in range(n): + for c0 in range(n): + if not is_free(r0, c0) or seen[r0][c0]: + continue + size = 0 + stack = [(r0, c0)] + seen[r0][c0] = True + while stack: + y, x = stack.pop() + size += 1 + for dr, dc in dirs: + a, b = y + dr, x + dc + if is_free(a, b) and not seen[a][b]: + seen[a][b] = True + stack.append((a, b)) + if not ok[size]: + return False + return True + + def solve() -> bool: + # 🔧 ФИКС (07.10.2026): random_start_cell — + # раньше всегда начинали с (0,0) → все уровни с верхнего левого угла. + # Теперь — случайная свободная клетка. + free_cells = [ + (r, c) + for r in range(n) + for c in range(n) + if is_free(r, c) + ] + if not free_cells: + return True # всё поле покрыто + start = rnd.choice(free_cells) + + grid[start[0]][start[1]] = len(paths) + target = lengths[rnd.randrange(len(lengths))] + if extend([list(start)], target): + return True + grid[start[0]][start[1]] = -1 + return False + + def extend(path: list[list[int]], target: int) -> bool: + steps[0] += 1 + if steps[0] > max_steps: + return False + + ln = len(path) + r, c = path[-1] + + def try_close() -> bool: + if not (left.get(ln, 0) > 0): + return False + left[ln] -= 1 + paths.append([list(p) for p in path]) + if regions_ok() and solve(): + return True + paths.pop() + left[ln] += 1 + return False + + if ln >= target and try_close(): + return True + if ln >= max_len: + return False + + # Соседи: сначала те, у которых меньше свободных соседей. + nbs = [] + for dr, dc in dirs: + a, b = r + dr, c + dc + if is_free(a, b): + k = free_count(a, b) + rnd.random() * 1.5 + nbs.append(((a, b), k)) + nbs.sort(key=lambda x: x[1]) + + for (a, b), _ in nbs: + grid[a][b] = len(paths) + path.append([a, b]) + if extend(path, target): + return True + path.pop() + grid[a][b] = -1 + if steps[0] > max_steps: + return False + + if ln < target and try_close(): + return True + return False + + if solve(): + return paths + + return None + + +# ============ Ядро: строит уровень ============ + +def build_level( + n: int, + words_by_len: dict[int, list[str]], + rnd: random.Random, +) -> dict | None: + """ + ШАГ 2. Разбивает поле и вписывает слова в змейки. + + Возвращает {size, letters: List[List[str]], words: [{word, cells}], } + или None, если не удалось. + """ + available = {ln: len(words) for ln, words in words_by_len.items()} + # Доступные длины ограничиваем 2..n*n, чтобы partition_grid не падал. + max_cells = n * n + available = {ln: cnt for ln, cnt in available.items() if 2 <= ln <= max_cells} + if not available: + return None + + paths = partition_grid(n, available, rnd) + if not paths: + return None + + pools: dict[int, list[str]] = {ln: shuffle(list(words), rnd) for ln, words in words_by_len.items()} + + letters = [[""] * n for _ in range(n)] + words_out: list[dict] = [] + for p in paths: + pool = pools.get(len(p), []) + if not pool: + # Не должно случаться: partition_grid согласован с available. + return None + w = pool.pop() + for i, ch in enumerate(w): + r, c = p[i] + letters[r][c] = ch + words_out.append({"word": w, "cells": p}) + + return {"size": n, "letters": letters, "words": words_out} + + +# ============ БД ============ + +async def fetch_words(pool) -> list[str]: + """ + Возвращает все слова из csv_words (A1+A2+B1), DISTINCT по word_pl. + Фильтр: длина 3..10 Unicode-символов. + """ + async with pool.acquire() as conn: + rows = await conn.fetch(""" + SELECT DISTINCT word_pl + FROM csv_words + WHERE level_code = ANY($1::text[]) + """, list(WORD_LEVELS)) + + raw_words = [r["word_pl"] for r in rows] + + # Фильтр по длине. + filtered: list[str] = [] + seen = set() + for w in raw_words: + if not w: + continue + wu = w.strip().upper() + if not wu or wu in seen: + continue + ln = word_length(wu) + if MIN_WORD_LEN <= ln <= MAX_WORD_LEN: + filtered.append(wu) + seen.add(wu) + + return filtered + + +async def fetch_translations(pool, words: list[str]) -> dict[str, dict[str, str]]: + """ + Возвращает переводы: {word_pl: {ru, uk, en}}. + Берём первую строку по каждому слову (DISTINCT). + """ + if not words: + return {} + + async with pool.acquire() as conn: + rows = await conn.fetch(""" + SELECT DISTINCT ON (word_pl) + word_pl, translation_ru, translation_uk, translation_en + FROM csv_words + WHERE level_code = ANY($1::text[]) + AND word_pl = ANY($2::text[]) + ORDER BY word_pl + """, list(WORD_LEVELS), words) + + return { + r["word_pl"]: { + "ru": r["translation_ru"] or "", + "uk": r["translation_uk"] or "", + "en": r["translation_en"] or "", + } + for r in rows + } + + +async def fetch_max_level_number(pool) -> int: + """Возвращает MAX(level_number) из levels или 0.""" + async with pool.acquire() as conn: + val = await conn.fetchval("SELECT COALESCE(MAX(level_number), 0) FROM levels") + return int(val or 0) + + +async def save_level( + pool, + level_number: int, + grid_size: int, + letters: list[list[str]], + words: list[dict], + translations: dict[str, dict[str, str]], +) -> bool: + """ + Сохраняет уровень в levels + level_words. + + level = 'common', game_type = 'wordsearch', is_active = TRUE, + created_by = NULL. + + ON CONFLICT DO NOTHING на levels (UNIQUE (level, level_number)). + Возвращает True, если уровень реально создан. + """ + import json as _json + + word_paths = {w["word"]: w["cells"] for w in words} + + async with pool.acquire() as conn: + async with conn.transaction(): + row = await conn.fetchrow(""" + INSERT INTO levels + (level_number, grid_size, game_type, level, + grid_letters, word_paths, is_active, created_by, created_at) + VALUES ($1, $2, $3, $4, $5, $6, TRUE, NULL, NOW()) + ON CONFLICT (level, level_number) DO NOTHING + RETURNING id + """, + level_number, + grid_size, + GAME_TYPE, + LEVEL_NAME, + _json.dumps(letters), + _json.dumps(word_paths), + ) + + if not row: + return False + + level_id = row["id"] + + # level_words — вставляем построчно. + for w in words: + word_pl = w["word"] + trans = translations.get(word_pl, {}) + await conn.execute(""" + INSERT INTO level_words + (level_id, word_pl, translation_ru, translation_uk, translation_en, level) + VALUES ($1, $2, $3, $4, $5, $6) + """, + level_id, + word_pl, + trans.get("ru", ""), + trans.get("uk", ""), + trans.get("en", ""), + LEVEL_NAME, + ) + + return True + + +# ============ Main ============ + +async def main() -> None: + logging.basicConfig( + level=logging.INFO, + format="%(asctime)s [%(levelname)s] %(message)s", + datefmt="%H:%M:%S", + ) + + logger.info("=== Генерация уровней филвордов ===") + pool = await get_pool() + + # 1. Слова + logger.info("Читаю слова из csv_words...") + all_words = await fetch_words(pool) + logger.info(f"Всего слов 3..10 букв: {len(all_words)}") + + if not all_words: + logger.error("Нет слов для генерации. Проверь csv_words.") + return + + words_by_len = group_by_length(all_words) + logger.info("Распределение по длинам:") + for ln in sorted(words_by_len.keys()): + logger.info(f" длина {ln}: {len(words_by_len[ln])} слов") + + # 2. MAX(level_number) + max_level_number = await fetch_max_level_number(pool) + logger.info(f"MAX(level_number) в БД: {max_level_number}") + + # 3. Переводы (берём все нужные слова сразу, чтобы не дёргать БД внутри цикла) + logger.info("Читаю переводы...") + translations = await fetch_translations(pool, all_words) + logger.info(f"Переводов: {len(translations)}") + + # 4. Генерация + next_level_number = max_level_number + 1 + created_total = 0 + stats_by_size: dict[int, dict[str, int]] = {} + + for n in GRID_SIZES: + stats_by_size[n] = {"created": 0, "failed": 0} + logger.info(f"\n--- Размер поля {n}×{n} ---") + + # Проверим, хватает ли длин: на n×n нужны длины из words_by_len. + # Слова длиннее n*n невозможны — отсекаем. + candidate_lengths = [ln for ln in words_by_len.keys() if ln <= n * n] + if not candidate_lengths: + logger.warning(f"Размер {n}: нет слов подходящей длины, пропускаю") + continue + + for i in range(LEVELS_PER_SIZE): + seed = SEED_BASE + next_level_number + rnd = random.Random(seed) + + # Копия words_by_len с только подходящими длинами. + wbl = {ln: list(words_by_len[ln]) for ln in candidate_lengths} + + level_data = build_level(n, wbl, rnd) + + if level_data is None: + stats_by_size[n]["failed"] += 1 + logger.warning(f" [{i+1}/{LEVELS_PER_SIZE}] размер {n}: не удалось сгенерировать") + # level_number НЕ инкрементим — попробуем следующий seed. + # Но чтобы не залипнуть, тоже увеличиваем счётчик. + next_level_number += 1 + continue + + # Сохраняем + saved = await save_level( + pool, + next_level_number, + level_data["size"], + level_data["letters"], + level_data["words"], + translations, + ) + + if saved: + stats_by_size[n]["created"] += 1 + created_total += 1 + logger.info( + f" [{i+1}/{LEVELS_PER_SIZE}] уровень #{next_level_number} " + f"({n}×{n}) слов: {len(level_data['words'])}" + ) + else: + logger.warning(f" [{i+1}/{LEVELS_PER_SIZE}] уровень #{next_level_number} — конфликт, пропущен") + + next_level_number += 1 + + # 5. Итоги + logger.info("\n=== Итого ===") + logger.info(f"Создано уровней всего: {created_total}") + for n in GRID_SIZES: + st = stats_by_size.get(n, {"created": 0, "failed": 0}) + logger.info(f" {n}×{n}: создано {st['created']}, не удалось {st['failed']}") + logger.info(f"Следующий свободный level_number: {next_level_number}") + + +if __name__ == "__main__": + asyncio.run(main()) \ No newline at end of file diff --git a/services/waves.py b/services/waves.py new file mode 100644 index 0000000..6fad3bb --- /dev/null +++ b/services/waves.py @@ -0,0 +1,64 @@ +""" +Волновая структура филвордов. + +Волна = 20 уровней (10 + 10). Волны бесконечные. + +| Волна | Первые 10 | Следующие 10 | +|-------|-----------|--------------| +| 1 | 5×5 | 6×6 | +| 2 | 5×5 | 6×6 | +| 3 | 6×6 | 7×7 | +| 4 | 6×6 | 7×7 | +| 5+ | 7×7 | 8×8 | +""" +from __future__ import annotations + + +def wave_plan(wave: int) -> list[int]: + """Возвращает список из 20 размеров сетки для волны.""" + if wave in (1, 2): + return [5] * 10 + [6] * 10 + if wave in (3, 4): + return [6] * 10 + [7] * 10 + return [7] * 10 + [8] * 10 + + +def wave_for_level(global_level: int) -> int: + """Какая волна содержит этот глобальный уровень (1-based).""" + if global_level < 1: + return 1 + return (global_level - 1) // 20 + 1 + + +def level_in_wave(global_level: int) -> int: + """Позиция уровня внутри волны (1..20).""" + return ((global_level - 1) % 20) + 1 + + +def grid_size_for(global_level: int) -> int: + """Размер сетки для глобального уровня.""" + wave = wave_for_level(global_level) + pos = level_in_wave(global_level) + plan = wave_plan(wave) + return plan[pos - 1] + + +def max_stars_for_wave() -> int: + """Максимум звёзд за волну (20 уровней × 5 звёзд).""" + return 20 * 5 + + +def wave_medal(stars_earned: int) -> str: + """ + Медаль волны по доле звёзд. + Пороги: gold >= 90%, silver >= 70%, bronze >= 50%, else 'none'. + """ + total = max_stars_for_wave() + pct = stars_earned / total if total > 0 else 0 + if pct >= 0.90: + return "gold" + if pct >= 0.70: + return "silver" + if pct >= 0.50: + return "bronze" + return "none" \ No newline at end of file diff --git a/services/xp.py b/services/xp.py new file mode 100644 index 0000000..8073165 --- /dev/null +++ b/services/xp.py @@ -0,0 +1,305 @@ +""" +XP-фундамент Pleily. + +Единая точка начисления опыта: + - RANKS — 48 званий × 4 языка + - level_for(total_xp) → (level, xp_in_level, xp_needed, rank_key) + - award_xp(conn, user_id, game, stars) → dict + +XP-кривая (по решению от 08.10.2026): + Ур.1 → нужно 1000 XP + Ур.2 → нужно 1500 XP + Ур.3 → нужно 2000 XP + ... + Ур.N → нужно 1000 + (N-1) * 500 + Ур.47 → нужно 24000 XP (потолок, потом расширим до 100) + +Множитель ×1.5: игра дня (определяется по Europe/Warsaw). +""" +from __future__ import annotations + +import logging +from datetime import datetime, timezone, timedelta +from typing import Optional +from zoneinfo import ZoneInfo + +logger = logging.getLogger(__name__) + +# ============ Константы ============ + +WARSAW_TZ = ZoneInfo("Europe/Warsaw") + +# Игры по кругу (для featured) +GAMES = ["wordsearch", "choose", "sentence", "bubbles"] + +# Множитель игры дня +FEATURED_MULTIPLIER = 1.5 + +# Базовая ставка: 1 звезда = 20 XP +POINTS_PER_STAR = 20 + +# Максимум звёзд за уровень +MAX_STARS = 5 + +# Минимум звёзд за пройденный уровень +MIN_STARS = 1 + +# Коэффициенты баланса (настроить после первых 1000 сессий) +# Применяются к base_points ДО множителя игры дня. +GAME_XP_COEF: dict[str, float] = { + "wordsearch": 1.0, + "choose": 1.0, + "sentence": 1.0, + "bubbles": 1.0, +} + +# Максимальный уровень (потом расширим до 100) +MAX_LEVEL = 47 + + +# ============ Звания (48 штук × 4 языка) ============ + +RANKS: list[dict] = [ + {"key": "rank_00", "pl": "Nowicjusz", "ru": "Новичок", "uk": "Новачок", "en": "Novice"}, + {"key": "rank_01", "pl": "Ciekawski", "ru": "Любопытный", "uk": "Допитливий", "en": "Curious"}, + {"key": "rank_02", "pl": "Uczeń", "ru": "Ученик", "uk": "Учень", "en": "Learner"}, + {"key": "rank_03", "pl": "Odkrywca", "ru": "Первооткрыватель", "uk": "Першовідкривач", "en": "Pioneer"}, + {"key": "rank_04", "pl": "Poszukiwacz", "ru": "Искатель", "uk": "Шукач", "en": "Seeker"}, + {"key": "rank_05", "pl": "Tropiciel", "ru": "Следопыт", "uk": "Слідопит", "en": "Pathfinder"}, + {"key": "rank_06", "pl": "Obserwator", "ru": "Наблюдатель", "uk": "Спостерігач", "en": "Observer"}, + {"key": "rank_07", "pl": "Czytelnik słów", "ru": "Читатель слов", "uk": "Читач слів", "en": "Word Reader"}, + {"key": "rank_08", "pl": "Rozmówca", "ru": "Собеседник", "uk": "Співрозмовник", "en": "Conversationalist"}, + {"key": "rank_09", "pl": "Praktyk", "ru": "Практик", "uk": "Практик", "en": "Practitioner"}, + {"key": "rank_10", "pl": "Gaduła", "ru": "Говорун", "uk": "Балакун", "en": "Chatterbox"}, + {"key": "rank_11", "pl": "Znawca liter", "ru": "Знаток букв", "uk": "Знавець літер", "en": "Letter Expert"}, + {"key": "rank_12", "pl": "Piśmienny", "ru": "Грамотей", "uk": "Грамотій", "en": "Literate"}, + {"key": "rank_13", "pl": "Badacz", "ru": "Исследователь", "uk": "Дослідник", "en": "Explorer"}, + {"key": "rank_14", "pl": "Podróżnik", "ru": "Путешественник", "uk": "Мандрівник", "en": "Traveler"}, + {"key": "rank_15", "pl": "Pewny siebie", "ru": "Уверенный", "uk": "Впевнений", "en": "Confident"}, + {"key": "rank_16", "pl": "Mól książkowy", "ru": "Книгочей", "uk": "Книголюб", "en": "Bookworm"}, + {"key": "rank_17", "pl": "Filolog", "ru": "Словесник", "uk": "Філолог", "en": "Wordsmith"}, + {"key": "rank_18", "pl": "Krasomówca", "ru": "Краснобай", "uk": "Красномовець", "en": "Smooth Talker"}, + {"key": "rank_19", "pl": "Znawca", "ru": "Знаток", "uk": "Знавець", "en": "Connoisseur"}, + {"key": "rank_20", "pl": "Mistrz podstaw", "ru": "Мастер азов", "uk": "Майстер основ", "en": "Master of Basics"}, + {"key": "rank_21", "pl": "Lingwista amator", "ru": "Лингвист-любитель", "uk": "Лінгвіст-аматор", "en": "Amateur Linguist"}, + {"key": "rank_22", "pl": "Tłumacz", "ru": "Переводчик", "uk": "Перекладач", "en": "Translator"}, + {"key": "rank_23", "pl": "Poliglota", "ru": "Полиглот", "uk": "Поліглот", "en": "Polyglot"}, + {"key": "rank_24", "pl": "Złotousty", "ru": "Златоуст", "uk": "Золотоустий", "en": "Golden Tongue"}, + {"key": "rank_25", "pl": "Mistrz słowa", "ru": "Мастер слов", "uk": "Майстер слова", "en": "Word Master"}, + {"key": "rank_26", "pl": "Ekspert", "ru": "Эксперт", "uk": "Експерт", "en": "Expert"}, + {"key": "rank_27", "pl": "Wirtuoz", "ru": "Виртуоз", "uk": "Віртуоз", "en": "Virtuoso"}, + {"key": "rank_28", "pl": "Mentor", "ru": "Наставник", "uk": "Наставник", "en": "Mentor"}, + {"key": "rank_29", "pl": "Mędrzec", "ru": "Мудрец", "uk": "Мудрець", "en": "Sage"}, + {"key": "rank_30", "pl": "Magister", "ru": "Магистр", "uk": "Магістр", "en": "Magister"}, + {"key": "rank_31", "pl": "Profesor", "ru": "Профессор", "uk": "Професор", "en": "Professor"}, + {"key": "rank_32", "pl": "Uczony", "ru": "Академик", "uk": "Академік", "en": "Academician"}, + {"key": "rank_33", "pl": "Arcymistrz", "ru": "Гроссмейстер", "uk": "Гросмейстер", "en": "Grandmaster"}, + {"key": "rank_34", "pl": "Strażnik słów", "ru": "Хранитель слов", "uk": "Хранитель слів", "en": "Keeper of Words"}, + {"key": "rank_35", "pl": "Wyrocznia", "ru": "Оракул", "uk": "Оракул", "en": "Oracle"}, + {"key": "rank_36", "pl": "Archiwista", "ru": "Архивариус", "uk": "Архіваріус", "en": "Archivist"}, + {"key": "rank_37", "pl": "Legenda", "ru": "Легенда", "uk": "Легенда", "en": "Legend"}, + {"key": "rank_38", "pl": "Tytan", "ru": "Титан", "uk": "Титан", "en": "Titan"}, + {"key": "rank_39", "pl": "Wielki Mistrz", "ru": "Великий мастер", "uk": "Великий майстер", "en": "Great Master"}, + {"key": "rank_40", "pl": "Patriarcha języka", "ru": "Патриарх языка", "uk": "Патріарх мови", "en": "Patriarch of Language"}, + {"key": "rank_41", "pl": "Gwiazda Pleily", "ru": "Звезда Pleily", "uk": "Зірка Pleily", "en": "Pleily Star"}, + {"key": "rank_42", "pl": "Supernowa", "ru": "Сверхновая", "uk": "Наднова", "en": "Supernova"}, + {"key": "rank_43", "pl": "Nieśmiertelny", "ru": "Бессмертный", "uk": "Безсмертний", "en": "Immortal"}, + {"key": "rank_44", "pl": "Najwyższy poliglota", "ru": "Верховный полиглот", "uk": "Верховний поліглот", "en": "Supreme Polyglot"}, + {"key": "rank_45", "pl": "Władca słów", "ru": "Повелитель слов", "uk": "Володар слів", "en": "Lord of Words"}, + {"key": "rank_46", "pl": "Żywa legenda", "ru": "Живая легенда", "uk": "Жива легенда", "en": "Living Legend"}, + {"key": "rank_47", "pl": "Wieczny poliglota", "ru": "Вечный полиглот", "uk": "Вічний поліглот", "en": "Eternal Polyglot"}, +] + +# Быстрый доступ: rank_key → dict +RANKS_BY_KEY: dict[str, dict] = {r["key"]: r for r in RANKS} + + +# ============ Уровни ============ + +def xp_needed_for_level(level: int) -> int: + """Сколько XP нужно, чтобы перейти с уровня `level` на `level+1`.""" + return 1000 + (level - 1) * 500 + + +def level_for(total_xp: int) -> tuple[int, int, int, str]: + """ + Возвращает (level, xp_in_level, xp_needed_for_next, rank_key). + + level — от 1 до MAX_LEVEL (47). Если XP больше, level=47, xp_in_level + продолжает расти, но xp_needed фиксируется на 24000. + """ + if total_xp < 0: + total_xp = 0 + + level = 1 + need = xp_needed_for_level(1) + remaining = total_xp + + while remaining >= need and level < MAX_LEVEL: + remaining -= need + level += 1 + need = xp_needed_for_level(level) + + # rank_key — 0-based: level 1 → rank_00, level 2 → rank_01, ... + rank_index = min(level - 1, len(RANKS) - 1) + rank_key = RANKS[rank_index]["key"] + + return level, remaining, need, rank_key + + +def rank_for(level: int, lang: str = "ru") -> str: + """Название звания для уровня на языке lang.""" + idx = min(max(level - 1, 0), len(RANKS) - 1) + rank = RANKS[idx] + return rank.get(lang) or rank.get("en") or rank["key"] + + +# ============ Игра дня ============ + +def featured_game(now: Optional[datetime] = None) -> str: + """ + Игра дня по кругу: wordsearch → choose → sentence → bubbles. + Граница суток — Europe/Warsaw. + """ + if now is None: + now = datetime.now(WARSAW_TZ) + elif now.tzinfo is None: + now = now.replace(tzinfo=WARSAW_TZ) + else: + now = now.astimezone(WARSAW_TZ) + + return GAMES[now.date().toordinal() % 4] + + +def featured_seconds_left(now: Optional[datetime] = None) -> int: + """Сколько секунд осталось до смены игры дня (до полуночи по Варшаве).""" + if now is None: + now = datetime.now(WARSAW_TZ) + elif now.tzinfo is None: + now = now.replace(tzinfo=WARSAW_TZ) + else: + now = now.astimezone(WARSAW_TZ) + + tomorrow = (now + timedelta(days=1)).replace( + hour=0, minute=0, second=0, microsecond=0 + ) + return int((tomorrow - now).total_seconds()) + + +# ============ Начисление XP ============ + +async def award_xp( + conn, + user_id: int, + game: str, + stars: int, +) -> dict: + """ + Единая функция начисления опыта. + + Args: + conn: asyncpg connection (уже acquired) + user_id: telegram_id (может быть отрицательным для Pleily) + game: 'wordsearch' | 'choose' | 'sentence' | 'bubbles' + stars: 1..5 + + Returns: + { + "stars": int, + "base_points": int, + "multiplier": float, + "points": int, + "featured": bool, + "level_up": {"from": int, "to": int, "rank_key": str} | None, + "total_xp": int, # после начисления + "level": int, # после начисления + "rank_key": str, + "xp_in_level": int, + "xp_needed": int, + } + """ + # 1. Валидация + stars = max(MIN_STARS, min(MAX_STARS, int(stars))) + if game not in GAME_XP_COEF: + raise ValueError(f"Unknown game: {game}") + + # 2. База + base = stars * POINTS_PER_STAR + base = int(round(base * GAME_XP_COEF.get(game, 1.0))) + + # 3. Множитель игры дня + is_featured = (game == featured_game()) + multiplier = FEATURED_MULTIPLIER if is_featured else 1.0 + points = int(round(base * multiplier)) + + # 4. Читаем текущий total_xp + row = await conn.fetchrow( + "SELECT total_xp FROM user_profile WHERE user_id = $1", + user_id, + ) + if row is None: + # Создаём профиль, если нет + await conn.execute( + """ + INSERT INTO user_profile (user_id, total_xp, weekly_xp) + VALUES ($1, 0, 0) + ON CONFLICT (user_id) DO NOTHING + """, + user_id, + ) + old_total = 0 + else: + old_total = int(row["total_xp"] or 0) + + old_level, _, _, _ = level_for(old_total) + + # 5. Пишем в xp_log + await conn.execute( + """ + INSERT INTO xp_log (user_id, game, stars, base_points, multiplier, points) + VALUES ($1, $2, $3, $4, $5, $6) + """, + user_id, game, stars, base, multiplier, points, + ) + + # 6. Обновляем user_profile + new_total = old_total + points + await conn.execute( + """ + UPDATE user_profile + SET total_xp = total_xp + $2, + weekly_xp = weekly_xp + $2, + updated_at = NOW() + WHERE user_id = $1 + """, + user_id, points, + ) + + # 7. Считаем новый уровень + new_level, xp_in_level, xp_needed, rank_key = level_for(new_total) + + level_up = None + if new_level > old_level: + level_up = { + "from": old_level, + "to": new_level, + "rank_key": rank_key, + } + logger.info( + "[xp] user=%s level_up %s → %s (%s), +%s xp", + user_id, old_level, new_level, rank_key, points, + ) + + return { + "stars": stars, + "base_points": base, + "multiplier": multiplier, + "points": points, + "featured": is_featured, + "level_up": level_up, + "total_xp": new_total, + "level": new_level, + "rank_key": rank_key, + "xp_in_level": xp_in_level, + "xp_needed": xp_needed, + } \ No newline at end of file