uranium-core/main.xml

<Layer Type="ActorFrame" InitCommand="%function(self)
  _G.oat = {}
  oat._main = self
  oat.dir = GAMESTATE:GetCurrentSong():GetSongDir()

  setmetatable(oat, {
    -- if something isn't found in the table, fall back to a global lookup
    __index = _G,

    -- handle oat() calls to set the environment
    __call = function(self, f)
      setfenv(f or 2, self)
      return f
    end
  })

  -- make require work
  -- stolen from mirin template
  -- https://github.com/XeroOl/notitg-mirin/blob/0fbff2ee93d905feeb58c4aac4fe7f5f9ebc9647/template/std.lua#L17
  oat.package = {
    -- uranium template loader path
    path = 'src/?.lua;src/?/init.lua;template/?.lua',
    preload = {},
    loaded = {},
    loaders = {
      function(modname)
        local preload = oat.package.preload[modname]
        return preload or 'no field oat.package.preload[\''..modname..'\']'
      end,
      function(modname)
        local errors = {}
        -- get the filename
        local filename = string.gsub(modname, '%.', '/')
        for path in (string.gfind or string.gmatch)(oat.package.path, '[^;]+') do
          -- get the file path
          local filepath = oat.dir .. string.gsub(path, '%?', filename)
          -- check if file exists
          if not GAMESTATE:GetFileStructure(filepath) then
            table.insert(errors, 'no file \''..filepath..'\'')
          else
            local loader, err = loadfile(filepath)
            -- check if file loads properly
            if err then
              error(err, 3)
            elseif loader then
              return oat(loader)
            end
          end
        end
        return table.concat(errors, '\n')
      end,
    },
  }

  function oat.require(modname)
    local loaded = oat.package.loaded
    if not loaded[modname] then
      local errors = {'module \''..modname..'\' not found:'}
      local chunk
      for _, loader in ipairs(oat.package.loaders) do
        local result = loader(modname)
        if type(result) == 'string' then
          table.insert(errors, result)
        elseif type(result) == 'function' then
          chunk = result
          break
        end
      end
      if not chunk then
        error(table.concat(errors, '\n'), 2)
      end
      loaded[modname] = chunk()
      if loaded[modname] == nil then
        loaded[modname] = true
      end
    end
    return loaded[modname]
  end

  oat()

  local function copy(src)
    local dest = {}
    for k, v in pairs(src) do
      dest[k] = v
    end
    return dest
  end

  oat.oat = _G.oat
  oat.type = _G.type
  oat.print = _G.print
  oat.pairs = _G.pairs
  oat.ipairs = _G.ipairs
  oat.unpack = _G.unpack
  oat.tonumber = _G.tonumber
  oat.tostring = _G.tostring
  oat.math = copy(_G.math)
  oat.table = copy(_G.table)
  oat.string = copy(_G.string)

  oat.scx = SCREEN_CENTER_X
  oat.scy = SCREEN_CENTER_Y
  oat.sw = SCREEN_WIDTH
  oat.sh = SCREEN_HEIGHT
  oat.dw = DISPLAY:GetDisplayWidth()
  oat.dh = DISPLAY:GetDisplayHeight()

  local uraniumFunc = {}

  function uraniumFunc:call(event, ...)
    if self._callbacks[event] then
      for _, callback in ipairs(self._callbacks[event]) do
        callback(unpack(arg))
      end
    end
  end

  local uraniumMeta = {}

  function uraniumMeta:__newindex(key, value)
    if self._callbacks[key] then
      table.insert(self._callbacks[key], value)
    else
      self._callbacks[key] = {value}
    end
  end

  uraniumMeta.__index = uraniumFunc

  uranium = setmetatable({_callbacks = {}}, uraniumMeta)

  function backToSongWheel(message)
    if message then
      SCREENMAN:SystemMessage(message)
      print(message)
    end
    GAMESTATE:FinishSong()
    -- disable update_command
    self:hidden(1)
  end

  local hasExited = false
  local function exit()
    if hasExited then return end
    hasExited = true
    uranium:call('exit')
  end

  local actorsInitialized = false -- if true, no new actors can be created

  local luaobj

  local globalQueue = {} -- for resetting

  local patchedFunctions = {}
  local function patchFunction(f, obj)
    if not patchedFunctions[f] then patchedFunctions[f] = {} end
    if not patchedFunctions[f][obj] then
      patchedFunctions[f][obj] = function(...)
        arg[1] = obj
        local results
        local status, result = pcall(function()
          -- doing it this way instead of returning because lua
          -- offers no way of grabbing everything BUT the first
          -- argument out of pcall
          results = {f(unpack(arg))}
        end)
        if not status then
          error(result, 2)
        else
          return unpack(results)
        end
      end
    end
    return patchedFunctions[f][obj]
  end

  local function onCommand(self)
    actorsInitialized = true
    uranium:call('init')
  end

  function reset(actor)
    if not actorsInitialized then error('uranium: cannot reset an actor during initialization', 2) end
    for _, q in ipairs(globalQueue) do
      local queueActor = q[1]
      if queueActor == actor.__raw then
        local v = q[2]

        local func = queueActor[v[1]]
        if not func then
          -- uhmmm ??? hm. what do we do??
        else
          patchFunction(func, queueActor)(unpack(v[2]))
        end
      end
    end
  end

  -- runs once during ScreenReadyCommand, before the user code is loaded
  -- hides various actors that are placed by the theme
  local function hideThemeActors()
    for _, element in ipairs {
      'Overlay', 'Underlay',
      'ScoreP1', 'ScoreP2',
      'LifeP1', 'LifeP2',
    } do
      local child = SCREENMAN(element)
      if child then child:hidden(1) end
    end
  end

  local lastt = GAMESTATE:GetSongTime()
  local function screen_ready_command(self)
    hideThemeActors()
    self:hidden(0)

    local errored = false
    local firstrun = true
    self:addcommand('Update', function()
      if not P1 and not P2 then -- sora exit hack
        exit()
      end

      if errored then
        return 0
      end
      errored = true

      t = os.clock()
      b = GAMESTATE:GetSongBeat()
      local dt = t - lastt
      lastt = t

      if firstrun then
        firstrun = false
        dt = 0
        self:GetChildren()[2]:hidden(1)
        uranium:call('ready')
      end

      for _, q in ipairs(globalQueue) do
        local actor = q[1]
        local v = q[2]

        local func = actor[v[1]]
        if not func then
          -- uhmmm ??? hm. what do we do??
        else
          patchFunction(func, actor)(unpack(v[2]))
        end
      end

      uranium:call('update', dt)

      errored = false

      return 0
    end)
    self:luaeffect('Update')
  end

  GAMESTATE:ApplyModifiers('clearall')

  -- actors

  local actorQueue = {}
  local currentActor = nil

  oat._actor = {}

  function oat._actor.next()
    local actor = actorQueue[1]
    if actor then
      table.remove(actorQueue, 1)
      currentActor = actor
      return true
    else
      return false
    end
  end

  function oat._actor.cond()
    return currentActor ~= nil
  end

  function oat._actor.hasShader()
    return oat._actor.cond() and (currentActor.frag ~= nil or currentActor.vert ~= nil)
  end

  function oat._actor.noShader()
    return oat._actor.cond() and not oat._actor.hasShader()
  end

  function oat._actor.type()
    return currentActor.type
  end

  function oat._actor.file()
    return currentActor.file
  end

  function oat._actor.frag()
    return currentActor.frag or 'nop.frag'
  end

  function oat._actor.vert()
    return currentActor.vert or 'nop.vert'
  end

  function oat._actor.font()
    return currentActor.font
  end

  function oat._actor.init(self)
    currentActor.init(self)
  end

  function oat._actor.initFrame(self)
    local nextChild = self(2)
    self:SetDrawFunction(function()
      if nextChild then
        nextChild:Draw()
      end
    end)
  end

  local function createProxyActor(name)
    local queue = {}
    local initCommands = {}
    local lockedActor

    return setmetatable({}, {
      __index = function(self, key)
        if key == '__raw' then
          return lockedActor
        end
        if lockedActor then
          local val = lockedActor[key]
          if type(val) == 'function' then
            return patchFunction(val, lockedActor)
          end
          return val
        end
        if key == '__lock' then
          return function(actor)
            for _, v in ipairs(queue) do
              local func = actor[v[1]]
              if not func then
                error(
                  'uranium: error on \'' .. name .. '\' initialization on ' .. v[3].short_src .. ':' .. v[3].currentline .. ':\n' ..
                  'you\'re calling a function \'' .. v[1] .. '\' on a ' .. name .. ' which doesn\'t exist!:\n'
                )
              else
                local success, result = pcall(function()
                  patchFunction(func, actor)(unpack(v[2]))
                end)
                if not success then
                  error(
                    'uranium: error on \'' .. name .. '\' initialization on ' .. v[3].short_src .. ':' .. v[3].currentline .. ':\n' ..
                    result
                  )
                end
              end
            end
            -- now that we know there's no poisonous methods in queue, let's offload them
            for _, v in ipairs(queue) do
              table.insert(globalQueue, {actor, v})
            end
            -- let's also properly route everything from the proxied actor to the actual actor
            lockedActor = actor
            -- and now let's run the initcommands
            for _, c in ipairs(initCommands) do
              local func = c[1]
              local success, result = pcall(function()
                func(actor)
              end)
              if not success then
                error(
                  'uranium: error on \'' .. name .. '\' InitCommand defined on ' .. v[3].short_src .. ':' .. v[3].currentline .. ':\n' ..
                  result
                )
              end
            end
            initCommands = {}
          end
        else
          return function(...)
            if key == 'addcommand' and arg[2] == 'Init' then
              table.insert(initCommands, {arg[3], debug.getinfo(2, 'Sl')})
            else
              table.insert(queue, {key, arg, debug.getinfo(2, 'Sl')})
            end
          end
        end
      end,
      __newindex = function()
        error('uranium: cannot set properties on actors!', 2)
      end,
      __tostring = function() return name end,
      __name = name
    })
  end

  local function createGenericFunc(type)
    return function()
      if actorsInitialized then error('uranium: cannot create an actor during runtime!!', 2) end
      local actor = createProxyActor(type)
      table.insert(actorQueue, {
        type = type,
        file = nil,
        init = function(a)
          actor.__lock(a)
        end
      })
      return actor
    end
  end

  Quad = createGenericFunc('Quad')
  ActorProxy = createGenericFunc('ActorProxy')
  Polygon = createGenericFunc('Polygon')
  ActorFrameTexture = createGenericFunc('ActorFrameTexture')

  function Sprite(file)
    if actorsInitialized then error('uranium: cannot create an actor during runtime!!', 2) end
    --if not file then error('uranium: cannot create a Sprite without a file', 2) end
    local actor = createProxyActor('Sprite')
    local type = nil
    if not file then type = 'Sprite' end
    table.insert(actorQueue, {
      type = type,
      file = file and oat.dir .. file,
      init = function(a)
        actor.__lock(a)
      end
    })
    return actor
  end

  local function isShaderCode(str)
    return string.find(str or '', '\n')
  end

  function Shader(frag, vert)
    if actorsInitialized then error('uranium: cannot create an actor during runtime!!', 2) end
    local actor = createProxyActor('RageShaderProgram')

    local fragFile = frag
    local vertFile = vert

    local isFragShaderCode = isShaderCode(frag)
    local isVertShaderCode = isShaderCode(vert)

    if isFragShaderCode then fragFile = nil end
    if isVertShaderCode then vertFile = nil end

    if (frag and vert) and ((isFragShaderCode and not isVertShaderCode) or (not isFragShaderCode and isVertShaderCode)) then
      error('uranium: cannot create a shader with 1 shader file and 1 shader code block', 2)
    end

    table.insert(actorQueue, {
      type = 'Sprite',
      frag = fragFile and ('../' .. fragFile) or 'nop.frag',
      vert = vertFile and ('../' .. vertFile) or 'nop.vert',
      init = function(a)
        actor.__lock(a:GetShader())

        -- shader code stuff
        if isFragShaderCode or isVertShaderCode then
          a:GetShader():compile(vert or '', frag or '')
        end
      end
    })
    return actor
  end

  function Model(file)
    if actorsInitialized then error('uranium: cannot create an actor during runtime!!', 2) end
    if not file then error('uranium: cannot create a Model without a file', 2) end
    local actor = createProxyActor('Model')
    table.insert(actorQueue, {
      type = nil,
      file = file and oat.dir .. file,
      init = function(a)
        actor.__lock(a)
      end
    })
    return actor
  end

  function BitmapText(font, text)
    if actorsInitialized then error('uranium: cannot create an actor during runtime!!', 2) end
    local actor = createProxyActor('BitmapText')
    table.insert(actorQueue, {
      type = 'BitmapText',
      font = font and (oat.dir .. font) or 'common',
      init = function(a)
        if text then a:settext(text) end
        actor.__lock(a)
      end
    })
    return actor
  end

  function ActorSound(file)
    if actorsInitialized then error('uranium: cannot create an actor during runtime!!', 2) end
    if not file then error('uranium: cannot create an ActorSound without a file', 2) end
    local actor = createProxyActor('ActorSound')
    table.insert(actorQueue, {
      type = 'ActorSound',
      file = oat.dir .. file,
      init = function(a)
        actor.__lock(a)
      end
    })
    return actor
  end

  local success, result = pcall(function()
    require('main')
  end)

  if success then
    luaobj = result

    self:addcommand('On', onCommand)
    self:addcommand('Ready', screen_ready_command)
    self:addcommand('Off', exit)
    self:queuecommand('Ready')
  else
    Trace('got an error loading main.lua!')
    Trace(result)
    backToSongWheel('loading .lua file failed, check log for details')
    error('uranium: loading main.lua file failed:\n' .. result)
  end

  -- NotITG and OpenITG have a long standing bug where the InitCommand on an actor can run twice in certain cases.
  -- By removing the command after it's done, it can only ever run once
  self:removecommand('Init')
end"><children>
  <Layer Condition="oat._actor.next()" File="actors.xml"/>
  <Layer Type="Quad" InitCommand="xywh,SCREEN_CENTER_X,SCREEN_CENTER_Y,SCREEN_WIDTH,SCREEN_HEIGHT;diffuse,#000000;sleep,9e9"/>
</children></Layer>