FF6 info script (personal modifications)

-- Features:
-- 1. Encounter prediction: predicts steps until encounter, and what will be encountered.
--    Does not predict front/back/pincer/side/preemptive variants, not will it work properly
--    on the floating continent. (there is tentative support for this (which actually makes up
--    a good part of the code), but it is buggy, and only works well when one is on the world map,
--    and has 3 or 4 chars in party, so it is disabled by default)
-- 2. Outline treasure chests and show their contents and status (green = untaken, red = taken)
-- 3. Outline squares that trigger events. Blue = transition to new area, light blue = transition
--    to same area, very light blue = transition to map, yellow = unclassified event.
-- 4. In battle, hp and mp bars are displayed over the enemies, as well as their battle gauges.
--    Their level is also displayed. On gau's turns, a "?" is displayed by any monster whose
--    rage is not known. Additionally, the enemies' resistances etc. are displayed in a compact
--    but hopefully readable manner, as a set of 4 3x3 sqares of pixels, where each has the
--    following format:
--      fil   ; fire (red) ice (blue) lightning (yellow)
--      pwp   ; poison (green) wind (gray) holy (white)
--      ew    ; earth (brown) water (blue)
--    The order of the sqares is, from left to right, absorb, nullify, resist, weak.
-- 5. Extra information is displayed for the currently selected monster.
--    normally, only its drops and hp/mp are displayed, but if locke is selecting the
--    monster with the steal command, its steals are also listed. If relm is selecting
--    a monster with control or sketch, that information will also be indicated.
-- 6. While in the rage menu, information about what the selected rage does is
--    displayed. Only the attack part of the rage is displayed so far, since I haven't thought
--    of a compact way of displaying all the status information associated with a rage.

addHours = 0
addMinutes = 4
addSeconds = 9
addFrames = 21
textX = 160
textY = 120

lMode1 = memory.readword(0x7e1501)
lMode2 = memory.readbyte(0x7e1503)
lMode3 = memory.readbyte
cMode1 = memory.readword(0x7e1501)
cMode2 = memory.readbyte(0x7e1503)
autoText = false

drawpixel = function(x,y,color)
    if x < 0 or y < 0 then return end
    if x >= 0x100 or y >= 0xE0 then return end
    gui.drawpixel(x,y,color)
end
-- the following section handles out of bounds checking.
-- This will hopefully not be necessary in later versions of snes9x-lua
-- The bounds checking for lines is slightly more complicated, so I did
-- not bother implementing it properly.
min = function(a,b) if a < b then return a else return b end end
max = function(a,b) if a < b then return b else return a end end
order = function(a,b) if a > b then return b, a else return a,b end end
olddrawbox = gui.drawbox
gui.drawbox = function(x1,y1,x2,y2,color)
    x1,x2 = order(x1,x2)
    y1,y2 = order(y1,y2)
    x1 = min(max(0,x1),255)
    y1 = min(max(0,y1),238)
    x2 = min(max(0,x2),255)
    y2 = min(max(0,y2),238)
    olddrawbox(x1,y1,x2,y2,nil,color)
end
oldtext = gui.text
gui.text = function(x,y,text)
    if x >= 0 and x < 256 and y >= 0 and y < 239 then
        oldtext(x,y,text)
    end
end
horline = function(x1,y,x2,color)
    x1,x2 = order(x1,x2)
    x1 = min(max(0,x1),255)
    x2 = min(max(0,x2),255)
    if y >= 0 and y < 239 then
        gui.drawline(x1,y,x2,y,color)
    end
end
vertline = function(x,y1,y2,color)
    y1,y2 = order(y1,y2)
    y1 = min(max(0,y1),238)
    y2 = min(max(0,y2),238)
    if x >= 0 and x < 256 then
        gui.drawline(x,y1,x,y2,color)
    end
end


startgauge = function(x,y,w)
    gx, gy, gw = x, y, w
end
drawgauge = function(c,m,col)
    if m == 0 then m = 1 end
    local g = c*gw/m
    horline(gx,gy,gx+g,col)
    horline(gx+g,gy,gx+gw,"#000000")
    gy = gy-1
end

tochar = function(i)
    if i < 0x80 then return ""
    elseif i < 0x9a then return string.char(string.byte("A")+i-0x80)
    elseif i < 0xb4 then return string.char(string.byte("a")+i-0x9a)
    elseif i < 0xbe then return string.char(string.byte("0")+i-0xb4)
    elseif i == 0xfe then return " "
    else return "" end
end

