LÖVE

Code: Select all

coroutine.yield()

Code: Select all

-- assuming our gamestate's basic functions, init, update, draw, etc., I'll show minimal stubs
function MyGameState:update()
  self.runner = self.runner()  -- Note here, always continuing with the last returned function
end

function MyGameState:init()
  self.runner = self:runMenu() -- where it first comes from
end

function MyGameState:runMenu()
  local menu = MyMethodForBuildingMenus()
    :withChaining()
    :andOtherFeatures()
    :finalizer()
  -- add to your entities here possibly

  local function loop()
    if love.keyboard:isDown("space") then
      local command = whateverEntitySystem:getOption(menu)
      if command == "submenu" then
        -- remove menu from entities
        return self:runSubMenu()
      end
    else
      -- call your entity system for updating generic menus
    end
    return loop
  end
  return loop
end

function MyGameState:runSubMenu()
  -- follows same structure as runMenu
end

Code: Select all

function states.action_menu:run_action_menu()
  local W, H = 18, 6
  local sw, sh = graphics.max_window_size()
  local main_menu = systems.menubox.assembly.builder.new()
    :at(math.floor((sw-W)/2), sh-H+1):size(W, H)
    :option("Talk", "talk")
    :option("Item", "use")
    :option("Equip", "equip")
    :option("Search", "search")
    :option("Attack", "attack", math.floor(W/2)+1, 1)
    :option("Magic", "mag")
    :option("Status", "stats")
    :option("System", "system")
    :build()

  local menu_close_then = menu_open(self.entities, main_menu)
  local function loop()
    if input.tap.cancel then
      menu_close_then(gamestate.pop)
    elseif input.tap.action then
      local command = main_menu.menu_config[main_menu.menu_selection].id
      if command == "talk" then
        if self.callback then self.callback() end
      elseif command == "stats" then
        return menu_close_then(self.run_stats_window, self)
      end
    else
      local cmd = systems.menubox.update(self.entities)
      if cmd == 'advance' then
        graphics.set_dirty()
      end
    end
    return loop
  end
  return loop
end

function states.action_menu:run_stats_window()
  local sw, sh = graphics.max_window_size()

  local W, H = 20, 12
  local stats_window = systems.drawboxes.assembly.new_window_builder()
    :at(math.floor((sw-W)/2), math.floor((sh-H)/2)):size(W, H)
    :text(("Level      %7i"):format(99), 1, 1)
    :text(("Experience %7i"):format(99999), 1, 2)
    :text(("Next Level %7i"):format(9999), 1, 3)
    :text("-", 1, 4)
    :text(("Hit Points %3i/%3i"):format(999, 999), 1, 5)
    :text("", 1, 6)
    :text("-", 1, 7)
    :text("-", 1, 8)
    :text("-", 1, 9)
    :text(("Carry Weight %2i/%2i"):format(99, 99), 1, 10)
    :build()

  local menu_close_then = menu_open(self.entities, stats_window)
  local function loop()
    if input.tap.cancel then
      return menu_close_then(self.run_action_menu, self)
    end
    return loop
  end
  return loop
end

Code: Select all

function MyGameState:MenuChain (menu)
    return Chain(
        -- Push menu onto stack and slide it onto screen.
        function (go)
            self.menuStack[#self.menuStack + 1] = menu
            -- A method that takes a callback, and starts a tween.
            -- The callback will run when the tween is finished.
            menu:slideIn(go)
        end,
        -- Await user input.
        function (go)
            -- A method that takes a callback and awaits menu input.
            -- The callback will run when input is received.
            -- A command (user action) object is passed to the callback.
            menu:awaitInput(go)
        end,
        -- Handle user input.
        function (go, command)
            -- If user is closing this menu, go to next link in chain now.
            if command.id == 'close' then
                go()
                return
            end
            -- If it's a submenu, return a new menu chain for it.
            if command.id == 'submenu' then
                return self:MenuChain(command.submenu)
            end
            -- Command's ID not recognized; it's not a menu-related command. Let it do its own thing.
            return self:MenuCommandChain(command)
        end,
        -- Slide menu off screen.
        function (go)
            menu:slideOut(go)
        end,
        -- Pop menu off the stack.
        function (go)
            assert(self.menuStack[#self.menuStack] == menu)
            self.menuStack[#self.menuStack] = nil
        end
    )
end

function MyGameState:MenuCommandChain (command)
    return Chain(
        function (go)
            if not command.execute then error 'bad menu command' end
            -- A method that takes a callback and starts executing a command. 
            -- The callback will run when the command is finished.
            command:execute(go)
        end
    )
end

function MyGameState:update (dt)
    local topMenu = self.menuStack[#self.menuStack]
    if topMenu then
        topMenu:update(dt)
    end
end

function MyGameState:draw ()
    for _, menu in ipairs(self.menuStack) do
        menu:draw()
    end
end

function MyGameState:init()
    self.menuStack = {}
    
    local menu = Menu(self)
        :addItem { id = 'close', title = 'Close' }
        :addItem { id = 'submenu', title = 'Crafting',
            submenu = self:CraftingMenu() }
        :addItem { id = 'submenu', title = 'Inventory',
            submenu = self:InventoryMenu() }
        :addItem {
            title = 'Turn orange',
            execute = function (cb)
                orangeTween:start(cb)
            end
        }
        :addItem {
            title = 'Quit',
            execute = function ()
                os.exit()
            end
        }
        
    self:MenuChain(menu)()
end