feat: XP foundation + waves + featured game + profile + leaderboard by total_xp
- 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
This commit is contained in:
+189
@@ -1335,6 +1335,195 @@ async def init_db():
|
|||||||
""")
|
""")
|
||||||
logger.info("Table auth_identities initialized (Pleily)")
|
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)")
|
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level_number ON sentences(level, sentence_number)")
|
||||||
# Оставляем score-индексы (не дубли)
|
# Оставляем score-индексы (не дубли)
|
||||||
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
|
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
|
||||||
|
|||||||
@@ -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 lectures, admin_auth, admin_wordsearch, admin_users
|
||||||
from routers import admin_ai # 🔧 НОВОЕ
|
from routers import admin_ai # 🔧 НОВОЕ
|
||||||
from routers import app_auth # 🆕 Pleily auth
|
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.sentences import init_sentences
|
||||||
from routers.achievements import init_achievements
|
from routers.achievements import init_achievements
|
||||||
from routers.learning_data import init_learning_data
|
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_users.router)
|
||||||
app.include_router(admin_ai.router) # 🔧 НОВОЕ
|
app.include_router(admin_ai.router) # 🔧 НОВОЕ
|
||||||
app.include_router(app_auth.router) # 🆕 Pleily
|
app.include_router(app_auth.router) # 🆕 Pleily
|
||||||
|
app.include_router(featured_router.router) # 🔧 НОВОЕ (08.10.2026)
|
||||||
|
|
||||||
|
|
||||||
# ============ Базовые эндпоинты ============
|
# ============ Базовые эндпоинты ============
|
||||||
|
|||||||
+74
-32
@@ -18,6 +18,12 @@ Telegram-юзеры сохраняют свои положительные teleg
|
|||||||
- DELETE /me — удаление аккаунта (Apple требует)
|
- DELETE /me — удаление аккаунта (Apple требует)
|
||||||
|
|
||||||
🔧 НОВОЕ (07.10.2026): pleily_auth — первая версия.
|
🔧 НОВОЕ (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 logging
|
||||||
import uuid
|
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_row = await conn.fetchrow("SELECT nextval('app_user_id_seq') AS uid")
|
||||||
uid = uid_row["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("""
|
await conn.execute("""
|
||||||
INSERT INTO users (telegram_id, username, source)
|
INSERT INTO users (telegram_id, username, source, device_id)
|
||||||
VALUES ($1, $2, 'app')
|
VALUES ($1, $2, 'app', $3)
|
||||||
""", uid, f"app_user_{abs(uid)}")
|
""", uid, f"app_user_{abs(uid)}", device_id)
|
||||||
|
|
||||||
# Создаём identity
|
# Создаём identity
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
@@ -174,44 +183,77 @@ async def auth_device(request: Request):
|
|||||||
@router.get("/me")
|
@router.get("/me")
|
||||||
async def auth_me(request: Request):
|
async def auth_me(request: Request):
|
||||||
"""
|
"""
|
||||||
Возвращает данные текущего Pleily-юзера. Для тестов и отладки.
|
Текущий юзер + XP-поля.
|
||||||
|
|
||||||
Требует Authorization: Bearer <JWT>.
|
🔧 НОВОЕ (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()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
row = await conn.fetchrow("""
|
user = await conn.fetchrow(
|
||||||
SELECT telegram_id, username, source, app_language, current_level, created_at
|
"""
|
||||||
|
SELECT telegram_id, username, app_language, current_level,
|
||||||
|
source, device_id, apple_id, created_at
|
||||||
FROM users WHERE telegram_id = $1
|
FROM users WHERE telegram_id = $1
|
||||||
""", user_id)
|
""",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
if not user:
|
||||||
|
raise HTTPException(401, "User not found")
|
||||||
|
|
||||||
if not row:
|
profile = await conn.fetchrow(
|
||||||
raise HTTPException(404, "User not found")
|
"""
|
||||||
|
SELECT nickname, avatar_id, total_xp, weekly_xp, week_started_at
|
||||||
|
FROM user_profile WHERE user_id = $1
|
||||||
|
""",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
|
||||||
# Получаем identities юзера (для диагностики)
|
# Weekly rank
|
||||||
identities_rows = await conn.fetch("""
|
weekly_rank = await conn.fetchval(
|
||||||
SELECT provider, provider_uid, created_at
|
"""
|
||||||
FROM auth_identities WHERE user_id = $1
|
SELECT COUNT(*) + 1
|
||||||
ORDER BY created_at
|
FROM user_profile
|
||||||
""", user_id)
|
WHERE weekly_xp > COALESCE((
|
||||||
|
SELECT weekly_xp FROM user_profile WHERE user_id = $1
|
||||||
|
), 0)
|
||||||
|
""",
|
||||||
|
telegram_id,
|
||||||
|
)
|
||||||
|
|
||||||
|
# Считаем уровень
|
||||||
|
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 {
|
return {
|
||||||
"user_id": row["telegram_id"],
|
"user_id": user["telegram_id"],
|
||||||
"username": row["username"],
|
"username": user["username"],
|
||||||
"source": row["source"],
|
"nickname": profile["nickname"] if profile else None,
|
||||||
"app_language": row["app_language"],
|
"avatar_id": int(profile["avatar_id"]) if profile and profile["avatar_id"] is not None else 0,
|
||||||
"current_level": row["current_level"],
|
"app_language": user["app_language"],
|
||||||
"created_at": row["created_at"].isoformat() if row["created_at"] else None,
|
"current_level": user["current_level"],
|
||||||
"identities": [
|
"source": user["source"],
|
||||||
{
|
"device_id": str(user["device_id"]) if user["device_id"] else None,
|
||||||
"provider": r["provider"],
|
"apple_id": user["apple_id"],
|
||||||
"provider_uid": r["provider_uid"],
|
"created_at": user["created_at"].isoformat() if user["created_at"] else None,
|
||||||
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
|
# --- XP ---
|
||||||
}
|
"total_xp": total_xp,
|
||||||
for r in identities_rows
|
"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,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
+44
-30
@@ -171,13 +171,21 @@ async def get_next_bubble_level(request: Request):
|
|||||||
|
|
||||||
@router.post("/complete")
|
@router.post("/complete")
|
||||||
async def complete_bubble_level(request: Request):
|
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)
|
telegram_id, _ = await require_auth(request)
|
||||||
body = await request.json()
|
body = await request.json()
|
||||||
words_count = body.get("words_count", 3)
|
words_count = body.get("words_count", 3)
|
||||||
completion_time = body.get("completion_time")
|
completion_time = body.get("completion_time")
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
|
list_opened = bool(body.get("list_opened", False))
|
||||||
# hints_used больше НЕ берём от клиента. Читаем из bubble_words_progress.current_hints_used.
|
wrong_words = int(body.get("wrong_words", 0) or 0)
|
||||||
|
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
@@ -187,19 +195,29 @@ async def complete_bubble_level(request: Request):
|
|||||||
if not user_exists:
|
if not user_exists:
|
||||||
raise HTTPException(401, "User not registered")
|
raise HTTPException(401, "User not registered")
|
||||||
|
|
||||||
# Получаем current_level пользователя
|
|
||||||
current_level = await conn.fetchval(
|
current_level = await conn.fetchval(
|
||||||
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
|
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
|
||||||
) or "A1"
|
) or "A1"
|
||||||
|
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
|
# Читаем серверный hints_used
|
||||||
# читаем серверный hints_used.
|
|
||||||
hints_used = await conn.fetchval(
|
hints_used = await conn.fetchval(
|
||||||
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1",
|
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) or 0
|
||||||
hints_used = min(max(0, hints_used), 3)
|
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("""
|
await conn.execute("""
|
||||||
INSERT INTO bubble_words_progress (user_id, levels_completed, total_score, level, current_hints_used)
|
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
|
current_hints_used = 0
|
||||||
""", telegram_id, score, current_level)
|
""", telegram_id, score, current_level)
|
||||||
|
|
||||||
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_bubblewords —
|
# Данные для достижений
|
||||||
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
|
|
||||||
total_levels = await conn.fetchval(
|
total_levels = await conn.fetchval(
|
||||||
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
|
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) 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 = [
|
achievements_to_check = [
|
||||||
("bubble_levels", total_levels),
|
("bubble_levels", total_levels),
|
||||||
("total_score", grand_total),
|
("total_score", xp_result["total_xp"]),
|
||||||
]
|
]
|
||||||
if hints_used == 0:
|
if hints_used == 0:
|
||||||
achievements_to_check.append(("bubble_no_hints", 1))
|
achievements_to_check.append(("bubble_no_hints", 1))
|
||||||
if score == 100:
|
if stars == 5:
|
||||||
achievements_to_check.append(("bubble_perfect", 1))
|
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))
|
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
|
from routers.achievements import check_and_award_achievements
|
||||||
new_achievements = []
|
new_achievements = []
|
||||||
for ach_type, value in achievements_to_check:
|
for ach_type, value in achievements_to_check:
|
||||||
@@ -258,6 +260,18 @@ async def complete_bubble_level(request: Request):
|
|||||||
"score": score,
|
"score": score,
|
||||||
"completion_time": completion_time,
|
"completion_time": completion_time,
|
||||||
"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"],
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|||||||
@@ -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(),
|
||||||
|
}
|
||||||
+204
-68
@@ -27,22 +27,11 @@ async def get_progress(request: Request):
|
|||||||
|
|
||||||
current_level = user["current_level"] or "A1"
|
current_level = user["current_level"] or "A1"
|
||||||
|
|
||||||
# 🔧 ФИКС (30.09.2026): progress_uses_per_level —
|
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
|
||||||
# возвращаем last_completed_level для ТЕКУЩЕГО уровня языка,
|
# Раньше возвращали last_completed_for_current из per-level JSONB,
|
||||||
# а не глобальный счётчик (который смешивал A1+A2+B1).
|
# но уровни теперь глобальные (level = 'common').
|
||||||
last_by_level = user["last_completed_by_level"] or {}
|
# Возвращаем users.last_completed_level — единый глобальный прогресс.
|
||||||
if isinstance(last_by_level, str):
|
last_completed = user["last_completed_level"] or 0
|
||||||
try:
|
|
||||||
import json as _json
|
|
||||||
last_by_level = _json.loads(last_by_level)
|
|
||||||
except Exception:
|
|
||||||
last_by_level = {}
|
|
||||||
|
|
||||||
last_completed_for_current = (
|
|
||||||
last_by_level.get(current_level, 0)
|
|
||||||
if isinstance(last_by_level, dict)
|
|
||||||
else 0
|
|
||||||
)
|
|
||||||
|
|
||||||
# Очки из филвордов
|
# Очки из филвордов
|
||||||
wordsearch_score = await conn.fetchval(
|
wordsearch_score = await conn.fetchval(
|
||||||
@@ -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)
|
total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0)
|
||||||
|
|
||||||
return {
|
return {
|
||||||
"last_completed_level": last_completed_for_current,
|
"last_completed_level": last_completed,
|
||||||
"last_completed_by_level": last_by_level,
|
|
||||||
"total_score": total_score,
|
"total_score": total_score,
|
||||||
"current_level": current_level
|
"current_level": current_level
|
||||||
}
|
}
|
||||||
@@ -93,42 +81,26 @@ async def get_level(request: Request, level_number: int):
|
|||||||
|
|
||||||
lang = user["app_language"] or "pl"
|
lang = user["app_language"] or "pl"
|
||||||
current_level = user["current_level"] or "A1"
|
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
|
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:
|
if level_number > 1 and level_number > last_completed + 1:
|
||||||
raise HTTPException(403, "Level not available yet. Complete previous level first.")
|
raise HTTPException(403, "Level not available yet. Complete previous level first.")
|
||||||
|
|
||||||
# 🔧 ФИКС (29.09.2026): приоритет ручным уровням.
|
# 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
|
||||||
# Если есть уровень, созданный вручную (created_by IS NOT NULL) —
|
# Ищем по level_number без created_by и без current_level.
|
||||||
# показываем его. Иначе — fallback на авто (created_by IS NULL).
|
# is_active = TRUE — чтобы черновики не показывались.
|
||||||
level = await conn.fetchrow("""
|
level = await conn.fetchrow("""
|
||||||
SELECT * FROM levels
|
SELECT * FROM levels
|
||||||
WHERE level = $1 AND level_number = $2
|
WHERE level_number = $1
|
||||||
AND created_by IS NOT NULL
|
AND is_active = TRUE
|
||||||
LIMIT 1
|
LIMIT 1
|
||||||
""", current_level, level_number)
|
""", 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)
|
|
||||||
|
|
||||||
if not level:
|
if not level:
|
||||||
raise HTTPException(404, "Level not found")
|
raise HTTPException(404, "Level not found")
|
||||||
@@ -312,6 +284,8 @@ async def complete_level(request: Request):
|
|||||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
|
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
|
||||||
# hints_used читаем из БД, не доверяем клиенту.
|
# hints_used читаем из БД, не доверяем клиенту.
|
||||||
hints_used = 0
|
hints_used = 0
|
||||||
|
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
|
||||||
|
xp_result = None
|
||||||
|
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
user = await conn.fetchrow(
|
user = await conn.fetchrow(
|
||||||
@@ -330,9 +304,10 @@ async def complete_level(request: Request):
|
|||||||
current_level_number = level["level_number"]
|
current_level_number = level["level_number"]
|
||||||
level_name = level["level"] or "A1"
|
level_name = level["level"] or "A1"
|
||||||
|
|
||||||
# Проверяем, что уровень принадлежит текущему уровню пользователя
|
# 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
|
||||||
if level_name != (user["current_level"] or "A1"):
|
# Уровни глобальные, поэтому убираем проверку «уровень принадлежит
|
||||||
raise HTTPException(403, "This level does not belong to your current level")
|
# твоему current_level». Оставляем только проверку прогресса выше.
|
||||||
|
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
|
||||||
|
|
||||||
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
|
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
|
||||||
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
|
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
|
||||||
@@ -365,19 +340,41 @@ async def complete_level(request: Request):
|
|||||||
telegram_id, level_id
|
telegram_id, level_id
|
||||||
) or 0
|
) or 0
|
||||||
|
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
|
# 🔧 НОВОЕ (08.10.2026): XP-система.
|
||||||
# читаем hints_used из БД, не доверяем клиенту.
|
# Читаем hints_used и list_opened из БД (не доверяем клиенту).
|
||||||
hints_used = await conn.fetchval(
|
hints_used = await conn.fetchval(
|
||||||
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
|
||||||
telegram_id, level_id
|
telegram_id, level_id
|
||||||
) or 0
|
) or 0
|
||||||
hints_used = min(max(0, hints_used), 3)
|
hints_used = min(max(0, hints_used), 3)
|
||||||
|
|
||||||
score = max(10, 100 - hints_used * 10)
|
# 🆕 Штрафы (филворд):
|
||||||
|
# -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"] # для обратной совместимости
|
||||||
|
|
||||||
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
|
|
||||||
# сбрасываем current_streak в 0 при завершении уровня.
|
|
||||||
#
|
|
||||||
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
|
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
|
||||||
# раньше INSERT падал с unique violation, если строка user_progress
|
# раньше INSERT падал с unique violation, если строка user_progress
|
||||||
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
|
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
|
||||||
@@ -395,22 +392,15 @@ async def complete_level(request: Request):
|
|||||||
current_streak = 0
|
current_streak = 0
|
||||||
""", telegram_id, level_id, hints_used, score, level_name)
|
""", telegram_id, level_id, hints_used, score, level_name)
|
||||||
|
|
||||||
# 🔧 ФИКС (30.09.2026): last_completed_by_level —
|
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
|
||||||
# обновляем per-level счётчик (JSONB) + старый last_completed_level.
|
# Обновляем только users.last_completed_level — глобальный.
|
||||||
|
# last_completed_by_level (JSONB) остаётся в БД для совместимости,
|
||||||
|
# но больше не пишется.
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
UPDATE users
|
UPDATE users
|
||||||
SET last_completed_level = GREATEST(last_completed_level, $2),
|
SET last_completed_level = GREATEST(COALESCE(last_completed_level, 0), $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
|
|
||||||
)
|
|
||||||
WHERE telegram_id = $1
|
WHERE telegram_id = $1
|
||||||
""", telegram_id, current_level_number, level_name)
|
""", telegram_id, current_level_number)
|
||||||
|
|
||||||
# Собираем данные для достижений внутри блока
|
# Собираем данные для достижений внутри блока
|
||||||
levels_completed = await conn.fetchval(
|
levels_completed = await conn.fetchval(
|
||||||
@@ -474,5 +464,151 @@ async def complete_level(request: Request):
|
|||||||
"status": "ok",
|
"status": "ok",
|
||||||
"score": score,
|
"score": score,
|
||||||
"already_completed": False,
|
"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,
|
||||||
}
|
}
|
||||||
+166
-96
@@ -10,7 +10,18 @@ LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
|
|||||||
|
|
||||||
@router.get("")
|
@router.get("")
|
||||||
async def get_leaderboard(request: Request, limit: int = 50):
|
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)
|
telegram_id, _ = await require_auth(request)
|
||||||
|
|
||||||
if limit < 1:
|
if limit < 1:
|
||||||
@@ -28,17 +39,39 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
|||||||
|
|
||||||
current_level = user["current_level"] or "A1"
|
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("""
|
rows = await conn.fetch("""
|
||||||
SELECT * FROM leaderboard_cache
|
SELECT
|
||||||
ORDER BY total_score DESC
|
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 $1
|
||||||
""", limit)
|
""", limit)
|
||||||
|
|
||||||
leaderboard = []
|
# Импорт XP-хелперов
|
||||||
for i, row in enumerate(rows):
|
from services.xp import level_for, rank_for
|
||||||
leaderboard.append({
|
|
||||||
"rank": i + 1,
|
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"],
|
"telegram_id": row["telegram_id"],
|
||||||
"username": row["username"] or f"Player{row['telegram_id']}",
|
"username": row["username"] or f"Player{row['telegram_id']}",
|
||||||
"total_score": row["total_score"],
|
"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"],
|
"bubble_levels_completed": row["bubble_levels_completed"],
|
||||||
"levels_completed": 0,
|
"levels_completed": 0,
|
||||||
"sentences_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 = [
|
||||||
# если пользователя нет в leaderboard_cache, подзапрос вернёт NULL,
|
_serialize_row(row, rank_num=i + 1)
|
||||||
# и COUNT(*) + 1 = 1 (юзер видит себя первым, хотя у него 0 очков).
|
for i, row in enumerate(rows)
|
||||||
# Теперь: если user нет в кэше — считаем его место по количеству
|
]
|
||||||
# записей с total_score > 0 + 1 (в конец списка).
|
|
||||||
my_total_in_cache = await conn.fetchval("""
|
|
||||||
SELECT total_score FROM leaderboard_cache WHERE telegram_id = $1
|
|
||||||
""", telegram_id)
|
|
||||||
|
|
||||||
if my_total_in_cache is None:
|
# ============ Мой ранг ============
|
||||||
# Пользователя нет в кэше — считаем по количеству с > 0
|
# Читаем мои XP + legacy-статистику.
|
||||||
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)
|
|
||||||
|
|
||||||
# Персональная статистика пользователя
|
|
||||||
my_row = await conn.fetchrow("""
|
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)
|
""", 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_wordsearch = my_row["wordsearch_score"]
|
||||||
my_sentence = my_row["sentence_score"]
|
my_sentence = my_row["sentence_score"]
|
||||||
my_wordquiz = my_row["wordquiz_score"]
|
my_wordquiz = my_row["wordquiz_score"]
|
||||||
my_words_guessed = my_row["words_guessed"]
|
my_words_guessed = my_row["words_guessed"]
|
||||||
my_bubblewords = my_row["bubblewords_score"]
|
my_bubblewords = my_row["bubblewords_score"]
|
||||||
my_bubble_levels = my_row["bubble_levels_completed"]
|
my_bubble_levels = my_row["bubble_levels_completed"]
|
||||||
else:
|
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
|
||||||
my_wordsearch = 0
|
|
||||||
my_sentence = 0
|
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
|
||||||
my_wordquiz = 0
|
my_position = await conn.fetchval("""
|
||||||
my_words_guessed = 0
|
SELECT COUNT(*) + 1
|
||||||
my_bubblewords = 0
|
FROM user_profile
|
||||||
my_bubble_levels = 0
|
WHERE total_xp > $1
|
||||||
|
""", my_total_xp) or 1
|
||||||
|
|
||||||
# Считаем НАПРЯМУЮ из основных таблиц
|
|
||||||
my_wordsearch_levels = await conn.fetchval(
|
my_wordsearch_levels = await conn.fetchval(
|
||||||
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) or 0
|
||||||
|
|
||||||
my_sentences_completed = await conn.fetchval(
|
my_sentences_completed = await conn.fetchval(
|
||||||
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) or 0
|
||||||
|
|
||||||
# Если пользователя нет в кэше — считаем очки из основных таблиц
|
# ============ level_stats (legacy для Mini App) ============
|
||||||
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",
|
|
||||||
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. Справочники (не зависят от юзера) — одним запросом
|
|
||||||
ref_row = await conn.fetchrow("""
|
ref_row = await conn.fetchrow("""
|
||||||
SELECT
|
SELECT
|
||||||
(SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels,
|
(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
|
(SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent
|
||||||
""")
|
""")
|
||||||
|
|
||||||
# 2. Очки и прогресс по всем уровням сразу — 4 запроса с GROUP BY
|
|
||||||
ws_rows = await conn.fetch("""
|
ws_rows = await conn.fetch("""
|
||||||
SELECT level,
|
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
|
||||||
COALESCE(SUM(score), 0) AS score,
|
|
||||||
COUNT(*) AS completed
|
|
||||||
FROM user_progress
|
FROM user_progress
|
||||||
WHERE user_id = $1 AND completed_at IS NOT NULL
|
WHERE user_id = $1 AND completed_at IS NOT NULL
|
||||||
GROUP BY level
|
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}
|
ws_by_level = {r["level"]: r for r in ws_rows}
|
||||||
|
|
||||||
s_rows = await conn.fetch("""
|
s_rows = await conn.fetch("""
|
||||||
SELECT level,
|
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
|
||||||
COALESCE(SUM(score), 0) AS score,
|
|
||||||
COUNT(*) AS completed
|
|
||||||
FROM sentence_progress
|
FROM sentence_progress
|
||||||
WHERE user_id = $1 AND completed_at IS NOT NULL
|
WHERE user_id = $1 AND completed_at IS NOT NULL
|
||||||
GROUP BY level
|
GROUP BY level
|
||||||
@@ -183,23 +242,19 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
|||||||
|
|
||||||
wq_rows = await conn.fetch("""
|
wq_rows = await conn.fetch("""
|
||||||
SELECT level, COALESCE(total_score, 0) AS score
|
SELECT level, COALESCE(total_score, 0) AS score
|
||||||
FROM word_quiz_progress
|
FROM word_quiz_progress WHERE user_id = $1
|
||||||
WHERE user_id = $1
|
|
||||||
""", telegram_id)
|
""", telegram_id)
|
||||||
wq_by_level = {r["level"]: r for r in wq_rows}
|
wq_by_level = {r["level"]: r for r in wq_rows}
|
||||||
|
|
||||||
bw_rows = await conn.fetch("""
|
bw_rows = await conn.fetch("""
|
||||||
SELECT level, COALESCE(total_score, 0) AS score
|
SELECT level, COALESCE(total_score, 0) AS score
|
||||||
FROM bubble_words_progress
|
FROM bubble_words_progress WHERE user_id = $1
|
||||||
WHERE user_id = $1
|
|
||||||
""", telegram_id)
|
""", telegram_id)
|
||||||
bw_by_level = {r["level"]: r for r in bw_rows}
|
bw_by_level = {r["level"]: r for r in bw_rows}
|
||||||
|
|
||||||
# 3. Собираем level_stats в Python — без единого запроса
|
|
||||||
level_stats = {}
|
level_stats = {}
|
||||||
for lvl in LEVELS:
|
for lvl in LEVELS:
|
||||||
lvl_lower = lvl.lower()
|
lvl_lower = lvl.lower()
|
||||||
|
|
||||||
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
|
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
|
||||||
ws_completed = ws_by_level.get(lvl, {}).get("completed", 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
|
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_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0
|
||||||
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
|
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
|
||||||
|
|
||||||
total_items = total_ws_levels + total_sentences
|
total_items = total_ws_levels + total_sentences
|
||||||
completed_items = ws_completed + s_completed
|
completed_items = ws_completed + s_completed
|
||||||
progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0
|
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,
|
"bubblewords_score": bw_score,
|
||||||
}
|
}
|
||||||
|
|
||||||
# 🔧 ИСПРАВЛЕНО: вызов достижений ВНЕ блока async with pool.acquire()
|
# Достижения
|
||||||
from routers.achievements import check_and_award_achievements
|
from routers.achievements import check_and_award_achievements
|
||||||
if my_position <= 3:
|
if my_position <= 3:
|
||||||
await check_and_award_achievements(telegram_id, "rank_reached", my_position)
|
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 {
|
return {
|
||||||
"leaderboard": leaderboard,
|
"leaderboard": leaderboard,
|
||||||
"current_level": current_level,
|
"current_level": current_level,
|
||||||
"my_rank": {
|
"my_rank": {
|
||||||
|
# Legacy
|
||||||
"rank": my_position,
|
"rank": my_position,
|
||||||
"telegram_id": telegram_id,
|
"telegram_id": telegram_id,
|
||||||
"total_score": my_total,
|
"total_score": my_total,
|
||||||
@@ -243,6 +302,17 @@ async def get_leaderboard(request: Request, limit: int = 50):
|
|||||||
"words_guessed": my_words_guessed,
|
"words_guessed": my_words_guessed,
|
||||||
"bubblewords_score": my_bubblewords,
|
"bubblewords_score": my_bubblewords,
|
||||||
"bubble_levels_completed": my_bubble_levels,
|
"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,
|
"level_stats": level_stats,
|
||||||
}
|
}
|
||||||
|
|||||||
+34
-4
@@ -160,6 +160,8 @@ async def check_sentence(request: Request):
|
|||||||
raise HTTPException(400, "Too many words")
|
raise HTTPException(400, "Too many words")
|
||||||
|
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
|
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
|
||||||
|
xp_result = None
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
user_exists = await conn.fetchval(
|
user_exists = await conn.fetchval(
|
||||||
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
|
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
|
||||||
@@ -207,12 +209,28 @@ async def check_sentence(request: Request):
|
|||||||
|
|
||||||
if is_correct:
|
if is_correct:
|
||||||
word_count = len(correct_words_original)
|
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:
|
if word_count <= 4:
|
||||||
score = 50
|
time_limit = 30
|
||||||
elif word_count <= 6:
|
elif word_count <= 6:
|
||||||
score = 75
|
time_limit = 45
|
||||||
else:
|
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(
|
await conn.execute(
|
||||||
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level)
|
"""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],
|
"correct_words": [normalize_word_for_display(w) for w in correct_words_original],
|
||||||
"already_completed": False,
|
"already_completed": False,
|
||||||
"score": score,
|
"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 {
|
return {
|
||||||
|
|||||||
@@ -104,3 +104,85 @@ async def set_level(request: Request):
|
|||||||
"status": "ok",
|
"status": "ok",
|
||||||
"level": level,
|
"level": level,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
# ============================================================
|
||||||
|
# 🆕 (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}
|
||||||
+68
-32
@@ -126,19 +126,26 @@ async def get_next_quiz(request: Request):
|
|||||||
|
|
||||||
@router.post("/check")
|
@router.post("/check")
|
||||||
async def check_quiz_answer(request: Request):
|
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)
|
telegram_id, _ = await require_auth(request)
|
||||||
body = await request.json()
|
body = await request.json()
|
||||||
correct_polish = body.get("correct_polish", "")
|
correct_polish = body.get("correct_polish", "")
|
||||||
user_answer = body.get("answer", "")
|
user_answer = body.get("answer", "")
|
||||||
completion_time = body.get("completion_time")
|
completion_time = body.get("completion_time")
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
|
# 🆕 wrong_count приходит с клиента для UI, но мы считаем на сервере
|
||||||
# mistakes больше НЕ берём от клиента. Считаем на сервере.
|
# 🔧 ФИКС: current_mistakes — серверный счётчик
|
||||||
|
|
||||||
if not correct_polish or not user_answer:
|
if not correct_polish or not user_answer:
|
||||||
raise HTTPException(400, "correct_polish and answer required")
|
raise HTTPException(400, "correct_polish and answer required")
|
||||||
|
|
||||||
# Защита от читерства: минимальное время 1 секунда
|
|
||||||
if completion_time is not None and completion_time < 1:
|
if completion_time is not None and completion_time < 1:
|
||||||
return {
|
return {
|
||||||
"correct": False,
|
"correct": False,
|
||||||
@@ -150,12 +157,11 @@ async def check_quiz_answer(request: Request):
|
|||||||
|
|
||||||
pool = await get_pool()
|
pool = await get_pool()
|
||||||
async with pool.acquire() as conn:
|
async with pool.acquire() as conn:
|
||||||
|
# Читаем серверный streak и mistakes
|
||||||
current_streak = await conn.fetchval(
|
current_streak = await conn.fetchval(
|
||||||
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
|
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) or 0
|
||||||
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
|
|
||||||
# читаем серверный current_mistakes.
|
|
||||||
mistakes = await conn.fetchval(
|
mistakes = await conn.fetchval(
|
||||||
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
|
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
@@ -165,7 +171,6 @@ async def check_quiz_answer(request: Request):
|
|||||||
current_streak += 1
|
current_streak += 1
|
||||||
else:
|
else:
|
||||||
current_streak = 0
|
current_streak = 0
|
||||||
# 🔧 Инкрементим mistakes на сервере
|
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
INSERT INTO word_quiz_progress (user_id, current_mistakes)
|
INSERT INTO word_quiz_progress (user_id, current_mistakes)
|
||||||
VALUES ($1, 1)
|
VALUES ($1, 1)
|
||||||
@@ -174,9 +179,24 @@ async def check_quiz_answer(request: Request):
|
|||||||
""", telegram_id)
|
""", telegram_id)
|
||||||
mistakes += 1
|
mistakes += 1
|
||||||
|
|
||||||
|
xp_result = None
|
||||||
|
score = 0
|
||||||
|
|
||||||
if is_correct:
|
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("""
|
await conn.execute("""
|
||||||
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
|
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
|
||||||
""", telegram_id)
|
""", telegram_id)
|
||||||
@@ -190,42 +210,34 @@ async def check_quiz_answer(request: Request):
|
|||||||
correct_streak = $3
|
correct_streak = $3
|
||||||
""", telegram_id, score, current_streak)
|
""", telegram_id, score, current_streak)
|
||||||
|
|
||||||
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_wordquiz —
|
# 🆕 Обновляем best_streak в choose_progress
|
||||||
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
|
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(
|
total_guessed = await conn.fetchval(
|
||||||
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
|
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
|
||||||
telegram_id
|
telegram_id
|
||||||
) or 0
|
) 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 = [
|
achievements_to_check = [
|
||||||
("quiz_guessed", total_guessed),
|
("quiz_guessed", total_guessed),
|
||||||
("total_score", grand_total),
|
("total_score", xp_result["total_xp"]),
|
||||||
]
|
]
|
||||||
if current_streak >= 10:
|
if current_streak >= 10:
|
||||||
achievements_to_check.append(("quiz_perfect_streak", current_streak))
|
achievements_to_check.append(("quiz_perfect_streak", current_streak))
|
||||||
if mistakes == 0:
|
if mistakes == 0:
|
||||||
achievements_to_check.append(("quiz_no_mistakes", 1))
|
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))
|
achievements_to_check.append(("quiz_speed", 3))
|
||||||
else:
|
else:
|
||||||
# При 3 ошибках — начисляем утешительные 10 очков
|
# При 3 ошибках — утешительный XP (10)
|
||||||
if mistakes >= 3:
|
if mistakes >= 3:
|
||||||
await conn.execute("""
|
await conn.execute("""
|
||||||
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes)
|
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
|
SET correct_streak = $2
|
||||||
""", telegram_id, current_streak)
|
""", telegram_id, current_streak)
|
||||||
|
|
||||||
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire()
|
# Достижения — вне транзакции
|
||||||
if is_correct:
|
if is_correct:
|
||||||
from routers.achievements import check_and_award_achievements
|
from routers.achievements import check_and_award_achievements
|
||||||
new_achievements = []
|
new_achievements = []
|
||||||
@@ -255,6 +267,20 @@ async def check_quiz_answer(request: Request):
|
|||||||
"score": score,
|
"score": score,
|
||||||
"correct_streak": current_streak,
|
"correct_streak": current_streak,
|
||||||
"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"],
|
||||||
|
# 🆕 Серия для UI
|
||||||
|
"streak_best": (await _get_best_streak(telegram_id)),
|
||||||
}
|
}
|
||||||
|
|
||||||
return {
|
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")
|
@router.get("/progress")
|
||||||
async def get_quiz_progress(request: Request):
|
async def get_quiz_progress(request: Request):
|
||||||
"""Статистика пользователя в квизе"""
|
"""Статистика пользователя в квизе"""
|
||||||
|
|||||||
@@ -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())
|
||||||
@@ -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"
|
||||||
+305
@@ -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,
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user