nonebot-plugin-mantou-affection 0.1.0__py3-none-any.whl

nonebot_plugin_mantou_affection/__init__.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from nonebot import get_plugin_config, require
+from nonebot.plugin import PluginMetadata
+
+from .config import Config
+
+__plugin_meta__ = PluginMetadata(
+    name="馒头好感度",
+    description="为群聊机器人馒头提供互动、关系阶段和跨插件共享好感状态",
+    usage=(
+        "/馒头互动｜/馒头好感｜/馒头好感榜｜/馒头好感帮助\n"
+        "SUPERUSER：/馒头好感调整 @群友 +10"
+    ),
+    type="application",
+    homepage="https://github.com/TonyLiangP2010405/nonebot-plugin-mantou-affection",
+    config=Config,
+    supported_adapters={"~onebot.v11"},
+)
+
+require("nonebot_plugin_localstore")
+
+from nonebot_plugin_localstore import get_plugin_data_dir
+
+from .commands import register_commands
+from .copywriting import AffectionTextLibrary
+from .integration import register_plugin_linkage
+from .models import AffectionResponse, AffectionSnapshot
+from .service import AffectionService
+from .storage import AffectionStore
+
+plugin_config = get_plugin_config(Config)
+data_file = Path(get_plugin_data_dir()) / "affection.json"
+store = AffectionStore(data_file)
+service = AffectionService(store, plugin_config)
+text_library = AffectionTextLibrary(
+    Path(__file__).parent / "resources" / "affection_texts.json",
+    plugin_config.mantou_affection_text_path,
+)
+matchers = register_commands(service, plugin_config)
+plugin_linkage = register_plugin_linkage(service, plugin_config)
+
+
+async def add_affection(
+    group_id: str | int,
+    user_id: str | int,
+    delta: int,
+    *,
+    nickname: str = "",
+    source: str = "external",
+) -> int:
+    """供其他插件主动增加好感度；返回实际增加值。"""
+
+    if delta <= 0:
+        raise ValueError("联动增加值必须大于 0")
+    result = await service.reward_external(
+        str(group_id), str(user_id), nickname, source, delta
+    )
+    return result.delta
+
+
+async def change_affection(
+    group_id: str | int,
+    user_id: str | int,
+    delta: int,
+    *,
+    nickname: str = "",
+    source: str = "external",
+) -> int:
+    """供其他插件按正负数改变好感度；返回实际变化值。"""
+
+    if delta == 0:
+        return 0
+    result = await service.reward_external(
+        str(group_id), str(user_id), nickname, source, delta
+    )
+    return result.delta
+
+
+async def get_affection(group_id: str | int, user_id: str | int) -> int:
+    """读取指定群友的当前好感度；不存在记录时返回 0。"""
+
+    return (await service.profile(str(group_id), str(user_id))).affection
+
+
+async def get_affection_snapshot(
+    group_id: str | int,
+    user_id: str | int,
+) -> AffectionSnapshot:
+    """读取好感度、等级、称号和语气分层，供其他插件软联动。"""
+
+    return await service.snapshot(str(group_id), str(user_id))
+
+
+async def get_affection_response(
+    scene: str,
+    group_id: str | int,
+    user_id: str | int,
+    *,
+    seed: str = "",
+) -> AffectionResponse:
+    """按场景与当前好感阶段选择文案；seed 非空时结果稳定。"""
+
+    snapshot = await service.snapshot(str(group_id), str(user_id))
+    text = text_library.pick(scene, snapshot, seed=seed)
+    return AffectionResponse(
+        affection=snapshot.affection,
+        level=snapshot.level,
+        title=snapshot.title,
+        band=snapshot.band,
+        text=text,
+    )

