private RequirementGroupViewModel FindBestMatch(RequirementGroupViewModel needle, IEnumerable <RequirementGroupViewModel> haystack)
{
RequirementGroupViewModel bestMatch = null;
int bestMatchCount = 0;
var requirementExs = RequirementEx.Combine(needle.Requirements.Select(r => r.Requirement));
foreach (var potentialMatch in haystack)
{
// convert to requirement clauses and compare
var compareRequirementExs = RequirementEx.Combine(potentialMatch.Requirements.Select(r => r.Requirement));
int matchCount = compareRequirementExs.Count;
foreach (var requirementEx in requirementExs)
{
for (int i = 0; i < compareRequirementExs.Count; i++)
{
if (compareRequirementExs[i] == requirementEx)
{
compareRequirementExs.RemoveAt(i);
break;
}
}
}
matchCount -= compareRequirementExs.Count;
if (matchCount > bestMatchCount)
{
bestMatchCount = matchCount;
bestMatch = potentialMatch;
}
}
return(bestMatch);
}
public bool RequirementsAreEqual(RequirementGroupViewModel that)
{
// quick check to make sure the same number of requirements exist
if (Requirements.Count() != that.Requirements.Count())
{
return(false);
}
// convert to requirement clauses and compare
var requirementExs = RequirementEx.Combine(Requirements.Select(r => r.Requirement));
var compareRequirementExs = RequirementEx.Combine(that.Requirements.Select(r => r.Requirement));
if (requirementExs.Count != compareRequirementExs.Count)
{
return(false);
}
foreach (var requirementEx in requirementExs)
{
bool matched = false;
for (int i = 0; i < compareRequirementExs.Count; i++)
{
if (compareRequirementExs[i] == requirementEx)
{
compareRequirementExs.RemoveAt(i);
matched = true;
break;
}
}
if (!matched)
{
return(false);
}
}
return(true);
}
private void DumpPublishedRequirements(StreamWriter stream, DumpAchievementItem dumpAchievement,
RequirementGroupViewModel requirementGroupViewModel, NumberFormat numberFormat)
{
bool needsAmpersand = false;
const int MaxWidth = 106; // 120 - " trigger = ".Length
int width = MaxWidth;
var requirementEnumerator = requirementGroupViewModel.Requirements.GetEnumerator();
while (requirementEnumerator.MoveNext())
{
if (String.IsNullOrEmpty(requirementEnumerator.Current.Definition))
{
continue;
}
var addSources = new StringBuilder();
var subSources = new StringBuilder();
var addHits = new StringBuilder();
bool isCombining = true;
do
{
switch (requirementEnumerator.Current.Requirement.Type)
{
case RequirementType.AddSource:
requirementEnumerator.Current.Requirement.Left.AppendString(addSources, numberFormat);
addSources.Append(" + ");
break;
case RequirementType.SubSource:
subSources.Append(" - ");
requirementEnumerator.Current.Requirement.Left.AppendString(subSources, numberFormat);
break;
case RequirementType.AddHits:
requirementEnumerator.Current.Requirement.AppendString(addHits, numberFormat);
addHits.Append(" || ");
break;
default:
isCombining = false;
break;
}
if (!isCombining)
{
break;
}
if (!requirementEnumerator.MoveNext())
{
return;
}
} while (true);
var definition = new StringBuilder();
requirementEnumerator.Current.Requirement.AppendString(definition, numberFormat,
addSources.Length > 0 ? addSources.ToString() : null,
subSources.Length > 0 ? subSources.ToString() : null,
addHits.Length > 0 ? addHits.ToString() : null);
foreach (var memoryItem in dumpAchievement.MemoryAddresses.Where(m => !String.IsNullOrEmpty(m.FunctionName)))
{
var memoryReference = Field.GetMemoryReference(memoryItem.Address, memoryItem.Size);
var functionCall = memoryItem.FunctionName + "()";
definition.Replace(memoryReference, functionCall);
}
if (needsAmpersand)
{
stream.Write(" && ");
width -= 4;
}
else
{
needsAmpersand = true;
}
while (definition.Length > MaxWidth)
{
var index = width;
while (index > 0 && definition[index] != ' ')
{
index--;
}
stream.Write(definition.ToString().Substring(0, index));
stream.WriteLine();
stream.Write(" ");
definition.Remove(0, index);
width = MaxWidth;
}
if (width - definition.Length < 0)
{
stream.WriteLine();
stream.Write(" ");
width = MaxWidth;
}
width -= definition.Length;
stream.Write(definition.ToString());
}
}
