temp: add animated sprites

.luarc.json

@@ -1,5 +1,8 @@
 {
     "$schema": "https://raw.githubusercontent.com/sumneko/vscode-lua/master/setting/schema.json",
+    "Lua.diagnostics.disable": [
+        "param-type-mismatch"
+    ],
     "Lua.runtime.version": "LuaJIT",
     "Lua.workspace.checkThirdParty": false,
     "Lua.workspace.library": [

.vimrc.lua

@@ -1,6 +1,6 @@
 local map = vim.api.nvim_set_keymap
 
-map('n', '<leader>l', ":execute 'silent !kitty love src &' | redraw!<cr>", {
+map('n', '<leader>l', ":execute 'silent !kitty -d src love . &' | redraw!<cr>", {
 	silent = true,
 	noremap = true
 })

src/data/maps/playground.tmx

@@ -0,0 +1,32 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.9" tiledversion="1.9.0" orientation="orthogonal" renderorder="right-down" width="30" height="20" tilewidth="16" tileheight="16" infinite="0" nextlayerid="3" nextobjectid="1">
+ <editorsettings>
+  <export target="test.lua" format="lua"/>
+ </editorsettings>
+ <tileset firstgid="1" source="../tilesets/test.tsx"/>
+ <layer id="1" name="walls" width="30" height="20">
+  <data encoding="csv">
+1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+1,0,0,0,1,1,1,0,0,0,0,0,0,0,0,1,1,1,1,1,0,0,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2147483649,2147483649,2147483649,0,0,0,0,1,
+1,0,0,0,0,1,1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,2147483649,2147483649,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,0,0,0,0,2147483649,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,2147483649,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,2147483649,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,2147483649,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,1,0,0,0,0,1,0,0,0,1,0,0,0,2147483649,2147483649,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,1,1,0,0,0,0,1,0,0,0,1,0,0,0,0,2147483649,2147483649,2147483649,0,0,0,0,1,
+1,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,0,0,1,
+1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,
+1,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,
+1,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1
+</data>
+ </layer>
+ <objectgroup id="2" name="spawnpoints"/>
+</map>

src/lib/ase-loader.lua

@@ -0,0 +1,353 @@
+--[[
+MIT License
+
+Copyright (c) 2021 Pedro Lucas (github.com/elloramir)
+
+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.
+]]--
+
+-- sizes in bytes
+local BYTE = 1
+local WORD = 2
+local SHORT = 2
+local DWORD = 4
+local LONG = 4
+local FIXED = 4
+
+-- parse data/text to number
+local function read_num(data, size)
+	local bytes = data:read(size)
+	local hex = ""
+
+	for i = size, 1, -1 do
+		local char = string.sub(bytes, i, i)
+		hex = hex .. string.format("%02X", string.byte(char))
+	end
+
+	return tonumber(hex, 16)
+end
+
+-- return a string by it size
+local function read_string(data)
+	local length = read_num(data, WORD)
+	return data:read(length)
+end
+
+local function grab_header(data)
+	local header = {}
+
+	header.file_size = read_num(data, DWORD)
+	header.magic_number = read_num(data, WORD)
+
+	if header.magic_number ~= 0xA5E0 then
+		error("Not a valid aseprite file")
+	end
+
+	header.frames_number = read_num(data, WORD)
+	header.width = read_num(data, WORD)
+	header.height = read_num(data, WORD)
+	header.color_depth = read_num(data, WORD)
+	header.opacity = read_num(data, DWORD)
+	header.speed = read_num(data, WORD)
+
+	-- skip
+	read_num(data, DWORD * 2)
+
+	header.palette_entry = read_num(data, BYTE)
+
+	-- skip
+	read_num(data, BYTE * 3)
+
+	header.number_color = read_num(data, WORD)
+	header.pixel_width = read_num(data, BYTE)
+	header.pixel_height = read_num(data, BYTE)
+	header.grid_x = read_num(data, SHORT)
+	header.grid_y = read_num(data, SHORT)
+	header.grid_width = read_num(data, WORD)
+	header.grid_height = read_num(data, WORD)
+
+	-- skip
+	read_num(data, BYTE * 84)
+
+	-- to the future
+	header.frames = {}
+
+	return header
+end
+
+local function grab_frame_header(data)
+	local frame_header = {}
+
+	frame_header.bytes_size = read_num(data, DWORD)
+	frame_header.magic_number = read_num(data, WORD)
+
+	if frame_header.magic_number ~= 0xF1FA then
+		error("Corrupted file")
+	end
+
+	local old_chunks = read_num(data, WORD)
+
+	frame_header.frame_duration = read_num(data, WORD)
+
+	-- skip
+	read_num(data, BYTE * 2)
+
+	-- if 0, use old chunks as chunks
+	local new_chunks = read_num(data, DWORD)
+
+	if new_chunks == 0 then
+		frame_header.chunks_number = old_chunks
+	else
+		frame_header.chunks_number = new_chunks
+	end
+
+	-- to the future
+	frame_header.chunks = {}
+
+	return frame_header
+end
+
+local function grab_color_profile(data)
+	local color_profile = {}
+
+	color_profile.type = read_num(data, WORD)
+	color_profile.uses_fixed_gama = read_num(data, WORD)
+	color_profile.fixed_game = read_num(data, FIXED)
+
+	-- skip
+	read_num(data, BYTE * 8)
+
+	if color_profile.type ~= 1 then
+		error("No suported color profile, use sRGB")
+	end
+
+	return color_profile
+end
+
+local function grab_palette(data)
+	local palette = {}
+
+	palette.entry_size = read_num(data, DWORD)
+	palette.first_color = read_num(data, DWORD)
+	palette.last_color = read_num(data, DWORD)
+	palette.colors = {}
+
+	-- skip
+	read_num(data, BYTE * 8)
+
+	for i = 1, palette.entry_size do
+		local has_name = read_num(data, WORD)
+
+		palette.colors[i] = {
+			color = {
+				read_num(data, BYTE),
+				read_num(data, BYTE),
+				read_num(data, BYTE),
+				read_num(data, BYTE)}}
+
+		if has_name == 1 then
+			palette.colors[i].name = read_string(data)
+		end
+	end
+
+	return palette
+end
+
+local function grab_old_palette(data)
+	local palette = {}
+
+	palette.packets = read_num(data, WORD)
+	palette.colors_packet = {}
+
+	for i = 1, palette.packets do
+		palette.colors_packet[i] = {
+			entries = read_num(data, BYTE),
+			number = read_num(data, BYTE),
+			colors = {}}
+
+		for j = 1, palette.colors_packet[i].number do
+			palette.colors_packet[i][j] = {
+				read_num(data, BYTE),
+				read_num(data, BYTE),
+				read_num(data, BYTE)}
+		end
+	end
+
+	return palette
+end
+
+local function grab_layer(data)
+	local layer = {}
+
+	layer.flags = read_num(data, WORD)
+	layer.type = read_num(data, WORD)
+	layer.child_level = read_num(data, WORD)
+	layer.width = read_num(data, WORD)
+	layer.height = read_num(data, WORD)
+	layer.blend = read_num(data, WORD)
+	layer.opacity = read_num(data, BYTE)
+
+	-- skip
+	read_num(data, BYTE * 3)
+
+	layer.name = read_string(data)
+
+	return layer
+end
+
+local function grab_cel(data, size)
+	local cel = {}
+
+	cel.layer_index = read_num(data, WORD)
+	cel.x = read_num(data, WORD)
+	cel.y = read_num(data, WORD)
+	cel.opacity_level = read_num(data, BYTE)
+	cel.type = read_num(data, WORD)
+
+	read_num(data, BYTE * 7)
+
+	if cel.type == 2 then
+		cel.width = read_num(data, WORD)
+		cel.height = read_num(data, WORD)
+		cel.data = data:read(size - 26)
+	end
+
+	return cel
+end
+
+local function grab_tags(data)
+	local tags = {}
+
+	tags.number = read_num(data, WORD)
+	tags.tags = {}
+
+	-- skip
+	read_num(data, BYTE * 8)
+
+	for i = 1, tags.number do
+		tags.tags[i] = {
+			from = read_num(data, WORD),
+			to = read_num(data, WORD),
+			direction = read_num(data, BYTE),
+			extra_byte = read_num(data, BYTE),
+			color = read_num(data, BYTE * 3),
+			skip_holder = read_num(data, BYTE * 8),
+			name = read_string(data)}
+	end
+
+	return tags
+end
+
+local function grab_slice(data)
+	local slice = {}
+
+	slice.key_numbers = read_num(data, DWORD)
+	slice.keys = {}
+	slice.flags = read_num(data, DWORD)
+
+	-- reserved?
+	read_num(data, DWORD)
+
+	slice.name = read_string(data)
+
+	for i = 1, slice.key_numbers do
+		slice.keys[i] = {
+			frame = read_num(data, DWORD),
+			x = read_num(data, DWORD),
+			y = read_num(data, DWORD),
+			width = read_num(data, DWORD),
+			height = read_num(data, DWORD)}
+
+		if slice.flags == 1 then
+			slice.keys[i].center_x = read_num(data, DWORD)
+			slice.keys[i].center_y = read_num(data, DWORD)
+			slice.keys[i].center_width = read_num(data, DWORD)
+			slice.keys[i].center_height = read_num(data, DWORD)
+		elseif slice.flags == 2 then
+			slice.keys[i].pivot_x = read_num(data, DWORD)
+			slice.keys[i].pivot_y = read_num(data, DWORD)
+		end
+	end
+
+	return slice
+end
+
+local function grab_user_data(data)
+	local user_data = {}
+
+	user_data.flags = read_num(data, DWORD)
+
+	if user_data.flags == 1 then
+		user_data.text = read_string(data)
+	elseif user_data.flags == 2 then
+		user_data.colors = read_num(data, BYTE * 4)
+	end
+
+	return user_data
+end
+
+local function grab_chunk(data)
+	local chunk = {}
+	chunk.size = read_num(data, DWORD)
+	chunk.type = read_num(data, WORD)
+
+	if chunk.type == 0x2007 then
+		chunk.data = grab_color_profile(data)
+	elseif chunk.type == 0x2019 then
+		chunk.data = grab_palette(data)
+	elseif chunk.type == 0x0004 then
+		chunk.data = grab_old_palette(data)
+	elseif chunk.type == 0x2004 then
+		chunk.data = grab_layer(data)
+	elseif chunk.type == 0x2005 then
+		chunk.data = grab_cel(data, chunk.size)
+	elseif chunk.type == 0x2018 then
+		chunk.data = grab_tags(data)
+	elseif chunk.type == 0x2022 then
+		chunk.data = grab_slice(data)
+	elseif chunk.type == 0x2020 then
+		chunk.data = grab_user_data(data)
+	end
+
+	return chunk
+end
+
+local function ase_loader(src)
+	local data = io.open(src, "rb")
+	assert(data, "can't open " .. src)
+	local ase = {}
+
+	-- parse header
+	ase.header = grab_header(data)
+
+	-- parse frames
+	for i = 1, ase.header.frames_number do
+		ase.header.frames[i] = grab_frame_header(data)
+
+		-- parse frames chunks
+		for j = 1, ase.header.frames[i].chunks_number do
+			ase.header.frames[i].chunks[j] = grab_chunk(data)
+		end
+	end
+
+	data.close()
+	return ase
+end
+
+return ase_loader

src/lib/json.lua

@@ -0,0 +1,388 @@
+--
+-- json.lua
+--
+-- 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 json = { _version = "0.1.2" }
+
+-------------------------------------------------------------------------------
+-- Encode
+-------------------------------------------------------------------------------
+
+local encode
+
+local escape_char_map = {
+  [ "\\" ] = "\\",
+  [ "\"" ] = "\"",
+  [ "\b" ] = "b",
+  [ "\f" ] = "f",
+  [ "\n" ] = "n",
+  [ "\r" ] = "r",
+  [ "\t" ] = "t",
+}
+
+local escape_char_map_inv = { [ "/" ] = "/" }
+for k, v in pairs(escape_char_map) do
+  escape_char_map_inv[v] = k
+end
+
+
+local function escape_char(c)
+  return "\\" .. (escape_char_map[c] or string.format("u%04x", c:byte()))
+end
+
+
+local function encode_nil(val)
+  return "null"
+end
+
+
+local function encode_table(val, stack)
+  local res = {}
+  stack = stack or {}
+
+  -- Circular reference?
+  if stack[val] then error("circular reference") end
+
+  stack[val] = true
+
+  if rawget(val, 1) ~= nil or next(val) == nil then
+    -- Treat as array -- check keys are valid and it is not sparse
+    local n = 0
+    for k in pairs(val) do
+      if type(k) ~= "number" then
+        error("invalid table: mixed or invalid key types")
+      end
+      n = n + 1
+    end
+    if n ~= #val then
+      error("invalid table: sparse array")
+    end
+    -- Encode
+    for i, v in ipairs(val) do
+      table.insert(res, encode(v, stack))
+    end
+    stack[val] = nil
+    return "[" .. table.concat(res, ",") .. "]"
+
+  else
+    -- Treat as an object
+    for k, v in pairs(val) do
+      if type(k) ~= "string" then
+        error("invalid table: mixed or invalid key types")
+      end
+      table.insert(res, encode(k, stack) .. ":" .. encode(v, stack))
+    end
+    stack[val] = nil
+    return "{" .. table.concat(res, ",") .. "}"
+  end
+end
+
+
+local function encode_string(val)
+  return '"' .. val:gsub('[%z\1-\31\\"]', escape_char) .. '"'
+end
+
+
+local function encode_number(val)
+  -- Check for NaN, -inf and inf
+  if val ~= val or val <= -math.huge or val >= math.huge then
+    error("unexpected number value '" .. tostring(val) .. "'")
+  end
+  return string.format("%.14g", val)
+end
+
+
+local type_func_map = {
+  [ "nil"     ] = encode_nil,
+  [ "table"   ] = encode_table,
+  [ "string"  ] = encode_string,
+  [ "number"  ] = encode_number,
+  [ "boolean" ] = tostring,
+}
+
+
+encode = function(val, stack)
+  local t = type(val)
+  local f = type_func_map[t]
+  if f then
+    return f(val, stack)
+  end
+  error("unexpected type '" .. t .. "'")
+end
+
+
+function json.encode(val)
+  return ( encode(val) )
+end
+
+
+-------------------------------------------------------------------------------
+-- Decode
+-------------------------------------------------------------------------------
+
+local parse
+
+local function create_set(...)
+  local res = {}
+  for i = 1, select("#", ...) do
+    res[ select(i, ...) ] = true
+  end
+  return res
+end
+
+local space_chars   = create_set(" ", "\t", "\r", "\n")
+local delim_chars   = create_set(" ", "\t", "\r", "\n", "]", "}", ",")
+local escape_chars  = create_set("\\", "/", '"', "b", "f", "n", "r", "t", "u")
+local literals      = create_set("true", "false", "null")
+
+local literal_map = {
+  [ "true"  ] = true,
+  [ "false" ] = false,
+  [ "null"  ] = nil,
+}
+
+
+local function next_char(str, idx, set, negate)
+  for i = idx, #str do
+    if set[str:sub(i, i)] ~= negate then
+      return i
+    end
+  end
+  return #str + 1
+end
+
+
+local function decode_error(str, idx, msg)
+  local line_count = 1
+  local col_count = 1
+  for i = 1, idx - 1 do
+    col_count = col_count + 1
+    if str:sub(i, i) == "\n" then
+      line_count = line_count + 1
+      col_count = 1
+    end
+  end
+  error( string.format("%s at line %d col %d", msg, line_count, col_count) )
+end
+
+
+local function codepoint_to_utf8(n)
+  -- http://scripts.sil.org/cms/scripts/page.php?site_id=nrsi&id=iws-appendixa
+  local f = math.floor
+  if n <= 0x7f then
+    return string.char(n)
+  elseif n <= 0x7ff then
+    return string.char(f(n / 64) + 192, n % 64 + 128)
+  elseif n <= 0xffff then
+    return string.char(f(n / 4096) + 224, f(n % 4096 / 64) + 128, n % 64 + 128)
+  elseif n <= 0x10ffff then
+    return string.char(f(n / 262144) + 240, f(n % 262144 / 4096) + 128,
+                       f(n % 4096 / 64) + 128, n % 64 + 128)
+  end
+  error( string.format("invalid unicode codepoint '%x'", n) )
+end
+
+
+local function parse_unicode_escape(s)
+  local n1 = tonumber( s:sub(1, 4),  16 )
+  local n2 = tonumber( s:sub(7, 10), 16 )
+   -- Surrogate pair?
+  if n2 then
+    return codepoint_to_utf8((n1 - 0xd800) * 0x400 + (n2 - 0xdc00) + 0x10000)
+  else
+    return codepoint_to_utf8(n1)
+  end
+end
+
+
+local function parse_string(str, i)
+  local res = ""
+  local j = i + 1
+  local k = j
+
+  while j <= #str do
+    local x = str:byte(j)
+
+    if x < 32 then
+      decode_error(str, j, "control character in string")
+
+    elseif x == 92 then -- `\`: Escape
+      res = res .. str:sub(k, j - 1)
+      j = j + 1
+      local c = str:sub(j, j)
+      if c == "u" then
+        local hex = str:match("^[dD][89aAbB]%x%x\\u%x%x%x%x", j + 1)
+                 or str:match("^%x%x%x%x", j + 1)
+                 or decode_error(str, j - 1, "invalid unicode escape in string")
+        res = res .. parse_unicode_escape(hex)
+        j = j + #hex
+      else
+        if not escape_chars[c] then
+          decode_error(str, j - 1, "invalid escape char '" .. c .. "' in string")
+        end
+        res = res .. escape_char_map_inv[c]
+      end
+      k = j + 1
+
+    elseif x == 34 then -- `"`: End of string
+      res = res .. str:sub(k, j - 1)
+      return res, j + 1
+    end
+
+    j = j + 1
+  end
+
+  decode_error(str, i, "expected closing quote for string")
+end
+
+
+local function parse_number(str, i)
+  local x = next_char(str, i, delim_chars)
+  local s = str:sub(i, x - 1)
+  local n = tonumber(s)
+  if not n then
+    decode_error(str, i, "invalid number '" .. s .. "'")
+  end
+  return n, x
+end
+
+
+local function parse_literal(str, i)
+  local x = next_char(str, i, delim_chars)
+  local word = str:sub(i, x - 1)
+  if not literals[word] then
+    decode_error(str, i, "invalid literal '" .. word .. "'")
+  end
+  return literal_map[word], x
+end
+
+
+local function parse_array(str, i)
+  local res = {}
+  local n = 1
+  i = i + 1
+  while 1 do
+    local x
+    i = next_char(str, i, space_chars, true)
+    -- Empty / end of array?
+    if str:sub(i, i) == "]" then
+      i = i + 1
+      break
+    end
+    -- Read token
+    x, i = parse(str, i)
+    res[n] = x
+    n = n + 1
+    -- Next token
+    i = next_char(str, i, space_chars, true)
+    local chr = str:sub(i, i)
+    i = i + 1
+    if chr == "]" then break end
+    if chr ~= "," then decode_error(str, i, "expected ']' or ','") end
+  end
+  return res, i
+end
+
+
+local function parse_object(str, i)
+  local res = {}
+  i = i + 1
+  while 1 do
+    local key, val
+    i = next_char(str, i, space_chars, true)
+    -- Empty / end of object?
+    if str:sub(i, i) == "}" then
+      i = i + 1
+      break
+    end
+    -- Read key
+    if str:sub(i, i) ~= '"' then
+      decode_error(str, i, "expected string for key")
+    end
+    key, i = parse(str, i)
+    -- Read ':' delimiter
+    i = next_char(str, i, space_chars, true)
+    if str:sub(i, i) ~= ":" then
+      decode_error(str, i, "expected ':' after key")
+    end
+    i = next_char(str, i + 1, space_chars, true)
+    -- Read value
+    val, i = parse(str, i)
+    -- Set
+    res[key] = val
+    -- Next token
+    i = next_char(str, i, space_chars, true)
+    local chr = str:sub(i, i)
+    i = i + 1
+    if chr == "}" then break end
+    if chr ~= "," then decode_error(str, i, "expected '}' or ','") end
+  end
+  return res, i
+end
+
+
+local char_func_map = {
+  [ '"' ] = parse_string,
+  [ "0" ] = parse_number,
+  [ "1" ] = parse_number,
+  [ "2" ] = parse_number,
+  [ "3" ] = parse_number,
+  [ "4" ] = parse_number,
+  [ "5" ] = parse_number,
+  [ "6" ] = parse_number,
+  [ "7" ] = parse_number,
+  [ "8" ] = parse_number,
+  [ "9" ] = parse_number,
+  [ "-" ] = parse_number,
+  [ "t" ] = parse_literal,
+  [ "f" ] = parse_literal,
+  [ "n" ] = parse_literal,
+  [ "[" ] = parse_array,
+  [ "{" ] = parse_object,
+}
+
+
+parse = function(str, idx)
+  local chr = str:sub(idx, idx)
+  local f = char_func_map[chr]
+  if f then
+    return f(str, idx)
+  end
+  decode_error(str, idx, "unexpected character '" .. chr .. "'")
+end
+
+
+function json.decode(str)
+  if type(str) ~= "string" then
+    error("expected argument of type string, got " .. type(str))
+  end
+  local res, idx = parse(str, next_char(str, 1, space_chars, true))
+  idx = next_char(str, idx, space_chars, true)
+  if idx <= #str then
+    decode_error(str, idx, "trailing garbage")
+  end
+  return res
+end
+
+
+return json

src/systems/player.lua

@@ -132,7 +132,10 @@ function Player:spawnPlayer()
 		vel = Vec(0, 0),
 		acc = Vec(),
 
-		sprite = {},
+		sprite = {
+			name = "player",
+			variant = "walk"
+		},
 		friction = 0.998,
 		speed = 800,
 		bolt_count = 10,

src/systems/sprite.lua

@@ -1,5 +1,76 @@
+local pprint = require("lib.pprint")
+local aseLoader = require("lib.ase-loader")
 local Sprite = {}
 
+-- TODO: Maybe add a texture atlas library for packing frame data
+-- TODO: For production maybe use another type of loader? (https://github.com/elloramir/packer, https://github.com/EngineerSmith/Runtime-TextureAtlas)
+local function loadAsepriteSprite(path)
+	local sprite = {}
+	local ase = aseLoader(path)
+
+	sprite.width = ase.header.width
+	sprite.height = ase.header.height
+	sprite.variants = {}
+
+	local FRAME_DATA_CHUNK = 0x2005
+	local FRAME_TAG_CHUNK = 0x2018
+
+	local frames = {}
+	local tags = {}
+	local default_variant
+
+	for _, frame in ipairs(ase.header.frames) do
+		for _, chunk in ipairs(frame.chunks) do
+			if chunk.type == FRAME_DATA_CHUNK then
+				print("frame data")
+				local cel = chunk.data
+				local buffer = love.data.decompress("data", "zlib", cel.data)
+				local data = love.image.newImageData(cel.width, cel.height, "rgba8", buffer)
+				local image = love.graphics.newImage(data)
+				local canvas = love.graphics.newCanvas(sprite.width, sprite.height)
+
+				-- you need to draw in a canvas before.
+				-- frame images can be of different sizes
+				-- but never bigger than the header width and height
+				love.graphics.setCanvas(canvas)
+				love.graphics.draw(image, cel.x, cel.y)
+				love.graphics.setCanvas()
+
+				table.insert(frames, {
+					image = canvas,
+					duration = frame.frame_duration / 1000
+				})
+			elseif chunk.type == FRAME_TAG_CHUNK then
+				for i, tag in ipairs(chunk.data.tags) do
+					-- first tag as default
+					if i == 1 then
+						default_variant = tag.name
+					end
+
+					-- aseprite use 0 notation to begin
+					-- but in lua, everthing starts in 1
+					tag.to = tag.to + 1
+					tag.from = tag.from + 1
+					tag.frames = tag.to - tag.from
+					tags[tag.name] = tag
+				end
+			end
+		end
+	end
+
+	pprint(tags)
+	pprint(frames)
+
+	return sprite
+end
+
+local all_sprites = {}
+all_sprites.player = loadAsepriteSprite("data/sprites/player.aseprite")
+
+function Sprite:addToWorld(group, e)
+	if group ~= "sprite" then return end
+end
+
 function Sprite:draw()
 	for _, e in ipairs(self.pool.groups.sprite.entities) do
 		love.graphics.setColor(1, 1, 1)