ProjectSettings

public static void AddPropertyInfo(Reckfell.Collections.Dictionary hint);

Adds a custom property info to a property. The dictionary must contain:

• "name": string (the property's name)
• "type": [int] (see Variant.Type)
• optionally "hint": string

ProjectSettings.Singleton.Set("category/property_name", 0);

var propertyInfo = new Reckfell.Collections.Dictionary
{
    { "name", "category/propertyName" },
    { "type", (int)Variant.Type.Int },
    { "hint", (int)PropertyHint.Enum },
    { "hint_string", "one,two,three" },
};

ProjectSettings.AddPropertyInfo(propertyInfo);

Note: Setting "usage" for the property is not supported. Use ProjectSettings.SetAsBasic, ProjectSettings.SetRestartIfChanged, and ProjectSettings.SetAsInternal to modify usage flags.

public static bool CheckChangedSettingsInGroup(string settingPrefix);

Checks if any settings with the prefix setting_prefix exist in the set of changed settings. See also ProjectSettings.GetChangedSettings.

public static void Clear(string name);

Clears the whole configuration (not recommended, may break things).

public static string[] GetChangedSettings();

Gets an array of the settings which have been changed since the last save. Note that internally changed_settings is cleared after a successful save, so generally the most appropriate place to use this method is when processing ProjectSettings.SettingsChanged.

public static Reckfell.Collections.Array<Reckfell.Collections.Dictionary> GetGlobalClassList();

Returns an Reckfell.Collections.Array of registered global classes. Each global class is represented as a Reckfell.Collections.Dictionary that contains the following entries:

• base is a name of the base class;
• class is a name of the registered global class;
• icon is a path to a custom icon of the global class, if it has any;
• language is a name of a programming language in which the global class is written;
• path is a path to a file containing the global class. Note: Both the script and the icon paths are local to the project filesystem, i.e. they start with asset://.

public static int GetOrder(string name);

Returns the order of a configuration value (influences when saved to the config file).

public static Variant GetSetting(string name, Variant defaultValue = default);

Reads a base setting value; returns defaultValue without creating a key if it is absent. Does not validate its type or resolve feature overrides. Use GetSettingWithOverride for overrides.

public static Variant GetSettingWithOverride(StringName name);

Reads a setting with active feature-tag overrides. Given game/content_mode and game/content_mode.demo, selects the demo variant when demo is active, otherwise the base value. Unlike GetSetting, resolves the override; this example does not establish priority among multiple active suffixes.

public static Variant GetSettingWithOverrideAndCustomFeatures(StringName name, ReadOnlySpan<string> features);

Similar to ProjectSettings.GetSettingWithOverride, but applies feature tag overrides instead of current OS features.

public static Variant GetSettingWithOverrideAndCustomFeatures(StringName name, string[] features);

Similar to ProjectSettings.GetSettingWithOverride, but applies feature tag overrides instead of current OS features.

public static string GlobalizePath(string path);

Converts asset://, user:// and supported uid:// paths into OS paths; other strings are left without that conversion. It does not create directories or extract packed resources. Globalize user:// before passing it to System.IO; keep using ResourceLoader for imported assets.

public static bool HasSetting(string name);

Tests whether a setting key exists, rather than whether its value has the expected type. Reading a missing key with a GetSetting fallback does not create it.

public static bool LoadResourcePack(string pack, bool replaceFiles = true, int offset = 0);

Mounts a PCK or ZIP into asset://; does not instantiate Entities or load DLLs into .NET. replaceFiles controls ordinary path collisions, but PCK removal entries apply even with false. Already loaded resources are not automatically updated: ordinary ResourceLoader.Load can return the old cached object. Mount updates before their resources are first accessed. A fresh DirAccess can enumerate added paths.

public static string LocalizePath(string path);

Converts suitable absolute paths inside the project root into asset://. Absolute paths outside the project generally remain absolute. It is not a general conversion of the user-data directory into user://; retain virtual slot paths explicitly.

public static Error Save();

Saves the configuration to the project.reckfell file. Note: This method is intended to be used by editor plugins, as modified ProjectSettings can't be loaded back in the running app. If you want to change project settings in exported projects, use ProjectSettings.SaveCustom to save an override.cfg file.

public static Error SaveCustom(string file);

Saves the current configuration to the supplied path. Values equal to their initial value are omitted; this is not restricted to one custom key and does not reload the file. Player preferences usually belong in a separate ConfigFile under user://.

public static void SetAsBasic(string name, bool basic);

Defines if the specified setting is considered basic or advanced. Basic settings will always be shown in the project settings. Advanced settings will only be shown if the user enables the "Advanced Settings" option.

public static void SetAsInternal(string name, bool @internal);

Defines if the specified setting is considered internal. An internal setting won't show up in the Project Settings dialog. This is mostly useful for addons that need to store their own internal settings without exposing them directly to the user.

public static void SetInitialValue(string name, Variant value);

Sets an existing setting initial value without changing its current value. A value equal to its initial value is omitted when saving. Create a missing key with SetSetting first.

public static void SetOrder(string name, int position);

Sets the order of a configuration value (influences when saved to the config file).

public static void SetRestartIfChanged(string name, bool restart);

Sets whether a setting requires restarting the editor to properly take effect. Note: This is just a hint to display to the user that the editor must be restarted for changes to take effect. Enabling ProjectSettings.SetRestartIfChanged does not delay the setting being set when changed.

public static void SetSetting(string name, Variant value);

Sets a setting in memory; Variant Nil removes the key. Does not write a file or guarantee immediate application to a running subsystem. For example, change Engine.MaxFps for the live frame-rate cap.

public static event Action SettingsChanged;

Emitted when any setting is changed, up to once per process frame.