fix: add additional checking

lua/CC Tweaked/tutel/tutel-client.lua

@@ -162,27 +162,38 @@ end
 declareCommandHandler("ABORT", handleAbort)
 
 --[[
-    main
+    event handling
 ]]
-function pollAndProcessMessages()
+local eventListeners = {}
-    local eventType, side, channel, replyChannel, message, dist = os.pullEvent("modem_message")
+local function registerEventListener(name, listener)
+    if not eventListeners[name] then eventListeners[name] = {} end
+    table.insert(eventListeners[name], listener)
+end
 
-    -- ignore messages not from host, HOST_CHANNEL and REPLY_CHANNEL will get assigned after receiving SCAN on channel 0
+local function dispatchEvents(event, ...)
+    local eventTbl = eventListeners[event]
+    if not eventTbl then return end
+
+    for i = 1, #eventTbl, 1 do
+        eventTbl[i](...)
+    end
+end
+local function handleMessages(side, channel, replyChannel, message, dist)
     if TURTLE_CHANNEL and channel ~= TURTLE_CHANNEL then return end
 
-    -- message validation
+    -- msg validation
     if type(message) ~= "table" then return end
     if not message.header or message.header ~= MSG_HEADER then return end
     if not message.data then message.data = {} end
 
-    -- command validation
+    -- cmd validation
     if not message.name then
-        log.warning("received nameless message")
+        log.warning("received nameless command?")
         return
     end
 
     if not commands[message.name] then
-        log.error("unhandled message (%s)", message.name)
+        log.error("unhandled command (%s)", message.name)
         return
     end
 
@@ -194,14 +205,33 @@ function pollAndProcessMessages()
         end
     end
 
-    cmd.handler(message.data)
+    -- cmd execution
+    local success, err = pcall(cmd.handler, message.data, message.id)
+    if not success then
+        log.error("error occurred while executing command %s: %s", message.name, err)
+        return
+    end
 
-    -- message handling
     log.info("processed command (%s)", message.name)
 end
+registerEventListener("modem_message", handleMessages)
 
-log.general("tutel client init")
+--[[
+    event polling
+]]
+function pollEvents()
+    local eventData = { os.pullEvent() }
 
+    local eventName = eventData[1]
+    table.remove(eventData, 1)
+
+    dispatchEvents(eventName, table.unpack(eventData))
+end
+
+--[[
+    main loop
+]]
+log.info("init")
 while true do
-    pollAndProcessMessages()
+    pollEvents()
 end

lua/CC Tweaked/tutel/tutel-host.lua

@@ -10,7 +10,15 @@
 ]]
 
 --[[
-    network variables
+    TO-DO List:
+        * Add argument / funcion type checks on callback styled register functions
+        * Make log screen scrolling work based on drawn lines not log indexes
+        * Rename network commands to messages, to avoid confusion with console commands
+        * Periodically check if turtle connections are valid
+]]
+
+--[[
+    general variables
 ]]
 local HOST_CHANNEL = 1337
 local TURTLE_CHANNEL_BASE = 1338
@@ -20,6 +28,59 @@ local MSG_HEADER = 0x747574656C
 local modem = peripheral.find("modem") or error("No modems found", 0)
 modem.open(HOST_CHANNEL)
 
+local monitor = peripheral.find("monitor")
+local scr = monitor or term
+
+local shouldRun = true
+
+--[[
+    helper functions
+]]
+function wrapText(text, maxWidth)
+    if not text then return {} end
+    if maxWidth <= 0 then return { text } end
+
+    local lines = {}
+    local currentLine = ""
+
+    for word, newline in text:gmatch("([^%s\n]*)(%s*\n?)") do
+        if newline:find("\n") then
+            if currentLine ~= "" then
+                table.insert(lines, currentLine)
+                currentLine = ""
+            end
+            if word ~= "" then
+                table.insert(lines, word)
+            else
+                table.insert(lines, "")
+            end
+        elseif #currentLine + #word <= maxWidth then
+            if currentLine == "" then
+                currentLine = word
+            else
+                currentLine = currentLine .. " " .. word
+            end
+        else
+            if currentLine ~= "" then
+                table.insert(lines, currentLine)
+                currentLine = word
+            else
+                while #word > maxWidth do
+                    table.insert(lines, word:sub(1, maxWidth))
+                    word = word:sub(maxWidth + 1)
+                end
+                currentLine = word
+            end
+        end
+    end
+
+    if currentLine ~= "" then
+        table.insert(lines, currentLine)
+    end
+
+    return lines
+end
+
 --[[
     logging
 ]]