nonebot_plugin_mantou_affection/commands.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+from nonebot import logger, on_command
+from nonebot.adapters import Event
+from nonebot.adapters.onebot.v11 import GroupMessageEvent, Message, MessageSegment
+from nonebot.params import CommandArg
+from nonebot.permission import SUPERUSER
+from nonebot.rule import Rule
+
+from .config import Config
+from .logic import level_for, progress_text
+from .parsing import parse_adjustment
+from .service import AffectionService, normalize_nickname
+
+
+async def _group_only(event: Event) -> bool:
+    return isinstance(event, GroupMessageEvent)
+
+
+GROUP_ONLY = Rule(_group_only)
+
+
+def _nickname(event: GroupMessageEvent) -> str:
+    raw = event.sender.card or event.sender.nickname or str(event.user_id)
+    return normalize_nickname(raw, str(event.user_id))
+
+
+def _gain_text(delta: int) -> str:
+    return f"好感度 +{delta}" if delta else "好感度没有变化"
+
+
+def register_commands(service: AffectionService, config: Config) -> tuple:
+    profile_cmd = on_command(
+        "馒头好感",
+        aliases={"馒头好感度", "我的好感"},
+        rule=GROUP_ONLY,
+        priority=10,
+        block=True,
+    )
+    interact_cmd = on_command(
+        "馒头互动",
+        aliases={"摸摸馒头", "陪馒头玩"},
+        rule=GROUP_ONLY,
+        priority=10,
+        block=True,
+    )
+    ranking_cmd = on_command(
+        "馒头好感榜",
+        aliases={"好感榜", "馒头排行榜"},
+        rule=GROUP_ONLY,
+        priority=10,
+        block=True,
+    )
+    help_cmd = on_command(
+        "馒头好感帮助",
+        aliases={"馒头好感菜单"},
+        rule=GROUP_ONLY,
+        priority=10,
+        block=True,
+    )
+    adjust_cmd = on_command(
+        "馒头好感调整",
+        permission=SUPERUSER,
+        rule=GROUP_ONLY,
+        priority=10,
+        block=True,
+    )
+
+    @profile_cmd.handle()
+    async def handle_profile(event: GroupMessageEvent) -> None:
+        try:
+            profile = await service.profile(str(event.group_id), str(event.user_id))
+        except Exception:
+            logger.exception("[mantou-affection] 读取好感度失败")
+            await profile_cmd.finish("馒头翻了翻小本本，但这一页暂时打不开，请稍后再试。")
+            return
+        level = level_for(profile.affection)
+        name = _nickname(event)
+        await profile_cmd.finish(
+            f"🥟 {name} 与{config.mantou_affection_bot_name}的好感档案\n"
+            f"好感度：{profile.affection}\n"
+            f"称号：Lv.{level.number}「{level.title}」\n"
+            f"今日插件联动：{service.linked_points_today(profile)}/"
+            f"{config.mantou_affection_link_daily_limit}\n"
+            f"进度：{progress_text(profile.affection)}"
+        )
+
+    @interact_cmd.handle()
+    async def handle_interact(event: GroupMessageEvent) -> None:
+        try:
+            result = await service.interact(
+                str(event.group_id), str(event.user_id), _nickname(event)
+            )
+        except Exception:
+            logger.exception("[mantou-affection] 互动失败")
+            await interact_cmd.finish("馒头刚刚走神了，没有记下这次互动，请稍后再试。")
+            return
+        if result.reason == "daily_limit":
+            await interact_cmd.finish(
+                f"今天已经陪{config.mantou_affection_bot_name}玩得够久啦，明天再来吧。"
+            )
+        if result.reason == "cooldown":
+            await interact_cmd.finish(
+                f"让{config.mantou_affection_bot_name}喘口气吧，"
+                f"{result.wait_seconds} 秒后再来互动。"
+            )
+        await interact_cmd.finish(
+            f"{result.text}\n{_gain_text(result.delta)}，当前 {result.affection}\n"
+            f"今天还可互动 {result.remaining} 次"
+        )
+
+    @ranking_cmd.handle()
+    async def handle_ranking(event: GroupMessageEvent) -> None:
+        try:
+            entries = await service.ranking(str(event.group_id))
+        except Exception:
+            logger.exception("[mantou-affection] 读取排行榜失败")
+            await ranking_cmd.finish("馒头暂时找不到排行榜，请稍后再试。")
+            return
+        if not entries:
+            await ranking_cmd.finish("本群还没有好感记录，发送 /馒头互动 成为第一位吧。")
+        medals = {1: "🥇", 2: "🥈", 3: "🥉"}
+        lines = [f"🥟 {config.mantou_affection_bot_name}好感榜"]
+        for entry in entries:
+            profile = entry.profile
+            name = profile.nickname or f"QQ {profile.user_id}"
+            prefix = medals.get(entry.rank, f"{entry.rank}.")
+            title = level_for(profile.affection).title
+            lines.append(f"{prefix} {name}｜{profile.affection}｜{title}")
+        await ranking_cmd.finish("\n".join(lines))
+
+    @help_cmd.handle()
+    async def handle_help() -> None:
+        await help_cmd.finish(
+            "🥟 馒头好感度菜单\n"
+            "/馒头互动 —— 和馒头玩一会儿\n"
+            "/馒头好感 —— 查看自己的好感档案\n"
+            "/馒头好感榜 —— 查看本群排行榜\n"
+            "/馒头好感调整 @群友 +10 —— SUPERUSER 调整好感"
+        )
+
+    @adjust_cmd.handle()
+    async def handle_adjust(event: GroupMessageEvent, args: Message = CommandArg()) -> None:
+        try:
+            adjustment = parse_adjustment(args)
+        except ValueError as error:
+            await adjust_cmd.finish(str(error))
+            return
+        try:
+            applied, profile = await service.adjust(
+                str(event.group_id), adjustment.user_id, "", adjustment.delta
+            )
+        except Exception:
+            logger.exception("[mantou-affection] 管理员调整好感度失败")
+            await adjust_cmd.finish("调整失败，请检查数据目录权限后重试。")
+            return
+        message = MessageSegment.at(adjustment.user_id) + MessageSegment.text(
+            f" 好感度已调整 {applied:+d}，当前为 {profile.affection}。"
+        )
+        await adjust_cmd.finish(message)
+
+    return profile_cmd, interact_cmd, ranking_cmd, help_cmd, adjust_cmd

