Alas, it's only a fancy memory watch. Doesn't do things like calculate the RNG or predict the enemy actions.Language: lualocal R1u= memory.readbyte local R2u= memory.readword local R4u= memory.readdword local R1s= memory.readbytesigned local R2s= memory.readwordsigned local R4s= memory.readdwordsigned --***************************************************************************** local function GuiTextRight(x,y,str,c1,c2) --***************************************************************************** str= tostring(str) x= x - (#str)*4 gui.text(x,y,str,c1,c2) end --***************************************************************************** local function StatAndExp(x,y,addr,str) --***************************************************************************** GuiTextRight( x,y,R1u(addr)) gui.text( x,y,string.format(".%2d",R1u(addr+1)),0xC0C0C0FF) local Growth= R2u(addr+0x17FA) if Growth ~= 0 then GuiTextRight(x+12,y+7, "+" .. Growth, 0x00FFFFFF) else gui.text(x,y+7,str,0xFFFF00FF) end end --***************************************************************************** local function StatAndMax(x,y,addr) --***************************************************************************** GuiTextRight( x,y,R1u(addr)) gui.text( x,y,string.format("/%3d",R1u(addr+1)),0xC0C0C0FF) end --***************************************************************************** local function DumpStats() --***************************************************************************** StatAndMax( 88,200,0x7E0589) -- HP StatAndMax(220,200,0x7E058B) -- MP GuiTextRight(236,192,R2u(0x7E1D97),0xC0FFC0FF) StatAndMax(120,214,0x7E058D) -- Luck gui.text(120,207,"Luck",0xFFFF00FF) GuiTextRight(148,207,R2s(0x7E1D9B),0xC0C0C0FF) local clr= 0xFFFF00FF if R2s(0x7E1D9B) > 0 then clr= 0x00FF00FF end GuiTextRight(148,214,R2u(0x7E1D99),clr) StatAndExp( 20,210,0x7E058F,"Arm") -- Arm Strength 0x7E1D89 StatAndExp( 50,210,0x7E0591,"Kno") -- Knowledge StatAndExp( 80,210,0x7E0593,"MgE") -- Magic Endurance StatAndExp(200,210,0x7E0595,"Lvl") -- Level GuiTextRight(256, 0,R4u(0x7E43C2)) -- Gold on hand end gui.register(DumpStats)
Tried this script yet? There are a few caveats with this script, such as the fact it makes no attempt to screen out things like xmouse or ymouse. On the other hand, the script does reveal every key currently held, and I really hope you have no trouble picking past the xmouse and ymouse to find out what the key is. We'll improve on this script later, after I explain better ways of dealing with input.get(). How do we detect when the user presses a key? I've already outlined how one could detect when a key is held, by having typed keys = input.get() and later if keys["A"] then as an example of looking for when the A key is held. However, there are times we want to execute code only once per key press. Maybe you're counting how many times the user pressed space, and you don't want the counter zooming upwards at a rapid pace when it's being held. My favorite method for detecting a key press in EmuLua stuff is as follows: Download PressKey.luaLanguage: lualocal function KeyCheck() local T= input.get() local y= 2 for k,v in pairs(T) do gui.text(2,y,k) y=y+10 end end gui.register(KeyCheck)
In the code above, I keep two tables. keys is the current keys held, and lastkeys keeps whatever was held a rather short moment ago. I need this so I can tell the moment the user pushes the key down, and not repeatedly run the same code when it is instead held. This is pretty crucial to detecting key presses. Hopefully, UpdateKeys() and Press(k) are short enough that you don't need me to identify what they do. I should hope even a beginner can understand what the code does. There is one further bit of trickery with input.get() one can do. One that makes it easier to handle binding functions to hotkeys in lua code, so to speak. From the above code, you might be doing something like this:Language: lualocal keys, lastkeys= input.get(), input.get() local function UpdateKeys() lastkeys= keys; keys= input.get() end local function Press(k) return keys[k] and (not lastkeys[k]) end local function Fn() -- Test function to use the above. UpdateKeys() -- Call this once, and only once per loop! if Press("space") then print("Congratulations! You pressed space! Have a cookie.") end if Press("A") then print("That's the keyboard's A key! That's not a controller A button!") end end gui.register(Fn)
However, when copying or moving this code around, you might end up having to mess with the tabs or spaces to keep it readable. Or if making a new function, you have to add a call here. For you coders, there is a way to streamline the function creation and, at the same time, let the lua code call the function at a key press, without needing to add a call elsewhere in code. My method is simply as follows: Download EmuLuaHotkeyFn.luaLanguage: luaif Press(SomeLetter) then --Insert code or function calls here end if Press(SomeOtherLetter) then --Insert even more code, or possibly function calls here end --Repeat for every function. Wow, this feels inconvenient.
KeyFunctions() uses pairs(keys) to walk through all the currently held keys, and specifically checks if they were pressed or simply held by using lastkeys. If a key was indeed pressed and not held since last update, it will look into KF to see if there exists something there. If so, it will call it as a function. As for creating functions to be placed into table KF, note how I do it. I pick a key, use it as an index for KF, and set whatever I indexed equal to a function, which I define on the spot. I don't need to add a function call to some sort of Master List of function calls, as KeyFunctions() handles that for me for any functions I stick into table KF. But that is more for larger scale projects that use numerous different functions for all the keyboard hotkeys you need to set. In any case, I said earlier that I would improve on the KeyCheck script above, and I will. All it takes is a minor tweak to KeyFunctions. Instead of calling a function in KF, we'll just stick what key we got into some string, which we'll display on screen... Download KeyCheck_v2.luaLanguage: lualocal keys, lastkeys= input.get(), input.get() local function UpdateKeys() lastkeys= keys; keys= input.get() end local KF= {} local function KeyFunctions() UpdateKeys() for key,v in pairs(keys) do if not lastkeys[key] then if KF[key] then KF[key]() end end end end gui.register(KeyFunctions) KF["space"]= function () print("That thing you pressed is the space bar.") end KF["A"]= function () print("Please insert more useful code here.") end
Now it's a lot less messy of a display. It shows just one key, the last one you've pressed, none of this mess with xmouse and all that. These are a few things that come to mind when handling input.get(). It's a very useful function, and if you ever want to create some interaction with any script, knowing a few tricks can really help with some problems of how to deal with the user's input in a clean way. But if all you make are throwaway scripts that only display RAM values, with possibly a few calculations to them... None of this will really apply. But when you start stepping into a point where you think something along the lines of "I hate having to edit and restart this script just to change this one value over and over," consider the idea of implementing input.get() into the code to change value for you.Language: lualocal keys, lastkeys= input.get(), input.get() local function UpdateKeys() lastkeys= keys; keys= input.get() end local LastPress= "Nothing, yet." local function KeyCheck2() UpdateKeys() for key,v in pairs(keys) do if not lastkeys[key] then LastPress= key end end gui.text(2,2,LastPress) end gui.register(KeyCheck2)
Should paint an (almost) invisible green box on the entire screen. You shouldn't notice any difference in color. What's likely a bug is the fact I see everything is shifted up 8 pixels. For more fun, here's a small box you can drag around:Language: luawhile true do gui.box(0, 8,255,231,0x00FF0001,0x00FF0001) emu.frameadvance() end
Language: lualocal lastkeys, keys= input.get(), input.get() --***************************************************************************** local function UpdateKeys() lastkeys= keys; keys= input.get() end --***************************************************************************** local function Limits(V,l,h) return math.max(math.min(V,h),l) end --***************************************************************************** local x,y= 50, 50 local function Fn() UpdateKeys() if keys.leftclick then x= Limits(x+keys.xmouse-lastkeys.xmouse , 0 , 235) y= Limits(y+keys.ymouse-lastkeys.ymouse , 8 , 211) end gui.box(x,y,x+20,y+20,0x00FF0001,0x00FF0040) end gui.register(Fn)
Language: luaR2u= memory.readword --***************************************************************************** local function roll(A,B,C) --***************************************************************************** return bit.band(0xFFFF, bit.bxor( bit.rshift(A, 5), bit.lshift(B,11), bit.rshift(B,15), bit.lshift(C, 1) ) ) end --***************************************************************************** local function unroll(A,B,C) --***************************************************************************** --Returns what the previous RNG was. local r= bit.band(0xFFFE,bit.bxor(A, bit.rshift(B, 5), bit.lshift(C, 11))) r= bit.bor(r,bit.band(0x0001,bit.bxor(B,bit.rshift(C,5)))) return bit.bor( bit.lshift(bit.band(0x0001,r),15), bit.rshift(bit.band(0xFFFE,r), 1) ) end local Raddr= 0x03000000 local R= {R2u(Raddr), R2u(Raddr+2), R2u(Raddr+4)} --***************************************************************************** local function RNGmatch(a,b,c) --***************************************************************************** return (R2u(Raddr) == a) and (R2u(Raddr+2) == b) and (R2u(Raddr+4) == c) end --***************************************************************************** local function AdvanceRNG() --***************************************************************************** local RR= {R[1], R[2], R[3]} for i= 0, 2000 do if RNGmatch(R[1],R[2],R[3]) then return i end if RNGmatch(RR[1],RR[2],RR[3]) then R= RR; return -i end table.insert(R,1,roll(R[1],R[2],R[3])); R[4]= nil table.insert(RR,unroll(RR[1],RR[2],RR[3])); table.remove(RR,1) end R[1]= R2u(Raddr) R[2]= R2u(Raddr+2) R[3]= R2u(Raddr+4) return false end local Count, Fail= 0, 0 --***************************************************************************** local function CountRolls() --***************************************************************************** local c= AdvanceRNG() if c then Count= Count+c else Fail= Fail+1; Count= 0 end end --***************************************************************************** local function ShowRolls() --***************************************************************************** gui.text(1,1,Count,"green") gui.text(1,9,Fail,"red") end gui.register(ShowRolls) while true do CountRolls() emu.frameadvance() end
Language: lua--Aids in displaying lua-based subtitles --FatRatKnight --S(start,end,left,top,line1, line2, ..., lineN) --Subtitle. Displays text --B(start,end,left,top,right,bottom,FillColor,BorderColor) --Box. Paints a colored box at selected area. --R1U(start,end,left,top,text,address) --ReadAddress. Displays one line of text and displays value at address. --Full list of related functions: R1U, R2U, R4U, R1S, R2S, R4S --A(start,end,left,top,FillColor,BorderColor, line1, line2, ..., lineN) --Auto Box&Subtitle. Displays text and a text-fitting box around it. --Additionally, I provide a lowercase letter version of each function. --The end parameter for lowercase is relative to start, so inserting 300 there --means that the subtitle will last 300 frames. Additionally, lowercase also --makes the box routine ask for width and height instead of right-side and --bottom-side. --The R#U and R#S functions need to be fully lowercase. r1U will fail. --But r1u will work just fine. local Subbies= {} local WID= 6 -- Width of each character. DeSmuME uses 6. local HGT= 9 -- Height. I'm arbitrarily using 9 here. if stylus then --DeSmuME. Platform: DS WID= 6; HGT= 9 elseif snes9x then --Snes9x. Platform: SNES WID= 4; HGT= 8 elseif vba then --VisualBoy Advance. Platforms: GBA, GB, GBC, SGB WID= 4; HGT= 8 elseif FCEU then --FCE Ultra / FCEUX. Platform: NES. WID= 2; HGT= 9 end -- Array based functions. --############################################################################# --***************************************************************************** local function DispMsg(T) --***************************************************************************** for i= 1, #T do gui.text(T.x,T.y+HGT*(i-1),T[i],T.c1,T.c2) end end --***************************************************************************** local function DispAddr(T) --***************************************************************************** gui.text(T.x,T.y, string.format(T.txt, T.rv(T.v)) , T.c1,T.c2) end --***************************************************************************** local function DispBox(T) --***************************************************************************** gui.box(T.x,T.y,T.x2,T.y2 , T.c1,T.c2) end --############################################################################# local CurrentIndex= 1 local ActiveSubs= {} --***************************************************************************** local function HandleArray() --***************************************************************************** -- I'll leave the intelligence of add/removal here. --Add while Subbies[CurrentIndex] and (Subbies[CurrentIndex].t <= movie.framecount()) do table.insert(ActiveSubs,Subbies[CurrentIndex]) CurrentIndex= CurrentIndex+1 end --Execute/remove local i= 1 while ActiveSubs[i] do if ActiveSubs[i].e >= movie.framecount() then ActiveSubs[i]:fn() i= i+1 else table.remove(ActiveSubs,i) end end end --***************************************************************************** local function ResetArray() --***************************************************************************** CurrentIndex= 1 ActiveSubs= {} end --***************************************************************************** local function AddToSubbies(T) --***************************************************************************** for i= #Subbies, 1, -1 do if T.t >= Subbies[i].t then table.insert(Subbies,i+1,T) return -- Escape, as we have inserted it! end end table.insert(Subbies,1,T) -- If we go here, the loop failed to insert. end --############################################################################# --############################################################################# -- [S]ubtitle -- Can take an arbitrary number of lines -- Its name is one letter long to save bytes. Lots of them. --***************************************************************************** function S(start,End , left,top , ...) --***************************************************************************** -- This is a CAPITAL S. Use absolutes. if arg.n <= 0 then return end -- Sanity; Must have text! local NewSub= { fn= DispMsg, t= start, e= End, x= left, y= top } for i= 1, arg.n do NewSub[i]= arg[i] end AddToSubbies(NewSub) end --***************************************************************************** function s(start,length , left,top , ...) --***************************************************************************** -- Lowercase s. Use relatives where it makes sense (frame end is it). if arg.n <= 0 then return end -- Sanity; Must have text! local NewSub= { fn= DispMsg, t= start, e= start+length, x= left, y= top } for i= 1, arg.n do NewSub[i]= arg[i] end AddToSubbies(NewSub) end --***************************************************************************** local function ReadMem(start,End , left,top , str,addr , NewFn) --***************************************************************************** -- Not for end-user; Call the R#U/S series instead! -- The usual start,end,left,top applies AddToSubbies{ fn= DispAddr, t= start, e= End, x= left, y= top, txt= str, v= addr, rv= NewFn } end --============================================================================= function R1U(start,End , x1,y1 , str,addr) ReadMem(start,End , x1,y1 , str,addr , memory.readbyteunsigned) end function R2U(start,End , x1,y1 , str,addr) ReadMem(start,End , x1,y1 , str,addr , memory.readwordunsigned) end function R4U(start,End , x1,y1 , str,addr) ReadMem(start,End , x1,y1 , str,addr , memory.readdwordunsigned) end function R1S(start,End , x1,y1 , str,addr) ReadMem(start,End , x1,y1 , str,addr , memory.readbytesigned) end function R2S(start,End , x1,y1 , str,addr) ReadMem(start,End , x1,y1 , str,addr , memory.readwordsigned) end function R4S(start,End , x1,y1 , str,addr) ReadMem(start,End , x1,y1 , str,addr , memory.readdwordsigned) end function r1u(start,length , x1,y1 , str,addr) ReadMem(start,start+length , x1,y1 , str,addr , memory.readbyteunsigned) end function r2u(start,length , x1,y1 , str,addr) ReadMem(start,start+length , x1,y1 , str,addr , memory.readwordunsigned) end function r4u(start,length , x1,y1 , str,addr) ReadMem(start,start+length , x1,y1 , str,addr , memory.readdwordunsigned) end function r1s(start,length , x1,y1 , str,addr) ReadMem(start,start+length , x1,y1 , str,addr , memory.readbytesigned) end function r2s(start,length , x1,y1 , str,addr) ReadMem(start,start+length , x1,y1 , str,addr , memory.readwordsigned) end function r4s(start,length , x1,y1 , str,addr) ReadMem(start,start+length , x1,y1 , str,addr , memory.readdwordsigned) end --============================================================================= -- [B]ox --***************************************************************************** function B(start,End , left,top , right,bottom , cf,cb) --***************************************************************************** AddToSubbies{ fn= DispBox, t= start, e= End, x= left, y= top, x2= right, y2= bottom, c1= cf, c2= cb } end --***************************************************************************** function b(start,length , left,top , width,height , cf,cb) --***************************************************************************** AddToSubbies{ fn= DispBox, t= start, e= start+length, x= left, y= top, x2= left+width, y2= top+height, c1= cf, c2= cb } end -- [A]uto -- Boxes and subtitles, wrapped in one. -- Calculates the box size for you! --***************************************************************************** function A(start,End , left,top , cf,cb , ...) --***************************************************************************** if arg.n <= 0 then return end -- Sanity local NewSub= { fn= DispMsg, t= start, e= End, x= left, y= top } local len= 0 for i= 1, arg.n do NewSub[i]= arg[i] len= math.max(len, string.len(arg[i])) end B(start,End , left-1,top-1 , left+len*WID,top+arg.n*HGT, cf,cb) AddToSubbies(NewSub) end --***************************************************************************** function a(start,length , left,top , cf,cb , ...) --***************************************************************************** if arg.n <= 0 then return end -- Sanity local NewSub= { fn= DispMsg, t= start, e= start+length, x= left, y= top } local len= 0 for i= 1, arg.n do NewSub[i]= arg[i] len= math.max(len, string.len(arg[i])) end B(start,start+length , left-1,top-1 , left+len*WID,top+arg.n*HGT, cf,cb) AddToSubbies(NewSub) end --############################################################################# --############################################################################# local LastFC= 0 --***************************************************************************** local function FrameCountSanity() --***************************************************************************** local FC= movie.framecount() if FC < LastFC then ResetArray() end LastFC= FC end --***************************************************************************** local function HandleSubs() --***************************************************************************** FrameCountSanity() HandleArray() end gui.register(HandleSubs)
MtEdit link looks wrong.
Noteable changes * [...] * New lua functions. *[...]
readup - - function read - - function write - - function set - - function readdown - - function getup - - function getdown - - function get - - function ... Nuts. No joypad.peek.Language: lualocal target= joypad for k,v in pairs(target) do print(k, "- -", type(v)) end
... Nuts. Still no frame-immediate way of reading then writing to joypad. Doesn't matter where I put this function (emu.frameadvance loop, emu.registerbefore, or whatever else). At least gui.register still runs while paused. That is still quite lovely. As for the accuracy, I say go make the change! The earlier versions of FCEUX will be available for sync stability of older movies, I hope.Language: lualocal function Fn() joypad.set(1,joypad.get(2)) end
Language: lualocal PLAYERS = 2 local btn = {"right","left","down","up","start","select","B","A"} --Joypad --############################################################################# -- Keyboard Control mapping local PlayerSwitch= "home" local solid= "pageup" -- Make the display less local clear= "pagedown" -- or more transparant. local mp= "numpad7" --More past. Tweak display to see further back! local lp= "numpad1" --Less past. You'll see less of the input stream. local mf= "numpad3" --More future. local lf= "numpad9" --Less future. local AutoList= true local Insert= "insert" local Delete= "delete" local AutoSwitch= "end" --############################################################################# -- Default values local Opq= 1 local DispX, DispY= 50, 80 --############################################################################# local PlSel= 1 local ThisJoypad= {} local JoypadList= {} local UserControl= {} local ListControl= {} for pl= 1, PLAYERS do ThisJoypad[pl]= {} JoypadList[pl]= {} UserControl[pl]= "inv" ListControl[pl]= true end local fc , Lastfc= 0 , 0 --***************************************************************************** local function UpdateFC() Lastfc= fc; fc= movie.framecount() end --***************************************************************************** --***************************************************************************** local function Within(V,l,h) return (V >= l) and (V <= h) end local function Limits(V,l,h) return math.max(math.min(V,h),l) end local function NullFN() return end --***************************************************************************** --############################################################################# --############################################################################# --Joypad --***************************************************************************** local function JoyToNum(Joys) -- Expects a table containing joypad buttons --***************************************************************************** -- Returns a number representing button presses. -- These numbers are the primary storage for this version of this script. local joynum= 0 for i= 1, #btn do if Joys[btn[i]] then joynum= bit.bor(joynum, bit.lshift(1,i)) end end return joynum end --***************************************************************************** local function ReadJoynum(Jn, button) -- Expects... Certain numbers! --***************************************************************************** -- Returns true or false. True if the indicated button is pressed -- according to the input. False otherwise. return ( bit.band(Jn , bit.lshift( 1, button )) ~= 0 ) end --***************************************************************************** local function LoadJoypad(pl) --***************************************************************************** -- Sets up the joypad to inject into the emulation. local joys= JoypadList[pl][fc] if ListControl[pl] then for b= 1, #btn do if joys and ReadJoynum(joys, b) then ThisJoypad[pl][btn[b]]= (UserControl[pl] or true) else ThisJoypad[pl][btn[b]]= (UserControl[pl] and nil) end end else for b= 1, #btn do ThisJoypad[pl][btn[b]]= (UserControl[pl] and nil) end end --UserControl is "inv" or false. I abuse the shortcutting of or & and. end --***************************************************************************** local function RegBoundaryHandleJoypad() --***************************************************************************** for pl= 1, PLAYERS do joypad.set(pl, ThisJoypad[pl]) end end --***************************************************************************** local function RegAfterHandleJoypad() --***************************************************************************** for pl= 1, PLAYERS do JoypadList[pl][Lastfc]= JoyToNum(joypad.get(pl)) LoadJoypad(pl) end end --############################################################################# --############################################################################# --Display (Joypad) --***************************************************************************** local Draw= {} --***************************************************************************** function Draw.left(x,y,color) -- ## gui.line(x+1,y ,x+2,y ,color) -- # gui.line(x+1,y+2,x+2,y+2,color) -- ## gui.pixel(x ,y+1,color) end function Draw.up(x,y,color) -- # gui.line(x ,y+1,x ,y+2,color) -- # # gui.line(x+2,y+1,x+2,y+2,color) -- # # gui.pixel(x+1,y ,color) end function Draw.right(x,y,color) -- ## gui.line(x ,y ,x+1,y ,color) -- # gui.line(x ,y+2,x+1,y+2,color) -- ## gui.pixel(x+2,y+1,color) end function Draw.down(x,y,color) -- # # gui.line(x ,y ,x ,y+1,color) -- # # gui.line(x+2,y ,x+2,y+1,color) -- # gui.pixel(x+1,y+2,color) end function Draw.A(x,y,color) -- ### gui.line(x ,y ,x ,y+2,color) -- ### gui.line(x+1,y ,x+1,y+1,color) -- # # gui.line(x+2,y ,x+2,y+2,color) end function Draw.B(x,y,color) -- # # gui.line(x ,y ,x ,y+2,color) -- ## gui.line(x+1,y+1,x+2,y+2,color) -- # # gui.pixel(x+2,y ,color) end function Draw.start(x,y,color) -- # gui.line(x+1,y ,x+1,y+2,color) -- ### gui.pixel(x ,y+1,color) -- # gui.pixel(x+2,y+1,color) end function Draw.select(x,y,color) -- ### gui.line(x ,y ,x+2,y ,color) -- # # gui.line(x ,y+2,x+2,y+2,color) -- ### gui.pixel(x ,y+1,color) gui.pixel(x+2,y+1,color) end Draw[0]= function(left, top, color) -- ### gui.line(left ,top ,left ,top+4,color)-- # # gui.line(left+2,top ,left+2,top+4,color)-- # # gui.pixel(left+1,top ,color) -- # # gui.pixel(left+1,top+4,color) -- ### end Draw[1]= function(left, top, color) -- # gui.line(left ,top+4,left+2,top+4,color)-- ## gui.line(left+1,top ,left+1,top+3,color)-- # gui.pixel(left ,top+1,color) -- # end -- ### Draw[2]= function(left, top, color) -- ### gui.line(left ,top ,left+2,top ,color)-- # gui.line(left ,top+3,left+2,top+1,color)-- ### gui.line(left ,top+4,left+2,top+4,color)-- # gui.pixel(left ,top+2,color) -- ### gui.pixel(left+2,top+2,color) end Draw[3]= function(left, top, color) -- ### gui.line(left ,top ,left+1,top ,color)-- # gui.line(left ,top+2,left+1,top+2,color)-- ### gui.line(left ,top+4,left+1,top+4,color)-- # gui.line(left+2,top ,left+2,top+4,color)-- ### end Draw[4]= function(left, top, color) -- # # gui.line(left ,top ,left ,top+2,color)-- # # gui.line(left+2,top ,left+2,top+4,color)-- ### gui.pixel(left+1,top+2,color) -- # end -- # Draw[5]= function(left, top, color) -- ### gui.line(left ,top ,left+2,top ,color)-- # gui.line(left ,top+1,left+2,top+3,color)-- ### gui.line(left ,top+4,left+2,top+4,color)-- # gui.pixel(left ,top+2,color) -- ### gui.pixel(left+2,top+2,color) end Draw[6]= function(left, top, color) -- ### gui.line(left ,top ,left+2,top ,color)-- # gui.line(left ,top+1,left ,top+4,color)-- ### gui.line(left+2,top+2,left+2,top+4,color)-- # # gui.pixel(left+1,top+2,color) -- ### gui.pixel(left+1,top+4,color) end -- ### Draw[7]= function(left, top, color) -- # gui.line(left ,top ,left+1,top ,color)-- ## gui.line(left+2,top ,left+1,top+4,color)-- # end -- # Draw[8]= function(left, top, color) -- ### gui.line(left ,top ,left ,top+4,color)-- # # gui.line(left+2,top ,left+2,top+4,color)-- ### gui.pixel(left+1,top ,color) -- # # gui.pixel(left+1,top+2,color) -- ### gui.pixel(left+1,top+4,color) end Draw[9]= function(left, top, color) -- ### gui.line(left ,top ,left ,top+2,color)-- # # gui.line(left+2,top ,left+2,top+3,color)-- ### gui.line(left ,top+4,left+2,top+4,color)-- # gui.pixel(left+1,top ,color) -- ### gui.pixel(left+1,top+2,color) end --***************************************************************************** local function GetColor(Jn,b) --***************************************************************************** if not Jn then return "white" end --Does not exist if not ReadJoynum(Jn,b) then return "red" end --Not pressed return "green" --Button pressed end --***************************************************************************** local function PaintFrame(x,y,Jn) --***************************************************************************** for b= 1, #btn do Draw[btn[b]](x+4*b,y,GetColor(Jn,b)) end end --***************************************************************************** local function PaintBorder(x,y) --***************************************************************************** local color= "green" if not AutoList then color= -0x003FFF01 end gui.line(x, y,x, y+4,color) gui.line(x+2+4*#btn,y,x+2+4*#btn,y+4,color) gui.pixel(x+1 ,y ,color) gui.pixel(x+1 ,y+4,color) gui.pixel(x+1+4*#btn,y ,color) gui.pixel(x+1+4*#btn,y+4,color) if PLAYERS > 1 then Draw[PlSel](x-4,y,color) end end local Past, Future= -5, 5 --***************************************************************************** local function PaintJoypadList(x,y) --***************************************************************************** gui.box(x+3,y+4*Past-1,x+4*#btn+3,y+4*Future+3,0x00000080) for i= Past, Future do PaintFrame(x,y+4*i, JoypadList[PlSel][fc+i]) end if Past <= 0 and Future >= 0 then PaintBorder(x+2,y-1) end end --############################################################################# --############################################################################# --User local lastkeys, keys= input.get(), input.get() --***************************************************************************** local function UpdateKeys() lastkeys= keys; keys= input.get() end local function Press(k) return keys[k] and (not lastkeys[k]) end --***************************************************************************** local KF= {} --***************************************************************************** local function KeyReader() --***************************************************************************** for k,v in pairs(keys) do if (not lastkeys[k]) and KF[k] then KF[k]() end end end local HandleMouse --***************************************************************************** local function HandleMouse_Main() --***************************************************************************** if keys.leftclick and lastkeys.leftclick then DispX= DispX + keys.xmouse - lastkeys.xmouse DispY= DispY + keys.ymouse - lastkeys.ymouse end end --***************************************************************************** local function HandleMouse_Option() --***************************************************************************** end HandleMouse= HandleMouse_Main local MaxRange= 54 ------------------------------------------------------------------------------- KF[solid]= function() Opq= math.min(Opq+0.125 , 1); gui.opacity(Opq) end KF[clear]= function() Opq= math.max(Opq-0.125 , 0); gui.opacity(Opq) end ------------------------------------------------------------------------------- KF[mp]=function() Past = Past -1; Future= math.min(Future,Past+MaxRange) end KF[lp]=function() Past = Past +1; Future= math.max(Future,Past) end KF[mf]=function() Future= Future+1; Past= math.max(Past,Future-MaxRange) end KF[lf]=function() Future= Future-1; Past= math.min(Past,Future) end local PlSwitch --***************************************************************************** local function PlSw() --***************************************************************************** for pl= 1, PLAYERS do UserControl[pl]= false ListControl[pl]= true end UserControl[PlSel]= "inv" ListControl[PlSel]= AutoList for pl= 1, PLAYERS do LoadJoypad(pl) end end PlSwitch= PlSw PlSw() ------------------------------------------------------------------------------- KF[PlayerSwitch]= function() ------------------------------------------------------------------------------- PlSel= (PlSel%PLAYERS)+1 PlSwitch() end ------------------------------------------------------------------------------- KF[Insert]= function() ------------------------------------------------------------------------------- local frame= fc while JoypadList[PlSel][frame] do frame=frame+1 end for i= frame, (fc+1), -1 do JoypadList[PlSel][i]= JoypadList[PlSel][i-1] end JoypadList[PlSel][fc]= 0 LoadJoypad(PlSel) end ------------------------------------------------------------------------------- KF[Delete]= function() ------------------------------------------------------------------------------- local i= fc while JoypadList[PlSel][i] do JoypadList[PlSel][i]= JoypadList[PlSel][i+1] i=i+1 end LoadJoypad(PlSel) end ------------------------------------------------------------------------------- KF[AutoSwitch]= function() ------------------------------------------------------------------------------- AutoList= not AutoList ListControl[PlSel]= AutoList end --############################################################################# --############################################################################# --Registry --***************************************************************************** local function RegisterAfter() --***************************************************************************** UpdateFC() RegAfterHandleJoypad() end emu.registerafter(RegisterAfter) --***************************************************************************** local function RegisterGui() --***************************************************************************** UpdateKeys() KeyReader() HandleMouse() DispX= Limits(DispX,-2,251-#btn*4) DispY= Limits(DispY,1+-4*Past,220-4*Future) PaintJoypadList(DispX, DispY) gui.pixel(0,0,0) end gui.register(RegisterGui) --***************************************************************************** local function RegisterLoad() --***************************************************************************** UpdateFC() for pl= 1, PLAYERS do LoadJoypad(pl) end end savestate.registerload(RegisterLoad) --***************************************************************************** while true do --Register boundary --***************************************************************************** RegBoundaryHandleJoypad() emu.frameadvance() end
Should work with the latest Snes9x 1.51 we have. If not, let me know.Language: lua--lua script for snes9x rerecording+lua. For SimCity (U) --Original by Dammit. Mostly rewritten by FatRatKnight, Feb 10 2010. local ShowNum, ShowGrid= true, true local ShowHex= false local Control= 2 local SwitchNum, SwitchGrid= "X","Y" local SwitchVal= "A" local SwitchDisp= "B" local Brd,Bck= {},{} Brd[0],Bck[0]= 0x00000060,0x00000000 --Black ; value zero Brd[1],Bck[1]= 0x005A00C0,0x005A0038 --V.Dark Green; Rock bottom, non-zero Brd[2],Bck[2]= 0x008C00C0,0x008C0038 --Dark Green ; Pitifully low Brd[3],Bck[3]= 0x00BD00C0,0x00BD0038 --Green ; Somewhat low Brd[4],Bck[4]= 0x00FF00C0,0x00FF0038 --Bright Green; Near-mid, but low Brd[5],Bck[5]= 0xFFFF00C0,0xFFFF0038 --Yellow ; Near-mid, but high Brd[6],Bck[6]= 0xFFB500C0,0xFFB50038 --YellowOrange; Somewhat high Brd[7],Bck[7]= 0xFF6300C0,0xFF630038 --Orange ; Rather high, I say Brd[8],Bck[8]= 0xFF0000C0,0xFF000038 --Pure red ; Absolute top local view -- Declaring that view exists here so functions can access it! local FieldW , FieldH= 120 , 100 -- Size of game's map local CamW , CamH = 32 , 28 -- Size of camera local CamX,CamY= 0x7E01BD,0x7E01BF -- Memory where camera position is stored --***************************************************************************** local function Byte_U(Index,TileX,TileY) --***************************************************************************** local Bx= view[Index]["Bx"] local Offset= math.floor(TileX/Bx) + math.floor(TileY/Bx)*math.floor(FieldW/Bx) local Val= memory.readbyte(view[Index]["addr"]+Offset) local C= 0 if Val ~= 0 then C= math.floor((Val+0x1F)/0x20) end return Bck[C], Brd[C], Val end --***************************************************************************** local function Bit___(Index,TileX,TileY) --Assumed box size is 1 --***************************************************************************** local Offset= math.floor(TileX/8) + TileY*math.floor(FieldW/8) local WhichBit= bit.rshift(0x80 , TileX % 8) local Test= memory.readbyte(view[Index]["addr"]+Offset) Test= (bit.band(Test,WhichBit) ~= 0) local Background, Border= 0x00B50038, 0x00B500C0 if Test then Background, Border= 0xFF840038, 0xFF8400C0 end return Background, Border, nil end --***************************************************************************** local function Word_S(Index,TileX,TileY) --Assumed it's Pop.Growth --***************************************************************************** local Bx= view[Index]["Bx"] local Offset= math.floor(TileX/Bx) + math.floor(TileY/Bx)*math.floor(FieldW/Bx) Val= memory.readwordsigned(view[Index]["addr"]+Offset*2) local C= 0 if Val ~= 0 then C= math.floor(( Val+300 )/60) C= math.min(math.max( 1,C ),8) end return Bck[C], Brd[C], Val end view = { -- Now define view, containing above functions -- {addr=0x7F0000, Mthd=Byte_U, Bx=4, name="Mystery" }, -- Was it charts? {addr=0x7F6B00, Mthd=Byte_U, Bx=2, name="Land value" }, {addr=0x7F76B8, Mthd=Byte_U, Bx=2, name="Crime" }, {addr=0x7F8270, Mthd=Byte_U, Bx=2, name="Pollution" }, {addr=0x7F8E28, Mthd=Byte_U, Bx=2, name="Pop.density"}, {addr=0x7F99E0, Mthd=Byte_U, Bx=2, name="Traffic" }, {addr=0x7FA598, Mthd=Bit___, Bx=1, name="Power" }, {addr=0x7FAB74, Mthd=Byte_U, Bx=4, name="LVmod:Parks"}, {addr=0x7FAE62, Mthd=Word_S, Bx=8, name="Growth rate"}, {addr=0x7FAFE8, Mthd=Byte_U, Bx=8, name="Police" }, {addr=0x7FB0AB, Mthd=Byte_U, Bx=8, name="Fire" }--, -- {addr=0x7FB16E, Mthd=Word_S, Bx=8, name="Tmp_Fire" }, -- {addr=0x7FB2F4, Mthd=Word_S, Bx=8, name="Tmp_Police" }, -- {addr=0x7FB47A, Mthd=Word_S, Bx=8, name="Com_Rate?" }, -- {addr=0x7FB600, Mthd=Byte_U, Bx=2, name="AltPollute1"}, -- {addr=0x7FC1B8, Mthd=Byte_U, Bx=2, name="AltPollute2"}, -- {addr=0x7FCD70, Mthd=Byte_U, Bx=4, name="LndVal.Mod "}, -- {addr=0x7FD05E, Mthd=Word_S, Bx=8, name="Tmp2_Police"} } --***************************************************************************** local function FindCam() --***************************************************************************** return memory.readwordsigned(CamX), memory.readwordsigned(CamY) end --***************************************************************************** local function ToDec(Num) --***************************************************************************** if not Num then return end return string.format("%d",Num) end --***************************************************************************** local function ToHex(Num) --***************************************************************************** if not Num then return end if Num < 0 then Num= Num+0x10000 end return string.format("%X",Num) end local ToString= ToDec if ShowHex == true then ToString= ToHex end --***************************************************************************** local function ShowStats(Left,Top,Right,Bottom, Fill,Bord,Str) --***************************************************************************** if ShowGrid then gui.box(Left,Top,Right,Bottom,Fill,Bord) end if Str and ShowNum then if Right-Left >= string.len(Str)*4+3 then gui.text(Left+2,Top+1,Str) end end end --***************************************************************************** local function DisplayScreen(Index) --***************************************************************************** local Left,Top= FindCam() local BoxSize= view[Index]["Bx"] local ReadData= view[Index]["Mthd"] local TileY= math.floor(math.max(Top, 0)/BoxSize)*BoxSize repeat local Temp= math.min(TileY+BoxSize,FieldH+1) local BoxUp= math.max((TileY-Top)*8,0) local BoxDn= math.min((Temp-Top)*8 - 1 , 223) local TileX= math.floor(math.max(Left, 0)/BoxSize)*BoxSize repeat Temp= math.min(TileX+BoxSize,FieldW+1) local BoxLf= math.max((TileX-Left)*8,0) local BoxRt= math.min((Temp-Left)*8 - 1 , 255) local Fill,Bord,Num= ReadData(Index,TileX,TileY) Num= ToString(Num) ShowStats(BoxLf,BoxUp,BoxRt,BoxDn, Fill,Bord,Num) TileX= TileX+BoxSize until (TileX >= Left+CamW) or (TileX >= FieldW) TileY= TileY+BoxSize until (TileY >= Top+CamH) or (TileY >= FieldH) end local Index= 1 --***************************************************************************** local function DisplayStuff() --***************************************************************************** local mode= memory.readbyte(0x7E0009) if (mode == 31) or (mode == 36) then if ShowNum or ShowGrid then DisplayScreen(Index) gui.text(200,215,view[Index].name,0x00FF00FF) end end end gui.register(DisplayStuff) local LastBtn= {} --***************************************************************************** while true do --***************************************************************************** local Btn= joypad.get(Control) if Btn[SwitchVal] and not LastBtn[SwitchVal] then Index= Index+1 if not view[Index] then Index= 1 end end if Btn[SwitchNum] and not LastBtn[SwitchNum] then ShowNum= not ShowNum end if Btn[SwitchGrid] and not LastBtn[SwitchGrid] then ShowGrid= not ShowGrid end LastBtn= Btn emu.frameadvance() end
I doubt anyone who joins will live up to the level of perfection you've set.