dragon-contest 1.0.0__tar.gz

dragon_contest-1.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.3
+Name: dragon-contest
+Version: 1.0.0
+Summary: Add your description here
+Requires-Dist: ruff>=0.14.0
+Requires-Dist: nonebot2>=2.0.0b10,<3.0.0
+Requires-Dist: nonebot-plugin-alconna>=0.4.3,<0.6.0
+Requires-Dist: nonebot-plugin-orm>=0.6.0,<0.7.0
+Requires-Dist: nonebot-plugin-apscheduler>=0.3.5,<0.6.0
+Requires-Python: >=3.10, <4.0
+Description-Content-Type: text/markdown
+

dragon_contest-1.0.0/pyproject.toml

@@ -0,0 +1,38 @@
+[project]
+name = "dragon-contest"
+version = "1.0.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.10, <4.0"
+dependencies = [
+    "ruff>=0.14.0",
+    "nonebot2>=2.0.0b10,<3.0.0",
+    "nonebot-plugin-alconna>=0.4.3,<0.6.0",
+    "nonebot-plugin-orm>=0.6.0,<0.7.0",
+    "nonebot-plugin-apscheduler>=0.3.5,<0.6.0",
+]
+
+
+[build-system]
+requires = ["uv_build>=0.8.17,<0.9.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "ruff>=0.14.0",
+]
+
+[tool.ruff]
+line-length = 88
+target-version = "py310"
+
+[tool.ruff.lint]
+select = ["E", "W", "F", "UP", "C", "T", "PYI", "PT", "Q"]
+ignore = ["E402", "C901"]
+fixable = ["ALL"]
+
+[tool.ruff.format]
+quote-style = "double"
+indent-style = "space"
+skip-magic-trailing-comma = false
+line-ending = "auto"

dragon_contest-1.0.0/src/dragon_contest/__init__.py

@@ -0,0 +1,58 @@
+from nonebot import require
+from nonebot.log import logger
+from nonebot.plugin import PluginMetadata, inherit_supported_adapters
+
+require("nonebot_plugin_orm")
+require("nonebot_plugin_alconna")
+require("nonebot_plugin_apscheduler")
+
+from .commands.command_registry import (
+    plugin_config,
+    dragon_contest_command,
+    join_dragon_contest_command,
+    cancel_dragon_contest_command,
+    revise_dragon_name_command,
+)
+
+
+__plugin_meta__ = PluginMetadata(
+    name="dragon-contest",
+    description="龙龙大赛插件",
+    usage="/加入龙龙大赛 <龙龙名称>",
+    type="application",
+    homepage="https://github.com/lyqgzbl/dragon-contest",
+    supported_adapters=inherit_supported_adapters("nonebot_plugin_alconna"),
+    extra={
+        "author": "lyqgzbl <admin@lyqgzbl.com",
+        "version": "1.0.0",
+    },
+)
+
+
+if not plugin_config.dc_github_token:
+    logger.opt(colors=True).warning(
+        "<yellow>缺失必要配置项 'dc_github_token'，已禁用龙龙大赛插件</yellow>"
+    )
+    openai_handler = None
+else:
+    from .openai_client import OpenAIHandler
+    openai_handler = OpenAIHandler(
+        api_key=plugin_config.dc_github_token,
+        endpoint="https://models.github.ai/inference",
+        model_name="openai/gpt-4.1-mini",
+        temperature=0.7,
+        top_p=0.9,
+    )
+
+
+from .commands import admin as _admin # noqa: F401
+from .commands import signup as _signup  # noqa: F401
+
+
+__all__ = [
+    "dragon_contest_command",
+    "join_dragon_contest_command",
+    "cancel_dragon_contest_command",
+    "revise_dragon_name_command",
+    "openai_handler",
+]

dragon_contest-1.0.0/src/dragon_contest/commands/__init__.py

@@ -0,0 +1 @@
+"""Command handlers for dragon-contest plugin."""

dragon_contest-1.0.0/src/dragon_contest/commands/admin.py

