refactor: 🚧 Adding ModConfig Resource

Author: KANAjetzt

addons/mod_loader/api/config.gd

@@ -5,119 +5,34 @@ extends Object
 
 const LOG_NAME := "ModLoader:Config"
 
-enum ML_CONFIG_STATUS {
-	OK,                  # 0 = No errors
-	NO_JSON_OK,          # 1 = No custom JSON (file probably does not exist). Uses defaults from manifest, if available
-	INVALID_MOD_ID,      # 2 = Invalid mod ID
-	NO_JSON_INVALID_KEY, # 3 = Invalid key, and no custom JSON was specified in the manifest defaults (`extra.godot.config_defaults`)
-	INVALID_KEY          # 4 = Invalid key, although config data does exists
-}
-
-
-# Retrieves the configuration data for a specific mod.
-# Returns a dictionary with three keys:
-# - "status_code": an integer indicating the status of the request
-# - "status_msg": a string containing a message explaining the status code
-# - "data": the configuration data
-#
-# Parameters:
-# - mod_dir_name: the name of the mod's directory / id
-#
-# Status Codes:
-# - ML_CONFIG_STATUS.OK: the request was successful and the configuration data is included in the "data" key
-# - ML_CONFIG_STATUS.INVALID_MOD_ID: the mod ID is not valid, and the "status_msg" key contains an error message
-# - ML_CONFIG_STATUS.NO_JSON_OK: there is no configuration file for the mod, the "data" key contains an empty dictionary
-#
-# Returns:
-# A dictionary with three keys: "status_code", "status_msg", and "data"
-static func get_mod_config(mod_dir_name: String) -> Dictionary:
-	var status_code = ML_CONFIG_STATUS.OK
-	var status_msg := ""
-	var data = {} # can be anything
 
+# Retrieves the configuration data for a specific mod
+static func get_mod_config(mod_id: String) -> Dictionary:
 	# Check if the mod ID is invalid
-	if not ModLoaderStore.mod_data.has(mod_dir_name):
-		status_code = ML_CONFIG_STATUS.INVALID_MOD_ID
-		status_msg = "Mod ID was invalid: %s" % mod_dir_name
-
-	# Mod ID is valid
-	if status_code == ML_CONFIG_STATUS.OK:
-		var mod := ModLoaderStore.mod_data[mod_dir_name] as ModData
-		var config_data := mod.config
-
-		# Check if there is no config file for the mod
-		if config_data.size() == 0:
-			status_code = ML_CONFIG_STATUS.NO_JSON_OK
-			status_msg = "No config file for %s.json. " % mod_dir_name
-
-		# Config file exists
-		if status_code == ML_CONFIG_STATUS.OK:
-				data = config_data
-
-	# Log any errors that occurred
-	if not status_code == ML_CONFIG_STATUS.OK:
-		if status_code == ML_CONFIG_STATUS.NO_JSON_OK:
-			# The mod has no user config file, which is not a critical error
-			var full_msg = "Config JSON Notice: %s" % status_msg
-			# Only log this once, to avoid flooding the log
-			ModLoaderLog.debug(full_msg, mod_dir_name, true)
-		else:
-			# The error is critical (e.g. invalid mod ID)
-			ModLoaderLog.fatal("Config JSON Error (%s): %s" % [status_code, status_msg], mod_dir_name)
-
-	return {
-		"status_code": status_code,
-		"status_msg": status_msg,
-		"data": data,
-	}
-
-
-# Returns a bool indicating if a retrieved mod config is valid.
-# Requires the full config object (ie. the dictionary that's returned by
-# `get_mod_config`)
-static func is_mod_config_data_valid(config_obj: Dictionary) -> bool:
-	return config_obj.status_code <= ML_CONFIG_STATUS.NO_JSON_OK
-
+	if not ModLoaderStore.mod_data.has(mod_id):
+		ModLoaderLog.fatal("Mod ID \"%s\" not found" % [mod_id], LOG_NAME)
+		return {}
 
-# Saves a full dictionary object to a mod's custom config file, as JSON.
-# Overwrites any existing data in the file.
-# Optionally updates the config object that's stored in memory (true by default).
-# Returns a bool indicating success or failure.
-# WARNING: Provides no validation
-static func save_mod_config_dictionary(mod_id: String, data: Dictionary, update_config: bool = true) -> bool:
-	# Use `get_mod_config` to check if a custom JSON file already exists.
-	# This has the added benefit of logging a fatal error if mod_name is
-	# invalid (as it already happens in `get_mod_config`)
-	var config_obj := get_mod_config(mod_id)
+	var config_data = ModLoaderStore.mod_data[mod_id].config
 
