For those who would like to understand how I determine the RNs based on the RAM values
--------------------------------Parameters to fix----------------------------------
--The game make an unknow update on the ram after map 9 (first split)
nb=624*30 -- Number of RN values to predict in addition to the 624 RN currently on the RAM (minimum 1)
-- around 21 boucles
--op = {101,9,66,101,9}
op = {101,9,67,5,101,9}
--op2 = {"<","<",">","<","<"}
op2 = {"<","<","<",">","<","<"}
--------------------------------------------------------------------------------------------------------------------------------------------------------
client.setwindowsize(2)
rngvalues={
{1;8;10;12;13;14;15;16};
{17;18;19;20;21;21;22;23};
{24;24;25;25;26;27;28;29};
{30;30;31;32;33;34;35;35};
{36;37;38;39;40;40;41;42};
{43;44;45;45;46;47;48;49};
{50;50;51;52;53;54;55;55};
{56;57;58;59;60;60;61;62};
{63;64;65;65;66;67;68;69};
{70;70;71;72;73;74;75;75};
{76;77;77;78;79;80;80;81};
{82;83;84;85;86;87;88;89};
{91;93;95;98;255;255;255;255};
{255;255;255;255;255;255;255;255};
{255;255;255;255;255;255;255;255};
{255;255;255;255;255;255;255;255}
}
--------------------------------------------------------------------------------------------------------------------------------------------------------
while true do
byte={}
for i=1, 2496 do
byte[i]=memory.readbyte(0x000E9847+i)
end
for i=624, 623+nb do -- Start of Loop 1 to predict the bytes
j=i*4
byte[j+1]=0
byte[j+2]=0
byte[j+3]=0
byte[j+4]=0
k=(i-623)*4
l=(i-227)*4
dw2 = {byte[k+1],byte[k+2],byte[k+3],byte[k+4]}
dw398 = {byte[l+1],byte[l+2],byte[l+3],byte[l+4]}
-----------------------------------Byte 1-----------------------------------
c1 = math.floor(byte[k+1]/2)
c2 = byte[l+1]
coef = 1
calc = c1 + c2
if byte[k+1] % 2 == 1 then
coef = -1
calc = -calc
byte[j+1] = byte[j+1] - 33
if byte[l+1] % 64 > 31 then byte[j+1] = byte[j+1] + 64 end
if byte[k+1] % 128 > 63 then calc = calc + 64 end
end
if c1 % 2 == 1 and c2 % 2 == 1 then calc = calc - 2*coef end
if c1 % 4 > 1 and c2 % 4 > 1 then calc = calc - 4*coef end
if c1 % 8 > 3 and c2 % 8 > 3 then calc = calc - 8*coef end
if c1 % 16 > 7 and c2 % 16 > 7 then calc = calc - 16*coef end
if c1 % 32 > 15 and c2 % 32 > 15 then calc = calc - 32*coef end
if c1 % 64 > 31 and c2 % 64 > 31 then calc = calc - 64 end
if c1 % 128 > 63 and c2 % 128 > 63 then calc = calc - 128*coef end
byte[j+1] = byte[j+1] + calc
-----------------------------------Byte 2-----------------------------------
c1 = math.floor(byte[k+2]/2)
c2 = byte[l+2]
calc = c1 + c2
if byte[k+1] % 2 == 1 then
calc = c1 + c2
byte[j+2] = byte[j+2] - 80
if byte[l+2] % 32 > 15 then byte[j+2] = byte[j+2] - 32 end
if byte[l+2] % 64 > 31 then byte[j+2] = byte[j+2] - 64 end
if byte[k+2] % 64 > 31 then calc = calc - 32 end
if byte[k+2] % 128 > 63 then calc = calc - 64 end
if c1 % 2 == 1 and c2 % 2 == 1 then calc = calc - 2 end
if c1 % 4 > 1 and c2 % 4 > 1 then calc = calc - 4 end
if c1 % 8 > 3 and c2 % 8 > 3 then calc = calc - 8 end
if c1 % 16 > 7 and c2 % 16 > 7 then calc = calc - 16 end
if c1 % 32 > 15 and c2 % 32 > 15 then calc = calc + 32 end
if c1 % 64 > 31 and c2 % 64 > 31 then calc = calc + 64 end
if c1 % 128 > 63 and c2 % 128 > 63 then calc = calc - 128 end
end
if byte[k+1] % 2 == 0 then
if c1 % 2 == 1 and c2 % 2 == 1 then calc = calc - 2 end
if c1 % 4 > 1 and c2 % 4 > 1 then calc = calc - 4 end
if c1 % 8 > 3 and c2 % 8 > 3 then calc = calc - 8 end
if c1 % 16 > 7 and c2 % 16 > 7 then calc = calc - 16 end
if c1 % 32 > 15 and c2 % 32 > 15 then calc = calc - 32 end
if c1 % 64 > 31 and c2 % 64 > 31 then calc = calc - 64 end
if c1 % 128 > 63 and c2 % 128 > 63 then calc = calc - 128 end
end
byte[j+2] = byte[j+2] + calc
-----------------------------------Byte 3-----------------------------------
c1 = math.floor(byte[k+3]/2)
c2 = byte[l+3]
calc = c1 + c2
if byte[k+1] % 2 == 1 then
calc = c1 + c2
byte[j+3] = byte[j+3] + 8
if byte[l+3] % 16 > 7 then byte[j+3] = byte[j+3] - 16 end
if byte[k+3] % 32 > 15 then calc = calc - 16 end
if c1 % 2 == 1 and c2 % 2 == 1 then calc = calc - 2 end
if c1 % 4 > 1 and c2 % 4 > 1 then calc = calc - 4 end
if c1 % 8 > 3 and c2 % 8 > 3 then calc = calc - 8 end
if c1 % 16 > 7 and c2 % 16 > 7 then calc = calc + 16 end
if c1 % 32 > 15 and c2 % 32 > 15 then calc = calc - 32 end
if c1 % 64 > 31 and c2 % 64 > 31 then calc = calc - 64 end
if c1 % 128 > 63 and c2 % 128 > 63 then calc = calc - 128 end
end
if byte[k+1] % 2 == 0 then
if c1 % 2 == 1 and c2 % 2 == 1 then calc = calc - 2 end
if c1 % 4 > 1 and c2 % 4 > 1 then calc = calc - 4 end
if c1 % 8 > 3 and c2 % 8 > 3 then calc = calc - 8 end
if c1 % 16 > 7 and c2 % 16 > 7 then calc = calc - 16 end
if c1 % 32 > 15 and c2 % 32 > 15 then calc = calc - 32 end
if c1 % 64 > 31 and c2 % 64 > 31 then calc = calc - 64 end
if c1 % 128 > 63 and c2 % 128 > 63 then calc = calc - 128 end
end
byte[j+3] = byte[j+3] + calc
-----------------------------------Byte 4-----------------------------------
c1 = math.floor(byte[k+4]/2)
c2 = byte[l+4]
calc = c1 + c2
if byte[k+1] % 2 == 1 then
calc = c1 + c2
byte[j+4] = byte[j+4] - 103
if byte[l+4] % 2 == 1 then byte[j+4] = byte[j+4] - 2 end
if byte[l+4] % 16 > 7 then byte[j+4] = byte[j+4] - 16 end
if byte[l+4] % 32 > 15 then byte[j+4] = byte[j+4] - 32 end
if byte[k+4] % 4 > 1 then calc = calc - 2 end
if byte[k+4] % 32 > 15 then calc = calc - 16 end
if byte[k+4] % 64 > 31 then calc = calc - 32 end
if byte[k+4] > 127 then calc = calc - 64 end
if c1 % 2 == 1 and c2 % 2 == 1 then calc = calc + 2 end
if c1 % 4 > 1 and c2 % 4 > 1 then calc = calc - 4 end
if c1 % 8 > 3 and c2 % 8 > 3 then calc = calc - 8 end
if c1 % 16 > 7 and c2 % 16 > 7 then calc = calc + 16 end
if c1 % 32 > 15 and c2 % 32 > 15 then calc = calc + 32 end
if c1 % 64 > 31 and c2 % 64 > 31 then calc = calc - 64 end
end
if byte[k+1] % 2 == 0 then
if c1 % 2 == 1 and c2 % 2 == 1 then calc = calc - 2 end
if c1 % 4 > 1 and c2 % 4 > 1 then calc = calc - 4 end
if c1 % 8 > 3 and c2 % 8 > 3 then calc = calc - 8 end
if c1 % 16 > 7 and c2 % 16 > 7 then calc = calc - 16 end
if c1 % 32 > 15 and c2 % 32 > 15 then calc = calc - 32 end
if c1 % 64 > 31 and c2 % 64 > 31 then calc = calc - 64 end
if byte[k+4] > 127 then calc = calc - 64 end
end
byte[j+4] = byte[j+4] + calc
----------------------------Extra calculations-----------------------------------
if byte[k+2] % 2 == 1 then byte[j+1] = byte[j+1] + 128 end
if byte[k+3] % 2 == 1 then byte[j+2] = byte[j+2] + 128 end
if byte[k+4] % 2 == 1 then byte[j+3] = byte[j+3] + 128 end
if byte[k] > 127 then
byte[j+4] = byte[j+4] + 64
if byte[l+4] % 128 > 63 then byte[j+4] = byte[j+4] - 128 end
end
byte[j+1] = byte[j+1] % 256
byte[j+2] = byte[j+2] % 256
byte[j+3] = byte[j+3] % 256
byte[j+4] = byte[j+4] % 256
end -- End of Loop 1
--------------------------------------------------------------------------------------------------------------------------------------------------------
predict={}
for i=0, 623+nb do -- Start of Loop 2 to predict the RN values
byte1 = ((byte[i*4+1] + 128 ) % 256) - 128
byte2 = ((byte[i*4+2] + 128 ) % 256) - 128
byte3 = ((byte[i*4+3] + 128 ) % 256) - 128
byte4 = ((byte[i*4+4] + 128 ) % 256) - 128
line=1
col=1
pol=0
----------------------------byte1 column----------------------------
if byte1 % 64 > 31 then col=col+4 end
if byte1 % 16 > 7 then pol=pol+1 end
----------------------------byte1 line----------------------------
if byte1 % 256 > 127 then line=line+2 end
----------------------------byte2 column----------------------------
C=2*math.floor((byte2 % 32)/8)
D=1
col=col+D*C
if byte2 % 8 > 3 then pol=pol+1 end
if byte2 % 128 > 63 then pol=pol+1 end
----------------------------byte2 line----------------------------
line=((line-1) % 16) + 1
F=line
G=2*math.floor(byte2/64)
if byte1 % 256 > 127 then G=-G end
line=line+G
if (line-1) % 16 > 7 then
if (F-1) % 16 < 8 then line=line+8 end
else if (F-1) % 16 > 7 then line=line+8 end
end
----------------------------byte3----------------------------
if byte3 % 2 == 1 then
line=line+8
col=col+4
end
if byte3 % 8 > 3 then
F=2
if byte2 % 128 > 63 then F=-F end
if byte1 % 256 > 127 then F=-F end
line=line+F
end
if byte3 % 64 > 31 then
if line % 2 == 1 then
line=line+1
else line=line-1
end
pol=pol+1
end
A=2*math.floor((byte3 % 32)/8)
if byte2 % 16 > 7 then A=-A end
if byte3 % 128 > 63 then A=-A end
col=col+A
Q=2*math.floor(byte3/64)
if byte2 % 16 > 7 then Q=-Q end
col=col+Q
----------------------------byte4 column----------------------------
M=2*math.floor(byte4/64)
A=2*math.floor(byte4/4)
if byte4 % 128 > 63 then A=-A end
if byte2 % 16 > 7 then
A=-A
M=-M
end
if byte3 % 16 > 7 then
A=-A
M=-M
end
if byte3 % 128 > 63 then
A=-A
M=-M
end
col=col+A+M
if byte4 % 4 > 1 then pol=pol+1 end
----------------------------byte4 column----------------------------
if byte4 % 2 == 1 then line=line+8 end
J=2*math.floor(byte4/32)
if byte3 % 8 > 3 then J=-J end
if byte2 % 128 > 63 then J=-J end
if byte1 % 256 > 127 then J=-J end
if byte4 % 32 > 15 then
if line % 2 == 1 then line=line+1
else line=line-1
end
end
line=line+J
K=2*math.floor(byte4/2)
if byte3 % 8 > 3 then K=-K end
if byte2 % 128 > 63 then K=-K end
if byte1 % 256 > 127 then K=-K end
if byte4 % 64 > 31 then K=-K end
line=line+K
L=1
if byte4 % 64 > 31 then L=-L end
if byte4 % 128 > 63 then L=-L end
if byte3 % 8 > 3 then L=-L end
if byte2 % 256 > 127 then L=-L end
if byte2 % 128 > 63 then L=-L end
if byte1 % 256 > 127 then L=-L end
if (L==-1) and byte4 % 8 > 3 then line=line+8 end
N=1
if byte1 % 256 > 127 then N=-N end
if byte2 % 256 > 127 then N=-N end
if byte2 % 128 > 63 then N=-N end
if byte3 % 8 > 3 then N=-N end
if N==-1 and (byte4 % 128 > 63) then line=line+8 end
-------------------------------------------------------------
pol=pol % 2
if pol == 1 then col=col+1 end
line=((line-1) % 16)+1
col=((col-1) % 8)+1
predict[i+1]=rngvalues[line][col]
end -- End of Loop 2
local file = io.open("rng2.txt", "w")
--for i=2205, 2215 do
for i=279, 370 do
-- if predict[i] < 9 then
-- file:write(i," ",predict[i],"\n")
-- end
end
file:close()
--for i=1, table.getn(byte) do
-- file:write(byte[i*624+4]," ",byte[i*624+3]," ",byte[i*624+2]," ",byte[i*624+1], "\n")
-- file:write(byte[i],"\n")
--end
rng=memory.read_u16_le(0x000CC270)
rnindex = rng-3
loop = 1
dummy = 0
start = 00000
i = rnindex + 3 + start
--i = start
hit = {0,0,0}
while dummy < table.getn(hit) and i < math.min(rng + 100001, table.getn(predict)-1-table.getn(op)) do
ibis = i
a=0
cnt=0
if predict[ibis-1] ~= 255 then
while cnt < table.getn(op) and ibis < table.getn(predict) do
if predict[ibis] ~= 255 then
if op2[cnt+1] == "<" then
if predict[ibis] < op[cnt+1] then
a = a + 1
end
elseif op2[cnt+1] == ">" then
if predict[ibis] > op[cnt+1] then
a = a + 1
end
end
cnt = cnt + 1
end
ibis = ibis + 1
end
end
if a == table.getn(op) then
dummy = dummy + 1
hit[dummy] = i
end
i = i + 1
end
--if dummy > 0 then
-- hit = i
--end
while true do
ref=rng
res={}
for i=1, 25 do
res[i]=0
end
beg=rnindex+4
beg2=beg
while predict[beg2]==255 do
beg2=beg2+1
end
res[9]=predict[beg2]
for i=-8, -1 do
beg=beg-1
out=0
while out==0 do
if beg<=0 then break end
while predict[beg]==255 do
beg=beg-1
end
out=1
end
if beg>0 then res[-i]=predict[beg] end
end
for i=10, 31 do
beg2=beg2+1
while predict[beg2]==255 do
beg2=beg2+1
end
res[i]=predict[beg2]
end
while rng==ref do
if res[1]>0 then gui.drawText(775,06,res[1]) end
if res[2]>0 then gui.drawText(775,21,res[2]) end
if res[3]>0 then gui.drawText(775,36,res[3]) end
if res[4]>0 then gui.drawText(775,51,res[4]) end
if res[5]>0 then gui.drawText(775,66,res[5]) end
if res[6]>0 then gui.drawText(775,81,res[6]) end
if res[7]>0 then gui.drawText(775,96,res[7]) end
if res[8]>0 then gui.drawText(775,111,res[8]) end
gui.drawText(775,126,res[9])
gui.drawText(775,141,res[10])
gui.drawText(775,156,res[11])
gui.drawText(775,171,res[12])
gui.drawText(775,186,res[13])
gui.drawText(775,201,res[14])
gui.drawText(775,216,res[15])
gui.drawText(775,231,res[16])
gui.drawText(775,246,res[17])
gui.drawText(775,261,res[18])
gui.drawText(775,276,res[19])
gui.drawText(775,291,res[20])
gui.drawText(775,306,res[21])
gui.drawText(775,321,res[22])
gui.drawText(775,336,res[23])
gui.drawText(775,351,res[24])
gui.drawText(775,366,res[25])
gui.drawText(775,381,res[26])
gui.drawText(775,396,res[27])
gui.drawText(775,414,res[28])
gui.drawText(775,429,res[29])
gui.drawText(775,444,res[30])
gui.drawText(775,459,res[31])
gui.drawText(760,126,"->")
gui.drawText(725,88,rng,"blue")
gui.drawText(725,103,loop,"blue")
gui.drawText(725,118,"Next")
gui.drawText(730,133,"RN")
f1 = emu.framecount()
for i=1, table.getn(hit), 1 do
if 0<=(hit[i]-4-rnindex) then
gui.drawText(725,141+15*i,hit[i]-4-rnindex,"red")
if (hit[i]-4-rnindex)<=31 then
gui.drawText(760,126+15*(hit[i]-4-rnindex),"->","red")
end
end
end
gui.drawText(725,318,client.borderheight())
gui.drawText(725,333,client.borderwidth())
gui.drawText(725,348,client.bufferheight())
gui.drawText(725,363,client.bufferwidth())
gui.drawText(725,378,client.screenheight())
gui.drawText(725,393,client.screenwidth())
emu.frameadvance();
rng=memory.read_u16_le(0x000CC270)
end
f2 = emu.framecount()
if f2 ~= f1 + 1 then
dummy = 0
i = 0
dw = memory.read_u32_le(0x000E9848)
while dummy == 0 and i < math.floor(nb/624+1) do
if 256*256*256*byte[624*i*4+4] + 256*256*byte[624*i*4+3] + 256*byte[624*i*4+2] + byte[624*i*4+1] == dw then
dummy = 1
end
i = i + 1
end
if dummy == 1 then
loop = i
rnindex = (loop-1)*624 + rng - 3
else break
end
else
if rng == 624 then
if byte[1]==0 and byte[2]==0 and byte[3]==0 and byte[4]==0 then
break
end
end
if rng < ref then
loop = loop + 1
end
rnindex = rnindex + ((rng - ref) % 624)
end
if (f2 ~= f1 + 1) or (hit[1]-4-rnindex) < 0 then --Calculate the new 3 closest RN
dummy = 0
--i = start
i = rnindex + 3
hit = {0,0,0}
while dummy < table.getn(hit) and i < math.min(rng + 100001, table.getn(predict)-1-table.getn(op)) do
ibis = i
a=0
cnt=0
if predict[ibis-1] ~= 255 then
while cnt < table.getn(op) and ibis < table.getn(predict) do
if predict[ibis] ~= 255 then
if op2[cnt+1] == "<" then
if predict[ibis] < op[cnt+1] then
a = a + 1
end
elseif op2[cnt+1] == ">" then
if predict[ibis] > op[cnt+1] then
a = a + 1
end
end
cnt = cnt + 1
end
ibis = ibis + 1
end
end
if a == table.getn(op) then
dummy = dummy + 1
hit[dummy] = i
end
i = i + 1
end
end
end
end --Restart the whole script