• string bizstring.binary(long num)

• Converts the number to a string representation of the binary value of the given number

• bool bizstring.contains(string str, string str2)

• Returns whether or not str contains str2

• bool bizstring.endswith(string str, string str2)

• Returns whether str ends wth str2

• string bizstring.hex(long num)

• Converts the number to a string representation of the hexadecimal value of the given number

• string bizstring.octal(long num)

• Converts the number to a string representation of the octal value of the given number

• string bizstring.pad_end(string str, int length, string pad_char)

• Appends zero or more of pad_char to the end (right) of str until it's at least length chars long. If pad_char is not a string exactly one char long, its first char will be used, or ' ' if it's empty.

• string bizstring.pad_start(string str, int length, string pad_char)

• Prepends zero or more of pad_char to the start (left) of str until it's at least length chars long. If pad_char is not a string exactly one char long, its first char will be used, or ' ' if it's empty.

• string bizstring.remove(string str, int position, int count)

• Returns a string that represents str with the given position and count removed

• string bizstring.replace(string str, string str2, string replace)

• Returns a string that replaces all occurrences of str2 in str1 with the value of replace

• nluatable bizstring.split(string str, string separator)

• Splits str into a Lua-style array using the given separator (consecutive separators in str will NOT create empty entries in the array). If the separator is not a string exactly one char long, ',' will be used.

• bool bizstring.startswith(string str, string str2)

• Returns whether str starts with str2

• string bizstring.substring(string str, int position, int length)

• Returns a string that represents a substring of str starting at position for the specified length

• string bizstring.tolower(string str)

• Returns an lowercase version of the given string

• string bizstring.toupper(string str)

• Returns an uppercase version of the given string

• string bizstring.trim(string str)

• returns a string that trims whitespace on the left and right ends of the string

• void client.addcheat(string code)

• adds a cheat code, if supported

• int client.borderheight()

• Gets the current height in pixels of the letter/pillarbox area (top side only) around the emu display surface, excluding the gameExtraPadding you've set. This function (the whole lot of them) should be renamed or refactored since the padding areas have got more complex.

• int client.borderwidth()

• Gets the current width in pixels of the letter/pillarbox area (left side only) around the emu display surface, excluding the gameExtraPadding you've set. This function (the whole lot of them) should be renamed or refactored since the padding areas have got more complex.

• int client.bufferheight()

• Gets the visible height of the emu display surface (the core video output). This excludes the gameExtraPadding you've set.

• int client.bufferwidth()

• Gets the visible width of the emu display surface (the core video output). This excludes the gameExtraPadding you've set.

• void client.clearautohold()

• Clears all autohold keys

• void client.closerom()

• Closes the loaded Rom

• nluatable client.createinstance(string name)

• returns a default instance of the given type of object if it exists (not case sensitive). Note: This will only work on objects which have a parameterless constructor. If no suitable type is found, or the type does not have a parameterless constructor, then nil is returned

• void client.displaymessages(bool value)

• sets whether or not on screen messages will display

• void client.enablerewind(bool enabled)

• Sets whether or not the rewind feature is enabled

• void client.exactsleep(int millis)

• sleeps exactly for n milliseconds

• void client.exit()

• Closes the emulator

• void client.exitCode(int exitcode)

• Closes the emulator and returns the provided code

• void client.frameskip(int numframes)

• Sets the frame skip value of the client UI (use 0 to disable)

• int client.get_approx_framerate()

• Gets the (host) framerate, approximated from frame durations.

• string client.get_lua_engine()

• returns the name of the Lua engine currently in use

• nluatable client.getavailabletools()

• Returns a list of the tools currently open

• object client.getconfig()

• gets the current config settings object

• bool client.GetSoundOn()

• Gets the state of the Sound On toggle

• int client.gettargetscanlineintensity()

• Gets the current scanline intensity setting, used for the scanline display filter

• nluatable client.gettool(string name)

• Returns an object that represents a tool of the given name (not case sensitive). If the tool is not open, it will be loaded if available. Use getavailabletools to get a list of names

• string client.getversion()

• Returns the current stable BizHawk version

• int client.getwindowsize()

• Gets the main window's size Possible values are 1, 2, 3, 4, 5, and 10

• void client.invisibleemulation(bool invisible)

• Disables and enables emulator updates

• bool client.ispaused()

• Returns true if emulator is paused, otherwise, false

• bool client.isseeking()

• Returns true if emulator is seeking, otherwise, false

• bool client.isturbo()

• Returns true if emulator is in turbo mode, otherwise, false

• void client.opencheats()

• opens the Cheats dialog

• void client.openhexeditor()

• opens the Hex Editor dialog

• void client.openramsearch()

• opens the RAM Search dialog

• void client.openramwatch()

• opens the RAM Watch dialog

• bool client.openrom(string path)

• Loads a ROM from the given path. Returns true if the ROM was successfully loaded, otherwise false.

• void client.opentasstudio()

• opens the TAStudio dialog

• void client.opentoolbox()

• opens the Toolbox Dialog

• void client.opentracelogger()

• opens the tracelogger if it is available for the given core

• void client.pause()

• Pauses the emulator

• void client.pause_av()

• If currently capturing Audio/Video, this will suspend the record. Frames will not be captured into the AV until client.unpause_av() is called

• void client.reboot_core()

• Reboots the currently loaded core

• void client.removecheat(string code)

• removes a cheat, if it already exists

• void client.saveram()

• flushes save ram to disk

• int client.screenheight()

• Gets the current height in pixels of the emulator's drawing area

• void client.screenshot([string path = nil])

• if a parameter is passed it will function as the Screenshot As menu item of EmuHawk, else it will function as the Screenshot menu item

• void client.screenshottoclipboard()

• Performs the same function as EmuHawk's Screenshot To Clipboard menu item

• int client.screenwidth()

• Gets the current width in pixels of the emulator's drawing area

• void client.seekframe(int frame)

• Makes the emulator seek to the frame specified

• void client.SetClientExtraPadding(int left, int top, int right, int bottom)

• Sets the extra padding added to the 'native' surface so that you can draw HUD elements in predictable placements

• void client.SetGameExtraPadding(int left, int top, int right, int bottom)

• Sets the extra padding added to the 'emu' surface so that you can draw HUD elements in predictable placements

• void client.setscreenshotosd(bool value)

• Sets the screenshot Capture OSD property of the client

• void client.SetSoundOn(bool enable)

• Sets the state of the Sound On toggle

• void client.settargetscanlineintensity(int val)

• Sets the current scanline intensity setting, used for the scanline display filter

• void client.setwindowsize(int size)

• Sets the main window's size to the give value. Accepted values are 1, 2, 3, 4, 5, and 10

• void client.sleep(int millis)

• sleeps for n milliseconds

• void client.speedmode(int percent)

• Sets the speed of the emulator (in terms of percent)

• void client.togglepause()

• Toggles the current pause state

• nluatable client.transformPoint(int x, int y)

• Transforms a point (x, y) in emulator space to a point in client space

• void client.unpause()

• Unpauses the emulator

• void client.unpause_av()

• If currently capturing Audio/Video this resumes capturing

• int client.xpos()

• Returns the x value of the screen position where the client currently sits

• int client.ypos()

• Returns the y value of the screen position where the client currently sits

• string comm.getluafunctionslist()

• returns a list of implemented functions

• string comm.httpGet(string url)

• makes a HTTP GET request

• string comm.httpGetGetUrl()

• Gets HTTP GET URL

• string comm.httpGetPostUrl()

• Gets HTTP POST URL

• string comm.httpPost(string url, string payload)

• makes a HTTP POST request

• string comm.httpPostScreenshot()

• HTTP POST screenshot

• void comm.httpSetGetUrl(string url)

• Sets HTTP GET URL

• void comm.httpSetPostUrl(string url)

• Sets HTTP POST URL

• void comm.httpSetTimeout(int timeout)

• Sets HTTP timeout in milliseconds

• string comm.httpTest()

• tests HTTP connections

• string comm.httpTestGet()

• tests the HTTP GET connection

• int comm.mmfCopyFromMemory(string mmf_filename, long addr, int length, string domain)

• Copy a section of the memory to a memory mapped file

• void comm.mmfCopyToMemory(string mmf_filename, long addr, int length, string domain)

• Copy a memory mapped file to a section of the memory

• string comm.mmfGetFilename()

• Gets the filename for the screenshots

• string comm.mmfRead(string mmf_filename, int expectedsize)

• Reads a string from a memory mapped file

• nluatable comm.mmfReadBytes(string mmf_filename, int expectedsize)

• Reads bytes from a memory mapped file

• int comm.mmfScreenshot()

• Saves screenshot to memory mapped file

• void comm.mmfSetFilename(string filename)

• Sets the filename for the screenshots

• int comm.mmfWrite(string mmf_filename, string outputstring )

• Writes a string to a memory mapped file

• int comm.mmfWriteBytes(string mmf_filename, nluatable bytearray)

• Write bytes to a memory mapped file

• string comm.socketServerGetInfo()

• returns the IP and port of the Lua socket server

• string comm.socketServerGetIp()

• returns the IP address of the Lua socket server

• int? comm.socketServerGetPort()

• returns the port of the Lua socket server

• bool comm.socketServerIsConnected()

• socketServerIsConnected

• string comm.socketServerResponse()

• Receives a message from the Socket server. Since BizHawk 2.6.2, all responses must be of the form $"{msg.Length:D} {msg}" i.e. prefixed with the length in base-10 and a space.

• string comm.socketServerScreenShot()

• sends a screenshot to the Socket server

• string comm.socketServerScreenShotResponse()

• sends a screenshot to the Socket server and retrieves the response

• int comm.socketServerSend(string sendstring )

• sends a string to the Socket server

• int comm.socketServerSendBytes(nluatable bytearray)

• sends bytes to the Socket server

• void comm.socketServerSetIp(string ip)

• sets the IP address of the Lua socket server

• void comm.socketServerSetPort(int port)

• sets the port of the Lua socket server

• void comm.socketServerSetTimeout(int timeout)

• sets the timeout in milliseconds for receiving messages

• bool comm.socketServerSuccessful()

• returns the status of the last Socket server action

• void console.clear()

• clears the output box of the Lua Console window

• string console.getluafunctionslist()

• returns a list of implemented functions

• void console.log(object[] outputs)

• Outputs the given object to the output box on the Lua Console dialog. Note: Can accept a LuaTable

• void console.write(object[] outputs)

• Outputs the given object to the output box on the Lua Console dialog. Note: Can accept a LuaTable

• void console.writeline(object[] outputs)

• Outputs the given object to the output box on the Lua Console dialog. Note: Can accept a LuaTable

• nluatable emu.disassemble(uint pc, [string name = ])

• Returns the disassembly object (disasm string and length int) for the given PC address. Uses System Bus domain if no domain name provided

• void emu.displayvsync(bool enabled)

• Sets the display vsync property of the emulator

• void emu.frameadvance()

• Signals to the emulator to resume emulation. Necessary for any lua script while loop or else the emulator will freeze!

• int emu.framecount()

• Returns the current frame count

• string emu.getboardname()

• returns (if available) the board name of the loaded ROM

• string emu.getdisplaytype()

• returns the display type (PAL vs NTSC) that the emulator is currently running in

• [deprecated] string emu.getluacore()

• returns the name of the Lua core currently in use

• int emu.getregister(string name)

• returns the value of a cpu register or flag specified by name. For a complete list of possible registers or flags for a given core, use getregisters

• nluatable emu.getregisters()

• returns the complete set of available flags and registers for a given core

• string emu.getsystemid()

• Returns the ID string of the current core loaded. Note: No ROM loaded will return the string NULL

• bool emu.islagged()

• Returns whether or not the current frame is a lag frame

• int emu.lagcount()

• Returns the current lag count

• void emu.limitframerate(bool enabled)

• sets the limit framerate property of the emulator

• void emu.minimizeframeskip(bool enabled)

• Sets the autominimizeframeskip value of the emulator

• void emu.setislagged([bool value = True])

• Sets the lag flag for the current frame. If no value is provided, it will default to true

• void emu.setlagcount(int count)

• Sets the current lag count

• void emu.setregister(string register, int value)

• sets the given register name to the given value

• void emu.setrenderplanes(bool[] luaparam)

• Toggles the drawing of sprites and background planes. Set to false or nil to disable a pane, anything else will draw them

• long emu.totalexecutedcycles()

• gets the total number of executed cpu cycles

• void emu.yield()

• allows a script to run while emulation is paused and interact with the gui/main window in realtime

All events support multiple registered methods.

• nluatable event.availableScopes()

• Lists the available scopes that can be specified for on_bus_* events

• bool event.can_use_callback_params([string subset = nil])

• Returns whether EmuHawk will pass arguments to callbacks. The current version passes arguments to "memory" callbacks (RAM/ROM/bus R/W), so this function will return true for that input. (It returns false for any other input.) This tells you whether it's necessary to enable workarounds/hacks because a script is running in a version without parameter support.

• string event.on_bus_exec(nluafunc luaf, uint address, [string name = nil], [string scope = nil])

• Fires immediately before the given address is executed by the core. Your callback can have 3 parameters (addr, val, flags). val is the value to be executed (or 0 always, if this feature is only partially implemented).

• string event.on_bus_exec_any(nluafunc luaf, [string name = nil], [string scope = nil])

• Fires immediately before every instruction executed (in the specified scope) by the core (CPU-intensive). Your callback can have 3 parameters (addr, val, flags). val is the value to be executed (or 0 always, if this feature is only partially implemented).

• string event.on_bus_read(nluafunc luaf, [uint? address = nil], [string name = nil], [string scope = nil])

• Fires immediately before the given address is read by the core. Your callback can have 3 parameters (addr, val, flags). val is the value read. If no address is given, it will fire on every memory read.

• string event.on_bus_write(nluafunc luaf, [uint? address = nil], [string name = nil], [string scope = nil])

• Fires immediately before the given address is written by the core. Your callback can have 3 parameters (addr, val, flags). val is the value to be written (or 0 always, if this feature is only partially implemented). If no address is given, it will fire on every memory write.

• string event.onconsoleclose(nluafunc luaf, [string name = nil])

• Fires when the emulator console closes

• string event.onexit(nluafunc luaf, [string name = nil])

• Fires after the calling script has stopped

• string event.onframeend(nluafunc luaf, [string name = nil])

• Calls the given lua function at the end of each frame, after all emulation and drawing has completed. Note: this is the default behavior of lua scripts

• string event.onframestart(nluafunc luaf, [string name = nil])

• Calls the given lua function at the beginning of each frame before any emulation and drawing occurs

• string event.oninputpoll(nluafunc luaf, [string name = nil])

• Calls the given lua function after each time the emulator core polls for input

• string event.onloadstate(nluafunc luaf, [string name = nil])

• Fires after a state is loaded. Your callback can have 1 parameter, which will be the name of the loaded state.

• [deprecated] string event.onmemoryexecute(nluafunc luaf, uint address, [string name = nil], [string scope = nil])

• Fires immediately before the given address is executed by the core. Your callback can have 3 parameters (addr, val, flags). val is the value to be executed (or 0 always, if this feature is only partially implemented).

