告别繁琐基建管理：Arknights-Mower任务调度系统深度解析-优快云博客

告别繁琐基建管理：Arknights-Mower任务调度系统深度解析

【免费下载链接】arknights-mower 《明日方舟》长草助手项目地址: https://gitcode.com/gh_mirrors/ar/arknights-mower

你是否还在为《明日方舟》基建管理的繁琐操作而烦恼？每天手动安排干员排班、计算最优任务时间、处理突发状态变化，这些重复性工作不仅消耗大量时间，还常常因人为疏忽导致资源浪费。本文将深入解析Arknights-Mower项目中革命性的任务管理系统，展示其如何通过智能调度算法和模块化设计，实现基建任务的全自动优化执行。读完本文，你将掌握：

任务调度系统的核心架构与工作原理
干员排班优化算法的实现细节
复杂任务冲突的智能解决策略
自定义任务流程的高级配置方法
性能调优与常见问题解决方案

系统架构 overview

Arknights-Mower的任务管理系统采用分层架构设计，通过模块化组件实现高内聚低耦合，确保系统的可扩展性和维护性。

mermaid

核心组件包括：

BaseSchedulerSolver：调度系统主控制器，负责任务的整体执行与状态转换
SchedulerTask：任务实体类，封装任务时间、类型、执行计划等信息
TaskTypes：任务类型枚举，定义系统支持的所有任务类型及其优先级
TaskUtils：任务处理工具集，提供调度算法、冲突解决、任务生成等核心功能

系统采用事件驱动架构，通过状态机模式处理基建场景转换，确保任务在正确的上下文环境中执行。

任务调度核心算法

优先级驱动的任务排序

任务调度系统的核心在于优先级驱动的智能排序算法，确保高优先级任务优先执行，同时避免任务堆积导致的资源浪费。

def scheduling(tasks, run_order_delay=5, execution_time=0.75, time_now=None):
    if time_now is None:
        time_now = datetime.now()
    if len(tasks) > 0:
        tasks.sort(key=lambda x: x.time)
        
        # 任务间隔最小时间（5分钟）
        min_time_interval = timedelta(minutes=run_order_delay)
        
        # 初始化变量以跟踪上一个优先级0任务和计划执行时间总和
        last_priority_0_task = None
        total_execution_time = 0
        
        # 遍历任务列表
        for i, task in enumerate(tasks):
            current_time = time_now
            # 判定任务堆积，如果第一个任务已经超时，则认为任务堆积
            if task.type.priority == 1 and current_time > task.time:
                total_execution_time += (current_time - task.time).total_seconds() / 60
            
            if task.type.priority == 1:
                if last_priority_0_task is not None:
                    time_difference = task.time - last_priority_0_task.time
                    if (
                        config.conf.run_order_grandet_mode.enable
                        and time_difference < min_time_interval
                        and time_now < last_priority_0_task.time
                    ):
                        logger.info("检测到跑单任务过于接近，准备修正跑单时间")
                        return last_priority_0_task, task
                # 更新上一个优先级0任务和总执行时间
                last_priority_0_task = task
                total_execution_time = 0
            # ... 其他处理逻辑

算法实现了以下关键功能：

优先级分层：将任务分为不同优先级，确保关键任务（如资源收集）优先执行
时间冲突检测：识别时间间隔过近的任务，避免执行冲突
执行时间预估：根据任务类型和数量动态计算执行时间，防止任务堆积
自适应调整：当检测到任务可能影响后续关键任务时，自动调整任务执行顺序

干员排班优化

系统通过复杂的排班算法实现干员资源的最优配置，平衡心情值、技能特性和任务需求。

def plan_metadata(op_data, tasks):
    # 清除，重新添加刷新
    tasks = [
        t for t in tasks if t.type not in [TaskTypes.SHIFT_ON, TaskTypes.RELEASE_DORM]
    ]
    _time = datetime.max
    min_resting_time = datetime.max
    _plan = {}
    _type = []
    
    # 计算最低休息时间
    total_agent = sorted(
        (
            v
            for v in op_data.operators.values()
            if v.is_high() and not v.room.startswith("dorm") and not v.is_resting()
        ),
        key=lambda x: x.current_mood() - x.lower_limit,
    )
    
    for agent in total_agent:
        # 如果全红脸，使用急救模式
        predicted_rest_time = max(
            agent.predict_exhaust(), datetime.now() + timedelta(minutes=30)
        )
        min_resting_time = min(min_resting_time, predicted_rest_time)
    
    logger.debug(f"预测最低休息时间为: {min_resting_time}")
    grouped_dorms = defaultdict(list)
    free_rooms = []
    # 分组 dorm 对象
    for dorm in op_data.dorm:
        if dorm.name and dorm.name in op_data.operators:
            operator = op_data.operators[dorm.name]
            grouped_dorms[operator.group].append(dorm)
            if not operator.is_high():
                free_rooms.append(dorm)
    # ... 干员分组与排班逻辑

排班算法考虑以下关键因素：

心情值管理：基于干员当前心情和恢复速率，预测最优休息时间
技能特性匹配：根据干员技能特性分配最适合的基建岗位
组策略优化：支持干员分组管理，确保团队协作效率最大化
紧急模式处理：当检测到干员心情过低时，自动触发急救模式

任务类型与生命周期管理

系统支持多种任务类型，每种任务都有明确定义的生命周期和状态转换规则。

核心任务类型

任务类型	优先级	描述	典型执行周期
RUN_ORDER	1	资源跑单任务	30-60分钟
SHIFT_ON	2	干员上班任务	4-8小时
SHIFT_OFF	2	干员下班任务	基于心情值
FIAMMETTA	2	菲亚梅塔充能任务	2-4小时
CLUE_PARTY	2	线索交流任务	12小时
RECRUIT	2	公招刷新任务	6小时
SKLAND	2	森空岛签到任务	24小时
WORKSHOP	2	加工站材料任务	1-3小时

任务生命周期管理

每个任务从创建到完成经历完整的生命周期，系统通过状态机确保任务正确执行。

mermaid

任务执行过程中，系统会持续监控执行状态，并处理可能的异常情况：

def handle_error(self, force=False):
    if self.scene() == Scene.UNKNOWN:
        self.device.exit()
        self.check_current_focus()
    if self.error or force:
        # 如果没有任何时间小于当前时间的任务才生成空任务
        if self.find_next_task(datetime.now()) is None:
            logger.debug("由于出现错误情况，生成一次空任务来执行纠错")
            self.tasks.append(SchedulerTask())
        # 如果没有任何时间小于当前时间的任务-10分钟 则清空任务
        if self.find_next_task(datetime.now() - timedelta(seconds=900)):
            logger.info("检测到执行超过15分钟的任务，清空全部任务")
            self.tasks = []
    elif self.find_next_task(datetime.now() + timedelta(hours=2.5)) is None:
        logger.debug("2.5小时内没有其他任务，生成一个空任务")
        self.tasks.append(SchedulerTask(time=datetime.now() + timedelta(hours=2.5)))
    return True

高级功能实现

智能冲突解决

系统实现了多种冲突解决策略，确保在复杂场景下任务仍能有序执行。

def try_reorder(op_data, new_plan):
    # 移除被拉去上班的替班
    assigned_names = {name for names in new_plan.values() for name in names}
    for d in op_data.dorm:
        if d.name in assigned_names:
            d.name = ""
            d.time = None
    
    # 复制副本，防止原本的dorm错误触发纠错
    dorm = copy.deepcopy(op_data.dorm)
    
    priority_list = op_data.config.ope_resting_priority
    vip = sum(1 for key in op_data.plan.keys() if key.startswith("dorm"))
    
    def get_ranking(name):
        if name in op_data.operators:
            _op = op_data.operators[name]
            if _op.operator_type == "high" and _op.resting_priority == "high":
                return "high"
            elif _op.operator_type == "high":
                return "normal"
        return "low"
    
    dorm_info = [
        {
            "name": room.name,
            "index": idx,
            "time": room.time,
            "priority": get_ranking(room.name),
        }
        for idx, room in enumerate(dorm)
    ]
    
    def sort_key(_op):
        length = len(priority_list)
        priority_order = {
            "high": length,
            "normal": length + 1,
            "low": length + 2,
        }
        return (
            priority_list.index(_op["name"])
            if _op["name"] in priority_list and _op["name"] != ""
            else priority_order[_op["priority"]],
            _op["index"],
        )
    
    dorm_info.sort(key=sort_key)
    # ... 宿舍重排序逻辑

冲突解决策略包括：

优先级排序：基于预定义规则对干员进行优先级排序
时间窗口调整：动态调整任务时间，避免资源冲突
资源抢占机制：关键任务可抢占非关键任务的资源
回滚恢复机制：任务失败时，系统能回滚到之前状态并尝试恢复

自适应任务生成

系统能根据当前游戏状态动态生成最优任务序列，无需人工干预。

def try_workshop_tasks(op_data, tasks):
    # 如果没有其他任务则进行加工站干员检查
    from arknights_mower.data import workshop_formula

    inventory_data = get_inventory_counts()
    if config.conf.workshop_settings and inventory_data:
        for item in config.conf.workshop_settings:
            valid = False
            if item.operator in op_data.operators.keys():
                agent = op_data.operators[item.operator]
                valid = agent.mood > 22
            else:
                logger.info(f"自动添加{item.operator}至干员数据列表")
                valid = True
                op_data.add(Operator(item.operator, ""))
            
            # 材料检查逻辑
            match = False
            for material in item.items:
                name = material.item_name
                metadata = workshop_formula[name]
                if name.startswith("家具零件"):
                    name = name.split("_")[-1]
                if (
                    name in inventory_data
                    and inventory_data[name] < material.self_upper_limit
                    and all(
                        child_name in inventory_data
                        and inventory_data[child_name]
                        > material.children_lower_limit
                        for child_name in metadata["items"]
                    )
                ):
                    match = True
                    break
            
            if match and valid:
                logger.info(f"{item.operator}满足使用条件:, 生成加工站任务")
                task = SchedulerTask(
                    task_type=TaskTypes.WORKSHOP, meta_data=item.operator
                )
                tasks.append(task)

自适应任务生成考虑以下因素：

资源库存水平：根据当前材料库存决定是否生成加工任务
干员心情状态：确保执行任务的干员心情值处于理想状态
任务优先级：新生成的任务不会影响高优先级任务的执行
玩家设置偏好：尊重玩家自定义的任务偏好和策略

实际应用与配置示例

基础配置示例

通过简单的配置即可实现基本的任务自动化：

{
  "workshop_settings": [
    {
      "operator": "九色鹿",
      "items": [
        {
          "item_name": "聚酸酯组",
          "self_upper_limit": 50,
          "children_lower_limit": 200
        },
        {
          "item_name": "酮凝集组",
          "self_upper_limit": 50,
          "children_lower_limit": 200
        }
      ]
    }
  ],
  "run_order_grandet_mode": {
    "enable": true,
    "back_to_index": true,
    "buffer_time": 300
  },
  "ope_resting_priority": ["能天使", "艾雅法拉", "银灰", "塞雷娅"]
}

高级调度策略

对于高级用户，系统支持复杂的调度策略配置，实现更精细的任务控制：

# 自定义任务排序函数示例
def custom_scheduling_strategy(tasks):
    # 1. 首先按优先级排序
    tasks.sort(key=lambda x: x.type.priority)
    
    # 2. 对于相同优先级的任务，按以下规则排序:
    #    - 加工站任务优先于宿舍任务
    #    - 高心情干员的任务优先
    #    - 接近截止时间的任务优先
    def custom_sort_key(task):
        type_priority = {
            TaskTypes.WORKSHOP: 0,
            TaskTypes.SHIFT_ON: 1,
            TaskTypes.SHIFT_OFF: 2,
            TaskTypes.RELEASE_DORM: 3
        }
        
        return (
            type_priority.get(task.type, 99),
            -sum(1 for name in task.plan.values() if name in high_priority_operators),
            task.time
        )
    
    # 对相同优先级的任务应用自定义排序
    grouped_tasks = {}
    for task in tasks:
        key = task.type.priority
        if key not in grouped_tasks:
            grouped_tasks[key] = []
        grouped_tasks[key].append(task)
    
    # 重组任务列表
    result = []
    for key in sorted(grouped_tasks.keys()):
        group = grouped_tasks[key]
        if key == 2:  # 仅对优先级为2的任务应用自定义排序
            group.sort(key=custom_sort_key)
        result.extend(group)
    
    return result

性能优化与常见问题

性能优化建议

随着任务数量增加，系统性能可能受到影响，可通过以下方法优化：

任务合并：将短时间内的相似任务合并，减少上下文切换开销

def merge_release_dorm(tasks, merge_interval):
    for idx in range(1, len(tasks) + 1):
        if idx == 1:
            continue
        task = tasks[-idx]
        last_not_release = None
        if task.type != TaskTypes.RELEASE_DORM:
            continue
        # 查找最近的非RELEASE_DORM任务
        for index_last_not_release in range(idx + 1, len(tasks) + 1):
            if tasks[-index_last_not_release].type != TaskTypes.RELEASE_DORM and tasks[-index_last_not_release].time > task.time - timedelta(minutes=1):
                last_not_release = tasks[-index_last_not_release]
        if last_not_release is not None:
            continue
        # 合并时间接近的RELEASE_DORM任务
        elif task.time + timedelta(minutes=merge_interval) > tasks[-idx + 1].time:
            tasks[-idx].time = tasks[-idx + 1].time + timedelta(seconds=1)
            tasks[-idx], tasks[-idx + 1] = tasks[-idx + 1], tasks[-idx]
            logger.info(f"自动合并{merge_interval}分钟以内任务")

资源预加载：提前加载常用干员数据和任务模板
任务过滤：移除不必要的任务类型，减少系统负载
并行执行：合理配置可并行执行的任务，提高资源利用率

常见问题解决方案

问题	原因	解决方案
任务频繁失败	图像识别错误	1. 更新游戏资源 2. 调整设备分辨率 3. 清理游戏缓存
干员排班不合理	优先级配置错误	1. 优化ope_resting_priority配置 2. 检查干员分组设置 3. 调整心情阈值参数
任务堆积	执行时间预估不准	1. 增加run_order_delay参数 2. 减少单次任务数量 3. 优化任务优先级
资源收集效率低	跑单策略问题	1. 启用grandet_mode 2. 调整buffer_time 3. 优化跑单路线

总结与展望

Arknights-Mower的任务管理系统通过先进的调度算法和灵活的配置选项，彻底解放了《明日方舟》玩家的基建管理压力。其核心优势包括：

智能自动化：系统能根据游戏状态自动生成和调整任务计划
高度可配置：从简单到复杂的多种配置选项，满足不同玩家需求
鲁棒性设计：完善的错误处理和恢复机制，确保系统稳定运行
持续进化：活跃的开发社区不断优化算法和添加新功能

未来，任务管理系统将朝着以下方向发展：

AI驱动优化：引入强化学习算法，根据玩家习惯自动优化策略
多账号管理：支持多账号并行管理，提高多开效率
跨平台支持：扩展到更多操作系统和设备类型
更精细的资源控制：提供更细粒度的资源分配和任务控制选项

通过Arknights-Mower的任务管理系统，玩家可以将更多精力投入到游戏的策略和乐趣部分，而将繁琐的基建管理工作交给智能算法处理。无论是休闲玩家还是重度肝帝，都能从中获得显著的体验提升。

如果你觉得本文对你有帮助，请点赞、收藏并关注项目更新。下期我们将深入探讨"高级图像处理与识别优化"，敬请期待！

【免费下载链接】arknights-mower 《明日方舟》长草助手项目地址: https://gitcode.com/gh_mirrors/ar/arknights-mower

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考