Cache emulator paths

Author: rsubtil

scenes/config/settings/emulator/EmulatorEditor.gd

@@ -26,14 +26,16 @@ func set_curr_emulator(_curr_emulator: Dictionary):
 	n_logo.text = "<click to add>" if not n_logo.icon else ""
 	n_name.text = curr_emulator["name"]
 	n_fullname.text = curr_emulator["fullname"]
-	n_path.text = RetroHubGenericEmulator.find_and_substitute_str(curr_emulator["binpath"], {})
+	n_path.text = RetroHubGenericEmulator.find_path(curr_emulator, "binpath", {})
 	n_command.text = curr_emulator["command"]
 
 func save() -> Dictionary:
 	curr_emulator["fullname"] = n_fullname.text
 	curr_emulator["binpath"] = n_path.text
 	curr_emulator["command"] = n_command.text
 
+	RetroHubConfig.set_emulator_path(curr_emulator["name"], "binpath", n_path.text)
+
 	return curr_emulator
 
 func reset():

scenes/config/settings/emulator/RetroArchEmulatorEditor.gd

@@ -35,11 +35,11 @@ func set_curr_emulator(_curr_emulator: Dictionary):
 	n_logo.text = "<click to add>" if not n_logo.icon else ""
 	n_name.text = curr_emulator["name"]
 	n_fullname.text = curr_emulator["fullname"]
-	n_path.text = RetroHubGenericEmulator.find_and_substitute_str(curr_emulator["binpath"], {})
+	n_path.text = RetroHubGenericEmulator.find_path(curr_emulator, "binpath", {})
 	n_core_path.text = RetroHubRetroArchEmulator.get_custom_core_path()
 	if n_core_path.text.is_empty():
