-
-
Save realmonster/11fbc8641e0ca6002cd10259b4c80133 to your computer and use it in GitHub Desktop.
Doom Troopers TAS Lua
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
-- Doom Troopers script for gens/bizhawk for TAS | |
-- by r57shell | |
local scrollx = 0 | |
local scrolly = 0 | |
local level = 0 | |
local level_prev = -1 | |
local wblocks = 0 | |
local hblocks = 0 | |
local blocks = nil | |
local cdata = nil | |
local invmap = {} | |
local ru8, ru16, ru32, rs8, rs16, rs32 | |
colors = { | |
[1] = 0xFFFFFF99, -- wall | |
[2] = 0xFFFFFF30, -- left | |
[3] = 0xFFFFFF30, -- right | |
[6] = 0x0000FF99, -- ceil | |
[10] = 0x00FF0099, -- exit | |
[15] = 0x99990099, -- player respawn | |
[16] = 0xFF000099, -- pit / lava | |
[17] = 0x00FF0099, -- mercury 2 secret room 1 exit | |
[18] = 0x00FF0099, -- mercury 2 secret room 1 teleport | |
[19] = 0x00FF0099, -- mercury 2 secret room 2 teleport | |
[23] = 0x00FF0099, -- mercury 1 secret room exit | |
[24] = 0x00FF0099, -- mercury 1 secret room teleport | |
[57] = 0xFF000099, -- nero spikes | |
[65] = 0x00FF0099, -- nero secret level | |
[66] = 0x00FF0099, -- nero secret level exit | |
} | |
local ground_color = 0x00FFFF99 | |
local text_color = 0xFFFFFFFF | |
local obj_text_color = 0x00FF00FF | |
local obj_color = 0x00FF00FF | |
local wind_color = 0x0000FF99 | |
local red = 0xFF0000FF | |
local cached = true | |
local bad_level = { | |
[3] = true, -- story | |
[4] = true, -- character selection | |
[5] = true, -- character selection 2 | |
[10] = true, -- title | |
[12] = true, -- planet 1 screen | |
[19] = true, -- planet 2 screen | |
[26] = true, -- planet 3 screen | |
[33] = true, -- planet 4 screen | |
[40] = true, -- victory | |
[41] = true, -- credits | |
[47] = true, -- rights | |
[52] = true, -- sega | |
[53] = true, -- RE | |
[54] = true, -- AE | |
} | |
local gui_text, gui_box, gui_line, gui_pixel | |
if gens then | |
ru8 = memory.readbyteunsigned | |
ru16 = memory.readwordunsigned | |
ru32 = memory.readlongunsigned | |
rs8 = memory.readbytesigned | |
rs16 = memory.readwordsigned | |
rs32 = memory.readlongsigned | |
gui_text, gui_line, gui_pixel = gui.text, gui.line, gui.setpixel | |
local gb = gui.box | |
function gui_box(x1, y1, x2, y2, c, o) | |
gb(x1, y1, x2, y2, o, c) | |
end | |
else | |
ru8 = memory.read_u8 | |
ru16 = memory.read_u16_be | |
ru32 = memory.read_u32_be | |
rs8 = memory.read_s8 | |
rs16 = memory.read_s16_be | |
rs32 = memory.read_s32_be | |
gui_text = gui.pixelText | |
gui_box = gui.drawBox | |
gui_line = gui.drawLine | |
gui_pixel = gui.drawPixel | |
function cconvert(c) | |
if type(c) == "string" then | |
c = tonumber(c,16) | |
end | |
return bit.band(c, 0xFFFFFF00) / 0x100 + bit.band(c, 0xFF) * 0x1000000 | |
end | |
for i = 0, 0xFF do | |
if colors[i] then | |
colors[i] = cconvert(colors[i]) | |
end | |
end | |
ground_color = cconvert(ground_color) | |
text_color = cconvert(text_color) | |
obj_text_color = cconvert(obj_text_color) | |
obj_color = cconvert(obj_color) | |
wind_color = cconvert(wind_color) | |
red = cconvert(red) | |
end | |
local max, min, floor = math.max, math.min, math.floor | |
gui_pixel_, gui_box_, gui_line_ = gui_pixel, gui_box, gui_line | |
local func_chunk = | |
[[local gui_box, gui_line, gui_pixel = gui_box_, gui_line_, gui_pixel_ | |
return function (x,y) | |
]] | |
-- splits tile into axis aligned rectangles of same color | |
-- w - width, h - height, data - actual tile colors. nil ignored. | |
-- returns list of rectangles. | |
-- all rectangles defined by: type, x1, y1, x2, y2, color | |
-- type is rectangle color, type should be ignored | |
-- x1, y1 - minimum x, y inclusive | |
-- x2, y2 - maximum x, y inclusive | |
function tile_split_simple(data, w, h) | |
local arr = {} | |
for x = 0, w-1 do | |
for y = 0, h-1 do | |
local v = data[y*w+x] | |
if v then | |
local t,x1,y1,x2,y2,z = unpack(arr[#arr] or {}) | |
if z == v | |
and t < 2 | |
and x2 == x | |
and y2 == y-1 then | |
arr[#arr][1] = 1 | |
arr[#arr][5] = y | |
local tt,xx1,yy1,xx2,yy2,zz = unpack(arr[#arr-1] or {}) | |
if (tt == 1 or tt == 2) | |
and zz == z | |
and yy1 == y1 | |
and yy2 == y | |
and xx2 == x-1 then | |
arr[#arr] = nil | |
arr[#arr][1] = 2 | |
arr[#arr][4] = x | |
end | |
else | |
arr[#arr+1] = {0,x,y,x,y,v} | |
end | |
end | |
end | |
end | |
return arr | |
end | |
-- flips tile data and splitter list vertically | |
function tile_splitter_vflip(data, w, h, list) | |
n = {} | |
for y = 0, h-1 do | |
for x = 0, w-1 do | |
n[(h-1-y)*w+x] = data[y*w+x] | |
end | |
end | |
for i = 1, #list do | |
local a = list[i] | |
a[3], a[5] = h-1-a[5], h-1-a[3] | |
end | |
return n | |
end | |
-- flips tile data and splitter list diagonally | |
function tile_splitter_dflip(data, w, h, list) | |
n = {} | |
for y = 0, h-1 do | |
for x = 0, w-1 do | |
n[x*h+y] = data[y*w+x] | |
end | |
end | |
for i = 1, #list do | |
local a = list[i] | |
a[2], a[3], a[4], a[5] = a[3], a[2], a[5], a[4] | |
end | |
return n | |
end | |
-- adds pixel to the tile | |
function tile_splitter_add(self, x, y, color) | |
if color then | |
table.insert(self, x) | |
table.insert(self, y) | |
table.insert(self, color) | |
end | |
end | |
function tile_splitter_split(self) | |
if #self < 3 then return {} end | |
-- find bound box | |
local minx, maxx, miny, maxy = self[1], self[1], self[2], self[2] | |
for i = 4, #self, 3 do | |
local x, y = unpack(self, i, i+1) | |
minx = min(minx, x) | |
maxx = max(maxx, x) | |
miny = min(miny, y) | |
maxy = max(maxy, y) | |
end | |
-- crop bounding box | |
maxx = maxx + 1 | |
maxy = maxy + 1 | |
local w, h = maxx-minx, maxy-miny | |
data = {} | |
for i = 1, #self, 3 do | |
local x, y, color = unpack(self, i, i+2) | |
data[(y-miny)*w+(x-minx)] = color | |
end | |
-- try all scan orders and pick the best | |
local best = nil | |
for i = 1, 4 do | |
local list = tile_split_simple(data, w, h) | |
if best == nil or #list < #best then | |
best = list | |
end | |
data = tile_splitter_vflip(data, w, h, best) | |
list = tile_split_simple(data, w, h) | |
if best == nil or #list < #best then | |
best = list | |
end | |
data = tile_splitter_dflip(data, w, h, best) | |
w, h = h, w -- swap w, h because we flipped it diagonaly | |
end | |
-- shift it back to original position | |
for i = 1, #best do | |
best[i][2] = best[i][2] + minx | |
best[i][3] = best[i][3] + miny | |
best[i][4] = best[i][4] + minx | |
best[i][5] = best[i][5] + miny | |
end | |
return best | |
end | |
tile_splitter_metatable = { | |
__index = { | |
add = tile_splitter_add, | |
split = tile_splitter_split, | |
}, | |
} | |
function tile_splitter() | |
local self = {} | |
setmetatable(self, tile_splitter_metatable) | |
return self | |
end | |
-- converts list returned by splitter into function code. | |
function tile_generator(arr) | |
f = "" | |
for i = 1, #arr do | |
local t,x1,y1,x2,y2,z = unpack(arr[i]) | |
if x1 == x2 and y1 == y2 then | |
f = f.."gui_pixel(x+"..x2..",y+"..y2..","..z..")\n" | |
elseif x1 == x2 or y1 == y2 then | |
f = f.."gui_line(x+"..x1..",y+"..y1.. | |
",x+"..x2..",y+"..y2..","..z..")\n" | |
else | |
f = f.."gui_box(x+"..x1..",y+"..y1.. | |
",x+"..x2..",y+"..y2..","..z..","..z..")\n" | |
end | |
end | |
return f | |
end | |
function climb(s) | |
local ts = tile_splitter() | |
for x = 0, 15 do | |
for y = 0, 15 do | |
if math.abs(x - s) + math.abs(y) < 10 | |
or x == 0 or x == 15 or y == 0 or y == 15 then | |
ts:add(x, y, colors[1]) | |
end | |
end | |
end | |
local arr = ts:split() | |
local f = tile_generator(arr) | |
f = func_chunk..f.."end" | |
return loadstring(f)() | |
end | |
function climb_wall(s) | |
local ts = tile_splitter() | |
for x = 0, 15 do | |
for y = 0, 15 do | |
if math.abs(x - s) < 1 | |
or y - floor(y / 3) * 3 == 0 and math.abs(x - s) < 3 then | |
ts:add(x, y, colors[1]) | |
end | |
end | |
end | |
local arr = ts:split() | |
local f = tile_generator(arr) | |
f = func_chunk..f.."end" | |
return loadstring(f)() | |
end | |
function flowf(dx, dy) | |
local len = math.sqrt(dx * dx + dy * dy) | |
local nx, ny = dx / len, dy / len | |
dx = dx * 1 | |
dy = dy * 1 | |
dx = dx + 8 | |
dy = dy + 8 | |
local al = 2 | |
local dx1, dy1 = dx - (nx - ny) * al, dy - (ny + nx) * al | |
local dx2, dy2 = dx - (nx + ny) * al, dy - (ny - nx) * al | |
local c = wind_color | |
return function(x, y) | |
gui_line(x + 8, y + 8, x + dx, y + dy, c) | |
gui_line(x + dx, y + dy, x + dx1, y + dy1, c) | |
gui_line(x + dx, y + dy, x + dx2, y + dy2, c) | |
gui_box(x, y, x + 15, y + 15, c, 0) | |
end | |
end | |
local climb_wall_r = climb_wall(0) | |
local climb_wall_l = climb_wall(15) | |
local callbacks = { | |
[4] = function (x, y) end, | |
[5] = function (x, y) end, | |
[7] = function(x, y) climb_wall_r(x, y) climb_wall_l(x, y) end, | |
[11] = climb(0), -- climb right | |
[12] = climb(15), -- climb left | |
[13] = climb_wall_r, -- climb wall right | |
[14] = climb_wall_l, -- climb wall left | |
[0x19] = flowf(-1, 0), | |
[0x1A] = flowf(-2, 0), | |
[0x1B] = flowf(-6, 0), | |
[0x1D] = flowf(1, 0), | |
[0x1E] = flowf(2, 0), | |
[0x24] = flowf(0, -14), | |
[0x25] = flowf(1, -1), | |
[0x26] = flowf(2, -6), | |
[0x27] = flowf(6, -10), | |
[0x28] = flowf(8, -13), | |
[0x29] = flowf(-1, -1), | |
[0x2A] = flowf(-2, -6), | |
[0x2B] = flowf(-6, -10), | |
[0x2C] = flowf(-8, -13), | |
[0x30] = flowf(0, 13), | |
[0x33] = flowf(6, 10), | |
[0x34] = flowf(8, 13), | |
[0x35] = flowf(-1, 1), | |
[0x36] = flowf(-2, 6), | |
} | |
for i = 0, 0xFF do | |
if colors[i] and not callbacks[i] then | |
local c = colors[i] | |
callbacks[i] = function (x, y) gui_box(x, y, x + 15, y + 15, c, c) end | |
end | |
end | |
function loadlevel() | |
wblocks = floor(ru16(0xFF00C0) / 16) | |
hblocks = floor(ru16(0xFF00C2) / 16) | |
if wblocks == 0 or hblocks == 0 then | |
level_prev = -1 | |
return | |
end | |
level_prev = level | |
--local offs = 0x54FEC + level * 2 | |
--offs = offs + ru16(offs) | |
cdata = {} | |
blocks = {} | |
invmap = {} | |
local BC = ru32(0xFF00BC) | |
local B4 = ru32(0xFF00B4) | |
local B8 = ru32(0xFF00B8) | |
for y = 0, hblocks - 1 do | |
for x = 0, wblocks - 1 do | |
local yy = ru16(BC + y * 2) + x * 2 | |
local aa = yy - floor(yy / 0x10000) * 0x10000 + floor(BC / 0x10000) * 0x10000 | |
local a = B4 + floor(ru16(aa) / 2) | |
local t = ru8(a + 2) | |
invmap[aa] = {x * 16, y * 16, t} | |
local dd = ru16(a) | |
local b8o = ru16(0xFF00C4 + floor(dd / 4)) | |
local b8d = B8 + b8o | |
if cached then | |
blocks[y * wblocks + x + 1] = {t, b8d} | |
end | |
if cdata[b8d] == nil then | |
local ts = tile_splitter() | |
for xxx = 0, 15 do | |
local v = ru8(b8d + xxx) | |
if v > 0 then | |
ts:add(xxx, v - 1, ground_color) | |
end | |
end | |
local arr = ts:split() | |
local f = tile_generator(arr) | |
f = func_chunk..f.."end" | |
cdata[b8d] = loadstring(f)() | |
end | |
end | |
end | |
end | |
function drawcell(x, y, t) | |
local c = callbacks[t] | |
if c then | |
c(x - scrollx, y - scrolly) | |
else | |
gui_text(x + 6 - scrollx, y + 5 - scrolly, string.format("%X", t), text_color) | |
end | |
end | |
function drawcell_high(x, y, t) | |
local c = callbacks[t] | |
if c then | |
c(x - scrollx, y - scrolly) | |
c(x - scrollx, y - scrolly) | |
c(x - scrollx, y - scrolly) | |
else | |
gui_text(x + 6 - scrollx, y + 5 - scrolly, string.format("%X", t), text_color) | |
end | |
end | |
function drawcollision() | |
if level_prev ~= level then | |
loadlevel() | |
if level_prev ~= level then | |
return | |
end | |
end | |
local BC = ru32(0xFF00BC) | |
local BCC = floor(BC / 0x10000) * 0x10000 | |
local B4 = ru32(0xFF00B4) | |
local B8 = ru32(0xFF00B8) | |
local left, right, top, bottom = scrollx, scrollx + 320, scrolly, scrolly + 224 | |
if cached then | |
for y_ = max(0,floor(top/16)), min(hblocks-1,floor((bottom-1)/16)) do | |
local y = y_ * 16 | |
for x_ = max(0,floor(left/16)), min(wblocks-1,floor((right-1)/16)) do | |
local tt = blocks[y_ * wblocks + x_ + 1] | |
if tt then | |
local x = x_ * 16 | |
local t, b = unpack(tt) | |
if t > 0 then | |
drawcell(x, y, t) | |
end | |
local f = cdata[b] | |
if f then | |
f(x - scrollx, y - scrolly) | |
end | |
end | |
end | |
end | |
else | |
for y_ = max(0,floor(top/16)), min(hblocks-1,floor((bottom-1)/16)) do | |
local y = y_ * 16 | |
local y1 = ru16(BC + y_ * 2) | |
for x_ = max(0,floor(left/16)), min(wblocks-1,floor((right-1)/16)) do | |
local x = x_*16 | |
local yy = y1 + x_ * 2 | |
local aa = yy - floor(yy / 0x10000) * 0x10000 + BCC | |
local a = B4 + floor(ru16(aa) / 2) | |
local t = ru8(a + 2) | |
local idx = ru16(a) | |
local b8o = ru16(0xFF00C4 + floor(idx / 4)) | |
local b8d = B8 + b8o | |
local f = cdata[b8d] | |
if t > 0 then | |
drawcell(x, y, t) | |
end | |
if f then | |
f(x - scrollx, y - scrolly) | |
else | |
for i = 0, 15 do | |
local v = ru8(b8d + i) | |
if v > 0 then | |
gui_pixel(x - scrollx + i, y - scrolly + v - 1, ground_color) | |
end | |
end | |
end | |
end | |
end | |
end | |
end | |
function mercury_boss(dx, dy, ax, ay, tx, ty) | |
if dx < 0 then | |
if -dx < 2 then | |
elseif -dx < 20 then | |
ax, tx = 4, 0x20 | |
else | |
ax, tx = 0x28, 0x400 | |
end | |
else | |
if dx < 2 then | |
elseif dx < 20 then | |
ax, tx = 4, -0x20 | |
elseif dx < 40 then | |
ax, tx = 15, -0x200 | |
else | |
ax, tx = 0x28, -0x400 | |
end | |
end | |
if dy < 0 then | |
if -dy < 3 then | |
elseif -dy < 20 then | |
ay, ty = 4, 0x20 | |
elseif -dy < 40 then | |
ay, ty = 15, 0x200 | |
else | |
ay, ty = 0x28, 0x400 | |
end | |
else | |
if dy < 3 then | |
elseif dy < 20 then | |
ay, ty = 4, -0x20 | |
elseif dy < 40 then | |
ay, ty = 15, -0x200 | |
else | |
ay, ty = 0x28, -0x400 | |
end | |
end | |
return ax, ay, tx, ty | |
end | |
function mercury_drone(x, y, ax, ay, tx, ty, s) | |
local dx, dy | |
if x > 0 then | |
if y > 0 then | |
dx = x + s | |
dy = y - s | |
else | |
dx = x - s | |
dy = y - s | |
end | |
else | |
if y > 0 then | |
dx = x + s | |
dy = y + s | |
else | |
dx = x - s | |
dy = y + s | |
end | |
end | |
if dx <= 0 then | |
tx = 0x500 | |
else | |
tx = -0x500 | |
end | |
if dy <= 0 then | |
ty = 0x500 | |
else | |
ty = -0x500 | |
end | |
return ax, ay, tx, ty | |
end | |
function traj(n, f, rx, ry, xx, yy, ax, ay, sx, sy, tx, ty, ss) | |
for i = 1, n do | |
ax, ay, tx, ty = f(floor(rx / 256) - xx, floor(ry / 256) - yy, ax, ay, tx, ty, ss) | |
if sx == tx then | |
elseif sx < tx then | |
sx = sx + ax | |
if sx > tx then sx = tx end | |
elseif sx > tx then | |
sx = sx - ax | |
if sx < tx then sx = tx end | |
end | |
if sy == ty then | |
elseif sy < ty then | |
sy = sy + ay | |
if sy > ty then sy = ty end | |
elseif sy > ty then | |
sy = sy - ay | |
if sy < ty then sy = ty end | |
end | |
gui_line(rx / 256, ry / 256, (rx + sx) / 256, (ry + sy) / 256, red) | |
rx = rx + sx | |
ry = ry + sy | |
end | |
end | |
local function rpos(addr) | |
local r = ru32(addr) | |
r = r - floor(r / 0x1000000) * 0x1000000 | |
if r > 0x800000 then | |
return r - 0x1000000 | |
else | |
return r | |
end | |
end | |
local mercury_boss_attacks = {'F', 'F', 'D', 'S', 'd'} | |
function drawobjs() | |
for i = 0, 100 do | |
local base = ru16(0xFF2BBA + i*2) | |
if base == 0 then | |
break | |
end | |
base = base + 0xFF0000 | |
local x = ru16(base + 0x32) - scrollx | |
local y = ru16(base + 0x34) - scrolly | |
local hp = rs16(base + 0x32 + 0x4A) | |
local proc = ru32(base + 0x8C) | |
if proc == 0x64028 or proc == 0x63FDE then | |
hp = rs16(base + 0x7C) | |
gui_text(85, 8, string.format("boss atk:%3d mv:%3d aim:%2d", rs16(base + 0xA4), rs16(base + 0xA0), rs16(base + 0xA8)), obj_text_color) | |
local atk = ru8(base + 0xA6) | |
local D, S, F = ' ', ' ', ' ' | |
if atk - floor(atk / 8) * 8 >= 4 then D = 'D' end | |
if atk - floor(atk / 4) * 4 >= 2 then S = 'S' end | |
if atk - floor(atk / 2) * 2 >= 1 then F = 'F' end | |
local pt = ru16(base + 0x7A) -- player target | |
local na = ru16(base + 0xA2) -- next attack | |
if na >= 3 then | |
na = 3 | |
if pt ~= 0 and rs16(0xFF0000 + pt + 0x34) <= rs16(base + 0x34) then | |
na = 4 -- staff failed | |
end | |
end | |
gui_text(90, 16, string.format("hp:%d %s %s", hp, mercury_boss_attacks[na + 1], D..S..F), obj_text_color) | |
local xx = rs16(base + 0xAA) - scrollx | |
local yy = rs16(base + 0xAC) - scrolly | |
local tsx = rs16(base + 0x5A) + rs16(base + 0x5C) | |
local tsy = rs16(base + 0x64) + rs16(base + 0x66) | |
local sx = rs16(base + 0x46) | |
local sy = rs16(base + 0x48) | |
local ax = rs16(base + 0x60) | |
local ay = rs16(base + 0x62) | |
local rx = rpos(base + 0x4E) - scrollx * 256 | |
local ry = rpos(base + 0x52) - scrolly * 256 | |
traj(rs16(base + 0xA0), mercury_boss, rx, ry, xx, yy, ax, ay, sx, sy, tsx, tsy) | |
if pt ~= 0 then | |
local px = rs16(0xFF0000 + pt + 0x32) - scrollx | |
local py = rs16(0xFF0000 + pt + 0x34) - scrolly | |
gui_box(px - 2, py - 2, px + 2, py + 2, red, 0) | |
end | |
gui_box(xx - 1, yy - 1, xx + 1, yy + 1, red, red) | |
gui_line(x, y, xx, yy, red) | |
end | |
if proc == 0x64820 or proc == 0x647E0 then | |
gui_text(140, 16, string.format("b:%3d mv:%2d", rs16(base + 0xAA), rs16(base + 0xAC)), obj_text_color) | |
local xx = ru16(base + 0xA6) - scrollx | |
local yy = ru16(base + 0xA8) - scrolly | |
local r = ru16(base + 0xA4) | |
local tsx = rs16(base + 0x5A) + rs16(base + 0x5C) | |
local tsy = rs16(base + 0x64) + rs16(base + 0x66) | |
local sx = rs16(base + 0x46) | |
local sy = rs16(base + 0x48) | |
local ax = rs16(base + 0x60) | |
local ay = rs16(base + 0x62) | |
local rx = rpos(base + 0x4E) - scrollx * 256 | |
local ry = rpos(base + 0x52) - scrolly * 256 | |
traj(rs16(base + 0xAC), mercury_drone, rx, ry, xx, yy, ax, ay, sx, sy, tsx, tsy, r) | |
if r == 0 then r = 1 end | |
gui_box(xx - r, yy - r, xx + r, yy + r, red, 0) | |
gui_line(x, y, xx, yy, red) | |
end | |
if x + 16 >= 0 and x < 320 | |
and y + 16 >= 0 and y < 224 then | |
gui_box(x - 1, y - 1, x + 1, y + 1, obj_color) | |
if hp > 0 then | |
gui_text(x - 1, y - 10, string.format("%d", hp), obj_text_color) | |
end | |
local z = ru8(base + 0x40) | |
if ru32(base + 0x68) == 0x51412 | |
and z - floor(z / 128) * 128 >= 64 then | |
local width = ru8(base + 0x44) | |
local height = ru8(base + 0x45) | |
if height > 0x80 then height = height - 0x100 end | |
gui_box(x - width, y + height, x + width, y, obj_color, 0) | |
end | |
end | |
end | |
end | |
function speed(v) | |
local vv | |
local r = ' ' | |
if v < 0 then | |
r = '-' | |
v = -v | |
end | |
vv = floor(v / 256) | |
return r..string.format("%d.%02d", vv, floor((v - vv * 256) * 100 / 256)) | |
end | |
function player_text(player, posx, posy) | |
local xpos = ru16(player + 0x32 + 0x0) | |
local ypos = ru16(player + 0x32 + 0x2) | |
local xspeed = rs16(player + 0x46) | |
local yspeed = rs16(player + 0x48) | |
local hp = rs16(player + 0x32 + 0x4A) | |
local wt, wb | |
if posx < 100 then | |
wt = ru8(0xFF0048 + 0x23) | |
wb = ru16(0xFF0048 + 0xE) | |
else | |
wt = ru8(0xFF006E + 0x23) | |
wb = ru16(0xFF006E + 0xE) | |
end | |
local text = string.format("x:%6d y:%6d sx:%s sy:%s", xpos, ypos, speed(xspeed), speed(yspeed)) | |
gui_text(posx, posy, text) | |
text = string.format("hp: %d w:%d b:%d", hp, wt, wb) | |
gui_text(posx, posy + 8, text) | |
end | |
function render() | |
level = ru16(0xFF002C) | |
if bad_level[level] then | |
level_prev = -1 | |
return | |
end | |
local player1 = 0xFF0642 | |
local player2 = ru16(0xFF0078) --0xFF06F0 | |
player_text(player1, 20, 0) | |
if player2 > 0 then | |
player_text(0xFF0000+player2, 195, 0) | |
end | |
scrollx = rs16(0xFF2DEE) | |
scrolly = rs16(0xFF2DF0) | |
drawcollision() | |
drawobjs() | |
end | |
function cell_check(a) | |
if invmap[a] then | |
local x, y, t = unpack(invmap[a]) | |
if t > 0 then | |
drawcell_high(x, y, t) | |
else | |
--gui_box(x - scrollx, y - scrolly, x + 15 - scrollx, y + 15 - scrolly, obj_color) | |
end | |
end | |
end | |
if gens then | |
memory.registerexec(0x5132C,function () | |
cell_check(memory.getregister("a1")) | |
end) | |
memory.registerexec(0x509C0,function () | |
cell_check(memory.getregister("a1")) | |
end) | |
gui.register(render) | |
else | |
event.onmemoryexecute(function () | |
cell_check(emu.getregister("M68K A1")) | |
end, 0x5132C) | |
event.onmemoryexecute(function () | |
cell_check(emu.getregister("M68K A1")) | |
end, 0x509C0) | |
event.onframeend(render) | |
end |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment