LÖVE

pgimeno wrote: ↑Thu Jun 06, 2019 1:19 am I've now taken a look at other similar libraries. Yours is the only one I see that has separate event handlers while running in the background, which seems interesting. However, I wonder if it wouldn't be better calling the same callbacks but letting them know whether they're on the background or not, and passing back whether the event was handled.

pgimeno wrote: ↑Thu Jun 06, 2019 1:19 am I don't like the idea of having the game screen stacked on top of the menu screen; I don't think the menu has to be preserved as if it was "paused" while you are playing and "resumed" when you finish. Also, if setting a pause state doesn't call the draw method of the previous stack, handling anything but a full-screen pause is going to be more complicated than adding the pause as another state in the current stack.

mateusak wrote: ↑Thu Jun 06, 2019 2:33 am I'll definitely look into implementing your suggestion, if you have any more of them nice ideas I appreciate it

pgimeno wrote: ↑Thu Jun 06, 2019 10:09 am It wasn't my idea, it was in s-ol's library actually. I liked the design.

pgimeno wrote: ↑Thu Jun 06, 2019 10:09 am It doesn't differentiate between event types; instead, you can decide per event type if you want to call events in order from bottom to top of the stack (adequate for draw events) or from top to bottom (adequate for control events). It tracks that with an internal order[eventtype] variable and a method to change it.

mateusak wrote: ↑Thu Jun 06, 2019 3:10 pm That's fine if there's no focus control like mine. If you see my code you'll see that the callbacks are actually calls to stackcall(), but they need extra arguments for focus control that would just complicate things for the end-user. If I replace focus control with a messaging system it's possible but then drawing blocking is inviable. If I use both, then it's just too complex.

function lower_level_state:draw()
  if not self:focused() then return end -- don't draw if not the top state of the stack
end

function top_level_state:keypressed(key, scancode, isrepeat)
  if key == "return" then
    -- do stuff
    return true -- "stop processing messages"
  end
end

function lower_level_state:keypressed(key, scancode, isrepeat)
  if key == "space" then
    -- do stuff - this code may execute
  end
  if key == "return" then
    -- this code won't execute if top_level_state runs on top of this
    -- (the whole callback won't be called in this case)
  end
end

function states:focused()
  return self.stack[#self.stack] == self
end

function states:call_event(event_name, ...)
  if self.bottom_up[event_name] then
    for i = 1, #self.stack do
      local state = self.stack[i]
      if state[callback] then
        -- for bottom-up, propagation isn't stopped
        state[callback](state, ...)
      end
    end
  else
    -- Loop from top to bottom
    for i = #self.stack, 1, -1 do
      local state = self.stack[i]
      if state[callback] and state[callback](state, ...) then
        -- for top-down, returning true causes to automatically stop propagation
        break
      end
    end
  end
end

function game:draw()
  camera:set()
  self:drawBackground()
  self:drawForeground()
  camera:unset()
end

function game:weakDraw()
  camera:set()
  self:drawBackground()
  camera:unset()
  love.graphics.setColor(0, 0, 0, 0.7)
  love.graphics.rectangle("fill", 0, 0, love.graphics.getDimensions())
  camera:set()
  self:drawForeground()
  camera:unset()
end

function game:draw()
  camera:set()
  self:drawBackground()
  if self:focused() then
    camera:unset()
    love.graphics.setColor(0, 0, 0, 0.7)
    love.graphics.rectangle("fill", 0, 0, love.graphics.getDimensions())
    camera:set()
  end
  self:drawForeground()
  camera:unset()
end

pgimeno wrote: ↑Thu Jun 06, 2019 11:53 pm This way, you don't need to clobber the functions with 'if handled then return end'; you just return true when handled, and that stops propagation, which looks clean to me.

I think that in most cases, you'll want the background draw() to be executed, therefore the cases where you need to check self:focused() systematically will not be many.

pgimeno wrote: ↑Thu Jun 06, 2019 11:53 pm For example, imagine you want to darken the background while paused, but not the foreground. If there's no function to tell you if focused(), you would need to do something like this:

Code: Select all

function game:draw()
  camera:set()
  self:drawBackground()
  self:drawForeground()
  camera:unset()
end

function game:weakDraw()
  camera:set()
  self:drawBackground()
  camera:unset()
  love.graphics.setColor(0, 0, 0, 0.7)
  love.graphics.rectangle("fill", 0, 0, love.graphics.getDimensions())
  camera:set()
  self:drawForeground()
  camera:unset()
end

function drawEveything(darkenBackground)
  camera:set()
  self:drawBackground()
  
  if darkenBackground then
    love.graphics.setColor(0, 0, 0, 0.7)
    love.graphics.rectangle("fill", 0, 0, love.graphics.getDimensions())
  end
  
  self:drawForeground()
  camera:unset()
end

function game:draw()
  drawEverything(false)
end

function game:weakDraw()
  drawEverything(true)
end