public void ParseReturnsCorrectResult()
{
var untranslatedStats = new[]
{
new UntranslatedStat("a", 1),
new UntranslatedStat("b", 2),
new UntranslatedStat("c", 3),
};
var modifierLines = new[] { "a1", "b2" };
var statTranslatorResult = new StatTranslatorResult(modifierLines, new UntranslatedStat[0]);
var translator = Mock.Of <IStatTranslator>(t => t.Translate(untranslatedStats) == statTranslatorResult);
var localSource = new ModifierSource.Local.Skill();
var globalSource = new ModifierSource.Global(localSource);
var coreParserParameters = new[]
{
new CoreParserParameter(modifierLines[0], globalSource, Entity.Character),
new CoreParserParameter(modifierLines[1], globalSource, Entity.Character),
};
var parseResults = new[]
{
ParseResult.Empty,
ParseResult.Failure("b2", ""),
};
var coreParser = Mock.Of <ICoreParser>(p =>
p.Parse(coreParserParameters[0]) == parseResults[0] &&
p.Parse(coreParserParameters[1]) == parseResults[1]);
var sut = new UntranslatedStatParser(translator, coreParser);
var parserParameter = new UntranslatedStatParserParameter(localSource, untranslatedStats);
var expected = ParseResult.Aggregate(parseResults);
var actual = sut.Parse(parserParameter);
Assert.AreEqual(expected, actual);
}
public void ParseMultipleSupportedActiveSkillsCorrectly()
{
var expected = ParseResult.Aggregate(new[]
{
CreateParseResult("0", "b", "c"),
CreateParseResult("1", "b"),
CreateParseResult("2", "a", "b", "d"),
});
var actives = new[]
{
CreateSkill("0", 0),
CreateSkill("1", 1),
CreateSkill("2", 2),
};
var supports = new[]
{
CreateSkill("a", 2),
CreateSkill("b", null),
CreateSkill("c", 0),
CreateSkill("d", 2),
};
var sut = CreateSut();
var actual = sut.Parse(actives.Concat(supports).ToList());
Assert.AreEqual(expected, actual);
}
public ParseResult Parse(PartialItemParserParameter parameter)
{
var(item, _, entity, baseItemDefinition, localSource, globalSource) = parameter;
var itemTags = baseItemDefinition.Tags;
var results = new List <ParseResult>(1 + item.Modifiers.Count)
{
ParseBuffStats(entity, itemTags, localSource, baseItemDefinition.BuffStats)
};
foreach (var modifier in item.Modifiers)
{
if (ModifierLocalityTester.AffectsProperties(modifier, itemTags))
{
results.Add(ParsePropertyModifier(localSource, entity, modifier));
}
else if (ModifierLocalityTester.IsLocal(modifier, itemTags))
{
results.Add(ParseLocalModifier(itemTags, localSource, entity, modifier));
}
else
{
results.Add(ParseGlobalModifier(itemTags, globalSource, entity, modifier));
}
}
return(ParseResult.Aggregate(results));
}
public ParseResult Parse(IReadOnlyList <Skill> skills)
{
var activeSkills = new List <Skill>();
var supportSkills = new List <Skill>(skills.Count);
foreach (var skill in skills)
{
if (_skillDefinitions.GetSkillById(skill.Id).IsSupport)
{
supportSkills.Add(skill);
}
else
{
activeSkills.Add(skill);
}
}
var parseResults = new List <ParseResult>(activeSkills.Count * supportSkills.Count);
foreach (var activeSkill in activeSkills)
{
parseResults.Add(_activeSkillParser.Parse(activeSkill));
var supportingSkills = _supportabilityTester.SelectSupportingSkills(activeSkill, supportSkills);
foreach (var supportingSkill in supportingSkills)
{
parseResults.Add(_supportSkillParser.Parse(activeSkill, supportingSkill));
}
}
return(ParseResult.Aggregate(parseResults));
}
public ParseResult Parse(GemsParserParameter parameter)
{
var(gems, entity) = parameter;
var results = new List <ParseResult>(gems.Count);
foreach (var gem in gems)
{
results.Add(_gemParser.Parse(gem, entity, out var newSkills));
parameter.Skills.AddRange(newSkills);
}
results.AddRange(ParseAdditionalSkillStats(parameter.Skills, entity));
return(ParseResult.Aggregate(results));
}
private ParseResult ParseTransformationModifier(string modifier, ModifierSource modifierSource,
IEnumerable <PassiveNodeDefinition> nodesInRadius)
{
var transformedNodeModifiers = _transformationParser.ApplyTransformation(modifier, nodesInRadius).ToList();
var results = new List <ParseResult>(transformedNodeModifiers.Count);
foreach (var transformedModifier in transformedNodeModifiers)
{
var parseResult = _coreParser.Parse(transformedModifier.Modifier, modifierSource, ModifierSourceEntity)
.ApplyMultiplier(transformedModifier.ValueMultiplier.Build, ModifierSourceEntity);
results.Add(parseResult);
}
return(ParseResult.Aggregate(results));
}
public ParseResult Parse(JewelInSkillTreeParserParameter parameter)
{
var(item, radius, nodeId) = parameter;
if (!item.IsEnabled)
{
return(ParseResult.Empty);
}
var localSource = new ModifierSource.Local.Jewel(radius, nodeId, item.Name);
var globalSource = new ModifierSource.Global(localSource);
var nodesInRadius = _tree.GetNodesInRadius(nodeId, radius).ToList();
var results = new List <ParseResult>(item.Modifiers.Count);
foreach (var modifier in item.Modifiers)
{
results.Add(ParseModifier(modifier, globalSource, nodesInRadius));
}
return(ParseResult.Aggregate(results));
}
public ParseResult Parse(ItemParserParameter parameter)
{
var(item, slot) = parameter;
if (!item.IsEnabled)
{
return(ParseResult.Empty);
}
var localSource = new ModifierSource.Local.Item(slot, item.Name);
var globalSource = new ModifierSource.Global(localSource);
var baseItemDefinition = _baseItemDefinitions.GetBaseItemById(item.BaseMetadataId);
var partialParserParameter =
new PartialItemParserParameter(item, slot, baseItemDefinition, localSource, globalSource);
var parseResults = new List <ParseResult>(_partialParsers.Length);
foreach (var partialParser in _partialParsers)
{
parseResults.Add(partialParser.Parse(partialParserParameter));
}
return(ParseResult.Aggregate(parseResults));
}
public ParseResult Parse(AdditionalSkillStatParserParameter parameter) => ParseResult.Aggregate(_parsers.Select(p => p.Parse(parameter)));
public ParseResult Parse(SkillsParserParameter parameter)
{
var(skills, entity) = parameter;
var(supportSkills, activeSkills) = skills.Partition(s => _skillDefinitions.GetSkillById(s.Id).IsSupport);
return(ParseResult.Aggregate(Parse(activeSkills.ToList(), supportSkills.ToList(), entity)));
}