ksaa 2025.5.23.3__py3-none-any.whl → 2025.6.23.0__py3-none-any.whl

kotonebot/kaa/game_ui/idols_overview.py

@@ -10,7 +10,8 @@ from kotonebot.kaa.util import paths
 from kotonebot.primitives import RectTuple, Rect
 from kotonebot.kaa.game_ui import Scrollable
 from kotonebot import device, action
-from kotonebot.kaa.image_db import ImageDatabase, HistDescriptor, FileDataSource
+from kotonebot.util import cv2_imread
+from kotonebot.kaa.image_db import ImageDatabase, HistDescriptor, FileDataSource, DatabaseQueryResult
 from kotonebot.backend.preprocessor import HsvColorsRemover
 
 logger = logging.getLogger(__name__)
@@ -106,8 +107,32 @@ def idols_db() -> ImageDatabase:
         _db = ImageDatabase(FileDataSource(str(path)), db_path, HistDescriptor(8), name='idols')
     return _db
 
+def match_idol(skin_id: str, idol_img: MatLike) -> DatabaseQueryResult | None:
+    """
+    将给定图像与指定偶像 ID 进行匹配。
+
+    :param skin_id: 偶像 ID。
+    :param idol_img: 待匹配偶像图像。
+    :return: 若匹配成功，则返回匹配结果，否则返回 None。
+    """
+    db = idols_db()
+    match = db.match(idol_img, 20)
+    if match and match.key.startswith(skin_id):
+        return match
+    else:
+        return None
+
 @action('定位偶像', screenshot_mode='manual-inherit')
-def locate_idol(skin_id: str):
+def locate_idol(skin_id: str) -> Rect | None:
+    """
+    定位并选中指定偶像。
+
+    前置条件：位于偶像总览界面。\n
+    结束状态：位于偶像总览界面。
+
+    :param skin_id: 目标偶像的 Skin ID
+    :return: 若成功，返回目标偶像的范围 (x, y, w, h)，否则返回 None。
+    """
     device.screenshot()
     logger.info('Locating idol %s', skin_id)
     x, y, w, h = R.Produce.BoxIdolOverviewIdols.xywh
@@ -146,15 +171,6 @@ def locate_idol(skin_id: str):
 
     # # 使用新函数绘制预览图
     # preview_img = draw_idol_preview(img, rects, db, path)
-    
-
-def test():
-    from kotonebot.backend.context import init_context, manual_context
-    init_context()
-    manual_context().begin()
-    locate_idol('i_card-skin-fktn-3-006')
 
 if __name__ == '__main__':
-    from kotonebot.util import cv2_imread
-
-    test()
+    locate_idol('i_card-skin-fktn-3-006')

kotonebot/kaa/game_ui/primary_button.py

@@ -0,0 +1,55 @@
+import cv2
+import numpy as np
+from typing import Optional
+from cv2.typing import MatLike
+
+from kotonebot import action, image, device
+from kotonebot.backend.core import Image
+from kotonebot.backend.image import TemplateMatchResult
+
+
+def primary_button_state(img: MatLike) -> Optional[bool]:
+    """
+    分析按钮图像并根据红色通道直方图返回按钮状态
+
+    :param img: 输入的按钮图像 (BGR格式)
+    :return: True - 启用状态
+             False - 禁用状态
+             None - 未知状态或输入无效
+    """
+    # 确保图像有效
+    if img is None or img.size == 0:
+        return None
+
+    # 计算红色通道直方图（五箱）
+    _, _, r = cv2.split(img)
+    hist = cv2.calcHist([r], [0], None, [5], [0, 256])
+    # 归一化并找出红色集中在哪一箱
+    hist = hist.ravel() / hist.sum()
+    max_idx = np.argmax(hist)
+
+    if max_idx == 3:
+        return False
+    elif max_idx == 4:
+        return True
+    else:
+        return None
+
+@action('寻找按钮', screenshot_mode='manual-inherit')
+def find_button(template: MatLike | Image, state: Optional[bool] = None) -> Optional[bool]:
+    """
+    在图像中寻找按钮并返回其状态
+
+    :param template: 按钮模板图像 (BGR格式)
+    :param state: 按钮状态 (True - 启用, False - 禁用, None - 任意)
+    :return: True - 启用状态
+             False - 禁用状态
+             None - 未找到按钮或状态未知
+    """
+    img = device.screenshot()
+    result = image.find(template)
+    if result is None:
+        return None
+    x, y, w, h = result.rect.xywh
+    button_img = img[y:y+h, x:x+w]
+    return primary_button_state(button_img)