nonebot_plugin_mantou_affection/config.py

@@ -0,0 +1,29 @@
+from pydantic import BaseModel, Field
+
+
+class Config(BaseModel):
+    """馒头好感度配置，所有配置均有默认值。"""
+
+    mantou_affection_bot_name: str = "馒头"
+    mantou_affection_timezone: str = "Asia/Shanghai"
+    mantou_affection_text_path: str = ""
+    mantou_affection_interaction_limit: int = Field(default=5, ge=1, le=50)
+    mantou_affection_interaction_cooldown: int = Field(default=60, ge=0, le=3600)
+    mantou_affection_max: int = Field(default=999, ge=1, le=999999)
+    mantou_affection_ranking_size: int = Field(default=10, ge=3, le=50)
+    mantou_affection_link_enabled: bool = True
+    mantou_affection_link_daily_limit: int = Field(default=10, ge=0, le=1000)
+    mantou_affection_link_cooldown: int = Field(default=300, ge=0, le=86400)
+    mantou_affection_link_rewards: dict[str, int] = Field(
+        default_factory=lambda: {
+            "nonebot_plugin_taozi": 2,
+            "nonebot_plugin_taozi_music": 2,
+            "nonebot_plugin_xianmei": 1,
+            "nonebot_plugin_daily_attendance": 2,
+            "nonebot_plugin_crystelf": 1,
+            "nonebot_plugin_chat_learning": 1,
+            "nonebot_plugin_msg_rank_card": 1,
+            "nonebot_plugin_bili_dynamic": 1,
+            "nonebot_plugin_miao": 1,
+        }
+    )

