diff options
| -rw-r--r-- | .gitignore | 1 | ||||
| -rw-r--r-- | conf.lua | 6 | ||||
| -rw-r--r-- | lib/cell.fnl | 10 | ||||
| -rw-r--r-- | lib/cells.fnl | 67 | ||||
| -rw-r--r-- | lib/game.fnl | 109 | ||||
| -rw-r--r-- | lib/main.fnl | 69 | ||||
| -rw-r--r-- | lib/proto.fnl | 78 | ||||
| -rw-r--r-- | lib/state.fnl | 19 | ||||
| -rw-r--r-- | main.lua | 3 | ||||
| -rw-r--r-- | vendor/lume.lua | 780 |
10 files changed, 1142 insertions, 0 deletions
diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..a941931 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +junk diff --git a/conf.lua b/conf.lua new file mode 100644 index 0000000..479acb1 --- /dev/null +++ b/conf.lua @@ -0,0 +1,6 @@ +function love.conf(t) + t.window.resizable = true + t.window.title = "GAMING" + t.window.vsync = 1 + t.window.msaa = 1 +end diff --git a/lib/cell.fnl b/lib/cell.fnl new file mode 100644 index 0000000..e9af960 --- /dev/null +++ b/lib/cell.fnl @@ -0,0 +1,10 @@ +(local proto (require :lib.proto)) + +{:init (proto.table-method :cell.init) + ;; given its 8 neighbors returns a new cell (or nil) + ;; TODO: other returns via either a clojure or coroutines + :birth (proto.meta-method :cell.birth) + :update (proto.meta-method :cell.update) + ;; returns a number from 0 to 1 + :aliveness (proto.meta-method-opt :cell.generation #0) + :color (proto.meta-method-opt :cell.color #[0 0 0])} diff --git a/lib/cells.fnl b/lib/cells.fnl new file mode 100644 index 0000000..442c7c7 --- /dev/null +++ b/lib/cells.fnl @@ -0,0 +1,67 @@ +(local cell (require :lib.cell)) + +(local neighbors [{:x -1 :y -1} + {:x -1 :y 0} + {:x -1 :y 1} + {:x 0 :y -1} + {:x 0 :y 1} + {:x 1 :y -1} + {:x 1 :y 0} + {:x 1 :y 1}]) + +(fn neighbors> [f threshold] + (var x 0) + ;; nnn this could be faster maybe + (each [k v (ipairs neighbors)] + (when (> (cell.aliveness (f v)) threshold) + (set x (+ x 1)))) + x) + +(local life + {cell.init + (fn [self] + (setmetatable {} self)) + cell.birth + (fn [self get] + (if (= (neighbors> get 0) 3) + self + nil)) + cell.update + (fn [self get] + (if (or (= (neighbors> get 0) 3) + (= (neighbors> get 0) 2)) + self + nil)) + cell.aliveness + #1 + cell.color + #[0.4 0.4 0.7] + }) + +(local brain + {cell.init + (fn [self] + (setmetatable {:stage 0} self)) + cell.birth + (fn [self get] + (if (= (neighbors> get 0.8) 2) + (do + (setmetatable {:stage 0} (getmetatable self))) + nil)) + cell.update + (fn [self get] + (if (= self.stage 0) + (setmetatable {:stage 1} (getmetatable self)) + nil)) + cell.aliveness + #(- 1 (* 0.5 $.stage)) + cell.color + #(if (= $.stage 0) + [0.7 0.4 0.3] + (= $.stage 5) + [0.5 0.4 0.3] + (= $.stage 1) + [0.2 0.2 0.3]) + }) + +{: life : brain} diff --git a/lib/game.fnl b/lib/game.fnl new file mode 100644 index 0000000..da96d9f --- /dev/null +++ b/lib/game.fnl @@ -0,0 +1,109 @@ +(local state (require :lib.state)) +(local cell (require :lib.cell)) +(local cells (require :lib.cells)) +(local fv (require :fennel.view)) + +(fn lerp* [a b c d x] + (+ c (* (/ (- x a) (- b a)) (- d c)))) + +(fn vec-lerp* [a b c d x] + {:x (lerp* a.x b.x c.x d.x x.x) + :y (lerp* a.y b.y c.y d.y x.y)}) + +(fn new-grid [w h f] + (var t {}) + (for [x 0 (- w 1)] + (tset t x {}) + (for [y 0 (- h 1)] + (tset (. t x) y (f x y)))) + t) + +(fn update [self] + (set self.ship.x (+ self.ship.x 0.02)) + (set self.ship.y (+ self.ship.y 0.005)) + (when (= self.tick 0) + (for [x 0 (- self.width 1)] + (for [y 0 (- self.height 1)] + (fn get [v] + (. self.grid + (% (+ v.x x) self.width) + (% (+ v.y y) self.height))) + (if (. self.grid x y) + ;; check if alive + (tset self.grid-alt x y (cell.update (. self.grid x y) + get)) + ;; check for neighbors and then use one at random + (do + (var neighbors []) + (for [x -1 1] + (for [y -1 1] + (table.insert neighbors (get {: x : y})))) + (if (. neighbors 1) + (tset self.grid-alt x y + (cell.birth (. neighbors (math.random (length neighbors))) get)) + (tset self.grid-alt x y nil)))))) + (set (self.grid self.grid-alt) (values self.grid-alt self.grid))) + ;; TODO + (set self.tick (% (+ self.tick 1) self.rate))) + +(fn id [x] x) + +(fn draw [self] + (local (width height) (love.graphics.getDimensions)) + (love.graphics.scale width height) + (local camera-size (math.max width height)) + (let [camera-size (math.max width height) + camera-box {:x width :y height} + camera-box {:x 1 :y 1} + radius-x (* self.radius (/ width camera-size)) + radius-y (* self.radius (/ height camera-size)) + camera-a {:x (- self.ship.x radius-x) + :y (- self.ship.y radius-y)} + camera-b {:x (+ self.ship.x radius-x) + :y (+ self.ship.y radius-y)} + cell-box (vec-lerp* {:x 0 :y 0} + {:x (* 2 radius-x) + :y (* 2 radius-y)} + {:x 0 :y 0} + camera-box + {:x 1 :y 1})] + (for [x (math.floor camera-a.x) (math.floor camera-b.x)] + (for [y (math.floor camera-a.y) (math.floor camera-b.y)] + (let [vec {:x (% x self.width) :y (% y self.height)} + render-a (vec-lerp* camera-a camera-b {:x 0 :y 0} camera-box + {: x : y}) + render-b (vec-lerp* camera-a camera-b {:x 0 :y 0} camera-box + {:x (+ x 1) :y (+ y 1)}) + the (. self.grid vec.x vec.y) + color (and the (cell.color the))] + (when color + (love.graphics.setColor (unpack color)) + (love.graphics.rectangle :fill + (id render-a.x) + (id render-a.y) + (id cell-box.x) + (id cell-box.y)))))))) + ;; (love.graphics.setLineWidth 0.1) + ;; (love.graphics.line 0 0 0.3 0.3) + ;; (love.graphics.polygon :line 0.3 0.3 0.6 0.3 0.4 0.6) + ;; (love.graphics.line 0.4 0.8 0.4 0.8) + ;; (love.graphics.print :Gaming)) + +(fn init [self] + (setmetatable + {:width 64 + :height 64 + :ship {:x 31 :y 31} + :radius 32 + :tick 0 + :rate 6 + :grid (new-grid 64 64 #(if (= (math.random 6) 1) + (if (< $1 52) + (cell.init cells.life) + (cell.init cells.brain)) + nil)) + :grid-alt (new-grid 64 64 #nil) + } + self)) + +{state.draw draw state.init init state.update update} diff --git a/lib/main.fnl b/lib/main.fnl new file mode 100644 index 0000000..4a9d26e --- /dev/null +++ b/lib/main.fnl @@ -0,0 +1,69 @@ +(local lume (require :vendor.lume)) +(local proto (require :lib.proto)) +(local state (require :lib.state)) +(local game (require :lib.game)) + +;; i am thinking we could actually do a really hacky thing (modules add themselves +;; to this list) with this later but +;; i'm not sure if it'd be worth it (it'd require those dependency loops maybe) +;; TODO: ^ +(local hotswap-modules + [:lib.cells + :lib.game + :lib.main]) + +;; the +;; oh thats why it doesnt work lmao + +(fn love.load [] + (global the-state (state.init game)) + (global messages {}) + (print "a")) + +(fn love.draw [] + (match (pcall #(state.draw the-state)) + (true x) nil + (false x) (do + (love.graphics.reset) + (print (.. "draw \n" x)) + (love.graphics.print (.. "draw: \n" x)))) + (love.graphics.reset) + (love.graphics.print (love.timer.getFPS)) + (when true ;; debug stuff + (love.graphics.print (table.concat + (lume.map messages #$.msg) + "\n") + 0 + 40) + (each [i v (lume.ripairs messages)] + (if (= v.ticks 0) + (table.remove messages i) + (set v.ticks (- v.ticks 1)))))) + +;; TODO: we need a better way to display errors at runtime for updates too +(fn love.update [] + ;; TODO: make state changes actually possible + (match (pcall #(state.update the-state)) + (true x) nil + (false x) (do + (print (.. "update: \n" x)) + (table.insert messages + {:ticks 1 + :msg (.. "update: \n" x)})))) + +(fn love.keypressed [key scancode repeat] + ;; (print key scancode repeat) + (when (= key "r") + (each [k v (lume.ripairs messages)] + (when (= v.type :reload-error) + (table.remove messages k))) + (print (.. (if (love.keyboard.isDown :lshift) :hard :soft) + " reloading...")) + (each [_ v (ipairs hotswap-modules)] + (match (lume.hotswap v) + (nil x) (table.insert messages + {:ticks -1 + :type :reload-error + :msg (.. "can't reload module " v "\n" x)}))) + (when (love.keyboard.isDown :lshift) + (love.load)))) diff --git a/lib/proto.fnl b/lib/proto.fnl new file mode 100644 index 0000000..13b65e9 --- /dev/null +++ b/lib/proto.fnl @@ -0,0 +1,78 @@ +;; function set in the prototype via its identity, i.e. +;; (local blah (meta-fn :blah) +;; (blah (setmetadata {} {blah (fn [] 4)})) ;; -> 4 +(fn meta-fn [name] + (local x {}) + (setmetatable + x + {:__call (fn [_ obj ...] ((. (getmetatable obj) x) ...)) + :__name name + :__fennelview (fn [] [name])})) + +(fn meta-method [name] + (local x {}) + (setmetatable + x + {:__call (fn [_ obj ...] ((. (getmetatable obj) x) obj ...)) + :__name name + :__fennelview (fn [] [name])})) + +;; function set in the prototype via its identity, i.e. +;; (local blah (meta-fn :blah) +;; however, these functions are optional, and nop if left out +;; (blah (setmetadata {} {})) ;; -> nil +(fn meta-fn-opt [name fallback] + (local x {}) + (setmetatable + x + {:__call (fn [_ obj ...] (if (and (getmetatable obj) + (. (getmetatable obj) x)) + ((. (getmetatable obj) x) ...) + fallback + (fallback ...) + nil)) + :__name name + :__fennelview (fn [] [name])})) + +(fn meta-method-opt [name fallback] + (local x {}) + (setmetatable + x + {:__call (fn [_ obj ...] (if (and (getmetatable obj) + (. (getmetatable obj) x)) + ((. (getmetatable obj) x) obj ...) + fallback + (fallback obj ...) + nil)) + :__name name + :__fennelview (fn [] [name])})) + +;; value set in the table via its identity, i.e. +;; (local blah (table-value :blah)) +;; (blah {blah 4}) ;; -> (. {blah 4} blah) -> 4 +(fn table-value [name] + (local x {}) + (setmetatable + x + {:__call (fn [_ obj ...] (. obj x)) + :__name name + :__fennelview (fn [] [name])})) + +(fn table-fn [name] + (local x {}) + (setmetatable + x + {:__call (fn [_ obj ...] ((. obj x) ...)) + :__name name + :__fennelview (fn [] [name])})) + +;; methods have an extra "self" param +(fn table-method [name] + (local x {}) + (setmetatable + x + {:__call (fn [_ obj ...] ((. obj x) obj ...)) + :__name name + :__fennelview (fn [] [name])})) + +{: meta-fn : meta-fn-opt : meta-method : meta-method-opt : table-value : table-fn : table-method} diff --git a/lib/state.fnl b/lib/state.fnl new file mode 100644 index 0000000..d98b94e --- /dev/null +++ b/lib/state.fnl @@ -0,0 +1,19 @@ +;; later if it becomes a hassle we can convert this into a separate +;; file that we can reload or something + +(local proto (require :lib.proto)) + +{ + :init (proto.table-method :state.init) + ;; update is a bit special; it can either return nothing (the state continues + ;; as is, and mutated somehow (sorry we're doing things non-purely; i'd like + ;; to do them purely but creating tables is slow as heck that'd be ridiculous)) + ;; or it can return a state that it transitions to automatically + ;; game pausing basically works like that: it returns a pause structure with the + ;; regular state within its object, and then the pause structure uses that state + ;; object to return back to it later. pretty cool! + :update (proto.meta-method-opt :state.update) + ;; all of the next functions are just. regular love functions, exactly the same + ;; i hope + :draw (proto.meta-method-opt :state.draw) + } diff --git a/main.lua b/main.lua new file mode 100644 index 0000000..d9b84cb --- /dev/null +++ b/main.lua @@ -0,0 +1,3 @@ +table.insert(package.loaders or package.searchers, require("fennel").makeSearcher({correlate = true})) + +require("lib/main") diff --git a/vendor/lume.lua b/vendor/lume.lua new file mode 100644 index 0000000..2157891 --- /dev/null +++ b/vendor/lume.lua @@ -0,0 +1,780 @@ +-- +-- lume +-- +-- Copyright (c) 2020 rxi +-- +-- 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. +-- +-- 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. +-- + +local lume = { _version = "2.3.0" } + +local pairs, ipairs = pairs, ipairs +local type, assert, unpack = type, assert, unpack or table.unpack +local tostring, tonumber = tostring, tonumber +local math_floor = math.floor +local math_ceil = math.ceil +local math_atan2 = math.atan2 or math.atan +local math_sqrt = math.sqrt +local math_abs = math.abs + +local noop = function() +end + +local identity = function(x) + return x +end + +local patternescape = function(str) + return str:gsub("[%(%)%.%%%+%-%*%?%[%]%^%$]", "%%%1") +end + +local absindex = function(len, i) + return i < 0 and (len + i + 1) or i +end + +local iscallable = function(x) + if type(x) == "function" then return true end + local mt = getmetatable(x) + return mt and mt.__call ~= nil +end + +local getiter = function(x) + if lume.isarray(x) then + return ipairs + elseif type(x) == "table" then + return pairs + end + error("expected table", 3) +end + +local iteratee = function(x) + if x == nil then return identity end + if iscallable(x) then return x end + if type(x) == "table" then + return function(z) + for k, v in pairs(x) do + if z[k] ~= v then return false end + end + return true + end + end + return function(z) return z[x] end +end + + + +function lume.clamp(x, min, max) + return x < min and min or (x > max and max or x) +end + + +function lume.round(x, increment) + if increment then return lume.round(x / increment) * increment end + return x >= 0 and math_floor(x + .5) or math_ceil(x - .5) +end + + +function lume.sign(x) + return x < 0 and -1 or 1 +end + + +function lume.lerp(a, b, amount) + return a + (b - a) * lume.clamp(amount, 0, 1) +end + + +function lume.smooth(a, b, amount) + local t = lume.clamp(amount, 0, 1) + local m = t * t * (3 - 2 * t) + return a + (b - a) * m +end + + +function lume.pingpong(x) + return 1 - math_abs(1 - x % 2) +end + + +function lume.distance(x1, y1, x2, y2, squared) + local dx = x1 - x2 + local dy = y1 - y2 + local s = dx * dx + dy * dy + return squared and s or math_sqrt(s) +end + + +function lume.angle(x1, y1, x2, y2) + return math_atan2(y2 - y1, x2 - x1) +end + + +function lume.vector(angle, magnitude) + return math.cos(angle) * magnitude, math.sin(angle) * magnitude +end + + +function lume.random(a, b) + if not a then a, b = 0, 1 end + if not b then b = 0 end + return a + math.random() * (b - a) +end + + +function lume.randomchoice(t) + return t[math.random(#t)] +end + + +function lume.weightedchoice(t) + local sum = 0 + for _, v in pairs(t) do + assert(v >= 0, "weight value less than zero") + sum = sum + v + end + assert(sum ~= 0, "all weights are zero") + local rnd = lume.random(sum) + for k, v in pairs(t) do + if rnd < v then return k end + rnd = rnd - v + end +end + + +function lume.isarray(x) + return type(x) == "table" and x[1] ~= nil +end + + +function lume.push(t, ...) + local n = select("#", ...) + for i = 1, n do + t[#t + 1] = select(i, ...) + end + return ... +end + + +function lume.remove(t, x) + local iter = getiter(t) + for i, v in iter(t) do + if v == x then + if lume.isarray(t) then + table.remove(t, i) + break + else + t[i] = nil + break + end + end + end + return x +end + + +function lume.clear(t) + local iter = getiter(t) + for k in iter(t) do + t[k] = nil + end + return t +end + + +function lume.extend(t, ...) + for i = 1, select("#", ...) do + local x = select(i, ...) + if x then + for k, v in pairs(x) do + t[k] = v + end + end + end + return t +end + + +function lume.shuffle(t) + local rtn = {} + for i = 1, #t do + local r = math.random(i) + if r ~= i then + rtn[i] = rtn[r] + end + rtn[r] = t[i] + end + return rtn +end + + +function lume.sort(t, comp) + local rtn = lume.clone(t) + if comp then + if type(comp) == "string" then + table.sort(rtn, function(a, b) return a[comp] < b[comp] end) + else + table.sort(rtn, comp) + end + else + table.sort(rtn) + end + return rtn +end + + +function lume.array(...) + local t = {} + for x in ... do t[#t + 1] = x end + return t +end + + +function lume.each(t, fn, ...) + local iter = getiter(t) + if type(fn) == "string" then + for _, v in iter(t) do v[fn](v, ...) end + else + for _, v in iter(t) do fn(v, ...) end + end + return t +end + + +function lume.map(t, fn) + fn = iteratee(fn) + local iter = getiter(t) + local rtn = {} + for k, v in iter(t) do rtn[k] = fn(v) end + return rtn +end + + +function lume.all(t, fn) + fn = iteratee(fn) + local iter = getiter(t) + for _, v in iter(t) do + if not fn(v) then return false end + end + return true +end + + +function lume.any(t, fn) + fn = iteratee(fn) + local iter = getiter(t) + for _, v in iter(t) do + if fn(v) then return true end + end + return false +end + + +function lume.reduce(t, fn, first) + local started = first ~= nil + local acc = first + local iter = getiter(t) + for _, v in iter(t) do + if started then + acc = fn(acc, v) + else + acc = v + started = true + end + end + assert(started, "reduce of an empty table with no first value") + return acc +end + + +function lume.unique(t) + local rtn = {} + for k in pairs(lume.invert(t)) do + rtn[#rtn + 1] = k + end + return rtn +end + + +function lume.filter(t, fn, retainkeys) + fn = iteratee(fn) + local iter = getiter(t) + local rtn = {} + if retainkeys then + for k, v in iter(t) do + if fn(v) then rtn[k] = v end + end + else + for _, v in iter(t) do + if fn(v) then rtn[#rtn + 1] = v end + end + end + return rtn +end + + +function lume.reject(t, fn, retainkeys) + fn = iteratee(fn) + local iter = getiter(t) + local rtn = {} + if retainkeys then + for k, v in iter(t) do + if not fn(v) then rtn[k] = v end + end + else + for _, v in iter(t) do + if not fn(v) then rtn[#rtn + 1] = v end + end + end + return rtn +end + + +function lume.merge(...) + local rtn = {} + for i = 1, select("#", ...) do + local t = select(i, ...) + local iter = getiter(t) + for k, v in iter(t) do + rtn[k] = v + end + end + return rtn +end + + +function lume.concat(...) + local rtn = {} + for i = 1, select("#", ...) do + local t = select(i, ...) + if t ~= nil then + local iter = getiter(t) + for _, v in iter(t) do + rtn[#rtn + 1] = v + end + end + end + return rtn +end + + +function lume.find(t, value) + local iter = getiter(t) + for k, v in iter(t) do + if v == value then return k end + end + return nil +end + + +function lume.match(t, fn) + fn = iteratee(fn) + local iter = getiter(t) + for k, v in iter(t) do + if fn(v) then return v, k end + end + return nil +end + + +function lume.count(t, fn) + local count = 0 + local iter = getiter(t) + if fn then + fn = iteratee(fn) + for _, v in iter(t) do + if fn(v) then count = count + 1 end + end + else + if lume.isarray(t) then + return #t + end + for _ in iter(t) do count = count + 1 end + end + return count +end + + +function lume.slice(t, i, j) + i = i and absindex(#t, i) or 1 + j = j and absindex(#t, j) or #t + local rtn = {} + for x = i < 1 and 1 or i, j > #t and #t or j do + rtn[#rtn + 1] = t[x] + end + return rtn +end + + +function lume.first(t, n) + if not n then return t[1] end + return lume.slice(t, 1, n) +end + + +function lume.last(t, n) + if not n then return t[#t] end + return lume.slice(t, -n, -1) +end + + +function lume.invert(t) + local rtn = {} + for k, v in pairs(t) do rtn[v] = k end + return rtn +end + + +function lume.pick(t, ...) + local rtn = {} + for i = 1, select("#", ...) do + local k = select(i, ...) + rtn[k] = t[k] + end + return rtn +end + + +function lume.keys(t) + local rtn = {} + local iter = getiter(t) + for k in iter(t) do rtn[#rtn + 1] = k end + return rtn +end + + +function lume.clone(t) + local rtn = {} + for k, v in pairs(t) do rtn[k] = v end + return rtn +end + + +function lume.fn(fn, ...) + assert(iscallable(fn), "expected a function as the first argument") + local args = { ... } + return function(...) + local a = lume.concat(args, { ... }) + return fn(unpack(a)) + end +end + + +function lume.once(fn, ...) + local f = lume.fn(fn, ...) + local done = false + return function(...) + if done then return end + done = true + return f(...) + end +end + + +local memoize_fnkey = {} +local memoize_nil = {} + +function lume.memoize(fn) + local cache = {} + return function(...) + local c = cache + for i = 1, select("#", ...) do + local a = select(i, ...) or memoize_nil + c[a] = c[a] or {} + c = c[a] + end + c[memoize_fnkey] = c[memoize_fnkey] or {fn(...)} + return unpack(c[memoize_fnkey]) + end +end + + +function lume.combine(...) + local n = select('#', ...) + if n == 0 then return noop end + if n == 1 then + local fn = select(1, ...) + if not fn then return noop end + assert(iscallable(fn), "expected a function or nil") + return fn + end + local funcs = {} + for i = 1, n do + local fn = select(i, ...) + if fn ~= nil then + assert(iscallable(fn), "expected a function or nil") + funcs[#funcs + 1] = fn + end + end + return function(...) + for _, f in ipairs(funcs) do f(...) end + end +end + + +function lume.call(fn, ...) + if fn then + return fn(...) + end +end + + +function lume.time(fn, ...) + local start = os.clock() + local rtn = {fn(...)} + return (os.clock() - start), unpack(rtn) +end + + +local lambda_cache = {} + +function lume.lambda(str) + if not lambda_cache[str] then + local args, body = str:match([[^([%w,_ ]-)%->(.-)$]]) + assert(args and body, "bad string lambda") + local s = "return function(" .. args .. ")\nreturn " .. body .. "\nend" + lambda_cache[str] = lume.dostring(s) + end + return lambda_cache[str] +end + + +local serialize + +local serialize_map = { + [ "boolean" ] = tostring, + [ "nil" ] = tostring, + [ "string" ] = function(v) return string.format("%q", v) end, + [ "number" ] = function(v) + if v ~= v then return "0/0" -- nan + elseif v == 1 / 0 then return "1/0" -- inf + elseif v == -1 / 0 then return "-1/0" end -- -inf + return tostring(v) + end, + [ "table" ] = function(t, stk) + stk = stk or {} + if stk[t] then error("circular reference") end + local rtn = {} + stk[t] = true + for k, v in pairs(t) do + rtn[#rtn + 1] = "[" .. serialize(k, stk) .. "]=" .. serialize(v, stk) + end + stk[t] = nil + return "{" .. table.concat(rtn, ",") .. "}" + end +} + +setmetatable(serialize_map, { + __index = function(_, k) error("unsupported serialize type: " .. k) end +}) + +serialize = function(x, stk) + return serialize_map[type(x)](x, stk) +end + +function lume.serialize(x) + return serialize(x) +end + + +function lume.deserialize(str) + return lume.dostring("return " .. str) +end + + +function lume.split(str, sep) + if not sep then + return lume.array(str:gmatch("([%S]+)")) + else + assert(sep ~= "", "empty separator") + local psep = patternescape(sep) + return lume.array((str..sep):gmatch("(.-)("..psep..")")) + end +end + + +function lume.trim(str, chars) + if not chars then return str:match("^[%s]*(.-)[%s]*$") end + chars = patternescape(chars) + return str:match("^[" .. chars .. "]*(.-)[" .. chars .. "]*$") +end + + +function lume.wordwrap(str, limit) + limit = limit or 72 + local check + if type(limit) == "number" then + check = function(s) return #s >= limit end + else + check = limit + end + local rtn = {} + local line = "" + for word, spaces in str:gmatch("(%S+)(%s*)") do + local s = line .. word + if check(s) then + table.insert(rtn, line .. "\n") + line = word + else + line = s + end + for c in spaces:gmatch(".") do + if c == "\n" then + table.insert(rtn, line .. "\n") + line = "" + else + line = line .. c + end + end + end + table.insert(rtn, line) + return table.concat(rtn) +end + + +function lume.format(str, vars) + if not vars then return str end + local f = function(x) + return tostring(vars[x] or vars[tonumber(x)] or "{" .. x .. "}") + end + return (str:gsub("{(.-)}", f)) +end + + +function lume.trace(...) + local info = debug.getinfo(2, "Sl") + local t = { info.short_src .. ":" .. info.currentline .. ":" } + for i = 1, select("#", ...) do + local x = select(i, ...) + if type(x) == "number" then + x = string.format("%g", lume.round(x, .01)) + end + t[#t + 1] = tostring(x) + end + print(table.concat(t, " ")) +end + + +function lume.dostring(str) + return assert((loadstring or load)(str))() +end + + +function lume.uuid() + local fn = function(x) + local r = math.random(16) - 1 + r = (x == "x") and (r + 1) or (r % 4) + 9 + return ("0123456789abcdef"):sub(r, r) + end + return (("xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx"):gsub("[xy]", fn)) +end + + +function lume.hotswap(modname) + local oldglobal = lume.clone(_G) + local updated = {} + local function update(old, new) + if updated[old] then return end + updated[old] = true + local oldmt, newmt = getmetatable(old), getmetatable(new) + if oldmt and newmt then update(oldmt, newmt) end + for k, v in pairs(new) do + if type(v) == "table" then update(old[k], v) else old[k] = v end + end + end + local err = nil + local function onerror(e) + for k in pairs(_G) do _G[k] = oldglobal[k] end + err = lume.trim(e) + end + local ok, oldmod = pcall(require, modname) + oldmod = ok and oldmod or nil + xpcall(function() + package.loaded[modname] = nil + local newmod = require(modname) + if type(oldmod) == "table" then update(oldmod, newmod) end + for k, v in pairs(oldglobal) do + if v ~= _G[k] and type(v) == "table" then + update(v, _G[k]) + _G[k] = v + end + end + end, onerror) + package.loaded[modname] = oldmod + if err then return nil, err end + return oldmod +end + + +local ripairs_iter = function(t, i) + i = i - 1 + local v = t[i] + if v ~= nil then + return i, v + end +end + +function lume.ripairs(t) + return ripairs_iter, t, (#t + 1) +end + + +function lume.color(str, mul) + mul = mul or 1 + local r, g, b, a + r, g, b = str:match("#(%x%x)(%x%x)(%x%x)") + if r then + r = tonumber(r, 16) / 0xff + g = tonumber(g, 16) / 0xff + b = tonumber(b, 16) / 0xff + a = 1 + elseif str:match("rgba?%s*%([%d%s%.,]+%)") then + local f = str:gmatch("[%d.]+") + r = (f() or 0) / 0xff + g = (f() or 0) / 0xff + b = (f() or 0) / 0xff + a = f() or 1 + else + error(("bad color string '%s'"):format(str)) + end + return r * mul, g * mul, b * mul, a * mul +end + + +local chain_mt = {} +chain_mt.__index = lume.map(lume.filter(lume, iscallable, true), + function(fn) + return function(self, ...) + self._value = fn(self._value, ...) + return self + end + end) +chain_mt.__index.result = function(x) return x._value end + +function lume.chain(value) + return setmetatable({ _value = value }, chain_mt) +end + +setmetatable(lume, { + __call = function(_, ...) + return lume.chain(...) + end +}) + + +return lume |