• [deprecated] string event.onmemoryexecuteany(nluafunc luaf, [string name = nil], [string scope = nil])

• Fires immediately before every instruction executed (in the specified scope) by the core (CPU-intensive). Your callback can have 3 parameters (addr, val, flags). val is the value to be executed (or 0 always, if this feature is only partially implemented).

• [deprecated] string event.onmemoryread(nluafunc luaf, [uint? address = nil], [string name = nil], [string scope = nil])

• Fires immediately before the given address is read by the core. Your callback can have 3 parameters (addr, val, flags). val is the value read. If no address is given, it will fire on every memory read.

• [deprecated] string event.onmemorywrite(nluafunc luaf, [uint? address = nil], [string name = nil], [string scope = nil])

• Fires immediately before the given address is written by the core. Your callback can have 3 parameters (addr, val, flags). val is the value to be written (or 0 always, if this feature is only partially implemented). If no address is given, it will fire on every memory write.

• string event.onsavestate(nluafunc luaf, [string name = nil])

• Fires after a state is saved. Your callback can have 1 parameter, which will be the name of the saved state.

• bool event.unregisterbyid(string guid)

• Removes the registered function that matches the guid. If a function is found and remove the function will return true. If unable to find a match, the function will return false.

• bool event.unregisterbyname(string name)

• Removes the first registered function that matches Name. If a function is found and remove the function will return true. If unable to find a match, the function will return false.

• void forms.addclick(long handle, nluafunc clickevent)

• adds the given lua function as a click event to the given control

• long forms.button(long formhandle, string caption, nluafunc clickevent, [int? x = nil], [int? y = nil], [int? width = nil], [int? height = nil])

• Creates a button control on the given form. The caption property will be the text value on the button. clickEvent is the name of a Lua function that will be invoked when the button is clicked. x, and y are the optional location parameters for the position of the button within the given form. The function returns the handle of the created button. Width and Height are optional, if not specified they will be a default size

• long forms.checkbox(long formhandle, string caption, [int? x = nil], [int? y = nil])

• Creates a checkbox control on the given form. The caption property will be the text of the checkbox. x and y are the optional location parameters for the position of the checkbox within the form

• void forms.clear(long componenthandle, luacolor color)

• Clears the canvas

• void forms.clearclicks(long handle)

• Removes all click events from the given widget at the specified handle

• void forms.clearImageCache(long componenthandle)

• clears the image cache that is built up by using gui.drawImage, also releases the file handle for cached images

• color forms.createcolor(int r, int g, int b, int a)

• Creates a color object useful with setproperty

• bool forms.destroy(long handle)

• Closes and removes a Lua created form with the specified handle. If a dialog was found and removed true is returned, else false

• void forms.destroyall()

• Closes and removes all Lua created dialogs

• void forms.drawArc(long componenthandle, int x, int y, int width, int height, int startangle, int sweepangle, [luacolor line = nil])

• draws a Arc shape at the given coordinates and the given width and height

• void forms.drawAxis(long componenthandle, int x, int y, int size, [luacolor color = nil])

• Draws an axis of the specified size at the coordinate pair.)

• void forms.drawBezier(long componenthandle, nluatable points, luacolor color)

• Draws a Bezier curve using the table of coordinates provided in the given color

• void forms.drawBox(long componenthandle, int x, int y, int x2, int y2, [luacolor line = nil], [luacolor background = nil])

• Draws a rectangle on screen from x1/y1 to x2/y2. Same as drawRectangle except it receives two points intead of a point and width/height

• void forms.drawEllipse(long componenthandle, int x, int y, int width, int height, [luacolor line = nil], [luacolor background = nil])

• Draws an ellipse at the given coordinates and the given width and height. Line is the color of the ellipse. Background is the optional fill color

• void forms.drawIcon(long componenthandle, string path, int x, int y, [int? width = nil], [int? height = nil])

• draws an Icon (.ico) file from the given path at the given coordinate. width and height are optional. If specified, it will resize the image accordingly

• void forms.drawImage(long componenthandle, string path, int x, int y, [int? width = nil], [int? height = nil], [bool cache = True])

• draws an image file from the given path at the given coordinate. width and height are optional. If specified, it will resize the image accordingly

• void forms.drawImageRegion(long componenthandle, string path, int source_x, int source_y, int source_width, int source_height, int dest_x, int dest_y, [int? dest_width = nil], [int? dest_height = nil])

• Draws a region of the given image file at the given location on the canvas, and optionally resizes it before drawing. Consult this diagram to see its usage (renders embedded on the TASVideos Wiki):

• void forms.drawLine(long componenthandle, int x1, int y1, int x2, int y2, [luacolor color = nil])

• Draws a line from the first coordinate pair to the 2nd. Color is optional (if not specified it will be drawn black)

• void forms.drawPie(long componenthandle, int x, int y, int width, int height, int startangle, int sweepangle, [luacolor line = nil], [luacolor background = nil])

• draws a Pie shape at the given coordinates and the given width and height

• void forms.drawPixel(long componenthandle, int x, int y, [luacolor color = nil])

• Draws a single pixel at the given coordinates in the given color. Color is optional (if not specified it will be drawn black)

• void forms.drawPolygon(long componenthandle, nluatable points, [int? x = nil], [int? y = nil], [luacolor line = nil], [luacolor background = nil])

• Draws a polygon using the table of coordinates specified in points. This should be a table of tables(each of size 2). If x or y is passed, the polygon will be translated by the passed coordinate pair. Line is the color of the polygon. Background is the optional fill color

• void forms.drawRectangle(long componenthandle, int x, int y, int width, int height, [luacolor line = nil], [luacolor background = nil])

• Draws a rectangle at the given coordinate and the given width and height. Line is the color of the box. Background is the optional fill color

• void forms.drawString(long componenthandle, int x, int y, string message, [luacolor forecolor = nil], [luacolor backcolor = nil], [int? fontsize = nil], [string fontfamily = nil], [string fontstyle = nil], [string horizalign = nil], [string vertalign = nil])

• Alias of DrawText()

• void forms.drawText(long componenthandle, int x, int y, string message, [luacolor forecolor = nil], [luacolor backcolor = nil], [int? fontsize = nil], [string fontfamily = nil], [string fontstyle = nil], [string horizalign = nil], [string vertalign = nil])

• Draws the given message at the given x,y coordinates and the given color. The default color is white. A fontfamily can be specified and is monospace generic if none is specified (font family options are the same as the .NET FontFamily class). The fontsize default is 12. The default font style is regular. Font style options are regular, bold, italic, strikethrough, underline. Horizontal alignment options are left (default), center, or right. Vertical alignment options are bottom (default), middle, or top. Alignment options specify which ends of the text will be drawn at the x and y coordinates.

• long forms.dropdown(long formhandle, nluatable items, [int? x = nil], [int? y = nil], [int? width = nil], [int? height = nil])

• Creates a dropdown (with a ComboBoxStyle of DropDownList) control on the given form. Dropdown items are passed via a lua table. Only the values will be pulled for the dropdown items, the keys are irrelevant. Items will be sorted alphabetically. x and y are the optional location parameters, and width and height are the optional size parameters.

• int forms.getMouseX(long componenthandle)

• Returns an integer representation of the mouse X coordinate relative to the PictureBox.

• int forms.getMouseY(long componenthandle)

• Returns an integer representation of the mouse Y coordinate relative to the PictureBox.

• string forms.getproperty(long handle, string property)

• returns a string representation of the value of a property of the widget at the given handle

• string forms.gettext(long handle)

• Returns the text property of a given form or control

• bool forms.ischecked(long handle)

• Returns the given checkbox's checked property

• long forms.label(long formhandle, string caption, [int? x = nil], [int? y = nil], [int? width = nil], [int? height = nil], [bool fixedwidth = False])

• Creates a label control on the given form. The caption property is the text of the label. x, and y are the optional location parameters for the position of the label within the given form. The function returns the handle of the created label. Width and Height are optional, if not specified they will be a default size.

• long forms.newform([int? width = nil], [int? height = nil], [string title = nil], [nluafunc onclose = nil])

• creates a new default dialog, if both width and height are specified it will create a dialog of the specified size. If title is specified it will be the caption of the dialog, else the dialog caption will be 'Lua Dialog'. The function will return an int representing the handle of the dialog created.

• string forms.openfile([string filename = nil], [string initialdirectory = nil], [string filter = nil])

• Creates a standard openfile dialog with optional parameters for the filename, directory, and filter. The return value is the directory that the user picked. If they chose to cancel, it will return an empty string

• long forms.pictureBox(long formhandle, [int? x = nil], [int? y = nil], [int? width = nil], [int? height = nil])

• Creates a new drawing area in the form. Optionally the location in the form as well as the size of the drawing area can be specified. Returns the handle the component can be refered to with.

• void forms.refresh(long componenthandle)

• Redraws the canvas

• void forms.setDefaultBackgroundColor(long componenthandle, luacolor color)

• Sets the default background color to use in drawing methods, transparent by default

• void forms.setDefaultForegroundColor(long componenthandle, luacolor color)

• Sets the default foreground color to use in drawing methods, white by default

• void forms.setDefaultTextBackground(long componenthandle, luacolor color)

• Sets the default backgroiund color to use in text drawing methods, half-transparent black by default

• void forms.setdropdownitems(long handle, nluatable items, [bool alphabetize = True])

• Updates the item list of a dropdown menu. The optional third parameter toggles alphabetical sorting of items, pass false to skip sorting.

• void forms.setlocation(long handle, int x, int y)

• Sets the location of a control or form by passing in the handle of the created object

• void forms.setproperty(long handle, string property, object value)

• Attempts to set the given property of the widget with the given value. Note: not all properties will be able to be represented for the control to accept

• void forms.setsize(long handle, int width, int height)

• TODO

• void forms.settext(long handle, string caption)

• Sets the text property of a control or form by passing in the handle of the created object

• long forms.textbox(long formhandle, [string caption = nil], [int? width = nil], [int? height = nil], [string boxtype = nil], [int? x = nil], [int? y = nil], [bool multiline = False], [bool fixedwidth = False], [string scrollbars = nil])

• Creates a textbox control on the given form. The caption property will be the initial value of the textbox (default is empty). Width and Height are option, if not specified they will be a default size of 100, 20. Type is an optional property to restrict the textbox input. The available options are HEX, SIGNED, and UNSIGNED. Passing it null or any other value will set it to no restriction. x, and y are the optional location parameters for the position of the textbox within the given form. The function returns the handle of the created textbox. If true, the multiline will enable the standard winform multi-line property. If true, the fixedWidth options will create a fixed width font. Scrollbars is an optional property to specify which scrollbars to display. The available options are Vertical, Horizontal, Both, and None. Scrollbars are only shown on a multiline textbox

• string gameinfo.getboardtype()

• returns identifying information about the 'mapper' or similar capability used for this game. empty if no such useful distinction can be drawn

• nluatable gameinfo.getoptions()

• returns the game options for the currently loaded rom. Options vary per platform

• string gameinfo.getromhash()

• returns the hash of the currently loaded rom, if a rom is loaded

• string gameinfo.getromname()

• returns the name of the currently loaded rom, if a rom is loaded

• string gameinfo.getstatus()

• returns the game database status of the currently loaded rom. Statuses are for example: GoodDump, BadDump, Hack, Unknown, NotInDatabase

• bool gameinfo.indatabase()

• returns whether or not the currently loaded rom is in the game database

• bool gameinfo.isstatusbad()

• returns the currently loaded rom's game database status is considered 'bad'

• bool genesis.getlayer_bga()

• Returns whether the bg layer A is displayed

• bool genesis.getlayer_bgb()

• Returns whether the bg layer B is displayed

• bool genesis.getlayer_bgw()

• Returns whether the bg layer W is displayed

• void genesis.setlayer_bga(bool value)

• Sets whether the bg layer A is displayed

• void genesis.setlayer_bgb(bool value)

• Sets whether the bg layer B is displayed

• void genesis.setlayer_bgw(bool value)

• Sets whether the bg layer W is displayed

• void gui.addmessage(string message)

• Adds a message to the OSD's message area

• void gui.clearGraphics([string surfacename = nil])

• clears all lua drawn graphics from the screen

• void gui.clearImageCache()

• clears the image cache that is built up by using gui.drawImage, also releases the file handle for cached images

• void gui.cleartext()

• clears all text created by gui.text()

• nluatable gui.createcanvas(int width, int height, [int? x = nil], [int? y = nil])

• Creates a canvas of the given size and, if specified, the given coordinates.

• void gui.defaultBackground(luacolor color)

• Sets the default background color to use in drawing methods, transparent by default

• void gui.defaultForeground(luacolor color)

• Sets the default foreground color to use in drawing methods, white by default

• void gui.defaultPixelFont(string fontfamily)

• Sets the default font to use in gui.pixelText(). Two font families are available, "fceux" and "gens" (or "0" and "1" respectively), "gens" is used by default

• void gui.defaultTextBackground(luacolor color)

• Sets the default background color to use in text drawing methods, half-transparent black by default

• void gui.drawAxis(int x, int y, int size, [luacolor color = nil], [string surfacename = nil])

• Draws an axis of the specified size at the coordinate pair.)

• void gui.drawBezier(nluatable points, luacolor color, [string surfacename = nil])

• Draws a Bezier curve using the table of coordinates provided in the given color

• void gui.drawBox(int x, int y, int x2, int y2, [luacolor line = nil], [luacolor background = nil], [string surfacename = nil])

• Draws a rectangle on screen from x1/y1 to x2/y2. Same as drawRectangle except it receives two points intead of a point and width/height

• void gui.drawEllipse(int x, int y, int width, int height, [luacolor line = nil], [luacolor background = nil], [string surfacename = nil])

• Draws an ellipse at the given coordinates and the given width and height. Line is the color of the ellipse. Background is the optional fill color

• [deprecated] void gui.DrawFinish()

• Finishes drawing to the current lua surface and causes it to get displayed.

• void gui.drawIcon(string path, int x, int y, [int? width = nil], [int? height = nil], [string surfacename = nil])

• draws an Icon (.ico) file from the given path at the given coordinate. width and height are optional. If specified, it will resize the image accordingly

• void gui.drawImage(string path, int x, int y, [int? width = nil], [int? height = nil], [bool cache = True], [string surfacename = nil])

• draws an image file from the given path at the given coordinate. width and height are optional. If specified, it will resize the image accordingly

• void gui.drawImageRegion(string path, int source_x, int source_y, int source_width, int source_height, int dest_x, int dest_y, [int? dest_width = nil], [int? dest_height = nil], [string surfacename = nil])

• draws a given region of an image file from the given path at the given coordinate, and optionally with the given size

• void gui.drawLine(int x1, int y1, int x2, int y2, [luacolor color = nil], [string surfacename = nil])

• Draws a line from the first coordinate pair to the 2nd. Color is optional (if not specified it will be drawn black)

• [deprecated] void gui.DrawNew(string name, [bool? clear = True])

