public static int GetSchemeVersionNumber(SchemeVersion version)
{
switch (version)
{
case SchemeVersion.Armageddon1:
case SchemeVersion.WorldParty:
return(1);
case SchemeVersion.Armageddon2:
return(2);
case SchemeVersion.Armageddon3:
return(3);
}
return(-1);
}
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 static bool Generate(string inputPath, SchemeVersion schemeVersion, string outputPath = null, int?seed = null, TextWriter errorTextWriter = null)
{
if (!File.Exists(inputPath))
{
if (errorTextWriter != null)
{
errorTextWriter.WriteLine("File {0} does not exist.", inputPath);
}
return(false);
}
if (schemeVersion < SchemeVersion.Armageddon1 || schemeVersion > SchemeVersion.Armageddon3)
{
if (errorTextWriter != null)
{
errorTextWriter.WriteLine("Invalid scheme version {0}.", schemeVersion);
}
return(false);
}
if (outputPath == null)
{
outputPath = Path.ChangeExtension(inputPath, "wsc");
}
Randomisation.SchemeGenerator schemeGenerator = null;
XmlParser.XmlErrorCollection xmlErrorCollection = null;
bool parseSucceeded = false;
try
{
XmlParser.XmlParser schemeXmlParse = new XmlParser.XmlParser(inputPath);
parseSucceeded = schemeXmlParse.Parse(out xmlErrorCollection, out schemeGenerator);
}
catch (Exception e)
{
if (errorTextWriter != null)
{
errorTextWriter.WriteLine(String.Format("Error while parsing XML file: {0}\r\nStack:\r\n{1}", e.Message, e.StackTrace));
}
return(false);
}
if (xmlErrorCollection != null)
{
if (xmlErrorCollection.Errors.Count > 0)
{
if (errorTextWriter != null)
{
errorTextWriter.WriteLine("Found {0} XML error(s):", xmlErrorCollection.Errors.Count);
}
foreach (XmlParser.XmlError xmlError in xmlErrorCollection.Errors)
{
if (xmlError.HasLineNumber())
{
if (errorTextWriter != null)
{
errorTextWriter.WriteLine(" - Line {0}: {1}", xmlError.lineNumber, xmlError.errorString);
}
}
else
{
if (errorTextWriter != null)
{
errorTextWriter.WriteLine(" - Unknown line: {0}", xmlError.errorString);
}
}
}
}
}
if (!parseSucceeded)
{
return(false);
}
try
{
Random rng = seed.HasValue ? new Random(seed.Value) : new Random();
Scheme testScheme = schemeGenerator.GenerateScheme(rng, schemeVersion);
using (FileStream fs = new FileStream(outputPath, FileMode.Create, FileAccess.Write))
{
testScheme.Serialise(fs);
fs.Close();
}
}
catch (Exception e)
{
if (errorTextWriter != null)
{
errorTextWriter.WriteLine(String.Format("Error while writing scheme file: {0}\r\nStack:\r\n{1}", e.Message, e.StackTrace));
}
return(false);
}
return(true);
}
public Scheme GenerateScheme(Random rng, SchemeVersion version)
{
Scheme scheme = new Scheme(version, ExtendedOptionsDataVersion);
//Generate values for every setting.
int settingsCount = Math.Min(scheme.Settings.Length, _settingGenerators.Length);
for (int i = 0; i < settingsCount; ++i)
{
ValueGenerator valueGenerator = _settingGenerators[i];
if (valueGenerator != null)
{
SettingTypes settingType = (SettingTypes)i;
Setting setting = scheme.Access(settingType);
Debug.Assert(setting != null);
setting.SetValue(valueGenerator.GenerateValue(rng), valueGenerator);
}
}
//Generate values for every weapon.
int weaponsCount = Math.Min(scheme.Weapons.Length, _weaponGenerators.Length);
for (int i = 0; i < weaponsCount; ++i)
{
WeaponGenerator weaponGenerator = _weaponGenerators[i];
for (int j = 0; j < (int)WeaponSettings.Count; ++j)
{
WeaponSettings weaponSetting = (WeaponSettings)j;
ValueGenerator valueGenerator = weaponGenerator.Get(weaponSetting);
if (valueGenerator != null)
{
WeaponTypes weaponType = (WeaponTypes)i;
Weapon weapon = scheme.Access(weaponType);
Debug.Assert(weapon != null);
Setting setting = weapon.Access(weaponSetting);
Debug.Assert(setting != null);
//Check value generator range (range check is not done at XML parsing-time for default values).
if (!valueGenerator.IsValueRangeWithinLimits(setting.Limits))
{
throw new Exception(String.Format("Generatable values for setting '{0}' must be within the range(s): {1}.",
setting.Name, setting.Limits.ToString()));
}
setting.SetValue(valueGenerator.GenerateValue(rng), valueGenerator);
}
}
}
//Generate values for every extended option.
if (version >= SchemeVersion.Armageddon3)
{
int optionsCount = Math.Min(scheme.ExtendedOptions.Length, _extendedOptionGenerators.Length);
for (int i = 0; i < optionsCount; ++i)
{
ValueGenerator valueGenerator = _extendedOptionGenerators[i];
if (valueGenerator != null)
{
ExtendedOptionTypes extendedOption = (ExtendedOptionTypes)i;
Setting setting = scheme.Access(extendedOption);
Debug.Assert(setting != null);
setting.SetValue(valueGenerator.GenerateValue(rng), valueGenerator);
}
}
}
//Handle guarantees.
foreach (Guarantee guarantee in _guarantees)
{
guarantee.ApplyGuarantee(scheme, rng);
}
return(scheme);
}
