eventsystem.lua

local Class = require 'modules.middleclass.middleclass'
local Timer = require 'modules.hump.timer'

local Event = Class('Event')

function Event:initialize(time, callbacks)
    assert(time and callbacks)
    self.timer = Timer.new()
    self.timer:after(time, function()
        self.dead = true
    end)

    self.callbacks = {
        start = callbacks.start,
        run = callbacks.run,
        stop = callbacks.stop
    }

    self.dead = false
    self.running = false
end

function Event:start()
    assert(not self.running)
    self.running = true
    if self.callbacks.start then self.callbacks.start() end
end

function Event:run(dt)
    assert(self.running)
    if self.callbacks.run then self.callbacks.run() end
    self.timer:update(dt)
end

function Event:stop()
    assert(self.running)
    self.running = false
    if self.callbacks.stop then self.callbacks.stop() end
end

function Event:isDead()
    return self.dead
end

-- EventSystem _________________________________________________________________

local EventSystem = {}

function EventSystem:init()
    self.events = {}
    self.activeEvent = nil
end

function EventSystem:update(dt)
    if self.activeEvent then
        if self.activeEvent:isDead() then
            EventSystem:next()
        else
            self.activeEvent:run(dt)
        end
    end
end

function EventSystem:queue(time, callbacks)
    local event = Event(time, callbacks)
    table.insert(self.events, event)
    if not self.activeEvent then
        EventSystem:next()
    end
end

function EventSystem:next()
    if self.activeEvent then
        self.activeEvent:stop()
    end

    if #self.events == 0 then
        self.activeEvent = nil
    else
        self.activeEvent = self.events[1]
        self.activeEvent:start()
        table.remove(self.events, 1)
    end
end

function EventSystem:clear()
    if self.activeEvent then
        self.activeEvent:stop()
    end
    self.events = {}
    self.activeEvent = nil
end

function EventSystem:isRunning()
    return self.activeEvent ~= nil
end

return EventSystem

Use (in src/objects/gemini.lua)

    local EventSystem = require ('src.eventSystem')
    EventSystem:queue(200, {})
    EventSystem:queue(100, {
        start = function()
            Signal.emit('dialogue', 'cut1')
        end,
        run = function(dt)
            self.vel.x = 0.6
            self.lookDir = Direction.RIGHT
        end,
        stop = function()
            Signal.emit('dialogue', 'cut2')
        end
    })
    EventSystem:queue(100, {
        run = function(dt)
            self.vel.x = -1
            self.lookDir = Direction.LEFT
            if self.ground then
                self.vel.y = -2
                Particles.cloudUp:emit(self.pos.x + self.size.x / 2, self.pos.y + self.size.y)
                Sounds.jump:play(self:getCenter())
            end
        end,
        stop = function()
            Signal.emit('dialogue', 'cut3')
        end
    })