湧き方向アルゴリズム#

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

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

    u8 x9, w9, x10, x11, x12, v17;
    u8 *x7, *w7;
    u64 x8, w8;
    u8 v5 = id;
    u8 x6 = 3;
    u8 w6 = 3;
    w7 = mArray;
    if (!(v5 & 0x80000000))
    {
        if (!w6)
            return v5;
        w8 = w6 - 1;
        do
        {
            v17 = w8;
            w9 = *w7;
            if (*w7 < v5)
                break;
            w6 -= w9 == v5;
            if (w9 == v5)
                break;
            w8 = v17 - 1;
            ++w7;
        }
        while (v17);
    }

    if (w6 < 1)
        return v5;

    x7 = mArray;
    x8 = random * w6 >> 0x20;
    while (1)
    {
        x9 = *x7;
        x10 = x8 == 0 ? 0 : x8 - 1;
        x11 = x8 == 0 ? *x7 : id;
        x12 = x9 == v5 ? 5 : x8 == 0;
        if (x9 != v5)
        {
            x8 = LODWORD(x10);
            id = x11;
        }
        if ((x12 & 7) != 5 && x12 & 7)
            break;
        --x6;
        ++x7;
        if (!x6)
            return v5;
    }
    return id;
}

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

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

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

private func getEnemyAppearId(random: UInt32, lastAppearId: UInt8) -> UInt8 {
    let w6 = lastAppearId == 1 ? 2 : 3
    let x8 = UInt8((UInt64(random) &* UInt64(w6)) >> 0x20)
    switch lastAppearId {
        case 0, 3:
        	return x8 + 1
        case 1:
        	return x8 + 2
        case 2:
        switch x8 {
            case 0:
            	return 1
            case 1:
            	return 3
            case 2:
            	return 2
            default:
            	return 0
        }
        default:
        	return 0
    }
}