/// <summary>
///
/// </summary>
/// <param name="input"></param>
/// <param name="args"></param>
/// <param name="variable"></param>
/// <param name="suggestions"></param>
/// <returns></returns>
Suggestion AutoCompleteVariable(string input, string[] args, ConfigVariable variable)
{
var suggestion = new Suggestion(input);
var type = variable.TargetProperty.PropertyType;
var candidates = new string[0];
//
// Gather possible values :
//
if (type == typeof(bool))
{
candidates = new string[] { "True", "False" };
}
else if (type.IsEnum)
{
candidates = Enum.GetNames(type);
}
else
{
candidates = new string[] { variable.Get() };
}
//
// Only name of the variables is entered.
// Just show possible values.
//
if (args.Length == 1)
{
suggestion.Set(args[0] + " ");
suggestion.AddRange(candidates.Select(c1 => args[0] + " " + c1));
return(suggestion);
}
//
// Select candidates that starts with entered value.
//
var longest = LongestCommon(args[1], ref candidates);
suggestion.AddRange(candidates.Select(c1 => args[0] + " " + c1));
// add quotes if longest common contains spaces :
if (longest != null && longest.Any(c => char.IsWhiteSpace(c)))
{
longest = "\"" + longest; // + "\"";
if (candidates.Length == 1)
{
// only on suggestion - close quotes.
longest += "\"";
}
}
else
{
}
suggestion.Set(string.Format("{0} {1}", args[0], longest));
return(suggestion);
}
private void cmdAccept_Click(object sender, EventArgs e)
{
SelectedVariables = new List <ConfigVariable>();
lvwVariables.Focus(); //make sure any last changes have been saved in list
Application.DoEvents();
foreach (ListViewItem lvi in lvwVariables.Items)
{
ConfigVariable cv = (ConfigVariable)lvi.Tag;
if (cv.ReplaceValue.Length == 0)
{
if (MessageBox.Show($"The variable '{cv.FindValue}' has no value! Do you want to accept this?", "Accept", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
{
return;
}
}
SelectedVariables.Add(cv);
}
string modifiedConfig = InputConfig;
foreach (ConfigVariable cv in SelectedVariables)
{
modifiedConfig = cv.ApplyOn(modifiedConfig);
}
FormattedConfig = modifiedConfig;
DialogResult = DialogResult.OK;
Close();
}
public string ApplyConfigVarsOnField(string field)
{
List <ConfigVariable> allConfigVars = new List <ConfigVariable>();
//applying its own first
foreach (ConfigVariable cv in ConfigVariables)
{
ConfigVariable existingCV = (from ConfigVariable c in allConfigVars
where c.FindValue == cv.FindValue
select c).FirstOrDefault();
if (existingCV == null)
{
allConfigVars.Add(cv.Clone());
}
}
if (allConfigVars.Count == 0) //adds dummy entry so internal vars also get applied
{
allConfigVars.Add(new ConfigVariable()
{
FindValue = DateTime.Now.Millisecond.ToString(), ReplaceValue = DateTime.Now.Millisecond.ToString()
});
}
return(allConfigVars.ApplyOn(field));
}
private void moveDownConfigVarToolStripButton_Click(object sender, EventArgs e)
{
if (lvwConfigVars.SelectedItems.Count == 1)
{
int index = lvwConfigVars.SelectedItems[0].Index;
if (index < lvwConfigVars.Items.Count - 1)
{
loadConfigVarEntry = true;
ConfigVariable tmpBottom = (ConfigVariable)lvwConfigVars.Items[index + 1].Tag;
ConfigVariable tmpTop = (ConfigVariable)lvwConfigVars.Items[index].Tag;
lvwConfigVars.Items[index + 1].Tag = tmpTop;
lvwConfigVars.Items[index + 1].Text = tmpTop.FindValue;
lvwConfigVars.Items[index + 1].SubItems[1].Text = tmpTop.ReplaceValue;
lvwConfigVars.Items[index].Tag = tmpBottom;
lvwConfigVars.Items[index].Text = tmpBottom.FindValue;
lvwConfigVars.Items[index].SubItems[1].Text = tmpBottom.ReplaceValue;
lvwConfigVars.Items[index].Selected = false;
lvwConfigVars.Items[index].Focused = false;
lvwConfigVars.Items[index + 1].Selected = true;
lvwConfigVars.Items[index + 1].Focused = true;
lvwConfigVars.Items[index].EnsureVisible();
loadConfigVarEntry = false;
}
}
}
public XmlConfigDataVariables InitConfigDataVariables(string sPath)
{
XmlConfigDataVariables xmlConfigDataVariables = null;
if (File.Exists(sPath))
{
xmlConfigDataVariables = FastSerialisation.Instance().GetSaveStructInCurrentDirectory <XmlConfigDataVariables>(sPath);
return(xmlConfigDataVariables);
}
xmlConfigDataVariables = new XmlConfigDataVariables()
{
listConfigVariable = new List <ConfigVariable>()
};
ConfigVariable configVariable = new ConfigVariable()
{
NomVariable = "VariableTest", FormuleVariable = eFormuleVariable.NC, NeedValidation = false, DefaultValue = "", listParamFormule = new List <BindingVariable>()
};
BindingVariable bindingVariable = new BindingVariable()
{
NomVariableBinding = "", SourceData = 0, DefaultValue = ""
};
configVariable.listParamFormule.Add(bindingVariable);
xmlConfigDataVariables.listConfigVariable.Add(configVariable);
string sReponse = FastSerialisation.Instance().SaveStructInCurrentDirectory <XmlConfigDataVariables>(xmlConfigDataVariables, sPath);
SingleLogFileAsXml.Instance().AjouteLog("Init", "ConfigClient.Variables.xml n'existe pas : creation : " + sReponse);
return(xmlConfigDataVariables);
}
public void GetTest()
{
var d0 = new ConfigVariable("a", null);
var d1 = new ConfigVariable("b", "c");
Assert.Null(d0.GetValue <string>());
Assert.Equal(1, d0.GetValue <int>(1));
Assert.Equal(0, d1.GetValue <int>());
Assert.Equal(1, d1.GetValue <int>(1));
}
public void Ctor2ArgTest()
{
string n0 = "a";
int v0 = 123;
var d0 = new ConfigVariable(n0, v0);
Assert.Equal(n0, d0.Name);
Assert.Equal(v0.ToString(), d0.Value);
Assert.Throws <ArgumentException>(() => new ConfigVariable("123a", null));
}
public void CtorDefaultTest()
{
var d = new ConfigVariable();
Assert.Equal("", d.Name);
Assert.Null(d.Value);
Assert.False(d.IsDirty);
Assert.True(d.IsNull);
Assert.Equal(ConfigVariable.Null, d);
}
private void txtVariableValue_TextChanged(object sender, EventArgs e)
{
if (!loadingVar == true && lvwVariables.SelectedItems.Count > 0)
{
ConfigVariable cv = (ConfigVariable)lvwVariables.SelectedItems[0].Tag;
if (txtVariableName.Text == cv.FindValue)
{
cv.ReplaceValue = txtVariableValue.Text;
}
}
}
private void lvwVariables_SelectedIndexChanged(object sender, EventArgs e)
{
if (lvwVariables.SelectedItems.Count > 0)
{
loadingVar = true;
ConfigVariable cv = (ConfigVariable)lvwVariables.SelectedItems[0].Tag;
txtVariableName.Text = cv.FindValue;
txtVariableValue.Text = cv.ReplaceValue;
txtVariableValue.ReadOnly = false;
loadingVar = false;
}
else
{
loadingVar = true;
txtVariableName.Text = "";
txtVariableValue.Text = "";
txtVariableValue.ReadOnly = true;
loadingVar = false;
}
}
public bool ContainVariables()
{
if (InputConfig == "")
{
return(false);
}
else
{
System.Text.RegularExpressions.Regex re = new System.Text.RegularExpressions.Regex("(\\[\\[).*?(\\]\\])", System.Text.RegularExpressions.RegexOptions.Multiline);
SelectedVariables = new List <ConfigVariable>();
foreach (var m in re.Matches(InputConfig))
{
string variableUnformatted = m.ToString();
string initialValue = "";
if (variableUnformatted.Contains(":"))
{
initialValue = variableUnformatted.Substring(variableUnformatted.IndexOf(':') + 1).TrimEnd(']');
}
ConfigVariable cv = (from ConfigVariable c in SelectedVariables
where c.FindValue == variableUnformatted
select c).FirstOrDefault();
if (cv == null)
{
cv = new ConfigVariable()
{
FindValue = variableUnformatted, ReplaceValue = initialValue
};
cv.FindValue = variableUnformatted;
SelectedVariables.Add(cv);
}
}
if (SelectedVariables.Count == 0)
{
return(false);
}
else
{
return(true);
}
}
}
public void Awake()
{
var epicLootConfig = EpicLoot.EpicLoot.GetConfigObject();
ConfigManager.RegisterMod(EpicLoot.EpicLoot.PluginId, epicLootConfig);
ConfigManager.ServerConfigReceived += InitializeConfig;
_gatedItemTypeModeConfig = ReplaceConfigVar <GatedItemTypeMode>(epicLootConfig, "Balance", "Item Drop Limits");
_bossesDropOneTrophyPerPlayer = ReplaceConfigVar <bool>(epicLootConfig, "Balance", "Bosses Drop One Trophy Per Player");
ConfigManager.RegisterModConfigVariable(EpicLoot.EpicLoot.PluginId, _lootConfigFile);
ConfigManager.RegisterModConfigVariable(EpicLoot.EpicLoot.PluginId, _magicEffectsConfigFile);
ConfigManager.RegisterModConfigVariable(EpicLoot.EpicLoot.PluginId, _itemInfoConfigFile);
ConfigManager.RegisterModConfigVariable(EpicLoot.EpicLoot.PluginId, _recipesConfigFile);
ConfigManager.RegisterModConfigVariable(EpicLoot.EpicLoot.PluginId, _enchantCostsConfigFile);
ConfigManager.RegisterModConfigVariable(EpicLoot.EpicLoot.PluginId, _itemNamesConfigFile);
ConfigManager.RegisterModConfigVariable(EpicLoot.EpicLoot.PluginId, _adventureDataConfigFile);
Harmony.CreateAndPatchAll(Assembly.GetExecutingAssembly(), PluginId);
}
internal static bool GetValue <T>(ConfigVariable <T> configVariable, out T result)
{
if (!m_data.TryGetValue(configVariable.ConfigKey, out var obj))
{
result = default(T);
return(false);
}
if (typeof(Enum).IsAssignableFrom(typeof(T)))
{
result = (T)Enum.Parse(typeof(T), obj.ToString());
}
else if (typeof(IConvertible).IsAssignableFrom(typeof(T)))
{
result = (T)Convert.ChangeType(obj, typeof(T));
}
else
{
result = JsonConvert.DeserializeObject <T>(JsonConvert.SerializeObject(obj));
}
return(true);
}
public void GetSetTest(Type t0, object v0, bool construct)
{
object u0 = v0;
if (construct)
{
object[] ca = null;
Type[] ts = null;
if (v0.GetType().IsArray)
{
List <Type> tl = new List <Type>();
List <object> al = new List <object>();
foreach (var v in v0 as IEnumerable)
{
al.Add(v);
tl.Add(v.GetType());
}
ca = al.ToArray();
ts = tl.ToArray();
}
else
{
ts = new Type[1];
ts[0] = v0.GetType();
ca = new object[1];
ca[0] = v0;
}
var ctor = t0.GetConstructor(ts);
u0 = ctor.Invoke(ca);
}
var d0 = new ConfigVariable("v", null);
d0.SetValue(u0);
var m = d0.GetType().GetMethod("GetValue");
var gm = m.MakeGenericMethod(t0);
var v1 = gm.Invoke(d0, new object[] { null });
Assert.Equal(u0, v1);
}
internal static void Register <T>(ConfigVariable <T> configVariable)
{
m_sampleData[configVariable.ConfigKey] = configVariable.DefaultValue;
File.WriteAllText(m_sampleConfigPath, JsonConvert.SerializeObject(m_sampleData, Formatting.Indented));
}
private ConfigObject FetchObject(List <Token> configSection)
{
if (configSection.Count == 0)
{
return(null);
}
ConfigObject resultObject = null;
var sectionBeginningToken = configSection.First();
if (sectionBeginningToken is VariableToken)
{
resultObject = new ConfigVariable
{
Name = (sectionBeginningToken as VariableToken).VariableName,
Value = (sectionBeginningToken as VariableToken).Value
};
return(resultObject);
}
if (sectionBeginningToken is ClassOpeningToken)
{
if ((sectionBeginningToken as ClassOpeningToken).ClassName == "data")
{
var dataClassType = ConfigDataTypeHelper.GetType(
configSection.OfType <StandaloneStringToken>().First());
var dataObject = (FetchObject(configSection.Skip(6).Take(configSection.Count - 7).ToList()));
dynamic dataValue = ExtractDataValue(dataClassType, dataObject);
resultObject = new DataClass()
{
DataType = dataClassType,
Value = dataValue
};
}
else if (Regex.Match((sectionBeginningToken as ClassOpeningToken).ClassName, @"^Item\d+$").Success)
{
var fetchedObjects = FetchListOfObjects(configSection.Skip(1).Take(configSection.Count - 2).ToList());
var fetchedReadOnlyProperty =
(fetchedObjects.FirstOrDefault(configObject => (configObject as ConfigVariable)?.Name == "readOnly")
as
ConfigVariable)?.Value;
resultObject = new ItemClass
{
Name =
(fetchedObjects.FirstOrDefault(configObject => (configObject as ConfigVariable)?.Name == "name") as
ConfigVariable)?.Value.ToString(),
Data = fetchedObjects.OfType <DataClass>().First(),
ReadOnly = fetchedReadOnlyProperty == null ? default(bool?) : (int)fetchedReadOnlyProperty == 1
};
}
else
{
resultObject = new GeneralClass()
{
ClassName = (sectionBeginningToken as ClassOpeningToken).ClassName,
Content = FetchListOfObjects(configSection.Skip(1).Take(configSection.Count - 2).ToList())
};
}
}
return(resultObject);
}
