481 lines
14 KiB
Lua
481 lines
14 KiB
Lua
-- main entrypoint 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:
|
|
-- * 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.
|
|
Test_errors = {}
|
|
App.run_tests()
|
|
if #Test_errors > 0 then
|
|
error('There were test failures:\n\n'..table.concat(Test_errors))
|
|
end
|
|
|
|
--? print('==')
|
|
App.disable_tests()
|
|
App.initialize_globals()
|
|
App.initialize(love.arg.parseGameArguments(arg), arg)
|
|
|
|
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
|
|
love.handlers[name](a,b,c,d,e,f)
|
|
end
|
|
end
|
|
|
|
dt = love.timer.step()
|
|
App.update(dt)
|
|
|
|
love.graphics.origin()
|
|
love.graphics.clear(love.graphics.getBackgroundColor())
|
|
App.draw()
|
|
love.graphics.present()
|
|
|
|
love.timer.sleep(0.001)
|
|
end
|
|
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()
|
|
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
|
|
|
|
function colortable(app_color)
|
|
return {app_color.r, app_color.g, app_color.b, app_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
|
|
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] = App[name]
|
|
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()..'/'
|
|
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
|