SHARE
TWEET

dq5rngsimulation.lua

a guest Nov 24th, 2011 59 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. enc100 = {4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,10,10,10,10,10,
  2. 10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,10,
  3. 10,10,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,
  4. 28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,
  5. 28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,
  6. 28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,
  7. 28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,
  8. 28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,
  9. 28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,28,}
  10.  
  11. --enc100の値は必要に応じて変更する
  12. rand = {}
  13. start = memory.readbyte(0x7E1A9A)
  14. step = 159
  15. stop = {999,999,999,999,999}
  16. avoid = true
  17. teki = 999
  18. text = "Fail"
  19. blank = {}
  20. distance = {0,0,0,0,0}
  21. input = {}
  22. for i = 1, 5 do
  23.         input[i] = {}
  24. end
  25.  
  26. blank[1] = {0,0}
  27. blank[2] = {0,0}
  28. blank[3] = {0,0}
  29. blank[4] = {0,0}
  30. blank[5] = {0,0}
  31. --同一フロア内での画面の切替えや強制待機に対応しようとしましたが、あまりうまく機能しないと思います。
  32.  
  33. seed1 = memory.readbyte(0x7E0993) + (memory.readbyte(0x7E0994) * 256)
  34. seed2 = memory.readbyte(0x7E0995) + (memory.readbyte(0x7E0996) * 256)
  35.        
  36. seedupper = math.floor(seed1 / 256)
  37. seedlower = seed1 % 256
  38. seedupper = (seedupper + (7 - (memory.readbyte(0x7E007F) % 8))) % 256
  39. seedlower = (seedlower + (7 - (memory.readbyte(0x7E007F) % 8))) % 256
  40. seed1 = seedlower + (seedupper * 256)
  41. seedlower = seed2 % 256
  42. seedlower = (seedlower + (7 - (memory.readbyte(0x7E007F) % 8))) % 256
  43. seed2 = ((math.floor(seed2 / 256) * 256) + seedlower) % 65536
  44.  
  45. seed1store = seed1
  46. seed2store = seed2
  47.        
  48. function rng()
  49.         resist1 = seed1
  50.         resist2 = seed2
  51.         carry = math.floor((seed1 * 2) / 65536)
  52.         seed1 = (seed1 * 2) % 65536
  53.         seed2 = ((seed2 * 2) + carry) % 65536
  54.         carry = math.floor((seed1 + resist1) / 65536)
  55.         seed1 = (seed1 + resist1) % 65536
  56.         seed2 = (seed2 + resist2 + carry) % 65536
  57.         carry = math.floor((seed1 + 0x15AD) / 65536)
  58.         seed1 = (seed1 + 0x15AD) % 65536
  59.         seed2 = (seed2 + carry) % 65536
  60.         rdm = seed2 % 256
  61.        
  62.         seedupper = math.floor(seed1 / 256)
  63.         seedlower = seed1 % 256
  64.         seedupper = (seedupper + 8) % 256
  65.         seedlower = (seedlower + 8) % 256
  66.         seed1 = seedlower + (seedupper * 256)
  67.         seedlower = ((seed2 % 256) + 8) % 256
  68.         seed2 = (math.floor(seed2 / 256) * 256 + seedlower) % 65536
  69.         return rdm
  70. end
  71.  
  72.  
  73. function wait(time)    
  74.         seedupper = math.floor(seed1 / 256)
  75.         seedlower = seed1 % 256
  76.         seedupper = (seedupper + time) % 256
  77.         seedlower = (seedlower + time) % 256
  78.         seed1 = seedlower + (seedupper * 256)
  79.         seedlower = ((seed2 % 256) + time) % 256
  80.         seed2 = (math.floor(seed2 / 256) * 256 + seedlower) % 65536
  81. end
  82.  
  83. i = 1
  84. while i < step - start do
  85.         rand[i] = rng()
  86.         if rand[i] < enc100[i] then teki = i
  87.                 avoid = false
  88.                 break
  89.         else text = "success" end
  90.         i = i + 1
  91. end
  92.  
  93. judge = true
  94. if avoid == false then
  95.         i = 1
  96.         while i < step + 1 - start do
  97.                 seed1 = seed1store
  98.                 seed2 = seed2store
  99.                 j = 1
  100.                
  101.                 if judge == false then break end
  102.        
  103.                 while j < step + 1 - start do
  104.                         avoid = true
  105.                         if j == 1 then
  106.                                 judge = false
  107.                         end
  108.                         for b = 1, 5 do
  109.                                 if j == blank[b][1] then
  110.                                         wait(blank[b][2])
  111.                                 end
  112.                         end
  113.                         if i == j then
  114.                                 wait(8)
  115.                                 rand[j] = 999
  116.                                 judge = true
  117.                         else rand[j] = rng() end
  118.                         if rand[j] < enc100[j] then teki = j
  119.                                 avoid = false
  120.                                 if judge == false then break end
  121.                         end
  122.                         if blank[3][2] == j then
  123.                                 if rand[j] < 129 then teki = j
  124.                                         avoid = false
  125.                                 end
  126.                         end
  127.                         if avoid == true then stop[1] = i - 1
  128.                         else
  129.                                 for x = 1, 5 do
  130.                                         if sort ~= true then
  131.                                                 if distance[x] <= j - 2 then
  132.                                                         sort = true
  133.                                                         for y = 1, 5-x do
  134.                                                                 distance[6-y] = distance[5-y]
  135.                                                                 input[6-y] = input[5-y]
  136.                                                         end
  137.                                                         distance[x] = j - 2
  138.                                                         input[x] = {i-1, j-2}
  139.                                                 end
  140.                                         end
  141.                                 end
  142.                                 sort = false
  143.                                 break
  144.                         end
  145.                         j = j + 1
  146.                 end
  147.                 if avoid == true then text = "Success"
  148.                 break end
  149.                 i = i + 1
  150.         end
  151. end
  152.  
  153. judge = true
  154. if avoid == false then
  155.         i = 1
  156.         while i < step + 1 - start do
  157.                 seed1 = seed1store
  158.                 seed2 = seed2store
  159.                 j = 1
  160.                
  161.                 if judge == false then break end
  162.                
  163.                 while j < step + 1 - start do
  164.                         avoid = true
  165.                         if j == 1 then
  166.                                 judge = false
  167.                         end
  168.                         for b = 1, 5 do
  169.                                 if j == blank[b][1] then
  170.                                         wait(blank[b][2])
  171.                                 end
  172.                         end
  173.                         if i == j then
  174.                                 wait(15)
  175.                                 rand[j] = 999
  176.                                 judge = true
  177.                         else rand[j] = rng() end
  178.                         if rand[j] < enc100[j] then teki = j
  179.                                 avoid = false
  180.                                 if judge == false then break end
  181.                         end
  182.                         if blank[3][2] == j then
  183.                                 if rand[j] < 129 then teki = j
  184.                                         avoid = false
  185.                                 end
  186.                         end
  187.                         if avoid == true then stop[1] = i + 14999
  188.                         else
  189.                                 for x = 1, 5 do
  190.                                         if sort ~= true then
  191.                                                 if distance[x] <= j - 2.875 then
  192.                                                         sort = true
  193.                                                         for y = 1, 5-x do
  194.                                                                 distance[6-y] = distance[5-y]
  195.                                                                 input[6-y] = input[5-y]
  196.                                                         end
  197.                                                         distance[x] = j - 2.875
  198.                                                         input[x] = {i+14999, j-2}
  199.                                                 end
  200.                                         end
  201.                                 end
  202.                                 sort = false
  203.                                 break
  204.                         end
  205.                         j = j + 1
  206.                 end
  207.                 if avoid == true then text = "Success"
  208.                 break end
  209.                 i = i + 1
  210.         end
  211. end
  212.  
  213. judge1 = true
  214. judge2 = true
  215. if avoid == false then
  216.         i = 1
  217.         while i < step + 2 - start do
  218.                 j = 1
  219.                 if judge2 == false then break end
  220.                
  221.                 while j < step + 2 - start do
  222.                         seed1 = seed1store
  223.                         seed2 = seed2store
  224.                         k = 1
  225.                        
  226.                         if judge1 == false then
  227.                                 judge1 = true
  228.                                 break
  229.                         end
  230.                
  231.                         while k < step + 2 - start do
  232.                                 if i > j then break end
  233.                                 avoid = true
  234.                                 if k == 1 then
  235.                                         judge1 = false
  236.                                         judge2 = false
  237.                                 end
  238.                                 hantei = false
  239.                                 for b = 1, 5 do
  240.                                         if k == blank[b][1] then
  241.                                                 wait(blank[b][2])
  242.                                         end
  243.                                 end
  244.                                 if j == k then
  245.                                         wait(8)
  246.                                         rand[k] = 999
  247.                                         judge1 = true
  248.                                         hantei = true
  249.                                 end
  250.                                 if i == k then
  251.                                         wait(8)
  252.                                         rand[k] = 999
  253.                                         judge2 = true
  254.                                 elseif hantei == false then rand[k] = rng() end
  255.                                 if rand[k] < enc100[k] then teki = j
  256.                                         avoid = false
  257.                                         if judge1 == false or judge2 == false then break end
  258.                                 end
  259.                                 if blank[3][2] == k then
  260.                                         if rand[k] < 129 then teki = j
  261.                                                 avoid = false
  262.                                         end
  263.                                 end
  264.                                 if avoid == true then stop[1] = i - 1
  265.                                         stop[2] = j - 2
  266.                                 else
  267.                                         for x = 1, 5 do
  268.                                                 if sort ~= true then
  269.                                                         if distance[x] <= k - 3 then
  270.                                                                 sort = true
  271.                                                                 for y = 1, 5-x do
  272.                                                                         distance[6-y] = distance[5-y]
  273.                                                                         input[6-y] = input[5-y]
  274.                                                                 end
  275.                                                                 distance[x] = k - 3
  276.                                                                 input[x] = {i-1, j-2, k-3}
  277.                                                         end
  278.                                                 end
  279.                                         end
  280.                                         sort = false
  281.                                         break
  282.                                 end
  283.                                 k = k + 1
  284.                         end
  285.                         if avoid == true then text = "Success"
  286.                         break end
  287.                         j = j + 1
  288.                 end
  289.                 if avoid == true then text = "Success"
  290.                 break end
  291.                 i = i + 1
  292.         end
  293. end
  294.  
  295. judge1 = true
  296. judge2 = true
  297. if avoid == false then
  298.         i = 1
  299.         while i < step + 2 - start do
  300.                 j = 1
  301.                 if judge2 == false then break end
  302.                
  303.                 while j < step + 2 - start do
  304.                         seed1 = seed1store
  305.                         seed2 = seed2store
  306.                         k = 1
  307.                
  308.                         if judge1 == false then
  309.                                 judge1 = true
  310.                                 break
  311.                         end
  312.                
  313.                         while k < step + 2 - start do
  314.                                 avoid = true
  315.                                 if k == 1 then
  316.                                         judge1 = false
  317.                                         judge2 = false
  318.                                 end
  319.                                 hantei = false
  320.                                 for b = 1, 5 do
  321.                                         if k == blank[b][1] then
  322.                                                 wait(blank[b][2])
  323.                                         end
  324.                                 end
  325.                                 if j == k then
  326.                                         wait(15)
  327.                                         rand[k] = 999
  328.                                         judge1 = true
  329.                                         hantei = true
  330.                                 end
  331.                                 if i == k then
  332.                                         wait(8)
  333.                                         rand[k] = 999
  334.                                         judge2 = true
  335.                                 elseif hantei == false then rand[k] = rng() end
  336.                                 if rand[k] < enc100[k] then teki = j
  337.                                         avoid = false
  338.                                         if judge1 == false or judge2 == false then break end
  339.                                 end
  340.                                 if blank[3][2] == k then
  341.                                         if rand[k] < 129 then teki = j
  342.                                                 avoid = false
  343.                                         end
  344.                                 end
  345.                                 if avoid == true then stop[1] = i - 1
  346.                                         stop[2] = j + 14998
  347.                                 else
  348.                                         for x = 1, 5 do
  349.                                                 if sort ~= true then
  350.                                                         if distance[x] <= k - 3.875 then
  351.                                                                 sort = true
  352.                                                                 for y = 1, 5-x do
  353.                                                                         distance[6-y] = distance[5-y]
  354.                                                                         input[6-y] = input[5-y]
  355.                                                                 end
  356.                                                                 distance[x] = k - 3.875
  357.                                                                 input[x] = {i-1, j+14998, k-3}
  358.                                                         end
  359.                                                 end
  360.                                         end
  361.                                         sort = false
  362.                                         break
  363.                                 end
  364.                                 k = k + 1
  365.                         end
  366.                         if avoid == true then text = "Success"
  367.                         break end
  368.                         j = j + 1
  369.                 end
  370.                 if avoid == true then text = "Success"
  371.                 break end
  372.                 i = i + 1
  373.         end
  374. end
  375.  
  376. judge1 = true
  377. judge2 = true
  378. judge3 = true
  379. if avoid == false then
  380.         i = 1
  381.         while i < step + 3 - start do
  382.                 j = 1
  383.                 if judge3 == false then break end
  384.                
  385.                 while j < step + 3 - start do
  386.                         k = 1
  387.                         if judge2 == false then
  388.                                 judge2 = true
  389.                                 break
  390.                         end
  391.                
  392.                         while k < step + 3 - start do
  393.                                 seed1 = seed1store
  394.                                 seed2 = seed2store
  395.                                 l = 1
  396.                                
  397.                                 if i > j then break end
  398.                                 if judge1 == false then
  399.                                         judge1 = true
  400.                                         break
  401.                                 end
  402.                                
  403.                                 while l < step + 3 - start do
  404.                                         if j > k then break end
  405.                                         avoid = true
  406.                                         if l == 1 then
  407.                                                 judge1 = false
  408.                                                 judge2 = false
  409.                                                 judge3 = false
  410.                                         end
  411.                                         hantei1 = false
  412.                                         hantei2 = false
  413.                                         for b = 1, 5 do
  414.                                                 if l == blank[b][1] then
  415.                                                         wait(blank[b][2])
  416.                                                 end
  417.                                         end
  418.                                         if k == l then
  419.                                                 wait(8)
  420.                                                 rand[l] = 999
  421.                                                 hantei1 = true
  422.                                                 judge1 = true
  423.                                         end
  424.                                         if j == l then
  425.                                                 wait(8)
  426.                                                 rand[l] = 999
  427.                                                 hantei2 = true
  428.                                                 judge2 = true
  429.                                         end
  430.                                         if i == l then
  431.                                                 wait(8)
  432.                                                 rand[l] = 999
  433.                                                 judge3 = true
  434.                                         elseif hantei1 == false and hantei2 == false then rand[l] = rng() end
  435.                                         if rand[l] < enc100[l] then teki = j
  436.                                                 avoid = false
  437.                                                 if judge1 == false or judge2 == false or judge3 == false then break end
  438.                                         end
  439.                                         if blank[3][2] == l then
  440.                                                 if rand[k] < 129 then teki = j
  441.                                                         avoid = false
  442.                                                 end
  443.                                         end
  444.                                         if avoid == true then stop[1] = i - 1
  445.                                                 stop[2] = j - 2
  446.                                                 stop[3] = k - 3
  447.                                         else
  448.                                                 for x = 1, 5 do
  449.                                                         if sort ~= true then
  450.                                                                 if distance[x] <= l - 4 then
  451.                                                                         sort = true
  452.                                                                         for y = 1, 5-x do
  453.                                                                                 distance[6-y] = distance[5-y]
  454.                                                                                 input[6-y] = input[5-y]
  455.                                                                         end
  456.                                                                         distance[x] = l - 4
  457.                                                                         input[x] = {i-1, j-2, k-3, l-4}
  458.                                                                 end
  459.                                                         end
  460.                                                 end
  461.                                                 sort = false
  462.                                                 break
  463.                                         end
  464.                                         l = l + 1
  465.                                 end
  466.                                 if avoid == true then text = "Success"
  467.                                 break end
  468.                                 k = k + 1
  469.                         end
  470.                         if avoid == true then text = "Success"
  471.                         break end
  472.                         j = j + 1
  473.                 end
  474.                 if avoid == true then text = "Success"
  475.                 break end
  476.                 i = i + 1
  477.         end
  478. end
  479.  
  480. if avoid == true then
  481.         print(stop[1]+start.." "..stop[2]+start.." "..stop[3]+start.." "..text)
  482. else
  483.         print("Fail!")
  484. end
  485. for i = 1, table.getn(distance) do
  486.         distance[i] = distance[i] + start
  487. end
  488. print(distance)
  489. for i = 1, 5 do
  490.         for j = 1, table.getn(input[i]) do
  491.                 input[i][j] = input[i][j] + start
  492.         end
  493. end
  494. print(input)
  495.  
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top