diff --git a/README.ACKNOWLEDGEMENT b/README.ACKNOWLEDGEMENT new file mode 100644 index 0000000..f222a3c --- /dev/null +++ b/README.ACKNOWLEDGEMENT @@ -0,0 +1,35 @@ +The following files: + +* signal.lua +* timer.lua + +Are based on hump - Helper Utilities for Massive Progression, +originally by Mathias Richter, and available at: +https://github.com/vrld/hump + +Under the following license: + +> Copyright (c) 2010-2018 Matthias Richter +> +> Permission is hereby granted, free of charge, to any person obtaining a copy +> of this software and associated documentation files (the "Software"), to deal +> in the Software without restriction, including without limitation the rights +> to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +> copies of the Software, and to permit persons to whom the Software is +> furnished to do so, subject to the following conditions: +> +> The above copyright notice and this permission notice shall be included in +> all copies or substantial portions of the Software. +> +> Except as contained in this notice, the name(s) of the above copyright holders +> shall not be used in advertising or otherwise to promote the sale, use or +> other dealings in this Software without prior written authorization. +> +> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +> IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +> FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +> AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +> LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +> OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +> THE SOFTWARE. + diff --git a/init.lua b/init.lua index b822f70..2644ac6 100644 --- a/init.lua +++ b/init.lua @@ -17,6 +17,8 @@ return { meta = require(BASE..'meta'), rect = require(BASE..'rect'), shadowtext = require(BASE..'shadowtext'), + signal = require(BASE..'signal'), strings = require(BASE..'strings'), + timer = require(BASE..'timer'), vec = require(BASE..'vec') } diff --git a/signal.lua b/signal.lua new file mode 100644 index 0000000..7817942 --- /dev/null +++ b/signal.lua @@ -0,0 +1,90 @@ +--- Timer utilities. +-- +-- This is a reworked implementation of the original signal module +-- from the hump library (https://github.com/vrld/hump). +-- See README.ACKNOWLEDGEMENT for detailed information. +-- +-- It offers functionality to register for and publish signals. +-- Implements the Observer pattern. +-- +-- @module gear.timer +-- @copyright 2010-2013 Matthias Richter +-- @copyright 2022 The DoubleFourteen Code Forge +-- @author Matthias Richter, Lorenzo Cogotti + +local Signal = {} +Signal.__index = function(self, key) + return Signal[key] or (function() + local t = {} + rawset(self, key, t) + return t + end)() +end + +function Signal:register(s, f) + self[s][f] = f + return f +end + +function Signal:emit(s, ...) + for f in pairs(self[s]) do + f(...) + end +end + +function Signal:remove(s, ...) + local f = {...} + for i = 1,select('#', ...) do + self[s][f[i]] = nil + end +end + +function Signal:clear(...) + local s = {...} + for i = 1,select('#', ...) do + self[s[i]] = {} + end +end + +function Signal:emitPattern(p, ...) + for s in pairs(self) do + if s:match(p) then self:emit(s, ...) end + end +end + +function Signal:registerPattern(p, f) + for s in pairs(self) do + if s:match(p) then self:register(s, f) end + end + return f +end + +function Signal:removePattern(p, ...) + for s in pairs(self) do + if s:match(p) then self:remove(s, ...) end + end +end + +function Signal:clearPattern(p) + for s in pairs(self) do + if s:match(p) then self[s] = {} end + end +end + +-- instancing +function Signal.new() + return setmetatable({}, Signal) +end + +-- default instance +local default = Signal.new() + +-- module forwards calls to default instance +local module = {} +for k in pairs(Signal) do + if k ~= "__index" then + module[k] = function(...) return default[k](default, ...) end + end +end + +return Signal diff --git a/timer.lua b/timer.lua new file mode 100644 index 0000000..663c196 --- /dev/null +++ b/timer.lua @@ -0,0 +1,201 @@ +--- Timer utilities. +-- +-- This is a reworked implementation of the original timer module +-- from the hump library (https://github.com/vrld/hump). +-- See README.ACKNOWLEDGEMENT for detailed information. +-- +-- It offers functionality to schedule tasks for delayed or periodic +-- execution, as well as tweening. +-- +-- @module gear.timer +-- @copyright 2010-2013 Matthias Richter +-- @copyright 2022 The DoubleFourteen Code Forge +-- @author Matthias Richter, Lorenzo Cogotti + +local Timer = {} +Timer.__index = Timer + +local function _nothing_() end + +local function updateTimerHandle(handle, dt) + -- handle: { + -- time = , + -- after = , + -- during = , + -- limit = , + -- count = , + -- } + handle.time = handle.time + dt + handle.during(dt, math.max(handle.limit - handle.time, 0)) + + while handle.time >= handle.limit and handle.count > 0 do + if handle.after(handle.after) == false then + handle.count = 0 + break + end + handle.time = handle.time - handle.limit + handle.count = handle.count - 1 + end +end + +function Timer:update(dt) + -- timers may create new timers, which leads to undefined behavior + -- in pairs() - so we need to put them in a different table first + local to_update = {} + for handle in pairs(self.functions) do + to_update[handle] = handle + end + + for handle in pairs(to_update) do + if self.functions[handle] then + updateTimerHandle(handle, dt) + if handle.count == 0 then + self.functions[handle] = nil + end + end + end +end + +function Timer:during(delay, during, after) + local handle = { + time = 0, + during = during, + after = after or _nothing_, + limit = delay, + count = 1 + } + + self.functions[handle] = true + return handle +end + +function Timer:after(delay, func) + return self:during(delay, _nothing_, func) +end + +function Timer:every(delay, after, count) + local count = count or math.huge -- exploit below: math.huge - 1 = math.huge + local handle = { + time = 0, + during = _nothing_, + after = after, + limit = delay, + count = count + } + + self.functions[handle] = true + return handle +end + +function Timer:cancel(handle) + self.functions[handle] = nil +end + +function Timer:clear() + self.functions = {} +end + +function Timer:script(f) + local co = coroutine.wrap(f) + co(function(t) + self:after(t, co) + coroutine.yield() + end) +end + +Timer.tween = setmetatable({ + -- helper functions + out = function(f) -- 'rotates' a function + return function(s, ...) return 1 - f(1-s, ...) end + end, + chain = function(f1, f2) -- concatenates two functions + return function(s, ...) return (s < .5 and f1(2*s, ...) or 1 + f2(2*s-1, ...)) * .5 end + end, + + -- useful tweening functions + linear = function(s) return s end, + quad = function(s) return s*s end, + cubic = function(s) return s*s*s end, + quart = function(s) return s*s*s*s end, + quint = function(s) return s*s*s*s*s end, + sine = function(s) return 1-math.cos(s*math.pi/2) end, + expo = function(s) return 2^(10*(s-1)) end, + circ = function(s) return 1 - math.sqrt(1-s*s) end, + + back = function(s,bounciness) + bounciness = bounciness or 1.70158 + return s*s*((bounciness+1)*s - bounciness) + end, + + bounce = function(s) -- magic numbers ahead + local a,b = 7.5625, 1/2.75 + return math.min(a*s^2, a*(s-1.5*b)^2 + .75, a*(s-2.25*b)^2 + .9375, a*(s-2.625*b)^2 + .984375) + end, + + elastic = function(s, amp, period) + amp, period = amp and math.max(1, amp) or 1, period or .3 + return (-amp * math.sin(2*math.pi/period * (s-1) - math.asin(1/amp))) * 2^(10*(s-1)) + end, +}, { + +-- register new tween +__call = function(tween, self, len, subject, target, method, after, ...) + -- recursively collects fields that are defined in both subject and target into a flat list + local function tween_collect_payload(subject, target, out) + for k,v in pairs(target) do + local ref = subject[k] + assert(type(v) == type(ref), 'Type mismatch in field "'..k..'".') + if type(v) == 'table' then + tween_collect_payload(ref, v, out) + else + local ok, delta = pcall(function() return (v-ref)*1 end) + assert(ok, 'Field "'..k..'" does not support arithmetic operations') + out[#out+1] = {subject, k, delta} + end + end + return out + end + + method = tween[method or 'linear'] -- see __index + local payload, t, args = tween_collect_payload(subject, target, {}), 0, {...} + + local last_s = 0 + return self:during(len, function(dt) + t = t + dt + local s = method(math.min(1, t/len), unpack(args)) + local ds = s - last_s + last_s = s + for _, info in ipairs(payload) do + local ref, key, delta = unpack(info) + ref[key] = ref[key] + delta * ds + end + end, after) +end, + +-- fetches function and generated compositions for method `key` +__index = function(tweens, key) + if type(key) == 'function' then return key end + + assert(type(key) == 'string', 'Method must be function or string.') + if rawget(tweens, key) then return rawget(tweens, key) end + + local function construct(pattern, f) + local method = rawget(tweens, key:match(pattern)) + if method then return f(method) end + return nil + end + + local out, chain = rawget(tweens,'out'), rawget(tweens,'chain') + return construct('^in%-([^-]+)$', function(...) return ... end) + or construct('^out%-([^-]+)$', out) + or construct('^in%-out%-([^-]+)$', function(f) return chain(f, out(f)) end) + or construct('^out%-in%-([^-]+)$', function(f) return chain(out(f), f) end) + or error('Unknown interpolation method: ' .. key) +end}) + +-- Timer instancing +function Timer.new() + return setmetatable({functions = {}, tween = Timer.tween}, Timer) +end + +return Timer