@gamely/gly-engine-lite 0.0.17 → 0.0.19

package/dist/main.lua

@@ -1,50 +1,110 @@
 local math = ((function() local x, y = pcall(require, 'math'); return x and y end)()) or _G.math
-local core_src_version = nil
-local core_src_lib_common_module = nil
-local core_src_lib_engine_api_encoder = nil
-local core_src_lib_engine_api_app = nil
-local core_src_lib_engine_api_hash = nil
-local core_src_lib_engine_api_http = nil
-local core_src_lib_engine_api_i18n = nil
-local core_src_lib_engine_api_key = nil
-local core_src_lib_engine_api_math = nil
-local core_src_lib_engine_api_array = nil
-local core_src_lib_engine_draw_fps = nil
-local core_src_lib_engine_draw_text = nil
-local core_src_lib_engine_draw_poly = nil
-local core_src_lib_engine_raw_memory = nil
-local core_src_lib_object_root = nil
-local core_src_lib_object_color = nil
-local core_src_lib_object_std = nil
-local core_src_lib_util_pipeline = nil
-local core_src_lib_util_decorator = nil
-local function main()
-local version = core_src_version()
-local zeebo_module = core_src_lib_common_module()
-local engine_encoder = core_src_lib_engine_api_encoder()
-local engine_game = core_src_lib_engine_api_app()
-local engine_hash = core_src_lib_engine_api_hash()
-local engine_http = core_src_lib_engine_api_http()
-local engine_i18n = core_src_lib_engine_api_i18n()
-local engine_key = core_src_lib_engine_api_key()
-local engine_math = core_src_lib_engine_api_math()
-local engine_array = core_src_lib_engine_api_array()
-local engine_draw_fps = core_src_lib_engine_draw_fps()
-local engine_draw_text = core_src_lib_engine_draw_text()
-local engine_draw_poly = core_src_lib_engine_draw_poly()
-local engine_raw_memory = core_src_lib_engine_raw_memory()
-local application_default = core_src_lib_object_root()
-local color = core_src_lib_object_color()
-local std = core_src_lib_object_std()
+local src_version_55d740741220 = nil
+local src_lib_common_module_55d74078d4c0 = nil
+local src_lib_engine_api_encoder_55d740797c20 = nil
+local src_lib_engine_api_app_55d7407cdb00 = nil
+local src_lib_engine_api_hash_55d740798450 = nil
+local src_lib_engine_api_http_55d74079e880 = nil
+local src_lib_engine_api_i18n_55d74075aa10 = nil
+local src_lib_engine_api_key_55d7407bfbd0 = nil
+local src_lib_engine_api_log_55d7407a7ec0 = nil
+local src_lib_engine_api_math_55d740799d40 = nil
+local src_lib_engine_api_array_55d740779000 = nil
+local src_lib_engine_api_media_55d7407489d0 = nil
+local src_lib_engine_draw_fps_55d740798890 = nil
+local src_lib_engine_draw_text_55d7407c8b90 = nil
+local src_lib_engine_draw_poly_55d740799b40 = nil
+local src_lib_engine_raw_memory_55d74079abd0 = nil
+local src_lib_protocol_http_callback_55d74079bca0 = nil
+local src_lib_object_root_55d7407b5bb0 = nil
+local src_lib_object_color_55d7407a8380 = nil
+local src_lib_object_std_55d74076e7c0 = nil
+local src_lib_util_pipeline_55d7407bc4c0 = nil
+local src_lib_util_decorator_55d7407a7e30 = nil
+local src_lib_util_http_55d74078aa00 = nil
+local function main_55d7407a19d0()
+local version = src_version_55d740741220()
+local zeebo_module = src_lib_common_module_55d74078d4c0()
+local engine_encoder = src_lib_engine_api_encoder_55d740797c20()
+local engine_game = src_lib_engine_api_app_55d7407cdb00()
+local engine_hash = src_lib_engine_api_hash_55d740798450()
+local engine_http = src_lib_engine_api_http_55d74079e880()
+local engine_i18n = src_lib_engine_api_i18n_55d74075aa10()
+local engine_key = src_lib_engine_api_key_55d7407bfbd0()
+local engine_log = src_lib_engine_api_log_55d7407a7ec0()
+local engine_math = src_lib_engine_api_math_55d740799d40()
+local engine_array = src_lib_engine_api_array_55d740779000()
+local engine_media = src_lib_engine_api_media_55d7407489d0()
+local engine_draw_fps = src_lib_engine_draw_fps_55d740798890()
+local engine_draw_text = src_lib_engine_draw_text_55d7407c8b90()
+local engine_draw_poly = src_lib_engine_draw_poly_55d740799b40()
+local engine_raw_memory = src_lib_engine_raw_memory_55d74079abd0()
+local callback_http = src_lib_protocol_http_callback_55d74079bca0()
+local application_default = src_lib_object_root_55d7407b5bb0()
+local color = src_lib_object_color_55d7407a8380()
+local std = src_lib_object_std_55d74076e7c0()
 local application = application_default
 local engine = {
 keyboard = function(a, b, c, d) end,
 current = application_default,
 root = application_default
 }