readsnesstring = function(from,maximum)
    local res = ""
    local tmp = memory.readbyte(from)
    local i = 0
    while tmp ~= 0xFF do
        if i == maximum then break end
        res = res .. tochar(tmp)
        from = from+1
        tmp = memory.readbyte(from)
        i = i+1
    end
    return res
end

getitemname = function(id)
    return readsnesstring(0xd2b300+0xd*id+1,12)
end
getmonstername = function(id)
    return readsnesstring(0xcfc050+0xa*id,10)
end
getattackname = function(id)
    local x = 0
    local maxlen = 10
    if id < 0x36 then
        x = id*7
        maxlen = 7
    elseif id < 0x51 then
        x = id*8-0x36
        maxlen = 8
    elseif id < 0x56 then x = id*0xA-0xd8
    else x = id*0xA-0xd8 -- vet ikke hvorfor indeksen blir d8 her.
    --else id < 0x5b then x = id*0xA-0xc4
    end
    return readsnesstring(0xe6f567+x,maxlen)
end


-- This is probably not the best way of determining the game mode, but it works.
mode_battle = function()
    return memory.readword(0x7e1501) == 0x0ba7 and memory.readbyte(0x7e1503) == 0xC1
end
mode_cave = function()
    return memory.readword(0x7e1501) == 0x0182 and memory.readbyte(0x7e1503) == 0xC0
end
mode_map  = function()
    return memory.readword(0x7e1501) == 0xa728 and memory.readbyte(0x7e1503) == 0xEE
end
mode_menu = function()
    return memory.readword(0x7e1501) == 0x1387 and memory.readbyte(0x7e1503) == 0xC3
end
function HandleKeys()
    keys = input.get()

    if press('T') then
        autoText = not autoText
    end

    last_keys = keys
end
function press(button)
    if keys[button] and not last_keys[button] then
        return true
    end
    return false
end

hours = 0
minutes = 0
seconds = 0
milliseconds = 0

function CalculateTime()
    frames = snes9x.framecount()
    frames = frames + addHours * 216000 + addMinutes * 3600 + addSeconds * 60 + addFrames
    hours = math.floor(frames / 216000)
    minutes = math.floor((frames - hours * 216000) / 3600)
    seconds = math.floor((frames - hours * 216000 - minutes * 3600) / 60)
    milliseconds = math.floor((frames - hours * 216000 - minutes * 3600 - seconds * 60) * 100 / 60)
end

function OutputTime()
    gui.text(textX, textY, "Time: " .. hours .. ":" .. string.format("%02d",minutes) .. ":" .. string.format("%02d",seconds) .. "." .. string.format("%02d",milliseconds))
    gui.text(textX, textY + 10, "Offset: " .. addHours .. ":" .. string.format("%02d",addMinutes) .. ":" .. string.format("%02d",addSeconds) .. "." .. string.format("%02d",math.floor(addFrames * 100 / 60)))
end


-- prints a compact representation of elemental properties.
-- There are 8 elements. Each is assigned a color, and a place
-- in a 3x3 matrix of pixels.
-- fil   ; fire (red) ice (blue) lightning (yellow)
-- pwp   ; poison (green) wind (gray) holy (white)
-- ew    ; earth (brown) water (blue)
-- Colors need not be uniqe, as the position fixes things.
-- This is then surrounded by black border.
print_element = function(x,y,elem)
    -- first draw the border
    horline(x, y, x+4, "#404040")
    vertline(x+4, y, y+4, "#404040")
    vertline(x, y, y+4, "#404040")
    horline(x, y+4, x+4, "#404040")
    -- now draw the elements
    local x,y=x+1,y+1
    putpix = function(x,y,b,c)
        if b == 1 then drawpixel(x,y,c) else drawpixel(x,y,"#000000") end
    end
    cols = {
        "#ff0000","#0000ff","#ffff00",
        "#00ff00","#808080","#ffffff",
        "#a08000","#0000ff","#000000"
    }
    for i = 1, 9 do
        dx, dy = (i-1)%3, math.floor((i-1)/3)
        putpix(x+dx,y+dy,elem % 2,cols[i])
        elem = math.floor(elem/2)
    end
end