• Changes drawing target to the specified lua surface name. This may clobber any previous drawing to this surface (pass false if you don't want it to)

• void gui.drawPie(int x, int y, int width, int height, int startangle, int sweepangle, [luacolor line = nil], [luacolor background = nil], [string surfacename = nil])

• draws a Pie shape at the given coordinates and the given width and height

• void gui.drawPixel(int x, int y, [luacolor color = nil], [string surfacename = nil])

• Draws a single pixel at the given coordinates in the given color. Color is optional (if not specified it will be drawn black)

• void gui.drawPolygon(nluatable points, [int? offsetx = nil], [int? offsety = nil], [luacolor line = nil], [luacolor background = nil], [string surfacename = nil])

• Draws a polygon using the table of coordinates specified in points. This should be a table of tables(each of size 2). If x or y is passed, the polygon will be translated by the passed coordinate pair. Line is the color of the polygon. Background is the optional fill color

• void gui.drawRectangle(int x, int y, int width, int height, [luacolor line = nil], [luacolor background = nil], [string surfacename = nil])

• Draws a rectangle at the given coordinate and the given width and height. Line is the color of the box. Background is the optional fill color

• void gui.drawString(int x, int y, string message, [luacolor forecolor = nil], [luacolor backcolor = nil], [int? fontsize = nil], [string fontfamily = nil], [string fontstyle = nil], [string horizalign = nil], [string vertalign = nil], [string surfacename = nil])

• Draws the given message in the emulator screen space (like all draw functions) at the given x,y coordinates and the given color. The default color is white. A fontfamily can be specified and is monospace generic if none is specified (font family options are the same as the .NET FontFamily class). The fontsize default is 12. The default font style is regular. Font style options are regular, bold, italic, strikethrough, underline. Horizontal alignment options are left (default), center, or right. Vertical alignment options are bottom (default), middle, or top. Alignment options specify which ends of the text will be drawn at the x and y coordinates. For pixel-perfect font look, make sure to disable aspect ratio correction.

• void gui.drawText(int x, int y, string message, [luacolor forecolor = nil], [luacolor backcolor = nil], [int? fontsize = nil], [string fontfamily = nil], [string fontstyle = nil], [string horizalign = nil], [string vertalign = nil], [string surfacename = nil])

• alias for gui.drawString

• void gui.pixelText(int x, int y, string message, [luacolor forecolor = nil], [luacolor backcolor = nil], [string fontfamily = nil], [string surfacename = nil])

• Draws the given message in the emulator screen space (like all draw functions) at the given x,y coordinates and the given color. The default color is white. Two font families are available, "fceux" and "gens" (or "0" and "1" respectively), both are monospace and have the same size as in the emulators they've been taken from. If no font family is specified, it uses "gens" font, unless that's overridden via gui.defaultPixelFont()

• void gui.text(int x, int y, string message, [luacolor forecolor = nil], [string anchor = nil])

• Displays the given text on the screen at the given coordinates. Optional Foreground color. The optional anchor flag anchors the text to one of the four corners. Anchor flag parameters: topleft, topright, bottomleft, bottomright

• void gui.use_surface(string surfacename)

• Stores the name of a surface to draw on, so you don't need to pass it to every draw function. The default is "emucore", and the other valid value is "client".

• nluatable input.get()

• Returns a lua table of all the buttons the user is currently pressing on their keyboard and gamepads

• nluatable input.getmouse()

• Returns a lua table of the mouse X/Y coordinates and button states. Table keys are X, Y, Left, Middle, Right, XButton1, XButton2, Wheel.

• nluatable joypad.get([int? controller = nil])

• returns a lua table of the controller buttons pressed. If supplied, it will only return a table of buttons for the given controller

• nluatable joypad.getimmediate([int? controller = nil])

• returns a lua table of any controller buttons currently pressed by the user

• nluatable joypad.getwithmovie([int? controller = nil])

• returns a lua table of the controller buttons pressed, including ones pressed by the current movie. If supplied, it will only return a table of buttons for the given controller

• void joypad.set(nluatable buttons, [int? controller = nil])

• sets the given buttons to their provided values for the current frame

• void joypad.setanalog(nluatable controls, [int? controller = nil])

• sets the given analog controls to their provided values for the current frame. Note that unlike set() there is only the logic of overriding with the given value.

• void joypad.setfrommnemonicstr(string inputlogentry)

• sets the given buttons to their provided values for the current frame, string will be interpreted the same way an entry from a movie input log would be

• void LuaCanvas.Clear(luacolor color)

• Clears the canvas

• void LuaCanvas.ClearImageCache()

• clears the image cache that is built up by using gui.drawImage, also releases the file handle for cached images

• void LuaCanvas.DrawArc(int x, int y, int width, int height, int startangle, int sweepangle, [luacolor line = nil])

• draws a Arc shape at the given coordinates and the given width and height

• void LuaCanvas.DrawAxis(int x, int y, int size, [luacolor color = nil])

• Draws an axis of the specified size at the coordinate pair.)

• void LuaCanvas.DrawBezier(nluatable points, luacolor color)

• Draws a Bezier curve using the table of coordinates provided in the given color

• void LuaCanvas.DrawBox(int x, int y, int x2, int y2, [luacolor line = nil], [luacolor background = nil])

• Draws a rectangle on screen from x1/y1 to x2/y2. Same as drawRectangle except it receives two points intead of a point and width/height

• void LuaCanvas.DrawEllipse(int x, int y, int width, int height, [luacolor line = nil], [luacolor background = nil])

• Draws an ellipse at the given coordinates and the given width and height. Line is the color of the ellipse. Background is the optional fill color

• void LuaCanvas.DrawIcon(string path, int x, int y, [int? width = nil], [int? height = nil])

• draws an Icon (.ico) file from the given path at the given coordinate. width and height are optional. If specified, it will resize the image accordingly

• void LuaCanvas.DrawImage(string path, int x, int y, [int? width = nil], [int? height = nil], [bool cache = True])

• draws an image file from the given path at the given coordinate. width and height are optional. If specified, it will resize the image accordingly

• void LuaCanvas.DrawImageRegion(string path, int sourcex, int sourcey, int sourcewidth, int sourceheight, int destx, int desty, [int? destwidth = nil], [int? destheight = nil])

• draws a given region of an image file from the given path at the given coordinate, and optionally with the given size

• void LuaCanvas.DrawLine(int x1, int y1, int x2, int y2, [luacolor color = nil])

• Draws a line from the first coordinate pair to the 2nd. Color is optional (if not specified it will be drawn black)

• void LuaCanvas.DrawPie(int x, int y, int width, int height, int startangle, int sweepangle, [luacolor line = nil], [luacolor background = nil])

• draws a Pie shape at the given coordinates and the given width and height

• void LuaCanvas.DrawPixel(int x, int y, [luacolor color = nil])

• Draws a single pixel at the given coordinates in the given color. Color is optional (if not specified it will be drawn black)

• void LuaCanvas.DrawPolygon(nluatable points, [int? x = nil], [int? y = nil], [luacolor line = nil], [luacolor background = nil])

• Draws a polygon using the table of coordinates specified in points. This should be a table of tables(each of size 2). Line is the color of the polygon. Background is the optional fill color

• void LuaCanvas.DrawRectangle(int x, int y, int width, int height, [luacolor line = nil], [luacolor background = nil])

• Draws a rectangle at the given coordinate and the given width and height. Line is the color of the box. Background is the optional fill color

• void LuaCanvas.DrawString(int x, int y, string message, [luacolor forecolor = nil], [luacolor backcolor = nil], [int? fontsize = nil], [string fontfamily = nil], [string fontstyle = nil], [string horizontalalign = nil], [string verticalalign = nil])

• Alias of DrawText()

• void LuaCanvas.DrawText(int x, int y, string message, [luacolor forecolor = nil], [luacolor backcolor = nil], [int? fontsize = nil], [string fontfamily = nil], [string fontstyle = nil], [string horizontalalign = nil], [string verticalalign = nil])

• Draws the given message at the given x,y coordinates and the given color. The default color is white. A fontfamily can be specified and is monospace generic if none is specified (font family options are the same as the .NET FontFamily class). The fontsize default is 12. The default font style is regular. Font style options are regular, bold, italic, strikethrough, underline. Horizontal alignment options are left (default), center, or right. Vertical alignment options are bottom (default), middle, or top. Alignment options specify which ends of the text will be drawn at the x and y coordinates.

• int LuaCanvas.GetMouseX()

• Returns an integer representation of the mouse X coordinate relative to the canvas window.

• int LuaCanvas.GetMouseY()

• Returns an integer representation of the mouse Y coordinate relative to the canvas window.

• void LuaCanvas.Refresh()

• Redraws the canvas

• void LuaCanvas.save_image_to_disk(string path)

• Saves everything that's been drawn to a .png file at the given path. Relative paths are relative to the path set for "Screenshots" for the current system.

• void LuaCanvas.SetDefaultBackgroundColor(luacolor color)

• Sets the default background color to use in drawing methods, transparent by default

• void LuaCanvas.SetDefaultForegroundColor(luacolor color)

• Sets the default foreground color to use in drawing methods, white by default

• void LuaCanvas.SetDefaultTextBackground(luacolor color)

• Sets the default background color to use in text drawing methods, half-transparent black by default

• void LuaCanvas.SetLocation(int x, int y)

• Sets the location of the canvas window

• void LuaCanvas.SetTitle(string title)

• Sets the canvas window title

• uint mainmemory.getcurrentmemorydomainsize()

• Returns the number of bytes of the domain defined as main memory

• string mainmemory.getname()

• returns the name of the domain defined as main memory for the given core

• nluatable mainmemory.read_bytes_as_array(long addr, int length)

• Reads length bytes starting at addr into an array-like table (1-indexed).

• nluatable mainmemory.read_bytes_as_dict(long addr, int length)

• Reads length bytes starting at addr into a dict-like table (where the keys are the addresses, relative to the start of the main memory).

• int mainmemory.read_s16_be(long addr)

• read signed 2 byte value, big endian

• int mainmemory.read_s16_le(long addr)

• read signed 2 byte value, little endian

• int mainmemory.read_s24_be(long addr)

• read signed 24 bit value, big endian

• int mainmemory.read_s24_le(long addr)

• read signed 24 bit value, little endian

• int mainmemory.read_s32_be(long addr)

• read signed 4 byte value, big endian

• int mainmemory.read_s32_le(long addr)

• read signed 4 byte value, little endian

• int mainmemory.read_s8(long addr)

• read signed byte

• uint mainmemory.read_u16_be(long addr)

• read unsigned 2 byte value, big endian

• uint mainmemory.read_u16_le(long addr)

• read unsigned 2 byte value, little endian

• uint mainmemory.read_u24_be(long addr)

• read unsigned 24 bit value, big endian

• uint mainmemory.read_u24_le(long addr)

• read unsigned 24 bit value, little endian

• uint mainmemory.read_u32_be(long addr)

• read unsigned 4 byte value, big endian

• uint mainmemory.read_u32_le(long addr)

• read unsigned 4 byte value, little endian

• uint mainmemory.read_u8(long addr)

• read unsigned byte

• uint mainmemory.readbyte(long addr)

• gets the value from the given address as an unsigned byte

• [deprecated] nluatable mainmemory.readbyterange(long addr, int length)

• Reads the address range that starts from address, and is length long. Returns a zero-indexed table containing the read values (an array of bytes.)

• single mainmemory.readfloat(long addr, bool bigendian)

• Reads the given address as a 32-bit float value from the main memory domain with th e given endian

• void mainmemory.write_bytes_as_array(long addr, nluatable bytes)

• Writes sequential bytes starting at addr.

• void mainmemory.write_bytes_as_dict(nluatable addrmap)

• Writes bytes at arbitrary addresses (the keys of the given table are the addresses, relative to the start of the main memory).

• void mainmemory.write_s16_be(long addr, int value)

• write signed 2 byte value, big endian

• void mainmemory.write_s16_le(long addr, int value)

• write signed 2 byte value, little endian

• void mainmemory.write_s24_be(long addr, int value)

• write signed 24 bit value, big endian

• void mainmemory.write_s24_le(long addr, int value)

• write signed 24 bit value, little endian

• void mainmemory.write_s32_be(long addr, int value)

• write signed 4 byte value, big endian

• void mainmemory.write_s32_le(long addr, int value)

• write signed 4 byte value, little endian

• void mainmemory.write_s8(long addr, uint value)

• write signed byte

• void mainmemory.write_u16_be(long addr, uint value)

• write unsigned 2 byte value, big endian

• void mainmemory.write_u16_le(long addr, uint value)

• write unsigned 2 byte value, little endian

• void mainmemory.write_u24_be(long addr, uint value)

• write unsigned 24 bit value, big endian

• void mainmemory.write_u24_le(long addr, uint value)

• write unsigned 24 bit value, little endian

• void mainmemory.write_u32_be(long addr, uint value)

• write unsigned 4 byte value, big endian

• void mainmemory.write_u32_le(long addr, uint value)

• write unsigned 4 byte value, little endian

• void mainmemory.write_u8(long addr, uint value)

• write unsigned byte

• void mainmemory.writebyte(long addr, uint value)

• Writes the given value to the given address as an unsigned byte

• [deprecated] void mainmemory.writebyterange(nluatable memoryblock)

• Writes the given values to the given addresses as unsigned bytes

• void mainmemory.writefloat(long addr, double value, bool bigendian)

• Writes the given 32-bit float value to the given address and endian

• string memory.getcurrentmemorydomain()

• Returns a string name of the current memory domain selected by Lua. The default is Main memory

• uint memory.getcurrentmemorydomainsize()

• Returns the number of bytes of the current memory domain selected by Lua. The default is Main memory

• nluatable memory.getmemorydomainlist()

• Returns a string of the memory domains for the loaded platform core. List will be a single string delimited by line feeds

• uint memory.getmemorydomainsize([string name = ])

• Returns the number of bytes of the specified memory domain. If no domain is specified, or the specified domain doesn't exist, returns the current domain size

• string memory.hash_region(long addr, int count, [string domain = nil])

• Returns a hash as a string of a region of memory, starting from addr, through count bytes. If the domain is unspecified, it uses the current region.

• nluatable memory.read_bytes_as_array(long addr, int length, [string domain = nil])

• Reads length bytes starting at addr into an array-like table (1-indexed).

• nluatable memory.read_bytes_as_dict(long addr, int length, [string domain = nil])

• Reads length bytes starting at addr into a dict-like table (where the keys are the addresses, relative to the start of the domain).

• int memory.read_s16_be(long addr, [string domain = nil])

• read signed 2 byte value, big endian

• int memory.read_s16_le(long addr, [string domain = nil])

• read signed 2 byte value, little endian

• int memory.read_s24_be(long addr, [string domain = nil])

• read signed 24 bit value, big endian

• int memory.read_s24_le(long addr, [string domain = nil])

• read signed 24 bit value, little endian

• int memory.read_s32_be(long addr, [string domain = nil])

• read signed 4 byte value, big endian

• int memory.read_s32_le(long addr, [string domain = nil])

• read signed 4 byte value, little endian

• int memory.read_s8(long addr, [string domain = nil])

• read signed byte

• uint memory.read_u16_be(long addr, [string domain = nil])

• read unsigned 2 byte value, big endian

• uint memory.read_u16_le(long addr, [string domain = nil])

• read unsigned 2 byte value, little endian

• uint memory.read_u24_be(long addr, [string domain = nil])

• read unsigned 24 bit value, big endian

• uint memory.read_u24_le(long addr, [string domain = nil])

• read unsigned 24 bit value, little endian

• uint memory.read_u32_be(long addr, [string domain = nil])

• read unsigned 4 byte value, big endian

• uint memory.read_u32_le(long addr, [string domain = nil])

• read unsigned 4 byte value, little endian

• uint memory.read_u8(long addr, [string domain = nil])

• read unsigned byte

• uint memory.readbyte(long addr, [string domain = nil])

• gets the value from the given address as an unsigned byte

• [deprecated] nluatable memory.readbyterange(long addr, int length, [string domain = nil])

• Reads the address range that starts from address, and is length long. Returns a zero-indexed table containing the read values (an array of bytes.)

• single memory.readfloat(long addr, bool bigendian, [string domain = nil])

• Reads the given address as a 32-bit float value from the main memory domain with th e given endian

• bool memory.usememorydomain(string domain)

• Attempts to set the current memory domain to the given domain. If the name does not match a valid memory domain, the function returns false, else it returns true

• void memory.write_bytes_as_array(long addr, nluatable bytes, [string domain = nil])

• Writes sequential bytes starting at addr.

• void memory.write_bytes_as_dict(nluatable addrmap, [string domain = nil])

• Writes bytes at arbitrary addresses (the keys of the given table are the addresses, relative to the start of the domain).

• void memory.write_s16_be(long addr, int value, [string domain = nil])

• write signed 2 byte value, big endian

• void memory.write_s16_le(long addr, int value, [string domain = nil])

• write signed 2 byte value, little endian

• void memory.write_s24_be(long addr, int value, [string domain = nil])

• write signed 24 bit value, big endian

• void memory.write_s24_le(long addr, int value, [string domain = nil])

• write signed 24 bit value, little endian

• void memory.write_s32_be(long addr, int value, [string domain = nil])

• write signed 4 byte value, big endian

• void memory.write_s32_le(long addr, int value, [string domain = nil])

• write signed 4 byte value, little endian

• void memory.write_s8(long addr, uint value, [string domain = nil])

• write signed byte

• void memory.write_u16_be(long addr, uint value, [string domain = nil])

• write unsigned 2 byte value, big endian

• void memory.write_u16_le(long addr, uint value, [string domain = nil])

• write unsigned 2 byte value, little endian

• void memory.write_u24_be(long addr, uint value, [string domain = nil])

• write unsigned 24 bit value, big endian

• void memory.write_u24_le(long addr, uint value, [string domain = nil])

• write unsigned 24 bit value, little endian

• void memory.write_u32_be(long addr, uint value, [string domain = nil])

• write unsigned 4 byte value, big endian

• void memory.write_u32_le(long addr, uint value, [string domain = nil])

• write unsigned 4 byte value, little endian

• void memory.write_u8(long addr, uint value, [string domain = nil])

• write unsigned byte

• void memory.writebyte(long addr, uint value, [string domain = nil])

• Writes the given value to the given address as an unsigned byte

• [deprecated] void memory.writebyterange(nluatable memoryblock, [string domain = nil])

• Writes the given values to the given addresses as unsigned bytes

• void memory.writefloat(long addr, double value, bool bigendian, [string domain = nil])

• Writes the given 32-bit float value to the given address and endian

• void memorysavestate.clearstatesfrommemory()

• clears all savestates stored in memory

• void memorysavestate.loadcorestate(string identifier)

• loads an in memory state with the given identifier

• void memorysavestate.removestate(string identifier)

• removes the savestate with the given identifier from memory

• string memorysavestate.savecorestate()

• creates a core savestate and stores it in memory. Note: a core savestate is only the raw data from the core, and not extras such as movie input logs, or framebuffers. Returns a unique identifer for the savestate

• string movie.filename()

• Returns the file name including path of the currently loaded movie

• nluatable movie.getcomments()

• If a movie is active, will return the movie comments as a lua table

• double movie.getfps()

• If a movie is loaded, gets the frames per second used by the movie to determine the movie length time

• nluatable movie.getheader()

• If a movie is active, will return the movie header as a lua table

• nluatable movie.getinput(int frame, [int? controller = nil])

• Returns a table of buttons pressed on a given frame of the loaded movie

• string movie.getinputasmnemonic(int frame)

• Returns the input of a given frame of the loaded movie in a raw inputlog string

• bool movie.getreadonly()

• Returns true if the movie is in read-only mode, false if in read+write

• ulong movie.getrerecordcount()

• Gets the rerecord count of the current movie.

• bool movie.getrerecordcounting()

• Returns whether or not the current movie is incrementing rerecords on loadstate

• nluatable movie.getsubtitles()

• If a movie is active, will return the movie subtitles as a lua table

• bool movie.isloaded()

• Returns true if a movie is loaded in memory (play, record, or finished modes), false if not (inactive mode)

• int movie.length()

• Returns the total number of frames of the loaded movie

• string movie.mode()

• Returns the mode of the current movie. Possible modes: "PLAY", "RECORD", "FINISHED", "INACTIVE"

• bool movie.play_from_start([string path = ])

• Resets the core to frame 0 with the currently loaded movie in playback mode. If a path to a movie is specified, attempts to load it, then continues with playback if it was successful. Returns true iff successful.

• void movie.save([string filename = ])

• Saves the current movie to the disc. If the filename is provided (no extension or path needed), the movie is saved under the specified name to the current movie directory. The filename may contain a subdirectory, it will be created if it doesn't exist. Existing files won't get overwritten.

• void movie.setreadonly(bool readonly)

• Sets the read-only state to the given value. true for read only, false for read+write

• void movie.setrerecordcount(ulong count)

• Sets the rerecord count of the current movie.

• void movie.setrerecordcounting(bool counting)

• Sets whether or not the current movie will increment the rerecord counter on loadstate

• bool movie.startsfromsaveram()

• Returns whether or not the movie is a saveram-anchored movie

• bool movie.startsfromsavestate()

• Returns whether or not the movie is a savestate-anchored movie

• void movie.stop([bool savechanges = True])

• Stops the current movie. Pass false to discard changes.

• string nds.getaudiobitrate()

• Returns the audio bitrate setting

• int nds.getscreengap()

• Returns the gap between the screens

• bool nds.getscreeninvert()

• Returns whether screens are inverted

• string nds.getscreenlayout()

• Returns which screen layout is active

• string nds.getscreenrotation()

• Returns how screens are rotated

• void nds.setaudiobitrate(string value)

• Sets the audio bitrate setting

• void nds.setscreengap(int value)

• Sets the gap between the screens

• void nds.setscreeninvert(bool value)

• Sets whether screens are inverted

• void nds.setscreenlayout(string value)

• Sets which screen layout is active

• void nds.setscreenrotation(string value)

• Sets how screens are rotated

• bool nes.getallowmorethaneightsprites()

• Gets the NES setting 'Allow more than 8 sprites per scanline' value

• int nes.getbottomscanline([bool pal = False])

• Gets the current value for the bottom scanline value

• bool nes.getclipleftandright()

• Gets the current value for the Clip Left and Right sides option

• bool nes.getdispbackground()

• Indicates whether or not the bg layer is being displayed

• bool nes.getdispsprites()

• Indicates whether or not sprites are being displayed

• int nes.gettopscanline([bool pal = False])

• Gets the current value for the top scanline value

• void nes.setallowmorethaneightsprites(bool allow)

• Sets the NES setting 'Allow more than 8 sprites per scanline'

• void nes.setclipleftandright(bool leftandright)

• Sets the Clip Left and Right sides option

• void nes.setdispbackground(bool show)

• Sets whether or not the background layer will be displayed

• void nes.setdispsprites(bool show)

• Sets whether or not sprites will be displayed

• void nes.setscanlines(int top, int bottom, [bool pal = False])

• sets the top and bottom scanlines to be drawn (same values as in the graphics options dialog). Top must be in the range of 0 to 127, bottom must be between 128 and 239. Not supported in the Quick Nes core

• bool savestate.load(string path, [bool suppressosd = False])

• Loads a savestate with the given path. Returns true iff succeeded. If EmuHawk is deferring quicksaves, to TAStudio for example, that form will do what it likes (and the path is ignored).

• bool savestate.loadslot(int slotnum, [bool suppressosd = False])

• Loads the savestate at the given slot number (must be an integer between 1 and 10). Returns true iff succeeded. If EmuHawk is deferring quicksaves, to TAStudio for example, that form will do what it likes with the slot number.

• void savestate.save(string path, [bool suppressosd = False])

• Saves a state at the given path. If EmuHawk is deferring quicksaves, to TAStudio for example, that form will do what it likes (and the path is ignored).

• void savestate.saveslot(int slotnum, [bool suppressosd = False])

• Saves a state at the given save slot (must be an integer between 1 and 10). If EmuHawk is deferring quicksaves, to TAStudio for example, that form will do what it likes with the slot number.

• bool snes.getlayer_bg_1()

• Returns whether the bg 1 layer is displayed

• bool snes.getlayer_bg_2()

• Returns whether the bg 2 layer is displayed

• bool snes.getlayer_bg_3()

• Returns whether the bg 3 layer is displayed

• bool snes.getlayer_bg_4()

• Returns whether the bg 4 layer is displayed

• bool snes.getlayer_obj_1()

• Returns whether the obj 1 layer is displayed

• bool snes.getlayer_obj_2()

• Returns whether the obj 2 layer is displayed

• bool snes.getlayer_obj_3()

• Returns whether the obj 3 layer is displayed

• bool snes.getlayer_obj_4()

• Returns whether the obj 4 layer is displayed

• void snes.setlayer_bg_1(bool value)

• Sets whether the bg 1 layer is displayed

• void snes.setlayer_bg_2(bool value)

• Sets whether the bg 2 layer is displayed

• void snes.setlayer_bg_3(bool value)

• Sets whether the bg 3 layer is displayed

• void snes.setlayer_bg_4(bool value)

• Sets whether the bg 4 layer is displayed

• void snes.setlayer_obj_1(bool value)

• Sets whether the obj 1 layer is displayed

• void snes.setlayer_obj_2(bool value)

• Sets whether the obj 2 layer is displayed

• void snes.setlayer_obj_3(bool value)

• Sets whether the obj 3 layer is displayed

• void snes.setlayer_obj_4(bool value)

• Sets whether the obj 4 layer is displayed

• string SQL.createdatabase(string name)

• Creates a SQLite Database. Name should end with .db

• string SQL.opendatabase(string name)

• Opens a SQLite database. Name should end with .db

• object SQL.readcommand([string query = ])

• Run a SQLite read command which includes Select. Returns all rows into a LuaTable.Ex: select * from rewards

• string SQL.writecommand([string query = ])

• Runs a SQLite write command which includes CREATE,INSERT, UPDATE. Ex: create TABLE rewards (ID integer PRIMARY KEY, action VARCHAR(20))

• void tastudio.addcolumn(string name, string text, int width)

• void tastudio.applyinputchanges()

• void tastudio.clearIconCache()

• Clears the cache that is built up by using tastudio.onqueryitemicon, so that changes to the icons on disk can be picked up.

• void tastudio.clearinputchanges()

• bool tastudio.engaged()

• returns whether or not tastudio is currently engaged (active)

• nluatable tastudio.getbranches()

• Returns a list of the current tastudio branches. Each entry will have the Id, Frame, and Text properties of the branch

• nluatable tastudio.getbranchinput(string branchid, int frame)

• Gets the controller state of the given frame with the given branch identifier

• string tastudio.getmarker(int frame)

• returns the marker text at the given frame, or an empty string if there is no marker for the given frame

• bool tastudio.getrecording()

• returns whether or not TAStudio is in recording mode

• nluatable tastudio.getselection()

• gets the currently selected frames

• bool tastudio.hasstate(int frame)

• Returns whether or not the given frame has a savestate associated with it

• bool? tastudio.islag(int frame)

• Returns whether or not the given frame was a lag frame, null if unknown

• void tastudio.loadbranch(int index)

• Loads a branch at the given index, if a branch at that index exists.

• void tastudio.onbranchload(nluafunc luaf)

• called whenever a branch is loaded. luaf must be a function that takes the integer branch index as a parameter

• void tastudio.onbranchremove(nluafunc luaf)

• called whenever a branch is removed. luaf must be a function that takes the integer branch index as a parameter

• void tastudio.onbranchsave(nluafunc luaf)

• called whenever a branch is created or updated. luaf must be a function that takes the integer branch index as a parameter

• void tastudio.ongreenzoneinvalidated(nluafunc luaf)

• Called whenever the greenzone is invalidated. Your callback can have 1 parameter, which will be the index of the first row that was invalidated.

• void tastudio.onqueryitembg(nluafunc luaf)

• called during the background draw event of the tastudio listview. luaf must be a function that takes 2 params: index, column. The first is the integer row index of the listview, and the 2nd is the string column name. luaf should return a value that can be parsed into a .NET Color object (string color name, or integer value)

• void tastudio.onqueryitemicon(nluafunc luaf)

• Called during the icon draw event of the tastudio listview. luaf must be a function that takes 2 params: (index, column). The first is the integer row index of the listview, and the 2nd is the string column name. The callback should return a string, the path to the .ico file to be displayed. The file will be cached, so if you change the file on disk, call tastudio.clearIconCache().

• void tastudio.onqueryitemtext(nluafunc luaf)

• Called during the text draw event of the tastudio listview. luaf must be a function that takes 2 params: (index, column). The first is the integer row index of the listview, and the 2nd is the string column name. The callback should return a string to be displayed.

• void tastudio.removemarker(int frame)

• if there is a marker for the given frame, it will be removed

• void tastudio.setbranchtext(string text, [int? index = nil])

• adds the given message to the existing branch, or to the branch that will be created next if branch index is not specified

• void tastudio.setlag(int frame, bool? value)

• Sets the lag information for the given frame, if the frame does not exist in the lag log, it will be added. If the value is null, the lag information for that frame will be removed

• void tastudio.setmarker(int frame, [string message = nil])

• Adds or sets a marker at the given frame, with an optional message

• void tastudio.setplayback(object frame)

• Seeks the given frame (a number) or marker (a string)

• void tastudio.setrecording(bool val)

• sets the recording mode on/off depending on the parameter

• void tastudio.submitanalogchange(int frame, string button, singlevalue)

• void tastudio.submitclearframes(int frame, int number)

• void tastudio.submitdeleteframes(int frame, int number)

• void tastudio.submitinputchange(int frame, string button, bool value)

• void tastudio.submitinsertframes(int frame, int number)

• void tastudio.togglerecording()

• toggles tastudio recording mode on/off depending on its current state

• void userdata.clear()

• clears all user data

• bool userdata.containskey(string key)

• returns whether or not there is an entry for the given key

• object userdata.get(string key)

• gets the data with the given key, if the key does not exist it will return nil

• nluatable userdata.get_keys()

• returns a list-like table of valid keys

• bool userdata.remove(string key)

• remove the data with the given key. Returns true if the element is successfully found and removed; otherwise, false.

• void userdata.set(string name, object value)

• adds or updates the data with the given key with the given value