48c05aa77a
This came up when trying to integrate my apps with the vudu debugger (https://github.com/deltadaedalus/vudu). In general, it's a subtle part of LÖVE's semantics that you can modify event handlers any time and your modifications will get picked up. Now my Freewheeling Apps will follow this norm as well.
516 lines
16 KiB
Lua
516 lines
16 KiB
Lua
-- love.run: main entrypoint function for LÖVE
|
|
--
|
|
-- Most apps can just use the default shown in https://love2d.org/wiki/love.run,
|
|
-- but we need to override it to:
|
|
-- * recover from errors (by switching to the source editor)
|
|
-- * run all tests (functions starting with 'test_') on startup, and
|
|
-- * save some state that makes it possible to switch between the main app
|
|
-- and a source editor, while giving each the illusion of complete
|
|
-- control.
|
|
function love.run()
|
|
App.version_check()
|
|
App.snapshot_love()
|
|
-- Tests always run at the start.
|
|
App.run_tests_and_initialize()
|
|
--? print('==')
|
|
|
|
love.timer.step()
|
|
local dt = 0
|
|
|
|
return function()
|
|
if love.event then
|
|
love.event.pump()
|
|
for name, a,b,c,d,e,f in love.event.poll() do
|
|
if name == "quit" then
|
|
if not love.quit or not love.quit() then
|
|
return a or 0
|
|
end
|
|
end
|
|
xpcall(function() love.handlers[name](a,b,c,d,e,f) end, handle_error)
|
|
end
|
|
end
|
|
|
|
dt = love.timer.step()
|
|
xpcall(function() App.update(dt) end, handle_error)
|
|
|
|
love.graphics.origin()
|
|
love.graphics.clear(love.graphics.getBackgroundColor())
|
|
xpcall(App.draw, handle_error)
|
|
love.graphics.present()
|
|
|
|
love.timer.sleep(0.001)
|
|
end
|
|
end
|
|
|
|
function handle_error(err)
|
|
local callstack = debug.traceback('', --[[stack frame]]2)
|
|
Error_message = 'Error: ' .. tostring(err)..'\n'..cleaned_up_callstack(callstack)
|
|
print(Error_message)
|
|
if Current_app == 'run' then
|
|
Settings.current_app = 'source'
|
|
love.filesystem.write('config', json.encode(Settings))
|
|
load_file_from_source_or_save_directory('main.lua')
|
|
App.undo_initialize()
|
|
App.run_tests_and_initialize()
|
|
else
|
|
love.event.quit()
|
|
end
|
|
end
|
|
|
|
-- I tend to read code from files myself (say using love.filesystem calls)
|
|
-- rather than offload that to load().
|
|
-- Functions compiled in this manner have ugly filenames of the form [string "filename"]
|
|
-- This function cleans out this cruft from error callstacks.
|
|
function cleaned_up_callstack(callstack)
|
|
local frames = {}
|
|
for frame in string.gmatch(callstack, '[^\n]+\n*') do
|
|
local line = frame:gsub('^%s*(.-)\n?$', '%1')
|
|
local filename, rest = line:match('([^:]*):(.*)')
|
|
local core_filename = filename:match('^%[string "(.*)"%]$')
|
|
-- pass through frames that don't match this format
|
|
-- this includes the initial line "stack traceback:"
|
|
local new_frame = (core_filename or filename)..':'..rest
|
|
table.insert(frames, new_frame)
|
|
end
|
|
-- the initial "stack traceback:" line was unindented and remains so
|
|
return table.concat(frames, '\n\t')
|
|
end
|
|
|
|
-- The rest of this file wraps around various LÖVE primitives to support
|
|
-- automated tests. Often tests will run with a fake version of a primitive
|
|
-- that redirects to the real love.* version once we're done with tests.
|
|
--
|
|
-- Not everything is so wrapped yet. Sometimes you still have to use love.*
|
|
-- primitives directly.
|
|
|
|
App = {}
|
|
|
|
-- save/restore various framework globals we care about -- only on very first load
|
|
function App.snapshot_love()
|
|
if Love_snapshot then return end
|
|
Love_snapshot = {}
|
|
-- save the entire initial font; it doesn't seem reliably recreated using newFont
|
|
Love_snapshot.initial_font = love.graphics.getFont()
|
|
end
|
|
|
|
function App.undo_initialize()
|
|
love.graphics.setFont(Love_snapshot.initial_font)
|
|
end
|
|
|
|
function App.run_tests_and_initialize()
|
|
App.load()
|
|
Test_errors = {}
|
|
App.run_tests()
|
|
if #Test_errors > 0 then
|
|
error(('There were %d test failures:\n\n%s'):format(#Test_errors, table.concat(Test_errors)))
|
|
end
|
|
App.disable_tests()
|
|
App.initialize_globals()
|
|
App.initialize(love.arg.parseGameArguments(arg), arg)
|
|
end
|
|
|
|
function App.run_tests()
|
|
local sorted_names = {}
|
|
for name,binding in pairs(_G) do
|
|
if name:find('test_') == 1 then
|
|
table.insert(sorted_names, name)
|
|
end
|
|
end
|
|
table.sort(sorted_names)
|
|
for _,name in ipairs(sorted_names) do
|
|
App.initialize_for_test()
|
|
--? print('=== '..name)
|
|
--? _G[name]()
|
|
xpcall(_G[name], function(err) prepend_debug_info_to_test_failure(name, err) end)
|
|
end
|
|
-- clean up all test methods
|
|
for _,name in ipairs(sorted_names) do
|
|
_G[name] = nil
|
|
end
|
|
end
|
|
|
|
function App.initialize_for_test()
|
|
App.screen.init{width=100, height=50}
|
|
App.screen.contents = {} -- clear screen
|
|
App.filesystem = {}
|
|
App.source_dir = ''
|
|
App.current_dir = ''
|
|
App.save_dir = ''
|
|
App.fake_keys_pressed = {}
|
|
App.fake_mouse_state = {x=-1, y=-1}
|
|
App.initialize_globals()
|
|
end
|
|
|
|
-- App.screen.resize and App.screen.move seem like better names than
|
|
-- love.window.setMode and love.window.setPosition respectively. They'll
|
|
-- be side-effect-free during tests, and they'll save their results in
|
|
-- attributes of App.screen for easy access.
|
|
|
|
App.screen={}
|
|
|
|
-- Use App.screen.init in tests to initialize the fake screen.
|
|
function App.screen.init(dims)
|
|
App.screen.width = dims.width
|
|
App.screen.height = dims.height
|
|
end
|
|
|
|
function App.screen.resize(width, height, flags)
|
|
App.screen.width = width
|
|
App.screen.height = height
|
|
App.screen.flags = flags
|
|
end
|
|
|
|
function App.screen.size()
|
|
return App.screen.width, App.screen.height, App.screen.flags
|
|
end
|
|
|
|
function App.screen.move(x,y, displayindex)
|
|
App.screen.x = x
|
|
App.screen.y = y
|
|
App.screen.displayindex = displayindex
|
|
end
|
|
|
|
function App.screen.position()
|
|
return App.screen.x, App.screen.y, App.screen.displayindex
|
|
end
|
|
|
|
-- If you use App.screen.print instead of love.graphics.print,
|
|
-- tests will be able to check what was printed using App.screen.check below.
|
|
--
|
|
-- One drawback of this approach: the y coordinate used depends on font size,
|
|
-- which feels brittle.
|
|
|
|
function App.screen.print(msg, x,y)
|
|
local screen_row = 'y'..tostring(y)
|
|
--? print('drawing "'..msg..'" at y '..tostring(y))
|
|
local screen = App.screen
|
|
if screen.contents[screen_row] == nil then
|
|
screen.contents[screen_row] = {}
|
|
for i=0,screen.width-1 do
|
|
screen.contents[screen_row][i] = ''
|
|
end
|
|
end
|
|
if x < screen.width then
|
|
screen.contents[screen_row][x] = msg
|
|
end
|
|
end
|
|
|
|
function App.screen.check(y, expected_contents, msg)
|
|
--? print('checking for "'..expected_contents..'" at y '..tostring(y))
|
|
local screen_row = 'y'..tostring(y)
|
|
local contents = ''
|
|
if App.screen.contents[screen_row] == nil then
|
|
error('no text at y '..tostring(y))
|
|
end
|
|
for i,s in ipairs(App.screen.contents[screen_row]) do
|
|
contents = contents..s
|
|
end
|
|
check_eq(contents, expected_contents, msg)
|
|
end
|
|
|
|
-- If you access the time using App.get_time instead of love.timer.getTime,
|
|
-- tests will be able to move the time back and forwards as needed using
|
|
-- App.wait_fake_time below.
|
|
|
|
App.time = 1
|
|
function App.get_time()
|
|
return App.time
|
|
end
|
|
function App.wait_fake_time(t)
|
|
App.time = App.time + t
|
|
end
|
|
|
|
function App.width(text)
|
|
return love.graphics.getFont():getWidth(text)
|
|
end
|
|
|
|
-- If you access the clipboard using App.get_clipboard and App.set_clipboard
|
|
-- instead of love.system.getClipboardText and love.system.setClipboardText
|
|
-- respectively, tests will be able to manipulate the clipboard by
|
|
-- reading/writing App.clipboard.
|
|
|
|
App.clipboard = ''
|
|
function App.get_clipboard()
|
|
return App.clipboard
|
|
end
|
|
function App.set_clipboard(s)
|
|
App.clipboard = s
|
|
end
|
|
|
|
-- In tests I mostly send chords all at once to the keyboard handlers.
|
|
-- However, you'll occasionally need to check if a key is down outside a handler.
|
|
-- If you use App.key_down instead of love.keyboard.isDown, tests will be able to
|
|
-- simulate keypresses using App.fake_key_press and App.fake_key_release
|
|
-- below. This isn't very realistic, though, and it's up to tests to
|
|
-- orchestrate key presses that correspond to the handlers they invoke.
|
|
|
|
App.fake_keys_pressed = {}
|
|
function App.key_down(key)
|
|
return App.fake_keys_pressed[key]
|
|
end
|
|
|
|
function App.fake_key_press(key)
|
|
App.fake_keys_pressed[key] = true
|
|
end
|
|
function App.fake_key_release(key)
|
|
App.fake_keys_pressed[key] = nil
|
|
end
|
|
|
|
-- Tests mostly will invoke mouse handlers directly. However, you'll
|
|
-- occasionally need to check if a mouse button is down outside a handler.
|
|
-- If you use App.mouse_down instead of love.mouse.isDown, tests will be able to
|
|
-- simulate mouse clicks using App.fake_mouse_press and App.fake_mouse_release
|
|
-- below. This isn't very realistic, though, and it's up to tests to
|
|
-- orchestrate presses that correspond to the handlers they invoke.
|
|
|
|
App.fake_mouse_state = {x=-1, y=-1} -- x,y always set
|
|
|
|
function App.mouse_move(x,y)
|
|
App.fake_mouse_state.x = x
|
|
App.fake_mouse_state.y = y
|
|
end
|
|
function App.mouse_down(mouse_button)
|
|
return App.fake_mouse_state[mouse_button]
|
|
end
|
|
function App.mouse_x()
|
|
return App.fake_mouse_state.x
|
|
end
|
|
function App.mouse_y()
|
|
return App.fake_mouse_state.y
|
|
end
|
|
|
|
function App.fake_mouse_press(x,y, mouse_button)
|
|
App.fake_mouse_state.x = x
|
|
App.fake_mouse_state.y = y
|
|
App.fake_mouse_state[mouse_button] = true
|
|
end
|
|
function App.fake_mouse_release(x,y, mouse_button)
|
|
App.fake_mouse_state.x = x
|
|
App.fake_mouse_state.y = y
|
|
App.fake_mouse_state[mouse_button] = nil
|
|
end
|
|
|
|
-- If you use App.open_for_reading and App.open_for_writing instead of other
|
|
-- various Lua and LÖVE helpers, tests will be able to check the results of
|
|
-- file operations inside the App.filesystem table.
|
|
|
|
function App.open_for_reading(filename)
|
|
if App.filesystem[filename] then
|
|
return {
|
|
lines = function(self)
|
|
return App.filesystem[filename]:gmatch('[^\n]+')
|
|
end,
|
|
read = function(self)
|
|
return App.filesystem[filename]
|
|
end,
|
|
close = function(self)
|
|
end,
|
|
}
|
|
end
|
|
end
|
|
|
|
function App.read_file(filename)
|
|
return App.filesystem[filename]
|
|
end
|
|
|
|
function App.open_for_writing(filename)
|
|
App.filesystem[filename] = ''
|
|
return {
|
|
write = function(self, s)
|
|
App.filesystem[filename] = App.filesystem[filename]..s
|
|
end,
|
|
close = function(self)
|
|
end,
|
|
}
|
|
end
|
|
|
|
function App.write_file(filename, contents)
|
|
App.filesystem[filename] = contents
|
|
return --[[status]] true
|
|
end
|
|
|
|
function App.mkdir(dirname)
|
|
-- nothing in test mode
|
|
end
|
|
|
|
function App.remove(filename)
|
|
App.filesystem[filename] = nil
|
|
end
|
|
|
|
-- Some helpers to trigger an event and then refresh the screen. Akin to one
|
|
-- iteration of the event loop.
|
|
|
|
-- all textinput events are also keypresses
|
|
-- TODO: handle chords of multiple keys
|
|
function App.run_after_textinput(t)
|
|
App.keypressed(t)
|
|
App.textinput(t)
|
|
App.keyreleased(t)
|
|
App.screen.contents = {}
|
|
App.draw()
|
|
end
|
|
|
|
-- not all keys are textinput
|
|
-- TODO: handle chords of multiple keys
|
|
function App.run_after_keychord(chord)
|
|
App.keychord_press(chord)
|
|
App.keyreleased(chord)
|
|
App.screen.contents = {}
|
|
App.draw()
|
|
end
|
|
|
|
function App.run_after_mouse_click(x,y, mouse_button)
|
|
App.fake_mouse_press(x,y, mouse_button)
|
|
App.mousepressed(x,y, mouse_button)
|
|
App.fake_mouse_release(x,y, mouse_button)
|
|
App.mousereleased(x,y, mouse_button)
|
|
App.screen.contents = {}
|
|
App.draw()
|
|
end
|
|
|
|
function App.run_after_mouse_press(x,y, mouse_button)
|
|
App.fake_mouse_press(x,y, mouse_button)
|
|
App.mousepressed(x,y, mouse_button)
|
|
App.screen.contents = {}
|
|
App.draw()
|
|
end
|
|
|
|
function App.run_after_mouse_release(x,y, mouse_button)
|
|
App.fake_mouse_release(x,y, mouse_button)
|
|
App.mousereleased(x,y, mouse_button)
|
|
App.screen.contents = {}
|
|
App.draw()
|
|
end
|
|
|
|
-- miscellaneous internal helpers
|
|
|
|
function App.color(color)
|
|
love.graphics.setColor(color.r, color.g, color.b, color.a)
|
|
end
|
|
|
|
-- prepend file/line/test
|
|
function prepend_debug_info_to_test_failure(test_name, err)
|
|
local err_without_line_number = err:gsub('^[^:]*:[^:]*: ', '')
|
|
local stack_trace = debug.traceback('', --[[stack frame]]5)
|
|
local file_and_line_number = stack_trace:gsub('stack traceback:\n', ''):gsub(': .*', '')
|
|
local full_error = file_and_line_number..':'..test_name..' -- '..err_without_line_number
|
|
--? local full_error = file_and_line_number..':'..test_name..' -- '..err_without_line_number..'\t\t'..stack_trace:gsub('\n', '\n\t\t')
|
|
table.insert(Test_errors, full_error)
|
|
end
|
|
|
|
nativefs = require 'nativefs'
|
|
|
|
local Keys_down = {}
|
|
|
|
-- call this once all tests are run
|
|
-- can't run any tests after this
|
|
function App.disable_tests()
|
|
-- have LÖVE delegate all handlers to App if they exist
|
|
-- make sure to late-bind handlers like LÖVE's defaults do
|
|
for name in pairs(love.handlers) do
|
|
if App[name] then
|
|
-- love.keyboard.isDown doesn't work on Android, so emulate it using
|
|
-- keypressed and keyreleased events
|
|
if name == 'keypressed' then
|
|
love.handlers[name] = function(key, scancode, isrepeat)
|
|
Keys_down[key] = true
|
|
return App.keypressed(key, scancode, isrepeat)
|
|
end
|
|
elseif name == 'keyreleased' then
|
|
love.handlers[name] = function(key, scancode)
|
|
Keys_down[key] = nil
|
|
return App.keyreleased(key, scancode)
|
|
end
|
|
else
|
|
love.handlers[name] = function(...) App[name](...) end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- test methods are disallowed outside tests
|
|
App.run_tests = nil
|
|
App.disable_tests = nil
|
|
App.screen.init = nil
|
|
App.filesystem = nil
|
|
App.time = nil
|
|
App.run_after_textinput = nil
|
|
App.run_after_keychord = nil
|
|
App.keypress = nil
|
|
App.keyrelease = nil
|
|
App.run_after_mouse_click = nil
|
|
App.run_after_mouse_press = nil
|
|
App.run_after_mouse_release = nil
|
|
App.fake_keys_pressed = nil
|
|
App.fake_key_press = nil
|
|
App.fake_key_release = nil
|
|
App.fake_mouse_state = nil
|
|
App.fake_mouse_press = nil
|
|
App.fake_mouse_release = nil
|
|
-- other methods dispatch to real hardware
|
|
App.screen.resize = love.window.setMode
|
|
App.screen.size = love.window.getMode
|
|
App.screen.move = love.window.setPosition
|
|
App.screen.position = love.window.getPosition
|
|
App.screen.print = love.graphics.print
|
|
App.open_for_reading =
|
|
function(filename)
|
|
local result = nativefs.newFile(filename)
|
|
local ok, err = result:open('r')
|
|
if ok then
|
|
return result
|
|
else
|
|
return ok, err
|
|
end
|
|
end
|
|
App.read_file =
|
|
function(path)
|
|
if not is_absolute_path(path) then
|
|
return --[[status]] false, 'Please use an unambiguous absolute path.'
|
|
end
|
|
local f, err = App.open_for_reading(path)
|
|
if err then
|
|
return --[[status]] false, err
|
|
end
|
|
local contents = f:read()
|
|
f:close()
|
|
return contents
|
|
end
|
|
App.open_for_writing =
|
|
function(filename)
|
|
local result = nativefs.newFile(filename)
|
|
local ok, err = result:open('w')
|
|
if ok then
|
|
return result
|
|
else
|
|
return ok, err
|
|
end
|
|
end
|
|
App.write_file =
|
|
function(path, contents)
|
|
if not is_absolute_path(path) then
|
|
return --[[status]] false, 'Please use an unambiguous absolute path.'
|
|
end
|
|
local f, err = App.open_for_writing(path)
|
|
if err then
|
|
return --[[status]] false, err
|
|
end
|
|
f:write(contents)
|
|
f:close()
|
|
return --[[status]] true
|
|
end
|
|
App.files = nativefs.getDirectoryItems
|
|
App.mkdir = nativefs.createDirectory
|
|
App.remove = nativefs.remove
|
|
App.source_dir = love.filesystem.getSource()..'/' -- '/' should work even on Windows
|
|
App.current_dir = nativefs.getWorkingDirectory()..'/'
|
|
App.save_dir = love.filesystem.getSaveDirectory()..'/'
|
|
App.get_time = love.timer.getTime
|
|
App.get_clipboard = love.system.getClipboardText
|
|
App.set_clipboard = love.system.setClipboardText
|
|
App.key_down = function(key) return Keys_down[key] end
|
|
App.mouse_move = love.mouse.setPosition
|
|
App.mouse_down = love.mouse.isDown
|
|
App.mouse_x = love.mouse.getX
|
|
App.mouse_y = love.mouse.getY
|
|
end
|