public void SetGroupSetting(SettingTypes settingTypes, object settings)
{
foreach (var prop in settings.GetType().GetProperties())
{
Update(prop.Name, settingTypes, Convert.ToString(prop.GetValue(settings, null)));
}
}
public static string GetDefaultSettings(SettingTypes type)
{
string xmlData = string.Empty;
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(Properties.Resources.defaultSettings);
switch (type)
{
case SettingTypes.All:
xmlData = xmlDocument.OuterXml;
break;
case SettingTypes.Categories:
xmlData = xmlDocument.SelectSingleNode("//CategoryList").OuterXml;
break;
case SettingTypes.Columns:
xmlData = xmlDocument.SelectSingleNode("//TableColumns").OuterXml;
break;
case SettingTypes.Positions:
xmlData = xmlDocument.SelectSingleNode("//PositionList").OuterXml;
break;
}
return(xmlData);
}
public Setting GetSetting(string name, SettingTypes parentName)
{
return(db.Repository <Setting>().ReadAll()
.Include(a => a.ParentSetting)
.FirstOrDefault(a => a.SettingName == name &&
a.ParentSetting.SettingName == parentName.ToString()));
}
public SettingNameModel(IAPIHelper apiHelper, IModelHelper modelHelper)
{
_apiHelper = apiHelper;
_modelHelper = modelHelper;
SettingTypes settingTypes = new SettingTypes();
SettingTypeList = new SelectList(settingTypes.GetSettingTypesDictionary(), "Key", "Value");
}
private decimal GetRate(SettingTypes type, decimal defaultRate)
{
return(_repository.Queryable()
.Where(x => x.Name == type)
.Select(x => x.Value.ParseToDecimal())
.ConvertSetToOption()
.DefaultIfEmpty(defaultRate)
.Single());
}
public void Update(string settingName, SettingTypes parentName, string newValue)
{
Setting updatedItem = Read(a =>
a.ParentSetting.SettingName == parentName.ToString() &&
a.SettingName == settingName,
a => a.ParentSetting);
updatedItem.Value = newValue;
}
private void SetSetting(SettingTypes type, string value)
{
var settingItem = new SettingItemModel(type.ToString().ToLower(), value);
var completeSettings = new CompleteSettingsModel(settingItem);
ScenarioCache.Store(ModelKeys.CompleteSettings, completeSettings);
WhenTheSettingsAreAttemptedToBeSet();
new CommonSteps().ThenTheRequestIsSuccessful();
}
void ParseSettingElement(XElement settingElement, SettingTypes settingType)
{
//Create the value generator.
ValueGenerator valueGenerator = CreateValueGenerator(settingElement, SchemeLimits.GetSettingLimits(settingType));
//Pass the new value generator to the scheme generator.
Debug.Assert(_schemeGenerator != null);
_schemeGenerator.Set(settingType, valueGenerator);
}
private string GetSetting(SettingTypes settingType)
{
var response = ApiCaller.Get <SettingItemModel>(Routes.GetSettingsByType(settingType));
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
var actualRate = response.Data.Value;
return(actualRate);
}
/// <summary>
/// Returns the wanted value of the setting.
/// </summary>
/// <typeparam name="T">Type of the wanted setting value.</typeparam>
/// <exception cref="EmptySettingException">Thrown if the setting is completly empty.</exception>
/// <exception cref="ActiveTypeLockException">Thrown if TypeLock is enabled and an invalid type was given.</exception>
/// <exception cref="InvalidSettingTypeException">Thrown if value is an unsupported setting type.</exception>
/// <returns>Value of the wanted type from the setting.</returns>
public T GetValue <T>()
{
// Setting.SetValue never called -> exception;
if (!SettingTypes.Any())
{
throw new EmptySettingException($"The setting \"{Key}\" does not have any values at this time.");
}
// TypeLock enabled, type already set and didn’t match -> exception;
if (TypeLock && SettingTypes.Any() && SettingTypes.First() != typeof(T))
{
throw new ActiveTypeLockException(
$"The setting \"{Key}\" has activated TypeLock. " +
"When TypeLock is enabled, a setting can only store and return one data type. " +
$"The data type already used is: \"{SettingTypes.First()}\".");
}
// Wanted type is never setten -> exception;
if (!SettingTypes.Contains(typeof(T)))
{
throw new EmptySettingException($"The setting \"{Key}\" does not store a value of this type.");
}
// Return value for existing type...
if (typeof(T) == typeof(int))
{
return((T)Convert.ChangeType(ValueInt, typeof(T)));
}
if (typeof(T) == typeof(double))
{
return((T)Convert.ChangeType(ValueDouble, typeof(T)));
}
if (typeof(T) == typeof(string))
{
return((T)Convert.ChangeType(ValueString, typeof(T)));
}
if (typeof(T) == typeof(bool))
{
return((T)Convert.ChangeType(ValueBool, typeof(T)));
}
if (typeof(T) == typeof(DateTime))
{
return((T)Convert.ChangeType(ValueDateTime, typeof(T)));
}
// or thro exception and return list of valid types.
throw new InvalidSettingTypeException(
$"The type {typeof(T)} is not a valid setting type. Currently valid setting types are: \n" +
GetType().GetProperties()
.Where(propertyInfo => propertyInfo.Name.StartsWith("Value")).Aggregate("",
(current, propertyInfo) => current + $"{propertyInfo.PropertyType}, ")
.TrimEnd(','));
}
public object GetGroupSetting(SettingTypes settingTypes, object settings)
{
var generalSettings = db.Repository <Setting>().ReadAll()
.Include(a => a.ParentSetting)
.Where(a => a.ParentSetting.SettingName == settingTypes.ToString())
.ToDictionary(o => o.SettingName, o => o.Value);
foreach (var prop in settings.GetType().GetProperties())
{
prop.SetValue(settings, generalSettings[prop.Name]);
}
return(settings);
}
public static void SaveSettings(SettingTypes settingType)
{
#region Variables
AllMergedColourSettingsManager colourSettingsManager = new AllMergedColourSettingsManager();
//ColourStringSettingsManager colourStringSettingsManager = new ColourStringSettingsManager();
ColourIntegerSettingsManager colourIntegerSettingsManager = new ColourIntegerSettingsManager();
GlobalBooleanSettingsManager globalBooleanSettingsManager = new GlobalBooleanSettingsManager();
GlobalStringSettingsManager globalStringSettingsManager = new GlobalStringSettingsManager();
#endregion
try
{
switch (settingType)
{
case SettingTypes.BOOLEAN:
globalBooleanSettingsManager.SaveBooleanSettings();
break;
case SettingTypes.COLOUR:
colourSettingsManager.SaveAllMergedColourSettings();
break;
case SettingTypes.COLOURSTRING:
//colourStringSettingsManager.SaveColourStringSettings();
break;
case SettingTypes.COLOURINTEGER:
colourIntegerSettingsManager.SaveColourIntegerSettings();
break;
case SettingTypes.STRING:
globalStringSettingsManager.SaveStringSettings();
break;
case SettingTypes.INTEGER:
colourIntegerSettingsManager.SaveColourIntegerSettings();
break;
default:
break;
}
}
catch (Exception exc)
{
ExceptionHandler.CaptureException(exc, methodSignature: Helpers.GetCurrentMethod());
}
}
public static void SaveSettings(SettingTypes settingType)
{
#region Variables
ColourSettingsManager colourSettingsManager = new ColourSettingsManager();
ColourStringSettingsManager colourStringSettingsManager = new ColourStringSettingsManager();
ColourIntegerSettingsManager colourIntegerSettingsManager = new ColourIntegerSettingsManager();
GlobalBooleanSettingsManager globalBooleanSettingsManager = new GlobalBooleanSettingsManager();
GlobalStringSettingsManager globalStringSettingsManager = new GlobalStringSettingsManager();
#endregion
try
{
switch (settingType)
{
case SettingTypes.BOOLEAN:
globalBooleanSettingsManager.SaveBooleanSettings();
break;
case SettingTypes.COLOUR:
colourSettingsManager.SaveColourSettings();
break;
case SettingTypes.COLOURSTRING:
colourStringSettingsManager.SaveColourStringSettings();
break;
case SettingTypes.COLOURINTEGER:
colourIntegerSettingsManager.SaveColourIntegerSettings();
break;
case SettingTypes.STRING:
globalStringSettingsManager.SaveStringSettings();
break;
case SettingTypes.INTEGER:
colourIntegerSettingsManager.SaveColourIntegerSettings();
break;
default:
break;
}
}
catch (Exception exc)
{
ExceptionHandler.CaptureException(exc);
}
}
public string GetItem(SettingTypes setting)
{
switch (setting)
{
case SettingTypes.Jwt:
return(Settings.Jwt);
case SettingTypes.UserId:
return(Settings.UserId);
default:
return("No matching setting");
}
}
/// <summary>
/// Set a value of the setting, or override it.
/// </summary>
/// <typeparam name="T">Type of the value.</typeparam>
/// <param name="value">New value itself.</param>
/// <exception cref="ActiveTypeLockException">Thrown if TypeLock is enabled and an invalid type was given.</exception>
/// <exception cref="InvalidSettingTypeException">Thrown if value is an unsupported setting type.</exception>
public void SetValue <T>(T value)
{
// TypeLock enabled, type already set and didn’t match -> exception;
if (TypeLock && SettingTypes.Any() && SettingTypes.First() != typeof(T))
{
throw new ActiveTypeLockException(
$"The setting \"{Key}\" has activated TypeLock. " +
"When TypeLock is enabled, a setting can only store and return one data type. " +
$"The data type already used is: \"{SettingTypes.First()}\".");
}
// Set value for existing type...
if (typeof(T) == typeof(int))
{
ValueInt = Convert.ToInt32(value);
}
else if (typeof(T) == typeof(double))
{
ValueDouble = Convert.ToDouble(value);
}
else if (typeof(T) == typeof(string))
{
ValueString = Convert.ToString(value);
}
else if (typeof(T) == typeof(bool))
{
ValueBool = Convert.ToBoolean(value);
}
else if (typeof(T) == typeof(DateTime))
{
ValueDateTime = Convert.ToDateTime(value);
}
else // ...or throw exception and return list of valid types.
{
throw new InvalidSettingTypeException(
$"The type {typeof(T)} is not a valid setting type. Currently valid setting types are: \n" +
GetType().GetProperties()
.Where(propertyInfo => propertyInfo.Name.StartsWith("Value")).Aggregate("",
(current, propertyInfo) => current + $"{propertyInfo.PropertyType}, ")
.TrimEnd(','));
}
// No exception thrown -> store setting type if not already stored.
if (!SettingTypes.Contains(typeof(T)))
{
SettingTypes.Add(typeof(T));
}
}
public void SetItem(SettingTypes setting, string value)
{
switch (setting)
{
case SettingTypes.Jwt:
Settings.Jwt = value;
break;
case SettingTypes.UserId:
Settings.UserId = value;
break;
default:
break;
}
}
public static ISettings Build(SettingTypes settingType)
{
switch (settingType)
{
case SettingTypes.Default:
return(new DefaultSettings());
case SettingTypes.Test:
return(new TestSettings());
case SettingTypes.Free:
return(new FreeSettings());
default:
throw new ArgumentOutOfRangeException(settingType.ToString() + " is not a valid settings type");
}
}
public bool DeleteImage(string category, string settingName, string fileName)
{
try
{
Storage storage = Storage.GetStorage(category);
SettingTypes settingType = SettingTypes.Default;
if (category == StorageScope.HospitalEnvironment)
{
settingType = SettingTypes.Info;
}
var setting = Read(a => a.SettingName == settingName &&
a.ParentSetting.SettingName == settingType.ToString(),
a => a.ParentSetting);
if (setting != null)
{
if (category == StorageScope.Official)
{
fileName = setting.Value;
storage.Delete(fileName);
setting.Value = "";
}
else if (category == StorageScope.HospitalEnvironment)
{
var fileArr = setting.Value.Split(';');
var fileList = new List <string>(fileArr);
storage.Delete(fileName);
var newStrArr = fileList.Where(a => a != fileName).ToArray();
if (newStrArr.Length == 0)
{
setting.Value = "";
}
else
{
setting.Value = string.Join(";", newStrArr);
}
}
Save();
}
return(true);
}
catch (Exception ex)
{
return(false);
}
}
public static void Save(SettingTypes type, object content)
{
var settingsLocation = Settings.Default.SettingsLocation;
var settingsContents = File.ReadAllText(settingsLocation);
var jsonObject = JObject.Parse(settingsContents);
if (type == SettingTypes.GameLocation)
{
jsonObject["GameLocation"] = (string)content;
}
if (type == SettingTypes.InstalledPreset)
{
jsonObject["InstalledPreset"] = (string)content;
}
File.WriteAllText(settingsLocation, jsonObject.ToString());
}
/// <summary>
/// Registers new option.
/// </summary>
/// <param name="key">Key used to access value.</param>
/// <param name="gconfKey">Path to key in GConf.</param>
/// <param name="valueType">Value type.</param>
/// <param name="requiresMenuRebuild">If true, SettingChanged event propagates information whether menu rebuild is required.</param>
/// <returns>True, if succeeded.</returns>
public bool RegisterSetting(string key, string gconfKey, SettingTypes valueType, bool requiresMenuRebuild)
{
try
{
Setting o = new Setting(gconfKey, valueType, requiresMenuRebuild);
this.settings.Add(key, o);
this.ReadGConfValue(o);
}
catch (Exception ex)
{
#if DEBUG
Tools.PrintInfo(ex, this.GetType());
#endif
return(false);
}
return(true);
}
static SettingLimits InitialiseSettingLimit(SettingTypes settingType)
{
switch (settingType)
{
case SettingTypes.Version:
return(new SettingLimits(1, 3));
//Boolean properties.
case SettingTypes.DisplayTotalRoundTime:
case SettingTypes.AutomaticReplays:
case SettingTypes.ArtilleryMode:
case SettingTypes.DonorCards:
case SettingTypes.DudMines:
case SettingTypes.InitialWormPlacement:
case SettingTypes.Blood:
case SettingTypes.AquaSheep:
case SettingTypes.SheepHeaven:
case SettingTypes.GodWorms:
case SettingTypes.IndestructibleTerrain:
case SettingTypes.UpgradedGrenade:
case SettingTypes.UpgradedShotgun:
case SettingTypes.UpgradedCluster:
case SettingTypes.UpgradedLongbow:
case SettingTypes.TeamWeapons:
case SettingTypes.SuperWeapons:
return(new SettingLimits(0, 1));
//Enum-based properties.
case SettingTypes.StockpilingMode:
return(new SettingLimits(0, (int)StockpilingModes.Count - 1));
case SettingTypes.WormSelect:
return(new SettingLimits(0, (int)WormSelectModes.Count - 1));
//All quartary properties.
case SettingTypes.SuddenDeathEvent:
return(new SettingLimits(0, (int)SuddenDeathEvents.Count - 1));
//Everything else has full byte range.
default:
return(new SettingLimits(0, 255));
}
}
public static dynamic Return(SettingTypes type)
{
var settingsLocation = Settings.Default.SettingsLocation;
var settingsContents = File.ReadAllText(settingsLocation);
var jsonObject = JObject.Parse(settingsContents);
if (type == SettingTypes.GameLocation)
{
return((string)jsonObject["GameLocation"]);
}
if (type == SettingTypes.InstalledPreset)
{
return((string)jsonObject["InstalledPreset"]);
}
// This will legit never happen. Shut up.
return(null);
}
public void SetSetting(SettingTypes settingType, string param)
{
if (settingType == SettingTypes.TempDir)
{
if (!Directory.Exists(param))
{
Directory.CreateDirectory(param);
}
MakeSettlement(settingType.ToText(), param + "\\AutomixSoftware");
}
else if (settingType == SettingTypes.TransitionDuration || settingType == SettingTypes.MixDuration ||
settingType == SettingTypes.BpmPriority || settingType == SettingTypes.KeyNumberPriority ||
settingType == SettingTypes.KeyTonalityPriority ||
settingType == SettingTypes.DanceabilityPriority ||
settingType == SettingTypes.Mp3Quality)
{
MakeSettlement(settingType.ToText(), param);
}
}
/// <summary>
/// Creates objects.
/// </summary>
/// <param name="key">Key used in GConf.</param>
/// <param name="type">Value type.</param>
/// <param name="requiresMenuRebuild">If true, SettingChanged event propagates information whether menu rebuild is required.</param>
public Setting(string key, SettingTypes type, bool requiresMenuRebuild)
{
this.Key = key;
this.RequiresMenuRebuild = requiresMenuRebuild;
this.Type = type;
switch (type)
{
case SettingTypes.Boolean:
this.type = typeof(bool);
break;
case SettingTypes.Integer:
this.type = typeof(int);
break;
case SettingTypes.String:
this.type = typeof(string);
break;
}
}
/// <summary>
/// Creates objects.
/// </summary>
/// <param name="key">Key used in GConf.</param>
/// <param name="type">Value type.</param>
/// <param name="requiresMenuRebuild">If true, SettingChanged event propagates information whether menu rebuild is required.</param>
public Setting(string key, SettingTypes type, bool requiresMenuRebuild)
{
this.Key = key;
this.RequiresMenuRebuild = requiresMenuRebuild;
this.Type = type;
switch (type)
{
case SettingTypes.Boolean:
this.type = typeof(bool);
break;
case SettingTypes.Integer:
this.type = typeof(int);
break;
case SettingTypes.String:
this.type = typeof(string);
break;
}
}
public Scheme(SchemeVersion version, int extendedOptionsDataVersion = 0, bool setUpDefaults = true)
{
Version = version;
Settings = new Setting[SchemeTypes.NumberOfNonWeaponSettings];
for (int i = 0; i < Settings.Length; ++i)
{
SettingTypes settingType = (SettingTypes)i;
Settings[i] = new Setting(settingType.ToString(), SchemeLimits.GetSettingLimits(settingType));
}
int weaponsCount = version >= SchemeVersion.Armageddon2 ? SchemeTypes.NumberOfWeapons : SchemeTypes.NumberOfNonSuperWeapons;
Weapons = new Weapon[weaponsCount];
for (int i = 0; i < Weapons.Length; ++i)
{
Weapons[i] = new Weapon((WeaponTypes)i);
}
if (version >= SchemeVersion.Armageddon3)
{
int optionsCount = SchemeTypes.GetExtendedOptionsSettingsCount(extendedOptionsDataVersion);
ExtendedOptions = new Setting[optionsCount];
for (int i = 0; i < ExtendedOptions.Length; ++i)
{
ExtendedOptionTypes extendedOption = (ExtendedOptionTypes)i;
ExtendedOptions[i] = new Setting(extendedOption.ToString(), SchemeLimits.GetExtendedOptionLimits(extendedOption), SchemeTypes.GetExtendedOptionSettingSize(extendedOption));
}
Access(ExtendedOptionTypes.DataVersion).SetValue(extendedOptionsDataVersion);
}
Access(SettingTypes.Version).SetValue(SchemeTypes.GetSchemeVersionNumber(version));
Access(SettingTypes.BountyMode).SetValue(SchemeGeneratorMagicNumber);
if (setUpDefaults)
{
SetUpDefaults();
}
}
public SettingItem(SettingTypes name, string value)
{
Name = name;
Value = value;
}
void ChooseSetting()
{
switch (Option)
{
case SettingMenuOption.Audio:
maxPos = AudioOptions.Count - 1;
UpdateAudioDisplay();
// Audio Controls
if (Confirm())
{
AudioOptions[0].GetComponent <Slider>().value = MusicVolume;
AudioOptions[1].GetComponent <Slider>().value = SFXVolume;
CurrentStage = Stage.EditSetting;
AudioOptions[pos].transform.parent.GetComponentInChildren <Text>().color = Color.green;
if (pos == 0)
{
SettingText.text = "Editing Music Volume...";
}
else
{
SettingText.text = "Editing SFX Volume...";
}
TypeToEdit = DetectSettingType(AudioOptions);
}
Pips[1].color = ActiveCol;
Pips[0].color = InactiveCol;
break;
case SettingMenuOption.Info:
maxPos = GameplayOptions.Count - 1;
UpdateInfoDisplay();
Pips[0].color = ActiveCol;
Pips[1].color = InactiveCol;
if (pos == 0)
{
if (Confirm())
{
if (ControllerType == (SupportedControllers.KeyboardP1ControllerP2) || (ControllerType == SupportedControllers.KeyboardP2ControllerP1))
{
SceneManager.LoadSceneAsync("InputCheck", LoadSceneMode.Additive);
}
}
else if (Confirm())
{
if (ControllerType == SupportedControllers.ArcadeBoard || ControllerType == SupportedControllers.GamePadBoth || ControllerType == SupportedControllers.KeyboardBoth)
{
GameplayOptions[pos].GetComponent <Text>().color = Color.red;
SettingText.text = "You can't do this... your controllers are not mixed...";
}
}
}
else if (pos == 1)
{
if (Confirm())
{
SettingText.text = "Reset Save Data?";
GameplayOptions[pos].GetComponent <Text>().color = Color.green;
ConfirmResetText.SetActive(true);
CurrentStage = Stage.EditSetting;
}
}
break;
default:
break;
}
if (Return())
{
Screens[(int)Option].GetComponent <CanvasGroup>().alpha = .5f;
pos = (int)Option;
if (pos == 0)
{
Pips[0].color = ActiveCol;
Pips[1].color = InactiveCol;
}
else
{
Pips[0].color = InactiveCol;
Pips[1].color = ActiveCol;
}
maxPos = Screens.Count - 1;
UpdateDisplay();
UpdatePips();
AudioOptions[0].transform.parent.GetComponentInChildren <Text>().color = Color.white;
AudioOptions[1].transform.parent.GetComponentInChildren <Text>().color = Color.white;
GameplayOptions[0].GetComponent <Text>().color = Color.white;
GameplayOptions[1].GetComponent <Text>().color = Color.white;
CurrentStage = Stage.ChangeScreen;
}
}
/// <summary>
/// Registers new option.
/// </summary>
/// <param name="key">Key used to access value.</param>
/// <param name="gconfKey">Path to key in GConf.</param>
/// <param name="valueType">Value type.</param>
/// <param name="requiresMenuRebuild">If true, SettingChanged event propagates information whether menu rebuild is required.</param>
/// <returns>True, if succeeded.</returns>
public bool RegisterSetting(string key, string gconfKey, SettingTypes valueType, bool requiresMenuRebuild)
{
try
{
Setting o = new Setting(gconfKey, valueType, requiresMenuRebuild);
this.settings.Add(key, o);
this.ReadGConfValue(o);
}
catch (Exception ex)
{
#if DEBUG
Tools.PrintInfo(ex, this.GetType());
#endif
return false;
}
return true;
}
public static string GetDefaultSettings(SettingTypes type)
{
string xmlData = string.Empty;
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.LoadXml(Properties.Resources.defaultSettings);
switch (type) {
case SettingTypes.All:
xmlData = xmlDocument.OuterXml;
break;
case SettingTypes.Categories:
xmlData = xmlDocument.SelectSingleNode("//CategoryList").OuterXml;
break;
case SettingTypes.Columns:
xmlData = xmlDocument.SelectSingleNode("//TableColumns").OuterXml;
break;
case SettingTypes.Positions:
xmlData = xmlDocument.SelectSingleNode("//PositionList").OuterXml;
break;
}
return (xmlData);
}
public Preset(string pkey, string name, SettingTypes type)
{
presetKey = pkey;
presetName = name;
presetType = type;
}
private static void SettingsNotFound(SettingTypes setting)
{
var response = ApiCaller.Get <SettingItemModel>(Routes.GetSettingsByType(setting));
Assert.AreEqual(HttpStatusCode.NotFound, response.StatusCode);
}
public IsSettingValueADecimal(IEnumerable <SettingItem> settings, SettingTypes settingType)
{
_settings = settings;
_settingType = settingType;
}
public static string GetSettingsByType(SettingTypes settingType)
{
return($"{Settings}/{settingType}");
}
public MemberSetting GetMemberSetting(int memberId, SettingTypes settingTypeId)
{
MemberSetting memberSetting = new MemberSetting();
using (context = new DomainContext())
{
context.Configuration.LazyLoadingEnabled = false;
var result = context.MemberSettings.SingleOrDefault(ms => ms.MemberId == memberId && ms.SettingTypeId == settingTypeId);
if (result != null)
{
memberSetting.MemberId = result.MemberId;
memberSetting.SettingTypeId = result.SettingTypeId;
memberSetting.Value = result.Value;
}
}
return memberSetting;
}