get_special = function(id)
    -- Information about the special attack
    -- This is used by rage, sketch, control.
    local special = memory.readbyte(0xcf001f+0x20*id)
    local specialn = readsnesstring(0xcfd0d0+id*10,10)
    local no_damage,no_dodge = bit(special, 6),bit(special,7)
    special = special % 0x40
    desc = "???"
    if special == 0x30 then desc = "absorb hp"
    elseif special == 0x31 then desc = "absorb mp"
    elseif special >= 0x32 then desc = "remove reflect"
    elseif special >= 0x20 then desc = string.format("+%d%%",(special-0x1f)*50)
    else
        local descs = { "Dark","Zombie","Poison","MagiTek","Clear","Imp","Petrify",
            "Death", "Condemned", "Near Fatal", "Image", "Mute", "Berserk",
            "Muddle", "Seizure", "Sleep", "Dance", "Regen", "Slow", "Haste",
            "Stop", "Shell", "Safe", "Reflect", "Rage", "Freeze", "Life 3",
            "Morph", "Chant!", "Disappear!", "Dog block", "Float" }
        desc = descs[special+1]
    end
    specialn = specialn.." ("..desc..")"
    return specialn, no_damage, no_dodge
end


print_status = function(status)
    -- Må finne ut hva bitsene i hver status byte betyr.
end

-- bit operations, since lua is silly enough to miss these
bit = function(n,i) return math.floor(n/2^i) % 2 end
bor = function(a,b)
    local c = 0
    local pot = 1
    while a ~= 0 or b ~= 0 do
        if a % 2 == 1 or b % 2 == 1 then c = c+pot end
        a = math.floor(a/2)
        b = math.floor(b/2)
        pot = pot*2
    end
    return c
end

-- to get the pixel distance from an encounter, we
-- need to fix an occational off-by-1 error for
-- count. this happens on the first frame when we reach
-- a whole square. we thus need to keep track of whether
-- the last position was whole or not
last_position_whole = true