kotonebot/kaa/game_ui/scrollable.py

@@ -327,12 +327,7 @@ class Scrollable:
         return ScrollableIterator(self, int(self.track_height * step), start, end, skip_first)
 
 if __name__ == '__main__':
-    from kotonebot.backend.context import init_context, manual_context, device
-    init_context()
-    manual_context().begin()
-    from kotonebot import device
     import cv2
-    from kotonebot.util import cv2_imread
     import time
     logger.setLevel(logging.DEBUG)
 

kotonebot/kaa/main/cli.py

@@ -1,13 +1,15 @@
 import os
 import sys
-import runpy
 import logging
 import argparse
 import importlib.metadata
 from datetime import datetime
 
 from .kaa import Kaa
+from ..util.paths import get_ahk_path
+from kotonebot.client.implements.windows import WindowsImplConfig
 from kotonebot.backend.context import tasks_from_id, task_registry
+from kotonebot.client.implements.remote_windows import RemoteWindowsServer
 
 version = importlib.metadata.version('ksaa')
 
@@ -90,9 +92,12 @@ def task_list() -> int:
 def remote_server() -> int:
     args = psr.parse_args()
     try:
-        # 使用runpy运行remote_windows.py模块
-        sys.argv = ['remote_windows.py', f'--host={args.host}', f'--port={args.port}']
-        runpy.run_module('kotonebot.client.implements.remote_windows', run_name='__main__')
+        ahk_path = get_ahk_path()
+        server = RemoteWindowsServer(WindowsImplConfig(window_title='gakumas', ahk_exe_path=ahk_path), args.host, args.port)
+        server.start()
+        return 0
+    except KeyboardInterrupt:
+        print("Server stopped by user")
         return 0
     except Exception as e:
         print(f'Error starting remote server: {e}')

kotonebot/kaa/main/dmm_host.py

@@ -1,11 +1,18 @@
+from importlib import resources
 from typing_extensions import override
 
-from kotonebot.client import Device, create_device
-from kotonebot.client import DeviceImpl, Device
+from kotonebot.client import Device, DeviceImpl
+from kotonebot.client.registration import create_device
+from kotonebot.client.implements.windows import WindowsImplConfig
+from kotonebot.client.implements.remote_windows import RemoteWindowsImplConfig
 from kotonebot.client.host import HostProtocol, Instance
+from kotonebot.client.host.protocol import WindowsHostConfig, RemoteWindowsHostConfig
+
+
+DmmHostConfigs = WindowsHostConfig | RemoteWindowsHostConfig
 
 # TODO: 可能应该把 start_game 和 end_game 里对启停的操作移动到这里来
-class DmmInstance(Instance):
+class DmmInstance(Instance[DmmHostConfigs]):
     def __init__(self):
         super().__init__('dmm', 'gakumas')
 
@@ -30,10 +37,29 @@ class DmmInstance(Instance):
         raise NotImplementedError()
 
     @override
-    def create_device(self, impl: DeviceImpl, *, timeout: float = 180) -> Device:
-        if impl not in ['windows', 'remote_windows']:
-            raise ValueError(f'Unsupported device implementation: {impl}')
-        return create_device('', impl, timeout=timeout)
+    def create_device(self, impl: DeviceImpl, host_config: DmmHostConfigs) -> Device:
+        if impl == 'windows':
+            assert isinstance(host_config, WindowsHostConfig)
+            win_config = WindowsImplConfig(
+                window_title=host_config.window_title,
+                ahk_exe_path=host_config.ahk_exe_path
+            )
+            return create_device(impl, win_config)
+
+        elif impl == 'remote_windows':
+            assert isinstance(host_config, RemoteWindowsHostConfig)
+            config = RemoteWindowsImplConfig(
+                windows_impl_config=WindowsImplConfig(
+                    window_title=host_config.windows_host_config.window_title,
+                    ahk_exe_path=host_config.windows_host_config.ahk_exe_path
+                ),
+                host=host_config.host,
+                port=host_config.port
+            )
+            return create_device(impl, config)
+
+        else:
+            raise ValueError(f'Unsupported impl for DMM: {impl}')
 
 class DmmHost(HostProtocol):
     instance = DmmInstance()

kotonebot/kaa/main/gr.py

