牌桌上的「鸣牌」「牌设」「代打」

牌桌右边一列开关里有这三颗钮。它们只决定这一盘哪些事不用问你、哪些事替你按，不改牌规。 下面先分别讲，再讲组合起来会怎样，最后有一个可以自己点的模拟器。

先记住这几条特殊规则

• 四种和一律照问：海底捞月（别人打出最后一张）、妙手回春（自己摸到最后一张）、杠上开花（自己杠完补摸的那张）、抢杠和。牌设、鸣牌怎么设都不管它们。
• 「不询问选中牌」不管自摸：选中的牌只管别人打出的那张；自己摸到能和照样问，自摸只归「不自摸」管。（「只询问选中牌」才会按选牌筛自摸。）
• 战鸣二次询问不受「不吃」「不碰」「不明杠」管：你点了「过」之后别人叫了更低档的动作、再问你一次时，吃、碰、杠都照问；「牌设」仍然照管。勾了鸣牌里的「不战鸣」，这一问一律替你过。
• 替你「过」会说一声：按设置当场替你过掉时，桌上会提示「按牌设已过 6万」「按鸣牌已过 3条」，看得出是哪项设置挡的。
• 设置只管设的那一盘：每盘开局拨回默认；掉线重连回来已经换了一盘的话，也会拨回默认并提示。

共同规矩

• 只管这一盘。每盘开局全部拨回默认，屏幕上会提示「新一盘 · …已拨回默认」。
• 默认什么都不动。不打开、不勾选，牌桌照常问你吃碰杠和。
• 动过就亮。勾了任何一项，对应那颗钮就变成金色，一眼能看出这一盘你设了东西。
• 藏掉的按钮等于「过」。服务器照常给你选项，只是不摆出来；摆完只剩「过」，就当场替你过，另外三家不用等你。

鸣牌 · 按动作种类关掉询问

点「鸣牌」，旁边弹出七格小菜单，可以多选。再点一次「鸣牌」或点屏幕别处就收起。勾的项当场生效，桌上正好有一问的话会按新设置重新摆按钮。

鸣牌不管和，和不和由「牌设」管。（「不战鸣」例外：战鸣那一问整个替你过，里面有和也一起过。）

牌设 · 按哪张牌决定问不问

点「牌设」，弹出选牌浮窗。每点一下都当场生效，点浮窗外面或再点一次「牌设」收起。每次打开都落在「设置A」那一页。

四个选项

• 一张都没选，选牌就不起作用，照常问。
• 「不自摸」「仅自摸」不认牌，一勾就管这一页的所有牌；两个只能二选一。
• A、B 两页叠加：任何一页说「问」就问。空着的页不参与。
• 暗杠、补杠、补花不归牌设管，归鸣牌管。切换「只询问 / 不询问」会清空这一页。「全不选」清这一页，「全部重置」两页一起清。

开局默认是哪种模式，在「系统设置 → 牌设默认」里选；没选过就是「只询问选中牌」。

一页就够

必须两页

能用一页就用一页。想让某几张只自摸，在一页里「不询问」它们就行（例 4）。只有某张不许自摸、另一张又要自摸时，一页写不下 ——「不自摸」管整页 —— 才分两页。

代打 · 替你出牌，有事就停

点「代打」打开，再点一次关掉。打开之后：

• 摸什么打什么，不换牌。轮到你摸牌后，等 1 秒，把刚摸进来的那一张打出去，手里原来的牌一张不动。
• 有按钮就停下等你。桌上只要摆出了按钮（吃、碰、杠、和、补），代打就停，等你自己选。
• 吃碰之后不替你出牌。吃碰之后没有「刚摸的牌」，这一手要你自己打。
• 刚打开就生效。正轮到你、刚摸完牌时点开，会立刻按上面的规矩处理这一手。

代打里的「自动和」

点开代打时，旁边会弹出一个「自动和」勾选框，勾不勾随你，点屏幕别处就收起。勾上之后：

• 只要摆出「和」钮（自摸、点炮、抢杠都算），停一下（约 0.4 秒，让你看见和钮冒出来）就替你按。
• 只替你按和。吃、碰、杠照旧停下等你；和钮与吃碰同时摆着时，和优先。
• 不检查够不够 8 番。不够番按下去就是错和，照样罚分。
• 被「牌设」藏掉的和钮不算，不会替你和。
• 自己摸到「不询问」里选中的牌，不替你和。和钮照样摆（你自己点照样能和），自动和不按；桌上只有这一颗和钮的话，代打照常 1 秒后把这张打出去。杠上开花、妙手回春除外，照样替你和（它们自带 8 番）。
• 关掉代打，自动和跟着关；每盘开局都清掉。

组合用法

记住一句话就能推出所有组合：鸣牌和牌设先决定摆哪些按钮，代打再看摆出来的按钮行事。被藏掉的按钮，对代打来说就是不存在。

试一试

左边设好，右边看桌上会摆哪些按钮。判断用的是牌桌上同一份代码。

常见问题

设了牌设，结果别人打什么都不问我了？

多半是选了牌、又在「只询问选中牌」模式下，这时只有选中的牌会问你。打开牌设点「全部重置」，再点浮窗外面让它生效。

A 选「只询问 3万」，B 选「不询问 3万」，会怎样？

跟没设一样，什么都照常问。两页叠加是任何一页说问就问：别人打 3万，A 说问；打别的牌，B 说问；自摸也都有一页说问。两页正好互补，合起来就是全部都问，等于白设。

为什么下一盘设置没了？

三颗钮都是「这一盘怎么打」的临时决定，每盘开局自动拨回。只有牌设开局用哪种模式，可以在「系统设置 → 牌设默认」里长期保存。

代打开着，为什么有时候不出牌？

桌上摆着按钮在等你（吃、碰、杠、和、补），或者刚吃碰完要你自己打。看一眼按钮条就知道。

开了自动和，会不会错和？

会。自动和只替你按和钮，不替你算番。国标要满 8 番才算和，不够就是错和，照规则罚分。知道哪张不够番，就在「牌设」里「不询问」它（或「只询问」够番的那几张），自动和就不会替你和那张，见组合 7。

↑ 回到顶部

发牌算法

本平台采用如下发牌算法。 发牌全程只由一样东西决定: 每盘一个 128 字节的随机种子。 同一个种子, 必然洗出同一副牌墙、掷出同一组骰子、发出同样的四手牌。

均匀度实测: 100 万副牌

用线上发牌的同一份代码连洗 100 万副(共 1.44 亿张牌), 统计每一种可能的偏向。 另设一组对照: 洗牌步骤完全相同, 只把随机数换成操作系统自带的密码学随机数(公认的"真随机"标准)。 我们的结果与对照组处在同一水平, 就说明两者分辨不出差别。

怎么读: 每项算出一个偏离度 z。完全随机时 z 本来就会在 ±1 附近来回晃; |z| 超过 3 才值得怀疑, 超过 5 判定为有问题。z 贴着 0 不动反而可疑, 所以"不是越小越好"。

四家起手手牌里各类牌的占比(庄家 14 张, 其余 13 张):

一副牌里万、条、筒各 36 张(各占 25%), 字牌 28 张(19.44%), 花牌 8 张(5.56%)。 四家与理论值、四家彼此之间, 都只差百分之零点零几。

起手向听数(离听牌还差几步, 越小牌越好; 0 至 6+ 各列为该向听数所占的百分比):

庄家多拿一张牌, 向听自然低一些, 这不是偏袒; 三家闲家的平均向听是 3.874、3.875、3.875, 几乎完全一样。

这一节证明了什么、没证明什么: 它证明的是洗牌算法本身不偏 —— 随机数经 SHAKE256(美国国家标准技术研究院的标准算法)展开, 取数时先用拒绝采样去掉会造成偏差的那一小段, 再取余数; 这套检验随代码一起保存, 发牌代码一改就重跑。 它证明不了"服务端有没有挑选种子" —— 算法再均匀, 挑种子照样能偏向某个人, 事后统计也看不出来。 回答这个问题要靠另一套机制(发牌前先公布种子的指纹、局后公开种子, 让每个人都能自己核对), 那是另一件事。 测试日期 2026-09-27。

1. 起手那副未洗的牌

private static List<int> BuildWall()
{
    var wall = new List<int>(144);
    foreach (var baseVal in new[] { 10, 20, 30 })          // 万 11-19, 条 21-29, 筒 31-39
        for (int n = 1; n <= 9; n++)
            for (int c = 0; c < 4; c++) wall.Add(baseVal + n);
    for (int n = 1; n <= 7; n++)                            // 东南西北中发白 41-47
        for (int c = 0; c < 4; c++) wall.Add(40 + n);
    for (int n = 0; n < 8; n++) wall.Add(61 + n);           // 春夏秋冬梅兰竹菊 61-68, 各 1 张
    return wall;                                            // 共 144 张
}

2. 开局

种子由系统的密码学随机数生成, 外部传不进来。

