登录

分享个【炸金花】的小工具

826
  • 楼主

    核心不是教你赢,是帮你复盘上一局手牌——抓鸡抓菜鸡。

    每局结束自动读记录页,把上一局各家手牌、输赢常显在面板下方。谁拿散牌诈鸡、谁的顺子被吓跑,一看就能对上号。

    左上角手牌胜率:看牌后给出这手牌全场最大的概率(只算还在场的),未看牌时按人数均分。

    吃闷有点用:明牌吃唯一闷家、开牌要 800、底注有 2000,不计沉没成本,门槛就是 800÷2800≈28.6%,过线就开。

    赢人机上限时,那行会标金色「上限」徽标。

    只读页面已有信息,不改游戏、不自动操作。装 Tampermonkey 拖进浏览器即可。概率按 “对手手牌随机” 算,仅供参考。
    image.webp

    // ==UserScript==
    // @name         炸金花 · 手牌最大概率
    // @namespace    https://sb.sb/games/gold-flower/
    // @version      1.6.1
    // @description  常显面板:给出自己手牌为全桌最大的概率(未看牌按人数、弃牌归零、赢牌 100%);每局结束自动读取「验证」记录页,常显上一局各家手牌与输赢
    // @match        https://sb.sb/games/gold-flower/*
    // @match        https://*.sb.sb/games/gold-flower/*
    // @run-at       document-idle
    // @grant        none
    // ==/UserScript==
    
    (function () {
      'use strict';
      if (window.__ZJH_PROB_V2__) return;
      window.__ZJH_PROB_V2__ = true;
    
      /*<<CORE>>*/
      /* ================= 牌型核心(纯逻辑,可单独测试) ================= */
    
      var SUITS = ['黑桃', '红桃', '梅花', '方块'];
      var SUIT_CHARS = ['\u2660', '\u2665', '\u2663', '\u2666'];
      var CAT_NAMES = ['散牌', '对子', '顺子', '金花', '顺金', '豹子'];
    
      // 站点编码:id 0..51
      //   花色 = id % 4  →  黑桃0 红桃1 梅花2 方块3
      //   点数 = floor(id/4) + 3  →  3..14 表示 3..A,15 表示 2
      function cardFromId(id) {
        var r = Math.floor(id / 4) + 3;
        return { v: r === 15 ? 2 : r, s: id % 4 };
      }
    
      // 顺子强度表(索引越大越强):234 < 345 < ... < JQK < A23 < QKA
      // 注意 K A 2 不是顺子(不在表内)
      var STRAIGHT_KEY = (function () {
        var order = [
          [2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10],
          [9, 10, 11], [10, 11, 12], [11, 12, 13], [2, 3, 14], [12, 13, 14]
        ];
        var m = {};
        for (var i = 0; i < order.length; i++) {
          var t = order[i];
          m[t[0] * 256 + t[1] * 16 + t[2]] = i;
        }
        return m;
      })();
    
      // 把三张牌压成一个整数,越大越强,直接比大小即可
      // cat: 5 豹子 / 4 顺金 / 3 金花 / 2 顺子 / 1 对子 / 0 散牌
      function evalThree(v0, s0, v1, s1, v2, s2) {
        var x = v0, y = v1, z = v2, t;
        if (x < y) { t = x; x = y; y = t; }
        if (y < z) { t = y; y = z; z = t; }
        if (x < y) { t = x; x = y; y = t; }
        // 现在 x >= y >= z
        var flush = (s0 === s1 && s1 === s2);
        var seq = STRAIGHT_KEY[z * 256 + y * 16 + x];
    
        if (x === z) return 5 * 4096 + x * 256;                            // 豹子
        if (seq !== undefined) return (flush ? 4 : 2) * 4096 + seq * 256;  // 顺金 / 顺子
        if (flush) return 3 * 4096 + x * 256 + y * 16 + z;                 // 金花
        if (x === y || y === z) {                                          // 对子
          var pv = (x === y) ? x : y;
          var kk = (x === y) ? z : x;
          return 1 * 4096 + pv * 256 + kk * 16;
        }
        return x * 256 + y * 16 + z;                                       // 散牌
      }
    
      function catOf(key) { return Math.floor(key / 4096); }
    
      // 52 张牌的值 / 花色查表
      var DV = new Int8Array(52), DS = new Int8Array(52);
      (function () {
        for (var i = 0; i < 52; i++) {
          var c = cardFromId(i);
          DV[i] = c.v; DS[i] = c.s;
        }
      })();
    
      // 去掉自己的三张牌,剩 49 张
      function remaining(myCards) {
        var out = [];
        for (var i = 0; i < 52; i++) {
          var dup = false;
          for (var j = 0; j < myCards.length; j++) {
            if (myCards[j].v === DV[i] && myCards[j].s === DS[i]) { dup = true; break; }
          }
          if (!dup) out.push(i);
        }
        return out;
      }
    
      // 精确枚举:只有一个对手时,遍历 C(49,3) = 18424 种手牌
      function exactOne(myKey, deck) {
        var worse = 0, total = 0, n = deck.length;
        for (var i = 0; i < n - 2; i++) {
          var a = deck[i];
          for (var j = i + 1; j < n - 1; j++) {
            var b = deck[j];
            for (var k = j + 1; k < n; k++) {
              var c = deck[k];
              total++;
              if (evalThree(DV[a], DS[a], DV[b], DS[b], DV[c], DS[c]) < myKey) worse++;
            }
          }
        }
        return worse / total;
      }
    
      // 确定性随机数,保证同一手牌每次算出的结果一致(不会跳数)
      function mulberry32(a) {
        return function () {
          a = (a + 0x6D2B79F5) | 0;
          var t = Math.imul(a ^ (a >>> 15), 1 | a);
          t = (t + Math.imul(t ^ (t >>> 7), 61 | t)) ^ t;
          return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
        };
      }
    
      function hashStr(s) {
        var h = 2166136261;
        for (var i = 0; i < s.length; i++) {
          h ^= s.charCodeAt(i);
          h = Math.imul(h, 16777619);
        }
        return h >>> 0;
      }
    
      // 蒙特卡洛:从 49 张里不放回地发出 nLive 手牌,统计自己是否最大
      // 前 nBlind 个对手视作「闷牌」,顺便统计只和闷牌对手比较时的概率
      function simulate(myKey, deck, nLive, nBlind, trials, seed) {
        var n = deck.length, need = nLive * 3;
        var pk = deck.slice();
        var rnd = mulberry32(seed >>> 0);
        var winAll = 0, winBlind = 0;
        for (var t = 0; t < trials; t++) {
          for (var i = 0; i < need; i++) {
            var j = i + ((rnd() * (n - i)) | 0);
            var tmp = pk[i]; pk[i] = pk[j]; pk[j] = tmp;
          }
          var okAll = true, okBlind = true;
          for (var h = 0; h < nLive; h++) {
            var a = pk[3 * h], b = pk[3 * h + 1], c = pk[3 * h + 2];
            if (evalThree(DV[a], DS[a], DV[b], DS[b], DV[c], DS[c]) >= myKey) {
              okAll = false;
              if (h < nBlind) okBlind = false;
              break;
            }
          }
          if (okAll) winAll++;
          if (okBlind) winBlind++;
        }
        return { all: winAll / trials, blind: nBlind ? winBlind / trials : 1 };
      }
      /*<</CORE>>*/
    
      /* ================= 参数 ================= */
      var TRIALS = 40000;          // 对手 >= 2 人时的模拟次数
      var MAX_CACHE = 200;
      var PANEL_W = 264;           // 与样式里 .panel 的 width 保持一致
    
      /* ================= DOM 读取 ================= */
      function txt(el) { return el ? (el.textContent || '').trim() : ''; }
      function q(sel, root) { return (root || document).querySelector(sel); }
      function qa(sel, root) {
        return Array.prototype.slice.call((root || document).querySelectorAll(sel));
      }
    
      function parseCardEl(el) {
        var id = el.getAttribute('data-id');
        if (id != null && id !== '' && !isNaN(+id)) return cardFromId(+id);
        var label = el.getAttribute('aria-label') || '';
        for (var i = 0; i < 4; i++) {
          if (label.indexOf(SUITS[i]) === 0) {
            var t = label.slice(2).trim();
            var v = t === 'A' ? 14 : t === 'K' ? 13 : t === 'Q' ? 12 : t === 'J' ? 11 : parseInt(t, 10);
            if (v >= 2 && v <= 14) return { v: v, s: i };
            return null;
          }
        }
        return null;
      }
    
      function readState() {
        var table = q('[data-gf-table]');
        if (!table) return null;
        var meSeat = q('[data-gf-seat="me"]', table);
        if (!meSeat) return null;
    
        var cards = [];
        qa('.gf-cards .ddz-card', meSeat).forEach(function (el) {
          if (el.classList.contains('is-back')) return;
          var c = parseCardEl(el);
          if (c) cards.push(c);
        });
    
        var seats = qa('[data-gf-seat]', table);
        var dealt = seats.some(function (s) { return qa('.gf-cards .ddz-card', s).length >= 3; });
    
        var nBlind = 0, nSeen = 0, folded = 0;
        seats.forEach(function (seat) {
          if (seat.getAttribute('data-gf-seat') === 'me') return;
          if (seat.classList.contains('is-empty')) return;
          if (dealt && qa('.gf-cards .ddz-card', seat).length < 3) return;   // 本局没发到牌
          if (seat.classList.contains('is-out')) { folded++; return; }
          // 是否看过牌:优先看座位 class,其次看标签文字(“看过牌” / “闷牌”)
          var seen = seat.classList.contains('is-seen') || txt(q('.gf-seen', seat)) === '看过牌';
          if (seen) nSeen++;
          else nBlind++;
        });
    
        var selfSeen = cards.length === 3;
        return {
          cards: cards,
          seen: selfSeen,
          meName: txt(q('.ddz-name', meSeat)) || txt(q('.uname', meSeat)),
          out: meSeat.classList.contains('is-out'),
          win: meSeat.classList.contains('is-winner'),
          settled: !!q('[data-gf-actions] [aria-label="再来一把"]', table),
          nLive: nBlind + nSeen,
          nBlind: nBlind,
          nSeen: nSeen,
          folded: folded
        };
      }
    
      /* ================= 计算 ================= */
      var cache = new Map();
    
      function analyze(st) {
        var c = st.cards;
        var myKey = evalThree(c[0].v, c[0].s, c[1].v, c[1].s, c[2].v, c[2].s);
        var handKey = c.map(function (x) { return x.v * 4 + x.s; }).sort(function (a, b) { return a - b; }).join(',');
        var sig = handKey + '|' + st.nLive + '|' + st.nBlind;
    
        var hit = cache.get(sig);
        if (hit) return hit;
    
        var res;
        if (st.nLive === 0) {
          res = { all: 1, blind: 1, exact: true };
        } else if (st.nLive === 1) {
          var p = exactOne(myKey, remaining(c));
          res = { all: p, blind: p, exact: true };
        } else {
          // 随机种子只跟手牌和对手人数有关:换个「闷/看」组合时主概率不会跳数
          var r = simulate(myKey, remaining(c), st.nLive, st.nBlind, TRIALS,
            hashStr(handKey + '|' + st.nLive));
          res = { all: r.all, blind: r.blind, exact: false };
        }
        res.key = myKey;
        res.cat = catOf(myKey);
    
        if (cache.size > MAX_CACHE) cache.clear();
        cache.set(sig, res);
        return res;
      }
    
      /* ================= 上一局手牌(读 /verify/<局号>/ 记录页) ================= */
      // 结算后页面顶部「验证」按钮的 href 就是本局记录页,里面含每一家的手牌
      var LS_LAST = 'zjh-last-hand-v1';
      var LS_LAST_CLOSED = 'zjh-last-hand-closed-v1';
      var VERIFY_RE = /\/verify\/(\d+)/;
    
      var lastRec = loadJSON(LS_LAST) || null;      // { id, url, rows, ts }
      var lastClosed = !!loadJSON(LS_LAST_CLOSED);
      var lastJob = { id: null, loading: false, error: '', url: '', tries: 0 };
    
      function handIdOf(url) {
        var m = String(url || '').match(VERIFY_RE);
        return m ? m[1] : null;
      }
    
      function esc(s) {
        return String(s == null ? '' : s).replace(/[&<>"]/g, function (ch) {
          return { '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;' }[ch];
        });
      }
    
      function rankShort(v) {
        return v === 14 ? 'A' : v === 13 ? 'K' : v === 12 ? 'Q' : v === 11 ? 'J' : String(v);
      }
    
      // 记录页的牌用 title="红桃Q" 标注,比读文字更稳
      function titleCard(t) {
        for (var i = 0; i < 4; i++) {
          if (t.indexOf(SUITS[i]) === 0) {
            var r = t.slice(2).trim();
            var v = r === 'A' ? 14 : r === 'K' ? 13 : r === 'Q' ? 12 : r === 'J' ? 11 : parseInt(r, 10);
            return (v >= 2 && v <= 14) ? { v: v, s: i } : null;
          }
        }
        return null;
      }
    
      // 只取单元格自身的文字,避开 <small> 的备注(例如「到了每日上限,少算 10700」)
      function cellOwnText(td) {
        if (!td) return '';
        var n = td.firstChild;
        if (n && n.nodeType === 3 && n.nodeValue.trim()) return n.nodeValue.trim();
        return txt(td);
      }
    
      function playerName(td) {
        if (!td) return '\u2014';
        var bot = td.querySelector('.ddz-bot-name');
        if (bot) {
          var s = '';
          for (var i = 0; i < bot.childNodes.length; i++) {
            if (bot.childNodes[i].nodeType === 3) s += bot.childNodes[i].nodeValue;
          }
          if (s.trim()) return s.trim();
        }
        return txt(td.querySelector('.uname') || td.querySelector('.top-name')) || '\u2014';
      }
    
      function parseRecord(html) {
        var doc = new DOMParser().parseFromString(html, 'text/html');
        var table = doc.querySelector('table.gf-rec') || doc.querySelector('table.ddz-rec') ||
          doc.querySelector('table.points-ledger') || doc.querySelector('table');
        if (!table) return [];
        var rows = [];
        qa('tr', table).forEach(function (tr) {
          var tds = tr.children;
          if (!tds || tds.length < 4 || tr.querySelector('th')) return;
          var cards = [];
          qa('.ddz-chips .ddz-chip', tr).forEach(function (el) {
            var c = titleCard(el.getAttribute('title') || '');
            if (c) cards.push(c);
          });
          if (cards.length !== 3) return;                  // 没发到牌的行
          cards.sort(function (a, b) { return b.v - a.v; });
          // 「结果」格里偶尔会跟一句「到了每日上限,少算 10700」,单独拎出来标在行里
          var resCell = tds[7];
          var resFull = txt(resCell).replace(/\s+/g, ' ').trim();
          rows.push({
            seat: txt(tds[0]).replace(/\s+/g, '').replace(/号$/, ''),
            name: playerName(tds[1]),
            cards: cards,
            seen: txt(tds[4]) === '看过',
            result: cellOwnText(resCell),
            capNote: /上限/.test(resFull) ? resFull.replace(/^赢\s*/, '').trim() : '',
            delta: txt(tr.querySelector('.ddz-delta')),
            win: !!tr.querySelector('.ddz-delta.is-win')
          });
        });
        return rows;
      }
    
      function loadHand(url, id) {
        if (lastJob.loading) return;
        lastJob = { id: id, loading: true, error: '', url: url, tries: 0 };
        renderLast();
        fetch(url, { credentials: 'same-origin', headers: { Accept: 'text/html' } })
          .then(function (r) {
            if (!r.ok) throw new Error('HTTP ' + r.status);
            return r.text();
          })
          .then(function (html) {
            var rows = parseRecord(html);
            if (!rows.length) throw new Error('EMPTY');
            lastRec = { id: id, url: url, rows: rows, ts: Date.now() };
            saveJSON(LS_LAST, lastRec);
            lastJob = { id: id, loading: false, error: '', url: url, tries: 0 };
            renderLast();
          })
          .catch(function (e) {
            var msg = (e && e.message) || '读取失败';
            // 记录页可能比结算晚几秒写入,空表时重试两次
            if (msg === 'EMPTY' && lastJob.tries < 2) {
              var tries = lastJob.tries + 1;
              lastJob = { id: id, loading: true, error: '', url: url, tries: tries };
              setTimeout(function () { loadHand(url, id); }, 1500 * tries);
              return;
            }
            lastJob = { id: id, loading: false, error: msg === 'EMPTY' ? '记录还没生成' : msg, url: url, tries: lastJob.tries };
            renderLast();
          });
      }
    
      /* ================= 面板 ================= */
      var CSS = [
        ':host{all:initial}',
        '.panel{width:264px;font:12px/1.5 -apple-system,BlinkMacSystemFont,"Segoe UI","Microsoft YaHei",sans-serif;',
        'color:#f3f6fc;background:linear-gradient(165deg,rgba(26,30,44,.97),rgba(13,16,24,.98));',
        'border:1px solid rgba(255,255,255,.13);border-radius:13px;overflow:hidden;',
        'box-shadow:0 12px 34px rgba(0,0,0,.5),inset 0 1px 0 rgba(255,255,255,.07);',
        'backdrop-filter:blur(10px);-webkit-backdrop-filter:blur(10px);user-select:none}',
        '.bar{display:flex;align-items:center;gap:6px;padding:7px 9px;background:rgba(255,255,255,.055);cursor:move}',
        '.dot{width:6px;height:6px;border-radius:50%;background:#f2c96b;box-shadow:0 0 8px rgba(242,201,107,.9);flex:none}',
        '.ttl{flex:1;font-size:11px;letter-spacing:.6px;color:#e9d9ab;font-weight:600}',
        '.mini{border:0;background:transparent;color:#6d768a;font-size:13px;line-height:1;cursor:pointer;padding:0 2px}',
        '.mini:hover{color:#f3f6fc}',
        '.body{padding:11px 10px 10px}',
        '.pct{display:flex;align-items:baseline;gap:2px}',
        '.pct b{flex:none;font-size:31px;font-weight:800;letter-spacing:-1.2px;line-height:1;font-variant-numeric:tabular-nums}',
        '.pct i{flex:none;font-style:normal;font-size:12px;opacity:.7}',
        '.track{height:3px;border-radius:2px;background:rgba(255,255,255,.1);margin:7px 0 0;overflow:hidden}',
        '.fill{height:100%;width:0;border-radius:2px;transition:width .28s ease,background .28s ease}',
        /* --- 上一局手牌 --- */
        '.last{border-top:1px solid rgba(255,255,255,.08);background:rgba(255,255,255,.018)}',
        '.last-head{display:flex;align-items:center;gap:6px;padding:5px 10px 4px}',
        '.lt{flex:1;min-width:0;font-size:10px;color:#9aa5ba;text-decoration:none;overflow:hidden;',
        'text-overflow:ellipsis;white-space:nowrap;cursor:pointer}',
        '.lt b{color:#e9d9ab;font-weight:700}',
        '.lt:hover{color:#f3f6fc}',
        '.lfold{border:0;background:transparent;color:#6d768a;font-size:10px;line-height:1;padding:0 2px;cursor:pointer;',
        'transition:transform .18s ease}',
        '.lfold:hover{color:#f3f6fc}',
        '.last.closed .lfold{transform:rotate(-90deg)}',
        '.last.closed .last-body{display:none}',
        '.last-body{padding:0 10px 7px;display:flex;flex-direction:column;gap:3px}',
        '.hrow{display:flex;align-items:baseline;gap:5px;font-size:11px;line-height:1.5}',
        '.hseat{flex:none;width:15px;color:#6b7488;font-variant-numeric:tabular-nums}',
        '.hrow.is-me .hseat{color:#f2c96b;font-weight:700}',
        '.hname{flex:1 1 auto;min-width:0;color:#dfe6f4;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}',
        '.hrow.is-win .hname{color:#ffd479;font-weight:600}',
        '.hcards{flex:none;display:flex;gap:1px;letter-spacing:-.2px}',
        '.mc{font-style:normal;color:#eef2f9}',
        '.mc.red{color:#ff8f8f}',
        '.hlimit{flex:none;font-size:9.5px;line-height:1.4;padding:0 4px;border-radius:999px;',
        'color:#f2c96b;border:1px solid rgba(242,201,107,.55);background:rgba(242,201,107,.1)}',
        '.hdelta{flex:none;min-width:44px;text-align:right;font-weight:700;font-variant-numeric:tabular-nums}',
        '.hdelta.win{color:#ff8f8f}',
        '.hdelta.lose{color:#5ee1a0}',
        '.hempty{font-size:11px;color:#6b7488;padding:1px 0 2px}',
        '.panel.min .body,.panel.min .last{display:none}'
      ].join('');
    
      var host = null, root = null, refs = {};
      var LS_POS = 'zjh-prob-pos-v1', LS_MIN = 'zjh-prob-min-v1';
    
      function loadJSON(k) {
        try { return JSON.parse(localStorage.getItem(k) || 'null'); } catch (e) { return null; }
      }
      function saveJSON(k, v) {
        try { localStorage.setItem(k, JSON.stringify(v)); } catch (e) { }
      }
    
      function ensurePanel() {
        if (host && host.isConnected) return;
        host = document.createElement('div');
        host.id = 'zjh-prob-host';
        host.style.cssText = 'position:fixed;z-index:2147483000;left:0;top:0;display:none';
        (document.body || document.documentElement).appendChild(host);
        root = host.attachShadow({ mode: 'open' });
        root.innerHTML =
          '<style>' + CSS + '</style>' +
          '<div class="panel">' +
          '<div class="bar"><span class="dot"></span><span class="ttl">炸金花 · 胜率</span>' +
          '<button class="mini" title="收起/展开">\u2013</button></div>' +
          '<div class="body">' +
          '<div class="pct"><b>--</b><i>%</i></div>' +
          '<div class="track"><div class="fill"></div></div>' +
          '</div>' +
          '<div class="last" style="display:none">' +
          '<div class="last-head"><a class="lt" target="_blank" rel="noopener"></a>' +
          '<button class="lfold" title="展开/收起上一局">\u25be</button></div>' +
          '<div class="last-body"></div>' +
          '</div>' +
          '</div>';
    
        refs.panel = root.querySelector('.panel');
        refs.bar = root.querySelector('.bar');
        refs.num = root.querySelector('.pct b');
        refs.unit = root.querySelector('.pct i');
        refs.fill = root.querySelector('.fill');
        refs.last = root.querySelector('.last');
        refs.lastLink = root.querySelector('.lt');
        refs.lastBody = root.querySelector('.last-body');
    
        // 上一局:点标题开记录页,点箭头折叠
        refs.lastLink.addEventListener('click', function (e) {
          if (!refs.lastLink.getAttribute('href')) e.preventDefault();
        });
        root.querySelector('.lfold').addEventListener('click', function (e) {
          e.stopPropagation();
          lastClosed = !lastClosed;
          saveJSON(LS_LAST_CLOSED, lastClosed);
          renderLast();
        });
        renderLast();
    
        // 位置
        var pos = loadJSON(LS_POS);
        if (!pos || typeof pos.x !== 'number') {
          pos = { x: Math.max(8, window.innerWidth - PANEL_W - 12), y: 86 };
        }
        place(pos.x, pos.y);
    
        // 收起状态
        if (loadJSON(LS_MIN)) refs.panel.classList.add('min');
        root.querySelector('.mini').addEventListener('click', function () {
          saveJSON(LS_MIN, refs.panel.classList.toggle('min'));
        });
    
        // 拖动
        var drag = null;
        refs.bar.addEventListener('pointerdown', function (e) {
          if (e.target.classList && e.target.classList.contains('mini')) return;
          var r = host.getBoundingClientRect();
          drag = { dx: e.clientX - r.left, dy: e.clientY - r.top };
          try { refs.bar.setPointerCapture(e.pointerId); } catch (err) { }
          e.preventDefault();
        });
        refs.bar.addEventListener('pointermove', function (e) {
          if (!drag) return;
          var x = Math.min(Math.max(0, e.clientX - drag.dx), window.innerWidth - 60);
          var y = Math.min(Math.max(0, e.clientY - drag.dy), window.innerHeight - 40);
          place(x, y);
        });
        refs.bar.addEventListener('pointerup', function (e) {
          if (!drag) return;
          drag = null;
          var r = host.getBoundingClientRect();
          saveJSON(LS_POS, { x: r.left, y: r.top });
          try { refs.bar.releasePointerCapture(e.pointerId); } catch (err) { }
        });
    
        // 窗口尺寸变化时把面板重新夹回视口
        window.addEventListener('resize', function () {
          if (!host || host.style.display === 'none') return;
          var r = host.getBoundingClientRect();
          place(r.left, r.top);
        });
      }
    
      function place(x, y) {
        // 夹在视口内,避免面板被右边缘裁掉(面板宽度或窗口尺寸变化时也成立)
        var w = (host.getBoundingClientRect().width) || PANEL_W;
        var maxX = Math.max(0, window.innerWidth - w - 8);
        var maxY = Math.max(0, window.innerHeight - 40);
        host.style.left = Math.min(Math.max(0, x), maxX) + 'px';
        host.style.top = Math.min(Math.max(0, y), maxY) + 'px';
      }
    
      function niceColor(p) {
        if (p >= 0.70) return '#4ade80';
        if (p >= 0.45) return '#fbbf24';
        if (p >= 0.22) return '#fb923c';
        return '#f87171';
      }
    
      /* --- 上一局手牌区 --- */
      var myName = '';
      var lastSig = '';
    
      function cardChips(cards) {
        return cards.map(function (c) {
          var red = (c.s === 1 || c.s === 3) ? ' red' : '';
          return '<i class="mc' + red + '">' + rankShort(c.v) + SUIT_CHARS[c.s] + '</i>';
        }).join('');
      }
    
      function renderLast() {
        if (!refs.last) return;
        var rec = lastRec;
        var rows = (rec && rec.rows && rec.rows.length) ? rec.rows : null;
        var loading = lastJob.loading;
        var err = lastJob.error;
        if (!rows && !loading && !err) { refs.last.style.display = 'none'; return; }
    
        refs.last.style.display = '';
        refs.last.classList.toggle('closed', lastClosed);
    
        var href = (rec && rec.url) || lastJob.url || '';
        var sig = [rows ? rec.id : '', rows ? rows.length : 0, loading ? 1 : 0, err, lastClosed ? 1 : 0, href, myName].join('|');
        if (sig === lastSig) return;
        lastSig = sig;
    
        if (href) refs.lastLink.setAttribute('href', href);
        else refs.lastLink.removeAttribute('href');
    
        var head;
        if (rows) {
          head = '上一局 <b>#' + esc(rec.id) + '</b> · ' + rows.length + ' 家' + (loading ? ' · 更新中' : '');
        } else if (loading) {
          head = '上一局 <b>#' + esc(lastJob.id || '') + '</b> · 读取中…';
        } else {
          head = '上一局 · 读取失败';
        }
        refs.lastLink.innerHTML = head;
    
        var html = '';
        if (rows) {
          rows.forEach(function (r) {
            var isMe = myName && r.name === myName;
            var tip = r.name + ' · ' + (r.seen ? '看过牌' : '闷牌') + ' · ' + r.result +
              (r.capNote ? ' · ' + r.capNote : '');
            html += '<div class="hrow' + (r.win ? ' is-win' : '') + (isMe ? ' is-me' : '') + '">' +
              '<span class="hseat">' + esc(r.seat) + '</span>' +
              '<span class="hname" title="' + esc(tip) + '">' + esc(r.name) + '</span>' +
              '<span class="hcards">' + cardChips(r.cards) + '</span>' +
              (r.capNote ? '<span class="hlimit" title="' + esc(r.capNote) + '">上限</span>' : '') +
              '<span class="hdelta ' + (r.win ? 'win' : 'lose') + '">' + esc(r.delta || r.result) + '</span>' +
              '</div>';
          });
          if (err) html += '<div class="hempty">新一局记录读取失败:' + esc(err) + '</div>';
        } else if (loading) {
          html = '<div class="hempty">正在读取本局记录…</div>';
        } else {
          html = '<div class="hempty">' + esc(err || '读取失败') + ',点标题可手动打开记录页</div>';
        }
        refs.lastBody.innerHTML = html;
      }
    
      function render(st, res) {
        /* --- 概率 --- */
        var p = null, intOnly = false;
        if (st.out) {
          // 已经弃牌:本局胜率归零
          p = 0;
          intOnly = true;
        } else if (st.win) {
          // 本局已赢:直接给 100%
          p = 1;
          intOnly = true;
        } else if (st.settled) {
          p = null;
        } else if (!st.seen) {
          // 没看牌:自己的牌也是随机的,全场每人胜率相同
          var n = st.nLive + 1;
          p = n > 0 ? 1 / n : 0;
        } else {
          p = res ? res.all : null;
          // 已看牌不再写「对 N 名在场对手」,把版面留给上一局明细
        }
    
        if (p == null) {
          refs.num.textContent = '\u2014';
          refs.num.style.color = '#8b94a7';
          refs.unit.textContent = '';
          refs.fill.style.width = '0';
        } else {
          var col = niceColor(p);
          // 0% / 100% 这类极端值不带小数点
          if (intOnly || p <= 0 || p >= 0.9995) {
            refs.num.textContent = String(Math.round(p * 100));
          } else {
            refs.num.textContent = (p * 100).toFixed(1);
          }
          refs.num.style.color = col;
          refs.unit.textContent = '%';
          refs.fill.style.width = p > 0 ? Math.max(1.5, p * 100) + '%' : '0';
          refs.fill.style.background = col;
        }
    
        renderLast();
      }
    
      function hide() {
        if (host) host.style.display = 'none';
      }
    
      function tick() {
        try {
          var st = readState();
          if (!st) { hide(); return; }
          myName = st.meName || '';
          ensurePanel();
          host.style.display = '';
          var res = (st.seen && !st.out) ? analyze(st) : null;
          render(st, res);
    
          // 本局结算后,「验证」按钮的 href 就是这一局的记录页,抓它拿各家手牌
          if (st.settled) {
            var va = q('[data-gf-verify]');
            var vurl = va ? (va.getAttribute('href') || '') : '';
            var vid = handIdOf(vurl);
            if (vid && (!lastRec || lastRec.id !== vid) && !lastJob.loading && lastJob.id !== vid) {
              loadHand(vurl, vid);
            }
          }
        } catch (e) {
          hide();
        }
      }
    
      /* ================= 启动 ================= */
      var pending = null;
      function schedule() {
        if (pending) return;
        pending = setTimeout(function () { pending = null; tick(); }, 100);
      }
    
      var started = false;
      function attach() {
        var table = q('[data-gf-table]');
        if (!table) {
          if (!started) setTimeout(attach, 800);
          return;
        }
        if (started) return;
        started = true;
        var obs = new MutationObserver(schedule);
        obs.observe(table, {
          subtree: true,
          childList: true,
          attributes: true,
          attributeFilter: ['class', 'data-id', 'aria-label'],
          characterData: true
        });
        // 兜底:即使观察器漏事件也能跟上
        setInterval(function () {
          if (!q('[data-gf-table]')) { hide(); return; }
          tick();
        }, 1200);
        tick();
      }
    
      if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', attach);
      } else {
        attach();
      }
    })();
    
    
    收藏支持 1反对打赏
    个性签名

    那不成啊,得按牌型办啊。地主家也没有输牌的习惯!