while true do
    -- Are we in battle?
    offset = 100
    if mode_battle() then
        --snes9x.speedmode("maximum")

        -- memory.writebyte(0x7e3bfc, 0)
        -- memory.writebyte(0x7e3bfd, 0)
        -- memory.writebyte(0x7e3bfe, 0)
        -- memory.writebyte(0x7e3bff, 0)
        -- memory.writebyte(0x7e3c00, 0)
        -- memory.writebyte(0x7e3c01, 0)
        -- memory.writebyte(0x7e3c02, 0)
        -- memory.writebyte(0x7e3c03, 0)
        -- memory.writebyte(0x7e3c04, 0)
        -- memory.writebyte(0x7e3c05, 0)
        -- memory.writebyte(0x7e3c06, 0)
        -- memory.writebyte(0x7e3c07, 0)

        sel_side, sel_i = memory.readbyte(0x7e7ace), memory.readbyte(0x7e7acf)
        sel_enemy, sel_party = memory.readbyte(0x7e7b7e),memory.readbyte(0x7e7b7d)
        sel_multi = memory.readbyte(0x7e7b7f)
        -- loop through present monsters
        for i = 0, 5 do
            -- a few shortcuts
            j, k = 2*i, 2*(4+i)
            state = memory.readword(0x7e3aa0+k)
            if state ~= 0 and bit(state,15) ~= 1 then
            -- get coordinates (we should know the size of the monster too, but we don't)
            x = memory.readbyte(0x7e80c2+1+j)
            -- this size is really the x-offset of the pointing hand relative to the start
            -- of the sprite. For a normal attack, this works fine, but for monsters on the
            -- right hand side of the screen, this offset is 0, as the hand is on their left
            -- side. To do things properly, I should get this in a more direct fashion, but
            -- I can't be bothered
            xsize = memory.readbyte(0x7e807a+1+j)
            if xsize == 0 then xsize = 0x20 end
            y = memory.readbyte(0x7e80ce+1+j)
            -- other interesting information
            id   = memory.readword(0x7e3388+j)
            xp   = memory.readword(0x7e3d8c+j)
            gold = memory.readword(0x7e3da0+j)
            hp   = memory.readword(0x7e3bf4+k)
            mp   = memory.readword(0x7e3c08+k)
            mhp  = memory.readword(0x7e3c1c+k)
            mmp  = memory.readword(0x7e3c30+k)
            level= memory.readbyte(0x7e3b18+k)
            speed= memory.readbyte(0x7e3b19+k)
            gauge= memory.readword(0x7e3218+k)
            -- elements
            absorb  =  memory.readbyte(0x7e3bcc+k)
            nullify =  memory.readbyte(0x7e3bcd+k)
            resist  =  memory.readbyte(0x7e3be1+k)
            weak    =  memory.readbyte(0x7e3be0+k)
            stealn  =  memory.readbyte(0x7e3311+j)
            stealr  =  memory.readbyte(0x7e3310+j)
            dropn   =  memory.readbyte(0xcf3000+4*id+3)
            dropr   =  memory.readbyte(0xcf3000+4*id+2)

            name = getmonstername(id)

            -- Print the gauges
            startgauge(x,y,xsize)
            drawgauge(mp, mmp, "#0000ff")
            drawgauge(hp, mhp, "#00ff00")
            drawgauge(gauge, 0x10000, "#ff0000")
            by = gy
            gui.text(x-16, by-8, string.format("%2d",level))
            print_element(x, by-6, absorb)
            print_element(x+4, by-6, nullify)
            print_element(x+8, by-6, resist)
            print_element(x+12, by-6, weak)
            gui.text(x+18, by-8, ""..hp)

            active_slot = memory.readbyte(0x7e0201)
            active_player = memory.readbyte(0x7e3ed8+active_slot*2)
            menu_pos = memory.readbyte(0x7e890f+active_slot)
            relm_info = active_player == 8 and menu_pos == 1
            locke_info = active_player == 1 and menu_pos == 1
            gau_info = active_player == 0xb

            if gau_info then
                local id_byte, id_bit = math.floor(id/8), id % 8
                if bit(memory.readbyte(0x7e1d2c+id_byte),id_bit) == 0 then
                    -- monster not known!
                    gui.text(x-8,y,"?")
                end
            end

            -- More detailed information for the monster we point to.
            -- This will depend on how it is being pointed to
            if (sel_side == 0 or sel_side == 2) and sel_i == i and
                sel_multi == 0 and sel_enemy ~= 0 then
                --gui.text(10,offset,"Level "..level.." "..name)
                --offset = offset+10
                gui.text(10,offset,string.format("HP:%d/%d, MP:%d/%d",hp,mhp,mp,mmp))
                offset = offset+10
                --gui.text(10,offset,string.format("XP:%d, gold:%d",xp,gold))
                --offset = offset+10
                if locke_info then
                    gui.text(10,offset,string.format("Steal %s/%s", getitemname(stealn), getitemname(stealr)))
                    offset = offset+10
                end
                gui.text(10,offset,string.format("Drops %s/%s", getitemname(dropn), getitemname(dropr)))
                offset = offset+10
                -- Special attack description
                specialn = get_special(id)
                -- Sketch
                sketch1 = memory.readbyte(0xcf4300+2*id)
                sketch2 = memory.readbyte(0xcf4300+2*id+1)
                -- control
                control, controln = {}, {}
                for ctrl_i = 0, 3 do
                    control[ctrl_i] = memory.readbyte(0xcf3d00+4*id+ctrl_i)
                end
                if sketch1 == 0xEF then sketch1n = specialn else sketch1n = getattackname(sketch1) end
                if sketch2 == 0xEF then sketch2n = specialn else sketch2n = getattackname(sketch2) end
                for ctrl_i = 0, 3 do
                    local ctrl,foo = control[ctrl_i]
                    if ctrl == 0xEF then foo = specialn
                    elseif ctrl == 0xFF then foo = "Nothing"
                    else foo = getattackname(ctrl) end
                    controln[ctrl_i] = foo
                end
                if relm_info then
                    gui.text(10,offset,string.format("Sketch %s/%s", sketch2n, sketch1n))
                    offset = offset+10
                    gui.text(10,offset,string.format("Control %s/%s",controln[0],controln[1]))
                    offset = offset+10
                    gui.text(10,offset,string.format("        %s/%s",controln[2],controln[3]))
                    offset = offset+10
                end
            end
        end end
        -- Rage information when in the rage menu
        if memory.readbyte(0x7e7bd4) == 0x24 then
            x = memory.readbyte(0x7e892f)
            y = memory.readbyte(0x7e8933)
            scroll = memory.readbyte(0x7e892b)
            i = 2*(y+scroll)+x
            id = memory.readbyte(0x7e257e + i)
            if id ~= 0xFF then
                -- What rages does this monster have?
                rage1 = memory.readbyte(0xcf4600+2*id)
                rage2 = memory.readbyte(0xcf4600+2*id+1)
                -- Special attack description
                specialn = get_special(id)
                if rage1 == 0xEF then rage1n = specialn else rage1n = getattackname(rage1) end
                if rage2 == 0xEF then rage2n = specialn else rage2n = getattackname(rage2) end
                gui.text(10,offset,string.format("%s/%s", rage1n, rage2n))
                offset = offset+10
            end
        end
    elseif mode_cave() then
        snes9x.speedmode("normal")
        -- get the screen position
        sx     = memory.readword(0x7e8297)
        sy     = memory.readword(0x7e8299)
        if sx >= 0x8000 then sx = sx-0x10000 end
        if sy >= 0x8000 then sy = sy-0x10000 end
        -- prepare to loop through treasures
        area   = memory.readword(0x7e0082)
        table  = 0xed8634
        i      = memory.readword(0xed82f4+2*area)
        to     = memory.readword(0xed82f4+2*(area+1))
        -- loop through the treasures
        while i ~= to do
            -- read from the treasure information array
            xi     = memory.readbyte(table+i)
            yi     = memory.readbyte(table+i+1)
            flagi  = memory.readword(table+i+2)
            item   = memory.readbyte(table+i+4)
            name   = getitemname(item)
            -- Has the box been taken? To find out, we need to
            -- do some bit manipulation.
            byte_index = math.floor(flagi/8)
            bit_index = flagi % 8
            if byte_index >= 0x40 then
                byte_index = byte_index - 0x40*math.floor(byte_index/0x40)
            end
            flag = memory.readbyte(0x7e1e40+byte_index)
            flag = flag % (2^(bit_index+1))
            flag = math.floor(flag/ 2^bit_index)
            -- flag is now 0 if not taken and 1 if taken
            if flag == 0 then color = "#00ff00" else color = "#ff0000" end

            -- get the real x,y position, using the fact that
            -- each square is 0x10 big.
            x,y = 0x10*xi, 0x10*yi
            -- relative coordinates
            rx, ry = x-sx, y-sy

            -- draw a nice red box around the treasure box
            gui.drawbox(rx, ry, rx+0x10, ry+0x10, color)
            gui.text(rx, ry-5, name)

            i = i + 5
        end
        table = 0xdfbb00
        i     = memory.readword(table+2*area)
        to    = memory.readword(table+2*(area+1))
        -- loop through the transitions
        while i ~= to do
            -- read from the treasure information array
            xi     = memory.readbyte(table+i)
            yi     = memory.readbyte(table+i+1)
            hmm    = memory.readword(table+i+2)
            xti    = memory.readbyte(table+i+4)
            yti    = memory.readbyte(table+i+5)
            area2 = hmm % 0x200
            -- is it to the same area? If so, color it
            -- light blue. Else make it normal blue.
            if area2 == area then color = "#8080ff"
            else color = "#0000ff" end

            -- get the real x,y position, using the fact that
            -- each square is 0x10 big.
            x,y = 0x10*xi, 0x10*yi
            -- relative coordinates
            rx, ry = x-sx, y-sy
            gui.drawbox(rx, ry, rx+0x10, ry+0x10, color)

            i = i + 6
        end
        table = 0xedf480
        i     = memory.readword(table+2*area)
        to    = memory.readword(table+2*(area+1))
        -- loop through the wide transitions
        while i ~= to do
            -- read from the treasure information array
            xi     = memory.readbyte(table+i)
            yi     = memory.readbyte(table+i+1)
            dxi    = memory.readbyte(table+i+2)
            dyi    = 0
            hmm    = memory.readword(table+i+3)
            xti    = memory.readbyte(table+i+5)
            yti    = memory.readbyte(table+i+6)
            area2 = hmm % 0x200
            if dxi >= 0x80 then dxi, dyi = 0, dxi % 0x80 end
            -- is it to the same area? If so, color it
            -- light blue. Else make it normal blue.
            if area2 == area then color = "#8080ff"
            elseif area2 == 0x1ff then color = "#b0b0ff"
            else color = "#0000ff" end

            -- get the real x,y position, using the fact that
            -- each square is 0x10 big.
            x,y,dx,dy = 0x10*xi, 0x10*yi, 0x10*dxi, 0x10*dyi
            -- relative coordinates
            rx, ry = x-sx, y-sy
            gui.drawbox(rx, ry, rx+dx+0x10, ry+dy+0x10, color)

            i = i + 7
        end
        table= 0xc40000
        i    = memory.readword(0xc40000+2*area)
        to   = memory.readword(0xc40000+2*(area+1))
        -- loop through the reactions
        while i ~= to do
            -- read from the treasure information array
            xi     = memory.readbyte(table+i)
            yi     = memory.readbyte(table+i+1)
            react1 = memory.readword(table+i+2)
            react2 = memory.readbyte(table+i+4)
            color = "#ffff00"

            -- get the real x,y position, using the fact that
            -- each square is 0x10 big.
            x,y = 0x10*xi, 0x10*yi
            -- relative coordinates
            rx, ry = x-sx, y-sy
            gui.drawbox(rx, ry, rx+0x10, ry+0x10, color)

            i = i + 5
        end
    else
        snes9x.speedmode("normal")
    end
    -- encounter counter
    if mode_map() or mode_cave() then
        -- Equipment-derived information is not kept permanently, it is recomputed
        -- at the beginning of every frame, I think. We need to know if the party
        -- has the moogle charm or charm bangle effect.
        -- We will therefore loop through the equipment of all characters.
        field_effects = 0
        status_effects = 0
        char_in_party = 0
        for id = 0, 0xF do
            tmp = memory.readbyte(0x7e1850+id)
            if tmp % 8 == memory.readbyte(0x7e1a6d) then
                -- character is present. If necessary, information about
                -- row and slot is also awailable in tmp.
                char_in_party = char_in_party + 1
                x = id*0x25+0x1F -- start of equipment
                for i = 0, 5 do
                    item = memory.readbyte(0x7e1600+x+i)
                    if item ~= 0xFF then
                        -- item actually equipped
                        field_effects = bor(field_effects,memory.readbyte(0xd85005+item*0x1e))
                        status_effects = bor(status_effects,memory.readbyte(0xd8500a+item*0x1e))
                    end
                end
            end
        end
        -- field_effects is what is later put in 11df

        if mode_map() then
            terrain = memory.readbyte(0x7e11f9) % 8
            at_22 = memory.readbyte(0xc0c28f+terrain) -- lave tall, men hva betyr de?
            a = memory.readbyte(0xc0c297+terrain) -- denne arrayen følger rett etter. samme størrelsesorden.
            -- b og c er faktisk x og y-posisjonen på kartet til *forrige encounter*!
            last_x = memory.readbyte(0x7e1f60)
            last_y = memory.readbyte(0x7e1f61)
            zone_x, zone_y = math.floor(last_x/0x20),math.floor(last_y/0x20)
            zone = memory.readbyte(0x7e1f64)*0x40+zone_y*8+zone_x

            -- a må inneholde en mapping fra terreng til offsets i følgende array.
            -- merkelig at slikt trengs.
            pack_index = memory.readbyte(0xcf5400+zone*4+a)
            gui.text(textX, textY + 30, "pack index: " .. pack_index)
            -- den høye byten her angir kanskje om det er world of balance eller ruin eller noe annet?
            encounter_rate_index = math.floor(memory.readbyte(0xcf5800+zone) / 4^at_22) % 4
             -- field_effects har info om charm bangle etc. encounter_rate_index info om more/less enc.
            x = (field_effects)%4*8 + encounter_rate_index*2
            -- x er nå indeks inn i encounter rate-tabellen.
            encounter_rate = memory.readword(0xc0c29f+x)
        else
            area = memory.readword(0x7e0082)
            ax,ay = math.floor(area/4), area % 4
            a = (memory.readbyte(0xcf5880+ax) / 4^ay) % 4
            x = ((memory.readbyte(0x7e11df) % 4) * 4 + a) * 2
            encounter_rate = memory.readword(0xc0c2bf+x)
            if bit(memory.readbyte(0x7e0525),7) == 0 then
                encounter_rate = 0
            end
            pack_index = memory.readbyte(0xcf5600+area)
            gui.text(textX, textY + 30, "pack index: " .. pack_index)
        end
        enc1 = memory.readword(0x7e1f6e)
        enc2 = memory.readbyte(0x7e1fa1)
        enc3 = memory.readbyte(0x7e1fa4)
        count = 1
        if encounter_rate ~= 0 then
            for i = 0, 100 do
                enc1 = enc1 + encounter_rate
                if enc1 >= 0x10000 then enc1 = 0xff00 end
                enc2 = (enc2+1) % 0x100
                if enc2 == 0 then enc3 = (enc3 + 0x11) % 0x100 end
                if (memory.readbyte(0xc0fd00+enc2)+enc3) % 0x100 < math.floor(enc1/0x100) then break end
                count = count+1
            end
            gui.text(10,offset,"Encounter in ".. count.." steps.")
            offset = offset+10

            -- Veldt?
            if pack_index == 0xFF then
                enc_veldt = (memory.readbyte(0x7e1fa5)+1) % 0x40
                -- find a nonzero byte in the encountered formations bitarray.
                while memory.readbyte(0x7e1ddd+enc_veldt) == 0 do
                    enc_veldt = (enc_veldt+1) % 0x40
                end
                enc5 = memory.readbyte(0x7e1fa3)
                enc4 = (memory.readbyte(0x7e1fa2)+1) % 0x100
                if enc4 == 0 then enc5 = enc5 + 0x17 end
                bit_index = (memory.readbyte(0x7ec0fd00+enc4)+enc5) % 0x8
                bitset = memory.readbyte(0x7e1ddd+enc_veldt)
                -- find a nonzero bit, starting at a random position
                while bit(bitset,bit_index) == 0 do
                    bit_index = (bit_index+1) % 8
                end
                formation = enc_veldt*8+bit_index
            else
                x = pack_index*8
                -- Encounter type. x is the index into the monster pack array
                enc1 = (memory.readbyte(0x7e1fa2)+1) % 0x100
                enc2 = memory.readbyte(0x7e1fa3)
                if enc1 == 0 then enc2 = enc2+0x17 end
                a = (memory.readbyte(0xc0fd00+enc1)+enc2) % 0x100

                if a > 0x50 then x = x+2 end
                if a > 0xa0 then x = x+2 end
                if a > 0xf0 then x = x+2 end
                formation = memory.readword(0xcf4800+x)
            end

-- At this point, we have all the frame-independent information about the
-- encounter we can get. The following is an attempt to handle the frame-
-- dependent information by predicting at what frame an encounter will occur.
-- This is formation variation (on the floating continent only), attack type
-- (front, back, pincer, side) and preemptiv or not. However, this ended in
-- failure. It works for 3-4 chars in party on the map, mostly, but not for
-- fewer chars, and not when not on the world map. If you want to enable it,
-- comment the following line
            skip_frame_dependent = true

            if not skip_frame_dependent then
                -- To find out more about the encounter, we need the frame-
                -- dependent be variable. We must first predict the number
                -- of pixels we are away from an encounter.
                if mode_map() then
                    faceing = memory.readbyte(0x7e00f6)
                    xpos = memory.readword(0x7e00c6)
                    ypos = memory.readword(0x7e00c8)
                else
                -- have to loop through all chars to find out who is the leader?
                -- However, the position we get this way does not move smoothly. Bleh.
                    for id = 0, 0xF do
                        local delta = 0x29*id
                        xpos, ypos = 0,0
                        if bit(memory.readbyte(0x7e0867+delta),7) == 1 then
                            faceing = memory.readbyte(0x7e086f+delta)
                            xpos = memory.readword(0x7e086a+delta)
                            ypos = memory.readword(0x7e086d+delta)
                            break
                        end
                    end
                end
                if faceing == 0 then pixels = ypos % 0x10
                elseif faceing == 1 then
                    pixels = xpos % 0x10
                    if pixels ~= 0 then pixels = 0x10-pixels end
                elseif faceing == 2 then
                    pixels = ypos % 0x10
                    if pixels ~= 0 then pixels = 0x10-pixels end
                else pixels = xpos % 0x10
                end
                -- this is the pixels left in our current step. then add the number
                -- of whole steps
                standing_still = false
                if pixels == 0 then
                    -- this is a whole position. was the last position whole too?
                    if last_position_whole then
                        standing_still = true
                        pixels = 0x10*count
                    else pixels = 0x10*(count-1) end
                    last_position_whole = true
                else
                    pixels = pixels + 0x10*(count-1)
                    last_position_whole = false
                end
                -- sprint shoes?
                if mode_cave() and bit(status_effects,5) then
                    pixels = math.floor(pixels/2)
                end
                -- compensate for the time it takes to start moving
                if standing_still then
                    if mode_map() then pixels = pixels+2
                    else
                        if bit(status_effects,5) == 1 then
                            pixels = pixels + memory.readbyte(0x7e0021e) % 4
                        else pixels = pixels + memory.readbyte(0x7e0021e) % 4 end
                    end
                end
                -- we assume that we are walking with maximum speed of 1 pixel per frame
                -- this will lead to be getting this value at the beginning of battle
                be = 4*((memory.readbyte(0x7e021e)+pixels+0x22) % 0x3c)
                gui.text(10,90,string.format("be: %x vs %x, %x %x", memory.readbyte(0x7e00be), be,pixels,xpos))

                if math.floor(formation / 0x8000) == 1 then
                    -- High bit of formation set: randomly add 0..3 to formation
                    be = (be+1) % 0x100
                    a = memory.readbyte(0xc0fd00+be) % 4
                    formation = (formation+a) % 0x8000
                end
            end
            info1 = memory.readbyte(0xcf5900+4*formation)
            info2 = memory.readbyte(0xcf5900+4*formation+1)
            info3 = memory.readbyte(0xcf5900+4*formation+2)
            info4 = memory.readbyte(0xcf5900+4*formation+3)

            -- Build monster list
            start = 0xcf6201+15*formation
            present = memory.readbyte(start)
            which = {}
            number_of_enemies = 0
            for i = 1, 6 do
                if present % 2 == 1 then
                    id = memory.readbyte(start+i)
                    if which[id] then which[id] = which[id]+1
                    else which[id] = 1 end
                    number_of_enemies = number_of_enemies + 1
                end
                present = math.floor(present/2)
            end
            -- Display list
            for id, num in pairs(which) do
                gui.text(10, offset, ""..num.." "..getmonstername(id))
                offset = offset + 10
            end

            if not skip_frame_dependent then
                -- What kind of encounter?
                variant = math.floor(info1 / 0x10) % 0x10
                -- variant is four bits long, and those bits are front, back, pincer, side; inverted.
                -- from high to low.
                -- let us extract these
                allowed = {}
                allowed_number = 0
                for i = 0, 3 do
                    allowed[i] = 1 - variant % 2
                    allowed_number = allowed_number + allowed[i]
                    variant = math.floor(variant/2)
                end
                if bit(status_effects,1) == 1 then
                    -- back guard, disable back and pincer.
                    -- This will prefer to remove pincer if not
                    -- both can be removed.
                    for i = 1, 2 do if allowed_number > 1 then
                        allowed[i] = 0
                        allowed_number = allowed_number-1
                    end end
                end
                if char_in_party < 3 and allowed_number > 1 then
                    -- not enough characters to do side attack
                    allowed[3] = 0
                    allowed_number = allowed_number - 1
                end

                -- Now we pick one of the possibilities
                -- First find the sum of the weights
                local sum = 0
                for i = 0, 3 do if allowed[i] == 1 then
                    sum = sum + memory.readbyte(0xc25279+i)+1
                end end
                -- before this point, be has been incremented by other things
                be = be + 0xa + 2*number_of_enemies + char_in_party
                -- get a random number from 0 to sum-1, using be
                be = (be+1) % 0x100
                rnd = math.floor(memory.readbyte(0xc0fd00+be)*sum/0x100)
                -- now loop through again, and pick the first that is bigger
                -- than the number
                sum = 0
                for i = 0, 3 do if allowed[3-i] == 1 then
                    sum = sum + memory.readbyte(0xc25279+i)+1
                    if sum > rnd then
                        chosen = 3-i
                        break
                    end
                end end

                vardesc = { "Front", "Back", "Pincer", "Side" }

                -- Finally, describe the result
                if chosen ~= 0 then
                    gui.text(10, offset, string.format("%s attack",vardesc[chosen+1]))
                    offset = offset+10
                end
            end
        end
    end
    HandleKeys()

    if autoText then
        gui.text(textX,textY + 20,"(T) Auto Text : On")
    else
        gui.text(textX,textY + 20,"(T) Auto Text : Off")
    end

    if autoText and (snes9x.framecount() % 6  == 0 or ((snes9x.framecount() - 1) % 6 == 0)) then
        curPad = joypad.get()
        curPad.A = true
        joypad.set(curPad)
    end

    if (memory.readbyte(0x7e1dd2) % 2 == 0) and (memory.readword(0x7e1501) == 0xa509) and (memory.readbyte(0x7e1503) == 0xEE) then
        x1 = memory.readword(0x7e0b00)
        y1 = memory.readword(0x7e0b02)
        x2 = memory.readword(0x7e0b04)
        y2 = memory.readword(0x7e0b06)

        gui.line(x1 + 176, 156, x1 + 176, 219, "#008080")
        gui.line(176, y1 + 156, 239, y1 + 156, "#008080")
        gui.line(x2 + 176, 156, x2 + 176, 219, "#008080")
        gui.line(176, y2 + 156, 239, y2 + 156, "#008080")
        gui.pixel(x1 + 176, y1 + 156, "#00ffff")
        gui.pixel(x2 + 176, y2 + 156, "#00ffff")

    end

    --for moviemaking
    --cMode1, cMode2 = memory.readword(0x7e1501), memory.readbyte(0x7e1503)
    --if lMode1 ~= cMode1 and lMode2 ~= cMode2 then
    --  snes9x.pause()
    --end
    --lMode1 = cMode1
    --lMode2 = cMode2

    CalculateTime()
    OutputTime()


    snes9x.frameadvance()
end