public static MahjongGame NewGame(int seatCount, int dealerSeat = 0)
    => NewGame(seatCount, SeedStream.NewSeed(), dealerSeat);   // RandomNumberGenerator.GetBytes(128)

public static MahjongGame NewGame(int seatCount, byte[] seed, int dealerSeat = 0)
{
    var dice = SeedStream.RollDice(seed);                  // 骰子也由种子定
    var game = new MahjongGame(seatCount, seed) { Style = DealStyle.Real, Dice = dice };
    game.Deal(seatCount, dealerSeat);
    return game;
}

// 构造时:
_wall = BuildWall();
SeedStream.Shuffle(_wall, seed);
InitialWall = _wall.ToArray();                             // 归档的就是这副洗好的牌

3. 随机流和洗牌

public sealed class SeedStream
{
    public const int SeedBytes = 128;
    private const int BlockBytes = 1024;
    private readonly byte[] _seed, _domain;
    private byte[] _buf = [];
    private int _pos;
    private long _chunk;

    public SeedStream(byte[] seed, string domain = "")
    {
        _domain = domain.Length == 0 ? [] : Encoding.ASCII.GetBytes(domain);
        _seed = seed;
    }

    public static byte[] NewSeed() => RandomNumberGenerator.GetBytes(SeedBytes);
    public static string CommitmentOf(byte[] seed) => Convert.ToHexString(SHA256.HashData(seed));

    // 每块 = SHAKE256(种子 ‖ 域标签 ‖ 大端 8 字节块号), 挤 1024 字节
    private void Refill()
    {
        var input = new byte[_seed.Length + _domain.Length + 8];
        _seed.CopyTo(input, 0);
        _domain.CopyTo(input, _seed.Length);
        BinaryPrimitives.WriteInt64BigEndian(input.AsSpan(_seed.Length + _domain.Length), _chunk++);
        _buf = Shake256.HashData(input, BlockBytes);
        _pos = 0;
    }

    private ulong NextU64()
    {
        if (_pos + 8 > _buf.Length) Refill();
        ulong v = BinaryPrimitives.ReadUInt64BigEndian(_buf.AsSpan(_pos));
        _pos += 8;
        return v;
    }

    // [0, n) 均匀整数, 拒绝采样(不取模, 免得分布歪)
    public int Next(int maxExclusive)
    {
        if (maxExclusive <= 1) return 0;
        ulong bound = (ulong)maxExclusive;
        ulong limit = ulong.MaxValue - ulong.MaxValue % bound;
        while (true) { ulong v = NextU64(); if (v < limit) return (int)(v % bound); }
    }

    // 骰子走独立的域 "dice", 不和洗牌共用一条流
    public static int[] RollDice(byte[] seed)
    {
        var rng = new SeedStream(seed, "dice");
        return [rng.Next(6) + 1, rng.Next(6) + 1, rng.Next(6) + 1, rng.Next(6) + 1];
    }

    // Fisher-Yates
    public static void Shuffle<T>(IList<T> list, byte[] seed)
    {
        var rng = new SeedStream(seed);
        for (int i = list.Count - 1; i > 0; i--)
        {
            int j = rng.Next(i + 1);
            (list[i], list[j]) = (list[j], list[i]);
        }
    }
}

4. 骰子定从哪儿抓, 按真桌规矩发牌

// s1 = 第一轮两颗之和(找风位), s2 = 第二轮两颗之和; 数墩, 一墩两张
public static int DealStartOf(int s1, int s2, int seatCount, int dealerSeat, int wallCount)
{
    int per = wallCount / seatCount;
    int k = ((s1 - 1) % seatCount + seatCount) % seatCount;
    int seat = ((dealerSeat + k) % seatCount + seatCount) % seatCount;
    return (seat * per + (s1 + s2) * 2) % wallCount;
}

// Deal(): 牌墙从断点转到下标 0, 然后从庄家起逆时针, 一次一墩四张
for (int round = 0; round < 3; round++)
    for (int k = 0; k < seatCount; k++)
    {
        int s = (dealerSeat + k) % seatCount;
        for (int c = 0; c < 4; c++) _hands[s].Add(_wall[_wallIndex++]);
    }
for (int k = 0; k < seatCount; k++)
    _hands[(dealerSeat + k) % seatCount].Add(_wall[_wallIndex++]);
Draw(DealerSeat);                                          // 庄家第 14 张

怎么验

1. 在牌谱页展开那一盘的牌, 下面就是这一盘的洗牌种子, 可以复制; 牌谱页的搜索框也能按种子反查牌局。
2. 照第 1 步造出未洗的那副牌(顺序必须一模一样, 花牌从 61 起)。
3. 用第 3 步的随机流和洗牌跑一遍。
4. 得到的牌墙与牌谱里的牌墙逐张比对 —— 应当一张不差。

这能证明的是: 牌谱里那副牌墙, 就是这个种子洗出来的, 事后没有被改动过。

段位是怎么算的

你身上只有两个数: PT 决定段位, R 决定跟谁打。 段位是履历, 走得慢; R 是当前实力, 反应快。R 掉了不会掉段, 只是暂时进不了高档场。

两个数

三个阶段

一局怎么算

PT · 级位

查下面那张级位表取名次分值即可。唯一的变数是连胜: 第 2 把起, 1位 的分值翻倍(只翻这一次, 不随连胜数继续叠)。

PT · 段位

一桌合计: 初段至三段为正(成长区), 四至六段为 0, 七段起为负。各段的具体分值见下面速查表。

同分并列: 并列的人平分所占名次的分值(PT 与 R 都是), 例如二、三位并列, 两人各拿二位与三位的平均。缺席者仍一律按 4 位。

PT · 段位差

同桌两人相差 2 段以上, 而高段的名次在低段之后: 高段转 PT 给这位低段 —— 高段是三段及以下转 1 PT(每局最多 3), 四段起转 2 PT(每局最多 6)。相差 1 段不转。

R

白话说: E 是按双方 R 算出的"你这局该拿多少", 打得比它好就涨、比它差就跌。 赢了比你强的人涨得多, 赢了比你弱的人涨得少; 输给比你弱的人扣得多。 连续拿一位没有额外奖励 —— 你的 R 越高, 同样拿一位涨得越少, R 会自己停在你真实水平附近。

连败缓冲: 一局 ΔR 为负算一败, 连续的败按下表打折或加重; 只要有一局 ΔR 不为负就清零。前 20 局不启用。R 没有下限。

哪些局算数

• 匹配场计段位 —— PT、R、统计、牌谱全都写。
• 好友约战房不计段位(PT 与 R 一动不动), 但统计与牌谱照写。想跟谁打就跟谁打, 刷不到分。
• 练习房不计段位。
• 赛事桌由赛事设置决定, 默认不计。

速查 · 级位

整条级位一共 225 PT。溢出的 PT 保留并立即再判一次, 所以连胜时一局可以跨 2 级 —— 理论最快 6 局连胜从 9级 打到初段。1级 升初段那一下溢出丢弃, 连胜清零。

速查 · 段位

升降段这一下发生了什么

• 级位 · 升PT ≥ 升级线 → 升一级, 余数带走, 立刻再判一次(所以能连跳)。
• 级位 · 降不存在。PT 算成负数就截在 0。
• 1级 → 初段PT 重置为 200(初段入段分), 余数丢弃, 连胜清零。
• 段位 · 升PT ≥ 升段线 → 升一段, PT 重置为新段的入段分, 余数丢弃。
• 段位 · 降PT < 0 → 掉一段, PT 重置为下一段的入段分; 正好 0 不掉。
• 初段 · 降掉回 1级, PT 给 15。
• 十段不再晋升, PT 不封顶; 跌破 0 掉回九段(PT 1800)。
• 天元由九段、十段玩家参加的赛事产生。因为很稀缺, 暂时为永久称号。

速查 · 定级 / K值 / 准入

新人 4 局定级

定级只是给个起点, 真正的校准由 R 承担(前 20 局 K=48, 涨得快)。 缺席局照样按 4位 计入定级 —— 否则可以靠缺席洗一个好起点。

R 的 K / M(取本局结算前的局数)

匹配档位准入(段位 且 R, 两个都要满足)

中级场只看 R: 谁和谁同一个房间由实力决定, 不会因为升了一段就突然被分进强手池。 同一个房间里优先和段位相近的人同桌 —— 每升一段, 对手就强一点。

缺席

• 什么算缺席整局从头到尾没打开过牌桌(赛事桌开了人没来)。 来了之后中途掉线的不算 —— 掉线由托管接着打, 照常按打出来的名次结算。
• 牌局照常缺席者的座位由托管替打, 别人该怎么打怎么打。
• 段位结算缺席者一律按 4位 结算 PT 与 R(新人期按 4位 计入定级), 托管替他打出第几名都不算他的。
• 在场的人按各自得分在在场者之间重新排名 —— 托管替缺席者打了第一的话, 在场三人按 1 / 2 / 3 位结算。