Ranger-X onescript

-- version 6 (2011-04-24)
-- written by mz, with additions by Dammit, Truncated and TheRandomPie_IV

local address = {
        ranger          = 0xFFC126,
        exup            = 0xFFD6C8,
        shot            = 0xFFCCA4,
        enemy           = 0xFF7E04,
        weapon_cooldown = 0xFFF00F,
        boss_hp         = 0xFFF03D,
        jetpack         = 0xFFCC8D,
        curr_char       = 0xFFF01B,
        boost_x         = 0xFFC139,
        boost_y         = 0xFFC13D,
        cam_pos_x       = 0xFFC094,
        cam_pos_y       = 0xFFC090,
        ranger_hb_pos_x = 0xFFD4A6,
        ranger_hb_pos_y = 0xFFD4AA,
        weapon_power    = 0xFFD6FC,
        ranger_hp       = 0xFFD722,
        ranger_inm      = 0xFFD726,
        ranger_ghost    = 0xFFF034,
        exup_hp         = 0xFFF016,
        targets         = 0xFFE655,
        rng             = 0xFFC118,

        -- not used
        weapon          = 0xFFD6FB,
        state           = 0xFFCC78
}
local offset = {
        x           = 0x02,
        sub_x       = 0x04,
        y           = 0x06,
        sub_y       = 0x08,
        speed_x     = 0x0A,
        sub_speed_x = 0x0C,
        speed_y     = 0x0E,
        sub_speed_y = 0x10,
        inm         = 0x3C,
        hp          = 0x3E
}
local value = {
        ranger_hb_size  = 32,
        shot_max_slots  = 32,
        enemy_max_slots = 256,
        slot_interval   = 0x40,
        hb_transparency = 25,
        inm_color       = "#FFFF00",
        ghost_color     = "#FF8040",
        deltaXdiff      = 0,
        deltaXcur       = 0,
        deltaXold       = 0,
        deltaYdiff      = 0,
        deltaYcur       = 0,
        deltaYold       = 0,
        bunnyhopMode    = 0
}
local draw = {
        row0 = 184,
        row1 = 192,
        row2 = 200,
        row3 = 208,
        row4 = 216,
        col0 = 84,
        col1 = 108,
        col2 = 138
}

gui.register ( function()
        GetGlobalValues()
        ObjectInformation("shot",  "#FF0000", value.shot_max_slots)
        ObjectInformation("enemy", "#00FF00", value.enemy_max_slots)
        PlayerInformation("#FFFFFF")
        LagCounterInformation()
        MainInformation()
        if value.bunnyhopMode == 1 then
                gui.text(177,220,"Bunnyhopping mode is ON", 'green')
        end

    outs = string.format("%d,%d\n", memory.readword(address.exup+offset.x), memory.readword(address.exup+offset.y));

    if (gens.lagged() == false) then
    --  x = io.open("D:\\Exupmove.csv", "a");
    --  x:write(outs);
    --  x:close()
    end


    Stage3Randomness()
end)


gens.registerafter(function()
        Bunnyhopper()
        LagCounter()
end)


