成语接龙5.0、群空调功能

konabot/common/web_render/__init__.py

@@ -1,13 +1,45 @@
 import asyncio
 import queue
+from typing import Any, Callable, Coroutine
 from loguru import logger
-from playwright.async_api import async_playwright, Browser
+from playwright.async_api import Page, Playwright, async_playwright, Browser, Page, BrowserContext
+
+
+PageFunction = Callable[[Page], Coroutine[Any, Any, Any]]
+
 
 class WebRenderer:
     browser_pool: queue.Queue["WebRendererInstance"] = queue.Queue()
+    context_pool: dict[int, BrowserContext] = {} # 长期挂载的浏览器上下文池
+    page_pool: dict[str, Page] = {} # 长期挂载的页面池
 
     @classmethod
-    async def render(cls, url: str, target: str, params: dict = {}, other_function: callable = None, timeout: int = 30) -> bytes:
+    async def get_browser_instance(cls) -> "WebRendererInstance":
+        if cls.browser_pool.empty():
+            instance = await WebRendererInstance.create()
+            cls.browser_pool.put(instance)
+        instance = cls.browser_pool.get()
+        cls.browser_pool.put(instance)
+        return instance
+    
+    @classmethod
+    async def get_browser_context(cls) -> BrowserContext:
+        instance = await cls.get_browser_instance()
+        if id(instance) not in cls.context_pool:
+            context = await instance.browser.new_context()
+            cls.context_pool[id(instance)] = context
+            logger.debug(f"Created new persistent browser context for WebRendererInstance {id(instance)}")
+        return cls.context_pool[id(instance)]
+
+    @classmethod
+    async def render(
+        cls,
+        url: str,
+        target: str,
+        params: dict = {},
+        other_function: PageFunction | None = None,
+        timeout: int = 30,
+    ) -> bytes:
         '''
         访问指定URL并返回截图
 
@@ -19,30 +51,85 @@ class WebRenderer:
         :return: 截图的字节数据
 
         '''
-        logger.debug(f"Requesting render for {url} targeting {target} with timeout {timeout}")
-        if cls.browser_pool.empty():
-            instance = await WebRendererInstance.create()
-            cls.browser_pool.put(instance)
-        instance = cls.browser_pool.get()
-        cls.browser_pool.put(instance)
+        instance = await cls.get_browser_instance()
         logger.debug(f"Using WebRendererInstance {id(instance)} to render {url} targeting {target}")
         return await instance.render(url, target, params=params, other_function=other_function, timeout=timeout)
 
+
+    @classmethod
+    async def render_persistent_page(cls, page_id: str, url: str, target: str, params: dict = {}, other_function: callable = None, timeout: int = 30) -> bytes:
+        '''
+        使用长期挂载的页面访问指定URL并返回截图
+
+        :param page_id: 页面唯一标识符
+        :param url: 目标URL
+        :param target: 渲染目标，如 ".box"、"#main" 等CSS选择器
+        :param timeout: 页面加载超时时间，单位秒
+        :param params: URL键值对参数
+        :param other_function: 其他自定义操作函数，接受page参数
+        :return: 截图的字节数据
+
+        '''
+        logger.debug(f"Requesting persistent render for page_id {page_id} at {url} targeting {target} with timeout {timeout}")
+        instance = await cls.get_browser_instance()
+        if page_id not in cls.page_pool:
+            context = await cls.get_browser_context()
+            page = await context.new_page()
+            cls.page_pool[page_id] = page
+            logger.debug(f"Created new persistent page for page_id {page_id} using WebRendererInstance {id(instance)}")
+        page = cls.page_pool[page_id]
+        return await instance.render_with_page(page, url, target, params=params, other_function=other_function, timeout=timeout)
+    
+    @classmethod
+    async def close_persistent_page(cls, page_id: str) -> None:
+        '''
+        关闭并移除长期挂载的页面
+
+        :param page_id: 页面唯一标识符
+        '''
+        if page_id in cls.page_pool:
+            page = cls.page_pool[page_id]
+            await page.close()
+            del cls.page_pool[page_id]
+            logger.debug(f"Closed and removed persistent page for page_id {page_id}")
+
+
+
 class WebRendererInstance:
     def __init__(self):
