public static List <string> BuildScript(MutationFilter mutationFilter, int tSysMutationFilter)
{
var lines = new List <string>();
for (var mutationIdx = 0; mutationIdx < mutationFilter.Mutations.Count; mutationIdx++)
{
var mutation = mutationFilter.Mutations[mutationIdx];
lines.Add($"0x{tSysMutationFilter:X8} Mutation #{mutationIdx + 1}:");
lines.Add("");
lines.Add($"Tier chances: {string.Join(", ", mutation.Chances)}");
lines.Add("");
foreach (var outcome in mutation.Outcomes)
{
for (var effectListIdx = 0; effectListIdx < outcome.EffectLists.Count; effectListIdx++)
{
var effectList = outcome.EffectLists.ElementAt(effectListIdx);
lines.Add($" - Chance {effectList.Chance}:");
for (var effectIdx = 0; effectIdx < effectList.Effects.Count; effectIdx++)
{
var effect = effectList.Effects.ElementAt(effectIdx);
//lines.Add($" - EffectType: {(MutationEffectType)effect.EffectType}");
var curLine = "";
PropertyInt propInt = 0;
var args = new List <EffectArgument>();
if (effect.Quality != null)
{
args.Add(effect.Quality);
}
if (effect.Arg1 != null)
{
args.Add(effect.Arg1);
}
if (effect.Arg2 != null)
{
args.Add(effect.Arg2);
}
for (var argIdx = 0; argIdx < args.Count; argIdx++)
{
var _arg = args.ElementAt(argIdx);
if (argIdx == 0)
{
curLine += " ";
}
if (argIdx == 1)
{
switch (effect.Type)
{
case MutationEffectType.Assign:
case MutationEffectType.AssignAdd:
case MutationEffectType.AssignSubtract:
case MutationEffectType.AssignMultiply:
case MutationEffectType.AssignDivide:
curLine += " = ";
break;
case MutationEffectType.Add:
case MutationEffectType.AddMultiply:
case MutationEffectType.AddDivide:
curLine += " += ";
break;
case MutationEffectType.Subtract:
case MutationEffectType.SubtractMultiply:
case MutationEffectType.SubtractDivide:
curLine += " -= ";
break;
case MutationEffectType.Multiply:
curLine += " *= ";
break;
case MutationEffectType.Divide:
curLine += " /= ";
break;
case MutationEffectType.AtLeastAdd:
curLine += " >= ";
break;
case MutationEffectType.AtMostSubtract:
curLine += " <= ";
break;
}
}
if (argIdx == 2)
{
switch (effect.Type)
{
case MutationEffectType.AssignAdd:
curLine += " + ";
break;
case MutationEffectType.AssignSubtract:
curLine += " - ";
break;
case MutationEffectType.AssignMultiply:
case MutationEffectType.AddMultiply:
case MutationEffectType.SubtractMultiply:
curLine += " * ";
break;
case MutationEffectType.AssignDivide:
case MutationEffectType.AddDivide:
case MutationEffectType.SubtractDivide:
curLine += " / ";
break;
case MutationEffectType.AtLeastAdd:
curLine += ", add ";
break;
case MutationEffectType.AtMostSubtract:
curLine += ", sub ";
break;
}
}
var arg = new EffectArgument(_arg);
switch (arg.Type)
{
case EffectArgumentType.Int:
if (argIdx == 1 && propInt == PropertyInt.WieldRequirements)
{
curLine += $"{(WieldRequirement)arg.IntVal}";
}
else
{
curLine += $"{arg.IntVal}";
}
break;
case EffectArgumentType.Double:
curLine += $"{arg.DoubleVal}";
break;
case EffectArgumentType.Quality:
switch (arg.StatType)
{
case StatType.Int:
curLine += $"{(PropertyInt)arg.StatIdx}";
if (argIdx == 0)
{
propInt = (PropertyInt)arg.StatIdx;
}
break;
case StatType.Bool:
curLine += $"{(PropertyBool)arg.StatIdx}";
break;
case StatType.Float:
curLine += $"{(PropertyFloat)arg.StatIdx}";
break;
case StatType.DID:
curLine += $"{(PropertyDataId)arg.StatIdx}";
break;
default:
curLine += $"Unknown StatType: {arg.StatType}, StatIdx: {arg.StatIdx}";
break;
}
break;
case EffectArgumentType.Random:
curLine += $"Random({arg.MinVal}, {arg.MaxVal})";
break;
case EffectArgumentType.Variable:
curLine += $"Variable[{arg.IntVal}]";
break;
default:
curLine += $"Unknown EffectArgumentType: {arg.Type}";
break;
}
}
lines.Add(curLine);
}
lines.Add("");
}
}
}
return(lines);
}
public static MutationFilter Parse(string filename)
{
if (!File.Exists(filename))
{
Console.WriteLine($"{filename} not found");
return(null);
}
var lines = File.ReadAllLines(filename);
string mutationLine = null;
var mutationFilter = new MutationFilter();
Mutation mutation = null;
MutationOutcome outcome = null;
EffectList effectList = null;
foreach (var line in lines)
{
if (line.Contains("Mutation #", StringComparison.OrdinalIgnoreCase))
{
mutationLine = line;
continue;
}
if (line.Contains("Tier chances", StringComparison.OrdinalIgnoreCase))
{
mutation = new Mutation();
mutationFilter.Mutations.Add(mutation);
var tierPieces = line.Split(',');
foreach (var tierPiece in tierPieces)
{
var match = Regex.Match(tierPiece, @"([\d.]+)");
if (match.Success && float.TryParse(match.Groups[1].Value, out var tierChance))
{
mutation.Chances.Add(tierChance);
}
else
{
Console.WriteLine($"Couldn't parse Tier chances for {mutationLine}: {tierPiece}");
mutation.Chances.Add(0.0f);
}
}
// verify
outcome = new MutationOutcome();
mutation.Outcomes.Add(outcome);
continue;
}
if (line.Contains("- Chance ", StringComparison.OrdinalIgnoreCase))
{
effectList = new EffectList();
outcome.EffectLists.Add(effectList);
var match = Regex.Match(line, @"([\d.]+)");
if (match.Success && float.TryParse(match.Groups[1].Value, out var chance))
{
effectList.Chance = chance;
}
else
{
Console.WriteLine($"Couldn't parse {line} for {mutationLine}");
}
continue;
}
if (!line.Contains("="))
{
continue;
}
var effect = new Effect();
effect.Type = GetMutationEffectType(line);
var firstOperator = GetFirstOperator(effect.Type);
var pieces = line.Split(firstOperator, 2);
if (pieces.Length != 2)
{
Console.WriteLine($"Couldn't parse {line}");
continue;
}
pieces[0] = pieces[0].Trim();
pieces[1] = pieces[1].Trim();
var firstStatType = GetStatType(pieces[0]);
/*if (firstStatType == StatType.Undef)
* {
* Console.WriteLine($"Couldn't determine StatType for {pieces[0]} in {line}");
* continue;
* }*/
effect.Quality = ParseEffectArgument(pieces[0]);
var hasSecondOperator = HasSecondOperator(effect.Type);
if (!hasSecondOperator)
{
effect.Arg1 = ParseEffectArgument(pieces[1]);
}
else
{
var secondOperator = GetSecondOperator(effect.Type);
var subpieces = pieces[1].Split(secondOperator, 2);
if (subpieces.Length != 2)
{
Console.WriteLine($"Couldn't parse {line}");
continue;
}
subpieces[0] = subpieces[0].Trim();
subpieces[1] = subpieces[1].Trim();
effect.Arg1 = ParseEffectArgument(subpieces[0]);
effect.Arg2 = ParseEffectArgument(subpieces[1]);
}
effectList.Effects.Add(effect);
}
return(mutationFilter);
}