+local cfg_system = {
+exit = native_system_exit,
+reset = native_system_reset,
+title = native_system_title,
+get_fps = native_system_get_fps,
+get_secret = native_system_get_secret,
+get_language = native_system_get_language
+}
+local cfg_media = {
+bootstrap=native_media_bootstrap,
+position=native_media_position,
+resize=native_media_resize,
+pause=native_media_pause,
+load=native_media_load,
+play=native_media_play
+}
+local cfg_poly = {
+repeats = {
+native_cfg_poly_repeat_0 or false,
+native_cfg_poly_repeat_1 or false,
+native_cfg_poly_repeat_2 or false
+},
+triangle = native_draw_triangle,
+poly2 = native_draw_poly2,
+poly = native_draw_poly,
+line = native_draw_line
+}
 local cfg_text = {
 font_previous = native_text_font_previous
 }
+local cfg_http = {
+install = native_http_install,
+handler = native_http_handler,
+has_ssl = native_http_has_ssl,
+has_callback = native_http_has_callback,
+force = native_http_force_protocol
+}
+local cfg_log = {
+fatal = native_log_fatal,
+error = native_log_error,
+warn = native_log_warn,
+info = native_log_info,
+debug = native_log_debug
+}
+local cfg_base64 = {
+decode = native_base64_decode,
+encode = native_base64_encode
+}
+local cfg_json = {
+decode = native_json_decode,
+encode = native_json_encode
+}
+local cfg_xml = {
+decode = native_xml_decode,
+encode = native_xml_encode
+}
 function native_callback_loop(dt)
 std.milis = std.milis + dt
 std.delta = dt
@@ -64,6 +124,12 @@ end
 function native_callback_keyboard(key, value)
 engine.keyboard(std, engine, key, value)
 end
+function native_callback_http(id, key, data)
+if cfg_http.has_callback then
+return callback_http.func(engine['http_requests'][id], key, data)
+end
+return nil
+end
 function native_callback_init(width, height, game_lua)
 application = zeebo_module.loadgame(game_lua)
 if application then
@@ -91,28 +157,34 @@ std.text.font_default=native_text_font_default
 std.draw.clear=function(tint)
 native_draw_clear(tint, 0, 0, application.data.width, application.data.height)
 end
+engine.root = application
 zeebo_module.require(std, application, engine)
 :package('@memory', engine_raw_memory)
-:package('@game', engine_game, native_dict_game)
+:package('@game', engine_game, cfg_system)
 :package('@math', engine_math)
 :package('@array', engine_array)
 :package('@key', engine_key, {})
 :package('@draw.fps', engine_draw_fps)
 :package('@draw.text', engine_draw_text, cfg_text)
-:package('@draw.poly', engine_draw_poly, native_dict_poly)
+:package('@draw.poly', engine_draw_poly, cfg_poly)
 :package('@color', color)
+:package('@log', engine_log, cfg_log)
 :package('math', engine_math.clib)
 :package('math.random', engine_math.clib_random)
-:package('http', engine_http, native_dict_http)
-:package('json', engine_encoder, native_dict_json)
-:package('xml', engine_encoder, native_dict_xml)
-:package('i18n', engine_i18n, native_get_system_lang)
-:package('hash', engine_hash, native_dict_secret)
+:package('http', engine_http, cfg_http)
+:package('base64', engine_encoder, cfg_base64)
+:package('json', engine_encoder, cfg_json)
+:package('xml', engine_encoder, cfg_xml)
+:package('i18n', engine_i18n, cfg_system)
+:package('hash', engine_hash, cfg_system)
+:package('media.video', engine_media, cfg_media)
+:package('media.audio', engine_media, cfg_media)
+:package('mock.video', engine_media)
+:package('mock.audio', engine_media)
 :run()
 application.data.width, std.app.width = width, width
 application.data.height, std.app.height = height, height
 std.app.title(application.meta.title..' - '..application.meta.version)
-engine.root = application
 engine.current = application
 application.callbacks.init(std, application.data)
 end
@@ -126,13 +198,13 @@ version=version
 }
 return P
 end
-core_src_version = function()
-return '0.0.17'
+src_version_55d740741220 = function()
+return '0.0.19'
 end
 --
-core_src_lib_common_module = function()
-local zeebo_pipeline = core_src_lib_util_pipeline()
-local application_default = core_src_lib_object_root()
+src_lib_common_module_55d74078d4c0 = function()
+local zeebo_pipeline = src_lib_util_pipeline_55d7407bc4c0()
+local application_default = src_lib_object_root_55d7407b5bb0()
 local function default(application, defaults)
 if not application then return nil end
 local index = 1    
@@ -330,7 +402,7 @@ require = require
 return P
 end
 --
-core_src_lib_engine_api_encoder = function()
+src_lib_engine_api_encoder_55d740797c20 = function()
 local function install(std, engine, library, name)
 std = std or {}
 std[name] = {
@@ -345,8 +417,8 @@ install=install
 return P
 end
 --
-core_src_lib_engine_api_app = function()
-local util_decorator = core_src_lib_util_decorator()
+src_lib_engine_api_app_55d7407cdb00 = function()
+local util_decorator = src_lib_util_decorator_55d7407a7e30()
 local function reset(std, engine)
 if std.node then
 std.bus.emit('exit')
@@ -377,7 +449,7 @@ end)
 std.app.title = util_decorator.prefix1(config.set_title, title)
 std.app.exit = util_decorator.prefix1(std, exit)
 std.app.reset = util_decorator.prefix2(std, engine, reset)
-std.app.get_fps = config.fps
+std.app.get_fps = config.get_fps
 return std.app
 end
 local P = {
@@ -386,7 +458,7 @@ install=install
 return P
 end
 --
-core_src_lib_engine_api_hash = function()
+src_lib_engine_api_hash_55d740798450 = function()
 local function djb2(digest)
 local index = 1
 local hash = 5381
@@ -399,27 +471,12 @@ hash = string.format('%08x', hash)
 hash = tonumber(hash:sub(#hash - 7), 16)
 return hash
 end
-local function fingerprint(all_your_secrets)
-local index = 1
-local digest = ''
-while index <= #all_your_secrets do
-local value = all_your_secrets[index]
-if type(value) == 'function' then
-digest = digest..tostring(value())
-else
-digest = digest..tostring(value)
-end
-index = index + 1
-end
-return djb2(digest)
-end
-local function install(std, engine, all_your_secrets)
-local id = fingerprint(all_your_secrets or {'not secret!'})
+local function install(std, engine, cfg_system)
+local id = djb2(cfg_system.get_secret())
 std = std or {}
 std.hash = std.hash or {}
 std.hash.djb2 = djb2
 std.hash.fingerprint = function() return id end
-return {hash=std.hash}
 end
 local P = {
 install = install
@@ -427,8 +484,8 @@ install = install
 return P
 end
 --
-core_src_lib_engine_api_http = function()
-local zeebo_pipeline = core_src_lib_util_pipeline()
+src_lib_engine_api_http_55d74079e880 = function()
+local zeebo_pipeline = src_lib_util_pipeline_55d7407bc4c0()
 local function fast(self)
 self.speed = '_fast'
 return self
@@ -457,17 +514,28 @@ local function failed(self, handler_func)
 self.failed_handler = handler_func
 return self
 end
-local function error(self, handler_func)
+local function http_error(self, handler_func)
 self.error_handler = handler_func
 return self
 end
-local function request(method, std, engine, protocol_handler)
+local function request(method, std, engine, protocol)
 local callback_handler = function()
+if std.node then
 std.node.emit(engine.current, 'http')
+elseif engine.current.callbacks.http then
+engine.current.callbacks.http(std, engine.current.data)
+end
 end
 return function (url)
+if protocol.has_callback then
+engine.http_count = engine.http_count + 1
+end
+if protocol.force then
+url = url:gsub("^[^:]+://", protocol.force.."://")
+end
 local game = engine.current.data
 local self = {
+id = engine.http_count,
 url = url,
 speed = '',
 method = method,
@@ -476,21 +544,17 @@ header_list = {},
 header_dict = {},
 param_list = {},
 param_dict = {},
-callback_handler = callback_handler,
 success_handler = function (std, game) end,
 failed_handler = function (std, game) end,
 error_handler = function (std, game) end,
-std = std,
-game = game,
 fast = fast,
 body = body,
 param = param,
 header = header,
 success = success,
 failed = failed,
-error = error,
+error = http_error,
 run = zeebo_pipeline.run,
-protocol_handler = protocol_handler
 }
 self.promise = function()
 zeebo_pipeline.stop(self)
@@ -499,29 +563,31 @@ self.resolve = function()
 zeebo_pipeline.resume(self)
 end
 self.set = function (key, value)
-self.std.http[key] = value
+std.http[key] = value
 end
 self.pipeline = {
 function()
-self:protocol_handler()
+if protocol.has_callback then engine.http_requests[self.id] = self end
+protocol.handler(self, self.id)
 end,
 function()
-self.callback_handler(self.std, self.game)
-if self.std.http.ok then
-self.success_handler(self.std, self.game)
-elseif self.std.http.error or not self.std.http.status then
-self.error_handler(self.std, self.game)
+callback_handler(std, game)
+if std.http.ok then
+self.success_handler(std, game)
+elseif std.http.error or not std.http.status then
+self.error_handler(std, game)
 else
-self.failed_handler(self.std, self.game)
+self.failed_handler(std, game)
 end
 end,
 function ()
-self.std.http.ok = nil
-self.std.http.body = nil
-self.std.http.error = nil
-self.std.http.status = nil
+std.http.ok = nil
+std.http.body = nil
+std.http.error = nil
+std.http.status = nil
 end,
 function()
+if protocol.has_callback then engine.http_requests[self.id] = nil end
 zeebo_pipeline.reset(self)
 end
 }
@@ -529,20 +595,21 @@ return self
 end
 end
 local function install(std, engine, protocol)
-local protocol_handler = protocol.handler
+assert(protocol.handler, 'missing protocol handler')
+if protocol.has_callback then
+engine.http_count = 0
+engine.http_requests = {}
+end
 std.http = std.http or {}
-std.http.get=request('GET', std, engine, protocol_handler)
-std.http.head=request('HEAD', std, engine, protocol_handler)
-std.http.post=request('POST', std, engine, protocol_handler)
-std.http.put=request('PUT', std, engine, protocol_handler)
-std.http.delete=request('DELETE', std, engine, protocol_handler)
-std.http.patch=request('PATCH', std, engine, protocol_handler)
+std.http.get=request('GET', std, engine, protocol)
+std.http.head=request('HEAD', std, engine, protocol)
+std.http.post=request('POST', std, engine, protocol)
+std.http.put=request('PUT', std, engine, protocol)
+std.http.delete=request('DELETE', std, engine, protocol)
+std.http.patch=request('PATCH', std, engine, protocol)
 if protocol.install then
 protocol.install(std, engine)
 end
-return {
-std={http=std.http}
-}
 end
 local P = {
 install=install
@@ -550,7 +617,7 @@ install=install
 return P
 end
 --
-core_src_lib_engine_api_i18n = function()
+src_lib_engine_api_i18n_55d74075aa10 = function()
 local language = 'en-US'
 local language_default = 'en-US'
 local language_list = {}
@@ -607,21 +674,24 @@ return function (x, y, text, a, b, c)
 return func(x, y, get_text(text), a, b, c)
 end
 end
-local function event_bus(std, engine)
-std.bus.listen('ret_i18n', function(result)
-update_languages(result)
-end)
-std.bus.emit_next('i18n')
-end
-local function install(std, engine, system_language)
+local function install(std, engine, cfg)
 if not (std and std.text and std.text.print) then
 error('missing draw text')
 end
 local old_put = std.text.put
 local old_print = std.text.print
 local old_print_ex = std.text.print_ex
-if system_language then
-set_language(system_language())
+local callback_lang = function(result)
+update_languages(result)
+if cfg and cfg.get_language then
+set_language(cfg.get_language())
+end
+end
+if not std.node and engine.root.callbacks.i18n then
+callback_lang(engine.root.callbacks.i18n())
+else
+std.bus.listen('ret_i18n', callback_lang)
+std.bus.emit_next('i18n')
 end
 std.text.put = decorator_draw_text(old_put)
 std.text.print = decorator_draw_text(old_print)
@@ -632,23 +702,14 @@ std.i18n.get_language = get_language
 std.i18n.set_language = set_language
 std.i18n.back = back_language
 std.i18n.next = next_language
-return {
-std={
-i18n=std.i18n,
-draw={
-text=std.draw.text
-}
-}
-}
 end
 local P = {
-event_bus=event_bus,
 install=install
 }
 return P
 end
 --
-core_src_lib_engine_api_key = function()
+src_lib_engine_api_key_55d7407bfbd0 = function()
 local function real_key(std, engine, rkey, rvalue)
 local value = rvalue == 1 or rvalue == true
 local key = engine.key_bindings[rkey] or (std.key.axis[rkey] and rkey)
@@ -663,6 +724,8 @@ std.key.axis.y = std.key.axis.down - std.key.axis.up
 end
 std.bus.emit('key')
 end
+local a = std.key.axis
+std.key.press.any = (a.left + a.right + a.down + a.up + a.a + a.b + a.c + a.d + a.menu) > 0
 end
 local function real_keydown(std, engine, key)
 real_key(std, engine, key, 1)
@@ -686,7 +749,54 @@ install = install
 return P
 end
 --
-core_src_lib_engine_api_math = function()
+src_lib_engine_api_log_55d7407a7ec0 = function()
+local util_decorator = src_lib_util_decorator_55d7407a7e30()
+local logging_types = {
+'none', 'fatal', 'error', 'warn', 'debug', 'info'
+}
+local function level(engine, lpf, lpn, level)
+local l = lpf[level] or lpn[level] or level
+if type(l) ~= 'number' or l <= 0 or l > #logging_types then
+error('logging level not exist: '..tostring(level)) 
+end
+engine.loglevel = l
+end
+local function init(std, engine, printers)
+local index = 1
+local level_per_func = {}
+local level_per_name = {}
+while index <= #logging_types do
+local ltype = logging_types[index]
+local lfunc = function() end
+if index > 1 and printers[ltype] then
+lfunc = (function (level)
+return function(message)
+if engine.loglevel >= level then
+printers[ltype](message)
+end
+end
+end)(index - 1)
+end
+level_per_func[lfunc] = index - 1
+level_per_name[ltype] = index - 1
+std.log[ltype] = lfunc
+index = index + 1
+end
+std.log.level = util_decorator.prefix3(engine, level_per_func, level_per_name, level)
+end
+local function install(std, engine, printers)
+std.log = std.log or {}
+engine.loglevel = #logging_types
+std.log.init = util_decorator.prefix2(std, engine, init)
+std.log.init(printers)
+end
+local P = {
+install = install
+}
+return P
+end
+--
+src_lib_engine_api_math_55d740799d40 = function()
 local function abs(value)
 if value < 0 then
 return -value
@@ -705,10 +815,6 @@ end
 local function clamp2(value, value_min, value_max)
 return (value - value_min) % (value_max - value_min + 1) + value_min
 end
-local function cycle(passed, duration)
-local endtime = (passed) % duration
-return ((endtime == 0 and (passed % (duration * 2)) or endtime)) / duration
-end
 local function dir(value, alpha)
 alpha = alpha or 0
 if value < -alpha then
@@ -720,11 +826,15 @@ return 0
 end
 end
 local function dis(x1,y1,x2,y2)
-return ((x2 - x1) ^ 2 + (y2 - y1) ^ 2) ^ 0.5
+local sqr = 1/2
+return ((x2 - x1) ^ 2 + (y2 - y1) ^ 2) ^ (sqr ~= 0 and sqr or 1)
 end
 local function dis2(x1,y1,x2,y2)
 return (x2 - x1) ^ 2 + (y2 - y1) ^ 2
 end
+local function dis3(x1,y1,x2,y2)
+return abs(x1 - x2) + abs(x2 - y2)
+end
 local function lerp(a, b, alpha)
 return a + alpha * ( b - a )
 end 
@@ -765,31 +875,20 @@ index = index + 1
 end
 return min_value
 end
-local function saw(value)
-if value < 0.25 then
-return value * 4
-elseif value < 0.50 then
-return 1 - ((value - 0.25) * 4)
-elseif value < 0.75 then
-return ((value - 0.50) * 4) * (-1)
-end
-return ((value - 0.75) * 4) - 1
-end
 local function install(std)
 std = std or {}
 std.math = std.math or {}
 std.math.abs=abs
 std.math.clamp=clamp
 std.math.clamp2=clamp2
-std.math.cycle=cycle
 std.math.dir=dir
 std.math.dis=dis
 std.math.dis2=dis2
+std.math.dis3=dis3
 std.math.lerp=lerp
 std.math.map=map
 std.math.max=max
 std.math.min=min
-std.math.saw=saw
 return std.math
 end
 local function install_clib(std)
@@ -844,8 +943,8 @@ install = install_clib_random
 return P;
 end
 --
-core_src_lib_engine_api_array = function()
-local util_decorator = core_src_lib_util_decorator()
+src_lib_engine_api_array_55d740779000 = function()
+local util_decorator = src_lib_util_decorator_55d7407a7e30()
 local function array_map(array, func)
 local res = {}
 local index = 1
@@ -955,17 +1054,6 @@ index = index + 1
 end
 return true
 end
-local function array_compare(array, func)
-local index = 1
-local length = #array 
-while index < length do
-if not func(array[index], array[index + 1]) then
-return false
-end
-index = index + 1
-end
-return true
-end
 local function array_pipeline(std, array)
 local decorator_iterator = function(func) 
 return function(self, func2, extra)
@@ -991,7 +1079,6 @@ first = decorator_reduce(array_first),
 last = decorator_reduce(array_last),
 some = decorator_reduce(array_some),
 every = decorator_reduce(array_every),
-compare = decorator_reduce(array_compare),
 table = function(self) return self.array end,
 json = function(self) return std.json.encode(self.array) end
 }
@@ -999,6 +1086,7 @@ return self
 end
 local function install(std, engine, library, name)
 local lib = std[name] or {}
+lib.map = array_map
 lib.filter = array_filter
 lib.unique = array_unique
 lib.each = array_foreach
@@ -1008,7 +1096,6 @@ lib.first = array_first
 lib.last = array_last
 lib.some = array_some
 lib.every = array_every
-lib.compare = array_compare
 lib.from = util_decorator.prefix1(std, array_pipeline)
 std[name] = lib
 end
@@ -1018,7 +1105,86 @@ install = install
 return P
 end
 --
-core_src_lib_engine_draw_fps = function()
+src_lib_engine_api_media_55d7407489d0 = function()
+local util_decorator = src_lib_util_decorator_55d7407a7e30()
+local function media_add(media, func, self, src)
+func(media - 1, self.id - 1, src)
+return self
+end
+local function media_play(media, func, self)
+func(media - 1, self.id - 1)
+return self
+end
+local function media_pause(media, func, self)
+func(media - 1, self.id - 1)
+return self
+end
+local function media_resize(media, func, self, width, height)
+func(media - 1, self.id - 1, width, height)
+return self
+end
+local function media_position(media, func, self, pos_x, pos_y)
+func(media - 1, self.id - 1, pos_x, pos_y)
+return self
+end
+local function media_channel(std, handler, mediatype, mediaid, max_channels)
+return function(id)
+local channels = std.media.channels[mediaid]
+id = id or 1
+if 0 >= id or id > max_channels then
+error('Please, do not do that!')
+end
+if not channels[id] then
+channels[id] = {
+id = id,
+add = util_decorator.prefix2(mediaid, handler.load, media_add),
+play = util_decorator.prefix2(mediaid, handler.play, media_play),
+pause = util_decorator.prefix2(mediaid, handler.pause, media_pause),
+resize = util_decorator.prefix2(mediaid, handler.resize, media_resize),
+position = util_decorator.prefix2(mediaid, handler.position, media_position)
+}
+if std.node then
+channels[id].node = std.node.load({})
+channels[id].apply = function()
+local node = channels[id].node
+local depth = 0
+local offset_x = 0
+local offset_y = 0
+while node and depth < 100 do
+offset_x = offset_x + node.config.offset_x
+offset_y = offset_y + node.config.offset_y
+node = node.config.parent
+depth = depth + 1
+end
+media_position(handler.position, channels[id], offset_x, offset_y)
+media_resize(handler.resize, channels[id], channels[id].node.data.width, channels[id].node.data.height)
+end
+end
+end
+return channels[id]
+end
+end
+local function install(std, engine, handlers, name)
+handlers = handlers or {}
+std.media = std.media or {}
+std.media.types = std.media.types or {}
+std.media.channels = std.media.channels or {}
+local mediatype = name:match('%w+%.(%w+)')
+local mediaid = #std.media.types + 1
+if not std.media[mediatype] then
+local max_channels = handlers.bootstrap and handlers.bootstrap(mediaid - 1, mediatype) or 8
+std.media.channels[mediaid] = {}
+std.media.types[mediaid] = mediatype
+std.media[mediatype] = media_channel(std, handlers, mediatype, mediaid, max_channels)
+end
+end
+local P = {
+install=install
+}
+return P
+end
+--
+src_lib_engine_draw_fps_55d740798890 = function()
 local function draw_fps(std, engine, show, pos_x, pos_y)
 if show < 1 then return end
 local x = engine.current.config.offset_x + pos_x
@@ -1035,19 +1201,19 @@ if show >= 3 then
 std.draw.rect(0, x + 96, y, 40, 24)
 end
 std.draw.color(0x000000FF)
-std.draw.font('Tiresias', 16)
+std.text.font_size(16)
 if show >= 3 then
 local floor = std.math.floor or math.floor or function() return 'XX' end
 local fps =  floor((1/std.delta) * 1000)
-std.draw.text(x + s, y, fps)
+std.text.print(x + s, y, fps)
 s = s + 46
 end
 if show >= 1 then
-std.draw.text(x + s, y, engine.fps)
+std.text.print(x + s, y, engine.fps)
 s = s + 46
 end
 if show >= 2 then
-std.draw.text(x + s, y, engine.root.config.fps_max)
+std.text.print(x + s, y, engine.root.config.fps_max)
 s = s + 46
 end
 end
@@ -1070,8 +1236,8 @@ install=install
 return P
 end
 --
-core_src_lib_engine_draw_text = function()
-local util_decorator = core_src_lib_util_decorator()
+src_lib_engine_draw_text_55d7407c8b90 = function()
+local util_decorator = src_lib_util_decorator_55d7407a7e30()
 local function text_put(std, engine, font_previous, pos_x, pos_y, text, size)
 size = size or 2
 local hem = engine.current.data.width / 80
@@ -1098,7 +1264,7 @@ install=install
 return P
 end
 --
-core_src_lib_engine_draw_poly = function()
+src_lib_engine_draw_poly_55d740799b40 = function()
 local function decorator_poo(object, func)
 if not object or not func then return func end
 return function(a, b, c, d)
@@ -1205,21 +1371,25 @@ install=install
 return P
 end
 --
-core_src_lib_engine_raw_memory = function()
+src_lib_engine_raw_memory_55d74079abd0 = function()
 local memory_dict_unload = {}
 local memory_dict = {}
 local memory_list = {}
-local function cache(key, load_func, unload_func)
-if memory_dict[key] then
+local function cache_get(key)
 return memory_dict[key]
 end
-if not load_func then
-return nil
-end
+local function cache_set(key, load_func, unload_func)
 local value = load_func()
 memory_list[#memory_list + 1] = key
 memory_dict_unload[key] = unload_func
 memory_dict[key] = value
+end
+local function cache(key, load_func, unload_func)
+local value = cache_get(key)
+if value == nil then
+cache_set(key, load_func, unload_func)
+value = cache_get(key)
+end    
 return value
 end
 local function unset(key)
@@ -1242,6 +1412,8 @@ local function install(std)
 std = std or {}
 std.mem = std.mem or {}
 std.mem.cache = cache
+std.mem.cache_get = cache_get
+std.mem.cache_set = cache_set
 std.mem.unset = unset
 std.mem.gc_clear_all = gc_clear_all
 return {
@@ -1254,7 +1426,75 @@ install=install
 return P
 end
 --
-core_src_lib_object_root = function()
+src_lib_protocol_http_callback_55d74079bca0 = function()
+local http_util = src_lib_util_http_55d74078aa00()
+local callbacks = {
+['async-promise'] = function(self)
+return self:promise()
+end,
+['async-resolve'] = function(self)
+return self:resolve()
+end,
+['get-url'] = function(self)
+return self.url
+end,
+['get-fullurl'] = function(self)
+return self.url..http_util.url_search_param(self.param_list, self.param_dict)
+end,
+['get-method'] = function(self)
+return self.method
+end,
+['get-body'] = function(self)
+return self.body_content
+end,
+['get-param-count'] = function(self)
+return #self.param_list
+end,
+['get-param-name'] = function(self, data)
+return self.param_list[self.data]
+end,
+['get-param-data'] = function(self, data)
+return self.param_dict[self.data] or self.param_dict[self.param_list[self.data]]
+end,
+['get-header-count'] = function(self)
+return #self.header_list
+end,
+['get-header-name'] = function(self, data)
+return self.header_list[self.data]
+end,
+['get-header-data'] = function(self, data)
+return self.heeader_dict[self.data] or self.heeader_dict[self.header_list[self.data]]
+end,
+['set-status'] = function(self, data)
+self.set('status', data)
+self.set('ok', http_util.is_ok(data))
+end,
+['set-error'] = function(self, data)
+self.set('error', data)
+end,
+['set-ok'] = function(self, data)
+self.set('ok', data)
+end,
+['set-body'] = function(self, data)
+self.set('body', data)
+end,
+['add-body-data'] = function(self, data, std)
+self.set('body', (std.http.body or '')..data)
+end    
+}
+local function native_http_callback(self, evt, data, std)
+if not callbacks[evt] then
+error('http evt '..evt..' not exist!')
+end
+return callbacks[evt](self, data, std)
+end
+local P = {
+func = native_http_callback
+}
+return P
+end
+--
+src_lib_object_root_55d7407b5bb0 = function()
 local P = {
 data={
 width=1280,
@@ -1273,7 +1513,7 @@ config = {
 offset_x = 0,
 offset_y = 0,
 require = '',
-fps_max = 100,
+fps_max = 60,
 fps_show = 0,
 fps_drop = 5,
 fps_time = 5
@@ -1284,7 +1524,7 @@ callbacks={
 return P;
 end
 --
-core_src_lib_object_color = function()
+src_lib_object_color_55d7407a8380 = function()
 local white = 0xFFFFFFFF
 local lightgray = 0xC8CCCCFF
 local gray = 0x828282FF
@@ -1346,7 +1586,7 @@ install = install
 return P
 end
 --
-core_src_lib_object_std = function()
+src_lib_object_std_55d74076e7c0 = function()
 local P = {
 milis = 0,
 delta = 0,
@@ -1400,14 +1640,15 @@ right=false,
 a=false,
 b=false,
 c=false,
-d=false
+d=false,
+any=false
 }
 }
 }
 return P;
 end
 --
-core_src_lib_util_pipeline = function()
+src_lib_util_pipeline_55d7407bc4c0 = function()
 local function pipe(self)
 return function()
 self:run()
@@ -1457,7 +1698,7 @@ run=run
 return P
 end
 --
-core_src_lib_util_decorator = function()
+src_lib_util_decorator_55d7407a7e30 = function()
 local function decorator_prefix3(zig, zag, zom, func)
 return function (a, b, c, d, e, f)
 return func(zig, zag, zom, a, b, c, d, e, f)
@@ -1507,4 +1748,153 @@ prefix1 = decorator_prefix1
 return P
 end
 --
-return main()
+src_lib_util_http_55d74078aa00 = function()
+local function is_ok(status)
+return (status and 200 <= status and status < 300) or false
+end
+local function is_ok_header(header)
+local status = tonumber(header:match('HTTP/%d.%d (%d%d%d)'))
+local ok = status and is_ok(status) or false
+return ok, status
+end
+local function is_redirect(status)
+return (status and 300 <= status and status < 400) or false
+end
+local function url_search_param(param_list, param_dict)
+local index, params = 1, ''
+while param_list and param_dict and index <= #param_list do
+local param = param_list[index]
+local value = param_dict[param]
+if #params == 0 then
+params = params..'?'
+else
+params = params..'&'
+end
+params = params..param..'='..(value or '')
+index = index + 1
+end
+return params
+end
+local function create_request(method, uri)
+local self = {
+body_content = '',
+header_list = {},
+header_dict = {},
+header_imutable = {},
+print_http_status = true
+}
+self.add_body_content = function (body)
+self.body_content = self.body_content..(body or '')
+return self
+end
+self.add_imutable_header = function (header, value, cond)
+if cond == false then return self end
+if self.header_imutable[header] == nil then
+self.header_list[#self.header_list + 1] = header
+self.header_dict[header] = value
+elseif self.header_imutable[header] == false then
+self.header_dict[header] = value
+end
+self.header_imutable[header] = true
+return self
+end
+self.add_mutable_header = function (header, value, cond)
+if cond == false then return self end
+if self.header_imutable[header] == nil then
+self.header_list[#self.header_list + 1] = header
+self.header_imutable[header] = false
+self.header_dict[header] = value
+end
+return self
+end
+self.add_custom_headers = function(header_list, header_dict)
+local index = 1
+while header_list and #header_list >= index do
+local header = header_list[index]
+local value = header_dict[header]
+if self.header_imutable[header] == nil then
+self.header_list[#self.header_list + 1] = header
+self.header_imutable[header] = false
+self.header_dict[header] = value
+elseif self.header_imutable[header] == false then
+self.header_dict[header] = value
+end
+index = index + 1
+end
+return self
+end
+self.not_status = function()
+self.print_http_status = false
+return self
+end
+self.to_http_protocol = function ()
+local index = 1
+local request = method..' '..uri..' HTTP/1.1\r\n'
+while index <= #self.header_list do
+local header = self.header_list[index]
+local value = self.header_dict[header]
+request = request..header..': '..value..'\r\n'
+index = index + 1
+end
+request = request..'\r\n'
+if method ~= 'GET' and method ~= 'HEAD' and #self.body_content > 0 then
+request = request..self.body_content..'\r\n\r\n'
+end
+return request, function() end
+end
+self.to_curl_cmd = function ()
+local index = 1
+local request = 'curl -L -'..'-silent -'..'-insecure '
+if self.print_http_status then
+request = request..'-w "\n%{http_code}" '
+end
+if method == 'HEAD' then
+request = request..'-'..'-HEAD '
+else
+request = request..'-X '..method..' '
+end
+while index <= #self.header_list do
+local header = self.header_list[index]
+local value = self.header_dict[header]
+request = request..'-H "'..header..': '..value..'" '
+index = index + 1
+end
+if method ~= 'GET' and method ~= 'HEAD' and #self.body_content > 0 then
+request = request..'-d \''..self.body_content..'\' '
+end
+request = request..uri
+return request, function() end
+end
+self.to_wget_cmd = function ()
+local request = 'wget -'..'-quiet -'..'-output-document=-'
+if method == 'HEAD' then
+request = request..' -'..'-method=HEAD'
+elseif method ~= 'GET' then
+request = request..' -'..'-method='..method
+end
+for index, header in ipairs(self.header_list) do
+local value = self.header_dict[header]
+if value then
+local escaped_value = value:gsub('"', '\\"')
+request = request..' -'..'-header="'..header..': '..escaped_value..'"'
+end
+end
+if method ~= 'GET' and method ~= 'HEAD' and #self.body_content > 0 then
+local escaped_body = self.body_content:gsub('"', '\\"')
+request = request..' -'..'-body-data="'..escaped_body..'"'
+end
+request = request..' '..uri
+return request, function() end
+end
+return self
+end
+return {
+is_ok=is_ok,
+is_ok_header=is_ok_header,
+is_redirect=is_redirect,
+url_search_param=url_search_param,
+create_request=create_request
+}
+end
+--
+return main_55d7407a19d0()

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@gamely/gly-engine-lite",
-    "version": "0.0.17",
+    "version": "0.0.19",
     "author": "RodrigoDornelles",
     "license": "Apache-2.0",
     "homepage": "https://docs.gamely.com.br",
@@ -8,7 +8,7 @@
     "funding": "https://github.com/sponsors/RodrigoDornelles",
     "bugs": "https://github.com/gamelly/gly-engine/issues",
     "description": "Game Engine written in 100% lua that runs in a vacuum.",
-    "main": "dist/index.lua",
+    "main": "dist/main.lua",
     "keywords": [
         "game engine",
         "game",