-        self.playwright = None
-        self.browser: Browser = None
-        self.lock: asyncio.Lock = None
+        self._playwright: Playwright | None = None
+        self._browser: Browser | None = None
+        self.lock = asyncio.Lock()
+
+    @property
+    def playwright(self) -> Playwright:
+        assert self._playwright is not None
+        return self._playwright
+
+    @property
+    def browser(self) -> Browser:
+        assert self._browser is not None
+        return self._browser
+
+    async def init(self):
+        self._playwright = await async_playwright().start()
+        self._browser = await self.playwright.chromium.launch(headless=True)
 
     @classmethod
     async def create(cls) -> "WebRendererInstance":
         instance = cls()
-        instance.playwright = await async_playwright().start()
-        instance.browser = await instance.playwright.chromium.launch(headless=True)
-        instance.lock = asyncio.Lock()
+        await instance.init()
         return instance
 
-    async def render(self, url: str, target: str, index: int = 0, params: dict = {}, other_function: callable = None, timeout: int = 30) -> bytes:
+    async def render(
+        self,
+        url: str,
+        target: str,
+        index: int = 0,
+        params: dict = {},
+        other_function: PageFunction | None = None,
+        timeout: int = 30
+    ) -> bytes:
         '''
         访问指定URL并返回截图
 
@@ -58,29 +145,39 @@ class WebRendererInstance:
         async with self.lock:
             context = await self.browser.new_context()
             page = await context.new_page()
-            logger.debug(f"Navigating to {url} with timeout {timeout}")
-            try:
-                url_with_params = url + ("?" + "&".join(f"{k}={v}" for k, v in params.items()) if params else "")
-                await page.goto(url_with_params, timeout=timeout * 1000, wait_until="load")
-                logger.debug(f"Page loaded successfully")
-                # 等待目标元素出现
-                await page.wait_for_selector(target, timeout=timeout * 1000)
-                logger.debug(f"Target element '{target}' found, taking screenshot")
-                if other_function:
-                    await other_function(page)
-                elements = await page.query_selector_all(target)
-                if not elements:
-                    raise Exception(f"Target element '{target}' not found on the page.")
-                if index >= len(elements):
-                    raise Exception(f"Index {index} out of range for elements matching '{target}'.")
-                element = elements[index]
-                screenshot = await element.screenshot()
-                logger.debug(f"Screenshot taken successfully")
-                return screenshot
-            finally:
-                await page.close()
-                await context.close()
+            screenshot = await self.inner_render(page, url, target, index, params, other_function, timeout)
+            await page.close()
+            await context.close()
+            return screenshot
+
+    async def render_with_page(self, page: Page, url: str, target: str, index: int = 0, params: dict = {}, other_function: callable = None, timeout: int = 30) -> bytes:
+        async with self.lock:
+            screenshot = await self.inner_render(page, url, target, index, params, other_function, timeout)
+            return screenshot
+
+    async def inner_render(self, page: Page, url: str, target: str, index: int = 0, params: dict = {}, other_function: callable = None, timeout: int = 30) -> bytes:
+        logger.debug(f"Navigating to {url} with timeout {timeout}")
+        url_with_params = url + ("?" + "&".join(f"{k}={v}" for k, v in params.items()) if params else "")
+        await page.goto(url_with_params, timeout=timeout * 1000, wait_until="load")
+        logger.debug("Page loaded successfully")
+        # 等待目标元素出现
+        await page.wait_for_selector(target, timeout=timeout * 1000)
+        logger.debug(f"Target element '{target}' found, taking screenshot")
+        if other_function:
+            await other_function(page)
+        elements = await page.query_selector_all(target)
+        if not elements:
+            logger.error(f"Target element '{target}' not found on the page.")
+            return None
+        if index >= len(elements):
+            logger.error(f"Index {index} out of range for elements matching '{target}'")
+            return None
+        element = elements[index]
+        screenshot = await element.screenshot()
+        logger.debug(f"Screenshot taken successfully")
+        return screenshot
 
     async def close(self):
         await self.browser.close()
         await self.playwright.stop()
+

konabot/plugins/air_conditioner/__init__.py

@@ -0,0 +1,120 @@
+from io import BytesIO
+from typing import Optional, Union
+from nonebot.adapters import Event as BaseEvent
+from nonebot.adapters.console.event import MessageEvent as ConsoleMessageEvent
+from nonebot.adapters.discord.event import MessageEvent as DiscordMessageEvent
+from nonebot_plugin_alconna import Alconna, AlconnaMatcher, Args, UniMessage, on_alconna
+from PIL import Image
+from konabot.common.longtask import DepLongTaskTarget
+from konabot.common.path import ASSETS_PATH
+from konabot.plugins.air_conditioner.ac import AirConditioner, generate_ac_image
+
+def get_ac(id: str) -> AirConditioner:
+    ac = AirConditioner.air_conditioners.get(id)
+    if ac is None:
+        ac = AirConditioner(id)
+    return ac
+
+async def send_ac_image(event: type[AlconnaMatcher], ac: AirConditioner):
+    if(ac.burnt == True):
+        # 打开坏掉的空调图片
+        with open(ASSETS_PATH / "img" / "ac" / "broken_ac.png", "rb") as f:
+            # 将其转为 GIF 格式发送
+            output = BytesIO()
+            Image.open(f).save(output, format="GIF")
+            output.seek(0)
+            await event.send(await UniMessage().image(raw=output).export())
+        return
+    if(ac.frozen == True):
+        # 打开坏掉的空调图片
+        with open(ASSETS_PATH / "img" / "ac" / "frozen_ac.png", "rb") as f:
+            # 将其转为 GIF 格式发送
+            output = BytesIO()
+            Image.open(f).save(output, format="GIF")
+            output.seek(0)
+            await event.send(await UniMessage().image(raw=output).export())
+        return
+    ac_image = await generate_ac_image(ac)
+    await event.send(await UniMessage().image(raw=ac_image).export())
+
+evt = on_alconna(Alconna(
+    "群空调"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "开空调"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    ac.on = True
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "关空调"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    ac.on = False
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "空调升温"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    if not ac.on or ac.burnt == True or ac.frozen == True:
+        await send_ac_image(evt, ac)
+        return
+    ac.temperature += 1
+    if ac.temperature > 40:
+        # 打开爆炸图片
+        with open(ASSETS_PATH / "img" / "other" / "boom.jpg", "rb") as f:
+            output = BytesIO()
+            Image.open(f).save(output, format="GIF")
+            await evt.send(await UniMessage().image(raw=output).export())
+        ac.burnt = True
+        await evt.send("太热啦，空调炸了！")
+        return
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "空调降温"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    if not ac.on or ac.burnt == True or ac.frozen == True:
+        await send_ac_image(evt, ac)
+        return
+    ac.temperature -= 1
+    if ac.temperature < 0:
+        ac.frozen = True
+    await send_ac_image(evt, ac)
+
+evt = on_alconna(Alconna(
+    "换空调"
+), use_cmd_start=True, use_cmd_sep=False, skip_for_unmatch=True)
+
+@evt.handle()
+async def _(event: BaseEvent, target: DepLongTaskTarget):
+    id = target.channel_id
+    ac = get_ac(id)
+    ac.change_ac()
+    await send_ac_image(evt, ac)

konabot/plugins/air_conditioner/ac.py

@@ -0,0 +1,225 @@
+from io import BytesIO
+
+import cv2
+import numpy as np
+from PIL import Image, ImageDraw, ImageFont
+
+from konabot.common.path import ASSETS_PATH, FONTS_PATH
+
+class AirConditioner:
+    air_conditioners: dict[str, "AirConditioner"] = {}
+
+    def __init__(self, id: str) -> None:
+        self.id = id
+        self.on = False
+        self.temperature = 24  # 默认温度
+        self.burnt = False
+        self.frozen = False
+        AirConditioner.air_conditioners[id] = self
+
+    def change_ac(self):
+        self.burnt = False
+        self.frozen = False
+        self.on = False
+        self.temperature = 24  # 重置为默认温度
+
+def text_to_transparent_image(text, font_size=40, padding=0, text_color=(0, 0, 0)):
+    """
+    将文本转换为带透明背景的图像，图像大小刚好包含文本
+    """
+    # 创建临时图像来计算文本尺寸
+    temp_image = Image.new('RGB', (1, 1), (255, 255, 255))
+    temp_draw = ImageDraw.Draw(temp_image)
+    
+    font = ImageFont.truetype(FONTS_PATH / "montserrat.otf", font_size)
+    
+    # 获取文本边界框
+    bbox = temp_draw.textbbox((0, 0), text, font=font)
+    text_width = bbox[2] - bbox[0]
+    text_height = bbox[3] - bbox[1]
+    
+    # 计算图像大小（文本大小 + 内边距）
+    image_width = int(text_width + 2 * padding)
+    image_height = int(text_height + 2 * padding)
+    
+    # 创建RGBA模式的空白图像（带透明通道）
+    image = Image.new('RGBA', (image_width, image_height), (0, 0, 0, 0))
+    draw = ImageDraw.Draw(image)
+    
+    # 绘制文本（考虑内边距）
+    x = padding - bbox[0]  # 调整起始位置
+    y = padding - bbox[1]
+    
+    # 设置文本颜色（带透明度）
+    if len(text_color) == 3:
+        text_color = text_color + (255,)  # 添加完全不透明的alpha值
+    
+    draw.text((x, y), text, fill=text_color, font=font)
+    
+    # 转换为OpenCV格式（BGRA）
+    image_cv = cv2.cvtColor(np.array(image), cv2.COLOR_RGBA2BGRA)
+    return image_cv
+
+def perspective_transform(image, target, corners):
+    """
+    对图像进行透视变换（保持透明通道）
+    target: 画布
+    corners: 四个角点的坐标，顺序为 [左上, 右上, 右下, 左下]
+    """
+    height, width = image.shape[:2]
+    
+    # 源点（原始图像的四个角）
+    src_points = np.array([
+        [0, 0],           # 左上
+        [width-1, 0],     # 右上
+        [width-1, height-1], # 右下
+        [0, height-1]     # 左下
+    ], dtype=np.float32)
+    
+    # 目标点（变换后的四个角）
+    dst_points = np.array(corners, dtype=np.float32)
+    
+    # 计算透视变换矩阵
+    matrix = cv2.getPerspectiveTransform(src_points, dst_points)
+    
+    # 获取画布大小
+    target_height, target_width = target.shape[:2]
+
+    # 应用透视变换（保持所有通道，包括alpha）
+    transformed = cv2.warpPerspective(image, matrix, (target_width, target_height), flags=cv2.INTER_LINEAR)
+
+    return transformed, matrix
+
+def blend_with_transparency(background, foreground, position):
+    """
+    将带透明通道的前景图像合成到背景图像上
+    position: 前景图像在背景图像上的位置 (x, y)
+    """
+    bg = background.copy()
+    
+    # 如果背景没有alpha通道，添加一个
+    if bg.shape[2] == 3:
+        bg = cv2.cvtColor(bg, cv2.COLOR_BGR2BGRA)
+        bg[:, :, 3] = 255  # 完全不透明
+    
+    x, y = position
+    fg_height, fg_width = foreground.shape[:2]
+    bg_height, bg_width = bg.shape[:2]
+    
+    # 确保位置在图像范围内
+    x = max(0, min(x, bg_width - fg_width))
+    y = max(0, min(y, bg_height - fg_height))
+    
+    # 提取前景的alpha通道并归一化
+    alpha_foreground = foreground[:, :, 3] / 255.0
+    
+    # 对于每个颜色通道进行合成
+    for c in range(3):
+        bg_region = bg[y:y+fg_height, x:x+fg_width, c]
+        fg_region = foreground[:, :, c]
+        
+        # alpha混合公式
+        bg[y:y+fg_height, x:x+fg_width, c] = (
+            alpha_foreground * fg_region + 
+            (1 - alpha_foreground) * bg_region
+        )
+    
+    # 更新背景的alpha通道（如果需要）
+    bg_alpha_region = bg[y:y+fg_height, x:x+fg_width, 3]
+    bg[y:y+fg_height, x:x+fg_width, 3] = np.maximum(bg_alpha_region, foreground[:, :, 3])
+    
+    return bg
+
+def precise_blend_with_perspective(background, foreground, corners):
+    """
+    精确合成：根据四个角点将前景图像透视合成到背景上
+    """
+    # 创建与背景相同大小的空白图像
+    bg_height, bg_width = background.shape[:2]
+    
+    # 如果背景没有alpha通道，转换为BGRA
+    if background.shape[2] == 3:
+        background_bgra = cv2.cvtColor(background, cv2.COLOR_BGR2BGRA)
+    else:
+        background_bgra = background.copy()
+    
+    # 创建与背景相同大小的前景图层
+    foreground_layer = np.zeros((bg_height, bg_width, 4), dtype=np.uint8)
+    
+    # 计算前景图像在背景中的边界框
+    min_x = int(min(corners[:, 0]))
+    max_x = int(max(corners[:, 0]))
+    min_y = int(min(corners[:, 1]))
+    max_y = int(max(corners[:, 1]))
+    
+    # 将变换后的前景图像放置到对应位置
+    fg_height, fg_width = foreground.shape[:2]
+    if min_y + fg_height <= bg_height and min_x + fg_width <= bg_width:
+        foreground_layer[min_y:min_y+fg_height, min_x:min_x+fg_width] = foreground
+    
+    # 创建掩码（只在前景有内容的地方合成）
+    mask = (foreground_layer[:, :, 3] > 0)
+    
+    # 合成图像
+    result = background_bgra.copy()
+    for c in range(3):
+        result[:, :, c][mask] = foreground_layer[:, :, c][mask]
+    result[:, :, 3][mask] = foreground_layer[:, :, 3][mask]
+    
+    return result
+
+def wiggle_transform(image) -> list[np.ndarray]:
+    '''
+    返回一组图像振动的帧组，模拟空调运作时的抖动效果
+    '''
+    frames = []
+    height, width = image.shape[:2]
+    shifts = [(-2, 0), (2, 0), (0, -2), (0, 2), (0, 0)]
+    for dx, dy in shifts:
+        M = np.float32([[1, 0, dx], [0, 1, dy]])
+        shifted = cv2.warpAffine(image, M, (width, height))
+        frames.append(shifted)
+    return frames
+
+async def generate_ac_image(ac: AirConditioner) -> BytesIO:
+    # 找到空调底图
+    ac_image = cv2.imread(str(ASSETS_PATH / "img" / "ac" / "ac.png"), cv2.IMREAD_UNCHANGED)
+
+    if not ac.on:
+        # 空调关闭状态，直接返回底图
+        pil_final = Image.fromarray(ac_image)
+        output = BytesIO()
+        pil_final.save(output, format="GIF")
+        return output
+
+    # 根据生成温度文本图像
+    text = f"{ac.temperature}°C"
+    text_image = text_to_transparent_image(
+        text, 
+        font_size=60, 
+        text_color=(0, 0, 0)  # 黑色文字
+    )
+
+    # 获取长宽比
+    height, width = text_image.shape[:2]
+    aspect_ratio = width / height
+
+    # 定义3D变换的四个角点（透视效果）
+    # 顺序: [左上, 右上, 右下, 左下]
+    corners = np.array([
+        [123, 45],    # 左上
+        [284, 101],   # 右上
+        [290, 140],   # 右下
+        [119, 100]    # 左下
+    ], dtype=np.float32)
+    
+    # 对文本图像进行3D变换（保持透明通道）
+    transformed_text, transform_matrix = perspective_transform(text_image, ac_image, corners)
+
+    final_image_simple = blend_with_transparency(ac_image, transformed_text, (0, 0))
+
+    frames = wiggle_transform(final_image_simple)
+    pil_frames = [Image.fromarray(frame) for frame in frames]
+    output = BytesIO()
+    pil_frames[0].save(output, format="GIF", save_all=True, append_images=pil_frames[1:], loop=0, duration=50)
+    return output

konabot/plugins/idiomgame/__init__.py

@@ -69,10 +69,11 @@ class TryStopState(Enum):
 class TryVerifyState(Enum):
     VERIFIED = 0
     VERIFIED_AND_REAL = 1
-    NOT_IDIOM = 2
-    WRONG_FIRST_CHAR = 3
-    BUT_NO_NEXT = 4
-    GAME_END = 5
+    ALREADY_USED = 2
+    NOT_IDIOM = 3
+    WRONG_FIRST_CHAR = 4
+    BUT_NO_NEXT = 5
+    GAME_END = 6
 
 
 class IdiomGame:
@@ -96,12 +97,14 @@ class IdiomGame:
         self.all_buff_score = 0
         self.lock = asynkio.Lock()
         self.remain_rounds = 0  # 剩余回合数
+        self.already_idioms: dict[str, int] = {} # 已经使用过的成语和使用过的次数
+        self.idiom_history: list[list[str]] = [] # 成语使用历史记录，多个数组以存储不同成语链
         IdiomGame.INSTANCE_LIST[group_id] = self
 
     def be_able_to_play(self) -> bool:
         if self.last_play_date != datetime.date.today():
             self.last_play_date = datetime.date.today()
-            self.remain_playing_times = 1
+            self.remain_playing_times = 3
         if self.remain_playing_times > 0:
             self.remain_playing_times -= 1
             return True
@@ -115,6 +118,8 @@ class IdiomGame:
         self.last_char = self.last_idiom[-1]
         if not self.is_nextable(self.last_char):
             self.choose_start_idiom()
+        else:
+            self.add_history_idiom(self.last_idiom, new_chain=True)
         return self.last_idiom
 
     @classmethod
@@ -148,6 +153,9 @@ class IdiomGame:
     def clear_score_board(self):
         self.score_board = {}
         self.last_char = ""
+        self.all_buff_score = 0
+        self.already_idioms = {}
+        self.idiom_history = []
 
     def get_score_board(self) -> dict:
         return self.score_board
@@ -169,6 +177,8 @@ class IdiomGame:
         self.last_char = self.last_idiom[-1]
         if not self.is_nextable(self.last_char):
             self._skip_idiom_async()
+        else:
+            self.add_history_idiom(self.last_idiom, new_chain=True)
         return self.last_idiom
 
     async def try_verify_idiom(self, idiom: str, user_id: str) -> TryVerifyState:
@@ -184,6 +194,29 @@ class IdiomGame:
         判断是否有成语可以接
         """
         return last_char in IdiomGame.AVALIABLE_IDIOM_FIRST_CHAR
+    
+    def add_already_idiom(self, idiom: str):
+        if idiom in self.already_idioms:
+            self.already_idioms[idiom] += 1
+        else:
+            self.already_idioms[idiom] = 1
+
+    def get_already_used_num(self, idiom: str) -> int:
+        if idiom in self.already_idioms:
+            return self.already_idioms[idiom]
+        return 0
+        
+    def add_history_idiom(self, idiom: str, new_chain: bool = False):
+        if new_chain or len(self.idiom_history) == 0:
+            self.idiom_history.append([idiom])
+        else:
+            self.idiom_history[-1].append(idiom)
+
+    def display_history(self) -> list[str]:
+        result = []
+        for chain in self.idiom_history:
+            result.append(" -> ".join(chain))
+        return result
 
     def _verify_idiom(self, idiom: str, user_id: str) -> list[TryVerifyState]:
         state = []
@@ -196,13 +229,18 @@ class IdiomGame:
             state.append(TryVerifyState.NOT_IDIOM)
             return state
         # 成语合法，更新状态
+        self.add_history_idiom(idiom)
+        score_k = 0.5 ** self.get_already_used_num(idiom) # 每被使用过一次，得分减半
+        if(score_k != 1):
+            state.append(TryVerifyState.ALREADY_USED)
+        self.add_already_idiom(idiom)
         state.append(TryVerifyState.VERIFIED)
         self.last_idiom = idiom
         self.last_char = idiom[-1]
-        self.add_score(user_id, 1)
+        self.add_score(user_id, 1 * score_k) # 先加 1 分
         if idiom in IdiomGame.ALL_IDIOMS:
             state.append(TryVerifyState.VERIFIED_AND_REAL)
-            self.add_score(user_id, 4) # 再加 4 分
+            self.add_score(user_id, 4 * score_k) # 再加 4 分
         self.remain_rounds -= 1
         if self.remain_rounds <= 0:
             self.now_playing = False
@@ -217,7 +255,7 @@ class IdiomGame:
         if user_id not in self.score_board:
             return 0
         # 避免浮点数精度问题导致过长
-        handled_score = round(self.score_board[user_id]["score"], 1)
+        handled_score = round(self.score_board[user_id]["score"] + self.all_buff_score, 1)
         return handled_score
 
     def add_score(self, user_id: str, score: int):
@@ -401,7 +439,7 @@ async def end_game(event: BaseEvent, group_id: str):
     result_text = UniMessage().text("游戏结束！\n最终得分榜：\n")
     score_board = instance.get_score_board()
     if len(score_board) == 0:
-        result_text += "无人得分！"
+        result_text += "无人得分！\n"
     else:
         # 按分数排序，名字用 at 的方式
         sorted_score = sorted(
@@ -413,6 +451,13 @@ async def end_game(event: BaseEvent, group_id: str):
                 + UniMessage().at(user_id)
                 + f": {round(info['score'] + instance.get_all_buff_score(), 1)} 分\n"
             )
+    if len(instance.idiom_history) == 0:
+        result_text += "\n本局没有任何接龙记录。"
+    else:
+        result_text += "\n你们的接龙记录是：\n"
+        history_lines = instance.display_history()
+        for line in history_lines:
+            result_text += line + "\n"
     await evt.send(await result_text.export())
     instance.clear_score_board()
 
@@ -499,20 +544,39 @@ async def _(event: BaseEvent, msg: UniMsg, target: DepLongTaskTarget):
             .export()
         )
         return
+    already_used_num = instance.get_already_used_num(user_idiom)
     if TryVerifyState.VERIFIED_AND_REAL in state:
-        await evt.send(
-            await UniMessage()
-            .at(user_id)
-            .text(f" 接上了，这是个真实成语，喜提 5 分！你有 {instance.get_user_score(user_id)} 分！")
-            .export()
-        )
+        score = 5 * (0.5 ** (already_used_num - 1))
+        if already_used_num > 1:
+            await evt.send(
+                await UniMessage()
+                .at(user_id)
+                .text(f" 接上了，这是个被重复用过的成语，喜提 {score} 分！你有 {instance.get_user_score(user_id)} 分！")
+                .export()
+            )
+        else:
+            await evt.send(
+                await UniMessage()
+                .at(user_id)
+                .text(f" 接上了，这是个真实成语，喜提 5 分！你有 {instance.get_user_score(user_id)} 分！")
+                .export()
+            )
     elif TryVerifyState.VERIFIED in state:
-        await evt.send(
-            await UniMessage()
-            .at(user_id)
-            .text(f" 接上了，喜提 1 分！你有 {instance.get_user_score(user_id)} 分！")
-            .export()
-        )
+        score = 1 * (0.5 ** (already_used_num - 1))
+        if already_used_num > 1:
+            await evt.send(
+                await UniMessage()
+                .at(user_id)
+                .text(f" 接上了，但重复了，喜提 {score} 分！你有 {instance.get_user_score(user_id)} 分！")
+                .export()
+            )
+        else:
+            await evt.send(
+                await UniMessage()
+                .at(user_id)
+                .text(f" 接上了，喜提 1 分！你有 {instance.get_user_score(user_id)} 分！")
+                .export()
+            )
     if TryVerifyState.GAME_END in state:
         await evt.send(await UniMessage().text("全部回合结束！").export())
         await end_game(event, group_id)

konabot/plugins/simple_notify/__init__.py

@@ -1,23 +1,19 @@
 import aiohttp
 import asyncio as asynkio
-import datetime
 from math import ceil
 from pathlib import Path
-from typing import Any, Literal
+from typing import Any
 
 import nanoid
 import nonebot
 import ptimeparse
 from loguru import logger
 from nonebot import get_plugin_config, on_message
-from nonebot.adapters import Bot, Event
-from nonebot.adapters.onebot.v11 import Bot as OBBot
-from nonebot.adapters.console import Bot as CBot
-from nonebot.adapters.discord import Bot as DCBot
+from nonebot.adapters import Event
 from nonebot_plugin_alconna import Alconna, Args, Subcommand, UniMessage, UniMsg, on_alconna
 from pydantic import BaseModel
 
-from konabot.common.longtask import DepLongTaskTarget, LongTask, LongTaskTarget, create_longtask, handle_long_task, longtask_data
+from konabot.common.longtask import DepLongTaskTarget, LongTask, create_longtask, handle_long_task, longtask_data
 
 evt = on_message()
 
@@ -32,27 +28,8 @@ PAGE_SIZE = 6
 FMT_STRING = "%Y年%m月%d日 %H:%M:%S"
 
 
-class NotifyMessage(BaseModel):
-    message: str
-
-
-class Notify(BaseModel):
-    platform: Literal["console", "qq", "discord"]
-
-    target: str
-    "需要接受通知的个体"
-
-    target_env: str | None
-    "在哪里进行通知，如果是 None 代表私聊通知"
-
-    notify_time: datetime.datetime
-    notify_msg: str
-
-
 class NotifyConfigFile(BaseModel):
     version: int = 2
-    notifies: list[Notify] = []
-    unsent: list[Notify] = []
     notify_channels: dict[str, str] = {}
 
 
@@ -78,36 +55,6 @@ async def send_notify_to_ntfy_instance(msg: str, channel: str):
             logger.info(f"访问 {url} 的结果是 {response.status}")
 
 
-def _get_bot_of(_type: type[Bot]):
-    for bot in nonebot.get_bots().values():
-        if isinstance(bot, _type):
-            return bot.self_id
-    return ""
-
-
-def get_target_from_notify(notify: Notify) -> LongTaskTarget:
-    if notify.platform == "console":
-        return LongTaskTarget(
-            platform="console",
-            self_id=_get_bot_of(CBot),
-            channel_id=notify.target_env or "",
-            target_id=notify.target,
-        )
-    if notify.platform == "discord":
-        return LongTaskTarget(
-            platform="discord",
-            self_id=_get_bot_of(DCBot),
-            channel_id=notify.target_env or "",
-            target_id=notify.target,
-        )
-    return LongTaskTarget(
-        platform="qq",
-        self_id=_get_bot_of(OBBot),
-        channel_id=notify.target_env or "",
-        target_id=notify.target,
-    )
-
-
 def load_notify_config() -> NotifyConfigFile:
     if not DATA_FILE_PATH.exists():
         return NotifyConfigFile()
@@ -160,40 +107,6 @@ async def _(msg: UniMsg, mEvt: Event, target: DepLongTaskTarget):
 
 driver = nonebot.get_driver()
 
-NOTIFIED_FLAG = {
-    "task_added": False,
-}
-
-
-@driver.on_bot_connect
-async def _():
-    if NOTIFIED_FLAG["task_added"]:
-        return
-
-    NOTIFIED_FLAG["task_added"] = True
-
-    DELTA = 2
-    logger.info(f"第一次探测到 Bot 连接，等待 {DELTA} 秒后开始通知")
-    await asynkio.sleep(DELTA)
-
-    await DATA_FILE_LOCK.acquire()
-
-    cfg = load_notify_config()
-    if cfg.version == 1:
-        logger.info("将配置文件的版本升级为 2")
-        cfg.version = 2
-    else:
-        for notify in [*cfg.notifies]:
-            await create_longtask(
-                handler=LONG_TASK_NAME,
-                data={ "message": notify.notify_msg },
-                target=get_target_from_notify(notify),
-                deadline=notify.notify_time,
-            )
-        cfg.notifies = []
-    save_notify_config(cfg)
-    DATA_FILE_LOCK.release()
-
 
 @handle_long_task("TASK_SIMPLE_NOTIFY")
 async def _(task: LongTask):
@@ -284,7 +197,17 @@ cmd_notify_channel = on_alconna(Alconna(
 
 @cmd_notify_channel.assign("$main")
 async def _(target: DepLongTaskTarget):
+    async with DATA_FILE_LOCK:
+        data = load_notify_config()
+        target_channel = data.notify_channels.get(target.target_id)
+
+    if target_channel is None:
+        channel_msg = "目前还没有配置 ntfy 地址"
+    else:
+        channel_msg = f"配置的 ntfy Channel 为：{target_channel}\n\n服务器地址：{config.plugin_notify_base_url}"
+
     await target.send_message(UniMessage.text(
+        f"{channel_msg}\n\n"
         "配置 ntfy 通知：\n\n"
         "- ntfy 创建: 启用 ntfy 通知，并为你随机生成一个通知渠道\n"
         "- ntfy 删除：禁用 ntfy 通知\n"

konabot/plugins/xibao_generate/__init__.py

@@ -75,6 +75,44 @@ async def _(msg: UniMsg, event: BaseEvent, content: Optional[str] = ""):
         other_function=lambda page: beibao_continue_handle(page, content),
         timeout=30
     )
+    await evt.send(
+        await UniMessage().image(raw=screenshot).export()
+    )
+
+async def continue_handle_3(page: Page, arg1: str, arg2: str) -> None:
+    # 这里可以添加一些预处理逻辑
+    # 找到 id 为 textL 的 input，id 为 textR 的 input
+    input1 = await page.query_selector("#textL")
+    input2 = await page.query_selector("#textR")
+    if input1:
+        await input1.fill(arg1)
+    if input2:
+        await input2.fill(arg2)
+    # 等待 0.3 秒钟
+    await page.wait_for_timeout(300)
+    # 等待 id 为 loading 的元素不可见
+    loading = await page.query_selector("#loading")
+    if loading:
+        await loading.wait_for_element_state("hidden")
+
+evt = on_alconna(
+    Alconna(
+        f"BA生成",
+        Args["arg1", str],
+        Args["arg2", str]
+    ),
+    use_cmd_start=True,
+    use_cmd_sep=False,
+    skip_for_unmatch=True,
+)
+@evt.handle()
+async def _(msg: UniMsg, event: BaseEvent, arg1: str, arg2: str):
+    screenshot = await WebRenderer.render(
+        url="https://tmp.nulla.top/ba-logo/",
+        target="#canvas",
+        other_function=lambda page: continue_handle_3(page, arg1, arg2),
+        timeout=30
+    )
     await evt.send(
         await UniMessage().image(raw=screenshot).export()
     )