@@ -0,0 +1,241 @@
+from datetime import datetime
+
+from nonebot.log import logger
+from sqlalchemy import delete, select, func
+from sqlalchemy.exc import IntegrityError
+from nonebot_plugin_orm import async_scoped_session
+from nonebot_plugin_alconna import MsgTarget, Target
+
+from ..models import ContestStatus, DragonContest, DragonContestPlayer
+from ..utils import (
+    get_current_contest,
+    get_or_create_config,
+    register_contest_start_job,
+)
+from ..commands.command_registry import (
+    dragon_contest_command,
+    add_dragon_contest_player_command,
+    remove_dragon_contest_player_command,
+    list_dragon_contest_player_command,
+)
+
+
+@dragon_contest_command.assign("create")
+async def handle_create_contest(
+    time: str,
+    limit: int | None,
+    sess: async_scoped_session,
+    target: MsgTarget,
+):
+    try:
+        dt = datetime.strptime(time, "%Y/%m/%d %H:%M")
+    except ValueError:
+        await dragon_contest_command.finish("时间格式错误,请使用YYYY/MM/DD HH:MM格式")
+        return
+    start_ts = int(dt.timestamp())
+    config = await get_or_create_config(sess)
+    contest_limit = limit if limit is not None else config.default_limit
+    if contest_limit < 1 or contest_limit > 32:
+        await dragon_contest_command.finish("参加人数限制必须在 1~32 之间")
+    contest = DragonContest(
+        start_ts=start_ts,
+        limit=contest_limit,
+        target=Target.dump(target),
+    )
+    if contest.start_ts <= int(datetime.now().timestamp()):
+        await dragon_contest_command.finish("比赛时间必须在未来")
+    sess.add(contest)
+    try:
+        await sess.commit()
+        register_contest_start_job(contest)
+    except IntegrityError:
+        await sess.rollback()
+        await dragon_contest_command.finish("创建比赛失败,请检查参数")
+    except Exception as e:
+        await sess.rollback()
+        logger.exception(e)
+        await dragon_contest_command.finish("创建比赛失败,请查看日志")
+    await dragon_contest_command.finish(
+        "已创建龙龙大赛\n"
+        f"时间：{time}\n"
+        f"人数限制：{contest_limit}\n"
+    )
+
+
+@dragon_contest_command.assign("delete")
+async def handle_delete_contest(id: int, sess: async_scoped_session):
+    contest = await sess.get(DragonContest, id)
+    if not contest:
+        await dragon_contest_command.finish(f"未找到ID为 {id} 的龙龙大赛")
+    if contest.status == ContestStatus.RUNNING.value:
+        await dragon_contest_command.finish("无法删除正在进行中的龙龙大赛")
+    await sess.execute(
+        delete(DragonContestPlayer).where(DragonContestPlayer.contest_id == id)
+    )
+    await sess.delete(contest)
+    try:
+        await sess.commit()
+    except Exception as e:
+        await sess.rollback()
+        logger.exception(e)
+        await dragon_contest_command.finish("删除比赛失败,请查看日志")
+    await dragon_contest_command.finish(
+        f"已删除龙龙大赛（ID: {id}）及其所有参赛数据"
+    )
+
+
+@dragon_contest_command.assign("list")
+async def handle_list_contests(sess: async_scoped_session):
+    contest = (
+        await sess.scalars(
+            select(DragonContest).order_by(DragonContest.start_ts.desc())
+        )
+    ).all()
+    if not contest:
+        await dragon_contest_command.finish("当前没有正在进行的龙龙大赛")
+    lines = ["当前正在进行的龙龙大赛：\n"]
+    for c in contest:
+        dt = datetime.fromtimestamp(c.start_ts)
+        lines.append(
+            f"ID: {c.id}\n"
+            f"时间：{dt:%Y-%m-%d %H:%M}\n"
+            f"人数限制：{c.limit}\n"
+            f"━━━━━━━━━━━━━━"
+        )
+    await dragon_contest_command.finish("\n".join(lines))
+
+
+@dragon_contest_command.assign("status")
+async def handle_contest_status(sess: async_scoped_session):
+    contest = await get_current_contest(sess)
+    if not contest:
+        await dragon_contest_command.finish("当前没有正在进行的龙龙大赛")
+    count = await sess.scalar(
+        select(func.count())
+        .select_from(DragonContestPlayer)
+        .where(DragonContestPlayer.contest_id == contest.id)
+    ) or 0
+    phase = "进行中" if contest.status == ContestStatus.RUNNING.value else "报名中"
+    await dragon_contest_command.finish(
+        "龙龙大赛\n\n"
+        f"当前阶段：{phase}\n"
+        f"时间：{datetime.fromtimestamp(contest.start_ts):%Y-%m-%d %H:%M}\n"
+        f"报名人数：{count}/{contest.limit}"
+    )
+
+
+@add_dragon_contest_player_command.handle()
+async def handle_add_dragon_contest_player(
+    name: str,
+    user_id: str,
+    sess: async_scoped_session,
+):
+    contest = await get_current_contest(sess)
+    if not contest:
+        await add_dragon_contest_player_command.finish("当前没有可报名的龙龙大赛")
+    if contest.status != ContestStatus.SIGNUP.value:
+        await add_dragon_contest_player_command.finish(
+            "当前阶段的龙龙大赛已无法进行该操作"
+        )
+    count = await sess.scalar(
+        select(func.count())
+        .select_from(DragonContestPlayer)
+        .where(
+            DragonContestPlayer.contest_id == contest.id,
+            DragonContestPlayer.eliminated.is_(False),
+        )
+    ) or 0
+    if count >= contest.limit:
+        await add_dragon_contest_player_command.finish("本次龙龙大赛报名人数已满")
+    exists = await sess.scalar(
+        select(func.count())
+        .select_from(DragonContestPlayer)
+        .where(
+            DragonContestPlayer.contest_id == contest.id,
+            DragonContestPlayer.user_id == user_id,
+        )
+    )
+    if exists:
+        await add_dragon_contest_player_command.finish("该用户已在参赛名单中")
+    player = DragonContestPlayer(
+        contest_id=contest.id,
+        user_id=user_id,
+        dragon_name=name,
+    )
+    sess.add(player)
+    try:
+        await sess.commit()
+    except IntegrityError:
+        await sess.rollback()
+        await add_dragon_contest_player_command.finish("添加失败,请查看日志")
+    except Exception as e:
+        await sess.rollback()
+        logger.exception(e)
+        await add_dragon_contest_player_command.finish("添加失败,请查看日志")
+    await add_dragon_contest_player_command.finish(
+        "已成功添加参赛者\n"
+        f"用户ID：{user_id}\n"
+        f"龙龙名称：{name}"
+    )
+
+
+@remove_dragon_contest_player_command.handle()
+async def handle_remove_dragon_contest_player(user_id: str, sess: async_scoped_session):
+    contest = await get_current_contest(sess)
+    if not contest:
+        await remove_dragon_contest_player_command.finish("当前没有龙龙大赛")
+    if contest.status != ContestStatus.SIGNUP.value:
+        await remove_dragon_contest_player_command.finish(
+            "当前阶段的龙龙大赛已无法进行该操作"
+        )
+    player = await sess.scalar(
+        select(DragonContestPlayer)
+        .where(
+            DragonContestPlayer.contest_id == contest.id,
+            DragonContestPlayer.user_id == user_id,
+        )
+    )
+    if not player:
+        await remove_dragon_contest_player_command.finish("该用户不在参赛名单中")
+    await sess.delete(player)
+    try:
+        await sess.commit()
+    except Exception as e:
+        await sess.rollback()
+        logger.exception(e)
+        await remove_dragon_contest_player_command.finish(
+            "移除参赛者失败,请查看日志"
+        )
+    await remove_dragon_contest_player_command.finish(
+        "已成功移除参赛者\n"
+        f"用户ID：{user_id}\n"
+        f"龙龙名称：{player.dragon_name}"
+    )
+
+
+@list_dragon_contest_player_command.handle()
+async def handle_list_dragon_contest_player(sess: async_scoped_session):
+    contest = await get_current_contest(sess)
+    if not contest:
+        await list_dragon_contest_player_command.finish("当前没有龙龙大赛")
+    players = (
+        await sess.scalars(
+            select(DragonContestPlayer)
+            .where(DragonContestPlayer.contest_id == contest.id)
+            .order_by(DragonContestPlayer.id)
+        )
+    ).all()
+    if not players:
+        await list_dragon_contest_player_command.finish("当前没有参赛者")
+    lines = [
+        "龙龙大赛参赛名单\n",
+        f"比赛时间：{datetime.fromtimestamp(contest.start_ts):%Y-%m-%d %H:%M}\n",
+    ]
+    for idx, p in enumerate(players, start=1):
+        status = "❌ 已淘汰" if p.eliminated else "✅ 在赛"
+        lines.append(
+            f"{idx}. {p.dragon_name}\n"
+            f"   用户ID：{p.user_id}\n"
+            f"   状态：{status}\n"
+        )
+    await list_dragon_contest_player_command.finish("\n".join(lines))

