From b377c9805d117767d4ca472c4093c6eec0157c83 Mon Sep 17 00:00:00 2001 From: Mikko Ahlroth Date: Fri, 17 Oct 2014 22:47:28 +0300 Subject: [PATCH] Changed indentation to the one true style --- hump/camera.lua | 82 ++++++++-------- hump/gamestate.lua | 78 +++++++-------- hump/signal.lua | 72 +++++++------- hump/timer.lua | 222 +++++++++++++++++++++--------------------- hump/vector-light.lua | 120 +++++++++++------------ hump/vector.lua | 132 ++++++++++++------------- 6 files changed, 353 insertions(+), 353 deletions(-) diff --git a/hump/camera.lua b/hump/camera.lua index d40b823..5fe5ae9 100644 --- a/hump/camera.lua +++ b/hump/camera.lua @@ -31,87 +31,87 @@ local camera = {} camera.__index = camera local function new(x,y, zoom, rot) - x,y = x or love.graphics.getWidth()/2, y or love.graphics.getHeight()/2 - zoom = zoom or 1 - rot = rot or 0 - return setmetatable({x = x, y = y, scale = zoom, rot = rot}, camera) + x,y = x or love.graphics.getWidth()/2, y or love.graphics.getHeight()/2 + zoom = zoom or 1 + rot = rot or 0 + return setmetatable({x = x, y = y, scale = zoom, rot = rot}, camera) end function camera:lookAt(x,y) - self.x, self.y = x,y - return self + self.x, self.y = x,y + return self end function camera:move(x,y) - self.x, self.y = self.x + x, self.y + y - return self + self.x, self.y = self.x + x, self.y + y + return self end function camera:pos() - return self.x, self.y + return self.x, self.y end function camera:rotate(phi) - self.rot = self.rot + phi - return self + self.rot = self.rot + phi + return self end function camera:rotateTo(phi) - self.rot = phi - return self + self.rot = phi + return self end function camera:zoom(mul) - self.scale = self.scale * mul - return self + self.scale = self.scale * mul + return self end function camera:zoomTo(zoom) - self.scale = zoom - return self + self.scale = zoom + return self end function camera:attach() - local cx,cy = love.graphics.getWidth()/(2*self.scale), love.graphics.getHeight()/(2*self.scale) - love.graphics.push() - love.graphics.scale(self.scale) - love.graphics.translate(cx, cy) - love.graphics.rotate(self.rot) - love.graphics.translate(-self.x, -self.y) + local cx,cy = love.graphics.getWidth()/(2*self.scale), love.graphics.getHeight()/(2*self.scale) + love.graphics.push() + love.graphics.scale(self.scale) + love.graphics.translate(cx, cy) + love.graphics.rotate(self.rot) + love.graphics.translate(-self.x, -self.y) end function camera:detach() - love.graphics.pop() + love.graphics.pop() end function camera:draw(func) - self:attach() - func() - self:detach() + self:attach() + func() + self:detach() end function camera:cameraCoords(x,y) - -- x,y = ((x,y) - (self.x, self.y)):rotated(self.rot) * self.scale + center - local w,h = love.graphics.getWidth(), love.graphics.getHeight() - local c,s = cos(self.rot), sin(self.rot) - x,y = x - self.x, y - self.y - x,y = c*x - s*y, s*x + c*y - return x*self.scale + w/2, y*self.scale + h/2 + -- x,y = ((x,y) - (self.x, self.y)):rotated(self.rot) * self.scale + center + local w,h = love.graphics.getWidth(), love.graphics.getHeight() + local c,s = cos(self.rot), sin(self.rot) + x,y = x - self.x, y - self.y + x,y = c*x - s*y, s*x + c*y + return x*self.scale + w/2, y*self.scale + h/2 end function camera:worldCoords(x,y) - -- x,y = (((x,y) - center) / self.scale):rotated(-self.rot) + (self.x,self.y) - local w,h = love.graphics.getWidth(), love.graphics.getHeight() - local c,s = cos(-self.rot), sin(-self.rot) - x,y = (x - w/2) / self.scale, (y - h/2) / self.scale - x,y = c*x - s*y, s*x + c*y - return x+self.x, y+self.y + -- x,y = (((x,y) - center) / self.scale):rotated(-self.rot) + (self.x,self.y) + local w,h = love.graphics.getWidth(), love.graphics.getHeight() + local c,s = cos(-self.rot), sin(-self.rot) + x,y = (x - w/2) / self.scale, (y - h/2) / self.scale + x,y = c*x - s*y, s*x + c*y + return x+self.x, y+self.y end function camera:mousepos() - return self:worldCoords(love.mouse.getPosition()) + return self:worldCoords(love.mouse.getPosition()) end -- the module return setmetatable({new = new}, - {__call = function(_, ...) return new(...) end}) + {__call = function(_, ...) return new(...) end}) diff --git a/hump/gamestate.lua b/hump/gamestate.lua index c440180..ea7736a 100644 --- a/hump/gamestate.lua +++ b/hump/gamestate.lua @@ -28,70 +28,70 @@ local function __NULL__() end -- default gamestate produces error on every callback local state_init = setmetatable({leave = __NULL__}, - {__index = function() error("Gamestate not initialized. Use Gamestate.switch()") end}) + {__index = function() error("Gamestate not initialized. Use Gamestate.switch()") end}) local stack = {state_init} local GS = {} function GS.new(t) return t or {} end -- constructor - deprecated! function GS.switch(to, ...) - assert(to, "Missing argument: Gamestate to switch to") - assert(to ~= GS, "Can't call switch with colon operator") - local pre = stack[#stack] - ;(pre.leave or __NULL__)(pre) - ;(to.init or __NULL__)(to) - to.init = nil - stack[#stack] = to - return (to.enter or __NULL__)(to, pre, ...) + assert(to, "Missing argument: Gamestate to switch to") + assert(to ~= GS, "Can't call switch with colon operator") + local pre = stack[#stack] + ;(pre.leave or __NULL__)(pre) + ;(to.init or __NULL__)(to) + to.init = nil + stack[#stack] = to + return (to.enter or __NULL__)(to, pre, ...) end function GS.push(to, ...) - assert(to, "Missing argument: Gamestate to switch to") - assert(to ~= GS, "Can't call push with colon operator") - local pre = stack[#stack] - ;(to.init or __NULL__)(to) - to.init = nil - stack[#stack+1] = to - return (to.enter or __NULL__)(to, pre, ...) + assert(to, "Missing argument: Gamestate to switch to") + assert(to ~= GS, "Can't call push with colon operator") + local pre = stack[#stack] + ;(to.init or __NULL__)(to) + to.init = nil + stack[#stack+1] = to + return (to.enter or __NULL__)(to, pre, ...) end function GS.pop(...) - assert(#stack > 1, "No more states to pop!") - local pre = stack[#stack] - stack[#stack] = nil - ;(pre.leave or __NULL__)(pre) - return (stack[#stack].resume or __NULL__)(pre, ...) + assert(#stack > 1, "No more states to pop!") + local pre = stack[#stack] + stack[#stack] = nil + ;(pre.leave or __NULL__)(pre) + return (stack[#stack].resume or __NULL__)(pre, ...) end function GS.current() - return stack[#stack] + return stack[#stack] end local all_callbacks = { - 'draw', 'errhand', 'focus', 'keypressed', 'keyreleased', 'mousefocus', - 'mousepressed', 'mousereleased', 'quit', 'resize', 'textinput', - 'threaderror', 'update', 'visible', 'gamepadaxis', 'gamepadpressed', - 'gamepadreleased', 'joystickadded', 'joystickaxis', 'joystickhat', - 'joystickpressed', 'joystickreleased', 'joystickremoved' + 'draw', 'errhand', 'focus', 'keypressed', 'keyreleased', 'mousefocus', + 'mousepressed', 'mousereleased', 'quit', 'resize', 'textinput', + 'threaderror', 'update', 'visible', 'gamepadaxis', 'gamepadpressed', + 'gamepadreleased', 'joystickadded', 'joystickaxis', 'joystickhat', + 'joystickpressed', 'joystickreleased', 'joystickremoved' } function GS.registerEvents(callbacks) - local registry = {} - callbacks = callbacks or all_callbacks - for _, f in ipairs(callbacks) do - registry[f] = love[f] or __NULL__ - love[f] = function(...) - registry[f](...) - return GS[f](...) - end - end + local registry = {} + callbacks = callbacks or all_callbacks + for _, f in ipairs(callbacks) do + registry[f] = love[f] or __NULL__ + love[f] = function(...) + registry[f](...) + return GS[f](...) + end + end end -- forward any undefined functions setmetatable(GS, {__index = function(_, func) - return function(...) - return (stack[#stack][func] or __NULL__)(stack[#stack], ...) - end + return function(...) + return (stack[#stack][func] or __NULL__)(stack[#stack], ...) + end end}) return GS diff --git a/hump/signal.lua b/hump/signal.lua index 52b4d63..404bf67 100644 --- a/hump/signal.lua +++ b/hump/signal.lua @@ -26,68 +26,68 @@ THE SOFTWARE. local Registry = {} Registry.__index = function(self, key) - return Registry[key] or (function() - local t = {} - rawset(self, key, t) - return t - end)() + return Registry[key] or (function() + local t = {} + rawset(self, key, t) + return t + end)() end function Registry:register(s, f) - self[s][f] = f - return f + self[s][f] = f + return f end function Registry:emit(s, ...) - for f in pairs(self[s]) do - f(...) - end + for f in pairs(self[s]) do + f(...) + end end function Registry:remove(s, ...) - local f = {...} - for i = 1,select('#', ...) do - self[s][f[i]] = nil - end + local f = {...} + for i = 1,select('#', ...) do + self[s][f[i]] = nil + end end function Registry:clear(...) - local s = {...} - for i = 1,select('#', ...) do - self[s[i]] = {} - end + local s = {...} + for i = 1,select('#', ...) do + self[s[i]] = {} + end end function Registry:emit_pattern(p, ...) - for s in pairs(self) do - if s:match(p) then self:emit(s, ...) end - end + for s in pairs(self) do + if s:match(p) then self:emit(s, ...) end + end end function Registry:remove_pattern(p, ...) - for s in pairs(self) do - if s:match(p) then self:remove(s, ...) end - end + for s in pairs(self) do + if s:match(p) then self:remove(s, ...) end + end end function Registry:clear_pattern(p) - for s in pairs(self) do - if s:match(p) then self[s] = {} end - end + for s in pairs(self) do + if s:match(p) then self[s] = {} end + end end local function new() - return setmetatable({}, Registry) + return setmetatable({}, Registry) end local default = new() return setmetatable({ - new = new, - register = function(...) return default:register(...) end, - emit = function(...) default:emit(...) end, - remove = function(...) default:remove(...) end, - clear = function(...) default:clear(...) end, - emit_pattern = function(...) default:emit_pattern(...) end, - remove_pattern = function(...) default:remove_pattern(...) end, - clear_pattern = function(...) default:clear_pattern(...) end, + new = new, + register = function(...) return default:register(...) end, + emit = function(...) default:emit(...) end, + remove = function(...) default:remove(...) end, + clear = function(...) default:clear(...) end, + emit_pattern = function(...) default:emit_pattern(...) end, + remove_pattern = function(...) default:remove_pattern(...) end, + clear_pattern = function(...) default:clear_pattern(...) end, }, {__call = new}) diff --git a/hump/timer.lua b/hump/timer.lua index 7cb8ff6..db1a681 100644 --- a/hump/timer.lua +++ b/hump/timer.lua @@ -30,144 +30,144 @@ Timer.__index = Timer local function _nothing_() end local function new() - return setmetatable({functions = {}, tween = Timer.tween}, Timer) + return setmetatable({functions = {}, tween = Timer.tween}, Timer) end function Timer:update(dt) - local to_remove = {} - for handle, delay in pairs(self.functions) do - delay = delay - dt - if delay <= 0 then - to_remove[#to_remove+1] = handle - end - self.functions[handle] = delay - handle.func(dt, delay) - end - for _,handle in ipairs(to_remove) do - self.functions[handle] = nil - handle.after(handle.after) - end + local to_remove = {} + for handle, delay in pairs(self.functions) do + delay = delay - dt + if delay <= 0 then + to_remove[#to_remove+1] = handle + end + self.functions[handle] = delay + handle.func(dt, delay) + end + for _,handle in ipairs(to_remove) do + self.functions[handle] = nil + handle.after(handle.after) + end end function Timer:do_for(delay, func, after) - local handle = {func = func, after = after or _nothing_} - self.functions[handle] = delay - return handle + local handle = {func = func, after = after or _nothing_} + self.functions[handle] = delay + return handle end function Timer:add(delay, func) - return self:do_for(delay, _nothing_, func) + return self:do_for(delay, _nothing_, func) end function Timer:addPeriodic(delay, func, count) - local count, handle = count or math.huge -- exploit below: math.huge - 1 = math.huge + local count, handle = count or math.huge -- exploit below: math.huge - 1 = math.huge - handle = self:add(delay, function(f) - if func(func) == false then return end - count = count - 1 - if count > 0 then - self.functions[handle] = delay - end - end) - return handle + handle = self:add(delay, function(f) + if func(func) == false then return end + count = count - 1 + if count > 0 then + self.functions[handle] = delay + end + end) + return handle end function Timer:cancel(handle) - self.functions[handle] = nil + self.functions[handle] = nil end function Timer:clear() - self.functions = {} + self.functions = {} 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, + -- 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, + -- 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, + 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, + 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, + 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 + -- 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, {...} + method = tween[method or 'linear'] -- see __index + local payload, t, args = tween_collect_payload(subject, target, {}), 0, {...} - local last_s = 0 - return self:do_for(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) + local last_s = 0 + return self:do_for(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 + 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 + 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 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) + 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}) -- default timer @@ -175,16 +175,16 @@ local default = new() -- the module return setmetatable({ - new = new, - update = function(...) return default:update(...) end, - do_for = function(...) return default:do_for(...) end, - add = function(...) return default:add(...) end, - addPeriodic = function(...) return default:addPeriodic(...) end, - cancel = function(...) return default:cancel(...) end, - clear = function(...) return default:clear(...) end, - tween = setmetatable({}, { - __index = Timer.tween, - __newindex = function(_,k,v) Timer.tween[k] = v end, - __call = function(t,...) return default:tween(...) end, - }) + new = new, + update = function(...) return default:update(...) end, + do_for = function(...) return default:do_for(...) end, + add = function(...) return default:add(...) end, + addPeriodic = function(...) return default:addPeriodic(...) end, + cancel = function(...) return default:cancel(...) end, + clear = function(...) return default:clear(...) end, + tween = setmetatable({}, { + __index = Timer.tween, + __newindex = function(_,k,v) Timer.tween[k] = v end, + __call = function(t,...) return default:tween(...) end, + }) }, {__call = new}) diff --git a/hump/vector-light.lua b/hump/vector-light.lua index 962c2c4..f621a86 100644 --- a/hump/vector-light.lua +++ b/hump/vector-light.lua @@ -27,135 +27,135 @@ THE SOFTWARE. local sqrt, cos, sin, atan2 = math.sqrt, math.cos, math.sin, math.atan2 local function str(x,y) - return "("..tonumber(x)..","..tonumber(y)..")" + return "("..tonumber(x)..","..tonumber(y)..")" end local function mul(s, x,y) - return s*x, s*y + return s*x, s*y end local function div(s, x,y) - return x/s, y/s + return x/s, y/s end local function add(x1,y1, x2,y2) - return x1+x2, y1+y2 + return x1+x2, y1+y2 end local function sub(x1,y1, x2,y2) - return x1-x2, y1-y2 + return x1-x2, y1-y2 end local function permul(x1,y1, x2,y2) - return x1*x2, y1*y2 + return x1*x2, y1*y2 end local function dot(x1,y1, x2,y2) - return x1*x2 + y1*y2 + return x1*x2 + y1*y2 end local function det(x1,y1, x2,y2) - return x1*y2 - y1*x2 + return x1*y2 - y1*x2 end local function eq(x1,y1, x2,y2) - return x1 == x2 and y1 == y2 + return x1 == x2 and y1 == y2 end local function lt(x1,y1, x2,y2) - return x1 < x2 or (x1 == x2 and y1 < y2) + return x1 < x2 or (x1 == x2 and y1 < y2) end local function le(x1,y1, x2,y2) - return x1 <= x2 and y1 <= y2 + return x1 <= x2 and y1 <= y2 end local function len2(x,y) - return x*x + y*y + return x*x + y*y end local function len(x,y) - return sqrt(x*x + y*y) + return sqrt(x*x + y*y) end local function dist2(x1,y1, x2,y2) - return len2(x1-x2, y1-y2) + return len2(x1-x2, y1-y2) end local function dist(x1,y1, x2,y2) - return len(x1-x2, y1-y2) + return len(x1-x2, y1-y2) end local function normalize(x,y) - local l = len(x,y) - if l > 0 then - return x/l, y/l - end - return x,y + local l = len(x,y) + if l > 0 then + return x/l, y/l + end + return x,y end local function rotate(phi, x,y) - local c, s = cos(phi), sin(phi) - return c*x - s*y, s*x + c*y + local c, s = cos(phi), sin(phi) + return c*x - s*y, s*x + c*y end local function perpendicular(x,y) - return -y, x + return -y, x end local function project(x,y, u,v) - local s = (x*u + y*v) / (u*u + v*v) - return s*u, s*v + local s = (x*u + y*v) / (u*u + v*v) + return s*u, s*v end local function mirror(x,y, u,v) - local s = 2 * (x*u + y*v) / (u*u + v*v) - return s*u - x, s*v - y + local s = 2 * (x*u + y*v) / (u*u + v*v) + return s*u - x, s*v - y end -- ref.: http://blog.signalsondisplay.com/?p=336 local function trim(maxLen, x, y) - local s = maxLen * maxLen / len2(x, y) - s = s > 1 and 1 or math.sqrt(s) - return x * s, y * s + local s = maxLen * maxLen / len2(x, y) + s = s > 1 and 1 or math.sqrt(s) + return x * s, y * s end local function angleTo(x,y, u,v) - if u and v then - return atan2(y, x) - atan2(v, u) - end - return atan2(y, x) + if u and v then + return atan2(y, x) - atan2(v, u) + end + return atan2(y, x) end -- the module return { - str = str, + str = str, - -- arithmetic - mul = mul, - div = div, - add = add, - sub = sub, - permul = permul, - dot = dot, - det = det, - cross = det, + -- arithmetic + mul = mul, + div = div, + add = add, + sub = sub, + permul = permul, + dot = dot, + det = det, + cross = det, - -- relation - eq = eq, - lt = lt, - le = le, + -- relation + eq = eq, + lt = lt, + le = le, - -- misc operations - len2 = len2, - len = len, - dist2 = dist2, - dist = dist, - normalize = normalize, - rotate = rotate, - perpendicular = perpendicular, - project = project, - mirror = mirror, - trim = trim, - angleTo = angleTo, + -- misc operations + len2 = len2, + len = len, + dist2 = dist2, + dist = dist, + normalize = normalize, + rotate = rotate, + perpendicular = perpendicular, + project = project, + mirror = mirror, + trim = trim, + angleTo = angleTo, } diff --git a/hump/vector.lua b/hump/vector.lua index 9abdf34..fb8b131 100644 --- a/hump/vector.lua +++ b/hump/vector.lua @@ -31,158 +31,158 @@ local vector = {} vector.__index = vector local function new(x,y) - return setmetatable({x = x or 0, y = y or 0}, vector) + return setmetatable({x = x or 0, y = y or 0}, vector) end local zero = new(0,0) local function isvector(v) - return type(v) == 'table' and type(v.x) == 'number' and type(v.y) == 'number' + return type(v) == 'table' and type(v.x) == 'number' and type(v.y) == 'number' end function vector:clone() - return new(self.x, self.y) + return new(self.x, self.y) end function vector:unpack() - return self.x, self.y + return self.x, self.y end function vector:__tostring() - return "("..tonumber(self.x)..","..tonumber(self.y)..")" + return "("..tonumber(self.x)..","..tonumber(self.y)..")" end function vector.__unm(a) - return new(-a.x, -a.y) + return new(-a.x, -a.y) end function vector.__add(a,b) - assert(isvector(a) and isvector(b), "Add: wrong argument types ( expected)") - return new(a.x+b.x, a.y+b.y) + assert(isvector(a) and isvector(b), "Add: wrong argument types ( expected)") + return new(a.x+b.x, a.y+b.y) end function vector.__sub(a,b) - assert(isvector(a) and isvector(b), "Sub: wrong argument types ( expected)") - return new(a.x-b.x, a.y-b.y) + assert(isvector(a) and isvector(b), "Sub: wrong argument types ( expected)") + return new(a.x-b.x, a.y-b.y) end function vector.__mul(a,b) - if type(a) == "number" then - return new(a*b.x, a*b.y) - elseif type(b) == "number" then - return new(b*a.x, b*a.y) - else - assert(isvector(a) and isvector(b), "Mul: wrong argument types ( or expected)") - return a.x*b.x + a.y*b.y - end + if type(a) == "number" then + return new(a*b.x, a*b.y) + elseif type(b) == "number" then + return new(b*a.x, b*a.y) + else + assert(isvector(a) and isvector(b), "Mul: wrong argument types ( or expected)") + return a.x*b.x + a.y*b.y + end end function vector.__div(a,b) - assert(isvector(a) and type(b) == "number", "wrong argument types (expected / )") - return new(a.x / b, a.y / b) + assert(isvector(a) and type(b) == "number", "wrong argument types (expected / )") + return new(a.x / b, a.y / b) end function vector.__eq(a,b) - return a.x == b.x and a.y == b.y + return a.x == b.x and a.y == b.y end function vector.__lt(a,b) - return a.x < b.x or (a.x == b.x and a.y < b.y) + return a.x < b.x or (a.x == b.x and a.y < b.y) end function vector.__le(a,b) - return a.x <= b.x and a.y <= b.y + return a.x <= b.x and a.y <= b.y end function vector.permul(a,b) - assert(isvector(a) and isvector(b), "permul: wrong argument types ( expected)") - return new(a.x*b.x, a.y*b.y) + assert(isvector(a) and isvector(b), "permul: wrong argument types ( expected)") + return new(a.x*b.x, a.y*b.y) end function vector:len2() - return self.x * self.x + self.y * self.y + return self.x * self.x + self.y * self.y end function vector:len() - return sqrt(self.x * self.x + self.y * self.y) + return sqrt(self.x * self.x + self.y * self.y) end function vector.dist(a, b) - assert(isvector(a) and isvector(b), "dist: wrong argument types ( expected)") - local dx = a.x - b.x - local dy = a.y - b.y - return sqrt(dx * dx + dy * dy) + assert(isvector(a) and isvector(b), "dist: wrong argument types ( expected)") + local dx = a.x - b.x + local dy = a.y - b.y + return sqrt(dx * dx + dy * dy) end function vector.dist2(a, b) - assert(isvector(a) and isvector(b), "dist: wrong argument types ( expected)") - local dx = a.x - b.x - local dy = a.y - b.y - return (dx * dx + dy * dy) + assert(isvector(a) and isvector(b), "dist: wrong argument types ( expected)") + local dx = a.x - b.x + local dy = a.y - b.y + return (dx * dx + dy * dy) end function vector:normalize_inplace() - local l = self:len() - if l > 0 then - self.x, self.y = self.x / l, self.y / l - end - return self + local l = self:len() + if l > 0 then + self.x, self.y = self.x / l, self.y / l + end + return self end function vector:normalized() - return self:clone():normalize_inplace() + return self:clone():normalize_inplace() end function vector:rotate_inplace(phi) - local c, s = cos(phi), sin(phi) - self.x, self.y = c * self.x - s * self.y, s * self.x + c * self.y - return self + local c, s = cos(phi), sin(phi) + self.x, self.y = c * self.x - s * self.y, s * self.x + c * self.y + return self end function vector:rotated(phi) - local c, s = cos(phi), sin(phi) - return new(c * self.x - s * self.y, s * self.x + c * self.y) + local c, s = cos(phi), sin(phi) + return new(c * self.x - s * self.y, s * self.x + c * self.y) end function vector:perpendicular() - return new(-self.y, self.x) + return new(-self.y, self.x) end function vector:projectOn(v) - assert(isvector(v), "invalid argument: cannot project vector on " .. type(v)) - -- (self * v) * v / v:len2() - local s = (self.x * v.x + self.y * v.y) / (v.x * v.x + v.y * v.y) - return new(s * v.x, s * v.y) + assert(isvector(v), "invalid argument: cannot project vector on " .. type(v)) + -- (self * v) * v / v:len2() + local s = (self.x * v.x + self.y * v.y) / (v.x * v.x + v.y * v.y) + return new(s * v.x, s * v.y) end function vector:mirrorOn(v) - assert(isvector(v), "invalid argument: cannot mirror vector on " .. type(v)) - -- 2 * self:projectOn(v) - self - local s = 2 * (self.x * v.x + self.y * v.y) / (v.x * v.x + v.y * v.y) - return new(s * v.x - self.x, s * v.y - self.y) + assert(isvector(v), "invalid argument: cannot mirror vector on " .. type(v)) + -- 2 * self:projectOn(v) - self + local s = 2 * (self.x * v.x + self.y * v.y) / (v.x * v.x + v.y * v.y) + return new(s * v.x - self.x, s * v.y - self.y) end function vector:cross(v) - assert(isvector(v), "cross: wrong argument types ( expected)") - return self.x * v.y - self.y * v.x + assert(isvector(v), "cross: wrong argument types ( expected)") + return self.x * v.y - self.y * v.x end -- ref.: http://blog.signalsondisplay.com/?p=336 function vector:trim_inplace(maxLen) - local s = maxLen * maxLen / self:len2() - s = (s > 1 and 1) or math.sqrt(s) - self.x, self.y = self.x * s, self.y * s - return self + local s = maxLen * maxLen / self:len2() + s = (s > 1 and 1) or math.sqrt(s) + self.x, self.y = self.x * s, self.y * s + return self end function vector:angleTo(other) - if other then - return atan2(self.y, self.x) - atan2(other.y, other.x) - end - return atan2(self.y, self.x) + if other then + return atan2(self.y, self.x) - atan2(other.y, other.x) + end + return atan2(self.y, self.x) end function vector:trimmed(maxLen) - return self:clone():trim_inplace(maxLen) + return self:clone():trim_inplace(maxLen) end