6 条回复

  • 频道
    #1

    支持!这小工具不错呀。

    个性签名

    🚀🚀 小秘书 V.PS 全场优惠 8.5折 🚀🚀

  • #2

    @grok 讲讲这个脚本的功能是啥,用人家说

    :

    这个脚本是炸金花页面上的只读小面板,不替你下注、不改牌局,只把页面上已经有的信息算给你看。

    上面那个大数字是「我这手牌现在是全场最大」的概率,只算还没弃牌的人。

    • 还没看牌:大家牌都未知,按还在场的人数均分。五个人就各 20%。
    • 看过牌、对手只剩一家:把剩下的牌全部组合算一遍,是精确值。
    • 对手还有两家或更多:随机发四万次,看你有多少次最大,所以同一手牌数字是稳的,但不是精确到每一注。
    • 你已经弃牌显示 0%;这局已经赢了显示 100%。颜色大致是:70% 以上绿,45% 以上黄,22% 以上橙,再低是红。

    楼主说的「吃闷」不是脚本另算的一条建议,是他自己怎么用这个数:明牌去开唯一的闷家,开牌要花 800、锅里已有 2000,不计已经沉下去的钱,门槛大约是 800÷2800≈28.6%。面板上的概率过了这条线,他才考虑开。概率按「别人的牌完全随机」来算,只供参考。

    下面那一栏是上一局复盘。这局点了结算后,脚本去读本局「验证」记录页,把各家座位、名字、三张牌和输赢常显示出来。谁拿散牌在诈、谁的顺子被吓跑,对得上号。赢机器人碰到当日上限时,那一行会多一个金色「上限」徽标,截图里王炸收租那行就是这样(A♠K♠3♠,+15,带上限)。

    面板可以拖、可以收成一条。装 Tampermonkey,脚本匹配炸金花页面,拖进去就能用。

    #3
    共 1 条回复
  • #4

    跟着大哥混一天饿三顿

  • #5

    感谢分享

  • #6

    好东西👍‼️

发表回复