@@ -110,7 +171,7 @@ end
 function handleScan(keys, id)
     local turt = registerTurtle({ keys.positionX, keys.positionY, keys.positionZ }, keys.fuel, id)
 
-    log.info("Received turtle info (pos: %d, %d, %d - fuel: %d - channel: %d - id: %d)", turt.position[1],
+    log.info("Received turtle info (pos: %d, %d, %d | fuel: %d | channel: %d | id: %d)", turt.position[1],
         turt.position[2], turt.position[3], turt.fuel, turt.channel, id)
 
     sendToAll("REGISTER", { ["id"] = id, ["turtleChannel"] = turt.channel })
@@ -152,19 +213,19 @@ function handleMessages(side, channel, replyChannel, message, dist)
 
     -- cmd validation
     if not message.name then
-        log.warning("received nameless command?")
+        log.warning("Received nameless command?")
         return
     end
 
     if not commands[message.name] then
-        log.error("unhandled command (%s)", message.name)
+        log.error("Unhandled command (%s)", message.name)
         return
     end
 
     local cmd = commands[message.name]
     for i, v in pairs(cmd.keys) do
         if type(message.data[i]) ~= v and v ~= "optional" then
-            log.error("command %s requires key %s of type %s (was %s)", message.name, i, v, type(message[i]))
+            log.error("Command %s requires key %s of type %s (was %s)", message.name, i, v, type(message[i]))
             return
         end
     end
@@ -172,125 +233,300 @@ function handleMessages(side, channel, replyChannel, message, dist)
     -- cmd execution
     local success, err = pcall(cmd.handler, message.data, message.id)
     if not success then
-        log.error("error occurred while executing command %s: %s", message.name, err)
+        log.error("Error occurred while executing command %s: %s", message.name, err)
     end
 
-    log.info("processed command (%s)", message.name)
+    log.info("Processed command (%s)", message.name)
 end
+
 registerEventListener("modem_message", handleMessages)
 
-local logOffset = 0
-
--- to-do: add key handlers
-
 --[[
     key handling
 ]]
-local keyListeners = {}
+local GLFW_KEY_DOWN      = 264
-function registerKeyListener(id, listener)
+local GLFW_KEY_UP        = 265
-    if not keyListeners[id] then keyListeners[id] = {} end
+local GLFW_KEY_ENTER     = 257
-    table.insert(keyListeners[id], listener)
+local GLFW_KEY_BACKSPACE = 259
 
-end
+local logOffset          = 0
 
-function dispatchKey(key, isHeld)
+function scrollLogs(key, isHeld)
-    local keyTbl = eventListeners[key]
+    if key == GLFW_KEY_DOWN then
-    if not keyTbl then return end
+        logOffset = logOffset - 1
-
+    elseif key == GLFW_KEY_UP then
-    for i = 1, #keyTbl, 1 do
+        logOffset = logOffset + 1
-        keyTbl[i](isHeld)
     end
 end
-registerEventListener("key", dispatchKey)
 
-function scrollLogsUp(isHeld)
+registerEventListener("key", scrollLogs)
-    logOffset = logOffset - 1
+
+--[[
+    console
+]]
+local consoleCommands = {}
+local commandBuffer = ""
+
+function registerConsoleCommand(name, handler, desc, usage)
+    local cmd = {
+        ["name"] = name,
+        ["handler"] = handler,
+        ["desc"] = desc or "",
+        ["usage"] = usage or nil
+    }
+    consoleCommands[name] = cmd
+end
+
+function processCommand()
+    local cmd
+    local args = {}
+
+    for word in commandBuffer:gmatch("%S+") do
+        if not cmd then
+            cmd = word
+        else
+            table.insert(args, word)
+        end
+    end
+
+    if consoleCommands[cmd] then
+        log.info("> %s %s", cmd, table.concat(args, " "))
+        consoleCommands[cmd].handler(args)
+    else
+        log.warning("Unknown command: %s", cmd)
+    end
+
+    commandBuffer = ""
+end
+
+function handleConsoleInput(char)
+    commandBuffer = commandBuffer .. char
+end
+
+registerEventListener("char", handleConsoleInput)
+
+function handleConsoleKeys(key)
+    if key == GLFW_KEY_ENTER and commandBuffer:len() > 0 then
+        processCommand()
+    elseif key == GLFW_KEY_BACKSPACE then
+        local len = commandBuffer:len()
+        if len >= 1 then
+            commandBuffer = commandBuffer:sub(0, len - 1)
+        end
+    end
+end
+
+registerEventListener("key", handleConsoleKeys)
+
+--[[
+    console commands
+]]
+function echoCommand(args)
+    log.info(table.concat(args, " "))
+end
+
+registerConsoleCommand("echo", echoCommand, "Prints your message", "echo (string)")
+
+function exitCommand(args)
+    shouldRun = false
+end
+
+registerConsoleCommand("exit", exitCommand, "Exits the program")
+
+function scanCommand(args)
+    log.info("Broadcasting SCAN")
+    sendToAll("SCAN", { ["hostChannel"] = HOST_CHANNEL })
+end
+
+registerConsoleCommand("scan", scanCommand, "Sends out a scan command to pair unlinked turtles")
+
+function clearCommand(args)
+    log.buffer = {}
+end
+
+registerConsoleCommand("clear", clearCommand, "Clears the console")
+
+function turtlesCommand(args)
+    if #turtles == 0 then
+        log.info("No turtles registered")
+        return
+    end
+
+    for i = 1, #turtles, 1 do
+        local turt = turtles[i]
+
+        local turtleMessage = ("Coords: %d, %d, %d - fuel: %d - channel: %d - id: %d - status: %s"):format(
+            turt.position[1],
+            turt.position[2], turt.position[3], turt.fuel, turt.channel, turt.id, turt.status)
+
+        log.info(turtleMessage)
+    end
+end
+
+registerConsoleCommand("turtles", turtlesCommand, "Lists all the linked turtles")
+
+function helpCommand(args)
+    if #args == 0 then
+        log.info("----- commands -----")
+        for _, cmd in pairs(consoleCommands) do
+            log.info("%s - %s", cmd.name, cmd.desc)
+        end
+    else
+        local cmdName = args[1]
+        local cmd = consoleCommands[cmdName]
+
+        if not cmdName then
+            log.error("Unable to find command: %s", cmdName)
+            return
+        end
+
+        log.info("---- %s ----", cmdName)
+        log.info(cmd.desc)
+        if cmd.usage then
+            log.info("Usage: %s", cmd.usage)
+        end
+    end
+end
+
+registerConsoleCommand("help", helpCommand, "Prints out all the console commands or usage of a specified command",
+    "help or help (command name)")
+
+--[[
+    drawing functions
+]]
+function drawLogs(x0, y0, x1, y1)
+    local w = x1 - x0
+    local h = y1 - y0
+
+    if #log.buffer == 0 then return end
+
     if logOffset < 0 then logOffset = 0 end
-end
+    if logOffset >= #log.buffer then logOffset = #log.buffer - 1 end
-registerKeyListener(265, scrollLogsUp)
+    if #log.buffer == 0 then logOffset = 0 end
 
-function scrollLogsDown(isHeld)
+    local drawnLines = 0
-    logOffset = logOffset + 1
+    for i = #log.buffer - logOffset, 1, -1 do
-    if logOffset >= #log.buffer then  logOffset = #log.buffer - 1 end
+        if drawnLines > h then break end
-end
-registerKeyListener(264, scrollLogsUp)
 
+        local entry = log.buffer[i]
+        local format = logTypes[entry.type]
 
---[[
+        local prevColourBg = scr.getBackgroundColour()
-    main
+        local prevColourFg = scr.getTextColour()
-]]
-log.general("tutel host init")
 
--- transmit scan
+        local prefix = ("[%s]"):format(entry.type)
--- log.info("broadcasting SCAN")
+        local prefixLength = #prefix
+        local maxMessageWidth = math.max(1, w - prefixLength)
 
---[[
+        local wrappedMessage = wrapText(tostring(entry.message), maxMessageWidth)
-    screen drawing
-]]
-function updateScreen()
-    local w, h = term.getSize()
 
-    local function drawTextCentered(text)
+        local messageBG, messageFG
-        local x = (w / 2) - (text:len() / 2)
+        if format.AffectContent then
-        local _, curY = term.getCursorPos()
+            messageBG = format.BG
-        term.setCursorPos(x, curY)
+            messageFG = format.FG
-        term.write(text)
+        else
-    end
+            messageBG = prevColourBg
+            messageFG = prevColourFg
+        end
 
-    -- reset state and clear screen
+        for lineIdx = #wrappedMessage, 1, -1 do
-    term.setBackgroundColor(colors.black)
+            if drawnLines > h then break end
-    term.clear()
 
-    -- -- title bar
+            local line = wrappedMessage[lineIdx]
-    term.setCursorPos(1, 1)
 
-    term.setBackgroundColor(colors.lightGray)
+            scr.setCursorPos(1, y1 - drawnLines)
-    term.setTextColour(colors.black)
 
-    term.clearLine()
+            if lineIdx == 1 then
-    drawTextCentered("tutel host controller")
+                scr.setBackgroundColor(format.BG)
-    
+                scr.setTextColor(format.FG)
-    term.setBackgroundColor(colors.black)
+                scr.write(prefix)
-    term.setTextColour(colors.white)
-
-    -- logs
-    local function drawLogs(startY, endY)
-        local drawnLines = 0
-        for i = #log.buffer - logOffset, 1, -1 do
-            if drawnLines > endY - startY then break end
-
-            local entry = log.buffer[i]
-            local format = logTypes[entry.type]
-
-            term.setCursorPos(0, endY - drawnLines)
-
-            local prevColourBg = term.getBackgroundColour()
-            local prevColourFg = term.getTextColour()
-
-            term.setBackgroundColour(format["BG"])
-            term.setTextColour(format["FG"])
-            term.write(("[%s]"):format(entry.type))
-
-            if format["AffectContent"] then
-                term.write((" %s\n"):format(entry.message))
-                term.setBackgroundColour(prevColourBg)
-                term.setTextColour(prevColourFg)
             else
-                term.setBackgroundColour(prevColourBg)
+                scr.setBackgroundColor(messageBG)
-                term.setTextColour(prevColourFg)
+                scr.write((" "):rep(prefixLength))
-                term.write((" %s\n"):format(entry.message))
+            end
+
+            scr.setBackgroundColor(messageBG)
+            scr.setTextColor(messageFG)
+            scr.write(" ")
+            scr.write(line)
+
+            local remaining = w - (prefixLength + #line)
+            if remaining > 0 then
+                scr.write((" "):rep(remaining))
             end
 
             drawnLines = drawnLines + 1
         end
+
+        scr.setBackgroundColor(prevColourBg)
+        scr.setTextColor(prevColourFg)
+    end
+end
+
+function drawStatusBar(y)
+    scr.setCursorPos(1, y)
+
+    scr.setBackgroundColor(colors.gray)
+    scr.setTextColor(colors.white)
+    scr.clearLine()
+
+    local str = ("Turtles: %d"):format(#turtles)
+    scr.write(str)
+end
+
+function drawCommandBar(w, y)
+    scr.setCursorPos(1, y)
+
+    scr.setBackgroundColor(colors.gray)
+    scr.setTextColor(colors.white)
+
+    scr.clearLine()
+
+    scr.write("$ ")
+
+    local startingIndex = commandBuffer:len() - w + 4
+    if startingIndex < 0 then
+        startingIndex = 0
     end
 
-    drawLogs(2, h - 1)
+    scr.write(commandBuffer:sub(startingIndex))
+    scr.setCursorBlink(true)
 end
 
 --[[
-    event polling
+    main loop functions
 ]]
+function updateScreen()
+    local w, h = scr.getSize()
+
+    local function drawTextCentered(text)
+        local x = (w / 2) - (text:len() / 2)
+        local _, curY = scr.getCursorPos()
+        scr.setCursorPos(x, curY)
+        scr.write(text)
+    end
+
+    -- reset state and clear screen
+    scr.setBackgroundColor(colors.black)
+    scr.clear()
+
+    -- -- title bar
+    scr.setCursorPos(1, 1)
+
+    scr.setBackgroundColor(colors.lightGray)
+    scr.setTextColour(colors.black)
+
+    scr.clearLine()
+    drawTextCentered("tutel host controller")
+
+    scr.setBackgroundColor(colors.black)
+    scr.setTextColour(colors.white)
+
+    drawLogs(1, 2, w, h - 1)
+    drawStatusBar(2)
+    drawCommandBar(w, h)
+end
+
 function pollEvents()
     local eventData = { os.pullEvent() }
 
@@ -301,15 +537,14 @@ function pollEvents()
 end
 
 --[[
-    main loop
+    main
 ]]
-for i=0, 15, 1 do
+log.general("Init")
-    log.info("some log %d", i)
-    log.warning("some warning %d", i)
-end
 
-sendToAll("SCAN", { ["hostChannel"] = HOST_CHANNEL })
+while shouldRun do
-while true do
     updateScreen()
     pollEvents()
 end
+
+scr.clear()
+scr.setCursorBlink(false)

lua/Cheat Engine/Supermarket.lua

@@ -0,0 +1,267 @@
+if (mono_enumDomains() == nil) then LaunchMonoDataCollector() end
+
+local is64Bit = targetIs64Bit()
+local ARRAY_SIZE_OFF = is64Bit and 0x18 or 0x10
+local ARRAY_DATA_OFF = is64Bit and 0x20 or 0x14
+local PTR_SIZE = is64Bit and 8 or 4
+
+local monoTypeToVartypeLookup = {
+    [0x02] = vtByte, -- BOOLEAN
+    [0x03] = vtWord, -- CHAR
+    [0x04] = vtByte, -- I1
+    [0x05] = vtByte, -- U1
+    [0x06] = vtWord, -- I2
+    [0x07] = vtWord, -- U2
+    [0x08] = vtDword, -- I4 (Int32)
+    [0x09] = vtDword, -- U4
+    [0x0a] = vtQword, -- I8
+    [0x0b] = vtQword, -- U8
+    [0x0c] = vtSingle, -- R4
+    [0x0d] = vtDouble, -- R8
+    [0x0e] = vtString, -- STRING
+    [0x0f] = vtPointer, -- PTR
+    [0x12] = vtPointer, -- CLASS
+    [0x14] = vtPointer -- ARRAY
+}
+
+--[[
+    generic helper functions
+]]
+function printf(fmt, ...) print(fmt:format(...)) end
+
+function splitByComma(str)
+    if str == nil or str == "" then return {} end
+    local result = {}
+    for word in string.gmatch(str, "([^,]+)") do table.insert(result, word) end
+    return result
+end
+
+--[[
+    mono helper functions
+]]
+function dumpFields(class)
+    print("class fields:")
+    for i, v in pairs(mono_class_enumFields(class)) do
+        printf("\tname: %s - static: %s", v.name, tostring(v.isStatic))
+    end
+end
+
+function getFieldFromName(class, name, shouldBeStatic)
+    local fields = mono_class_enumFields(class)
+    if not fields then return nil end
+    for i, v in pairs(fields) do
+        if v.isStatic == (shouldBeStatic == true) and v.name == name then
+            return v
+        end
+    end
+    print(("could not find field: %s"):format(name))
+    return nil
+end
+
+--[[
+    mono class wrappers
+]]
+function MonoArray(addr)
+    if not addr or addr == 0 then error("attempted to instantiate MonoArray with invalid addr") end
+
+    local classId, className = mono_object_getClass(addr)
+    if not className then error("address did not point to valid object") end
+    if className:sub(-2) ~= "[]" then error("address did not point to array") end
+
+    local array = {
+        _address = addr,
+        getLength = function(self)
+            return readInteger(self._address + ARRAY_SIZE_OFF)
+        end,
+        getElement = function(self, idx)
+            if idx < 0 or idx >= self:getLength() then
+                error("invalid index")
+            end
+            return
+                readPointer(self._address + ARRAY_DATA_OFF + (idx * PTR_SIZE))
+        end
+    }
+
+    setmetatable(array, {
+        __tostring = function() return "Mono array instance" end,
+        __index = function(self, k)
+            local idx = tonumber(k)
+            if idx ~= nil then return self:getElement(idx) end
+            return rawget(self, k)
+        end
+    })
+    return array
+end
+
+local stringClass = mono_findClass("System", "String")
+local string_Length = getFieldFromName(stringClass, "_stringLength")
+local string_FirstChar = getFieldFromName(stringClass, "_firstChar")
+
+function MonoStringReader(addr)
+    if not addr or addr == 0 then return nil end
+    local classId, className = mono_object_getClass(addr)
+    if className ~= "String" then error("address did not point to string") end
+
+    local str = {
+        _address = addr,
+        getLength = function(self)
+            return readInteger(self._address + string_Length.offset)
+        end,
+        getValue = function(self)
+            return readString(self._address + string_FirstChar.offset,
+                              self:getLength() * 2, true)
+        end
+    }
+
+    setmetatable(str, {
+        __tostring = function(self) return self:getValue() end,
+        __index = str
+    })
+    return str
+end
+
+function MonoFunctionHelper(fnName, fnId, isStatic)
+    local fn = {
+        _name = fnName,
+        _id = fnId,
+        _signatures = {},
+        _static = isStatic
+    }
+
+    if type(fnId) == "table" then
+        for i, v in ipairs(fnId) do
+            local sig = mono_method_getSignature(v)
+            table.insert(fn._signatures, {id = v, params = splitByComma(sig)})
+        end
+    end
+
+    setmetatable(fn, {
+        __call = function(self, ...)
+            local args = {...}
+            local methodArgs = args
+            local instancePtr = nil
+
+            if not self._static then
+                if #args == 0 then
+                    error("Instance method " .. self._name ..
+                              " requires instance pointer")
+                end
+                instancePtr = table.remove(methodArgs, 1)
+            end
+
+            local activeId = nil
+            if type(self._id) == "table" then
+                for _, candidate in ipairs(self._signatures) do
+                    if #candidate.params == #methodArgs then
+                        activeId = candidate.id
+                        break
+                    end
+                end
+                if not activeId then
+                    error("No overload for " .. self._name ..
+                              " matches arg count " .. #methodArgs)
+                end
+            else
+                activeId = self._id
+            end
+
+            local paramsInfo = mono_method_get_parameters(activeId)
+            local monoArgs = {}
+            for i = 1, #methodArgs do
+                local pType = paramsInfo.parameters[i].type
+                table.insert(monoArgs, {
+                    type = monoTypeToVartypeLookup[pType] or vtPointer,
+                    value = methodArgs[i]
+                })
+            end
+
+            return mono_invoke_method(mono_enumDomains()[1], activeId,
+                                      instancePtr, monoArgs)
+        end,
+        __tostring = function(self) return "MonoFunction: " .. self._name end
+    })
+    return fn
+end
+
+function MonoClass(namespace, name)
+    local classId = mono_findClass(namespace, name)
+    if not classId then error("Could not find class " .. name) end
+
+    local domain = mono_enumDomains()[1]
+    local staticAddr = mono_class_getStaticFieldAddress(domain, classId)
+    local methodsRaw = mono_class_enumMethods(classId)
+
+    local methodsSorted = {}
+    for _, v in pairs(methodsRaw) do
+        if methodsSorted[v.name] then
+            if type(methodsSorted[v.name]) ~= "table" then
+                methodsSorted[v.name] = {methodsSorted[v.name]}
+            end
+            table.insert(methodsSorted[v.name], v.method)
+        else
+            methodsSorted[v.name] = v.method
+        end
+    end
+
+    local methodsWrapped = {}
+    for mName, mId in pairs(methodsSorted) do
+        local checkId = type(mId) == "table" and mId[1] or mId
+        local flags = mono_method_getFlags(checkId)
+        local isStatic = bAnd(flags, 0x0010) ~= 0
+        methodsWrapped[mName] = MonoFunctionHelper(mName, mId, isStatic)
+    end
+
+    local classObj = {
+        _id = classId,
+        _name = name,
+        _ns = namespace,
+        _fieldInfo = {},
+        _staticAddr = staticAddr,
+        _methods = methodsWrapped,
+        getStaticFieldOffset = function(self, name)
+            local field = getFieldFromName(self._id, name, true)
+            return field and field.offset or nil
+        end,
+        getStaticField = function(self, offset)
+            return readPointer(self._staticAddr + offset)
+        end,
+        getMethod = function(self, methodName)
+            local m = self._methods[methodName]
+            if not m then
+                error("Method " .. methodName .. " not found!")
+            end
+            return m
+        end
+    }
+
+    return setmetatable(classObj, {
+        __index = function(self, key)
+            return self._methods[key] or rawget(self, key)
+        end
+    })
+end
+
+local typeClass = MonoClass("System", "Type")
+function Type(typeName)
+    local typeStr = mono_new_string(typeName)
+    local getType = typeClass:getMethod("GetType")
+    local typeRet = getType(typeStr)
+
+    print(type(typeRet), typeRet)
+end
+
+--[[
+    game
+]]
+local GameDataClass = MonoClass("", "GameData")
+local instanceOffset = GameDataClass:getStaticFieldOffset("Instance")
+
+printf("GameData class id: %s", tostring(GameDataClass))
+printf("GameData.Instance field offset: %x", instanceOffset or 0)
+
+local gameDataInstance = GameDataClass:getStaticField(instanceOffset)
+printf("GameData: %x", gameDataInstance or 0)
+
+local alterFunds = GameDataClass:getMethod("CmdAlterFunds")
+printf("GameData.CmdAlterFunds: %x", alterFunds._id or 0)
+alterFunds(gameDataInstance, 13371337)