@gamely/gly-engine-nano 0.1.5

package/dist/main.lua

@@ -0,0 +1,473 @@
+local source_version_c2b = nil
+local source_engine_api_system_key_c3d = nil
+local source_engine_api_draw_text_c48 = nil
+local source_engine_api_draw_poly_c53 = nil
+local source_engine_api_system_color_c65 = nil
+local source_shared_var_object_std_c70 = nil
+local source_shared_string_eval_code_c82 = nil
+local source_shared_functional_decorator_10a6 = nil
+local function main_c22()
+local version = source_version_c2b()
+local engine_key = source_engine_api_system_key_c3d()
+local engine_api_draw_text = source_engine_api_draw_text_c48()
+local engine_api_draw_poly = source_engine_api_draw_poly_c53()
+local color = source_engine_api_system_color_c65()
+local std = source_shared_var_object_std_c70()
+local eval_code = source_shared_string_eval_code_c82()
+local f=function(a,b)end
+local engine={keyboard=f}
+local application={
+meta={title='', version=''},
+data={width=1280,height=720},
+config={offset_x=0,offset_y=0},
+callbacks={loop=f,draw=f,exit=f,init=f}
+}
+std.log={fatal=f,error=f,warn=f,info=f,debug=f}
+std.bus={emit=f,emit_next=f,listen=f,listen_std_engine=f}
+std.i18n={next=f,back=f,get_language=function()return'en-US'end}
+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={
+is_tui = native_text_is_tui,
+font_previous=native_text_font_previous
+}
+function native_callback_loop(dt)
+std.milis, std.delta=std.milis + dt, 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)
+local ok, script=true, game_lua
+if type(script) == 'string' then
+ok, script=eval_code.script(script)
+end
+if not script then
+ok, script=pcall(loadfile, 'game.lua')
+end
+if not ok or not script then
+error(script, 0)
+end
+std.app.width=width
+std.app.height=height
+script.data={width=width,height=height}
+script.config=application.config
+application=script
+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.image.load=native_image_load
+std.image.draw=native_image_draw
+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
+std.app.reset = function()
+(application.callbacks.exit or function() end)(std, application.data)
+application.callbacks.init(std, application.data)
+end
+engine.root=application
+color.install(std, engine)
+engine_key.install(std, engine, {})
+engine_api_draw_text.install(std, engine, cfg_text)
+engine_api_draw_poly.install(std, engine, cfg_poly)
+engine.current=application
+application.callbacks.init(std, application.data)
+end
+local P={
+meta={
+title='gly-engine-nano',
+author='RodrigoDornelles',
+description='shh!',
+version=version
+}
+}
+return P
+end
+source_version_c2b = function()
+return '0.1.5'
+end
+--
+source_engine_api_system_key_c3d = 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
+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)
+end
+local function real_keyup(std, engine, key)
+real_key(std, engine, key, 0)
+end
+local function install(std, engine, key_bindings)
+engine.key_bindings = key_bindings or {}
+engine.keyboard = real_key
+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 P = {
+install = install
+}
+return P
+end
+--
+source_engine_api_draw_text_c48 = function()
+local util_decorator = source_shared_functional_decorator_10a6()
+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_x, align_y)
+local w, h = std.text.mensure(text)
+local aligns_x, aligns_y = {w, w/2, 0}, {h, h/2, 0}
+std.text.print(x - aligns_x[(align_x or 1) + 2], y - aligns_y[(align_y or 1) + 2], text)
+return w, h
+end
+local function install(std, engine, config)
+std.text.font_previous = config.font_previous
+std.text.is_tui = config.is_tui or function() return false end
+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
+--
+source_engine_api_draw_poly_c53 = 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
+--
+source_engine_api_system_color_c65 = function()
+local function install(std)
+std.color = std.color or {}
+std.color.white = 0xFFFFFFFF
+std.color.lightgray = 0xC8CCCCFF
+std.color.gray = 0x828282FF
+std.color.darkgray = 0x505050FF
+std.color.yellow = 0xFDF900FF
+std.color.gold = 0xFFCB00FF
+std.color.orange = 0xFFA100FF
+std.color.pink = 0xFF6DC2FF
+std.color.red = 0xE62937FF
+std.color.maroon = 0xBE2137FF
+std.color.green = 0x00E430FF
+std.color.lime = 0x009E2FFF
+std.color.darkgreen = 0x00752CFF
+std.color.skyblue = 0x66BFFFFF
+std.color.blue = 0x0079F1FF
+std.color.darkblue = 0x0052ACFF
+std.color.purple = 0xC87AFFFF
+std.color.violet = 0x873CBEFF
+std.color.darkpurple = 0x701F7EFF
+std.color.beige = 0xD3B083FF
+std.color.brown = 0x7F6A4FFF
+std.color.darkbrown = 0x4C3F2FFF
+std.color.black = 0x000000FF
+std.color.blank = 0x00000000
+std.color.magenta = 0xFF00FFFF
+end
+local P = {
+install = install
+}
+return P
+end
+--
+source_shared_var_object_std_c70 = function()
+local P = {
+milis = 0,
+delta = 0,
+math = {
+},
+media = {
+},
+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
+},
+image = {
+load = function() end,
+draw = 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,
+any=false
+}
+}
+}
+return P;
+end
+--
+source_shared_string_eval_code_c82 = function()
+local function script(src)
+local loader = loadstring or load
+if not loader then
+error('eval not allowed')
+end
+local ok, chunk = pcall(loader, src)
+if not ok then
+return false, chunk
+end
+if type(chunk) ~= 'function' then
+return false, 'failed to eval code'
+end
+return pcall(chunk)
+end
+local P = {
+script = script,
+}
+return P
+end
+--
+source_shared_functional_decorator_10a6 = 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 function table_prefix1(prefix, fn_table)
+local new_table = {}
+for name, fn in pairs(fn_table) do
+new_table[name] = decorator_prefix1(prefix, fn)
+end
+return new_table
+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,
+prefix1_t = table_prefix1
+}
+return P
+end
+--
+return main_c22()

package/package.json

@@ -0,0 +1,26 @@
+{
+    "name": "@gamely/gly-engine-nano",
+    "version": "0.1.5",
+    "author": "RodrigoDornelles",
+    "license": "Apache-2.0",
+    "homepage": "https://docs.gamely.com.br",
+    "repository": "https://github.com/gly-engine/gly-engine",
+    "funding": "https://github.com/sponsors/RodrigoDornelles",
+    "bugs": "https://github.com/gly-engine/gly-engine/issues",
+    "description": "Game Engine written in 100% lua that runs in a vacuum.",
+    "main": "dist/main.lua",
+    "browser": "dist/main.lua",
+    "types": "types/main.d.ts",
+    "keywords": [
+        "game engine",
+        "game",
+        "engine"
+    ],
+    "scripts": {
+        "step1": "cd ../.. && rm -Rf dist && mkdir -p ./dist/types",
+        "step2": "cd ../.. && node cli.js build --core nano --bundler --outdir dist/dist",
+        "step3": "cd ../.. && node cli.js meta source/cli/main.lua --infile npm/gly-engine-nano/package.json --outfile dist/package.json",
+        "step4": "cd ../.. && echo \"declare module '@gamely/gly-engine-nano' {\n const content: string;\n export default content;\n}\" > dist/types/main.d.ts",
+        "build": "npm run step1 && npm run step2 && npm run step3 && npm run step4"
+    }
+}

package/types/main.d.ts

@@ -0,0 +1,4 @@
+declare module '@gamely/gly-engine-nano' {
+ const content: string;
+ export default content;
+}