function GetGlobalValues()
        -- Camera Position
        value.cam_pos_x = memory.readword(address.cam_pos_x)
        value.cam_pos_y = memory.readword(address.cam_pos_y)

        -- Ranger
        value.ranger_hp = memory.readword(address.ranger_hp)
        value.ranger_pos_x = memory.readword(address.ranger+offset.x) + memory.readbyte(address.ranger+offset.sub_x) / 0x100
        value.ranger_pos_y = memory.readword(address.ranger+offset.y) + memory.readbyte(address.ranger+offset.sub_y) / 0x100

        value.ranger_boost_x = memory.readbytesigned(address.boost_x)
        value.ranger_boost_y = memory.readbytesigned(address.boost_y)

        value.ranger_rel_pos_x = value.ranger_pos_x-value.cam_pos_x
        value.ranger_rel_pos_y = value.ranger_pos_y-value.cam_pos_y
        value.ranger_sub_speed_x = memory.readbyte(address.ranger+offset.sub_speed_x) / 0x100
        value.ranger_speed_x = memory.readwordsigned(address.ranger+offset.speed_x) + value.ranger_sub_speed_x
        value.ranger_sub_speed_y = memory.readbyte(address.ranger+offset.sub_speed_y) / 0x100
        value.ranger_speed_y = memory.readwordsigned(address.ranger+offset.speed_y) + value.ranger_sub_speed_y
        value.ranger_hb_pos_x = memory.readword(address.ranger_hb_pos_x)
        value.ranger_hb_pos_y = memory.readword(address.ranger_hb_pos_y)
        value.ranger_hb_rel_pos_x = value.ranger_hb_pos_x-value.cam_pos_x
        value.ranger_hb_rel_pos_y = value.ranger_hb_pos_y-value.cam_pos_y
        value.ranger_inm = memory.readword(address.ranger_inm)
        value.ranger_ghost = memory.readword(address.ranger_ghost)

        -- Ex-Up
        value.exup_hp = memory.readword(address.exup_hp)
        value.exup_pos_x = memory.readword(address.exup+offset.x)
        value.exup_pos_y = memory.readword(address.exup+offset.y)
        value.exup_rel_pos_x = value.exup_pos_x-value.cam_pos_x
        value.exup_rel_pos_y = value.exup_pos_y-value.cam_pos_y
        value.exup_sub_speed_x = memory.readbyte(address.exup+offset.sub_speed_x) / 0x100
        value.exup_speed_x = memory.readwordsigned(address.exup+offset.speed_x) + value.exup_sub_speed_x
        value.exup_sub_speed_y = memory.readbyte(address.exup+offset.sub_speed_y) / 0x100
        value.exup_speed_y = memory.readwordsigned(address.exup+offset.speed_y) + value.exup_sub_speed_y
        value.exup_hb_pos_x = value.exup_pos_x-16
        value.exup_hb_pos_y = value.exup_pos_y
        value.exup_hb_rel_pos_x = value.exup_hb_pos_x-value.cam_pos_x
        value.exup_hb_rel_pos_y = value.exup_hb_pos_y-value.cam_pos_y

        -- Current Character
        value.curr_char_byte = memory.readbyte(address.curr_char)
        if value.curr_char_byte == 0 then
                value.curr_char_hp = value.ranger_hp
                value.curr_char_pos_x = value.ranger_pos_x
                value.curr_char_pos_y = value.ranger_pos_y
                value.curr_char_speed_x = value.ranger_speed_x
                value.curr_char_speed_y = value.ranger_speed_y
        else
                value.curr_char_hp = value.exup_hp
                value.curr_char_pos_x = value.exup_pos_x
                value.curr_char_pos_y = value.exup_pos_y
                value.curr_char_speed_x = value.exup_speed_x
                value.curr_char_speed_y = value.exup_speed_y
        end

        -- Other
        value.weapon_cooldown = memory.readbyte(address.weapon_cooldown)
        value.weapon_power = memory.readword(address.weapon_power)
        value.jetpack = memory.readbyte(address.jetpack)
        value.boss_hp = memory.readbyte(address.boss_hp)
        value.targets = memory.readbyte(address.targets)
end


function MainInformation()
        gui.text(255,  16, value.boss_hp)
        gui.text( 51, 201, value.curr_char_hp .. "/62")
        gui.text(draw.col1,draw.row0,"x","magenta")
        gui.text(draw.col2,draw.row0,"y","magenta")
        gui.text(draw.col0,draw.row1,"pos")
        gui.text(draw.col0,draw.row2,"spd","yellow")
        gui.text(draw.col0,draw.row3,"boost","red")
        gui.text(draw.col0,draw.row4,"delta","cyan")
        gui.text(draw.col1,draw.row1,string.format("%.2f",value.curr_char_pos_x))
        gui.text(draw.col2,draw.row1,string.format("%.2f",value.curr_char_pos_y))
        gui.text(draw.col1,draw.row2,value.curr_char_speed_x,"yellow")
        gui.text(draw.col2,draw.row2,value.curr_char_speed_y,"yellow")
        gui.text(draw.col1,draw.row3,value.ranger_boost_x,"red")
        gui.text(draw.col2,draw.row3,value.ranger_boost_y,"red")
        gui.text(162, 190, "Busy: " .. value.weapon_cooldown)
        gui.text(235, 201, value.weapon_power .. "/3968")
        gui.text(290, 203, value.jetpack)
--      gui.text(146,  7, "Left: " .. value.targets) -- useless?
    gui.text(146,  7, "Bird " .. memory.readwordsigned(0xFFC89A))
        -- delta
        if (gens.framecount()%2) == 0 then
                value.deltaXcur = value.curr_char_pos_x
                value.deltaXdiff = value.deltaXcur - value.deltaXold
                value.deltaYcur = value.curr_char_pos_y
                value.deltaYdiff = value.deltaYcur - value.deltaYold
        end
        gui.text(draw.col1,draw.row4,value.deltaXdiff,"cyan")
        gui.text(draw.col2,draw.row4,value.deltaYdiff,"cyan")
    gui.text(draw.col2,draw.row4,value.deltaYdiff,"cyan")
        value.deltaXold = value.deltaXcur
        value.deltaYold = value.deltaYcur
