湧き方向アルゴリズム

湧き方向を求めるアルゴリズムは解析済みで以下のようなコードになることがわかっていました。

1
u8 WaveMgr::getEnemyAppearId(u64 random, u8 id)
2
{
3
    u8 mArray[3] = {
4
        1, 2, 3
5
    };
6

7
    u8 x9, w9, x10, x11, x12, v17;
8
    u8 *x7, *w7;
9
    u64 x8, w8;
10
    u8 v5 = id;
11
    u8 x6 = 3;
12
    u8 w6 = 3;
13
    w7 = mArray;
14
    if (!(v5 & 0x80000000))
15
    {
16
        if (!w6)
17
            return v5;
18
        w8 = w6 - 1;
19
        do
20
        {
21
            v17 = w8;
22
            w9 = *w7;
23
            if (*w7 < v5)
24
                break;
25
            w6 -= w9 == v5;
26
            if (w9 == v5)
27
                break;
28
            w8 = v17 - 1;
29
            ++w7;
30
        }
31
        while (v17);
32
    }
33

34
    if (w6 < 1)
35
        return v5;
36

37
    x7 = mArray;
38
    x8 = random * w6 >> 0x20;
39
    while (1)
40
    {
41
        x9 = *x7;
42
        x10 = x8 == 0 ? 0 : x8 - 1;
43
        x11 = x8 == 0 ? *x7 : id;
44
        x12 = x9 == v5 ? 5 : x8 == 0;
45
        if (x9 != v5)
46
        {
47
            x8 = LODWORD(x10);
48
            id = x11;
49
        }
50
        if ((x12 & 7) != 5 && x12 & 7)
51
            break;
52
        --x6;
53
        ++x7;
54
        if (!x6)
55
            return v5;
56
    }
57
    return id;
58
}

ただしこれはバイナリを解析して得られたアセンブラを直接 C++に書き直しているだけなので可読性が非常に悪く、なんで 1 湧きが連続しないのかということはわからないままでした。

ただエミュレートしているだけでアルゴリズム解析ができていない以上、ひょっとしたら超低確率で湧き方向 1 が連続する可能性もあったわけです。

今回、このコードを Swift に移植するにあたり高速化のためにより深く解析を行うことにしました。

Swift

そして解析した結果得られたコードが以下の通りで、二つのループ文を消した上で変数も二つにまで減らすことができました。

1
private func getEnemyAppearId(random: UInt32, lastAppearId: UInt8) -> UInt8 {
2
    let w6 = lastAppearId == 1 ? 2 : 3
3
    let x8 = UInt8((UInt64(random) &* UInt64(w6)) >> 0x20)
4
    switch lastAppearId {
5
        case 0, 3:
6
          return x8 + 1
7
        case 1:
8
          return x8 + 2
9
        case 2:
10
        switch x8 {
11
            case 0:
12
              return 1
13
            case 1:
14
              return 3
15
            case 2:
16
              return 2
17
            default:
18
              return 0
19
        }
20
        default:
21
          return 0
22
    }
23
}

最終的にどんな湧き方向になるかは「一つ前の湧き方向」と「生成された乱数の剰余」だけで決定することがわかります。

わかりやすい表

::: tip 湧き方向 0 について

湧き方向 0 は一番最初の初期化にしか使われない。

:::

結論から言えば、湧き方向 1 が連続しないのは前回の湧き方向が 1 の時に除数として 2 が選ばれるために剰余が 0 か 1 のどちらかしか発生しないことが原因です。

プログラム的には前回の湧き方向が 1 で剰余が 2 であれば湧き方向は 1 になるはずなのですが、剰余が絶対に 0 か 1 しかありえないのでこのパターンは存在しないことになります。

よって、ありとあらゆるシードにおいて 1 湧きは連続しないことが証明されました。

では、結局どの湧き方向が一番多いのでしょうか？

湧き方向確率を考える

事前の総当り的な解析から次のことがわかっています。

といってもこれはたった 100 万件を調べて程度なので真の値を反映しているとは言えません。

前提条件

とはいっても、実際に全通り試さずに結果を予測するのですから予めある程度の前提条件が必要になります。

• 疑似乱数生成器(以降 PRNG とする)の出力は一様に分布している

今回必要になる条件はこれだけですが、スプラトゥーンの PRNG は Xorshift の亜種のようなものなので一様なのかと言われればかなり疑問が残ります。

が、これを前提にしないと全く始まらないのでここでは「ほぼ一様分布である」と仮定して話を考えます。

初手の湧き方向

初手の湧き方向を求めることは簡単です。まず、初期化によって湧き方向(この値は実際には使われない)が決定されます。

その湧き方向(以降 X0 とする)から初手の湧き方向が求められるのですが、X0 が 1 であれば 1 湧きは連続しないことから初手湧きは必ず 1 ではありません。

PRNG の出力が一様分布であれば以下のような表になるはずです。

つまり、湧き方向が 1 になるのは(1/3 * 1/3) * 2 = 0.2222...となります。

すると総当り解析で得られた 0.2252 という値は非常に近く信頼できそうな気がしてきます。

ちなみに 2 湧きと 3 湧きは確率が等しく、(1/3 * 1/3) * 2 + 1/3 * 1/2 = 0.3888...となります。

全体の確率を考える

N+1 回目の湧き方向を求めたければ N 回目の湧き方向の情報から計算すれば良いので、

のようなグラフを考えて漸化式を解いて一般式を求めれば良い。でもそれってめんどくさいですよね？

なので十分長いマルコフ連鎖として考えます。

すると、ノードが三つだけになるのでめちゃくちゃ考えやすくなりますね。

得られる方程式

$p_1 = p_2 * \frac{1}{3} + p_3 * \frac{1}{3}$

$p_2 = p_1 * \frac{1}{2} + p_2 * \frac{1}{3} + p_3 * \frac{1}{3}$

$p_3 = p_1 * \frac{1}{2} + p_2 * \frac{1}{3} + p_3 * \frac{1}{3}$

$1 = p_1 + p_2 + p_3$

これを計算すると、

$3p_1 = p_2 + p_3$

$p_2 = p_3$

$1 = p_1 + p_2 + p_3$

が得られ、最終的に解として、

$p_1=\frac{1}{4}, p_2=p_3=\frac{3}{8}$

が求められます。

::: tip MathJax

Vuepress + mathjax って複数行で数式かけないんですかね？

:::

理論値と実測値の差異

では理論値と実測値を比較してみます。

理論値

実測値

というわけで、いい塩梅に落ち着いたのではないでしょうか。

恐らくこれで間違ってはいないはずです、多分。