-	if not is_mod_config_data_valid(config_obj):
-		ModLoaderLog.warning("Could not save the config JSON file because the config data was invalid", mod_id)
-		return false
+	# Check if there is no config file for the mod
+	if not config_data:
+		ModLoaderLog.debug("No config for mod id \"%s\"" % mod_id, LOG_NAME, true)
+		return {}
 
-	var data_original: Dictionary = config_obj.data
-	var data_new := {}
+	return config_data
 
-	# Merge
-	if update_config:
-		# Update the config held in memory
-		data_original.merge(data, true)
-		data_new = data_original
-	else:
-		# Don't update the config in memory
-		data_new = data_original.duplicate(true)
-		data_new.merge(data, true)
 
-	var configs_path := _ModLoaderPath.get_path_to_configs()
-	var json_path := configs_path.plus_file(mod_id + ".json")
+static func is_mod_config_data_valid(config_data: ModConfig):
+	var json_schema := JSONSchema.new()
+	var error := json_schema.validate(config_data.get_data_as_string(), config_data.get_schema_as_string())
 
-	return _ModLoaderFile.save_dictionary_to_json_file(data_new, json_path)
 
+static func update_mod_config(mod_id: String, data: Dictionary) -> void:
+	# Update the config held in memory
+	ModLoaderStore.mod_data[mod_id].config.merge(data, true)
 
-# Saves a single settings to a mod's custom config file.
-# Returns a bool indicating success or failure.
-static func save_mod_config_setting(mod_id: String, key:String, value, update_config: bool = true) -> bool:
-	var new_data = {
-		key: value
-	}
 
-	return save_mod_config_dictionary(mod_id, new_data, update_config)
+# Saves a full dictionary object to a mod's config file, as JSON.
+static func save_mod_config(config_data: ModConfig) -> bool:
+	return _ModLoaderFile.save_dictionary_to_json_file(config_data.data, config_data.save_path)

addons/mod_loader/classes/mod_config.gd

@@ -0,0 +1,16 @@
+class_name ModConfig
+extends Resource
+
+
+var mod_id: String
+var schema: Dictionary
+var data: Dictionary
+var save_path: String
+
+
+func get_data_as_string() -> String:
+	return JSON.print(data)
+
+
+func get_schema_as_string() -> String:
+	return JSON.print(schema)

addons/mod_loader/classes/mod_data.gd

@@ -38,7 +38,7 @@ var importance := 0
 # Contents of the manifest
 var manifest: ModManifest
 # Updated in _load_mod_configs
-var config := {}
+var config: ModConfig
 
 # only set if DEBUG_ENABLE_STORING_FILEPATHS is enabled
 var file_paths: PoolStringArray = []
@@ -73,6 +73,51 @@ func load_manifest() -> void:
 	manifest = mod_manifest
 
 
+func load_mod_config() -> void:
+	config = ModConfig.new()
+	config.save_path = _ModLoaderPath.get_path_to_configs().plus_file("%s.json" % dir_name)
+	config.schema = manifest.config_schema
+
+	# Generate config_default based on the default values in config_schema
+	_get_config_default_data(config.schema.properties)
+
+	# Validate the config defaults
+	manifest.is_config_valid(
+		config.get_data_as_string(),
+		config.get_schema_as_string()
+	)
+
+	# Save the default config to disk if there is no file yet
+	if not _ModLoaderFile.file_exists(config.save_path):
+		_ModLoaderFile.save_dictionary_to_json_file(config.data, config.save_path)
+
+
+# Recursively searches for default values
+func _get_config_default_data(property: Dictionary, current_prop := config.data) -> void:
+	# Exit function if property is empty
+	if property.empty():
+		return
+
+	for property_key in property.keys():
+		var prop = property[property_key]
+
+		# If this property contains nested properties, we recursively call this function
+		if "properties" in prop:
+			current_prop[property_key] = {}
+			_get_config_default_data(prop.properties, current_prop[property_key])
+			# Return early here because a object will not have a "default" key
+			return
+
+		# If this property contains a default value, add it to the global config_defaults dictionary
+		if "default" in prop:
+			# Initialize the current_key if it is missing in config_defaults
+			if not current_prop.has(property_key):
+				current_prop[property_key] = {}
+
+			# Add the default value to the config_defaults
+			current_prop[property_key] = prop.default
+
+
 # Validates if [member dir_name] matches [method ModManifest.get_mod_id]
 func _is_mod_dir_name_same_as_id(mod_manifest: ModManifest) -> bool:
 	var manifest_id := mod_manifest.get_mod_id()

addons/mod_loader/classes/mod_manifest.gd

@@ -32,8 +32,6 @@ var incompatibilities: PoolStringArray = []
 var load_before: PoolStringArray = []
 var tags : PoolStringArray = []
 var config_schema := {}
-# Is generated based on the default values in config_schema
-var config_defaults := {}
 var description_rich := ""
 var image: StreamTexture
 
@@ -136,9 +134,6 @@ func _init(manifest: Dictionary) -> void:
 	):
 		return
 
-	if not config_schema.empty():
-		_handle_mod_config()
-
 
 # Mod ID used in the mod loader
 # Format: {namespace}-{name}
@@ -200,59 +195,6 @@ func to_json() -> String:
 	}, "\t")
 
 
-func _handle_mod_config() -> void:
-	var config_path := _ModLoaderPath.get_path_to_configs().plus_file("%s-%s.json" % [namespace, name])
-
-	# Generate config_default based on the default values in config_schema
-	_get_config_default_data(config_schema.properties)
-
-	# Validate the config defaults
-	is_config_valid(
-		get_config_default_data_as_string(),
-		get_config_schema_as_string()
-	)
-
-	# Save the default config to disk if there is no file yet
-	if not _ModLoaderFile.file_exists(config_path):
-		_ModLoaderFile.save_dictionary_to_json_file(config_defaults, config_path)
-
-
-# Recursively searches for default values
-func _get_config_default_data(property: Dictionary, current_prop := config_defaults) -> void:
-	# Exit function if property is empty
-	if property.empty():
-		return
-
-	for property_key in property.keys():
-		var prop = property[property_key]
-
-		# If this property contains nested properties, we recursively call this function
-		if "properties" in prop:
-			current_prop[property_key] = {}
-			_get_config_default_data(prop.properties, current_prop[property_key])
-			# Return early here because a object will not have a "default" key
-			return
-
-		# If this property contains a default value, add it to the global config_defaults dictionary
-		if "default" in prop:
-			# Initialize the current_key if it is missing in config_defaults
-			if not current_prop.has(property_key):
-				current_prop[property_key] = {}
-
-			# Add the default value to the config_defaults
-			current_prop[property_key] = prop.default
-
-
-# Returns a JSON string representing the default configuration data
-func get_config_default_data_as_string() -> String:
-	return JSON.print(config_defaults)
-
-
-# Returns a JSON string representing the configuration schema
-func get_config_schema_as_string() -> String:
-	return JSON.print(config_schema)
-
-
 func is_config_valid(config_data: String, config_schema: String) -> bool:
 	var json_schema := JSONSchema.new()
 	var error := json_schema.validate(config_data, config_schema)

addons/mod_loader/mod_loader.gd

@@ -98,6 +98,8 @@ func _load_mods() -> void:
 	for dir_name in ModLoaderStore.mod_data:
 		var mod: ModData = ModLoaderStore.mod_data[dir_name]
 		mod.load_manifest()
+		if not mod.manifest.get("config_schema") and not mod.manifest.config_schema.empty():
+			mod.load_mod_config()
 
 	# Set up mod configs. If a mod's JSON file is found, its data gets added
 	# to mod_data.{dir_name}.config
@@ -485,7 +487,7 @@ func save_scene(modified_scene: Node, scene_path: String) -> void:
 
 func get_mod_config(mod_dir_name: String = "", key: String = "") -> Dictionary:
 	ModLoaderDeprecated.deprecated_changed("ModLoader.get_mod_config", "ModLoaderConfig.get_mod_config", "6.0.0")
-	return ModLoaderConfig.get_mod_config(mod_dir_name, key)
+	return ModLoaderConfig.get_mod_config(mod_dir_name)
 
 
 func deprecated_direct_access_UNPACKED_DIR() -> String: