smbot/smb.lua

-- disassembly used for reference:
-- https://gist.githubusercontent.com/1wErt3r/4048722/raw/59e88c0028a58c6d7b9156749230ccac647bc7d4/SMBDIS.ASM

local band = bit.band
local floor = math.floor
local emu = emu
local gui = gui

local util = require("util")
local R = memory.readbyteunsigned
local W = memory.writebyte
local function S(addr) return util.signbyte(R(addr)) end

local valid_tiles = {
    0x00, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
    0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
    0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26,
    0x51, 0x52, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
    0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x60, 0x61,
    0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
    0x6B, 0x6C, 0x89, 0xC0, 0xC1, 0xC2, 0xC3, 0xC4,
    0xC5
}

local tile_lut = {}
for i, v in ipairs(valid_tiles) do
    tile_lut[v] = i - 1
end

local area_lut = {
    -- first digit: world number.
    -- second digit: level number.
    -- note: excludes pipe intros.
    [11] = 0, [12] = 2, [13] = 3, [14] = 4,
    [21] = 0, [22] = 2, [23] = 3, [24] = 4,
    [31] = 0, [32] = 1, [33] = 2, [34] = 3,
    [41] = 0, [42] = 2, [43] = 3, [44] = 4,
    [51] = 0, [52] = 1, [53] = 2, [54] = 3,
    [61] = 0, [62] = 1, [63] = 2, [64] = 3,
    [71] = 0, [72] = 2, [73] = 3, [74] = 4,
    [81] = 0, [82] = 1, [83] = 2, [84] = 3,
}

local rotation_offsets = { -- FIXME: not all of these are pixel-perfect.
    0, -40, -- 0x00
    6, -38,
    15, -37,
    22, -32,
    28, -28,
    32, -22,
    37, -14,
    39, -6,
    40, 0, -- 0x08
    38, 7,
    37, 15,
    33, 23,
    27, 29,
    22, 33,
    14, 37,
    6, 39,
    0, 41, -- 0x10
    -7, 40,
    -16, 38,
    -22, 34,
    -28, 28,
    -34, 23,
    -38, 16,
    -40, 8,
    -40, -0, -- 0x18
    -40, -6,
    -38, -14,
    -34, -22,
    -28, -28,
    -22, -32,
    -16, -36,
    -8, -38,
}

-- TODO: reinterface to one "input" array visible to main.lua.
local sprite_input = {}
local tile_input = {}
local extra_input = {}

local overlay = false

local function get_timer()
    return R(0x7F8) * 100 + R(0x7F9) * 10 + R(0x7FA)
end

local function get_score()
    return R(0x7DE) * 10000 +
           R(0x7DF) * 1000 +
           R(0x7E0) * 100 +
           R(0x7E1) * 10 +
           R(0x7E2)
end

local function set_timer(time)
    W(0x7F8, floor(time / 100))
    W(0x7F9, floor((time / 10) % 10))
    W(0x7FA, floor(time % 10))
end

local function mark_sprite(x, y, t)
    if t == 0 or x <= -8 or x >= 0xFF or y <= 0 or y >= 0xE8 then
        -- place unused/unseen sprites
        x = -8 -- just off the left side of the screen
        y = 0xC8 -- at ground level.
    end

    local cx = 2 * (x - 0x80) -- relative to center of screen.
    local cy = 2 * (y - 0x88) -- relative to standing on 4th block from floor.

    if x < 0 or x >= 256 or y < 0 or y > 224 then
        sprite_input[#sprite_input+1] = 0
        sprite_input[#sprite_input+1] = 0
        --sprite_input[#sprite_input+1] = 0
    else
        sprite_input[#sprite_input+1] = cx
        sprite_input[#sprite_input+1] = cy
        --sprite_input[#sprite_input+1] = t
    end

    if overlay and t ~= 0 then
        gui.box(x-4, y-4, x+4, y+4)
        gui.text(x-13, y-3-9, ("%+04i"):format(t), '#FFFFFF', '#0000003F')
        gui.text(x-13, y-3+9, ("%+04i"):format(cx), '#FFFFFF', '#0000003F')
    end
end

local function mark_tile(x, y, t)
    tile_input[#tile_input+1] = tile_lut[t]
    if t == 0 then return end
    if overlay then
        gui.box(x-8, y-8, x+8, y+8)
        gui.text(x-5, y-3, ("%02X"):format(t), '#FFFFFF', '#00000000')
    end
end

local function getxy(i, x_addr, y_addr, pageloc_addr, hipos_addr)
    local spl_l = R(0x71A)
    local spl_r = R(0x71B)
    local sx_l = R(0x71C)
    local sx_r = R(0x71D)

    local x = R(x_addr + i)
    local y = R(y_addr + i)
    local sx, sy = x, y
    if pageloc_addr ~= nil then
        local page = R(pageloc_addr + i)
        sx = sx - sx_l - (spl_l - page) * 256
    else
        sx = sx - sx_l
    end
    if hipos_addr ~= nil then
        local hipos = S(hipos_addr + i)
        sy = sy + (hipos - 1) * 256
    end

    return sx, sy
end

local function paused() return band(R(0x776), 1) end

local function get_state()
    if R(0xE) == 0xFF then return 'power' end
    if R(0x774) > 0 then return 'lagging' end
    if R(0x7A2) > 0 then return 'waiting_demo' end
    if R(0x717) > 0 then return 'playing_demo' end
--  if R(0x770) == 0xFF then return 'power' end
    if paused() ~= 0 then return 'paused' end
    if R(0xE) == 0 then return 'world_screen' end
--  if R(0x712) == 1 then return 'deadmusic' end
    if R(0x7CA) == 0x94 then return 'dead' end
    if R(0xE) == 4 then return 'win_flagpole' end
    if R(0xE) == 5 then return 'win_walking' end
    if R(0xE) == 6 then return 'lose' end
--  if R(0x770) == 0 then return 'not_playing' end
    if R(0x770) == 2 then return 'win_castle' end
    if R(0x772) == 2 then return 'no_control' end
    if R(0x772) == 3 then return 'playing' end
    if R(0x770) == 1 then return 'loading' end
    if R(0x770) == 3 then return 'lose' end
    return 'unknown'
end

local function advance()
    emu.frameadvance()
    while emu.lagged() do emu.frameadvance() end -- skip lag frames.
    while R(0x774) > 0 do emu.frameadvance() end -- also lag frames.
end

local function handle_enemies()
    -- enemies, flagpole
    for i = 0, 5 do
        local x, y = getxy(i, 0x87, 0xCF, 0x6E, 0xB6)
        x, y = x + 8, y + 16
        local tid = R(0x16 + i)
        local flags = R(0xF + i)
        --local offscr = R(0x3D8 + i)
        local invisible = tid < 0x10 and flags == 0
        if tid == 0x30 then y = y - 8 end -- flagpole flag
        if tid == 0x31 then y = y - 8 end -- castle flag
        if tid == 0x16 then x, y = x - 4, y - 12 end -- fireworks
        if tid >= 0x24 and tid <= 0x29 then x, y = x + 16, y - 12 end -- moving platforms
        if tid == 0x2D then x, y = x, y end -- bowser (TODO: determine head or body)
        if tid == 0x15 then x, y = x, y - 12 end -- bowser fire
        if tid == 0x32 then x, y = x, y - 8 end -- spring
        -- tid == 0x35 -- toad
        if tid == 0x1D or tid == 0x1B then -- rotating fire bars
            x, y = x - 4, y - 12
            -- this is a mess... gotta find out its rotation and then project.
            -- TODO: handle long fire bars too
            local rot = R(0xA0 + i) --* 0x100 + R(0x58 + i)
            if overlay then
                gui.text(x-13, y-3+9, ("%04X"):format(rot), '#FFFFFF', '#0000003F')
            end
            local x_off, y_off = rotation_offsets[rot*2+1], rotation_offsets[rot*2+2]
            x, y = x + x_off, y + y_off
        end
        if invisible then
            mark_sprite(0, 0, 0)
        else
            mark_sprite(x, y, tid + 1)
        end
    end
end

local function handle_fireballs()
    for i = 0, 1 do
        local x, y = getxy(i, 0x8D, 0xD5, 0x74, 0xBC)
        x, y = x + 4, y + 4
        local state = R(0x24 + i)
        local invisible = state == 0
        if invisible then
            mark_sprite(0, 0, 0)
        else
            mark_sprite(x, y, 257)
        end
    end
end

local function handle_blocks()
    for i = 0, 3 do
        local x, y = getxy(i, 0x8F, 0xD7, 0x76, 0xBE)
        x, y = x + 8, y + 8
        local state = R(0x26 + i)
        local invisible = state == 0
        if invisible then
            mark_sprite(0, 0, 0)
        else
            mark_sprite(x, y, 258)
        end
    end
end

local function handle_hammers()
    -- hammers, coins, score bonus text...
    for i = 0, 8 do
        local x, y = getxy(i, 0x93, 0xDB, 0x7A, 0xC2)
        x, y = x + 8, y + 8
        local state = R(0x2A + i)
        -- skip coin effect states. not interactable; we don't care!
        if state ~= 0 and state >= 0x30 then
            mark_sprite(x, y, state + 1)
        else
            mark_sprite(0, 0, 0)
        end
    end
end

local function handle_misc()
    for i = 0, 0 do
        local x, y = getxy(i, 0x9C, 0xE4, 0x83, 0xCB)
        x, y = x + 8, y + 8
        local state = R(0x33 + i)
        if state ~= 0 then
            mark_sprite(x, y, state + 1)
        else
            mark_sprite(0, 0, 0)
        end
    end
end

local function handle_tiles()
    --local tile_col = R(0x6A0)
    local tile_scroll = floor(R(0x73F) / 16) + R(0x71A) * 16
    local tile_scroll_remainder = R(0x73F) % 16
    extra_input[#extra_input+1] = tile_scroll_remainder
--  for y = 0, 12 do
    -- afaik the bottom row is always a copy of the second to bottom,
    -- and the top is always air, so drop those from the inputs:
    for y = 1, 11 do
        for x = 0, 16 do
            local col = (x + tile_scroll) % 32
            local t
            if col < 16 then
                t = R(0x500 + y * 16 + (col % 16))
            else
                t = R(0x5D0 + y * 16 + (col % 16))
            end
            local sx = x * 16 + 8 - tile_scroll_remainder
            local sy = y * 16 + 40
            mark_tile(sx, sy, t)
        end
    end
end

return {
-- TODO: don't expose these; provide interfaces for everything needed.
R=R,
W=W,
S=S,
overlay=overlay,

valid_tiles=valid_tiles,
area_lut=area_lut,

sprite_input=sprite_input,
tile_input=tile_input,
extra_input=extra_input,

get_timer=get_timer,
get_score=get_score,
set_timer=set_timer,
mark_sprite=mark_sprite,
mark_tile=mark_tile,
getxy=getxy,
paused=paused,
get_state=get_state,
advance=advance,
handle_enemies=handle_enemies,
handle_fireballs=handle_fireballs,
handle_blocks=handle_blocks,
handle_hammers=handle_hammers,
handle_misc=handle_misc,
handle_tiles=handle_tiles,
}