@gamely/gly-engine-lite 0.0.14

package/README.md

@@ -0,0 +1,3 @@
+<div align="center">
+<h1>:mechanical_arm:<br>GLY Engine<br><sup><sub>powered by <a href="https://gamely.com.br" target="_blank">gamely.com.br</a></sub></sup></h1>
+</div>

package/dist/main.lua

@@ -0,0 +1,1332 @@
+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_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_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 application = application_default
+local engine = {
+keyboard = function(a, b, c, d) end,
+current = application_default,
+root = application_default
+}
+local cfg_text = {
+font_previous = native_text_font_previous
+}
+function native_callback_loop(dt)
+std.milis = std.milis + dt
+std.delta = dt
+application.callbacks.loop(std, application.data)
+end
+function native_callback_draw()
+native_draw_start()
+application.callbacks.draw(std, application.data)
+native_draw_flush()
+end
+function native_callback_resize(width, height)
+application.data.width = width
+application.data.height = height
+std.app.width = width
+std.app.height = height
+end
+function native_callback_keyboard(key, value)
+engine.keyboard(std, engine, key, value)
+end
+function native_callback_init(width, height, game_lua)
+application = zeebo_module.loadgame(game_lua)
+if application then
+application.data.width = width
+application.data.height = height
+std.app.width = width
+std.app.height = height
+end
+std.bus = {
+emit=function() end,
+emit_next=function() end,
+listen=function() end,
+listen_std_engine=function() end
+}
+std.draw.color=native_draw_color
+std.draw.font=native_draw_font
+std.draw.rect=native_draw_rect
+std.draw.line=native_draw_line
+std.draw.image=native_draw_image
+std.text.print=native_text_print
+std.text.mensure=native_text_mensure
+std.text.font_size=native_text_font_size
+std.text.font_name=native_text_font_name
+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
+zeebo_module.require(std, application, engine)
+:package('@memory', engine_raw_memory)
+:package('@game', engine_game, native_dict_game)
+:package('@math', engine_math)
+:package('@key', engine_key, {})
+:package('@draw.fps', engine_draw_fps)
+:package('@draw.fps', engine_draw_text, cfg_text)
+:package('@draw.poly', engine_draw_poly, native_dict_poly)
+:package('@color', color)
+: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)
+: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
+local P = {
+meta={
+title='gly-engine-lite',
+author='RodrigoDornelles',
+description='native lite',
+version=version
+}
+}
+return P
+end
+core_src_version = function()
+return '0.0.14'
+end
+--
+core_src_lib_common_module = function()
+local zeebo_pipeline = core_src_lib_util_pipeline()
+local application_default = core_src_lib_object_root()
+local function default(application, defaults)
+if not application then return nil end
+local index = 1    
+local items = {'data', 'meta', 'config', 'callbacks'}
+local normalized_aplication = {}
+defaults = defaults or application_default
+while index <= #items do
+local key1 = items[index]
+local keys = defaults[key1]
+normalized_aplication[key1] = {}
+for key2, default_value in pairs(keys) do
+local value = application[key1] and application[key1][key2]
+normalized_aplication[key1][key2] = value or default_value
+end
+index = index + 1
+end
+normalized_aplication.config.id = tostring(application) 
+normalized_aplication.assets = application.assets or {}
+if application.callbacks then
+for event, handler in pairs(application.callbacks) do
+normalized_aplication.callbacks[event] = handler
+end
+end
+return normalized_aplication
+end
+local function normalize(application)
+if not application then return nil end
+if application.Game then
+application = application.Game
+end
+if application.new and type(application.new) == 'function' then
+application = application.new()
+end
+if application and (application.meta or application.callbacks) then
+return application
+end
+local normalized_aplication = {
+data = {},
+meta = {},
+assets = {},
+config = {},
+callbacks = {}
+}
+for key, value in pairs(application) do
+if key == 'assets' then
+normalized_aplication.assets = value
+elseif application_default.meta[key] then
+normalized_aplication.meta[key] = value
+elseif application_default.config[key] then
+normalized_aplication.config[key] = value
+elseif type(value) == 'function' then
+normalized_aplication.callbacks[key] = value
+else
+normalized_aplication.data[key] = value
+end
+end
+return normalized_aplication
+end
+local function loadgame(game_file, defaults)
+if type(game_file) == 'table' or type(game_file) == 'userdata' then
+return default(normalize(game_file), defaults)
+end
+local cwd = '.'
+local application = type(game_file) == 'function' and game_file
+local game_title = not application and game_file and game_file:gsub('%.lua$', '') or 'game'
+if not application and game_file and game_file:find('\n') then
+local ok, app = pcall(load, game_file)
+if not ok then
+ok, app = pcall(loadstring, game_file)
+end
+application = ok and app
+else
+if love and love.filesystem and love.filesystem.getSource then
+cwd = love.filesystem.getSource()
+end
+if not application then
+application = loadfile(cwd..'/'..game_title..'.lua')
+end
+if not application then
+local ok, app = pcall(require, game_title)
+application = ok and app
+end
+end
+if not application and io and io.open and game_file then
+local app_file = io.open(game_file)
+if app_file then
+local app_src = app_file:read('*a')
+local ok, app = pcall(load, app_src)
+if not ok then
+ok, app = pcall(loadstring, app_src)
+end
+application = ok and app
+app_file:close()
+end
+end
+while application and type(application) == 'function' do
+application = application()
+end
+return default(normalize(application), defaults)
+end
+local function package(self, module_name, module, custom)
+local system = module_name:sub(1, 1) == '@'
+local name = system and module_name:sub(2) or module_name
+if system then
+self.list_append(name)
+self.stdlib_required[name] = true
+end
+self.pipeline[#self.pipeline + 1] = function ()
+if not self.list_exist(name) then return end
+if not system and not self.lib_required[name] then return end
+if not system and self.engine.lib_installed[name] then return end
+if system and self.engine.stdlib_installed[name] then return end
+local try_install = function()
+module.install(self.std, self.engine, custom, module_name)
+if module.event_bus then
+module.event_bus(self.std, self.engine, custom, module_name)
+end
+end
+local ok, msg = pcall(try_install)
+if not ok then
+self.lib_error[name] = msg    
+return
+end
+if system then
+self.engine.stdlib_installed[name] = true
+else
+self.engine.lib_installed[name] = true
+end
+end
+return self
+end
+local function require(std, application, engine)
+if not application then
+error('game not found!')
+end
+local application_require = application.config.require
+local next_library = application_require:gmatch('%S+')
+local self = {
+std=std,
+engine=engine,
+package = package,
+event = {},
+list = {},
+lib_error = {},
+lib_optional = {},
+lib_required = {},
+stdlib_required = {},
+pipeline = {},
+pipe = zeebo_pipeline.pipe
+}
+if not engine.lib_installed then
+engine.lib_installed = {}
+engine.stdlib_installed = {}
+end
+self.list_exist = function (name)
+return self.lib_optional[name] or self.lib_required[name] or self.stdlib_required[name]
+end
+self.list_append = function (name)
+if not self.list_exist(name) then
+self.list[#self.list + 1] = name
+end
+end
+self.run = function()
+local index = 1
+zeebo_pipeline.run(self)
+while index <= #self.list do
+local name = self.list[index]
+if self.stdlib_required[name] and not self.engine.stdlib_installed[name] then
+error('system library not loaded: '..name..'\n'..(self.lib_error[name] or ''))
+end
+if self.lib_required[name] and not self.engine.lib_installed[name] then
+error('library not loaded: '..name..'\n'..(self.lib_error[name] or ''))
+end
+index = index + 1
+end
+end
+repeat
+local lib = next_library()
+if lib then
+local name, optional = lib:match('([%w%.]+)([?]?)')
+self.list_append(name)
+if optional and #optional > 0 then
+self.lib_optional[name] = true
+else
+self.lib_required[name] = true
+end
+end
+until not lib
+return self
+end
+local P = {
+loadgame = loadgame,
+require = require
+}
+return P
+end
+--
+core_src_lib_engine_api_encoder = function()
+local function install(std, engine, library, name)
+std = std or {}
+std[name] = {
+encode=library.encode,
+decode=library.decode
+}
+return {[name]=std[name]}
+end
+local P = {
+install=install
+}
+return P
+end
+--
+core_src_lib_engine_api_app = function()
+local util_decorator = core_src_lib_util_decorator()
+local function reset(std, engine)
+if std.node then
+std.bus.emit('exit')
+std.bus.emit('init')
+else
+engine.root.callbacks.exit(std, engine.root.data)
+engine.root.callbacks.init(std, engine.root.data)
+end
+end
+local function exit(std)
+std.bus.emit('exit')
+std.bus.emit('quit')
+end
+local function title(func, window_name)
+if func then
+func(window_name)
+end
+end
+local function install(std, engine, config)
+std = std or {}
+config = config or {}
+std.app = std.app or {}
+std.bus.listen('post_quit', function()
+if config.quit then
+config.quit()
+end
+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
+return std.app
+end
+local P = {
+install=install
+}
+return P
+end
+--
+core_src_lib_engine_api_hash = function()
+local function djb2(digest)
+local index = 1
+local hash = 5381
+while index <= #digest do
+local char = string.byte(digest, index)
+hash = (hash * 33) + char
+index = index + 1
+end
+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!'})
+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
+}
+return P
+end
+--
+core_src_lib_engine_api_http = function()
+local zeebo_pipeline = core_src_lib_util_pipeline()
+local function fast(self)
+self.speed = '_fast'
+return self
+end
+local function body(self, content)
+self.body_content=content
+return self
+end
+local function param(self, name, value)
+local index = #self.param_list + 1
+self.param_list[index] = name
+self.param_dict[name] = value
+return self
+end
+local function header(self, name, value)
+local index = #self.header_list + 1
+self.header_list[index] = name
+self.header_dict[name] = value
+return self
+end
+local function success(self, handler_func)
+self.success_handler = handler_func
+return self
+end
+local function failed(self, handler_func)
+self.failed_handler = handler_func
+return self
+end
+local function error(self, handler_func)
+self.error_handler = handler_func
+return self
+end
+local function request(method, std, engine, protocol_handler)
+local callback_handler = function()
+std.node.emit(engine.current, 'http')
+end
+return function (url)
+local game = engine.current.data
+local self = {
+url = url,
+speed = '',
+method = method,
+body_content = '',
+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,
+run = zeebo_pipeline.run,
+protocol_handler = protocol_handler
+}
+self.promise = function()
+zeebo_pipeline.stop(self)
+end
+self.resolve = function()
+zeebo_pipeline.resume(self)
+end
+self.set = function (key, value)
+self.std.http[key] = value
+end
+self.pipeline = {
+function()
+self:protocol_handler()
+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)
+else
+self.failed_handler(self.std, self.game)
+end
+end,
+function ()
+self.std.http.ok = nil
+self.std.http.body = nil
+self.std.http.error = nil
+self.std.http.status = nil
+end,
+function()
+zeebo_pipeline.reset(self)
+end
+}
+return self
+end
+end
+local function install(std, engine, protocol)
+local protocol_handler = protocol.handler
+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)
+if protocol.install then
+protocol.install(std, engine)
+end
+return {
+std={http=std.http}
+}
+end
+local P = {
+install=install
+}
+return P
+end
+--
+core_src_lib_engine_api_i18n = function()
+local language = 'en-US'
+local language_default = 'en-US'
+local language_list = {}
+local language_inverse_list = {}
+local translate = {}
+local function update_languages(texts)
+local index = 1
+translate = texts
+language_list = {language_default}
+language_inverse_list = {[language_default]=1}
+repeat
+local lang = next(texts)
+if lang then
+index = index + 1
+language_inverse_list[lang] = index
+language_list[#language_list + 1] = lang
+end
+until lang
+end
+local function get_text(old_text)
+local new_text = translate[language] and translate[language][old_text]
+return new_text or old_text
+end
+local function get_language()
+return language
+end
+local function set_language(l)
+if language_inverse_list[l] then
+language = l
+else 
+language = language_default
+end
+end
+local function next_language(to)
+local index = language_inverse_list[language]
+local incr = to or 1
+if index then
+index = index + incr
+if index > #language_list then
+index = 1
+end
+if index <= 0 then
+index = #language_list
+end
+index = index == 0 and 1 or index
+set_language(language_list[index])
+end
+end
+local function back_language()
+next_language(-1)
+end
+local function decorator_draw_text(func)
+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)
+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())
+end
+std.text.put = decorator_draw_text(old_put)
+std.text.print = decorator_draw_text(old_print)
+std.text.print_ex = decorator_draw_text(old_print_ex)
+std.i18n = {}
+std.i18n.get_text = get_text
+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()
+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)
+if key then
+std.key.axis[key] = value and 1 or 0
+std.key.press[key] = value
+if key == 'right' or key == 'left' then
+std.key.axis.x = std.key.axis.right - std.key.axis.left
+end
+if key == 'down' or key == 'up' then
+std.key.axis.y = std.key.axis.down - std.key.axis.up
+end
+std.bus.emit('key')
+end
+end
+local function real_keydown(std, engine, key)
+real_key(std, engine, key, 1)
+end
+local function real_keyup(std, engine, key)
+real_key(std, engine, key, 0)
+end
+local function event_bus(std, engine)
+std.bus.listen_std_engine('rkey', real_key)
+std.bus.listen_std_engine('rkey1', real_keydown)
+std.bus.listen_std_engine('rkey0', real_keyup)
+end
+local function install(std, engine, key_bindings)
+engine.key_bindings = key_bindings or {}
+engine.keyboard = real_key
+end
+local P = {
+event_bus = event_bus,
+install = install
+}
+return P
+end
+--
+core_src_lib_engine_api_math = function()
+local function abs(value)
+if value < 0 then
+return -value
+end
+return value
+end
+local function clamp(value, value_min, value_max)
+if value < value_min then
+return value_min
+elseif value > value_max then
+return value_max
+else
+return value
+end
+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
+return -1
+elseif value > alpha then
+return 1
+else
+return 0
+end
+end
+local function dis(x1,y1,x2,y2)
+return ((x2 - x1) ^ 2 + (y2 - y1) ^ 2) ^ 0.5
+end
+local function dis2(x1,y1,x2,y2)
+return (x2 - x1) ^ 2 + (y2 - y1) ^ 2
+end
+local function lerp(a, b, alpha)
+return a + alpha * ( b - a )
+end 
+local function map(value, in_min, in_max, out_min, out_max)
+return (value - in_min) * (out_max - out_min) / (in_max - in_min) + out_min
+end
+local function max(...)
+local args = {...}
+local index = 1
+local value = nil
+local max_value = nil
+if #args == 1 then
+args = args[1]
+end
+while index <= #args do
+value = args[index]
+if max_value == nil or value > max_value then
+max_value = value
+end
+index = index + 1
+end
+return max_value
+end
+local function min(...)
+local args = {...}
+local index = 1
+local value = nil
+local min_value = nil
+if #args == 1 then
+args = args[1]
+end
+while index <= #args do
+value = args[index]
+if min_value == nil or value < min_value then
+min_value = value
+end
+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.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)
+std = std or {}
+std.math = std.math or {}
+std.math.acos=math.acos
+std.math.asin=math.asin
+std.math.atan=math.atan
+std.math.atan2=math.atan2
+std.math.ceil=math.ceil
+std.math.cos=math.cos
+std.math.cosh=math.cosh
+std.math.deg=math.deg
+std.math.exp=math.exp
+std.math.floor=math.floor
+std.math.fmod=math.fmod
+std.math.frexp=math.frexp
+std.math.huge=math.huge
+std.math.ldexp=math.ldexp
+std.math.log=math.log
+std.math.log10=math.log10
+std.math.modf=math.modf
+std.math.pi=math.pi
+std.math.pow=math.pow
+std.math.rad=math.rad
+std.math.sin=math.sin
+std.math.sinh=math.sinh
+std.math.sqrt=math.sqrt
+std.math.tan=math.tan
+std.math.tanh=math.tanh
+return std.math
+end
+local function install_clib_random(std)
+std = std or {}
+std.math = std.math or {}
+std.math.random = function(a, b)
+a = a and math.floor(a)
+b = b and math.floor(b)
+return math.random(a, b)
+end
+return std.math
+end
+local P = {
+install = install,
+clib = {
+install = install_clib
+},
+clib_random = {
+install = install_clib_random
+}
+}
+return P;
+end
+--
+core_src_lib_engine_draw_fps = 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
+local y = engine.current.config.offset_y + pos_y
+local s = 4
+std.draw.color(0xFFFF00FF)
+if show >= 1 then
+std.draw.rect(0, x, y, 40, 24)
+end
+if show >= 2 then
+std.draw.rect(0, x + 48, y, 40, 24)
+end
+if show >= 3 then
+std.draw.rect(0, x + 96, y, 40, 24)
+end
+std.draw.color(0x000000FF)
+std.draw.font('Tiresias', 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)
+s = s + 46
+end
+if show >= 1 then
+std.draw.text(x + s, y, engine.fps)
+s = s + 46
+end
+if show >= 2 then
+std.draw.text(x + s, y, engine.root.config.fps_max)
+s = s + 46
+end
+end
+local function event_bus(std, engine)
+std.bus.listen('post_draw', function()
+engine.current = engine.root
+draw_fps(std, engine, engine.root.config.fps_show, 8, 8)
+end)
+end
+local function install(std, engine)
+std.app = std.app or {}
+std.app.fps_show = function(show)
+engine.root.config.fps_show = show
+end
+end
+local P = {
+event_bus=event_bus,
+install=install
+}
+return P
+end
+--
+core_src_lib_engine_draw_text = function()
+local util_decorator = core_src_lib_util_decorator()
+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
+local vem = engine.current.data.height / 24
+local font_size = hem * size
+std.text.font_default(0)
+std.text.font_size(font_size)
+std.text.print(pos_x * hem, pos_y * vem, text)
+font_previous()
+end
+local function text_print_ex(std, engine, x, y, text, align)
+local w, h = std.text.mensure(text)
+local aligns = {w, w/2, 0}
+std.text.print(x - aligns[(align or 1) + 2], y, text)
+return w, h
+end
+local function install(std, engine, config)
+std.text.print_ex = util_decorator.prefix2(std, engine, text_print_ex)
+std.text.put = util_decorator.prefix3(std, engine, config.font_previous, text_put)
+end
+local P = {
+install=install
+}
+return P
+end
+--
+core_src_lib_engine_draw_poly = function()
+local function decorator_poo(object, func)
+if not object or not func then return func end
+return function(a, b, c, d)
+return func(object, a, b, c, d)
+end
+end
+local function decorator_line(func_draw_line)
+return function(mode, verts)
+local index = 4
+while index <= #verts do
+func_draw_line(verts[index - 3], verts[index - 2], verts[index - 1], verts[index])
+index = index + 2
+end
+end
+end
+local function decorator_triangle(func_draw_poly, std, func_draw_triangle)
+if not func_draw_triangle then
+return func_draw_poly
+end
+local point = function(x, y, px, py, scale, angle, ox, oy)
+local xx = x + ((ox - px) * -scale * std.math.cos(angle)) - ((ox - py) * -scale * std.math.sin(angle))
+local yy = y + ((oy - px) * -scale * std.math.sin(angle)) + ((oy - py) * -scale * std.math.cos(angle))
+return xx, yy
+end
+return function(engine_mode, verts, x, y, scale, angle, ox, oy)
+if #verts ~= 6 then
+return func_draw_poly(engine_mode, verts, x, y, scale, angle, ox, oy)
+end
+ox = ox or 0
+oy = oy or ox or 0
+local x1, y1 = point(x, y, verts[1], verts[2], scale, angle, ox, oy)
+local x2, y2 = point(x, y, verts[3], verts[4], scale, angle, ox, oy)
+local x3, y3 = point(x, y, verts[5], verts[6], scale, angle, ox, oy)
+return func_draw_triangle(engine_mode, x1, y1, x2, y2, x3, y3)
+end
+end
+local function decorator_poly(func_draw_poly, std, modes, repeats)
+local func_repeat = function(verts, mode)
+if repeats and repeats[mode + 1] then
+verts[#verts + 1] = verts[1]
+verts[#verts + 1] = verts[2]
+end
+end
+return function (engine_mode, verts, x, y, scale, angle, ox, oy)
+if #verts < 6 or #verts % 2 ~= 0 then return end
+local mode = modes and modes[engine_mode + 1] or engine_mode
+local rotated = std.math.cos and angle and angle ~= 0
+ox = ox or 0
+oy = oy or ox or 0
+if x and y and not rotated then
+local index = 1
+local verts2 = {}
+scale = scale or 1
+while index <= #verts do
+if index % 2 ~= 0 then
+verts2[index] = x + (verts[index] * scale)
+else
+verts2[index] = y + (verts[index] * scale)
+end
+index = index + 1
+end
+func_repeat(verts2, engine_mode)
+func_draw_poly(mode, verts2)
+elseif x and y then
+local index = 1
+local verts2 = {}
+while index < #verts do
+local px = verts[index]
+local py = verts[index + 1]
+local xx = x + ((ox - px) * -scale * std.math.cos(angle)) - ((ox - py) * -scale * std.math.sin(angle))
+local yy = y + ((oy - px) * -scale * std.math.sin(angle)) + ((oy - py) * -scale * std.math.cos(angle))
+verts2[index] = xx
+verts2[index + 1] = yy
+index = index + 2
+end
+func_repeat(verts2, engine_mode)
+func_draw_poly(mode, verts2)
+else
+func_draw_poly(mode, verts)
+end
+end
+end
+local function decorator_position(engine, func)
+return function(mode, verts, pos_x, pos_y, scale, angle, ox, oy)
+local x = engine.current.config.offset_x + (pos_x or 0)
+local y = engine.current.config.offset_y + (pos_y or 0)
+ox = ox or 0
+oy = ox or oy or 0
+scale = scale or 1
+angle = angle or 0
+return func(mode, verts, x, y, scale, angle, ox, oy)
+end
+end
+local function install(std, engine, config)
+local draw_line = decorator_poo(config.object, config.line)
+local draw_poly = decorator_poo(config.object, config.poly) or decorator_line(draw_line)
+local draw_poly2 = config.poly2 or decorator_poly(draw_poly, std, config.modes, config.repeats)
+local draw_verts = decorator_triangle(draw_poly2, std, config.triangle)
+std.draw.poly = decorator_position(engine, draw_verts)
+end
+local P = {
+install=install
+}
+return P
+end
+--
+core_src_lib_engine_raw_memory = function()
+local memory_dict_unload = {}
+local memory_dict = {}
+local memory_list = {}
+local function cache(key, load_func, unload_func)
+if memory_dict[key] then
+return memory_dict[key]
+end
+if not load_func then
+return nil
+end
+local value = load_func()
+memory_list[#memory_list + 1] = key
+memory_dict_unload[key] = unload_func
+memory_dict[key] = value
+return value
+end
+local function unset(key)
+if memory_dict_unload[key] then
+memory_dict_unload[key](memory_dict[key])
+end
+memory_dict[key] = nil
+end
+local function gc_clear_all()
+local index = 1
+local items = #memory_list
+while index <= items do
+unset(memory_list[index])
+index = index + 1
+end
+memory_list = {}
+return items
+end
+local function install(std)
+std = std or {}
+std.mem = std.mem or {}
+std.mem.cache = cache
+std.mem.unset = unset
+std.mem.gc_clear_all = gc_clear_all
+return {
+mem=std.mem
+}
+end
+local P = {
+install=install
+}
+return P
+end
+--
+core_src_lib_object_root = function()
+local P = {
+data={
+width=1280,
+height=720
+},
+meta={
+id='',
+title='',
+author='',
+company='',
+description='',
+version=''
+},
+config = {
+offset_x = 0,
+offset_y = 0,
+require = '',
+fps_max = 100,
+fps_show = 0,
+fps_drop = 5,
+fps_time = 5
+},
+callbacks={
+}
+}
+return P;
+end
+--
+core_src_lib_object_color = function()
+local white = 0xFFFFFFFF
+local lightgray = 0xC8CCCCFF
+local gray = 0x828282FF
+local darkgray = 0x505050FF
+local yellow = 0xFDF900FF
+local gold = 0xFFCB00FF
+local orange = 0xFFA100FF
+local pink = 0xFF6DC2FF
+local red = 0xE62937FF
+local maroon = 0xBE2137FF
+local green = 0x00E430FF
+local lime = 0x009E2FFF
+local darkgreen = 0x00752CFF
+local skyblue = 0x66BFFFFF
+local blue = 0x0079F1FF
+local darkblue = 0x0052ACFF
+local purple = 0xC87AFFFF
+local violet = 0x873CBEFF
+local darkpurple = 0x701F7EFF
+local beige = 0xD3B083FF
+local brown = 0x7F6A4FFF
+local darkbrown = 0x4C3F2FFF
+local black = 0x000000FF
+local blank = 0x00000000
+local magenta = 0xFF00FFFF
+local function install(std)
+std = std or {}
+std.color = std.color or {}
+std.color.white = white
+std.color.lightgray = lightgray
+std.color.gray = gray
+std.color.darkgray = darkgray
+std.color.yellow = yellow
+std.color.gold = gold
+std.color.orange = orange
+std.color.pink = pink
+std.color.red = red
+std.color.maroon = maroon
+std.color.green = green
+std.color.lime = lime
+std.color.darkgreen = darkgreen
+std.color.skyblue = skyblue
+std.color.blue = blue
+std.color.darkblue = darkblue
+std.color.purple = purple
+std.color.violet = violet
+std.color.darkpurple = darkpurple
+std.color.beige = beige
+std.color.brown = brown
+std.color.darkbrown = darkbrown
+std.color.black = black
+std.color.blank = blank
+std.color.magenta = magenta
+return std.color
+end
+local P = {
+install = install
+}
+return P
+end
+--
+core_src_lib_object_std = function()
+local P = {
+milis = 0,
+delta = 0,
+math = {
+},
+draw = {
+image = function() end,
+clear = function () end,
+color = function () end,
+rect = function () end,
+line = function () end,
+poly = function () end,
+tui_text = function() end
+},
+text = {
+put = function() end,
+print = function() end,
+mensure = function() end,
+font_size = function() end,
+font_name = function() end,
+font_default = function() end
+},
+app = {
+width = 1280,
+height = 720,
+title = function() end,
+reset = function () end,
+load = function() end,
+exit = function () end
+},
+key = {
+axis = {
+x = 0,
+y = 0,
+menu=0,
+up=0,
+down=0,
+left=0,
+right=0,
+a = 0,
+b = 0, 
+c = 0,
+d = 0
+},
+press = {
+menu=false,
+up=false,
+down=false,
+left=false,
+right=false,
+a=false,
+b=false,
+c=false,
+d=false
+}
+}
+}
+return P;
+end
+--
+core_src_lib_util_pipeline = function()
+local function pipe(self)
+return function()
+self:run()
+end
+end
+local function stop(self)
+if self.pipeline and not self.pipeline2 then
+self.pipeline2 = self.pipeline
+self.pipeline = nil
+end
+end
+local function resume(self)
+if not self.pipeline and self.pipeline2 then
+self.pipeline = self.pipeline2
+self.pipeline2 = nil
+self:run()
+end
+end
+local function run(self)
+self.pipeline_current = self.pipeline_current or 1
+while self.pipeline and self.pipeline_current and self.pipeline_current <= #self.pipeline do
+self.pipeline[self.pipeline_current]()
+if self.pipeline_current then
+self.pipeline_current = self.pipeline_current + 1
+end
+end
+return self
+end
+local function reset(self)
+self.pipeline = self.pipeline or self.pipeline2
+self.pipeline2 = nil
+self.pipeline_current = nil
+end
+local function clear(self)
+self.pipeline_current = nil
+self.pipeline2 = nil
+self.pipeline = nil
+end
+local P = {
+reset=reset,
+clear=clear,
+pipe=pipe,
+stop=stop,
+resume=resume,
+run=run
+}
+return P
+end
+--
+core_src_lib_util_decorator = 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)
+end
+end
+local function decorator_prefix2(zig, zag, func)
+return function (a, b, c, d, e, f)
+return func(zig, zag, a, b, c, d, e, f)
+end
+end
+local function decorator_prefix1(zig, func)
+return function (a, b, c, d, e, f)
+return func(zig, a, b, c, d, e, f)
+end
+end
+local function decorator_offset_xy2(object, func)
+return function(a, b, c, d, e, f)
+local x = object.offset_x + (b or 0)
+local y = object.offset_y + (c or 0)
+return func(a, x, y, d, e, f)
+end
+end
+local function decorator_offset_xyxy1(object, func)
+return function(a, b, c, d, e, f)
+local x1 = object.offset_x + a
+local y1 = object.offset_y + b
+local x2 = object.offset_x + c
+local y2 = object.offset_y + d
+return func(x1, y1, x2, y2, e, f)
+end
+end
+local function decorator_offset_xy1(object, func)
+return function(a, b, c, d, e, f)
+local x = object.offset_x + a
+local y = object.offset_y + b
+return func(x, y, c, d, e, f)
+end
+end
+local P = {
+offset_xy1 = decorator_offset_xy1,
+offset_xy2 = decorator_offset_xy2,
+offset_xyxy1 = decorator_offset_xyxy1,
+prefix3 = decorator_prefix3,
+prefix2 = decorator_prefix2,
+prefix1 = decorator_prefix1
+}
+return P
+end
+--
+return main()

package/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "@gamely/gly-engine-lite",
+    "version": "0.0.14",
+    "author": "RodrigoDornelles",
+    "license": "Apache-2.0",
+    "homepage": "https://docs.gamely.com.br",
+    "repository": "https://github.com/gamelly/gly-engine",
+    "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",
+    "keywords": [
+        "game engine",
+        "game",
+        "engine"
+    ]
+}