Created
November 17, 2018 13:05
-
-
Save Sephi-Chan/a9779cb901ae4c45559e371ba3936486 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
-- | |
-- json.lua | |
-- | |
-- Copyright (c) 2018 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.1" } | |
------------------------------------------------------------------------------- | |
-- 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 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(3, 6), 16 ) | |
local n2 = tonumber( s:sub(9, 12), 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 has_unicode_escape = false | |
local has_surrogate_escape = false | |
local has_escape = false | |
local last | |
for j = i + 1, #str do | |
local x = str:byte(j) | |
if x < 32 then | |
decode_error(str, j, "control character in string") | |
end | |
if last == 92 then -- "\\" (escape char) | |
if x == 117 then -- "u" (unicode escape sequence) | |
local hex = str:sub(j + 1, j + 5) | |
if not hex:find("%x%x%x%x") then | |
decode_error(str, j, "invalid unicode escape in string") | |
end | |
if hex:find("^[dD][89aAbB]") then | |
has_surrogate_escape = true | |
else | |
has_unicode_escape = true | |
end | |
else | |
local c = string.char(x) | |
if not escape_chars[c] then | |
decode_error(str, j, "invalid escape char '" .. c .. "' in string") | |
end | |
has_escape = true | |
end | |
last = nil | |
elseif x == 34 then -- '"' (end of string) | |
local s = str:sub(i + 1, j - 1) | |
if has_surrogate_escape then | |
s = s:gsub("\\u[dD][89aAbB]..\\u....", parse_unicode_escape) | |
end | |
if has_unicode_escape then | |
s = s:gsub("\\u....", parse_unicode_escape) | |
end | |
if has_escape then | |
s = s:gsub("\\.", escape_char_map_inv) | |
end | |
return s, j + 1 | |
else | |
last = x | |
end | |
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 | |
-------------------------------------------------------------------------------------------------------------------------------------------- | |
-------------------------------------------------------------------------------------------------------------------------------------------- | |
local pc = app.pixelColor | |
function icolor(pixel) | |
return "rgba(" .. pc.rgbaR(pixel) .. ", " .. pc.rgbaG(pixel) .. ", " .. pc.rgbaB(pixel) .. ", " .. pc.rgbaA(pixel) .. ")" | |
end | |
local debug = false | |
function log(message) | |
return debug and print(message) | |
end | |
function irectangle(rectangle) | |
return "rectangle(" .. rectangle.x .. ", " .. rectangle.y .. ", " .. rectangle.width .. ", " .. rectangle.height .. ")" | |
end | |
function ipoint(point) | |
return "point(" .. point.x .. ", " .. point.y .. ")" | |
end | |
function get_layer(sprite, name) | |
for i, layer in ipairs(sprite.layers) do | |
if layer.name == name then | |
return layer | |
end | |
end | |
end | |
-- Return the cels of the given layer indexed by frame number. | |
function get_layer_cels(sprite, layer_name) | |
local layer = get_layer(app.activeSprite, layer_name) | |
local cels = {} | |
for i, cel in ipairs(layer.cels) do | |
cels[cel.frame] = cel | |
end | |
return cels | |
end | |
function find_origin(cel, color) | |
log("Search origin in cel for frame " .. cel.frame .. " in layer " .. cel.layer.name .. " looking for color " .. icolor(color)) | |
local image = cel.image | |
local bounds = cel.bounds | |
local width = bounds.width | |
for y = 0, bounds.height do | |
for x = 0, width do | |
if image:getPixel(x,y) == color then | |
return { | |
x = x + bounds.x, | |
y = y + bounds.y | |
} | |
end | |
end | |
end | |
end | |
function find_boxes(cel, color, origin) | |
if not cel then return end | |
local boxes = {} | |
local image = cel.image | |
local bounds = cel.bounds | |
local ignored_points = {} | |
log("Search box of color " .. icolor(color) .. " in the cel for frame " .. cel.frame .. " and layer " .. cel.layer.name .. ". Origin is " .. ipoint(origin)) | |
for y = 0, bounds.height do | |
for x = 0, bounds.width do | |
-- Search for pixels of the right color and which doesn't belong to a previously visited rectangle. | |
local pixel = image:getPixel(x, y) | |
if pixel == color and not ignored_points[x .. "_" .. y] then | |
local rectangle, visited_points = get_rectangle(cel, Point(x, y), color) | |
rectangle.x = x + bounds.x - origin.x | |
rectangle.y = y + bounds.y - origin.y | |
log("Add box " .. irectangle(rectangle)) | |
table.insert(boxes, rectangle) | |
-- Mark the pixels of this rectangle as visited. | |
for point, _ in pairs(visited_points) do | |
ignored_points[point] = true | |
end | |
end | |
end | |
end | |
return boxes | |
end | |
-- Image being processes from top left corner, the first pixel encountered | |
-- is always the top left of a rectangle. Just follow the horizontal line | |
-- to the right until you get no more pixel, then go down until no more pixel | |
-- down, then left, then top until you reach the starting point. | |
function get_rectangle(cel, start, color) | |
log("Start exploring a rectangle from " .. ipoint(start)) | |
local rectangle = { x = start.x, y = start.y, width = nil, height = nil } | |
local visited_points = { [start.x .. "_" .. start.y] = true} | |
local image = cel.image | |
local bounds = cel.bounds | |
local width = bounds.width | |
local point = { x = start.x, y = start.y } | |
local watchdog = 1000 | |
repeat | |
watchdog = watchdog - 1 | |
if point and image:getPixel(point.x + 1, point.y) == color then -- Go right. | |
visited_points[point.x + 1 .. "_" .. point.y] = true | |
point.x = point.x + 1 | |
elseif point and image:getPixel(point.x, point.y + 1) == color then -- Go down. | |
visited_points[point.x .. "_" .. point.y + 1] = true | |
point.y = point.y + 1 | |
else -- Found the bottom right corner! | |
rectangle.width = point.x - start.x + 1 | |
rectangle.height = point.y - start.y + 1 | |
end | |
until rectangle.width or watchdog == 0 | |
-- Add the remaining points to the visited points. | |
for x = start.x, point.x do | |
visited_points[x .. "_" .. point.y] = true | |
end | |
for y = start.y, point.y do | |
visited_points[start.x .. "_" .. y] = true | |
end | |
return rectangle, visited_points | |
end | |
function extract_animations(sprite, colors) | |
local origin_layer = get_layer(sprite, "Origin") | |
local hitboxes_cels = get_layer_cels(sprite, "Hitboxes") | |
local hurtboxes_cels = get_layer_cels(sprite, "Hurtboxes") | |
local moveboxes_cels = get_layer_cels(sprite, "Moveboxes") | |
local animations = {} | |
for _, tag in ipairs(sprite.tags) do | |
animations[tag.name] = { | |
name = tag.name, | |
frames = {} | |
} | |
for i = 1, tag.frames do | |
local frame_index = tag.fromFrame + i - 1 | |
local origin = find_origin(origin_layer.cels[frame_index], colors.origin) | |
log("Process frame " .. frame_index .. " of animation " .. tag.name) | |
animations[tag.name].frames[i] = { | |
index = i, | |
origin = origin, | |
hitboxes = find_boxes(hitboxes_cels[frame_index], colors.hitbox, origin), | |
hurtboxes = find_boxes(hurtboxes_cels[frame_index], colors.hurtbox, origin), | |
moveboxes = find_boxes(moveboxes_cels[frame_index], colors.movebox, origin), | |
rectangle = { | |
x = (frame_index - 1) * sprite.width, | |
y = 0, | |
width = sprite.width, | |
height = sprite.height | |
} | |
} | |
end | |
end | |
return animations | |
end | |
local red = pc.rgba(255, 0, 0, 255) | |
local green = pc.rgba(0, 255, 0, 255) | |
local blue = pc.rgba(0, 0, 255, 255) | |
local yellow = pc.rgba(255, 255, 0, 255) | |
local colors = { | |
origin = red, | |
movebox = green, | |
hurtbox = blue, | |
hitbox = yellow | |
} | |
local animations = extract_animations(app.activeSprite, colors) | |
local file = io.open("hero.json", "w") | |
io.output(file) | |
io.write(json.encode(animations)) | |
io.close() |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment