.github/workflows/ci-workflow.yml

@@ -7,13 +7,13 @@ jobs:
         name: Build and run
         runs-on: ubuntu-latest
         steps:
-          - uses: actions/checkout@b4ffde65f46336ab88eb53be808477a3936bae11
+          - uses: actions/checkout@v1
-          - uses: actions/setup-java@99b8673ff64fbf99d8d325f52d9a5bdedb8483e9
+          - uses: actions/setup-java@v1
             with:
-                java-version: '21.0.5+11.0.LTS'
+                java-version: '17'
-                distribution: 'temurin'
           - name: Run.sh
             env:
                 DEFOLD_USER: bjorn.ritzl@gmail.com
                 DEFOLD_AUTH: foobar
+                DEFOLD_BOOSTRAP_COLLECTION: /test/test.collectionc
             run: ./.test/run.sh

.gitignore

@@ -9,6 +9,3 @@ build
 builtins
 .internal
 luacov.report.out
-/.editor_settings
-manifest.private.der
-manifest.public.der

.test/run.sh

@@ -5,6 +5,7 @@ else
 	PLATFORM="$1"
 fi
 
+
 echo "${PLATFORM}"
 
 # {"version": "1.2.89", "sha1": "5ca3dd134cc960c35ecefe12f6dc81a48f212d40"}
@@ -15,28 +16,26 @@ echo "Using Defold dmengine_headless version ${SHA1}"
 # Create dmengine_headless and bob.jar URLs
 DMENGINE_URL="http://d.defold.com/archive/${SHA1}/engine/${PLATFORM}/dmengine_headless"
 BOB_URL="http://d.defold.com/archive/${SHA1}/bob/bob.jar"
-DMENGINE_FILE=dmengine_headless_${SHA1}
-BOB_FILE=bob_${SHA1}.jar
 
 # Download dmengine_headless
-if ! [ -f ${DMENGINE_FILE} ]; then
+echo "Downloading ${DMENGINE_URL}"
-	echo "Downloading ${DMENGINE_URL} to ${DMENGINE_FILE}"
+curl -L -o dmengine_headless ${DMENGINE_URL}
-	curl -L -o ${DMENGINE_FILE} ${DMENGINE_URL}
+chmod +x dmengine_headless
-	chmod +x ${DMENGINE_FILE}
-fi
 
 # Download bob.jar
-if ! [ -f ${BOB_FILE} ]; then
+echo "Downloading ${BOB_URL}"
-	echo "Downloading ${BOB_URL} to ${BOB_FILE}"
+curl -L -o bob.jar ${BOB_URL}
-	curl -L -o ${BOB_FILE} ${BOB_URL}
-fi
 
 # Fetch libraries
-echo "Running ${BOB_FILE} - resolving dependencies"
+echo "Running bob.jar - resolving dependencies"
-java -jar ${BOB_FILE} --auth "foobar" --email "john@doe.com" resolve
+java -jar bob.jar --auth "foobar" --email "john@doe.com" resolve
 
-echo "Running ${BOB_FILE} - building"
+echo "Running bob.jar - building"
-java -jar ${BOB_FILE} --debug build --settings=test.settings
+java -jar bob.jar --debug build --keep-unused
 
-echo "Starting ${DMENGINE_FILE}"
+echo "Starting dmengine_headless"
-./${DMENGINE_FILE}
+if [ -n "${DEFOLD_BOOSTRAP_COLLECTION}" ]; then
+	./dmengine_headless --config=bootstrap.main_collection=${DEFOLD_BOOSTRAP_COLLECTION}
+else
+	./dmengine_headless
+fi

README_API.md

@@ -212,21 +212,12 @@ IMPORTANT! You must call `monarch.on_message(message_id, message, sender)` from
 * `fn` (function) - The function to call screen focus changes
 
 