end


function GetObjectValues(obj_type,obj_value,slot_n)
                obj_value.slot_offset = slot_n * value.slot_interval
                obj_value.obj_id      = memory.readwordsigned(address[obj_type]+obj_value.slot_offset)
                obj_value.hp          = memory.readwordsigned(address[obj_type]+offset.hp+obj_value.slot_offset) --hp
--              obj_value.hp          = string.format("%x",(address[obj_type]+obj_value.slot_offset)) -- show slot address
                obj_value.pos_x       = memory.readword(address[obj_type]+offset.x+obj_value.slot_offset)
                obj_value.pos_y       = memory.readword(address[obj_type]+offset.y+obj_value.slot_offset)
                obj_value.rel_pos_x   = obj_value.pos_x-value.cam_pos_x
                obj_value.rel_pos_y   = obj_value.pos_y-value.cam_pos_y
                obj_value.speed_x     = memory.readwordsigned(address[obj_type]+offset.speed_x+obj_value.slot_offset)
                obj_value.speed_y     = memory.readwordsigned(address[obj_type]+offset.speed_y+obj_value.slot_offset)
                obj_value.hb_size_x   = 16
                obj_value.hb_size_y   = 16
                obj_value.inm         = memory.readwordsigned(address[obj_type]+offset.inm+obj_value.slot_offset)
end


function ObjectInformation(obj_type,color,maxslots)
        for slot_n = 0,maxslots do
                local obj_value = {}
                GetObjectValues(obj_type,obj_value,slot_n)

                if obj_value.obj_id ~= 0 and
                   --obj_value.hp > 0 and -- comment out this line to show all objects, including more enemy bullets
                   obj_value.rel_pos_x > -20 and obj_value.rel_pos_x < 353 and
                   obj_value.rel_pos_y > -12 and obj_value.rel_pos_y < 257 then

                        -- change color if hit
                        if obj_value.inm > 0 then color_to_use = value.inm_color
                        else color_to_use = color end

                        -- object hitbox
                        gui.box(obj_value.rel_pos_x-(obj_value.hb_size_x/2),
                                obj_value.rel_pos_y-(obj_value.hb_size_y/2),
                                obj_value.rel_pos_x+(obj_value.hb_size_x/2),
                                obj_value.rel_pos_y+(obj_value.hb_size_y/2),
                                color_to_use .. value.hb_transparency)

                        -- object vector
                        gui.line(obj_value.rel_pos_x,
                                 obj_value.rel_pos_y,
                                 obj_value.rel_pos_x+obj_value.speed_x,
                                 obj_value.rel_pos_y+obj_value.speed_y,
                                 color_to_use .. "FF")

                        -- object hp
                        gui.text(obj_value.rel_pos_x,obj_value.rel_pos_y,obj_value.hp) --slot_n)

                end -- if end

        end -- for end
end


function PlayerInformation(color)
        if value.ranger_inm > 0 then color = value.inm_color end
        if value.ranger_ghost > 0 then color = value.ghost_color end

        -- Ranger hitbox
        gui.box(value.ranger_hb_rel_pos_x,
                value.ranger_hb_rel_pos_y,
                value.ranger_hb_rel_pos_x+value.ranger_hb_size,
                value.ranger_hb_rel_pos_y+value.ranger_hb_size,
                color .. value.hb_transparency)

        -- Ranger vector
        gui.line(value.ranger_rel_pos_x,
                 value.ranger_rel_pos_y,
                 value.ranger_rel_pos_x+value.ranger_speed_x,
                 value.ranger_rel_pos_y+value.ranger_speed_y,
                 color)

        -- Ranger information
