サーモンランのWAVE内容を先読みする方法と解説

1
class NSRandom:
2
mSeed1 = 0x00000000
3
mSeed2 = 0x00000000
4
mSeed3 = 0x00000000
5
mSeed4 = 0x00000000
6

7
    def __init__(self):
8
        pass
9

10
    def init(self, seed):
11
        self.mSeed1 = 0xFFFFFFFF & (0x6C078965 * (seed ^ (seed >> 30)) + 1)
12
        self.mSeed2 = 0xFFFFFFFF & (0x6C078965 * (self.mSeed1 ^ (self.mSeed1 >> 30)) + 2)
13
        self.mSeed3 = 0xFFFFFFFF & (0x6C078965 * (self.mSeed2 ^ (self.mSeed2 >> 30)) + 3)
14
        self.mSeed4 = 0xFFFFFFFF & (0x6C078965 * (self.mSeed3 ^ (self.mSeed3 >> 30)) + 4)
15

16
    def getU32(self):
17
        n = self.mSeed1 ^ (0xFFFFFFFF & self.mSeed1 << 11)
18
        self.mSeed1 = self.mSeed2
19
        self.mSeed2 = self.mSeed3
20
        self.mSeed3 = self.mSeed4
21
        self.mSeed4 = (n ^ (n >> 8) ^ self.mSeed4 ^ (self.mSeed4 >> 19))
22

23
        return self.mSeed4

1
def getWaveInfo(self):
2
mEventProb = [18, 1, 1, 1, 1, 1, 1]
3
mTideProb = [1, 3, 1]
4
self.rnd.init(self.mGameSeed)
5

6
    for wave in range(3):
7
        sum = 0
8
        for event in range(7):
9
            if (
10
                (wave > 0)
11
                and (self.mEvent[wave - 1] != 0)
12
                and (self.mEvent[wave - 1] == event)
13
            ):
14
                continue
15
            sum += mEventProb[event]
16
            if (self.rnd.getU32() * sum >> 0x20) < mEventProb[event]:
17
                self.mEvent[wave] = event
18
        sum = 0
19
        for tide in range(3):
20
            if tide == 0 and 1 <= self.mEvent[wave] and self.mEvent[wave] <= 3:
21
                continue
22
            sum += mTideProb[tide]
23
            if (self.rnd.getU32() * sum >> 0x20) < mTideProb[tide]:
24
                self.mTide[wave] = 0 if self.mEvent[wave] == 6 else tide

1
def setWaveMgr(self):
2
self.rnd.init(self.mGameSeed)
3
self.rnd.getU32()
4
self.mWaveMgr = [
5
WaveMgr(0, self.mGameSeed),
6
WaveMgr(1, self.rnd.getU32()),
7
WaveMgr(2, self.rnd.getU32()),
8
]

1
def getGeyserPos(self):
2
self.rnd.init(self.mWaveSeed)
3
mReuse = [False, False, False, False]
4
mPos = ["D", "E", "F", "G"]
5
mSucc = []
6

7
for idx in range(15):
8
for sel in range(len(mPos) - 1, 0, -1):
9
index = (self.rnd.getU32() * (sel + 1)) >> 0x20
10
mPos[sel], mPos[index] = mPos[index], mPos[sel]
11
mReuse[sel], mReuse[index] = mReuse[index], mReuse[sel]
12
mSucc += mPos[0]
13
if mReuse[0]:
14
self.rnd.getU32()
15
return mSucc

1
def getEnemyAppearId(self, previousId):
2
mArray = [1, 2, 3]
3
mIndex = 0
4
w6 = 3
5
x6 = 3
6
v5 = previousId
7
w7 = mArray
8
if not (id & 0x80000000):
9
w8 = w6 - 1
10
while True:
11
v17 = w8
12
w9 = w7[mIndex]
13
if w9 < id:
14
break
15
w6 -= w9 == id
16
if w9 == id:
17
break
18
w8 = v17 - 1
19
mIndex += 1
20
if not v17:
21
break
22

23
    mIndex = 0
24
    x7 = mArray
25
    x8 = 0xFFFFFFFF & (self.rnd.getU32() * w6 >> 0x20)
26

27
    while True:
28
        x9 = x7[mIndex]
29
        x10 = 0 if x8 == 0 else x8 - 1
30
        x11 = x9 if x8 == 0 else v5
31
        x12 = 5 if x9 == v5 else x8 == 0
32
        if x9 != v5:
33
            x8 = 0xFFFFFFFF & x10
34
            id = x11
35
        if (x12 & 7) != 5 and (x12 & 7):
36
            break
37
        x6 -= 1
38
        mIndex += 1
39
        if not x6:
40
            return v5
41
    return id

1
def getEnemyId(self):
2
mRnd = NSRandom.NSRandom()
3
mRnd.init(self.rnd.getU32())
4

5
    mRareId = 0
6
    for mProb in range(7):
7
        if not (mRnd.getU32() * (mProb + 1) >> 0x20):
8
            mRareId = mProb
9
    return mRareId