nonebot_plugin_mantou_affection/copywriting.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import random
+from pathlib import Path
+from typing import Any
+
+from nonebot import logger
+
+from .models import AffectionSnapshot
+
+
+class AffectionTextLibrary:
+    """按插件场景和好感阶段加载文案，支持大型外部 JSON 文案库热更新。"""
+
+    def __init__(self, bundled_path: Path, custom_path: str = ""):
+        self.bundled_path = bundled_path
+        self.custom_path = Path(custom_path).expanduser() if custom_path else None
+        self._custom_mtime_ns: int | None = None
+        self._bundled = self._load_file(bundled_path)
+        self._scenes = self._bundled
+
+    def _bundled_copy(self) -> dict[str, dict[str, tuple[str, ...]]]:
+        return {scene: dict(bands) for scene, bands in self._bundled.items()}
+
+    @staticmethod
+    def _normalize(data: Any) -> dict[str, dict[str, tuple[str, ...]]]:
+        if not isinstance(data, dict):
+            raise ValueError("文案库根节点必须是 JSON 对象")
+        result: dict[str, dict[str, tuple[str, ...]]] = {}
+        for scene, bands in data.items():
+            if not isinstance(scene, str) or not isinstance(bands, dict):
+                continue
+            normalized_bands: dict[str, tuple[str, ...]] = {}
+            for band, texts in bands.items():
+                if not isinstance(band, str) or not isinstance(texts, list):
+                    continue
+                cleaned = tuple(
+                    text.strip() for text in texts if isinstance(text, str) and text.strip()
+                )
+                if cleaned:
+                    normalized_bands[band] = cleaned
+            if normalized_bands:
+                result[scene] = normalized_bands
+        return result
+
+    @classmethod
+    def _load_file(cls, path: Path) -> dict[str, dict[str, tuple[str, ...]]]:
+        with path.open("r", encoding="utf-8") as file:
+            return cls._normalize(json.load(file))
+
+    def _reload_custom_if_needed(self) -> None:
+        if self.custom_path is None:
+            return
+        try:
+            mtime_ns = self.custom_path.stat().st_mtime_ns
+        except OSError as error:
+            if self._custom_mtime_ns != -1:
+                logger.warning(f"[mantou-affection] 无法读取自定义文案库: {error}")
+                self._scenes = self._bundled_copy()
+            self._custom_mtime_ns = -1
+            return
+        if mtime_ns == self._custom_mtime_ns:
+            return
+        try:
+            custom = self._load_file(self.custom_path)
+        except (OSError, ValueError, json.JSONDecodeError) as error:
+            logger.warning(f"[mantou-affection] 自定义文案库格式错误，继续使用内置文案: {error}")
+            self._scenes = self._bundled_copy()
+            self._custom_mtime_ns = mtime_ns
+            return
+        merged = self._bundled_copy()
+        for scene, bands in custom.items():
+            merged.setdefault(scene, {}).update(bands)
+        self._scenes = merged
+        self._custom_mtime_ns = mtime_ns
+        logger.info(f"[mantou-affection] 已加载自定义文案库: {self.custom_path}")
+
+    def pick(self, scene: str, snapshot: AffectionSnapshot, *, seed: str = "") -> str | None:
+        self._reload_custom_if_needed()
+        choices = self._scenes.get(scene, {}).get(snapshot.band, ())
+        if not choices:
+            return None
+        if not seed:
+            return random.SystemRandom().choice(choices)
+        digest = hashlib.sha256(f"{scene}\0{snapshot.band}\0{seed}".encode()).digest()
+        return choices[int.from_bytes(digest[:8], "big") % len(choices)]

nonebot_plugin_mantou_affection/integration.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from nonebot import logger
+from nonebot.adapters import Event
+from nonebot.adapters.onebot.v11 import GroupMessageEvent
+from nonebot.consts import (
+    ENDSWITH_KEY,
+    FULLMATCH_KEY,
+    KEYWORD_KEY,
+    PREFIX_KEY,
+    REGEX_MATCHED,
+    STARTSWITH_KEY,
+)
+from nonebot.matcher import Matcher
+from nonebot.message import run_postprocessor
+
+from .config import Config
+from .service import AffectionService, normalize_nickname
+
+SELF_PLUGIN = "nonebot_plugin_mantou_affection"
+MEANINGFUL_STATE_KEYS = {
+    PREFIX_KEY,
+    REGEX_MATCHED,
+    FULLMATCH_KEY,
+    STARTSWITH_KEY,
+    ENDSWITH_KEY,
+    KEYWORD_KEY,
+}
+
+
+def is_meaningful_trigger(state: dict) -> bool:
+    """只奖励有明确命令/正则/完整匹配的 Matcher，忽略普通消息监听器。"""
+
+    return any(key in state for key in MEANINGFUL_STATE_KEYS)
+
+
+def matcher_source(matcher: Matcher) -> str:
+    plugin_name = matcher.plugin_name or ""
+    if plugin_name:
+        return plugin_name
+    module_name = matcher.module_name or ""
+    return module_name.split(".", 1)[0]
+
+
+def register_plugin_linkage(service: AffectionService, config: Config):
+    @run_postprocessor
+    async def reward_after_plugin(
+        matcher: Matcher,
+        event: Event,
+        exception=None,
+    ) -> None:
+        if exception is not None or not config.mantou_affection_link_enabled:
+            return
+        if not isinstance(event, GroupMessageEvent):
+            return
+        source = matcher_source(matcher)
+        if not source or source == SELF_PLUGIN:
+            return
+        reward = config.mantou_affection_link_rewards.get(source, 0)
+        if reward == 0 or not is_meaningful_trigger(matcher.state):
+            return
+        nickname = event.sender.card or event.sender.nickname or str(event.user_id)
+        try:
+            result = await service.reward_external(
+                str(event.group_id),
+                str(event.user_id),
+                normalize_nickname(nickname, str(event.user_id)),
+                source,
+                reward,
+            )
+        except Exception:
+            logger.exception(f"[mantou-affection] 处理插件联动失败: {source}")
+            return
+        if result.accepted and result.delta:
+            logger.debug(
+                f"[mantou-affection] {source} 联动奖励: "
+                f"group={event.group_id} user={event.user_id} delta={result.delta}"
+            )
+
+    return reward_after_plugin

