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:
2026-10-09 08:12:19 +00:00
parent a3f7d9521f
commit 84927b063f
13 changed files with 1800 additions and 278 deletions
+189
View File
@@ -1335,6 +1335,195 @@ async def init_db():
""")
logger.info("Table auth_identities initialized (Pleily)")
# ============================================================
# 🔧 НОВОЕ (08.10.2026): XP-фундамент Pleily.
# user_profile, xp_log, choose_progress, user_seen_levels,
# user_game_progress, wave_results, bubble_levels,
# user_seen_bubble_levels, user_word_stats.
# + расширение sentences (tokens, alt_orders, word_count).
# ============================================================
# ---------- user_profile ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_profile (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
nickname TEXT,
avatar_id INTEGER DEFAULT 0,
total_xp INTEGER DEFAULT 0,
weekly_xp INTEGER DEFAULT 0,
week_started_at DATE DEFAULT CURRENT_DATE,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_user_profile_weekly
ON user_profile(weekly_xp DESC)
""")
logger.info("Table user_profile initialized (XP)")
# ---------- xp_log ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS xp_log (
id BIGSERIAL PRIMARY KEY,
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
game TEXT NOT NULL,
stars INTEGER NOT NULL,
base_points INTEGER NOT NULL,
multiplier NUMERIC(3,2) NOT NULL DEFAULT 1.0,
points INTEGER NOT NULL,
created_at TIMESTAMP DEFAULT NOW()
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_xp_log_user_date
ON xp_log(user_id, created_at DESC)
""")
logger.info("Table xp_log initialized (XP)")
# ---------- choose_progress (серии в "Выбери слово") ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS choose_progress (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
current_streak INTEGER DEFAULT 0,
best_streak INTEGER DEFAULT 0,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
logger.info("Table choose_progress initialized")
# ---------- user_seen_levels (филворд: какие уровни видел) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_seen_levels (
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
level_id INTEGER NOT NULL
REFERENCES levels(id) ON DELETE CASCADE,
seen_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (user_id, level_id)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_user_seen_levels_user
ON user_seen_levels(user_id, seen_at DESC)
""")
logger.info("Table user_seen_levels initialized")
# ---------- user_game_progress (сессии филворда) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_game_progress (
user_id BIGINT PRIMARY KEY
REFERENCES users(telegram_id) ON DELETE CASCADE,
session_number INTEGER DEFAULT 1,
session_level_number INTEGER DEFAULT 1,
global_level_number INTEGER DEFAULT 1,
time_limit_seconds INTEGER,
updated_at TIMESTAMP DEFAULT NOW()
)
""")
logger.info("Table user_game_progress initialized")
# ---------- wave_results (итоги волны) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS wave_results (
id BIGSERIAL PRIMARY KEY,
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
wave_number INTEGER NOT NULL,
stars_earned INTEGER DEFAULT 0,
medal TEXT DEFAULT 'none',
completed_at TIMESTAMP DEFAULT NOW(),
UNIQUE (user_id, wave_number)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_wave_results_user
ON wave_results(user_id, wave_number DESC)
""")
logger.info("Table wave_results initialized")
# ---------- bubble_levels ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS bubble_levels (
id BIGSERIAL PRIMARY KEY,
word_ids INTEGER[] NOT NULL,
difficulty INTEGER DEFAULT 1,
created_at TIMESTAMP DEFAULT NOW()
)
""")
logger.info("Table bubble_levels initialized")
# ---------- user_seen_bubble_levels ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_seen_bubble_levels (
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
bubble_level_id BIGINT NOT NULL
REFERENCES bubble_levels(id) ON DELETE CASCADE,
seen_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (user_id, bubble_level_id)
)
""")
logger.info("Table user_seen_bubble_levels initialized")
# ---------- user_word_stats (повторение слов) ----------
await conn.execute("""
CREATE TABLE IF NOT EXISTS user_word_stats (
user_id BIGINT NOT NULL
REFERENCES users(telegram_id) ON DELETE CASCADE,
word_pl TEXT NOT NULL,
correct INTEGER DEFAULT 0,
wrong INTEGER DEFAULT 0,
last_seen_at TIMESTAMP DEFAULT NOW(),
PRIMARY KEY (user_id, word_pl)
)
""")
await conn.execute("""
CREATE INDEX IF NOT EXISTS idx_user_word_stats_user
ON user_word_stats(user_id, last_seen_at DESC)
""")
logger.info("Table user_word_stats initialized")
# ---------- sentences: tokens, alt_orders, word_count ----------
for col_name, col_type in (
("tokens", "JSONB DEFAULT '[]'::jsonb"),
("alt_orders", "JSONB DEFAULT '[]'::jsonb"),
("word_count", "INTEGER DEFAULT 0"),
):
col_exists = await conn.fetchval("""
SELECT 1 FROM information_schema.columns
WHERE table_name = 'sentences' AND column_name = $1
""", col_name)
if not col_exists:
await conn.execute(
f"ALTER TABLE sentences ADD COLUMN {col_name} {col_type}"
)
logger.info(f"Added {col_name} column to sentences")
# Backfill: word_count для существующих предложений
await conn.execute("""
UPDATE sentences
SET word_count = array_length(
regexp_split_to_array(trim(sentence_pl), '\\s+'), 1
)
WHERE word_count = 0 OR word_count IS NULL
""")
logger.info("Backfilled sentences.word_count")
# ---------- Backfill: user_profile для существующих юзеров ----------
await conn.execute("""
INSERT INTO user_profile (user_id, total_xp, weekly_xp)
SELECT u.telegram_id, 0, 0
FROM users u
WHERE NOT EXISTS (
SELECT 1 FROM user_profile p WHERE p.user_id = u.telegram_id
)
ON CONFLICT (user_id) DO NOTHING
""")
logger.info("Backfilled user_profile for existing users")
await conn.execute("CREATE INDEX IF NOT EXISTS idx_sentences_level_number ON sentences(level, sentence_number)")
# Оставляем score-индексы (не дубли)
await conn.execute("CREATE INDEX IF NOT EXISTS idx_user_progress_score ON user_progress(score DESC)")
+2
View File
@@ -15,6 +15,7 @@ from routers import users, game, hints, leaderboard, sentences, achievements, wo
from routers import lectures, admin_auth, admin_wordsearch, admin_users
from routers import admin_ai # 🔧 НОВОЕ
from routers import app_auth # 🆕 Pleily auth
from routers import featured as featured_router # 🔧 НОВОЕ (08.10.2026)
from routers.sentences import init_sentences
from routers.achievements import init_achievements
from routers.learning_data import init_learning_data
@@ -375,6 +376,7 @@ app.include_router(admin_wordsearch.router)
app.include_router(admin_users.router)
app.include_router(admin_ai.router) # 🔧 НОВОЕ
app.include_router(app_auth.router) # 🆕 Pleily
app.include_router(featured_router.router) # 🔧 НОВОЕ (08.10.2026)
# ============ Базовые эндпоинты ============
+77 -35
View File
@@ -18,6 +18,12 @@ Telegram-юзеры сохраняют свои положительные teleg
- DELETE /me — удаление аккаунта (Apple требует)
🔧 НОВОЕ (07.10.2026): pleily_auth — первая версия.
🔧 ФИКС (07.10.2026): device_id_in_users —
теперь device_id пишется и в users.device_id, и в auth_identities.
Это нужно для SQL-запросов по device_id (админка, миграции).
🔧 НОВОЕ (08.10.2026): auth_me_xp_fields —
в /auth/me добавлены XP-поля: level, rank_key, rank_name,
xp_in_level, xp_needed, total_xp, weekly_xp, weekly_rank.
"""
import logging
import uuid
@@ -97,11 +103,14 @@ async def _create_app_user(conn, device_id: str) -> int:
uid_row = await conn.fetchrow("SELECT nextval('app_user_id_seq') AS uid")
uid = uid_row["uid"]
# Создаём юзера в users
# 🔧 ФИКС (07.10.2026): device_id_in_users —
# раньше device_id сохранялся только в auth_identities,
# а в users.device_id был NULL. Теперь — в обоих местах.
# Это нужно для SQL-запросов по device_id (админка, миграции).
await conn.execute("""
INSERT INTO users (telegram_id, username, source)
VALUES ($1, $2, 'app')
""", uid, f"app_user_{abs(uid)}")
INSERT INTO users (telegram_id, username, source, device_id)
VALUES ($1, $2, 'app', $3)
""", uid, f"app_user_{abs(uid)}", device_id)
# Создаём identity
await conn.execute("""
@@ -174,45 +183,78 @@ async def auth_device(request: Request):
@router.get("/me")
async def auth_me(request: Request):
"""
Возвращает данные текущего Pleily-юзера. Для тестов и отладки.
Требует Authorization: Bearer <JWT>.
Текущий юзер + XP-поля.
🔧 НОВОЕ (08.10.2026): добавлены level, rank_key, rank_name,
xp_in_level, xp_needed, total_xp, weekly_xp.
"""
user_id, _username = await require_auth(request)
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
row = await conn.fetchrow("""
SELECT telegram_id, username, source, app_language, current_level, created_at
user = await conn.fetchrow(
"""
SELECT telegram_id, username, app_language, current_level,
source, device_id, apple_id, created_at
FROM users WHERE telegram_id = $1
""", user_id)
""",
telegram_id,
)
if not user:
raise HTTPException(401, "User not found")
if not row:
raise HTTPException(404, "User not found")
profile = await conn.fetchrow(
"""
SELECT nickname, avatar_id, total_xp, weekly_xp, week_started_at
FROM user_profile WHERE user_id = $1
""",
telegram_id,
)
# Получаем identities юзера (для диагностики)
identities_rows = await conn.fetch("""
SELECT provider, provider_uid, created_at
FROM auth_identities WHERE user_id = $1
ORDER BY created_at
""", user_id)
# Weekly rank
weekly_rank = await conn.fetchval(
"""
SELECT COUNT(*) + 1
FROM user_profile
WHERE weekly_xp > COALESCE((
SELECT weekly_xp FROM user_profile WHERE user_id = $1
), 0)
""",
telegram_id,
)
return {
"user_id": row["telegram_id"],
"username": row["username"],
"source": row["source"],
"app_language": row["app_language"],
"current_level": row["current_level"],
"created_at": row["created_at"].isoformat() if row["created_at"] else None,
"identities": [
{
"provider": r["provider"],
"provider_uid": r["provider_uid"],
"created_at": r["created_at"].isoformat() if r["created_at"] else None,
}
for r in identities_rows
],
}
# Считаем уровень
from services.xp import level_for, rank_for
total_xp = int(profile["total_xp"]) if profile else 0
weekly_xp = int(profile["weekly_xp"]) if profile else 0
level, xp_in_level, xp_needed, rank_key = level_for(total_xp)
lang = (user["app_language"] or "ru").lower()
if lang not in ("pl", "ru", "uk", "en"):
lang = "ru"
return {
"user_id": user["telegram_id"],
"username": user["username"],
"nickname": profile["nickname"] if profile else None,
"avatar_id": int(profile["avatar_id"]) if profile and profile["avatar_id"] is not None else 0,
"app_language": user["app_language"],
"current_level": user["current_level"],
"source": user["source"],
"device_id": str(user["device_id"]) if user["device_id"] else None,
"apple_id": user["apple_id"],
"created_at": user["created_at"].isoformat() if user["created_at"] else None,
# --- XP ---
"total_xp": total_xp,
"weekly_xp": weekly_xp,
"level": level,
"rank_key": rank_key,
"rank_name": rank_for(level, lang),
"xp_in_level": xp_in_level,
"xp_needed": xp_needed,
"weekly_rank": int(weekly_rank) if weekly_rank else 0,
}
@router.delete("/me")
+44 -30
View File
@@ -171,13 +171,21 @@ async def get_next_bubble_level(request: Request):
@router.post("/complete")
async def complete_bubble_level(request: Request):
"""Завершение уровня пузырей, начисление очков и проверка достижений"""
"""Завершение уровня пузырей, начисление XP и проверка достижений.
🔧 НОВОЕ (08.10.2026): XP-система.
Штрафы:
-1 за открытие списка слов (один раз за уровень)
-1 за каждое неправильно собранное слово (макс 3)
-1 если time_ms > 60 сек
Минимум 1 звезда.
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
words_count = body.get("words_count", 3)
completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
# hints_used больше НЕ берём от клиента. Читаем из bubble_words_progress.current_hints_used.
list_opened = bool(body.get("list_opened", False))
wrong_words = int(body.get("wrong_words", 0) or 0)
pool = await get_pool()
async with pool.acquire() as conn:
@@ -187,19 +195,29 @@ async def complete_bubble_level(request: Request):
if not user_exists:
raise HTTPException(401, "User not registered")
# Получаем current_level пользователя
current_level = await conn.fetchval(
"SELECT current_level FROM users WHERE telegram_id = $1", telegram_id
) or "A1"
# 🔧 ФИКС (24.09.2026): client_controlled_hints_bubblewords —
# читаем серверный hints_used.
# Читаем серверный hints_used
hints_used = await conn.fetchval(
"SELECT current_hints_used FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10)
# 🆕 Расчёт звёзд
# Старт 5. Штрафы: hints(1) + wrong_words(до 3) + time(1)
time_penalty = 1 if (completion_time and completion_time > 60) else 0
wrong_penalty = min(max(0, wrong_words), 3)
hint_penalty = 1 if hints_used > 0 else 0
list_penalty = 1 if list_opened else 0
stars = max(1, 5 - time_penalty - wrong_penalty - hint_penalty - list_penalty)
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "bubbles", stars)
score = xp_result["points"]
await conn.execute("""
INSERT INTO bubble_words_progress (user_id, levels_completed, total_score, level, current_hints_used)
@@ -211,42 +229,26 @@ async def complete_bubble_level(request: Request):
current_hints_used = 0
""", telegram_id, score, current_level)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_bubblewords —
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
# Данные для достижений
total_levels = await conn.fetchval(
"SELECT levels_completed FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [
("bubble_levels", total_levels),
("total_score", grand_total),
("total_score", xp_result["total_xp"]),
]
if hints_used == 0:
achievements_to_check.append(("bubble_no_hints", 1))
if score == 100:
if stars == 5:
achievements_to_check.append(("bubble_perfect", 1))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 45:
if completion_time is not None and 0 < completion_time <= 45:
achievements_to_check.append(("bubble_speed", 45))
if completion_time is not None and 0 < completion_time <= 30:
achievements_to_check.append(("bubble_speed_30", 30))
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire()
# Достижения — вне транзакции
from routers.achievements import check_and_award_achievements
new_achievements = []
for ach_type, value in achievements_to_check:
@@ -258,6 +260,18 @@ async def complete_bubble_level(request: Request):
"score": score,
"completion_time": completion_time,
"new_achievements": new_achievements,
# 🆕 XP-поля
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
}
+36
View File
@@ -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(),
}
+206 -70
View File
@@ -27,23 +27,12 @@ async def get_progress(request: Request):
current_level = user["current_level"] or "A1"
# 🔧 ФИКС (30.09.2026): progress_uses_per_level —
# возвращаем last_completed_level для ТЕКУЩЕГО уровня языка,
# а не глобальный счётчик (который смешивал A1+A2+B1).
last_by_level = user["last_completed_by_level"] or {}
if isinstance(last_by_level, str):
try:
import json as _json
last_by_level = _json.loads(last_by_level)
except Exception:
last_by_level = {}
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Раньше возвращали last_completed_for_current из per-level JSONB,
# но уровни теперь глобальные (level = 'common').
# Возвращаем users.last_completed_level — единый глобальный прогресс.
last_completed = user["last_completed_level"] or 0
last_completed_for_current = (
last_by_level.get(current_level, 0)
if isinstance(last_by_level, dict)
else 0
)
# Очки из филвордов
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1",
@@ -71,8 +60,7 @@ async def get_progress(request: Request):
total_score = (wordsearch_score or 0) + (sentence_score or 0) + (wordquiz_score or 0) + (bubblewords_score or 0)
return {
"last_completed_level": last_completed_for_current,
"last_completed_by_level": last_by_level,
"last_completed_level": last_completed,
"total_score": total_score,
"current_level": current_level
}
@@ -93,42 +81,26 @@ async def get_level(request: Request, level_number: int):
lang = user["app_language"] or "pl"
current_level = user["current_level"] or "A1"
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик (без per-level).
# Уровни глобальные (level = 'common'), поэтому прогресс —
# users.last_completed_level. last_completed_by_level оставлен
# в БД для совместимости, но больше не используется здесь.
last_completed = user["last_completed_level"] or 0
# 🔧 ФИКС (30.09.2026): last_completed_by_level —
# используем per-level счётчик. Fallback на last_completed_level (старый).
last_completed_by_level = user["last_completed_by_level"] or {}
if isinstance(last_completed_by_level, str):
try:
import json as _json
last_completed_by_level = _json.loads(last_completed_by_level)
except Exception:
last_completed_by_level = {}
last_completed = last_completed_by_level.get(current_level, 0) if isinstance(last_completed_by_level, dict) else 0
# Проверяем, что уровень доступен (не дальше следующего за пройденным)
if level_number > 1 and level_number > last_completed + 1:
raise HTTPException(403, "Level not available yet. Complete previous level first.")
# 🔧 ФИКС (29.09.2026): приоритет ручным уровням.
# Если есть уровень, созданный вручную (created_by IS NOT NULL) —
# показываем его. Иначе — fallback на авто (created_by IS NULL).
# 🔧 ОБНОВЛЕНО (07.10.2026): все уровни — common (автогенерированные).
# Ищем по level_number без created_by и без current_level.
# is_active = TRUE — чтобы черновики не показывались.
level = await conn.fetchrow("""
SELECT * FROM levels
WHERE level = $1 AND level_number = $2
AND created_by IS NOT NULL
WHERE level_number = $1
AND is_active = TRUE
LIMIT 1
""", current_level, level_number)
# Fallback на авто, если ручного нет
if not level:
level = await conn.fetchrow("""
SELECT * FROM levels
WHERE level = $1 AND level_number = $2
AND created_by IS NULL
LIMIT 1
""", current_level, level_number)
""", level_number)
if not level:
raise HTTPException(404, "Level not found")
@@ -312,6 +284,8 @@ async def complete_level(request: Request):
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# hints_used читаем из БД, не доверяем клиенту.
hints_used = 0
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
async with pool.acquire() as conn:
user = await conn.fetchrow(
@@ -330,9 +304,10 @@ async def complete_level(request: Request):
current_level_number = level["level_number"]
level_name = level["level"] or "A1"
# Проверяем, что уровень принадлежит текущему уровню пользователя
if level_name != (user["current_level"] or "A1"):
raise HTTPException(403, "This level does not belong to your current level")
# 🔧 ОБНОВЛЕНО (07.10.2026): level = 'common'.
# Уровни глобальные, поэтому убираем проверку «уровень принадлежит
# твоему current_level». Оставляем только проверку прогресса выше.
# (Проверка не твоя-не твоя была актуальна, когда были A1/A2/B1.)
# 🔧 ФИКС (25.09.2026): already_completed_detects_hint_row —
# раньше already_completed = True при ЛЮБОЙ строке user_progress.
@@ -365,19 +340,41 @@ async def complete_level(request: Request):
telegram_id, level_id
) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_hints_game —
# читаем hints_used из БД, не доверяем клиенту.
# 🔧 НОВОЕ (08.10.2026): XP-система.
# Читаем hints_used и list_opened из БД (не доверяем клиенту).
hints_used = await conn.fetchval(
"SELECT hints_used FROM user_progress WHERE user_id = $1 AND level_id = $2",
telegram_id, level_id
) or 0
hints_used = min(max(0, hints_used), 3)
score = max(10, 100 - hints_used * 10)
# 🔧 ФИКС (23.09.2026): client_controlled_achievement_values —
# сбрасываем current_streak в 0 при завершении уровня.
#
# 🆕 Штрафы (филворд):
# -1 за открытие списка слов (один раз за уровень)
# -1 за использование подсказки (один раз за уровень)
# -1 за превышение времени
list_opened = bool(body.get("list_opened", False))
# Лимит времени по размеру сетки
grid_size = level["grid_size"]
time_limits = {5: 45, 6: 60, 7: 90, 8: 120}
time_limit = time_limits.get(grid_size, 60)
completion_time_val = completion_time or 0
time_penalty = 1 if (completion_time_val > time_limit) else 0
hint_penalty = 1 if hints_used > 0 else 0
list_penalty = 1 if list_opened else 0
stars = max(
1,
5 - time_penalty - hint_penalty - list_penalty
)
# Начисляем XP через единую функцию
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "wordsearch", stars)
score = xp_result["points"] # для обратной совместимости
# 🔧 ФИКС (25.09.2026): complete_level_insert_overwrites_hints_used —
# раньше INSERT падал с unique violation, если строка user_progress
# уже была создана hints.py (юзер взял подсказку → уровень не завершится).
@@ -395,22 +392,15 @@ async def complete_level(request: Request):
current_streak = 0
""", telegram_id, level_id, hints_used, score, level_name)
# 🔧 ФИКС (30.09.2026): last_completed_by_level —
# обновляем per-level счётчик (JSONB) + старый last_completed_level.
# 🔧 ОБНОВЛЕНО (07.10.2026): единый счётчик progress.
# Обновляем только users.last_completed_level — глобальный.
# last_completed_by_level (JSONB) остаётся в БД для совместимости,
# но больше не пишется.
await conn.execute("""
UPDATE users
SET last_completed_level = GREATEST(last_completed_level, $2),
last_completed_by_level = jsonb_set(
COALESCE(last_completed_by_level, '{}'::jsonb),
ARRAY[$3::text],
to_jsonb(GREATEST(
COALESCE((last_completed_by_level->>$3)::int, 0),
$2
)),
true
)
SET last_completed_level = GREATEST(COALESCE(last_completed_level, 0), $2)
WHERE telegram_id = $1
""", telegram_id, current_level_number, level_name)
""", telegram_id, current_level_number)
# Собираем данные для достижений внутри блока
levels_completed = await conn.fetchval(
@@ -471,8 +461,154 @@ async def complete_level(request: Request):
new_achievements.extend(ach)
return {
"status": "ok",
"status": "ok",
"score": score,
"already_completed": False,
"new_achievements": new_achievements
"new_achievements": new_achievements,
# 🆕 XP-поля
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
}
# ============================================================
# 🆕 (08.10.2026): Волновая выдача уровня.
# ============================================================
@router.post("/next")
async def get_next_level(request: Request):
"""
Выдаёт следующий уровень по волновой структуре.
Логика:
1. Смотрим user_game_progress.global_level_number.
2. Определяем волну и размер сетки через wave_plan.
3. Ищем непройденный уровень нужного размера (в user_seen_levels).
4. Помечаем как seen, обновляем user_game_progress.
5. Возвращаем level_number.
"""
telegram_id, _ = await require_auth(request)
pool = await get_pool()
async with pool.acquire() as conn:
# Читаем или создаём прогресс
row = await conn.fetchrow(
"""
SELECT global_level_number, session_number, session_level_number
FROM user_game_progress WHERE user_id = $1
""",
telegram_id,
)
if row is None:
await conn.execute(
"""
INSERT INTO user_game_progress
(user_id, global_level_number, session_number, session_level_number)
VALUES ($1, 1, 1, 1)
ON CONFLICT (user_id) DO NOTHING
""",
telegram_id,
)
global_level = 1
session_number = 1
session_level = 1
else:
global_level = int(row["global_level_number"] or 1)
session_number = int(row["session_number"] or 1)
session_level = int(row["session_level_number"] or 1)
# Определяем волну и размер
from services.waves import wave_for_level, level_in_wave, grid_size_for
wave = wave_for_level(global_level)
pos_in_wave = level_in_wave(global_level)
grid_size = grid_size_for(global_level)
# Ищем непройденный уровень нужного размера
# Исключаем те, что уже в user_seen_levels
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND l.id NOT IN (
SELECT level_id FROM user_seen_levels WHERE user_id = $2
)
ORDER BY RANDOM()
LIMIT 1
""",
grid_size, telegram_id,
)
# Fallback: если непройденных нет, берём самый давно виденный
if level is None:
level = await conn.fetchrow(
"""
SELECT l.id, l.level_number
FROM levels l
JOIN user_seen_levels usl ON usl.level_id = l.id
WHERE l.grid_size = $1
AND l.is_active = TRUE
AND usl.user_id = $2
ORDER BY usl.seen_at ASC
LIMIT 1
""",
grid_size, telegram_id,
)
if level is None:
raise HTTPException(404, "No levels available for this grid size")
level_id = level["id"]
level_number = level["level_number"]
# Помечаем как seen (обновляем seen_at если уже был)
await conn.execute(
"""
INSERT INTO user_seen_levels (user_id, level_id, seen_at)
VALUES ($1, $2, NOW())
ON CONFLICT (user_id, level_id) DO UPDATE
SET seen_at = NOW()
""",
telegram_id, level_id,
)
# Обновляем прогресс
next_global = global_level + 1
next_session_level = session_level + 1
next_session = session_number
if next_session_level > 20:
next_session_level = 1
next_session += 1
await conn.execute(
"""
UPDATE user_game_progress
SET global_level_number = $2,
session_number = $3,
session_level_number = $4,
updated_at = NOW()
WHERE user_id = $1
""",
telegram_id, next_global, next_session, next_session_level,
)
return {
"level_id": level_id,
"level_number": level_number,
"grid_size": grid_size,
"wave": wave,
"position_in_wave": pos_in_wave,
"session_number": session_number,
"session_level": session_level,
"global_level": global_level,
}
+171 -101
View File
@@ -10,7 +10,18 @@ LEVELS = ["A1", "A2", "B1", "B2", "C1", "C2"]
@router.get("")
async def get_leaderboard(request: Request, limit: int = 50):
"""Рейтинг игроков — быстрое чтение из кэша"""
"""
Рейтинг игроков.
🔧 ОБНОВЛЕНО (08.10.2026): XP-фундамент.
Сортировка: total_xp DESC → total_score DESC.
weekly_xp в БД остаётся, но больше НЕ используется в сортировке.
Legacy-поля (total_score, wordsearch_score, ...) сохранены для Mini App.
Новые поля в каждой строке: total_xp, level, rank_key, rank_name,
xp_in_level, xp_needed, avatar_id.
"""
telegram_id, _ = await require_auth(request)
if limit < 1:
@@ -28,17 +39,39 @@ async def get_leaderboard(request: Request, limit: int = 50):
current_level = user["current_level"] or "A1"
# Быстрое чтение из MATERIALIZED VIEW
# 🆕 Топ-N: matview + LEFT JOIN user_profile для XP.
# 🔧 ОБНОВЛЕНО (08.10.2026): сортировка по total_xp (weekly_xp убран).
rows = await conn.fetch("""
SELECT * FROM leaderboard_cache
ORDER BY total_score DESC
SELECT
lc.*,
COALESCE(p.weekly_xp, 0) AS weekly_xp,
COALESCE(p.total_xp, 0) AS total_xp,
COALESCE(p.avatar_id, 0) AS avatar_id,
u.app_language
FROM leaderboard_cache lc
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
ORDER BY COALESCE(p.total_xp, 0) DESC,
lc.total_score DESC,
lc.telegram_id ASC
LIMIT $1
""", limit)
leaderboard = []
for i, row in enumerate(rows):
leaderboard.append({
"rank": i + 1,
# Импорт XP-хелперов
from services.xp import level_for, rank_for
def _serialize_row(row, rank_num):
"""Собирает строку рейтинга с legacy + XP-полями."""
weekly_xp = int(row["weekly_xp"] or 0)
total_xp = int(row["total_xp"] or 0)
level, xp_in_level, xp_needed, rank_key = level_for(total_xp)
lang = (row.get("app_language") or "ru").lower()
if lang not in ("pl", "ru", "uk", "en"):
lang = "ru"
return {
# Legacy (Mini App)
"rank": rank_num,
"telegram_id": row["telegram_id"],
"username": row["username"] or f"Player{row['telegram_id']}",
"total_score": row["total_score"],
@@ -50,100 +83,131 @@ async def get_leaderboard(request: Request, limit: int = 50):
"bubble_levels_completed": row["bubble_levels_completed"],
"levels_completed": 0,
"sentences_completed": 0,
})
# 🆕 XP (Pleily)
"weekly_xp": weekly_xp, # оставлен для legacy Mini App
"total_xp": total_xp,
"level": level,
"rank_key": rank_key,
"rank_name": rank_for(level, lang),
"xp_in_level": xp_in_level,
"xp_needed": xp_needed,
"avatar_id": int(row["avatar_id"] or 0),
"app_language": lang,
}
# 🔧 ФИКС (25.09.2026): leaderboard_rank_wrong_for_uncached_user —
# если пользователя нет в leaderboard_cache, подзапрос вернёт NULL,
# и COUNT(*) + 1 = 1 (юзер видит себя первым, хотя у него 0 очков).
# Теперь: если user нет в кэше — считаем его место по количеству
# записей с total_score > 0 + 1 (в конец списка).
my_total_in_cache = await conn.fetchval("""
SELECT total_score FROM leaderboard_cache WHERE telegram_id = $1
""", telegram_id)
leaderboard = [
_serialize_row(row, rank_num=i + 1)
for i, row in enumerate(rows)
]
if my_total_in_cache is None:
# Пользователя нет в кэше — считаем по количеству с > 0
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > 0
""") or 1
else:
user_rank = await conn.fetchval("""
SELECT COUNT(*) + 1 FROM leaderboard_cache
WHERE total_score > $1
""", my_total_in_cache)
# Персональная статистика пользователя
# ============ Мой ранг ============
# Читаем мои XP + legacy-статистику.
my_row = await conn.fetchrow("""
SELECT * FROM leaderboard_cache WHERE telegram_id = $1
SELECT
lc.*,
COALESCE(p.weekly_xp, 0) AS weekly_xp,
COALESCE(p.total_xp, 0) AS total_xp,
COALESCE(p.avatar_id, 0) AS avatar_id,
u.app_language
FROM leaderboard_cache lc
LEFT JOIN user_profile p ON p.user_id = lc.telegram_id
LEFT JOIN users u ON u.telegram_id = lc.telegram_id
WHERE lc.telegram_id = $1
""", telegram_id)
if my_row:
# Если юзера нет в matview — пробуем только user_profile.
if not my_row:
my_profile = await conn.fetchrow("""
SELECT
p.weekly_xp, p.total_xp, p.avatar_id,
u.username, u.app_language, u.current_level
FROM user_profile p
JOIN users u ON u.telegram_id = p.user_id
WHERE p.user_id = $1
""", telegram_id)
if my_profile:
my_weekly_xp = int(my_profile["weekly_xp"] or 0)
my_total_xp = int(my_profile["total_xp"] or 0)
my_avatar_id = int(my_profile["avatar_id"] or 0)
my_username = my_profile["username"]
my_lang = (my_profile["app_language"] or "ru").lower()
else:
my_weekly_xp = 0
my_total_xp = 0
my_avatar_id = 0
my_username = None
my_lang = "ru"
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
my_position = await conn.fetchval("""
SELECT COUNT(*) + 1
FROM user_profile
WHERE total_xp > $1
""", my_total_xp) or 1
# Legacy-статистика (для совместимости с Mini App)
my_wordsearch = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_sentence = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_wordquiz = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_words_guessed = await conn.fetchval(
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubblewords = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubble_levels = await conn.fetchval(
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
my_wordsearch_levels = 0
my_sentences_completed = 0
my_avatar_id_final = my_avatar_id
my_username_final = my_username
my_lang_final = my_lang
else:
my_weekly_xp = int(my_row["weekly_xp"] or 0)
my_total_xp = int(my_row["total_xp"] or 0)
my_avatar_id_final = int(my_row["avatar_id"] or 0)
my_username_final = my_row["username"]
my_lang_final = (my_row["app_language"] or "ru").lower()
my_wordsearch = my_row["wordsearch_score"]
my_sentence = my_row["sentence_score"]
my_wordquiz = my_row["wordquiz_score"]
my_words_guessed = my_row["words_guessed"]
my_bubblewords = my_row["bubblewords_score"]
my_bubble_levels = my_row["bubble_levels_completed"]
else:
my_wordsearch = 0
my_sentence = 0
my_wordquiz = 0
my_words_guessed = 0
my_bubblewords = 0
my_bubble_levels = 0
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
# Считаем НАПРЯМУЮ из основных таблиц
my_wordsearch_levels = await conn.fetchval(
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
# 🔧 ОБНОВЛЕНО (08.10.2026): место по total_xp (не weekly_xp).
my_position = await conn.fetchval("""
SELECT COUNT(*) + 1
FROM user_profile
WHERE total_xp > $1
""", my_total_xp) or 1
my_sentences_completed = await conn.fetchval(
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
# Если пользователя нет в кэше — считаем очки из основных таблиц
if not my_row:
my_wordsearch = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
my_wordsearch_levels = await conn.fetchval(
"SELECT COUNT(DISTINCT level_id) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_sentences_completed = await conn.fetchval(
"SELECT COUNT(*) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_sentence = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
my_wordquiz = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_words_guessed = await conn.fetchval(
"SELECT COALESCE(words_guessed, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubblewords = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_bubble_levels = await conn.fetchval(
"SELECT COALESCE(levels_completed, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
my_total = my_wordsearch + my_sentence + my_wordquiz + my_bubblewords
my_position = user_rank or 1
# 🔧 ФИКС N+1 (19.09.2026): 48 запросов → 5.
# Было: цикл по 6 уровням × 8 запросов = 48 round-trip к БД.
# Стало: 5 агрегированных запросов + сборка level_stats в Python.
# 1. Справочники (не зависят от юзера) — одним запросом
# ============ level_stats (legacy для Mini App) ============
ref_row = await conn.fetchrow("""
SELECT
(SELECT COUNT(*) FROM levels WHERE level = 'A1') AS a1_levels,
@@ -160,11 +224,8 @@ async def get_leaderboard(request: Request, limit: int = 50):
(SELECT COUNT(*) FROM sentences WHERE level = 'C2') AS c2_sent
""")
# 2. Очки и прогресс по всем уровням сразу — 4 запроса с GROUP BY
ws_rows = await conn.fetch("""
SELECT level,
COALESCE(SUM(score), 0) AS score,
COUNT(*) AS completed
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
FROM user_progress
WHERE user_id = $1 AND completed_at IS NOT NULL
GROUP BY level
@@ -172,9 +233,7 @@ async def get_leaderboard(request: Request, limit: int = 50):
ws_by_level = {r["level"]: r for r in ws_rows}
s_rows = await conn.fetch("""
SELECT level,
COALESCE(SUM(score), 0) AS score,
COUNT(*) AS completed
SELECT level, COALESCE(SUM(score), 0) AS score, COUNT(*) AS completed
FROM sentence_progress
WHERE user_id = $1 AND completed_at IS NOT NULL
GROUP BY level
@@ -183,23 +242,19 @@ async def get_leaderboard(request: Request, limit: int = 50):
wq_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) AS score
FROM word_quiz_progress
WHERE user_id = $1
FROM word_quiz_progress WHERE user_id = $1
""", telegram_id)
wq_by_level = {r["level"]: r for r in wq_rows}
bw_rows = await conn.fetch("""
SELECT level, COALESCE(total_score, 0) AS score
FROM bubble_words_progress
WHERE user_id = $1
FROM bubble_words_progress WHERE user_id = $1
""", telegram_id)
bw_by_level = {r["level"]: r for r in bw_rows}
# 3. Собираем level_stats в Python — без единого запроса
level_stats = {}
for lvl in LEVELS:
lvl_lower = lvl.lower()
ws_score = ws_by_level.get(lvl, {}).get("score", 0) or 0
ws_completed = ws_by_level.get(lvl, {}).get("completed", 0) or 0
s_score = s_by_level.get(lvl, {}).get("score", 0) or 0
@@ -209,7 +264,6 @@ async def get_leaderboard(request: Request, limit: int = 50):
total_ws_levels = ref_row[f"{lvl_lower}_levels"] or 0
total_sentences = ref_row[f"{lvl_lower}_sent"] or 0
total_items = total_ws_levels + total_sentences
completed_items = ws_completed + s_completed
progress_percent = round((completed_items / total_items * 100), 1) if total_items > 0 else 0
@@ -223,15 +277,20 @@ async def get_leaderboard(request: Request, limit: int = 50):
"bubblewords_score": bw_score,
}
# 🔧 ИСПРАВЛЕНО: вызов достижений ВНЕ блока async with pool.acquire()
# Достижения
from routers.achievements import check_and_award_achievements
if my_position <= 3:
await check_and_award_achievements(telegram_id, "rank_reached", my_position)
# ============ Мой ранг (XP) ============
my_level, my_xp_in_level, my_xp_needed, my_rank_key = level_for(my_total_xp)
my_rank_name = rank_for(my_level, my_lang_final)
return {
"leaderboard": leaderboard,
"current_level": current_level,
"my_rank": {
# Legacy
"rank": my_position,
"telegram_id": telegram_id,
"total_score": my_total,
@@ -243,6 +302,17 @@ async def get_leaderboard(request: Request, limit: int = 50):
"words_guessed": my_words_guessed,
"bubblewords_score": my_bubblewords,
"bubble_levels_completed": my_bubble_levels,
# 🆕 XP
"username": my_username_final,
"weekly_xp": my_weekly_xp, # оставлен для legacy Mini App
"total_xp": my_total_xp,
"level": my_level,
"rank_key": my_rank_key,
"rank_name": my_rank_name,
"xp_in_level": my_xp_in_level,
"xp_needed": my_xp_needed,
"avatar_id": my_avatar_id_final,
"app_language": my_lang_final,
},
"level_stats": level_stats,
}
+34 -4
View File
@@ -160,6 +160,8 @@ async def check_sentence(request: Request):
raise HTTPException(400, "Too many words")
pool = await get_pool()
# 🔧 НОВОЕ (08.10.2026): XP-система — результат award_xp.
xp_result = None
async with pool.acquire() as conn:
user_exists = await conn.fetchval(
"SELECT 1 FROM users WHERE telegram_id = $1", telegram_id
@@ -207,12 +209,28 @@ async def check_sentence(request: Request):
if is_correct:
word_count = len(correct_words_original)
# 🆕 Расчёт звёзд для "Составь предложение"
# Старт 5. Штрафы:
# -1 за каждую неверную проверку (клиент шлёт wrong_checks)
# -1 если time > лимита (по длине: 3-4 → 30с, 5-6 → 45с, 7-8 → 60с)
wrong_checks = int(body.get("wrong_checks", 0) or 0)
if word_count <= 4:
score = 50
time_limit = 30
elif word_count <= 6:
score = 75
time_limit = 45
else:
score = 100
time_limit = 60
time_penalty = 1 if (completion_time and completion_time > time_limit) else 0
wrong_penalty = min(max(0, wrong_checks), 3)
stars = max(1, 5 - wrong_penalty - time_penalty)
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "sentence", stars)
score = xp_result["points"]
await conn.execute(
"""INSERT INTO sentence_progress (user_id, sentence_id, completed_at, score, level)
@@ -267,7 +285,19 @@ async def check_sentence(request: Request):
"correct_words": [normalize_word_for_display(w) for w in correct_words_original],
"already_completed": False,
"score": score,
"new_achievements": new_achievements
"new_achievements": new_achievements,
# 🆕 XP
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
}
return {
+83 -1
View File
@@ -103,4 +103,86 @@ async def set_level(request: Request):
return {
"status": "ok",
"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}
+73 -37
View File
@@ -126,19 +126,26 @@ async def get_next_quiz(request: Request):
@router.post("/check")
async def check_quiz_answer(request: Request):
"""Проверяет ответ, начисляет очки и проверяет достижения"""
"""Проверяет ответ, начисляет XP и проверяет достижения.
🔧 НОВОЕ (08.10.2026): XP-система + серии.
Штрафы:
-1 за каждый неверный выбор (макс 3)
-1 если time_ms > 30 сек
Минимум 1 звезда.
Серия: correct_streak (best_streak хранится в choose_progress).
"""
telegram_id, _ = await require_auth(request)
body = await request.json()
correct_polish = body.get("correct_polish", "")
user_answer = body.get("answer", "")
completion_time = body.get("completion_time")
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
# mistakes больше НЕ берём от клиента. Считаем на сервере.
# 🆕 wrong_count приходит с клиента для UI, но мы считаем на сервере
# 🔧 ФИКС: current_mistakes — серверный счётчик
if not correct_polish or not user_answer:
raise HTTPException(400, "correct_polish and answer required")
# Защита от читерства: минимальное время 1 секунда
if completion_time is not None and completion_time < 1:
return {
"correct": False,
@@ -147,25 +154,23 @@ async def check_quiz_answer(request: Request):
}
is_correct = user_answer.strip().lower() == correct_polish.strip().lower()
pool = await get_pool()
async with pool.acquire() as conn:
# Читаем серверный streak и mistakes
current_streak = await conn.fetchval(
"SELECT correct_streak FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
# 🔧 ФИКС (24.09.2026): client_controlled_mistakes_wordquiz —
# читаем серверный current_mistakes.
mistakes = await conn.fetchval(
"SELECT current_mistakes FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
if is_correct:
current_streak += 1
else:
current_streak = 0
# 🔧 Инкрементим mistakes на сервере
await conn.execute("""
INSERT INTO word_quiz_progress (user_id, current_mistakes)
VALUES ($1, 1)
@@ -173,14 +178,29 @@ async def check_quiz_answer(request: Request):
SET current_mistakes = word_quiz_progress.current_mistakes + 1
""", telegram_id)
mistakes += 1
xp_result = None
score = 0
if is_correct:
score = max(10, 50 - (mistakes * 20))
# 🔧 Сбрасываем mistakes при правильном ответе
# 🆕 Расчёт звёзд для "Выбери слово"
# Старт 5 звёзд. Штрафы:
# -1 за каждый неверный (макс 3)
# -1 если time > 30 сек
time_penalty = 1 if (completion_time and completion_time > 30) else 0
wrong_penalty = min(mistakes, 3)
stars = max(1, 5 - wrong_penalty - time_penalty)
# Начисляем XP
from services.xp import award_xp
xp_result = await award_xp(conn, telegram_id, "choose", stars)
score = xp_result["points"]
# Сбрасываем mistakes + обновляем серию
await conn.execute("""
UPDATE word_quiz_progress SET current_mistakes = 0 WHERE user_id = $1
""", telegram_id)
await conn.execute("""
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak)
VALUES ($1, 1, $2, $3)
@@ -189,43 +209,35 @@ async def check_quiz_answer(request: Request):
total_score = word_quiz_progress.total_score + $2,
correct_streak = $3
""", telegram_id, score, current_streak)
# 🔧 ФИКС (23.09.2026): achievements_nested_pool_acquire_wordquiz —
# вызовы достижений вынесены за async with pool.acquire() (паттерн game.py).
# 🆕 Обновляем best_streak в choose_progress
await conn.execute("""
INSERT INTO choose_progress (user_id, current_streak, best_streak)
VALUES ($1, $2, $2)
ON CONFLICT (user_id) DO UPDATE
SET current_streak = $2,
best_streak = GREATEST(choose_progress.best_streak, $2),
updated_at = NOW()
""", telegram_id, current_streak)
# Собираем данные для достижений
total_guessed = await conn.fetchval(
"SELECT words_guessed FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
wordsearch_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM user_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
sentence_score = await conn.fetchval(
"SELECT COALESCE(SUM(score), 0) FROM sentence_progress WHERE user_id = $1 AND completed_at IS NOT NULL",
telegram_id
) or 0
wordquiz_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM word_quiz_progress WHERE user_id = $1",
telegram_id
) or 0
bubblewords_score = await conn.fetchval(
"SELECT COALESCE(total_score, 0) FROM bubble_words_progress WHERE user_id = $1",
telegram_id
) or 0
grand_total = wordsearch_score + sentence_score + wordquiz_score + bubblewords_score
achievements_to_check = [
("quiz_guessed", total_guessed),
("total_score", grand_total),
("total_score", xp_result["total_xp"]),
]
if current_streak >= 10:
achievements_to_check.append(("quiz_perfect_streak", current_streak))
if mistakes == 0:
achievements_to_check.append(("quiz_no_mistakes", 1))
if completion_time is not None and completion_time > 0 and int(completion_time) <= 3:
if completion_time is not None and 0 < completion_time <= 3:
achievements_to_check.append(("quiz_speed", 3))
else:
# При 3 ошибках — начисляем утешительные 10 очков
# При 3 ошибках — утешительный XP (10)
if mistakes >= 3:
await conn.execute("""
INSERT INTO word_quiz_progress (user_id, words_guessed, total_score, correct_streak, current_mistakes)
@@ -242,7 +254,7 @@ async def check_quiz_answer(request: Request):
SET correct_streak = $2
""", telegram_id, current_streak)
# 🔧 ФИКС (23.09.2026): вызовы достижений ВНЕ блока async with pool.acquire()
# Достижения — вне транзакции
if is_correct:
from routers.achievements import check_and_award_achievements
new_achievements = []
@@ -255,6 +267,20 @@ async def check_quiz_answer(request: Request):
"score": score,
"correct_streak": current_streak,
"new_achievements": new_achievements,
# 🆕 XP-поля
"stars": xp_result["stars"],
"base_points": xp_result["base_points"],
"multiplier": xp_result["multiplier"],
"points": xp_result["points"],
"featured": xp_result["featured"],
"level_up": xp_result["level_up"],
"total_xp": xp_result["total_xp"],
"level": xp_result["level"],
"rank_key": xp_result["rank_key"],
"xp_in_level": xp_result["xp_in_level"],
"xp_needed": xp_result["xp_needed"],
# 🆕 Серия для UI
"streak_best": (await _get_best_streak(telegram_id)),
}
return {
@@ -264,6 +290,16 @@ async def check_quiz_answer(request: Request):
}
async def _get_best_streak(telegram_id: int) -> int:
"""Возвращает best_streak пользователя из choose_progress."""
pool = await get_pool()
async with pool.acquire() as conn:
return await conn.fetchval(
"SELECT best_streak FROM choose_progress WHERE user_id = $1",
telegram_id
) or 0
@router.get("/progress")
async def get_quiz_progress(request: Request):
"""Статистика пользователя в квизе"""
+516
View File
@@ -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())
+64
View File
@@ -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
View File
@@ -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,
}