dragon_contest-1.0.0/src/dragon_contest/commands/command_registry.py

@@ -0,0 +1,174 @@
+from nonebot import get_plugin_config
+from nonebot.permission import SUPERUSER
+from nonebot.rule import Rule
+from arclet.alconna import Args, Alconna, CommandMeta, Option, Subcommand
+from nonebot_plugin_alconna import on_alconna
+
+from ..config import Config
+
+
+plugin_config = get_plugin_config(Config)
+
+
+def is_enable() -> Rule:
+    def _rule() -> bool:
+        return bool(plugin_config.dc_github_token)
+    return Rule(_rule)
+
+
+dragon_contest_command = on_alconna(
+    Alconna(
+        "dragon_contest",
+        Subcommand(
+            "create|创建",
+            Args["time#比赛时间", str],
+            Option(
+                "-n|number",
+                Args["limit#参加人数限制,最大值为 32", int],
+            ),
+            help_text="创建一个新的龙龙大赛,时间格式为YYYY/MM/DD HH:MM",
+        ),
+        Subcommand(
+            "delete|删除",
+            Args["id#比赛ID", int],
+            help_text="删除指定ID的龙龙大赛",
+        ),
+        Subcommand(
+            "list|列表",
+            help_text="列出所有正在进行的龙龙大赛",
+        ),
+        Subcommand(
+            "status|状态",
+            help_text="显示龙龙大赛报名状态",
+        ),
+        meta=CommandMeta(
+            compact=True,
+            description="龙龙大赛管理系统",
+            usage="使用样例: /龙龙大赛 创建 2025/08/05 22:00",
+            example="/龙龙大赛 创建 2025/08/05 22:00",
+        ),
+    ),
+    permission=SUPERUSER,
+    aliases={"龙龙大赛"},
+    use_cmd_start=True,
+    rule=is_enable(),
+    priority=10,
+    block=True,
+)
+
+
+add_dragon_contest_player_command = on_alconna(
+    Alconna(
+        "添加龙龙大赛参赛者",
+        Args["user_id#用户ID", str],
+        Args["name#龙龙名称", str],
+        meta=CommandMeta(
+            compact=True,
+            description="为当前龙龙大赛添加参赛者",
+            usage="/添加龙龙大赛参赛者 用户ID 龙龙名称",
+            example="/添加龙龙大赛参赛者 12345678 我的龙龙",
+        ),
+    ),
+    permission=SUPERUSER,
+    use_cmd_start=True,
+    priority=10,
+    block=True,
+)
+
+
+remove_dragon_contest_player_command = on_alconna(
+    Alconna(
+        "移除龙龙大赛参赛者",
+        Args["user_id#用户ID", str],
+        meta=CommandMeta(
+            compact=True,
+            description="移除当前龙龙大赛的参赛者",
+            usage="/移除龙龙大赛参赛者 用户ID",
+            example="/移除龙龙大赛参赛者 12345678",
+        ),
+    ),
+    permission=SUPERUSER,
+    use_cmd_start=True,
+    priority=10,
+    block=True,
+)
+
+
+list_dragon_contest_player_command = on_alconna(
+    Alconna(
+        "龙龙大赛参赛名单",
+        meta=CommandMeta(
+            compact=True,
+            description="查看当前龙龙大赛的参赛名单",
+            usage="/龙龙大赛参赛名单",
+            example="/龙龙大赛参赛名单",
+        ),
+    ),
+    permission=SUPERUSER,
+    use_cmd_start=True,
+    priority=10,
+    block=True,
+)
+
+
+join_dragon_contest_command = on_alconna(
+    Alconna(
+        "加入龙龙大赛",
+        Args["name#龙龙名称", str],
+        meta=CommandMeta(
+            compact=True,
+            description="加入龙龙大赛",
+            usage="/加入龙龙大赛",
+            example="/加入龙龙大赛 玉涛性欲姬",
+        ),
+    ),
+    use_cmd_start=True,
+    priority=10,
+    block=True,
+)
+
+
+cancel_dragon_contest_command = on_alconna(
+    Alconna(
+        "取消报名",
+        meta=CommandMeta(
+            compact=True,
+            description="取消已报名的龙龙大赛",
+            usage="/取消报名",
+            example="/取消报名",
+        ),
+    ),
+    use_cmd_start=True,
+    priority=10,
+    block=True,
+)
+
+
+revise_dragon_name_command = on_alconna(
+    Alconna(
+        "修改龙龙名称",
+        Args["name#新的龙龙名称", str],
+        meta=CommandMeta(
+            compact=True,
+            description="修改已报名的龙龙大赛",
+            usage="/修改龙龙名称",
+            example="/修改龙龙名称 新的龙龙名称",
+        ),
+    ),
+    use_cmd_start=True,
+    priority=10,
+    block=True,
+)
+
+
+__all__ = [
+    "plugin_config",
+    "is_enable",
+    "dragon_contest_command",
+    "add_dragon_contest_player_command",
+    "remove_dragon_contest_player_command",
+    "list_dragon_contest_player_command",
+    "join_dragon_contest_command",
+    "cancel_dragon_contest_command",
+    "revise_dragon_name_command",
+]