-		n_core_path.text = RetroHubGenericEmulator.find_and_substitute_str(
-				curr_emulator["corepath"],
+		n_core_path.text = RetroHubGenericEmulator.find_path(
+				curr_emulator, "corepath",
 				{"binpath": n_path.text}
 		)
 	n_command.text = curr_emulator["command"]
@@ -69,6 +69,9 @@ func save() -> Dictionary:
 
 	curr_emulator["cores"] = cores.duplicate(true)
 
+	RetroHubConfig.set_emulator_path("retroarch", "binpath", n_path.text)
+	RetroHubConfig.set_emulator_path("retroarch", "corepath", n_core_path.text)
+
 	return curr_emulator
 
 func reset():

scenes/popups/first_time/EmulatorsSection.gd

@@ -7,7 +7,6 @@ signal advance_section
 @onready var n_emulator_info_tab := %EmulatorInfoTab
 
 var icon_cache := {}
-var emulator_cache := {}
 
 func _ready():
 	n_systems.get_popup().max_size.y = RetroHubUI.max_popupmenu_height + 50
@@ -39,7 +38,6 @@ func set_systems():
 		else:
 			n_systems.add_icon_item(preload("res://assets/icons/failure.svg"), system["fullname"])
 			n_systems.set_item_metadata(n_systems.get_item_count()-1, false)
-	emulator_cache.clear()
 
 func handle_emulator_info(system_raw: Dictionary) -> bool:
 	var system_emulators : Array = system_raw["emulator"]
@@ -52,38 +50,18 @@ func handle_emulator_info(system_raw: Dictionary) -> bool:
 			var emulator : Dictionary = emulators["retroarch"]
 			parent.add_child(retroarch_info)
 
-			if not emulator_cache.has("retroarch"):
-				emulator_cache["retroarch"] = {}
-
 			# Test for binpath first
-			var binpaths
-			if emulator_cache["retroarch"].has("binpaths"):
-				binpaths = emulator_cache["retroarch"]["binpaths"]
-			else:
-				binpaths = emulator["binpath"]
-				emulator_cache["retroarch"]["binpaths"] = binpaths
-			var binpath : String
-			if emulator_cache["retroarch"].has("binpath"):
-				binpath = emulator_cache["retroarch"]["binpath"]
-			else:
-				binpath = FileUtils.test_for_valid_path(binpaths)
-				emulator_cache["retroarch"]["binpath"] = binpath
+			var binpath := RetroHubRetroArchEmulator.find_path(emulator, "binpath", {})
 			if not binpath.is_empty():
 				retroarch_info.set_path_found(true, binpath)
 				# Then test for cores
 				var required_cores : Array = system_emulator["retroarch"]
-				var corespath : String
-				if emulator_cache["retroarch"].has("corespath"):
-					corespath = emulator_cache["retroarch"]["corespath"]
-				else:
-					corespath = RetroHubRetroArchEmulator.get_custom_core_path()
-					if corespath.is_empty():
-						corespath = JSONUtils.format_string_with_substitutes(FileUtils.test_for_valid_path(emulator["corepath"]) , {"binpath": binpath})
-					if corespath.is_empty():
-						retroarch_info.set_core_found(false, "Could not find any cores inside:\n" + convert_list_to_string(emulator["corepath"]))
-						emulator_cache["retroarch"]["corespath"] = corespath
-						continue
-					emulator_cache["retroarch"]["corespath"] = corespath
+				var corespath := RetroHubRetroArchEmulator.get_custom_core_path()
+				if corespath.is_empty():
+					corespath = JSONUtils.format_string_with_substitutes(FileUtils.test_for_valid_path(emulator["corepath"]) , {"binpath": binpath})
+				if corespath.is_empty():
+					retroarch_info.set_core_found(false, "Could not find any cores inside:\n" + convert_list_to_string(emulator["corepath"]))
+					continue
 				var cores : Array = emulator["cores"]
 				var avail_cores := []
 				for req_core in required_cores:
@@ -94,9 +72,12 @@ func handle_emulator_info(system_raw: Dictionary) -> bool:
 					retroarch_info.set_core_found(false, "No default config for cores:\n" + convert_list_to_string(required_cores))
 					continue
 				var corepaths := []
+				var corepath := ""
 				for core in avail_cores:
+					corepath = RetroHubRetroArchEmulator.find_core_path(core["name"], emulator, corespath)
+					if not corepath.is_empty():
+						break
 					corepaths.push_back(corespath.path_join(core["file"]))
-				var corepath := FileUtils.test_for_valid_path(corepaths)
 				if not corepath.is_empty():
 					for core in avail_cores:
 						if core["file"] == corepath.get_file():
@@ -106,7 +87,7 @@ func handle_emulator_info(system_raw: Dictionary) -> bool:
 					retroarch_info.set_core_found(false, convert_list_to_string(corepaths))
 					continue
 			else:
-				retroarch_info.set_path_found(false, convert_list_to_string(binpaths))
+				retroarch_info.set_path_found(false, convert_list_to_string(emulator["binpath"]))
 				continue
 
 		elif emulators.has(system_emulator):
@@ -115,36 +96,19 @@ func handle_emulator_info(system_raw: Dictionary) -> bool:
 			var emulator : Dictionary = emulators[system_emulator]
 			parent.add_child(generic_info)
 
-			if not emulator_cache.has(emulator["name"]):
-				emulator_cache[emulator["name"]] = {}
-
 			generic_info.set_name(emulator["fullname"])
 			if not icon_cache.has(system_emulator):
 				icon_cache[system_emulator] = load("res://assets/emulators/%s.png" % system_emulator)
 			generic_info.set_logo(icon_cache[system_emulator])
 
 			# Test for binpath first
-			var binpaths
-			if emulator_cache[emulator["name"]].has("binpaths"):
-				binpaths = emulator_cache[emulator["name"]]["binpaths"]
-			else:
-				binpaths = emulator["binpath"]
-				emulator_cache[emulator["name"]]["binpaths"] = binpaths
-			var binpath : String
-			if emulator_cache[emulator["name"]].has("binpath"):
-				binpath = emulator_cache[emulator["name"]]["binpath"]
-			else:
-				binpath = FileUtils.test_for_valid_path(binpaths)
-				emulator_cache[emulator["name"]]["binpath"] = binpath
+			var binpath := RetroHubGenericEmulator.find_path(emulator, "binpath", {})
 			if not binpath.is_empty():
 				found = true
 				generic_info.set_found(true, binpath)
 				continue
-			elif binpaths is Array:
-				generic_info.set_found(false, convert_list_to_string(binpaths))
-				continue
 			else:
-				generic_info.set_found(false, binpaths)
+				generic_info.set_found(false, convert_list_to_string(emulator["binpath"]))
 				continue
 	return found
 

source/Config.gd

@@ -21,6 +21,8 @@ var systems : Dictionary
 var _systems_raw : Dictionary
 var _system_renames : Dictionary
 var emulators_map : Dictionary
+var emulators_paths : Dictionary
+var _should_save := false
 
 var _is_sc := false
 
@@ -96,6 +98,8 @@ func load_emulators():
 			emulators_map[child["name"]].merge(child, true)
 			emulators_map[child["name"]]["#modified"] = true
 	JSONUtils.make_system_specific(emulators_map, FileUtils.get_os_string())
+	# Load emulator paths
+	emulators_paths = JSONUtils.load_json_file(get_emulator_paths_file())
 
 func set_system_renaming():
 	for system_name in config.system_names:
@@ -585,8 +589,12 @@ func bootstrap_config_dir():
 				push_error("Error when creating directory " + path)
 
 		# Bootstrap system specific configs
-		for filename in ["emulators.json", "systems.json"]:
-			var filepath_out := get_config_dir() + "/rh_" + (filename as String)
+		for filename in [
+			"rh_emulators.json",
+			"rh_systems.json",
+			"_emulator_paths.json"
+			]:
+			var filepath_out := get_config_dir() + "/" + (filename as String)
 			var file := FileAccess.open(filepath_out, FileAccess.WRITE)
 			if not file:
 				push_error("Error when opening file " + filepath_out + " for saving")
@@ -601,6 +609,9 @@ func save_config():
 	if config.save_config_to_path(get_config_file()):
 		push_error("Error when saving config to " + get_config_file())
 	save_theme_config()
+	if _should_save:
+		_should_save = false
+		JSONUtils.save_json_file(emulators_paths, get_emulator_paths_file())
 
 func _restore_keys(dict: Dictionary, keys: Array):
 	for key in keys:
@@ -718,6 +729,25 @@ func _determine_sc_mode():
 	if FileAccess.file_exists(exe_path + "/._sc_") or FileAccess.file_exists(exe_path + "/_sc_"):
 		_is_sc = true
 
+func get_emulator_path(emulator_name: String, key: String) -> String:
+	if emulators_paths.has(emulator_name) and emulators_paths[emulator_name].has(key):
+		return emulators_paths[emulator_name][key]
+	return ""
+
+func set_emulator_path(emulator_name: String, key: String, value: String) -> void:
+	if value.is_empty():
+		if emulators_paths.has(emulator_name):
+			emulators_paths[emulator_name].erase(key)
+			if emulators_paths[emulator_name].is_empty():
+				emulators_paths.erase(emulator_name)
+			_should_save = true
+		return
+
+	if not emulators_paths.has(emulator_name):
+		emulators_paths[emulator_name] = {}
+	emulators_paths[emulator_name][key] = value
+	_should_save = true
+
 func get_config_dir() -> String:
 	var path : String
 	if _is_sc:
@@ -744,6 +774,9 @@ func get_systems_file() -> String:
 func get_emulators_file() -> String:
 	return "res://base_config/emulators.json"
 
+func get_emulator_paths_file() -> String:
+	return get_config_dir() + "/_emulator_paths.json"
+
 func get_custom_systems_file() -> String:
 	return get_config_dir() + "/rh_systems.json"
 

source/emulators/GenericEmulator.gd

@@ -8,17 +8,24 @@ var _substitutes := {}
 func _init(emulator_raw : Dictionary, game_data : RetroHubGameData):
 	_substitutes["rompath"] = game_data.path
 	_substitutes["romfolder"] = game_data.path.get_base_dir()
-	var binpath := RetroHubGenericEmulator.find_and_substitute_str(emulator_raw["binpath"], _substitutes)
+	var binpath := RetroHubGenericEmulator.find_path(emulator_raw, "binpath", _substitutes)
 	if not binpath.is_empty():
 		_substitutes["binpath"] = binpath
 		command = RetroHubGenericEmulator.substitute_str(emulator_raw["command"], _substitutes)
 	else:
 		print("Could not find binpath for emulator \"%s\"" % emulator_raw["name"])
 
-static func find_and_substitute_str(paths, substitutes: Dictionary) -> String:
+static func find_path(emulator_def: Dictionary, key: String, substitutes: Dictionary) -> String:
+	var path := RetroHubConfig.get_emulator_path(emulator_def["name"], key)
+	if not path.is_empty() and FileAccess.file_exists(path):
+		return path
+	var paths = emulator_def[key]
 	if paths is Array:
-		return substitute_str(FileUtils.test_for_valid_path(paths), substitutes)
-	return substitute_str(FileUtils.expand_path(paths), substitutes)
+		path = substitute_str(FileUtils.test_for_valid_path(paths), substitutes)
+	else:
+		path = substitute_str(FileUtils.expand_path(paths), substitutes)
+	RetroHubConfig.set_emulator_path(emulator_def["name"], key, path)
+	return path
 
 static func substitute_str(path, substitutes: Dictionary) -> String:
 	return JSONUtils.format_string_with_substitutes(path, substitutes)

source/emulators/RetroarchEmulator.gd

@@ -2,6 +2,10 @@ extends RetroHubGenericEmulator
 class_name RetroHubRetroArchEmulator
 
 static func get_custom_core_path() -> String:
+	var corepath := RetroHubConfig.get_emulator_path("retroarch", "corepath")
+	if not corepath.is_empty():
+		return corepath
+
 	var config_file := get_config_path()
 	if config_file:
 		var file := FileAccess.open(config_file + "/retroarch.cfg", FileAccess.READ)
@@ -10,7 +14,9 @@ static func get_custom_core_path() -> String:
 				var line := file.get_line()
 				if "libretro_directory" in line:
 					var path := line.get_slice("=", 1).replace("\"", "").replace("'", "").strip_edges()
-					return FileUtils.expand_path(path)
+					path = FileUtils.expand_path(path)
+					RetroHubConfig.set_emulator_path("retroarch", "corepath", path)
+					return path
 		return ""
 	return ""
 
@@ -20,7 +26,7 @@ static func get_config_path() -> String:
 			# RetroArch on Windows works as a "portable" installation. Config is located beside main files.
 			# Try to find a valid binpath.
 			var emulator : Dictionary = RetroHubConfig.emulators_map["retroarch"]
-			var binpath := RetroHubRetroArchEmulator.find_and_substitute_str(emulator["binpath"], {})
+			var binpath := RetroHubRetroArchEmulator.find_path(emulator, "binpath", {})
 			return binpath
 		FileUtils.OS_ID.LINUX:
 			# RetroArch uses either XDG_CONFIG_HOME or HOME.
@@ -38,25 +44,34 @@ static func get_config_path() -> String:
 		_:
 			return ""
 
+static func find_core_path(core_key: String, emulator_def: Dictionary, corepath: String) -> String:
+	var path_key := "core_" + core_key
+	var path := RetroHubConfig.get_emulator_path("retroarch", path_key)
+	if not path.is_empty() and FileAccess.file_exists(corepath.path_join(path)):
+		return path
+	for core_info in emulator_def["cores"]:
+		if core_info["name"] == core_key:
+			var core_file : String = core_info["file"]
+			var core_file_path : String = corepath.path_join(core_file)
+			RetroHubConfig.set_emulator_path("retroarch", path_key, core_file)
+			if FileAccess.file_exists(core_file_path):
+				return core_file
+	return ""
+
 func _init(emulator_raw : Dictionary, game_data : RetroHubGameData, system_cores : Array):
 	super(emulator_raw, game_data)
 	var corepath := RetroHubRetroArchEmulator.get_custom_core_path()
 	if corepath.is_empty():
-		corepath = RetroHubRetroArchEmulator.find_and_substitute_str(emulator_raw["corepath"], _substitutes)
+		corepath = RetroHubRetroArchEmulator.find_path(emulator_raw, "corepath", _substitutes)
 	var corefile : String
 	_substitutes["corepath"] = corepath
 	for core_name in system_cores:
-		for core_info in emulator_raw["cores"]:
-			if core_info["name"] == core_name:
-				var core_file_path : String = corepath.path_join(core_info["file"])
-				if FileAccess.file_exists(core_file_path):
-					corefile = core_info["file"]
-					_substitutes["corefile"] = corefile
-					break
+		corefile = RetroHubRetroArchEmulator.find_core_path(core_name, emulator_raw, corepath)
 		if not corefile.is_empty():
 			break
 
 	if not corefile.is_empty():
+		_substitutes["corefile"] = corefile
 		command = RetroHubRetroArchEmulator.substitute_str(command, _substitutes)
 	else:
 		print("Could not find valid core file for emulator \"%s\"" % game_data.system.name)