--      gui.text(value.ranger_hb_rel_pos_x+2, value.ranger_hb_rel_pos_y+1, "X: "..value.ranger_pos_x)
--      gui.text(value.ranger_hb_rel_pos_x+2, value.ranger_hb_rel_pos_y+1+8, "Y: "..value.ranger_pos_y)
--      gui.text(value.ranger_hb_rel_pos_x+2, value.ranger_hb_rel_pos_y+1+16, "SX: "..value.ranger_speed_x)
--      gui.text(value.ranger_hb_rel_pos_x+2, value.ranger_hb_rel_pos_y+1+24, "SY: "..value.ranger_speed_y)

        -- Exup hitbox
        gui.box(value.exup_hb_rel_pos_x,
                value.exup_hb_rel_pos_y,
                value.exup_hb_rel_pos_x+value.ranger_hb_size,
                value.exup_hb_rel_pos_y+value.ranger_hb_size,
                color .. value.hb_transparency)

        -- Exup vector
        gui.line(value.exup_rel_pos_x,
                 value.exup_rel_pos_y+16,
                 value.exup_rel_pos_x+value.exup_speed_x,
                 value.exup_rel_pos_y+16+value.exup_speed_y,
                 color)

        -- Ranger information
        gui.text(value.exup_hb_rel_pos_x+2, value.exup_hb_rel_pos_y+1, "X: "..value.exup_pos_x)
        gui.text(value.exup_hb_rel_pos_x+2, value.exup_hb_rel_pos_y+1+8, "Y: "..value.exup_pos_y)
        gui.text(value.exup_hb_rel_pos_x+2, value.exup_hb_rel_pos_y+1+16, "SX: "..value.exup_speed_x)
        gui.text(value.exup_hb_rel_pos_x+2, value.exup_hb_rel_pos_y+1+24, "SY: "..value.exup_speed_y)
end


-----------------
-- Lag counter --
-----------------

local waslagged = 0
local lagCount = gens.lagcount()
local lagColor = "#FFFFFF"

function LagCounter()
        lagColor = "#FFFFFF"
        if gens.lagged() then
                islagged = 1
        else
                islagged = 0
        end

    if (islagged == waslagged) then
           lagCount = lagCount - 1 + 2*islagged
           lagColor = "#00FF00"
    end

        waslagged = islagged
end

function LagCounterInformation()
        gui.text(8,32,gens.framecount(),lagColor)
        gui.text(8,40,lagCount,"#00FF00")
end

input.registerhotkey(1, function()
        lagCount = 0
        gui.redraw()
end)


-----------------
-- Bunnyhopper --
-----------------

local skipNextFrame = 0
local bunnyhop = 0

function GetFutureValues(future)
        -- start setting up a portal in the present, so we can go back from the future if we need to
        local bunnystate = savestate.create()
        savestate.save(bunnystate)

        future.isLagged = 0
        future.weAreLanding = 0

        -- go to the future and retrieve information
        joypad.set(1, {right=true,down=true})
        gens.emulateframeinvisible()
        future.sx1 = memory.readwordsigned(address.ranger+offset.speed_x) + (memory.readbyte(address.ranger+offset.sub_speed_x) / 0x100)
        future.sy1 = memory.readwordsigned(address.ranger+offset.speed_y) + (memory.readbyte(address.ranger+offset.sub_speed_y) / 0x100)

        -- if the future frame is lagged, we better prepare ourselves for it
        if gens.lagged() then
                future.isLagged = 1
                if future.sx1 == 9 then
                        skipNextFrame = 1
                end
                if future.sx1 == 0 and future.sy1 == 0 then
                        bunnyhop = 1
                end
        end

        -- go to the second future frame and retrieve even more information
        joypad.set(1, {right=true,down=true})
        gens.emulateframeinvisible()
        future.sx2 = memory.readwordsigned(address.ranger+offset.speed_x) + (memory.readbyte(address.ranger+offset.sub_speed_x) / 0x100)
        future.sy2 = memory.readwordsigned(address.ranger+offset.speed_y) + (memory.readbyte(address.ranger+offset.sub_speed_y) / 0x100)
        if gens.lagged() and future.sx2 ~= 0 and future.sy2 == 0 and future.sy1 > 0 then
                future.weAreLanding = 1
        end

        -- go to the third future frame and retrieve even more even more information
        joypad.set(1, {right=true,down=true})
        gens.emulateframeinvisible()
        future.sx3 = memory.readwordsigned(address.ranger+offset.speed_x) + (memory.readbyte(address.ranger+offset.sub_speed_x) / 0x100)
        future.sy3 = memory.readwordsigned(address.ranger+offset.speed_y) + (memory.readbyte(address.ranger+offset.sub_speed_y) / 0x100)
        if not gens.lagged() and future.sx3 ~= 0 and future.sy3 == 0 and future.sy2 > 0 then
                future.weAreLanding = 1
        end

        -- go back to the present while we're safe
        savestate.load(bunnystate)
end

