开发日志251210

问题分析与整体思路

• 前处理需要“智能判断”（e.g., 基于视频作者/标题决定是否点赞/评论），但主要脚本要保持“哑巴”（只执行一次动作，不带判断）。

• 如果引入概率（e.g., 评论后概率点赞）或组合（e.g., 点赞 + 评论评论），前处理就容易爆炸：每种组合都需要自定义前处理，导致代码重复和维护噩梦。

• 统一前处理层：所有任务共享一个前处理管道（pipeline），这是一个函数数组，按序执行（e.g., 跳过广告 → 进入页面 → 搜索 → 预识别视频）。

• 规则引擎：在前处理末尾，用一个“决策器”（decider）基于配置规则（e.g., 概率、条件）动态生成“动作列表”（actions list），如 [点赞, 评论, 评论后点赞]。

• 主要脚本：只是一个“执行器”（executor），接收动作列表，按序调用独立的“原子动作函数”（e.g., likeVideo() 只点赞一次，不带任何判断）。

• 整个流程：前处理返回 { success: true, videoInfo: {...}, actionsToRun: [...] }，然后主要执行器跑 actionsToRun，返回 { preResult, mainResult }。

• 灵活组合：不用为每种情况写新前处理，只改配置（e.g., JSON 对象）就能实现“评论后概率点赞”或“给评论评论”。

• 解耦：原子动作函数保持纯净（只做一件事），判断全在前处理决策器里。

• 可扩展：以后加新前处理（如“检查网络”）或新动作（如“转发”）只需加函数到管道/列表。

• 整个结果：返回包含前处理 + 主要执行的完整日志/结果，便于群控系统监控。

推荐架构设计

1. 核心组件定义

• 前处理管道 (prePipeline)：一个函数数组，每个函数返回 { success: bool, data: {...} } 或抛错。失败时中断管道。
• 示例函数：skipAd(), enterPage('同城'), searchVideo('关键词'), recognizeVideo()。

• 决策器 (decider)：在前处理数据基础上，用规则生成 actions 列表。
• 规则用 JSON 配置：支持条件 (if author == 'xxx' then like)、概率 (random 30% then comment)、序列 (after comment then 50% like)。

• 原子动作 (atomicActions)：独立的函数，只执行一次行为，返回 { success: bool, msg: '...' }。
• e.g., likeVideo(), commentVideo('内容'), replyToComment('回复')。

• 主要执行器 (mainExecutor)：接收 actions 列表，按序执行，返回结果数组。

• 配置对象 (taskConfig)：JSON 驱动整个任务，定义管道、规则等。

2. 示例配置 JSON

{
  "taskName": "搜索视频后概率点赞+评论",
  "prePipeline": [
    "skipAd",              // 函数名或引用
    "enterPage:sameCity",  // 支持参数
    "searchVideo:门窗广告", // 支持参数
    "recognizeVideo"       // 预识别作者/标题
  ],
  "decisionRules": [
    {
      "if": "video.author.includes('品牌X')",  // 条件 (JS 表达式)
      "then": [
        { "action": "likeVideo", "prob": 0.8 },  // 80% 概率点赞
        { "action": "commentVideo", "prob": 0.5, "args": "好产品！" },  // 50% 概率评论
        { "after": "commentVideo", "action": "likeComment", "prob": 0.3 }  // 评论后 30% 概率点赞评论
      ]
    },
    {
      "if": "true",  // 默认规则
      "then": [{ "action": "likeVideo", "prob": 0.3 }]  // 低概率默认点赞
    }
  ],
  "postPipeline": []  // 可选后处理，如“返回推荐页”
}

3. 核心代码实现（Auto.js / JS 示例）

// ==================== 原子动作函数（保持纯净，只执行一次） ====================
function skipAd() {
    // 模拟：点击跳过广告
    if (id("skip_ad").exists()) {
        id("skip_ad").findOne().click();
        return { success: true, data: {} };
    }
    return { success: false, msg: "无广告" };
}

function enterPage(pageType) {
    // 模拟：进入同城/搜索页
    if (pageType === 'sameCity') {
        id("same_city_btn").click();
    } // ... 其他类型
    sleep(1000);
    return { success: true, data: { page: pageType } };
}

function searchVideo(keyword) {
    // 模拟：输入搜索 + 确认
    id("search_input").setText(keyword);
    id("search_btn").click();
    sleep(2000);
    return { success: true, data: { keyword } };
}

function recognizeVideo() {
    // 模拟：OCR 或 UI 识别作者/标题
    const author = textContains("@").findOne()?.text() || "";
    const title = descContains("视频标题").findOne()?.desc() || "";
    return { success: true, data: { author, title } };
}

function likeVideo() {
    // 只点赞一次
    if (id("like_btn").exists()) {
        id("like_btn").findOne().click();
        return { success: true, msg: "点赞成功" };
    }
    return { success: false, msg: "点赞失败" };
}

function commentVideo(content) {
    // 只评论一次
    id("comment_input").setText(content);
    id("send_comment").click();
    return { success: true, msg: "评论成功" };
}

function likeComment() {
    // 只点赞最新评论
    if (className("CommentLikeBtn").exists()) {
        className("CommentLikeBtn").findOne().click();
        return { success: true, msg: "点赞评论成功" };
    }
    return { success: false, msg: "无评论可点赞" };
}

// ==================== 函数映射（易扩展） ====================
const funcMap = {
    skipAd, enterPage, searchVideo, recognizeVideo,
    likeVideo, commentVideo, likeComment
    // 加新函数在这里
};

// ==================== 决策器（生成 actions 列表） ====================
function decideActions(videoInfo, rules) {
    const actions = [];
    for (let rule of rules) {
        if (eval(rule.if)) {  // 安全起见，可用 new Function() 代替 eval
            for (let act of rule.then) {
                if (Math.random() < (act.prob || 1)) {
                    actions.push(act);
                }
            }
            break;  // 第一匹配规则生效
        }
    }
    return actions;  // e.g., [{action: "likeVideo"}, {action: "commentVideo", args: "..."}]
}

// ==================== 主要执行器 ====================
function runMain(actions) {
    const results = [];
    let lastAction = null;
    for (let act of actions) {
        // 处理 "after" 依赖
        if (act.after && act.after !== lastAction?.action) continue;

        const func = funcMap[act.action];
        if (func) {
            const res = func(act.args);
            results.push({ action: act.action, ...res });
            lastAction = act;
        } else {
            results.push({ action: act.action, success: false, msg: "未知动作" });
        }
    }
    return results;
}

// ==================== 完整任务运行器 ====================
function runTask(taskConfig) {
    const preResults = [];
    let preData = {};

    // 执行前处理管道
    for (let preStep of taskConfig.prePipeline) {
        const [funcName, arg] = preStep.split(':');  // 支持参数
        const func = funcMap[funcName];
        if (!func) return { success: false, msg: `未知前处理: ${funcName}` };

        const res = func(arg?.trim());
        preResults.push({ step: funcName, ...res });
        if (!res.success) return { success: false, preResults };

        Object.assign(preData, res.data);  // 累积数据
    }

    // 决策生成 actions
    const actions = decideActions(preData, taskConfig.decisionRules);

    // 执行主要脚本
    const mainResults = runMain(actions);

    // 可选后处理（类似前处理）

    return { success: true, preResults, mainResults };
}

// ==================== 示例调用 ====================
const config = { /* 上面的 JSON 示例 */ };
const fullResult = runTask(config);
toastLog(JSON.stringify(fullResult, null, 2));  // 返回整个结果

如何解决你的具体问题

• 概率点赞/评论：全在前处理决策器里用 prob 处理，主要脚本不变。

• 评论后概率点赞：用 after: "commentVideo" 在规则里定义依赖顺序，主要脚本无需知道。

• 给评论评论：加新原子动作 replyToComment()，在规则里加 {action: "replyToComment", after: "commentVideo"}。

• 每种情况不用新前处理：所有任务共享同一管道和决策器，只改 config JSON（e.g., 不同任务有不同 rules）。

• 群控扩展：在群控主控端，用 JSON config 发给每个设备，设备运行 runTask(config) 返回结果。