public ConfigEntry <T> Bind <T>(ConfigDefinition configDefinition, T defaultValue, ConfigDescription configDescription = null, bool?serverAuthoritative = null)
{
ConfigEntry <T> entry = new ConfigEntry <T>(_mod.Config.Bind(configDefinition, defaultValue, configDescription), serverAuthoritative != null ? (bool)serverAuthoritative : _DefaultBindAuthority);
_configEntries[entry.BaseEntry.Definition.ToString()] = entry;
return(entry);
}
public ConfigStringConvar(string name, string defaultValue, string helpText, ConfigFile configFile, ConfigDefinition configDefinition, ConVarFlags flags = ConVarFlags.None) : base(name, defaultValue, helpText, flags)
{
file = configFile;
definition = configDefinition;
SetString(configFile.Wrap <string>(configDefinition).Value);
onValueChanged += valuechanged;
}
private static ConfigEntry <T> BindConfig <T>(ConfigFile file, ConfigDefinition definition, ConfigDescription cd, T defaultValue)
{
baseVRConfigID++;
var entry = file.Bind <T>(definition, defaultValue, cd);
return(entry);
}
private ConfigData GetDefaultConfigData(ConfigDefinition configDefinition)
{
return(new ConfigData(configDefinition,
configDefinition.DefaultValue,
ConfigScope.Default,
ConfigFilter.GlobalAppliesTo));
}
private void InitProperties(string section, string key, Type defaultValueType, object defaultValue, string description, int order = 0)
{
ConfigDefinition = new ConfigDefinition(section, key);
FieldType = defaultValueType;
DefaultValue = defaultValue;
ConfigDescription = string.IsNullOrEmpty(description) ? null : new ConfigDescription(description);
Order = order;
}
public void CanRegisterConfigs(ConfigDefinition config)
{
ConfigManager manager = GetConfigManager() as ConfigManager;
manager.RegisterConfig(config);
manager.BuildConfig();
Assert.Equal(config.DefaultValue, manager.GetConfigValueInternal(config.Key, null));
}
internal static bool configfloat(string catagorie, string description, float defaultvalue, out float value)
{
ConfigDefinition configDefinition = new ConfigDefinition(catagorie, description);
var bindConfig = configFile.Bind(configDefinition, defaultvalue);
value = bindConfig.Value;
return(true);
}
public OmegaMod()
{
Config = base.Config;
Logger = base.Logger;
var sizeDescription = new ConfigDescription("Shield Growth Rate");
var sizeDefinition = new ConfigDefinition("Shield", "SizePerSecond");
_sizePerSecond = Config.Bind(sizeDefinition, 1f, sizeDescription);
}
public static ConfigEntry <T> GetConfigEntry <T>(this ConfigFile configFile, ConfigDefinition definition)
{
if (!configFile.TryGetEntry <T>(definition, out var entry))
{
throw new InvalidOperationException("Config entry has not been added yet.");
}
return(entry);
}
private static ConfigEntry <bool> BindBool(ConfigFile file, string section, string key, bool defaultVal, string description, string title)
{
ConfigDefinition def = new ConfigDefinition(section, key);
ConfigDescription cd = new ConfigDescription(description);
var entry = BindConfig(file, def, cd, defaultVal);
VRSettings.Add(new BepinGTFOSettingBool(title, eSettingInputType.BoolToggle, (eCellSettingID)baseVRConfigID, entry, defaultVal));
return(entry);
}
private static ConfigEntry <float> BindFloat(ConfigFile file, string section, string key, float defaultVal, float minVal, float maxVal, string description, string title)
{
AcceptableValueBase a = new AcceptableValueRange <float>(minVal, maxVal);
ConfigDefinition def = new ConfigDefinition(section, key);
ConfigDescription cd = new ConfigDescription(description, a);
var entry = BindConfig(file, def, cd, defaultVal);
VRSettings.Add(new BepinGTFOSettingFloat(title, eSettingInputType.FloatSlider, (eCellSettingID)baseVRConfigID, entry, defaultVal, minVal, maxVal));
return(entry);
}
private static ConfigEntry <string> BindStringDropdown(ConfigFile file, string section, string key, string defaultVal, string description, string title, string[] possibleValues)
{
AcceptableValueList <string> acceptableValues = new AcceptableValueList <string>(possibleValues);
ConfigDefinition def = new ConfigDefinition(section, key);
ConfigDescription cd = new ConfigDescription(description, acceptableValues);
var entry = BindConfig(file, def, cd, defaultVal);
VRSettings.Add(new BepinGTFOSettingString(title, eSettingInputType.StringArrayDropdown, (eCellSettingID)baseVRConfigID, entry, defaultVal, possibleValues));
return(entry);
}
/// <summary>
/// Gets the value of a config from only the specified provider.
/// </summary>
/// <param name="section"></param>
/// <param name="definition"></param>
/// <param name="providerId"></param>
/// <returns></returns>
private object GetConfigValueOrDefault(IConfigurationSection section, ConfigDefinition definition, string providerId)
{
try
{
return(section.Get(definition.ValueType, providerId));
}
catch (InvalidOperationException ex)
{
WriteWarning($"[ConfigManager] Failed to get value for [{definition.Key}]. Using the default value [{definition.DefaultValue}] instead. Error: {ex.Message}. {ex.InnerException?.Message}");
WriteDebug($"[ConfigManager] Exception: {ex.Message}, stack trace: \n{ex.StackTrace}");
return(definition.DefaultValue);
}
}
public override void LoadConfig()
{
foreach (var entry in ConfigManager.ConfigElements)
{
var key = entry.Key;
var def = new ConfigDefinition(CTG_NAME, key);
if (Config.ContainsKey(def) && Config[def] is ConfigEntryBase configEntry)
{
var config = entry.Value;
config.BoxedValue = configEntry.BoxedValue;
}
}
}
internal ConfigEntry(ConfigFile configFile,
ConfigDefinition definition,
T defaultValue,
ConfigDescription configDescription) : base(configFile, definition, typeof(T),
defaultValue, configDescription)
{
configFile.SettingChanged += (sender, args) =>
{
if (args.ChangedSetting == this)
{
SettingChanged?.Invoke(sender, args);
}
};
}
public bool checkKeyCode(string configkey)
{
var entry = new ConfigDefinition("Keyboard Shortcuts", configkey);
if (entry != null)
{
if (Config.ContainsKey(entry))
{
BepInEx.Configuration.KeyboardShortcut shortcut = (BepInEx.Configuration.KeyboardShortcut)Config[entry].BoxedValue;
return(shortcut.IsDown());
}
}
return(false);
}
public string GetMotS(string stageName)
{
string name = stageName.ToLower();
if (stageMessages.ContainsKey(name))
{
return(stageMessages[name].Value);
}
var configDef = new ConfigDefinition(ModuleName, name);
if (PluginEntry.Configuration.ContainsKey(configDef))
{
stageMessages.Add(name, PluginEntry.Configuration.Bind <string>(configDef, ""));
return(stageMessages[name].Value);
}
return("");
}
/// <inheritdoc/>
public void RegisterConfig(ConfigDefinition config)
{
// check if key already taken
if (_configDefinitionMap.ContainsKey(config.Key))
{
if (_configDefinitionMap[config.Key] == config)
{
Debug.WriteLine($"Config with key [{config.Key}] was registered twice");
}
else
{
throw new AzPSArgumentException($"Duplicated config key. [{config.Key}] was already taken.", nameof(config.Key));
}
return;
}
// configure environment variable provider
EnvironmentVariableParsers[config.Key] = config.ParseFromEnvironmentVariables;
_configDefinitionMap[config.Key] = config;
}
public static bool SaveOptions()
{
try
{
List <PropertyInfo> properties = AccessTools.GetDeclaredProperties(typeof(MultiplayerOptions));
foreach (PropertyInfo prop in properties)
{
ConfigDefinition key = new ConfigDefinition(SECTION_NAME, prop.Name);
configFile[key].BoxedValue = prop.GetValue(Options);
}
configFile.Save();
}
catch (Exception e)
{
Log.Error($"Could not load {OPTION_SAVE_FILE}", e);
return(false);
}
return(true);
}
PluginEntry()
{
#if DEBUG
Logger.LogWarning("This is an experimental build!");
#endif
rng = new Random();
statDefs = new List <DumbStat>();
StatsToAdd = Config.Bind("main", "amount", 5, "How many stats to add to the end screen.");
disablePoints = Config.Bind("miscellaneous", "Disable points in the end screen?", false);
List <string> stringBuilder = new List <string>();
var types = Assembly.GetExecutingAssembly().GetTypes();
foreach (Type tInfo in types)
{
if (typeof(DumbStat).IsAssignableFrom(tInfo))
{
var statAttrs = tInfo.GetCustomAttribute <DumbStatDefAttribute>();
if (statAttrs != null)
{
var stat = (DumbStat)Activator.CreateInstance(tInfo);
statDefs.Add(stat);
stringBuilder.Add(stat.Definition.displayToken);
}
}
}
ConfigDefinition bl = new ConfigDefinition("main", "blacklist");
ConfigDescription bld = new ConfigDescription("Possible values: " + string.Join(";", stringBuilder));
blackList = Config.Bind <string>(bl, "", bld);
var version = Config.Bind <string>("miscellaneous", "config version", VERSION);
if (Version.Parse(VERSION).CompareTo(Version.Parse(version.Value)) != 0)
{
string hold = blackList.Value;
blackList = null;
Config.Remove(bl);
Config.Save();
version.Value = VERSION;
blackList = Config.Bind <string>(bl, "", bld);
blackList.Value = hold;
}
BlackList = new List <string>(blackList.Value.Split(';', ',', ' '));
}
void Awake()
{
// Setup/Apply Config file
List <ConfigDefinition> configList = new List <ConfigDefinition>();
foreach (var enemy in TrophyXPDict.Keys)
{
configList.Add(new ConfigDefinition("ExpScaling", enemy));
}
ConfigDefinition bossConsumption =
new ConfigDefinition("BossConsumption", "CanConsumeBosses");
foreach (var config in configList)
{
TrophyXPDict[config.Key] = Config.Bind(config, TrophyXPDict[config.Key]).Value;
}
CanConsumeBosses = Config.Bind(bossConsumption, true).Value;
Harmony.PatchAll();
}
/// <inheritdoc/>
public void RegisterConfig(ConfigDefinition config)
{
// check if key already taken
if (_configDefinitionMap.ContainsKey(config.Key))
{
if (_configDefinitionMap[config.Key] == config)
{
Debug.WriteLine($"Config with key [{config.Key}] was registered twice");
}
else
{
throw new AzPSArgumentException($"Duplicated config key. [{config.Key}] was already taken.", nameof(config.Key));
}
return;
}
// configure environment variable providers
if (!string.IsNullOrEmpty(config.EnvironmentVariableName))
{
EnvironmentVariableToKeyMap[config.EnvironmentVariableName] = ConfigPathHelper.GetPathOfConfig(config.Key);
}
_configDefinitionMap[config.Key] = config;
}
public void UpdateDescription(T vanillaValue, bool ignoreAlreadyUpdated = false)
{
if (!ignoreAlreadyUpdated && _updatedDescription)
{
return;
}
_updatedDescription = true;
string desc = Entry.Description.Description;
T val = Value;
ConfigDefinition def = Entry.Definition;
ConfigFile file = Entry.ConfigFile;
file.Remove(def);
Entry = file.Bind(def, (T)(Entry.DefaultValue is bool?vanillaValue: Entry.DefaultValue),
new ConfigDescription(desc + (desc.EndsWith(".") ? "" : ".") + " Vanilla value: " + vanillaValue));
if (Changer != null)
{
Entry.SettingChanged += (sender, args) => ChangeAction.Invoke(Changer);
}
Entry.Value = val is bool && _updateBoolValue ? vanillaValue : val;
Entry.ConfigFile.Save();
}
/// <summary>
/// Types of defaultValue and definition.AcceptableValues have to be the same as settingType.
/// </summary>
internal ConfigEntryBase(ConfigFile configFile,
ConfigDefinition definition,
Type settingType,
object defaultValue,
ConfigDescription configDescription)
{
ConfigFile = configFile ?? throw new ArgumentNullException(nameof(configFile));
Definition = definition ?? throw new ArgumentNullException(nameof(definition));
SettingType = settingType ?? throw new ArgumentNullException(nameof(settingType));
Description = configDescription ?? ConfigDescription.Empty;
if (Description.AcceptableValues != null &&
!SettingType.IsAssignableFrom(Description.AcceptableValues.ValueType))
{
throw new
ArgumentException("configDescription.AcceptableValues is for a different type than the type of this setting");
}
DefaultValue = defaultValue;
// Free type check and automatically calls ClampValue in case AcceptableValues were provided
BoxedValue = defaultValue;
}
private void config()
{
const string sectionName = "may the day treat you well";
ConfigDefinition moveSpeedDef = new ConfigDefinition(sectionName, "Set Move Speed");
ConfigDescription moveSpeedDesc = new ConfigDescription($"Set Beetle Move Speed to this amount (base is {_origBaseMoveSpeed})");
SetMoveSpeed = Config.Bind <float>(moveSpeedDef, 9.5f, moveSpeedDesc);
ConfigDefinition attackSpeedDef = new ConfigDefinition(sectionName, "Attack Speed Multiplier");
ConfigDescription attackSpeedDesc = new ConfigDescription("Multiply Beetle Attack Speed by this amount");
MultAttackSpeed = Config.Bind <float>(attackSpeedDef, 2f, attackSpeedDesc);
ConfigDefinition levelAttackSpeedDef = new ConfigDefinition(sectionName, "Set Level Attack speed");
ConfigDescription levelAttackSpeedDesc = new ConfigDescription("Set Beetle Attack speed gained per level");
SetLevelAttackSpeed = Config.Bind <float>(levelAttackSpeedDef, 0.1f, levelAttackSpeedDesc);
ConfigDefinition damageDef = new ConfigDefinition(sectionName, "Damage Multipier");
ConfigDescription damageDesc = new ConfigDescription("Multiply Beetle Damage by this amount");
MultDamage = Config.Bind <float>(damageDef, 0.8f, damageDesc);
}
public void SetMotS(string stageName, string newArgs)
{
string name = stageName.ToLower();
if (stageMessages.ContainsKey(name))
{
stageMessages[name].Value = newArgs;
}
else
{
var configDef = new ConfigDefinition(ModuleName, name);
if (PluginEntry.Configuration.ContainsKey(configDef))
{
stageMessages.Add(name, PluginEntry.Configuration.Bind <string>(configDef, ""));
stageMessages[name].Value = newArgs;
}
else
{
ConfigEntry <string> entry = PluginEntry.Configuration.Bind <string>(configDef, "", new ConfigDescription(_MOTSHelp));
entry.Value = newArgs;
stageMessages.Add(name, entry);
}
}
}
private string GenerateKey(ConfigDefinition def) => $"{rwMod.ModID}_{def.Section}_{def.Key}";
private static bool TryGetBase(ConfigFile file, ConfigDefinition key, out ConfigEntryBase entryBase)
{
try { entryBase = file[key]; return(true); }
catch (Exception) { entryBase = null; }
return(false);
}
private static int CompareCDkey(ConfigDefinition x, ConfigDefinition y)
{
return(x.Key.CompareTo(y.Key));
}
private void ParseConfig(ConfigFile configFile)
{
// Settings
var startingSkillPointsPerAbilityPointConfig = new ConfigDefinition("main", "StartingSkillPointsPerAbilityPoint");
var startingAbilityPointsConfig = new ConfigDefinition("main", "StartingAbilityPoints");
var maxSkillValueAtCreation = new ConfigDefinition("main", "MaximumSkillValueAtCreation");
var skillPointsAbilityLimit = new ConfigDefinition("main", "SkillPointsAbilityLimited");
bool reload = false;
if (configFile.GetSetting <int>(startingAbilityPointsConfig) == null)
{
configFile.AddSetting <int>(startingAbilityPointsConfig, 8, new ConfigDescription("The amount of Ability points you get at character creation. Default is 8."));
configFile.Save();
reload = true;
}
if (configFile.GetSetting <int>(startingSkillPointsPerAbilityPointConfig) == null)
{
configFile.AddSetting <int>(startingSkillPointsPerAbilityPointConfig, 5, new ConfigDescription("The amount of Skill points you get at character creation, per starting Ability point.\nFor example: the default value of 5, combined with the default value of 8 for starting Ability points, results in a total of 40 Skill points to spend at character creation."));
configFile.Save();
reload = true;
}
if (configFile.GetSetting <int>(maxSkillValueAtCreation) == null)
{
configFile.AddSetting <int>(maxSkillValueAtCreation, 6, new ConfigDescription("The maximum value of a Skill at character creation, regardless of Ability scores or total Skill points."));
configFile.Save();
reload = true;
}
if (configFile.GetSetting <int>(skillPointsAbilityLimit) == null)
{
configFile.AddSetting(skillPointsAbilityLimit, 1, new ConfigDescription("The manner in which skill point assignment is limited by Ability scores.\n1: For a given Ability, you can put skill points in a maximum number of skills tied to that Ability equal to the Ability's score (e.g. if you have Motorics 2, you can increase a maximum of 2 different Motorics skills).\n2: For a given Ability, you can distribute a maximum of StartingSkillPointsPerAbilityPoint times the Ability's value into Skills tied to that ability (e.g. if StartingSkillPointsPerAbilityPoint = 5 (default), and you have Motorics 2, you can distribute a total of 10 skill points in Motorics skills)\n0: No limit on skill points distribution based on Ability scores (not recommended).", new AcceptableValueRange <int>(0, 2)));
configFile.Save();
reload = true;
}
if (reload)
{
configFile.Reload();
}
_startingAbilityPoints = configFile.GetSetting <int>(startingAbilityPointsConfig).Value;
_startingSkillPointsPerAbilityPoint = configFile.GetSetting <int>(startingSkillPointsPerAbilityPointConfig).Value;
_maxSkillValue = configFile.GetSetting <int>(maxSkillValueAtCreation).Value;
try
{
_abilityLimitSetting = (AbilityLimitationSetting)configFile.GetSetting <int>(skillPointsAbilityLimit).Value;
}
catch (Exception ex)
{
Console.WriteLine("ParseConfig: error parsing ability limit setting. Defaulting to 1.");
_abilityLimitSetting = AbilityLimitationSetting.LIMIT_NR_OF_SKILLS;
}
Console.WriteLine("Advanced Character Creation Configuration:");
Console.WriteLine($". Ability points at character creation: {_startingAbilityPoints}");
Console.WriteLine($". Skill points per ability point at character creation: {_startingSkillPointsPerAbilityPoint}");
Console.WriteLine($". => Total nr. of Skill points to spend on character creation: {_startingAbilityPoints * _startingSkillPointsPerAbilityPoint}");
Console.WriteLine($". Maximum value of any Skill at character creation: {_maxSkillValue}");
Console.WriteLine($". Ability score limitation on Skill point spending: {Enum.GetName(typeof(AbilityLimitationSetting), _abilityLimitSetting)}");
}