function Bunnyhopper()
        if value.bunnyhopMode ~= 1 then return end

        local input = {}
        local future = {}

        GetFutureValues(future)

        if future.isLagged == 1 then -- don't set input for the next frame
                return
        end

        -- x speed is 9, don't press right
        if skipNextFrame == 1 then
                skipNextFrame = 0
                input.down = true
                joypad.set(1, input)
                return
        end

        input.right = true
        -- we're not landing at 8.5 speed, slow down the fall
        if future.weAreLanding == 1 and (future.sx2 < 8.5 or future.sx3 < 8.5) then
                joypad.set(1, input)
                return
        end
        -- we have to hop here
        if bunnyhop == 1 then
                input.up = true
                bunnyhop = 0
        else
                -- if we're ducking, prepare to hop on the next frame
                if future.sx1 == 0 and future.sy1 == 0 then
                        bunnyhop = 1
                end
                -- if we're not hopping or ducking, we're falling; then speed up the fall
                input.down = true
        end
        joypad.set(1, input)
end

input.registerhotkey(2, function()
        value.bunnyhopMode = math.abs(value.bunnyhopMode - 1)
        bunnyhop = 0
        Bunnyhopper()
        gui.redraw()
end)


-----------------
-- Save States --
-----------------

savestate.registersave(function(slotnumber)
        return waslagged,islagged,lagCount,lagColor,bunnyhop,skipNextFrame
end)

savestate.registerload(function(slotnumber)
        local a,b,c,d,e,f = savestate.loadscriptdata(slotnumber)
        if a then
                waslagged = a
                islagged = b
                lagCount = c
                lagColor = d
        end

        if e and f then
                bunnyhop = e
                skipNextFrame = f
        end
        Bunnyhopper()
end)


-------------------
-- RNG Simulator --
-------------------

function GetRandom()
--      value.rng = memory.readlong(address.rng)
--      value.rng = 0x7C705AEA

        regD1 = value.rng                                                                    -- MOVE.L  ($C118),D1
        regD0 = regD1                                                                        -- MOVE.L  D1,D0
        regD1 = SHIFT(regD1,-2)                                                              -- ASL.L   #2,D1
        regD1 = regD1 + regD0                                                                -- ADD.L   D0,D1
        regD1 = SHIFT(regD1,-3)                                                              -- ASL.L   #3,D1
        regD1 = regD1 + regD0                                                                -- ADD.L   D0,D1
        regD0 = OR(AND(regD1,0xFFFF),AND(regD0,0xFFFF0000))                                  -- MOVE.W  D1,D0
        regD1 = OR(SHIFT(AND(regD1,0xFFFF),-16),AND(SHIFT(AND(regD1,0xFFFF0000),16),0xFFFF)) -- SWAP.W  D1
        regD0 = OR(AND(regD0,0xFFFF0000),(AND(regD0+AND(regD1,0xFFFF),0xFFFF)))              -- ADD.W   D1,D0
        regD1 = OR(AND(regD0,0xFFFF),AND(regD1,0xFFFF0000))                                  -- MOVE.W  D0,D1
        regD1 = OR(SHIFT(AND(regD1,0xFFFF),-16),AND(SHIFT(AND(regD1,0xFFFF0000),16),0xFFFF)) -- SWAP.W  D1

--      gui.text(100,100,string.format("%X",regD0)..":"..string.format("%X",regD1),"red")
        value.rng = regD1
        return(regD0)
end


function Stage3Randomness()
        local yinit,num2sub,rngtmp
        local targetyi   = {336,416,336,416,416,400,336,336,432,416,336}
        local targetaddy = {0xFF7F44,0xFF7F84,0xFF8044,0xFF8084,0xFF80C4,0xFF8A44,0xFF8D04,0xFF8D84,0xFF8E04,0xFF8E44,0xFF9744}
        local targetslot = {5,6,9,10,11,49,60,62,64,65,101}
        local numcolor   = { [0x400]="green", [0x800]="yellow", [0xC00]="orange" }
        value.rng = memory.readlong(address.rng)
--      value.rng = 0x583B78DA
--      value.rng = 0x5BD9780A

        -- RNG advances 5 times after B2
        for x=1,5 do
                GetRandom()
        end

        -- subtract 1024*x to each target
        for target=1,11 do
                if target == 11 then
                        for x=1,38 do
                                GetRandom()
                        end
                end
                currentYpos = memory.readwordsigned(address.enemy+offset.y+targetslot[target]*value.slot_interval)
                gui.text(33,30+8*target,currentYpos)
                rngtmp = GetRandom()
                num2sub = SHIFT(AND(rngtmp,7)+1,-8)*4
                color = "red"
                if num2sub < 0x1000 then color = numcolor[num2sub] end
                yinit = targetyi[target] - ( SHIFT(AND(rngtmp,7)+1,-8)*4 - 4 )
                gui.text(55,30+8*target,yinit,color)
                gui.text(100,30+8*target,string.format("%X",num2sub),color)
--              print((targetaddy[target]-address.enemy)/0x40)
        end
end