nonebot_plugin_mantou_affection/logic.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import random
+from datetime import date
+
+from .models import AffectionSnapshot, InteractionResult, Level, LinkRewardResult, Profile
+
+LEVELS: tuple[tuple[int, str], ...] = (
+    (0, "初次见面"),
+    (10, "有点眼熟"),
+    (30, "愿意靠近"),
+    (60, "悄悄在意"),
+    (100, "暧昧升温"),
+    (160, "特别偏爱"),
+    (250, "心照不宣"),
+)
+
+INTERACTIONS: tuple[tuple[str, int], ...] = (
+    ("{bot}从蒸笼边探出头，认真听你说完了今天的事。", 1),
+    ("{bot}晃了晃脑袋，假装没看见，其实嘴角偷偷翘起来了。", 1),
+    ("你轻轻拍了拍{bot}，收获了一只热乎乎的贴贴。", 2),
+    ("{bot}把今天攒下来的桃气分给了你一点。", 2),
+    ("{bot}在你的群昵称旁边画了一颗小桃心。", 3),
+    ("{bot}正在发呆，没有听清，但还是礼貌地向你点了点头。", 0),
+)
+
+
+def level_for(affection: int) -> Level:
+    score = max(0, affection)
+    index = 0
+    for candidate, (threshold, _) in enumerate(LEVELS):
+        if score < threshold:
+            break
+        index = candidate
+    threshold, title = LEVELS[index]
+    next_threshold = LEVELS[index + 1][0] if index + 1 < len(LEVELS) else None
+    return Level(index + 1, title, threshold, next_threshold)
+
+
+def progress_text(affection: int) -> str:
+    level = level_for(affection)
+    if level.next_threshold is None:
+        return "已达到最高称号"
+    return f"距离下一称号还差 {level.next_threshold - affection} 点"
+
+
+def snapshot_for(affection: int) -> AffectionSnapshot:
+    level = level_for(affection)
+    if level.number <= 2:
+        band = "neutral"
+    elif level.number == 3:
+        band = "warm"
+    elif level.number == 4:
+        band = "close"
+    elif level.number == 5:
+        band = "flirty"
+    else:
+        band = "intimate"
+    return AffectionSnapshot(
+        affection=max(0, affection),
+        level=level.number,
+        title=level.title,
+        band=band,
+    )
+
+
+def perform_interaction(
+    profile: Profile,
+    *,
+    bot_name: str,
+    today: date,
+    now_timestamp: float,
+    daily_limit: int,
+    cooldown_seconds: int,
+    affection_max: int,
+    rng: random.Random,
+) -> InteractionResult:
+    today_text = today.isoformat()
+    if profile.interaction_date != today_text:
+        profile.interaction_date = today_text
+        profile.interaction_count = 0
+        profile.last_interaction_at = 0.0
+
+    remaining = max(0, daily_limit - profile.interaction_count)
+    if remaining == 0:
+        return InteractionResult(
+            False,
+            "daily_limit",
+            "",
+            0,
+            0,
+            0,
+            profile.affection,
+            level_for(profile.affection),
+        )
+
+    elapsed = now_timestamp - profile.last_interaction_at
+    if profile.last_interaction_at and elapsed < cooldown_seconds:
+        wait_seconds = max(1, int(cooldown_seconds - elapsed + 0.999))
+        return InteractionResult(
+            False,
+            "cooldown",
+            "",
+            0,
+            remaining,
+            wait_seconds,
+            profile.affection,
+            level_for(profile.affection),
+        )
+
+    text, reward = rng.choice(INTERACTIONS)
+    before = profile.affection
+    profile.affection = min(affection_max, profile.affection + reward)
+    profile.interaction_count += 1
+    profile.last_interaction_at = now_timestamp
+    profile.updated_at = now_timestamp
+    return InteractionResult(
+        True,
+        "ok",
+        text.format(bot=bot_name),
+        profile.affection - before,
+        max(0, daily_limit - profile.interaction_count),
+        0,
+        profile.affection,
+        level_for(profile.affection),
+    )
+
+
+def adjust_affection(profile: Profile, delta: int, affection_max: int, now_timestamp: float) -> int:
+    before = profile.affection
+    profile.affection = min(affection_max, max(0, profile.affection + delta))
+    profile.updated_at = now_timestamp
+    return profile.affection - before
+
+
+def apply_link_reward(
+    profile: Profile,
+    *,
+    source: str,
+    reward: int,
+    today: date,
+    now_timestamp: float,
+    daily_limit: int,
+    cooldown_seconds: int,
+    affection_max: int,
+) -> LinkRewardResult:
+    today_text = today.isoformat()
+    if profile.linked_date != today_text:
+        profile.linked_date = today_text
+        profile.linked_points = 0
+        profile.plugin_last_awards = {}
+
+    if daily_limit <= 0 or profile.linked_points >= daily_limit:
+        return LinkRewardResult(
+            False, "daily_limit", 0, profile.affection, profile.linked_points
+        )
+
+    plugin_last_awards = profile.plugin_last_awards or {}
+    last_award = plugin_last_awards.get(source, 0.0)
+    if last_award and now_timestamp - last_award < cooldown_seconds:
+        return LinkRewardResult(False, "cooldown", 0, profile.affection, profile.linked_points)
+
+    available = daily_limit - profile.linked_points
+    requested = max(-available, min(available, reward))
+    if requested >= 0:
+        actual_reward = min(requested, affection_max - profile.affection)
+    else:
+        actual_reward = max(requested, -profile.affection)
+    plugin_last_awards[source] = now_timestamp
+    profile.plugin_last_awards = plugin_last_awards
+    profile.linked_points += abs(actual_reward)
+    profile.affection += actual_reward
+    profile.updated_at = now_timestamp
+    return LinkRewardResult(True, "ok", actual_reward, profile.affection, profile.linked_points)