@@ -15,6 +15,7 @@ from kotonebot.kaa.db import IdolCard
 from kotonebot.config.manager import load_config, save_config
 from kotonebot.config.base_config import UserConfig, BackendConfig
 from kotonebot.backend.context import task_registry, ContextStackVars
+from kotonebot.backend.context.context import vars
 from kotonebot.client.host import Mumu12Host, LeidianHost
 from kotonebot.kaa.common import (
     BaseConfig, APShopItems, CapsuleToysConfig, ClubRewardConfig, PurchaseConfig, ActivityFundsConfig,
@@ -69,12 +70,14 @@ ConfigKey = Literal[
     'anomaly_capsule_toys_count',
     
     # start game
-    'start_game_enabled', 'start_through_kuyo', 
+    'start_game_enabled', 'start_through_kuyo',
     'game_package_name', 'kuyo_package_name',
-    
+    'disable_gakumas_localify', 'dmm_game_path',
+
     # end game
-    'exit_kaa', 'kill_game', 'kill_dmm', 
+    'exit_kaa', 'kill_game', 'kill_dmm',
     'kill_emulator', 'shutdown', 'hibernate',
+    'restore_gakumas_localify',
     
     'activity_funds',
     'presents',
@@ -180,6 +183,8 @@ class KotoneBotUI:
     def __init__(self, kaa: Kaa) -> None:
         self.is_running: bool = False
         self.single_task_running: bool = False
+        self.is_stopping: bool = False  # 新增：标记是否正在停止过程中
+        self.is_single_task_stopping: bool = False  # 新增：标记单个任务是否正在停止
         self._kaa = kaa
         self._load_config()
         self._setup_kaa()
@@ -230,14 +235,20 @@ class KotoneBotUI:
 
         return f"已导出到 {zip_filename}"
 
-    def get_button_status(self) -> str:
+    def get_button_status(self) -> Tuple[str, bool]:
+        """获取按钮状态和交互性"""
         if not hasattr(self, 'run_status'):
-            return "启动"
+            return "启动", True
 
         if not self.run_status.running:
             self.is_running = False
-            return "启动"
-        return "停止"
+            self.is_stopping = False  # 重置停止状态
+            return "启动", True
+
+        if self.is_stopping:
+            return "停止中...", False  # 停止中时禁用按钮
+
+        return "停止", True
 
     def update_task_status(self) -> List[List[str]]:
         status_list: List[List[str]] = []
@@ -260,6 +271,11 @@ class KotoneBotUI:
     def toggle_run(self) -> Tuple[str, List[List[str]]]:
         if not self.is_running:
             return self.start_run()
+
+        # 如果正在停止过程中，忽略重复点击
+        if self.is_stopping:
+            return "停止中...", self.update_task_status()
+
         return self.stop_run()
 
     def start_run(self) -> Tuple[str, List[List[str]]]:
@@ -268,10 +284,19 @@ class KotoneBotUI:
         return "停止", self.update_task_status()
 
     def stop_run(self) -> Tuple[str, List[List[str]]]:
+        self.is_stopping = True  # 设置停止状态
+
+        # 如果当前处于暂停状态，先恢复再停止
+        if vars.flow.is_paused:
+            gr.Info("检测到任务暂停，正在恢复后停止...")
+            vars.flow.request_resume()
+
         self.is_running = False
         if self._kaa:
             self.run_status.interrupt()
-        return "启动", self.update_task_status()
+            gr.Info("正在停止任务...")
+
+        return "停止中...", self.update_task_status()
 
     def start_single_task(self, task_name: str) -> Tuple[str, str]:
         if not task_name:
@@ -292,11 +317,48 @@ class KotoneBotUI:
         return "停止任务", f"正在执行任务: {task_name}"
 
     def stop_single_task(self) -> Tuple[str, str]:
+        self.is_single_task_stopping = True  # 设置单个任务停止状态
+
+        # 如果当前处于暂停状态，先恢复再停止
+        if vars.flow.is_paused:
+            gr.Info("检测到任务暂停，正在恢复后停止...")
+            vars.flow.request_resume()
+
         self.single_task_running = False
         if hasattr(self, 'run_status') and self._kaa:
             self.run_status.interrupt()
-            gr.Info("任务已停止")
-        return "执行任务", "任务已停止"
+            gr.Info("正在停止任务...")
+        return "停止中...", "正在停止任务..."
+
+    def toggle_pause(self) -> str:
+        """切换暂停/恢复状态"""
+        if vars.flow.is_paused:
+            vars.flow.request_resume()
+            gr.Info("任务已恢复")
+            return "暂停"
+        else:
+            vars.flow.request_pause()
+            gr.Info("任务已暂停")
+            return "恢复"
+
+    def get_pause_button_status(self) -> str:
+        """获取暂停按钮的状态"""
+        if vars.flow.is_paused:
+            return "恢复"
+        else:
+            return "暂停"
+
+    def get_pause_button_with_interactive(self) -> gr.Button:
+        """获取暂停按钮的状态和交互性"""
+        try:
+            text = "恢复" if vars.flow.is_paused else "暂停"
+        except ValueError:
+            # ValueError: Forwarded object vars called before initialization.
+            # TODO: vars.flow.is_paused 应该要可以在脚本正式启动前就能访问
+            text = '未启动'
+        # 如果正在停止过程中，禁用暂停按钮
+        interactive = not (self.is_stopping or self.is_single_task_stopping)
+        return gr.Button(value=text, interactive=interactive)
         
     def save_settings2(self, return_values: list[ConfigBuilderReturnValue], *args) -> str:
         options = BaseConfig()
@@ -326,7 +388,8 @@ class KotoneBotUI:
             gr.Markdown("## 状态")
 
             with gr.Row():
-                run_btn = gr.Button("启动", scale=1)
+                run_btn = gr.Button("启动", scale=2)
+                pause_btn = gr.Button("暂停", scale=1)
             if self._kaa.upgrade_msg:
                 gr.Markdown('### 配置升级报告')
                 gr.Markdown(self._kaa.upgrade_msg)
@@ -338,19 +401,39 @@ class KotoneBotUI:
                 label="任务状态"
             )
 
-            def on_run_click(evt: gr.EventData) -> Tuple[str, List[List[str]]]:
-                return self.toggle_run()
+            def on_run_click(evt: gr.EventData) -> Tuple[gr.Button, List[List[str]]]:
+                result = self.toggle_run()
+                # 如果正在停止，禁用按钮
+                interactive = not self.is_stopping
+                button = gr.Button(value=result[0], interactive=interactive)
+                return button, result[1]
+
+            def on_pause_click(evt: gr.EventData) -> str:
+                return self.toggle_pause()
 
             run_btn.click(
                 fn=on_run_click,
                 outputs=[run_btn, task_status]
             )
 
+            pause_btn.click(
+                fn=on_pause_click,
+                outputs=[pause_btn]
+            )
+
             # 添加定时器，分别更新按钮状态和任务状态
+            def update_run_button_status():
+                text, interactive = self.get_button_status()
+                return gr.Button(value=text, interactive=interactive)
+
             gr.Timer(1.0).tick(
-                fn=self.get_button_status,
+                fn=update_run_button_status,
                 outputs=[run_btn]
             )
+            gr.Timer(1.0).tick(
+                fn=self.get_pause_button_with_interactive,
+                outputs=[pause_btn]
+            )
             gr.Timer(1.0).tick(
                 fn=self.update_task_status,
                 outputs=[task_status]
@@ -370,21 +453,34 @@ class KotoneBotUI:
                 value=None
             )
 
-            # 创建执行按钮
-            execute_btn = gr.Button("执行任务")
+            # 创建执行按钮和暂停按钮
+            with gr.Row():
+                execute_btn = gr.Button("执行任务", scale=2)
+                pause_btn = gr.Button("暂停", scale=1)
             task_result = gr.Markdown("")
 
-            def toggle_single_task(task_name: str) -> Tuple[str, str]:
+            def toggle_single_task(task_name: str) -> Tuple[gr.Button, str]:
                 if self.single_task_running:
-                    return self.stop_single_task()
+                    # 如果正在停止过程中，忽略重复点击
+                    if self.is_single_task_stopping:
+                        return gr.Button(value="停止中...", interactive=False), "正在停止任务..."
+
+                    result = self.stop_single_task()
+                    return gr.Button(value=result[0], interactive=False), result[1]
                 else:
-                    return self.start_single_task(task_name)
+                    result = self.start_single_task(task_name)
+                    return gr.Button(value=result[0], interactive=True), result[1]
 
-            def get_task_button_status() -> str:
+            def get_task_button_status() -> gr.Button:
                 if not hasattr(self, 'run_status') or not self.run_status.running:
                     self.single_task_running = False
-                    return "执行任务"
-                return "停止任务"
+                    self.is_single_task_stopping = False  # 重置停止状态
+                    return gr.Button(value="执行任务", interactive=True)
+
+                if self.is_single_task_stopping:
+                    return gr.Button(value="停止中...", interactive=False)  # 停止中时禁用按钮
+
+                return gr.Button(value="停止任务", interactive=True)
 
             def get_single_task_status() -> str:
                 if not hasattr(self, 'run_status'):
@@ -417,17 +513,29 @@ class KotoneBotUI:
 
                 return ""
 
+            def on_pause_click(evt: gr.EventData) -> str:
+                return self.toggle_pause()
+
             execute_btn.click(
                 fn=toggle_single_task,
                 inputs=[task_dropdown],
                 outputs=[execute_btn, task_result]
             )
 
+            pause_btn.click(
+                fn=on_pause_click,
+                outputs=[pause_btn]
+            )
+
             # 添加定时器更新按钮状态和任务状态
             gr.Timer(1.0).tick(
                 fn=get_task_button_status,
                 outputs=[execute_btn]
             )
+            gr.Timer(1.0).tick(
+                fn=self.get_pause_button_with_interactive,
+                outputs=[pause_btn]
+            )
             gr.Timer(1.0).tick(
                 fn=get_single_task_status,
                 outputs=[task_result]
@@ -1106,6 +1214,17 @@ class KotoneBotUI:
                     label="Kuyo包名",
                     info=StartGameConfig.model_fields['kuyo_package_name'].description
                 )
+                disable_gakumas_localify = gr.Checkbox(
+                    label="禁用 Gakumas Localify 汉化插件",
+                    value=self.current_config.options.start_game.disable_gakumas_localify,
+                    info=StartGameConfig.model_fields['disable_gakumas_localify'].description
+                )
+                dmm_game_path = gr.Textbox(
+                    value=self.current_config.options.start_game.dmm_game_path or "",
+                    label="DMM 版游戏路径",
+                    info=StartGameConfig.model_fields['dmm_game_path'].description,
+                    placeholder="例：F:\\Games\\gakumas\\gakumas.exe"
+                )
             start_game_enabled.change(
                 fn=lambda x: gr.Group(visible=x),
                 inputs=[start_game_enabled],
@@ -1117,12 +1236,16 @@ class KotoneBotUI:
             config.start_game.start_through_kuyo = data['start_through_kuyo']
             config.start_game.game_package_name = data['game_package_name']
             config.start_game.kuyo_package_name = data['kuyo_package_name']
-        
+            config.start_game.disable_gakumas_localify = data['disable_gakumas_localify']
+            config.start_game.dmm_game_path = data['dmm_game_path'] if data['dmm_game_path'] else None
+
         return set_config, {
             'start_game_enabled': start_game_enabled,
             'start_through_kuyo': start_through_kuyo,
             'game_package_name': game_package_name,
-            'kuyo_package_name': kuyo_package_name
+            'kuyo_package_name': kuyo_package_name,
+            'disable_gakumas_localify': disable_gakumas_localify,
+            'dmm_game_path': dmm_game_path
         }
 
 
@@ -1160,6 +1283,11 @@ class KotoneBotUI:
                 value=self.current_config.options.end_game.hibernate,
                 info=EndGameConfig.model_fields['hibernate'].description
             )
+            restore_gakumas_localify = gr.Checkbox(
+                label="恢复 Gakumas Localify 汉化插件状态",
+                value=self.current_config.options.end_game.restore_gakumas_localify,
+                info=EndGameConfig.model_fields['restore_gakumas_localify'].description
+            )
         
         def set_config(config: BaseConfig, data: dict[ConfigKey, Any]) -> None:
             config.end_game.exit_kaa = data['exit_kaa']
@@ -1168,14 +1296,16 @@ class KotoneBotUI:
             config.end_game.kill_emulator = data['kill_emulator']
             config.end_game.shutdown = data['shutdown']
             config.end_game.hibernate = data['hibernate']
-        
+            config.end_game.restore_gakumas_localify = data['restore_gakumas_localify']
+
         return set_config, {
             'exit_kaa': exit_kaa,
             'kill_game': kill_game,
             'kill_dmm': kill_dmm,
             'kill_emulator': kill_emulator,
             'shutdown': shutdown,
-            'hibernate': hibernate
+            'hibernate': hibernate,
+            'restore_gakumas_localify': restore_gakumas_localify
         }
 
     def _create_activity_funds_settings(self) -> ConfigBuilderReturnValue: