登录

烧饼刮刮乐助手:自动买票刮开、面额张数可选、大奖停止

45716
  • 楼主 编辑于

    更新日志

    v1.2.0 (2026-11-16)

    修复切换浏览器标签后,自动买票和刮票暂停 的问题,新增默认开启的后台运行选项。


    刮刮乐目前每一批都要重复点买票、刮开,再继续买下一批,所以你就需要 烧饼刮刮乐助手,把这些重复操作自动完成。

    支持选择面额和每批张数,统计投入、返还与净额,也可以设置中了百倍大奖或饼王徽奖池后停止。

    当前版本:v1.1.0
    运行方式:浏览器安装 Tampermonkey(油猴)后使用
    适用页面:烧饼刮刮乐

    一、支持哪些功能?

    功能说明
    自动买票、刮开点击开始后,自动购买、刮开本批票,再继续下一批
    面额选择支持 10、25、50、100、200 游戏币
    每批张数选择支持一次购买 1、2、3、5、10 张同一面额的票
    购买参数同步助手面板与游戏页面的选项同步,并显示每批实际花费
    大奖停止百倍烤炉、饼王徽奖池可以分别勾选,命中后停止继续买票
    批次控制可设置批次间隔和批次上限,上限填 0 表示不限批次
    本轮统计显示购买批数、完成批数、完成张数、中奖张数、投入、返还和净额
    旧票处理页面恢复了未刮完的票时,先处理这些票
    悬浮窗支持拖动和收起,方便调整位置

    脚本负责自动执行页面操作,开奖结果和奖金以站点结算为准。

    二、怎么使用?

    默认批次间隔为 3 秒,批次上限为 10 批。间隔支持 2~60 秒,批次上限填 0 表示持续运行,直到手动停止、命中已勾选的停止条件,或遇到异常。

    批次上限按买票次数计算。 例如,每批 5 张、上限 10 批,正常完成时一共购买 50 张。

    运行过程中会锁定面额和张数。需要修改时,先停止并处理完当前批次,再调整参数重新开始。

    三、统计怎么看?

    面板会显示:

    • 新购批次、完成批次:分别表示本轮买下多少批、已经处理完成多少批。
    • 完成张数、中奖张数:统计已完成批次中的票数和有奖票数。
    • 投入、返还、净额:投入包含票价和抽成,返还按实际到账奖金累计,净额为返还减去投入。

    例如,选择 200 面额、每批 2 张:

    每批投入:412 游戏币
    
    如果一张中百倍,另一张没中:
    本批返还:20,000 游戏币
    本批净额:+19,588 游戏币
    

    金额统计以本轮已完成的新购批次为准。 正在处理的批次,会在完成后计入;补刮之前留下的旧票不计入本轮统计。

    “中奖张数” 包含 ×1 奖励,因此有奖不一定代表净赚。停止后再次点击 “开始”,会开启新一轮统计。

    四、“中奖停止” 如何生效?

    可以分别勾选:

    • 中了百倍烤炉停止
    • 中了饼王徽奖池停止

    命中条件后,助手会完成当前批次的刮开与统计,然后停止购买下一批。

    例如一次买了 10 张,其中一张中了目标奖项,其余票已经一起购买,仍会完成这一批的处理。希望按单张判断是否继续,可以把每批张数设为 1 张。

    五、使用时留意这几点

    • 选择面额和张数后,需要手动点击 “开始” 才会运行。
    • 页面切到后台时,助手会暂缓新操作;回到前台后,继续仍在运行的任务。
    • 余额不足、请求异常或页面状态无法识别时,助手会停止并显示原因。
    • 网站改版后,脚本可能需要重新适配。

    效果图

    image.webp

    // ==UserScript==
    // @name         烧饼刮刮乐助手
    // @namespace    https://sb.sb/
    // @version      1.2.0
    // @description  面额/张数选择、自动购买刮开、后台运行、统计和大奖停止
    // @match        https://sb.sb/games/scratch/*
    // @match        https://sb.sb/games/scratch
    // @run-at       document-start
    // @grant        none
    // @sandbox      raw
    // @noframes
    // ==/UserScript==
    
    /*
     * 安装:Tampermonkey 添加新脚本,替换全部内容并保存,然后刷新游戏页。
     * 使用:在助手中选择面额与每批张数,再点击“开始”。默认最多新购10批,间隔3秒。
     * 选项与原页面双向同步;运行中或当前票未处理完时锁定,停止且本批完成后可修改。
     * 0批表示不限批次;首次可设为1批检查。百倍/奖池停止默认勾选,可自行取消。
     * 统计:每次开始重置,只累计本轮新购且刮开确认完成的批次;补刮旧票不重复记账。
     * 停止:不再发起新的点击;游戏已经发出的请求、已经开始的动画仍可能完成。
     * 后台:暂停新操作,回前台继续;刷新、跳转或请求异常不会自动续跑。
     * 拖动标题可移动窗口;收起按钮保留可拖动的标题栏。
     */
    
    (() => {
      'use strict';
      if (window.top !== window.self || window.__SB_SCRATCH_V120__) return;
      window.__SB_SCRATCH_V120__ = true;
      const VERSION = '1.2.0';
      const STORE = 'sb-scratch-helper-settings-v1';
      const LOCK = 'sb-scratch-helper-running';
      const DEFAULTS = { interval: 3, maxBatches: 10, stopTop: true, stopPool: true, background: true };
      const nativeFetch = window.fetch;
      let config = { ...DEFAULTS };
      try {
        const saved = JSON.parse(localStorage.getItem(STORE) || '{}');
        for (const key of Object.keys(DEFAULTS)) if (key in saved) config[key] = saved[key];
      } catch (_) {}
      for (const key of ['stopTop', 'stopPool', 'background']) {
        if (typeof config[key] !== 'boolean') config[key] = DEFAULTS[key];
      }
      if (!(config.interval >= 2 && config.interval <= 60)) config.interval = 3;
      if (!Number.isInteger(config.maxBatches) || config.maxBatches < 0 || config.maxBatches > 100000) config.maxBatches = 10;
    
      let env = null, run = null, ui = null, host = null, worker = null;
      let workerReady = false, starting = false, epoch = 0, releaseLock = null;
      let busyTick = false, lastPulse = 0, runSerial = 0;
      const tidy = value => String(value ?? '').replace(/\s+/g, ' ').trim();
      const fmt = value => Number(value).toLocaleString('zh-CN');
      const integer = value => (typeof value === 'number' || (typeof value === 'string' && /^\d+$/.test(value))) &&
        Number.isSafeInteger(Number(value)) && Number(value) >= 0;
      const onPage = () => location.hostname === 'sb.sb' && /^\/games\/scratch\/?$/.test(location.pathname);
      const shown = element => !!element && !element.hidden && element.getClientRects().length > 0 &&
        getComputedStyle(element).display !== 'none' && getComputedStyle(element).visibility !== 'hidden';
      const blankStats = () => ({ bought: 0, completed: 0, tickets: 0, wins: 0, spent: 0, paid: 0 });
      function address(value) {
        const url = new URL(value, location.href);
        if (url.origin !== location.origin) throw new Error('游戏接口地址不匹配,请刷新页面。');
        url.hash = '';
        return url.href;
      }
      function status(message, error = false) {
        if (!ui) return;
        ui.status.textContent = message;
        ui.status.classList.toggle('error', error);
      }
      function log(message) {
        if (!ui) return;
        const line = document.createElement('div');
        line.textContent = new Date().toLocaleTimeString() + ' ' + message;
        ui.log.prepend(line);
        while (ui.log.children.length > 16) ui.log.lastElementChild.remove();
      }
      function progress() { if (run?.running) run.waitSince = Date.now(); }
      function stop(message, error = false) {
        epoch++;
        starting = false;
        const active = run?.running;
        if (run) run.running = false;
        if (releaseLock) { const release = releaseLock; releaseLock = null; release(); }
        status(message, error);
        if (active || error) log(message);
        draw();
      }
      function fault(context, message) {
        context.uncertain = true;
        if (env === context) stop(message + ';请刷新页面核实当前批次后再开始。', true);
      }
      function state() {
        if (!env?.main?.isConnected) return 'missing';
        const text = tidy(env.main.getAttribute('aria-label'));
        if (env.main.classList.contains('is-busy') || env.main.getAttribute('aria-busy') === 'true') return 'busy';
        if (/下一张/.test(text)) return 'next';
        if (/刮开/.test(text)) return 'reveal';
        if (/买\s*\d+\s*张/.test(text) && !env.form.classList.contains('is-batch')) return 'buy';
        return 'unknown';
      }
      function radios(name) { return Array.from(env?.form.querySelectorAll(`input[name="${name}"]`) || []); }
      function selected() {
        const bet = Number(env.form.querySelector('input[name="bet"]:checked')?.value);
        const count = Number(env.form.querySelector('input[name="n"]:checked')?.value);
        if (![10, 25, 50, 100, 200].includes(bet) || ![1, 2, 3, 5, 10].includes(count)) {
          throw new Error('请先选择有效面额和张数。');
        }
        return { bet, count };
      }
      function fee(bet) { return Math.floor(bet * env.rake / 100); }
      function cost(bet, count) { return (bet + fee(bet)) * count; }
      function coins() {
        for (const element of document.querySelectorAll('[data-wheel-coins]')) {
          const text = tidy(element.textContent).replace(/[,,]/g, '');
          if (/^\d+$/.test(text)) return Number(text);
        }
        return env.coins;
      }
      function acknowledged(record) {
        return record.status === 'settled' && record.tickets.length === record.count &&
          record.tickets.every(ticket => ticket.ack === 'ok');
      }
      function editable() {
        const r = env?.current;
        return !!env && !run?.running && !starting && !env.reading && !env.buying && state() === 'buy' &&
          (!r || r.finished || (acknowledged(r) && !r.polls));
      }
      function syncChoices() {
        if (!ui || !env) return;
        const canEdit = editable();
        for (const [name, field] of [['bet', ui.bet], ['n', ui.count]]) {
          const inputs = radios(name);
          if (field.options.length !== inputs.length || inputs.some((r, i) => field.options[i]?.value !== r.value)) {
            field.replaceChildren(...inputs.map(input => {
              const option = document.createElement('option');
              option.value = input.value;
              option.textContent = input.value + (name === 'bet' ? ' 游戏币' : ' 张');
              return option;
            }));
          }
          inputs.forEach((input, i) => { field.options[i].disabled = input.disabled; });
          const active = inputs.find(input => input.checked);
          if (active) field.value = active.value;
          field.disabled = !canEdit;
        }
      }
      function changeChoice(name, value) {
        if (!editable()) { syncChoices(); return; }
        const input = radios(name).find(item => item.value === value && !item.disabled);
        if (!input) { status('该选项当前不可用,请检查余额。', true); syncChoices(); return; }
        input.checked = true;
        input.dispatchEvent(new Event('change', { bubbles: true }));
        draw();
        status('购买参数已同步,点击开始运行。');
      }
      function draw() {
        if (!ui) return;
        syncChoices();
        const active = !!run?.running || starting;
        ui.start.disabled = active || !env || env.uncertain;
        ui.stop.disabled = !active;
        for (const key of Object.keys(DEFAULTS)) ui[key].disabled = active;
        const s = run?.stats || blankStats();
        ui.stats.textContent = `新购 ${s.bought} 批 · 完成 ${s.completed} 批\n` +
          `完成 ${s.tickets} 张 · 中奖 ${s.wins} 张\n投入 ${fmt(s.spent)} · 返还 ${fmt(s.paid)}\n` +
          `净额 ${s.paid - s.spent > 0 ? '+' : ''}${fmt(s.paid - s.spent)} 游戏币`;
        ui.clock.textContent = workerReady ? '后台计时已就绪' : '常规计时(后台可能变慢)';
        try {
          const plan = run?.running ? run : selected();
          ui.plan.textContent = `${plan.bet} 币 × ${plan.count} 张 · 每批 ${fmt(cost(plan.bet, plan.count))} 币(含抽成)`;
        } catch (_) { ui.plan.textContent = '等待游戏加载'; }
      }
    
      // 只临时启用原站已有的即时揭示分支,不伪造可见性或替换全站动画。
      function pageClick(button) {
        if (!button || button.disabled || !shown(button)) throw new Error('原页面按钮暂不可用。');
        const game = window.bbsGame;
        if (!game || typeof game.reduce !== 'boolean') throw new Error('未找到原站动画设置,请刷新页面。');
        const previous = game.reduce;
        try {
          game.reduce = true;
          if (game.reduce !== true) throw new Error('无法启用即时刮开,请刷新页面。');
          button.click();
        } finally { game.reduce = previous; }
      }
      function ticketKey(data) {
        return Array.isArray(data.tickets) ? data.tickets.map(t => String(t.id)).sort().join(',') : '';
      }
      function ingest(record, data) {
        if (!data || !['pending', 'settled'].includes(data.status)) throw new Error('开奖状态格式变化');
        if (Number(data.n) !== record.count || (data.bet != null && Number(data.bet) !== record.bet)) {
          throw new Error('批次面额或数量不一致');
        }
        if (record.status === 'settled' && data.status === 'pending') throw new Error('收到过期的未开奖响应');
        if (data.json_url && record.url && address(data.json_url) !== record.url) throw new Error('批次地址不一致');
        if (Number.isFinite(data.coins)) env.coins = data.coins;
        if (data.json_url) record.url = address(data.json_url);
        if (data.status === 'pending') {
          if (!record.url) throw new Error('缺少开奖查询地址');
          record.status = 'pending';
          return;
        }
        if (!Array.isArray(data.tickets) || data.tickets.length !== record.count) throw new Error('票据数量不一致');
        const ids = ticketKey(data);
        if (record.ids && record.ids !== ids) throw new Error('票号与当前批次不一致');
        const seen = new Set();
        const next = data.tickets.map(value => {
          const id = String(value.id ?? '');
          if (!/^\d+$/.test(id) || seen.has(id) || !integer(value.bet) || Number(value.bet) !== record.bet ||
              !integer(value.paid) || !Number.isInteger(value.symbol) || value.symbol < -1 || value.symbol > 8) {
            throw new Error('票据字段无法核实');
          }
          seen.add(id);
          const previous = record.tickets.find(t => t.id === id);
          const url = value.reveal_url ? address(value.reveal_url) : previous?.url || '';
          if (!value.revealed && !url) throw new Error('缺少刮开确认地址');
          if (previous && (previous.paid !== Number(value.paid) || previous.symbol !== value.symbol || previous.url !== url)) {
            throw new Error('同一票号的结算内容发生变化');
          }
          return { id, bet: Number(value.bet), paid: Number(value.paid), symbol: value.symbol, url,
            ack: previous?.ack || (value.revealed === true ? 'ok' : 'idle') };
        });
        // 保持票据对象身份,避免响应解析先后顺序让已发请求的ACK丢失。
        record.tickets = next.map(ticket => {
          const previous = record.tickets.find(t => t.id === ticket.id);
          return previous ? Object.assign(previous, ticket) : ticket;
        });
        if (new Set(record.tickets.filter(t => t.url).map(t => t.url)).size !== record.tickets.filter(t => t.url).length) {
          throw new Error('刮开确认地址重复');
        }
        const first = record.status !== 'settled';
        record.ids = ids;
        record.status = 'settled';
        if (first) { progress(); log(`开奖完成:${record.count} 张,等待刮开与确认。`); }
      }
      function adopt(data, owner = null) {
        const count = Number(data?.n), bet = Number(data?.bet ?? data?.tickets?.[0]?.bet);
        if (![1, 2, 3, 5, 10].includes(count) || ![10, 25, 50, 100, 200].includes(bet)) {
          throw new Error('购买批次参数不兼容');
        }
        if (owner && (owner.bet !== bet || owner.count !== count)) throw new Error('返回的购买参数与启动设置不同');
        const prior = env.current;
        const url = data.json_url ? address(data.json_url) : '';
        const ids = data.status === 'settled' ? ticketKey(data) : '';
        if (prior && ((url && prior.url === url) || (ids && prior.ids === ids))) {
          if (owner) throw new Error('购买响应重复返回已有批次');
          ingest(prior, data);
          return prior;
        }
        if (prior && !prior.finished && !acknowledged(prior)) throw new Error('上一批尚未确认完成');
        const record = { owner, count, bet, url, ids: '', status: '', tickets: [], polls: 0, finished: false };
        ingest(record, data);
        env.current = record;
        if (owner) { owner.stats.bought++; log(`已购买第 ${owner.stats.bought} 批:${bet} 币 × ${count} 张。`); }
        progress();
        draw();
        return record;
      }
    
      function route(context, input, options) {
        let url, method;
        try {
          url = address(typeof input === 'string' || input instanceof URL ? String(input) : input.url);
          method = String(options?.method || input?.method || 'GET').toUpperCase();
        } catch (_) { return null; }
        if (method === 'POST' && url === context.buyURL) return { type: 'buy', context, owner: context.expectedBuy };
        const record = context.current;
        if (!record) return null;
        if (method === 'GET' && record.url === url) return { type: 'poll', context, record };
        if (method === 'POST') {
          const ticket = record.tickets.find(t => t.url === url);
          if (ticket) return { type: 'reveal', context, record, ticket };
        }
        return null;
      }
      async function receive(mark, response) {
        const context = mark.context;
        if (!context.live || context !== env) return;
        if (!response.ok || response.redirected) throw new Error(`请求返回异常(HTTP ${response.status})`);
        const text = await response.clone().text();
        if (!context.live || context !== env) return;
        let data = null;
        if (text.trim()) {
          try { data = JSON.parse(text); }
          catch (_) {
            if (mark.type !== 'reveal' || /^\s*</.test(text)) {
              throw new Error('接口返回了无法识别的内容,可能需要重新登录');
            }
          }
        }
        if (data?.error || data?.success === false || data?.ok === false) {
          if (mark.type === 'buy' && ['pending', 'unscratched'].includes(data.code) && data.batch) {
            adopt(data.batch, null);
            log('恢复已有票据,不计为本轮新购。');
            return;
          }
          throw new Error(tidy(data?.error || data?.message || '服务器未确认请求').slice(0, 160));
        }
        if (mark.type === 'buy') {
          if (!data) throw new Error('购买响应为空');
          adopt(data, mark.owner || null);
        } else if (mark.type === 'poll') {
          if (context.current !== mark.record) throw new Error('收到旧批次的延迟响应');
          ingest(mark.record, data);
        } else {
          // 原站允许空正文的2xx,不能要求ACK一定带某个JSON字段。
          if (context.current !== mark.record) throw new Error('收到旧票的延迟确认');
          mark.ticket.ack = 'ok';
          progress();
        }
      }
      function observedFetch(input, options) {
        // 恢复旧票的首次查询可能早于DOMContentLoaded;请求发出前先建立观察上下文。
        if (onPage() && (!env?.live || !env.root.isConnected)) {
          try { attach(); } catch (error) { if (env) fault(env, error.message || '游戏初始化失败'); }
        }
        const context = env;
        const mark = context?.live ? route(context, input, options) : null;
        if (!mark) return Reflect.apply(nativeFetch, this, arguments);
        context.reading++;
        if (mark.type === 'buy') {
          context.buying++;
          context.expectedBuy = null;
          if (!mark.owner && run?.running) stop('检测到手动购票,本轮自动运行已停止。');
        } else if (mark.type === 'poll') mark.record.polls++;
        else {
          if (mark.ticket.ack !== 'idle') fault(context, '检测到重复的刮开请求');
          mark.ticket.ack = 'pending';
        }
        const finish = () => {
          context.reading--;
          if (mark.type === 'buy') context.buying--;
          if (mark.type === 'poll') mark.record.polls--;
          draw();
        };
        let promise;
        try { promise = Reflect.apply(nativeFetch, this, arguments); }
        catch (error) { fault(context, '请求未能发出'); finish(); throw error; }
        Promise.resolve(promise).then(response => receive(mark, response)).catch(error => {
          if (mark.ticket) mark.ticket.ack = 'error';
          if (context.live) fault(context, '请求结果不确定:' + tidy(error.message || error));
        }).finally(finish);
        return promise;
      }
      window.fetch = observedFetch;
    
      function complete(record) {
        if (record.finished) return;
        record.finished = true;
        if (record.owner === run) {
          const s = run.stats;
          s.completed++;
          s.tickets += record.tickets.length;
          s.wins += record.tickets.filter(t => t.symbol >= 0).length;
          s.spent += record.tickets.reduce((sum, t) => sum + t.bet + fee(t.bet), 0);
          s.paid += record.tickets.reduce((sum, t) => sum + t.paid, 0);
          log(`第 ${s.completed} 批完成,累计净额 ${fmt(s.paid - s.spent)} 币。`);
        } else log('旧票处理完成,不计入本轮统计。');
        run.nextBuyAt = Date.now() + run.interval * 1000;
        progress();
        if (run.stopPool && record.tickets.some(t => t.symbol === 8)) stop('中了饼王徽奖池,已停止购买下一批。');
        else if (run.stopTop && record.tickets.some(t => t.symbol === 7)) stop('中了百倍烤炉,已停止购买下一批。');
        else if (run.maxBatches && run.stats.bought >= run.maxBatches) stop('已完成设定批次。');
        draw();
      }
      function step() {
        if (!run?.running) return;
        if (!env?.live || !onPage() || !env.root.isConnected) { stop('已离开刮刮乐页面。'); return; }
        if (window.fetch !== observedFetch) { fault(env, '请求观察器被其他脚本替换'); return; }
        if (env.uncertain) { stop('上次请求结果不确定,请刷新后再开始。', true); return; }
        if (document.hidden && !run.background) {
          run.hiddenPaused = true;
          status('已暂停:允许后台运行未勾选。');
          return;
        }
        if (run.hiddenPaused) { run.hiddenPaused = false; progress(); }
        const now = Date.now();
        const limit = document.hidden ? 600000 : 120000;
        if (now - run.waitSince > limit) { fault(env, '等待当前批次超时'); return; }
        if (env.reading || env.buying) { status('等待请求确认…'); return; }
        const record = env.current;
        const view = state();
        if (record && !record.finished) {
          if (record.status === 'pending') { status('等待原站开奖…'); return; }
          if (acknowledged(record) && view === 'buy' && !record.polls) { complete(record); return; }
          if (record.tickets.some(t => t.ack === 'error')) { fault(env, '刮开确认失败'); return; }
          if (record.tickets.some(t => t.ack === 'pending') || record.polls) { status('等待全部票据确认…'); return; }
          if (view === 'reveal' || view === 'next') {
            if (now - run.lastAction < 500) return;
            run.lastAction = now;
            status('正在即时刮开本批票…');
            pageClick(shown(env.all) && !env.all.disabled ? env.all : env.main);
            progress();
            return;
          }
          status(view === 'busy' ? '等待游戏处理本批票…' : '等待刮开完成确认…');
          return;
        }
        if (view !== 'buy') { status('等待游戏进入可购票状态…'); return; }
        if (run.maxBatches && run.stats.bought >= run.maxBatches) { stop('已达到设定批次上限。'); return; }
        const plan = selected();
        if (plan.bet !== run.bet || plan.count !== run.count) { stop('页面购买参数发生变化,已停止,请重新选择。', true); return; }
        if (env.main.disabled || !env.open) { stop('当前暂停售票。', true); return; }
        if (coins() < cost(run.bet, run.count)) { stop('余额不足以购买设定面额和张数,已停止。'); return; }
        if (now < run.nextBuyAt) {
          status(`下批倒计时 ${Math.ceil((run.nextBuyAt - now) / 1000)} 秒${document.hidden ? ' · 后台运行中' : ''}`);
          return;
        }
        env.expectedBuy = run;
        run.lastAction = now;
        status('正在购买下一批…');
        pageClick(env.main);
        if (env.expectedBuy) {
          env.expectedBuy = null;
          throw new Error('原页面没有发出购票请求,请检查页面提示。');
        }
        progress();
      }
      function readSettings() {
        const interval = Number(ui.interval.value), maxBatches = Number(ui.maxBatches.value);
        if (!Number.isFinite(interval) || interval < 2 || interval > 60) throw new Error('批次间隔请填2~60秒。');
        if (!Number.isInteger(maxBatches) || maxBatches < 0 || maxBatches > 100000) throw new Error('批次上限请填0~100000的整数。');
        return { interval, maxBatches, stopTop: ui.stopTop.checked, stopPool: ui.stopPool.checked, background: ui.background.checked };
      }
      function begin() {
        if (!env?.live || env.uncertain || env.reading || env.buying || window.fetch !== observedFetch) {
          throw new Error('页面尚未就绪,或上一请求未核实,请刷新页面后再开始。');
        }
        const plan = selected();
        const settings = readSettings();
        if (!window.bbsGame || typeof window.bbsGame.reduce !== 'boolean') throw new Error('原站脚本尚未加载完成。');
        config = settings;
        try { localStorage.setItem(STORE, JSON.stringify(config)); } catch (_) {}
        run = { ...settings, ...plan, id: ++runSerial, running: true, stats: blankStats(),
          waitSince: Date.now(), nextBuyAt: Date.now(), lastAction: 0, hiddenPaused: false };
        status('已开始,等待处理当前页面。');
        log(`开始:${plan.bet} 币 × ${plan.count} 张;后台运行${settings.background ? '开启' : '关闭'}。`);
        draw();
      }
      async function start() {
        if (starting || run?.running) return;
        if (!navigator.locks?.request) { status('此浏览器缺少运行锁,请使用新版Chrome、Edge或Firefox。', true); return; }
        const token = ++epoch;
        starting = true;
        draw();
        try {
          await navigator.locks.request(LOCK, { ifAvailable: true }, async lock => {
            if (token !== epoch) return;
            if (!lock) { status('另一个标签页正在运行助手,请先停止那一页。', true); return; }
            let resolve;
            const held = new Promise(done => { resolve = done; });
            releaseLock = resolve;
            begin();
            starting = false;
            draw();
            await held;
          });
        } catch (error) { if (token === epoch) stop(error.message || '启动失败', true); }
        finally { if (token === epoch) { starting = false; draw(); } }
      }
    
      function mount() {
        if (host?.isConnected) return;
        host = document.createElement('div');
        host.id = 'sb-scratch-helper-v120';
        host.style.cssText = 'position:fixed;right:18px;top:84px;z-index:2147483000;font:13px/1.55 system-ui,sans-serif;';
        const shadow = host.attachShadow({ mode: 'open' });
        shadow.innerHTML = `<style>
          *{box-sizing:border-box}section{width:320px;max-width:calc(100vw - 16px);color:#f1eee5;background:#191b20;border:1px solid #8a7040;border-radius:12px;box-shadow:0 8px 32px #0006;overflow:hidden}
          header{padding:10px 12px;background:#29251d;display:flex;align-items:center;justify-content:space-between;cursor:move;touch-action:none;user-select:none}
          header strong{color:#f5cb79;font-size:14px}header button{width:28px;padding:2px}.body{padding:12px}.row{display:grid;grid-template-columns:1fr 1fr;gap:10px;margin-bottom:8px}
          label{display:block}select,input[type=number]{width:100%;padding:6px;margin-top:3px;color:#fff;background:#292c33;border:1px solid #555b68;border-radius:6px;font:inherit}
          .check{margin:7px 0}.check input{accent-color:#d9a846;vertical-align:middle}button{padding:8px 12px;border:0;border-radius:6px;background:#3c4350;color:#fff;cursor:pointer;font:inherit}
          button:disabled,select:disabled,input:disabled{opacity:.5;cursor:default}.actions{display:flex;gap:8px;margin:11px 0}.actions button{flex:1}#start{background:#a67820}
          #plan{color:#ffd58c;margin:8px 0}#status{padding:7px;background:#252a33;border-radius:6px;overflow-wrap:anywhere}.error{color:#ffaaa1}#stats{white-space:pre-line;margin:10px 0;font-variant-numeric:tabular-nums}
          .small{color:#aeb4be;font-size:11px}.log{max-height:115px;overflow:auto;font-size:11px;color:#b7beca;overflow-wrap:anywhere}summary{cursor:pointer;color:#b7beca}[hidden]{display:none!important}
        </style><section><header><strong>刮刮乐助手 v${VERSION}</strong><button id="collapse" title="收起">−</button></header><div class="body">
          <div class="row"><label>面额<select id="bet"></select></label><label>每批张数<select id="count"></select></label></div>
          <div class="row"><label>批次间隔(秒)<input id="interval" type="number" min="2" max="60"></label><label>批次上限(0不限)<input id="maxBatches" type="number" min="0" max="100000"></label></div>
          <label class="check"><input id="background" type="checkbox"> 允许后台运行(自动刮开跳过动画)</label>
          <label class="check"><input id="stopTop" type="checkbox"> 中百倍烤炉后停止</label>
          <label class="check"><input id="stopPool" type="checkbox"> 中饼王徽奖池后停止</label>
          <div id="plan"></div><div class="actions"><button id="start">开始</button><button id="stop" disabled>停止</button></div>
          <div id="status">等待游戏加载…</div><div id="stats"></div>
          <div class="small">金额按本轮已完成的新购批次统计,含抽成;旧票不计入。再次开始会重新统计。</div>
          <div class="small" id="clock"></div><details><summary>运行记录</summary><div class="log" id="log"></div></details>
        </div></section>`;
        const pick = id => shadow.getElementById(id);
        ui = Object.fromEntries(['bet', 'count', 'interval', 'maxBatches', 'background', 'stopTop', 'stopPool', 'start', 'stop', 'plan', 'status', 'stats', 'clock', 'log'].map(id => [id, pick(id)]));
        ui.interval.value = config.interval;
        ui.maxBatches.value = config.maxBatches;
        for (const key of ['background', 'stopTop', 'stopPool']) ui[key].checked = config[key];
        ui.bet.addEventListener('change', () => changeChoice('bet', ui.bet.value));
        ui.count.addEventListener('change', () => changeChoice('n', ui.count.value));
        ui.start.addEventListener('click', start);
        ui.stop.addEventListener('click', () => stop('已手动停止;已发出的本批请求仍会完成。'));
        const body = shadow.querySelector('.body');
        pick('collapse').addEventListener('click', () => { body.hidden = !body.hidden; pick('collapse').textContent = body.hidden ? '+' : '−'; });
        let drag = null;
        const header = shadow.querySelector('header');
        header.addEventListener('pointerdown', event => {
          if (event.button !== 0 || event.target.closest('button')) return;
          const rect = host.getBoundingClientRect();
          drag = { x: event.clientX - rect.left, y: event.clientY - rect.top };
          header.setPointerCapture(event.pointerId);
          event.preventDefault();
        });
        header.addEventListener('pointermove', event => {
          if (!drag) return;
          host.style.right = 'auto';
          host.style.left = Math.max(4, Math.min(innerWidth - host.offsetWidth - 4, event.clientX - drag.x)) + 'px';
          host.style.top = Math.max(4, Math.min(innerHeight - 45, event.clientY - drag.y)) + 'px';
        });
        for (const type of ['pointerup', 'pointercancel', 'lostpointercapture']) header.addEventListener(type, () => { drag = null; });
        (document.body || document.documentElement).append(host);
      }
      function attach() {
        if (!onPage()) return;
        const node = document.getElementById('scratch-config');
        const root = document.querySelector('[data-sc]');
        if (!node || !root || !window.bbsGame) return;
        if (env?.root === root && env.live) return;
        if (env) { env.live = false; stop('游戏页面重新加载,请重新开始。'); }
        const data = JSON.parse(node.textContent);
        const form = root.querySelector('[data-sc-form]');
        const main = root.querySelector('[data-sc-buy]');
        if (!data.init || !data.buy || !form || !main) return;
        const rake = Number(form.getAttribute('data-rake-pct'));
        if (!Number.isFinite(rake) || rake < 0 || rake > 100) throw new Error('无法读取抽成比例');
        env = { root, form, main, all: root.querySelector('[data-sc-all]'), live: true, rake,
          buyURL: address(data.buy), coins: Number(data.init.coins), open: !!data.init.on,
          current: null, reading: 0, buying: 0, expectedBuy: null, uncertain: false };
        if (data.init.open) adopt(data.init.open, null);
        form.addEventListener('change', () => queueMicrotask(draw));
        mount();
        status('已就绪。选择参数后点击开始;默认允许后台运行。');
        draw();
      }
      function pulse() {
        const now = Date.now();
        if (busyTick || now - lastPulse < 250) return;
        const gap = now - lastPulse;
        lastPulse = now;
        busyTick = true;
        try {
          if (!onPage()) { if (run?.running) stop('已离开刮刮乐页面。'); return; }
          attach();
          if (!ui && document.body) mount();
          // 恢复调度后只检查当前状态,不补发积压的操作,也不把休眠时间算作网络等待。
          if (run?.running && gap > 10000) run.waitSince = now;
          step();
          draw();
        } catch (error) {
          if (env) fault(env, error.message || '页面处理异常');
          else status(error.message || '等待页面加载', true);
        } finally { busyTick = false; }
      }
      function startClock() {
        setInterval(pulse, 1000); // Worker不可用时仍保留常规调度。
        try {
          const url = URL.createObjectURL(new Blob([
            "setInterval(()=>postMessage('tick'),500);postMessage('ready');"
          ], { type: 'text/javascript' }));
          try { worker = new Worker(url); }
          finally { URL.revokeObjectURL(url); }
          worker.onmessage = () => { workerReady = true; pulse(); };
          worker.onerror = () => { workerReady = false; worker?.terminate(); worker = null; draw(); };
        } catch (_) { workerReady = false; }
      }
      document.addEventListener('visibilitychange', () => {
        if (run?.running && !document.hidden) progress();
        pulse();
      });
      document.addEventListener('DOMContentLoaded', pulse);
      window.addEventListener('pagehide', () => stop('页面已离开,自动运行已停止。'));
      window.addEventListener('pageshow', pulse);
      startClock();
      pulse();
    })();
    
    收藏支持 1反对打赏 1
    个性签名

    学习的能力和方法比知识本身更重要

1 人打赏,共 8 饼 心上人 8

16 条回复

发表回复