-- 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()
Version, Major_version = App.love_version()
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
-- abort without running love.quit handler
Disable_all_quit_handlers = true
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 = {}
function App.love_version()
local major_version, minor_version = love.getVersion()
local version = major_version..'.'..minor_version
return version, major_version
end
-- 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
local error_message = ''
if Warning_before_tests then
error_message = Warning_before_tests..'\n\n'
end
error_message = error_message .. ('There were %d test failures:\n%s'):format(#Test_errors, table.concat(Test_errors))
error(error_message)
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)
--? App.initialize_for_test() -- debug: run a single test at a time like these 2 lines
--? test_search()
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, key)
App.keychord_press(chord, key)
App.keyreleased(key)
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) -- most likely to be useful, but set to 0 for a complete stack trace
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
-- uncomment this line for a complete stack trace
--? 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.file_info = nativefs.getInfo
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