dragon_contest-1.0.0/src/dragon_contest/commands/signup.py

@@ -0,0 +1,120 @@
+from datetime import datetime
+
+from nonebot.adapters import Event
+from nonebot.log import logger
+from sqlalchemy import delete, select, func
+from sqlalchemy.exc import IntegrityError
+from nonebot_plugin_orm import async_scoped_session
+
+from ..models import DragonContestPlayer
+from ..utils import get_signup_contest
+from ..commands.command_registry import (
+    cancel_dragon_contest_command,
+    join_dragon_contest_command,
+    revise_dragon_name_command,
+)
+
+
+@join_dragon_contest_command.handle()
+async def handle_join_contest(
+    name: str,
+    sess: async_scoped_session,
+    event: Event,
+):
+    contest = await get_signup_contest(sess)
+    if not contest:
+        await join_dragon_contest_command.finish("当前阶段的龙龙大赛已无法进行该操作")
+    current_count = await sess.scalar(
+        select(func.count())
+        .select_from(DragonContestPlayer)
+        .where(DragonContestPlayer.contest_id == contest.id)
+    ) or 0
+    if current_count >= contest.limit:
+        await join_dragon_contest_command.finish("本次龙龙大赛报名人数已满")
+    player = DragonContestPlayer(
+        contest_id=contest.id,
+        user_id=str(event.get_user_id()),
+        dragon_name=name,
+    )
+    sess.add(player)
+    try:
+        await sess.commit()
+    except IntegrityError:
+        await sess.rollback()
+        await join_dragon_contest_command.finish("你已经报名过本次龙龙大赛")
+    except Exception as e:
+        await sess.rollback()
+        logger.exception(e)
+        await join_dragon_contest_command.finish("加入比赛失败,请查看日志")
+    dt = datetime.fromtimestamp(contest.start_ts)
+    await join_dragon_contest_command.finish(
+        "报名成功！\n"
+        f"龙龙名称：{name}\n"
+        f"比赛时间：{dt:%Y-%m-%d %H:%M}"
+    )
+
+
+@cancel_dragon_contest_command.handle()
+async def handle_cancel_contest(
+    sess: async_scoped_session,
+    event: Event,
+):
+    contest = await get_signup_contest(sess)
+    if not contest:
+        await cancel_dragon_contest_command.finish("当前阶段的龙龙大赛已无法进行该操作")
+    stmt = (
+        delete(DragonContestPlayer)
+        .where(
+            DragonContestPlayer.contest_id == contest.id,
+            DragonContestPlayer.user_id == str(event.get_user_id()),
+        )
+        .returning(DragonContestPlayer.id)
+    )
+    result = await sess.execute(stmt)
+    deleted_ids = result.scalars().all()
+    if not deleted_ids:
+        await cancel_dragon_contest_command.finish("你尚未报名本次龙龙大赛")
+    try:
+        await sess.commit()
+    except Exception as e:
+        await sess.rollback()
+        logger.exception(e)
+        await cancel_dragon_contest_command.finish("取消报名失败,请查看日志")
+    await cancel_dragon_contest_command.finish("已取消本次龙龙大赛的报名")
+
+
+@revise_dragon_name_command.handle()
+async def handle_revise_dragon_name(
+    name: str,
+    sess: async_scoped_session,
+    event: Event,
+):
+    contest = await get_signup_contest(sess)
+    if not contest:
+        await revise_dragon_name_command.finish("当前阶段的龙龙大赛已无法进行该操作")
+    if datetime.now().timestamp() > contest.start_ts - 600:
+        await revise_dragon_name_command.finish(
+            "距离比赛开始不足10分钟,无法修改龙龙名称"
+        )
+    player = await sess.scalar(
+        select(DragonContestPlayer)
+        .where(
+            DragonContestPlayer.contest_id == contest.id,
+            DragonContestPlayer.user_id == str(event.get_user_id()),
+        )
+    )
+    if not player:
+        await revise_dragon_name_command.finish("你尚未报名本次龙龙大赛")
+    player.dragon_name = name
+    try:
+        await sess.commit()
+    except Exception as e:
+        await sess.rollback()
+        logger.exception(e)
+        await revise_dragon_name_command.finish("修改龙龙名称失败,请查看日志")
+    dt = datetime.fromtimestamp(contest.start_ts)
+    await revise_dragon_name_command.finish(
+        "龙龙名称修改成功\n"
+        f"新名称：{name}\n"
+        f"比赛时间：{dt:%Y-%m-%d %H:%M}"
+    )

dragon_contest-1.0.0/src/dragon_contest/config.py

@@ -0,0 +1,7 @@
+from pydantic import BaseModel
+
+class Config(BaseModel):
+    dc_github_token: str | None = None
+    dc_default_dragon_number: int = 32
+    dc_signup_before_seconds: int = 30 * 24 * 3600
+    dc_signup_end_before_seconds: int = 10 * 60

dragon_contest-1.0.0/src/dragon_contest/contest_runner.py

@@ -0,0 +1,108 @@
+from sqlalchemy import select
+from nonebot import get_bot
+from nonebot.log import logger
+from nonebot_plugin_orm import get_session
+from nonebot_plugin_alconna import MsgTarget, Target, UniMessage
+
+from .utils import run_single_battle
+from .models import DragonContest, DragonContestPlayer, ContestStatus
+
+async def run_contest(contest_id: int):
+    async with get_session() as sess:
+        contest = await sess.get(DragonContest, contest_id)
+        if not contest:
+            return
+        if not contest.status != ContestStatus.RUNNING.value:
+            return
+        try:
+            target: MsgTarget = Target.load(contest.target)
+        except Exception:
+            logger.opt(colors=True).error(
+                f"<red>比赛ID {contest_id} 的目标反序列化失败,比赛取消</red>"
+            )
+            contest.status = ContestStatus.FINISHED.value
+            await sess.commit()
+            return
+        try:
+            bot = get_bot(target.self_id)
+        except Exception:
+            logger.opt(colors=True).warning("<yellow>未找到可用的机器人实例,此任务将被跳过</yellow>")
+            contest.status = ContestStatus.FINISHED.value
+            await sess.commit()
+            return
+        players = (
+            await sess.scalars(
+                select(DragonContestPlayer)
+                .where(
+                    DragonContestPlayer.contest_id == contest_id,
+                    DragonContestPlayer.eliminated.is_(False),
+                )
+            )
+        ).all()
+        if len(players) < 2:
+            await UniMessage.text("比赛人数不足,比赛取消").send(target=target, bot=bot)
+            contest.status = ContestStatus.FINISHED.value
+            await sess.commit()
+            return
+        contest.status = ContestStatus.RUNNING.value
+        await sess.commit()
+        await UniMessage.text(
+            f"龙龙大赛开始,本次参赛人数为: {len(players)}"
+        ).send(target=target, bot=bot)
+        round_no = contest.current_round or 1
+        while True:
+            alive_players = (
+                await sess.scalars(
+                    select(DragonContestPlayer)
+                    .where(
+                        DragonContestPlayer.contest_id == contest_id,
+                        DragonContestPlayer.eliminated.is_(False),
+                    )
+                )
+            ).all()
+            if len(alive_players) <= 1:
+                break
+            await UniMessage.text(
+                f"第 {round_no} 轮比赛开始,当前剩余选手: {len(alive_players)}"
+            ).send(target=target, bot=bot)
+            for i in range(0, len(alive_players), 2):
+                if i + 1 >= len(alive_players):
+                    await UniMessage.text(
+                        f"选手 {alive_players[i].dragon_name} 获得轮空,直接晋级下一轮"
+                    ).send(target=target, bot=bot)
+                    continue
+                p1 = alive_players[i]
+                p2 = alive_players[i + 1]
+                winner, loser, reason = await run_single_battle(p1, p2, round_no)
+                loser.eliminated = True
+                sess.add(loser)
+                await UniMessage.text(
+                    f"对战结果：\n"
+                    f"选手1：{p1.dragon_name}\n"
+                    f"选手2：{p2.dragon_name}\n"
+                    f"获胜者：{winner.dragon_name}\n"
+                    f"失败者：{loser.dragon_name}\n"
+                    f"理由：{reason}\n"
+                    ).send(target=target, bot=bot)
+                await sess.commit()
+            round_no +=1
+            contest.current_round = round_no
+            sess.add(contest)
+            await sess.commit()
+        champion = (
+            await sess.scalars(
+                select(DragonContestPlayer)
+                .where(
+                    DragonContestPlayer.contest_id == contest_id,
+                    DragonContestPlayer.eliminated.is_(False),
+                )
+            )
+        ).first()
+        if champion:
+            await UniMessage.text(
+                "龙龙大赛圆满结束\n"
+                f"本届龙龙大赛冠军为: {champion.dragon_name}!"
+                ).send(target=target, bot=bot)
+        contest.status = ContestStatus.FINISHED.value
+        sess.add(contest)
+        await sess.commit()

dragon_contest-1.0.0/src/dragon_contest/models.py

@@ -0,0 +1,46 @@
+from enum import Enum
+from nonebot_plugin_orm import Model
+from sqlalchemy.orm import Mapped, mapped_column
+from sqlalchemy import ForeignKey, UniqueConstraint, String, JSON
+
+
+class DragonContestConfig(Model):
+    __tablename__ = "dragon_contest_config"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    default_limit: Mapped[int] = mapped_column(nullable=False)
+
+
+class ContestStatus(str, Enum):
+    SIGNUP = "signup"
+    RUNNING = "running"
+    FINISHED = "finished"
+
+
+class DragonContest(Model):
+    __tablename__ = "dragon_contest"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    start_ts: Mapped[int] = mapped_column(index=True)
+    limit: Mapped[int] = mapped_column(nullable=False)
+    target: Mapped[dict] = mapped_column(JSON, nullable=False)
+    current_round: Mapped[int] = mapped_column(default=1)
+    status: Mapped[str] = mapped_column(
+        String(16),
+        default=ContestStatus.SIGNUP.value,
+        nullable=False,
+        index=True,
+    )
+
+
+class DragonContestPlayer(Model):
+    __tablename__ = "dragon_contest_player"
+    id: Mapped[int] = mapped_column(primary_key=True)
+    contest_id: Mapped[int] = mapped_column(
+        ForeignKey("dragon_contest.id"),
+        index=True,
+    )
+    user_id: Mapped[str] = mapped_column(index=True)
+    dragon_name: Mapped[str] = mapped_column(String(32))
+    eliminated: Mapped[bool] = mapped_column(default=False)
+    __table_args__ = (
+        UniqueConstraint("contest_id", "user_id"),
+    )

dragon_contest-1.0.0/src/dragon_contest/openai_client.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping, Sequence
+from typing import Any, cast
+from azure.ai.inference.aio import ChatCompletionsClient
+from azure.ai.inference.models import ChatRequestMessage
+from azure.core.credentials import AzureKeyCredential
+
+
+class OpenAIHandler:
+    def __init__(
+        self,
+        api_key: str,
+        endpoint: str,
+        model_name: str,
+        temperature: float,
+        top_p: float,
+    ):
+        self.client = ChatCompletionsClient(
+            endpoint=endpoint,
+            credential=AzureKeyCredential(api_key)
+        )
+        self.api_key = api_key
+        self.endpoint = endpoint
+        self.model_name = model_name
+        self.temperature = temperature
+        self.top_p = top_p
+
+    async def get_response(
+        self,
+        messages: Sequence[ChatRequestMessage | Mapping[str, Any]],
+    ) -> str:
+        request_messages = cast(list[ChatRequestMessage], list(messages))
+        response = await self.client.complete(
+            messages=request_messages,
+            model=self.model_name,
+            temperature=self.temperature,
+            top_p=self.top_p,
+        )
+        choices = response.choices
+        if not choices:
+            raise ValueError("GitHub Models returned no choices")
+        content = choices[0].message.content
+        if not content:
+            raise ValueError("GitHub Models returned empty content")
+        return content

dragon_contest-1.0.0/src/dragon_contest/utils.py