-## monarch.on_post(screen_id, fn_or_url)
+## monarch.on_post(screen_id, fn)
-Set either a function to be called when `msg.post()` is called on a specific screen or a URL where the message is sent.
+Set a function to be called when `msg.post()` is called on a specific screen. IMPORTANT! You must call `monarch.on_message(message_id, message, sender)` from the same script as this function was called.
-
-IMPORTANT! If you provide a function you must also make sure to call `monarch.on_message(message_id, message, sender)` from the same script as this function was called.
 
 **PARAMETERS**
 * `screen_id` (string|hash) - Id of the screen
-* `fn_or_url` (function) - The function to call or URL to send message to
+* `fn` (function) - The function to call when the screen receives a message using `msg.post`
-
-
-## monarch.has_missing_resources(screen_id)
-Check if a screen has any missing resources. If the screen is loaded by a collection proxy with Load Dynamically this will use `collectionproxy.missing_resources()`. For other cases this function will always return false.
-
-**RETURN**
-* `result` (boolean) - true if the screen has missing resources
 
 
 ## monarch.debug()

README_TRANSITIONS.md

@@ -114,7 +114,7 @@ end
 
 function on_message(self, message_id, message, sender)
 	if message_id == hash("my_resize_message") then
-		transition.window_resized(message.width, message.height)
+		self.transition.window_resized(message.width, message.height)
 	end
 end
 ```

example/advanced/confirm.gui_script

@@ -29,7 +29,7 @@ function on_input(self, action_id, action)
 			end
 		elseif gui.pick_node(self.no, action.x, action.y) then
 			print("no")
-			monarch.back(nil, nil, function()
+			monarch.back(function()
 				print("back from popup done")
 			end)
 		end

example/advanced/popup.gui_script

@@ -27,7 +27,7 @@ function on_input(self, action_id, action)
 			end)
 		elseif gui.pick_node(self.cancel, action.x, action.y) then
 			print("cancel")
-			monarch.back(nil, nil, function()
+			monarch.back(function()
 				print("back from popup done")
 			end)
 		elseif gui.pick_node(self.about, action.x, action.y) then

example/advanced/pregame.gui_script

@@ -19,7 +19,7 @@ function on_input(self, action_id, action)
 			end)
 		elseif gui.pick_node(self.back, action.x, action.y) then
 			print("back")
-			monarch.back(nil, nil, function()
+			monarch.back(function()
 				print("back from pregame done")
 			end)
 		end

monarch/editor-script/make_monarch.editor_script

@@ -79,9 +79,16 @@ end
 
 gui_template = function(gui_script)
     return [[script: "]].. gui_script .. [["
-    material: "/builtins/materials/gui.material"
+background_color {
-    adjust_reference: ADJUST_REFERENCE_PARENT
+    x: 0.0
-    ]] 
+    y: 0.0
+    z: 0.0
+    w: 0.0
+}
+material: "/builtins/materials/gui.material"
+adjust_reference: ADJUST_REFERENCE_PARENT
+max_nodes: 512
+]] 
 end
 
 gui_script_content = [[local monarch = require "monarch.monarch"
@@ -109,8 +116,8 @@ end
 
 collection_template = function(gui_script, name)
     return [[name: "]].. name .. [["
-    scale_along_z: 0
+scale_along_z: 0
-    embedded_instances {
+embedded_instances {
   id: "go"
   data: "components {\n"
   "  id: \"monarch\"\n"
@@ -144,8 +151,8 @@ collection_template = function(gui_script, name)
       y: 1.0
       z: 1.0
   }
-    }
+}
-    ]]
+]]
 
 end
 

monarch/monarch.lua

@@ -228,17 +228,6 @@ function M.is_visible(id)
 end
 
 
---- Check if a screen is loaded
--- @param id (string|hash)
--- @return true if the screen is loaded
-function M.is_loaded(id)
-	assert(id, "You must provide a screen id")
-	id = tohash(id)
-	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
-	return screens[id].loaded
-end
-
-
 --- Check if a screen is a popup
 -- @param id Screen id
 -- @return true if the screen is a popup
@@ -430,10 +419,8 @@ local function unload(screen, force)
 	elseif screen.factory then
 		log("unload() factory", screen.id)
 		for id, instance in pairs(screen.factory_ids) do
-			if go.exists(instance) then
 			go.delete(instance)
 		end
-		end
 		screen.factory_ids = nil
 		if screen.auto_preload and not force then
 			screen.loaded = false
@@ -464,7 +451,8 @@ local function preload(screen)
 	screen.preloading = true
 	if screen.proxy then
 		log("preload() proxy")
-		if M.has_missing_resources(screen.id) then
+		local missing_resources = collectionproxy.missing_resources(screen.proxy)
+		if #missing_resources > 0 then
 			local error_message = ("preload() collection proxy %s is missing resources"):format(tostring(screen.id))
 			log(error_message)
 			screen.preloading = false
@@ -521,13 +509,9 @@ local function load(screen)
 		msg.post(screen.proxy, MSG_ENABLE)
 	elseif screen.factory then
 		screen.factory_ids = collectionfactory.create(screen.factory)
-		if screen.transition_id then
 		screen.transition_url = screen.factory_ids[screen.transition_id]
-		end
-		if screen.focus_id then
 		screen.focus_url = screen.factory_ids[screen.focus_id]
 	end
-	end
 	screen.loaded = true
 	screen.preloaded = false
 	return true
@@ -731,8 +715,8 @@ local function back_out(screen, next_screen, wait_for_transition, cb)
 	log("back_out()", screen.id)
 	assert(wait_for_transition ~= nil)
 	run_coroutine(screen, cb, function()
-		active_transition_count = active_transition_count + 1
 		notify_transition_listeners(M.SCREEN_TRANSITION_OUT_STARTED, { screen = screen.id, next_screen = next_screen and next_screen.id })
+		active_transition_count = active_transition_count + 1
 		change_context(screen)
 		release_input(screen, next_screen)
 		focus_lost(screen, next_screen)
@@ -879,10 +863,13 @@ function M.show(id, options, data, cb)
 				show_in(screen, top, options and options.reload, add_to_stack, WAIT_FOR_TRANSITION, callbacks.track())
 			else
 				-- show screen
-				show_in(screen, top, options and options.reload, add_to_stack, WAIT_FOR_TRANSITION, callbacks.track())
+				local cb = callbacks.track()
+				show_in(screen, top, options and options.reload, add_to_stack, DO_NOT_WAIT_FOR_TRANSITION, function()
 					if add_to_stack and top and not top.popup then
 						show_out(top, screen, WAIT_FOR_TRANSITION, callbacks.track())
 					end
+					cb()
+				end)
 			end
 
 			callbacks.when_done(function()
@@ -925,7 +912,7 @@ function M.hide(id, cb)
 			log("hide() you can only hide the screen at the top of the stack", id)
 			return false
 		end
-		return M.back(nil, nil, cb)
+		return M.back(id, cb)
 	else
 		log("hide() queuing action", id)
 		queue_action(function(action_done, action_error)
@@ -987,6 +974,17 @@ end
 -- @param cb (function) - Optional callback to invoke when the previous screen is visible again
 function M.back(options, data, cb)
 	log("back() queuing action")
+	-- backwards compatibility with old version M.back(data, cb)
+	-- case when back(data, cb)
+	if type(data) == "function" then
+		cb = data
+		data = options
+		options = nil
+	-- case when back(data, nil)
+	elseif options ~= nil and data == nil and cb == nil then
+		data = options
+		options = nil
+	end
 
 	queue_action(function(action_done)
 		local callbacks = callback_tracker()
@@ -1016,16 +1014,16 @@ function M.back(options, data, cb)
 					-- we do this to ensure that we do not reset the times step of the screen
 					-- we go back to until it is no longer obscured by the popup
 					if screen.popup and not top.popup then
-						local back_cb = callbacks.track()
 						back_out(screen, top, WAIT_FOR_TRANSITION, function()
 							back_in(top, screen, WAIT_FOR_TRANSITION, back_cb)
 						end)
 					else
-						back_in(top, screen, WAIT_FOR_TRANSITION, callbacks.track())
+						back_in(top, screen, DO_NOT_WAIT_FOR_TRANSITION, function()
-						back_out(screen, top, WAIT_FOR_TRANSITION, callbacks.track())
+							back_out(screen, top, WAIT_FOR_TRANSITION, back_cb)
+						end)
 					end
 				else
-					back_out(screen, top, WAIT_FOR_TRANSITION, callbacks.track())
+					back_out(screen, top, WAIT_FOR_TRANSITION, back_cb)
 				end
 			end
 		end
@@ -1132,20 +1130,6 @@ function M.preload(id, options, cb)
 	return true -- return true for legacy reasons (before queue existed)
 end
 
---- Check if a screen has missing resources, always returns false for factory
--- @param id (string|hash) - Id of the screen to preload
-function M.has_missing_resources(id)
-	assert(id, "You must provide a screen id")
-	id = tohash(id)
-	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
-
-	local screen = screens[id]
-	if screen.proxy then
-		local missing_resources = collectionproxy.missing_resources(screen.proxy)
-		return #missing_resources > 0
-	end
-	return false
-end
 
 --- Unload a preloaded monarch screen
 -- @param id (string|hash) - Id of the screen to unload
@@ -1197,8 +1181,8 @@ end
 -- @return error (string|nil) Error message if unable to send message
 function M.post(id, message_id, message)
 	assert(id, "You must provide a screen id")
-	if not M.is_loaded(id) then
+	if not M.is_visible(id) then
-		return false, "Unable to post message to screen if it isn't loaded"
+		return false, "Unable to post message to screen if it isn't visible"
 	end
 
 	assert(message_id, "You must provide a message_id")
@@ -1350,36 +1334,24 @@ function M.on_focus_changed(id, fn)
 end
 
 ---
--- Set either a function to be called when msg.post() is called on a specific
+-- Set a function to call when a screen is sent a message using monarch.post()
--- screen or a URL where the message is sent.
+-- The function will receive (message_id, message, sender)
--- IMPORTANT! If you provide a function you must also make sure to call
+-- IMPORTANT! You must call monarch.on_message() from the same script as
--- monarch.on_message(message_id, message, sender) from the same script as
+-- this function was called
--- this function was called.
 -- @param id Screen id to associate the message listener function with
--- @param fn_or_url The function to call or URL to send message to
+-- @param fn Message listener function
-function M.on_post(id, fn_or_url)
+function M.on_post(id, fn)
 	assert(id, "You must provide a screen id")
+	assert(fn, "You must provide a post receiver function")
 	id = tohash(id)
 	assert(screens[id], ("There is no screen registered with id %s"):format(tostring(id)))
 	local screen = screens[id]
-
-	local t = type(fn_or_url)
-	if t == "function" then
-		screen.receiver_fn = fn_or_url
 	screen.receiver_url = msg.url()
-	elseif t == "userdata" or t == "string" then
+	screen.receiver_fn = fn
-		screen.receiver_fn = nil
-		screen.receiver_url = fn_or_url
-	else
-		screen.receiver_fn = nil
-		screen.receiver_url = msg.url()
-	end
 end
 
-local empty_hash = hash("")
-
 local function url_to_key(url)
-	return (url.socket or empty_hash) .. (url.path or empty_hash) .. (url.fragment or empty_hash)
+	return (url.socket or hash("")) .. (url.path or hash("")) .. (url.fragment or hash(""))
 end
 
 

test.settings

@@ -1,2 +0,0 @@
-[bootstrap]
-main_collection = /test/test.collectionc

test/msg.lua

@@ -64,17 +64,5 @@ function M.last(url)
 	return messages[#messages]
 end
 
-function M.filter(url, fn)
-	local t = {}
-	local messages = M.messages(url)
-	for i=1,#messages do
-		local message = messages[i]
-		if fn(message) then
-			t[#t + 1] = message
-		end
-	end
-	return t
-end
-
 
 return M

test/test_monarch.lua

@@ -155,17 +155,6 @@ return function()
 			assert(wait_until_visible(POPUP1))
 		end)
 
-		it("should be able to tell if a screen is loaded or not", function()
-			assert(not monarch.is_loaded(SCREEN1))
-			monarch.show(SCREEN1)
-			assert(wait_until_visible(SCREEN1))
-			assert(monarch.is_loaded(SCREEN1))
-			
-			monarch.hide(SCREEN1)
-			assert(wait_until_hidden(SCREEN1))
-			assert(not monarch.is_loaded(SCREEN1))
-		end)
-		
 		it("should be able to show a screen without adding it to the stack", function()
 			monarch.show(BACKGROUND, { no_stack = true })
 			assert(wait_until_visible(BACKGROUND), "Background was never shown")
@@ -230,7 +219,7 @@ return function()
 			assert(monarch.data(SCREEN2) == data2, "Expected data on screen2 doesn't match actual data")
 
 			local data_back = { going = "back" }
-			monarch.back(nil, data_back)
+			monarch.back(data_back)
 			assert(wait_until_visible(SCREEN1))
 
 			assert(monarch.data(SCREEN1) == data_back, "Expected data on screen1 doesn't match actual data")
@@ -418,37 +407,43 @@ return function()
 
 			monarch.show(SCREEN1)
 			assert(wait_until_not_busy())
+			assert(mock_msg.messages(URL1)[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(mock_msg.messages(URL1)[1].message.screen == SCREEN1)
+			assert(mock_msg.messages(URL2)[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(mock_msg.messages(URL2)[1].message.screen == SCREEN1)
+			assert(mock_msg.messages(URL1)[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL1)[2].message.screen == SCREEN1)
+			assert(mock_msg.messages(URL2)[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL2)[2].message.screen == SCREEN1)
 												
 			monarch.remove_listener(URL2)
 			monarch.show(SCREEN2)
 			assert(wait_until_not_busy())
 
+			assert(#mock_msg.messages(URL1) == 6)
+			assert(#mock_msg.messages(URL2) == 2)
+			assert(mock_msg.messages(URL1)[3].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(mock_msg.messages(URL1)[3].message.screen == SCREEN2)
+			assert(mock_msg.messages(URL1)[4].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL1)[4].message.screen == SCREEN2)
+			assert(mock_msg.messages(URL1)[5].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
+			assert(mock_msg.messages(URL1)[5].message.screen == SCREEN1)
+			assert(mock_msg.messages(URL1)[6].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
+			assert(mock_msg.messages(URL1)[6].message.screen == SCREEN1)
+
 			monarch.back()
 			assert(wait_until_not_busy())
 
-			local messages = mock_msg.filter(URL1, function(m)
+			assert(#mock_msg.messages(URL1) == 10)
-				return m.message.screen == SCREEN1
+			assert(#mock_msg.messages(URL2) == 2)
-			end)
+			assert(mock_msg.messages(URL1)[7].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
-			assert(messages[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(mock_msg.messages(URL1)[7].message.screen == SCREEN1)
-			assert(messages[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL1)[8].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
-			assert(messages[3].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
+			assert(mock_msg.messages(URL1)[8].message.screen == SCREEN1)
-			assert(messages[4].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
+			assert(mock_msg.messages(URL1)[9].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
-			assert(messages[5].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
+			assert(mock_msg.messages(URL1)[9].message.screen == SCREEN2)
-			assert(messages[6].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
+			assert(mock_msg.messages(URL1)[10].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
-
+			assert(mock_msg.messages(URL1)[10].message.screen == SCREEN2)
-			messages = mock_msg.filter(URL2, function(m)
-				return m.message.screen == SCREEN1
-			end)
-			assert(messages[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
-			assert(messages[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
-			
-			messages = mock_msg.filter(URL1, function(m)
-				return m.message.screen == SCREEN2
-			end)
-			assert(messages[1].message_id == monarch.SCREEN_TRANSITION_IN_STARTED)
-			assert(messages[2].message_id == monarch.SCREEN_TRANSITION_IN_FINISHED)
-			assert(messages[3].message_id == monarch.SCREEN_TRANSITION_OUT_STARTED)
-			assert(messages[4].message_id == monarch.SCREEN_TRANSITION_OUT_FINISHED)
 		end)
 		
 		it("should be able to show a screen even while it is preloading", function()