@@ -0,0 +1,184 @@
+import re
+import json
+import random
+from datetime import datetime
+
+from sqlalchemy import select
+from nonebot import get_plugin_config, get_driver
+from nonebot.log import logger
+from nonebot_plugin_apscheduler import scheduler
+from nonebot_plugin_orm import async_scoped_session, get_session
+
+from .config import Config
+from .models import (
+    ContestStatus,
+    DragonContest,
+    DragonContestConfig,
+    DragonContestPlayer,
+)
+
+
+driver = get_driver()
+plugin_config = get_plugin_config(Config)
+
+
+async def get_signup_contest(sess: async_scoped_session) -> DragonContest | None:
+    now_ts = int(datetime.now().timestamp())
+    signup_end = now_ts + plugin_config.dc_signup_before_seconds
+    return await sess.scalar(
+        select(DragonContest)
+        .where(
+            DragonContest.start_ts >= now_ts,
+            DragonContest.start_ts <= signup_end,
+            DragonContest.status == ContestStatus.SIGNUP.value,
+        )
+        .order_by(DragonContest.start_ts.asc())
+    )
+
+
+async def get_active_contest(sess: async_scoped_session) -> DragonContest | None:
+    now_ts = int(datetime.now().timestamp())
+    return await sess.scalar(
+        select(DragonContest)
+        .where(
+            DragonContest.start_ts <= now_ts,
+            DragonContest.status == ContestStatus.RUNNING.value,
+        )
+        .order_by(DragonContest.start_ts.desc())
+    )
+
+
+async def get_current_contest(sess: async_scoped_session) -> DragonContest | None:
+    contest = await get_active_contest(sess)
+    if contest:
+        return contest
+    return await get_signup_contest(sess)
+
+
+async def get_or_create_config(sess: async_scoped_session) -> DragonContestConfig:
+    config = await sess.get(DragonContestConfig, 1)
+    if not config:
+        config = DragonContestConfig(
+            id=1,
+            default_limit=plugin_config.dc_default_dragon_number,
+        )
+        sess.add(config)
+        await sess.commit()
+    return config
+
+
+def register_contest_start_job(contest: DragonContest):
+    scheduler.add_job(
+        on_contest_start,
+        trigger="date",
+        run_date=datetime.fromtimestamp(contest.start_ts),
+        args=[contest.id],
+        id=f"dragon_contest_start_{contest.id}",
+        replace_existing=True,
+    )
+
+
+async def on_contest_start(contest_id: int):
+    async with get_session() as sess:
+        contest = await sess.get(DragonContest, contest_id)
+        if not contest:
+            return
+        if contest.status == ContestStatus.RUNNING.value:
+            return
+        contest.status = ContestStatus.RUNNING.value
+        sess.add(contest)
+        try:
+            await sess.commit()
+        except Exception as e:
+            await sess.rollback()
+            logger.exception(e)
+
+
+async def run_single_battle(
+    p1: DragonContestPlayer,
+    p2: DragonContestPlayer,
+    round: int,
+):
+    from . import openai_handler
+    if openai_handler is None:
+        winner, loser = random.sample([p1, p2], 2)
+        return (
+            winner,
+            loser,
+            "未配置 OpenAI,随机决出胜负"
+        )
+    system_prompt = (
+        "你是龙龙大赛的裁判。"
+        "只输出一段 JSON，不要输出任何额外文本。"
+        "JSON 格式如下："
+        '{"winner":"p1|p2","reason":"..."}'
+    )
+    user_prompt = (
+        f"第 {round} 回合对战：\n"
+        f"选手1：{p1.dragon_name}\n"
+        f"选手2：{p2.dragon_name}\n\n"
+        "请从战斗力、智慧、速度、防御、技能等方面综合比较，"
+        "给出更强者，并用一句话说明原因。"
+    )
+    messages = [
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": user_prompt},
+    ]
+    try:
+        content = await openai_handler.get_response(messages)
+    except Exception:
+        logger.exception("调用 OpenAI 接口失败,随机决出胜负")
+        winner, loser = random.sample([p1, p2], 2)
+        return (
+            winner,
+            loser,
+            "调用 OpenAI 接口失败,随机决出胜负"
+        )
+    match = re.search(r"\{.*\}", content, flags=re.S)
+    if not match:
+        winner, loser = random.sample([p1, p2], 2)
+        return (
+            winner,
+            loser,
+            f"AI 输出格式错误,随机决出胜负。原始输出：{content}"
+        )
+    try:
+        data = json.loads(match.group(0))
+    except Exception:
+        winner, loser = random.sample([p1, p2], 2)
+        return (
+            winner,
+            loser,
+            f"输出解析失败,随机决出胜负。原始输出：{content}"
+        )
+    winner_flag = str(data.get("winner", "")).strip().lower()
+    reason = str(data.get("reason", "")).strip()
+    if not reason:
+        reason = "AI 未给出明确理由"
+    if winner_flag == "p1":
+        return p1, p2, reason
+    elif winner_flag == "p2":
+        return p2, p1, reason
+    winner, loser = random.sample([p1, p2], 2)
+    return (
+        winner,
+        loser,
+        f"AI 输出胜者不明确,随机决出胜负。原始输出：{content}"
+    )
+
+
+@driver.on_startup
+async def restore_contest_start_jobs():
+    async with get_session() as sess:
+        now_ts = int(datetime.now().timestamp())
+        contests = await sess.scalars(
+            select(DragonContest)
+            .where(
+                DragonContest.start_ts > now_ts,
+                DragonContest.status == ContestStatus.SIGNUP.value,
+            )
+        )
+        for contest in contests:
+            if contest.start_ts <= now_ts:
+                continue
+            register_contest_start_job(contest)