public void ParseFrenzyReturnsCorrectResult()
{
var frenzyGem = new Gem("Frenzy", 20, 20, ItemSlot.Boots, 0, 0, true);
var frenzy = Skill.FromGem(frenzyGem, true);
var definition = _skillDefinitions.GetSkillById("Frenzy");
var levelDefinition = definition.Levels[20];
var local = new ModifierSource.Local.Skill("Frenzy", "Frenzy");
var global = new ModifierSource.Global(local);
var valueCalculationContextMock = new Mock <IValueCalculationContext>();
var isMainSkillStat = SetupIsActiveSkillInContext(valueCalculationContextMock, frenzy);
var offHandTagsStat = new Stat("OffHand.ItemTags");
valueCalculationContextMock.Setup(c => c.GetValue(offHandTagsStat, NodeType.Total, PathDefinition.MainPath))
.Returns(new NodeValue(Tags.Weapon.EncodeAsDouble()));
var mainHandTagsStat = new Stat("MainHand.ItemTags");
valueCalculationContextMock
.Setup(c => c.GetValue(mainHandTagsStat, NodeType.Total, PathDefinition.MainPath))
.Returns(new NodeValue(Tags.Ranged.EncodeAsDouble()));
var frenzyAmountStat = new Stat("Frenzy.Amount");
valueCalculationContextMock
.Setup(c => c.GetValue(frenzyAmountStat, NodeType.Total, PathDefinition.MainPath))
.Returns(new NodeValue(3));
var baseCostStat = new Stat("Boots.0.0.Cost");
valueCalculationContextMock
.Setup(c => c.GetValue(baseCostStat, NodeType.Total, PathDefinition.MainPath))
.Returns((NodeValue?)levelDefinition.ManaCost);
var expectedModifiers =
new (string stat, Form form, double?value, ModifierSource source, bool mainSkillOnly)[]
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);
}
protected Modifier CreateAdditionalStatModifier(Skill skill, IValueBuilder valueBuilder, Entity modifierSourceEntity)
{
var stats = GetAdditionalStatBuilder(skill).BuildToStats(modifierSourceEntity).ToList();
var value = Build(skill, valueBuilder, modifierSourceEntity);
var modifierSource = new ModifierSource.Global(new ModifierSource.Local.Given());
return(new Modifier(stats, Form.TotalOverride, value, modifierSource));
}
public ModifierCollection(
IBuilderFactories builderFactories, ModifierSource.Local localModifierSource,
Entity modifierSourceEntity)
{
(_builderFactories, _localModifierSource, _modifierSourceEntity) =
(builderFactories, localModifierSource, modifierSourceEntity);
_globalModifierSource = new ModifierSource.Global(_localModifierSource);
}
public void BuildReturnsPassedModifierSource()
{
var sut = CreateSut();
var expected = new ModifierSource.Global();
var(_, actual, _) = sut.BuildToSingleResult(expected);
Assert.AreEqual(expected, actual);
}
private ParseResult ParseGlobalModifier(Tags itemTags, ModifierSource.Global source, Entity entity, string modifier)
{
var result = _coreParser.Parse(modifier, source, entity);
if (itemTags.HasFlag(Tags.Flask))
{
result = MultiplyValuesByFlaskEffect(result, entity);
}
return(result);
}
private static Modifier CreateModifier(IReadOnlyList <IStat> stats, Form form, IValue value,
ModifierSource source)
{
if (form == Form.TotalOverride && source is ModifierSource.Local localSource)
{
source = new ModifierSource.Global(localSource);
}
return(new Modifier(stats, form, value, source));
}
public static IReadOnlyList <Modifier> Parse(IParser parser, IEnumerable <IGivenStats> givenStats)
{
var modifierSource = new ModifierSource.Global(new ModifierSource.Local.Given());
var givenParser = new GivenStatsParser(parser, modifierSource);
foreach (var given in givenStats)
{
givenParser.Parse(given);
}
return(givenParser._modifiers);
}
public void AddModifierUsesCorrectPath()
{
var node = MockNodeProvider();
var source = new ModifierSource.Global(new ModifierSource.Local.Given());
var modifier = MockModifier(source: source);
var collection = CreateModifierNodeCollection();
var selector = new FormNodeSelector(modifier.Form, new PathDefinition(source.CanonicalSource));
var factory = Mock.Of <IStatNodeFactory>(f => f.Create(selector) == collection);
var sut = CreateSut(factory);
sut.AddModifier(node, modifier);
CollectionAssert.Contains(collection.DefaultView, (node.DefaultView, modifier));
}
public void ParseRareJewelInBodyArmourReturnsCorrectResult()
{
var mods = new[]
{
"+120 to Armour",
"+27 to maximum Life",
"+13% to Fire Resistance",
};
var item = new Item("Metadata/Items/Jewels/JewelAbyssRanged",
"Grim Arbiter Searching Eye Jewel", 0, 54, FrameType.Rare, false, mods, true);
var local = new ModifierSource.Local.Item(ItemSlot.BodyArmour, item.Name);
var global = new ModifierSource.Global(local);
var valueCalculationContext = Mock.Of <IValueCalculationContext>();
var expectedModifiers = new (string stat, Form form, double?value)[]
private static IEnumerable <object[]> ReadParseableStatLines()
{
ModifierSource passiveNodeSource = new ModifierSource.Global(new ModifierSource.Local.PassiveNode(0));
ModifierSource itemSource = new ModifierSource.Global(new ModifierSource.Local.Item(ItemSlot.Belt));
ModifierSource givenSource = new ModifierSource.Global(new ModifierSource.Local.Given());
var unparsedGivenStats = new GivenStatsCollection(null !, null !, null !).SelectMany(s => s.GivenStatLines);
return(ReadDataLines("SkillTreeStatLines").Select(s => (s, passiveNodeSource))
.Concat(ReadDataLines("ItemAffixes").Select(s => (s, itemSource)))
.Concat(ReadDataLines("ParseableStatLines").Select(s => (s, passiveNodeSource)))
.Concat(unparsedGivenStats.Select(s => (s, givenSource)))
.Where(t => !NotParseableStatLines.Value.Contains(t.s.ToLowerInvariant()))
.Select(t => new object[] { t.s, t.Item2 }));
}
public SkillPreParseResult(
SkillDefinition skillDefinition, SkillLevelDefinition levelDefinition, SkillDefinition mainSkillDefinition,
ModifierSource.Local.Skill localSource, ModifierSource.Global globalSource, Entity modifierSourceEntity,
IConditionBuilder isMainSkill, IConditionBuilder isActiveSkill)
{
SkillDefinition = skillDefinition;
LevelDefinition = levelDefinition;
MainSkillDefinition = mainSkillDefinition;
LocalSource = localSource;
GlobalSource = globalSource;
ModifierSourceEntity = modifierSourceEntity;
IsMainSkill = isMainSkill;
IsActiveSkill = isActiveSkill;
}
public void ParseRareAstralPlateReturnsCorrectResult()
{
var mods = new[]
{
"+1% to Fire Resistance", "+50 to maximum Life", "+32 to Strength", "10% increased Armour"
};
var item = new Item("Metadata/Items/Armours/BodyArmours/BodyStr15",
"Hypnotic Keep Astral Plate", 20, 62, FrameType.Rare, false, mods, true);
var definition = _baseItemDefinitions.GetBaseItemById(item.BaseMetadataId);
var local = new ModifierSource.Local.Item(ItemSlot.BodyArmour, item.Name);
var global = new ModifierSource.Global(local);
var armourPropertyStat = new Stat("BodyArmour.Armour");
var valueCalculationContext = Mock.Of <IValueCalculationContext>(c =>
c.GetValue(armourPropertyStat, NodeType.Total, PathDefinition.MainPath) == (NodeValue?)5);
var expectedModifiers =
new (string stat, Form form, double?value, ModifierSource source)[]
public static async Task ClassInit()
{
_builderFactories = await BuilderFactoriesTask.ConfigureAwait(false);
_metaStats = _builderFactories.MetaStatBuilders;
var parser = await ParserTask.ConfigureAwait(false);
var modSource = new ModifierSource.Global();
_givenMods = parser.ParseGivenModifiers()
.Append(
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.Taken
.For(_builderFactories.EntityBuilders.Enemy)),
Form.Increase, new Constant(20), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Resistance
.For(_builderFactories.EntityBuilders.Enemy)),
Form.BaseSet, new Constant(60), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.DamageMultiplier),
Form.BaseAdd, new Constant(75), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Level),
Form.BaseSet, new Constant(90), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.WithSkills),
Form.BaseSet, new Constant(5), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Accuracy),
Form.BaseAdd, new Constant(1000), modSource),
new Modifier(
Build(_metaStats.SkillHitDamageSource),
Form.BaseSet, new Constant((int)DamageSource.Attack), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.MainHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.OffHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_builderFactories.EquipmentBuilders.Equipment[ItemSlot.MainHand].ItemTags),
Form.TotalOverride, new Constant(Tags.Sword.EncodeAsDouble()), modSource))
.ToList();
}
public static void ClassInit()
{
var compRoot = new CompositionRoot();
_builderFactories = compRoot.BuilderFactories;
_metaStats = compRoot.MetaStats;
var modSource = new ModifierSource.Global();
_givenMods = GivenStatsParser.Parse(compRoot.Parser, compRoot.GivenStats.Result)
.Append(
new Modifier(
Build(_builderFactories.StatBuilders.Level.For(_builderFactories.EntityBuilders.Enemy)),
Form.BaseSet, new Constant(84), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.Taken
.For(_builderFactories.EntityBuilders.Enemy)),
Form.Increase, new Constant(20), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Resistance
.For(_builderFactories.EntityBuilders.Enemy)),
Form.BaseSet, new Constant(60), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Level),
Form.BaseSet, new Constant(90), modSource),
new Modifier(
Build(_builderFactories.DamageTypeBuilders.Physical.Damage.WithSkills),
Form.BaseSet, new Constant(5), modSource),
new Modifier(
Build(_builderFactories.StatBuilders.Accuracy),
Form.BaseAdd, new Constant(1000), modSource),
new Modifier(
Build(_metaStats.SkillHitDamageSource),
Form.BaseSet, new Constant((int)DamageSource.Attack), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.MainHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_metaStats.SkillUsesHand(AttackDamageHand.OffHand)),
Form.BaseSet, new Constant(true), modSource),
new Modifier(
Build(_builderFactories.EquipmentBuilders.Equipment[ItemSlot.MainHand].ItemTags),
Form.TotalOverride, new Constant((int)Tags.Sword), modSource))
.ToList();
}
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 void MultipleUpdates()
{
var sut = Calculator.Create();
var source = new ModifierSource.Global();
var removedModifier = new Modifier(new[] { Stat }, Form.BaseAdd, new Constant(100), source);
sut.NewBatchUpdate()
.AddModifier(Stat, Form.BaseAdd, new Constant(10), source)
.DoUpdate();
sut.NewBatchUpdate()
.AddModifier(Stat, Form.BaseAdd, new Constant(1), source)
.AddModifier(removedModifier)
.DoUpdate();
sut.NewBatchUpdate()
.RemoveModifier(removedModifier)
.AddModifier(Stat, Form.BaseAdd, new Constant(1000), source)
.DoUpdate();
var actual = sut.NodeRepository.GetNode(Stat).Value;
Assert.AreEqual(new NodeValue(1011), actual);
}
public void EvasionCalculation()
{
var sut = Calculator.CreateCalculator();
var evasionStat = new Stat();
var lvlStat = new Stat();
var dexterityStat = new Stat();
var globalSource = new ModifierSource.Global();
var bodySource = new ModifierSource.Local.Item(ItemSlot.BodyArmour);
var shieldSource = new ModifierSource.Local.Item(ItemSlot.OffHand);
sut.NewBatchUpdate()
.AddModifier(evasionStat, Form.BaseSet, new Constant(53), globalSource)
.AddModifier(evasionStat, Form.BaseAdd, new PerStatValue(lvlStat, 3), globalSource)
.AddModifier(evasionStat, Form.BaseSet, new Constant(1000), bodySource)
.AddModifier(evasionStat, Form.BaseSet, new Constant(500), shieldSource)
.AddModifier(evasionStat, Form.Increase, new Constant(100), globalSource)
.AddModifier(evasionStat, Form.Increase, new PerStatValue(dexterityStat, 1, 5), globalSource)
.AddModifier(evasionStat, Form.Increase, new Constant(20), shieldSource)
.AddModifier(evasionStat, Form.More, new Constant(100), bodySource)
.AddModifier(lvlStat, Form.BaseSet, new Constant(90), globalSource)
.AddModifier(dexterityStat, Form.BaseSet, new Constant(32), globalSource)
.AddModifier(dexterityStat, Form.BaseAdd, new Constant(50), globalSource)
.DoUpdate();
var lvlTotal = 90 * 3;
var dexterityTotal = 50 + 32;
var globalBase = 53 + lvlTotal;
var globalIncrease = 1 + Math.Ceiling(dexterityTotal / 5.0) / 100;
var globalTotal = globalBase * (1 + globalIncrease);
var bodyBase = 1000;
var bodyTotal = bodyBase * (1 + globalIncrease) * 2;
var shieldBase = 500;
var shieldTotal = shieldBase * (1 + globalIncrease + 0.2);
var evasionTotal = globalTotal + bodyTotal + shieldTotal;
var actual = sut.NodeRepository.GetNode(evasionStat).Value;
Assert.AreEqual(new NodeValue(evasionTotal), actual);
}
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 void AddAddsFromStatsCorrectly()
{
var expectedStats = new[] { new StatStub(), };
var expectedForm = Form.BaseSet;
var expectedValue = new Constant(42);
var expectedModifierSource = new ModifierSource.Global();
var expected = new []
{
new Modifier(expectedStats, expectedForm, expectedValue, expectedModifierSource)
};
var buildParams = new BuildParameters(expectedModifierSource, Entity.Enemy, expectedForm);
var formBuilderMock = new Mock <IFormBuilder>();
formBuilderMock.Setup(b => b.Build())
.Returns((expectedForm, Funcs.Identity));
var statBuilderMock = new Mock <IStatBuilder>();
statBuilderMock.Setup(b => b.Build(buildParams))
.Returns(new[] { new StatBuilderResult(expectedStats, expectedModifierSource, Funcs.Identity), });
var valueBuilder = Mock.Of <IValueBuilder>(b => b.Build(buildParams) == expectedValue);
var intermediateModifier = new ModifierBuilder()
.WithForm(formBuilderMock.Object).WithStat(statBuilderMock.Object).WithValue(valueBuilder)
.Build();
var givenStats = new[]
{
Mock.Of <IGivenStats>(s =>
s.AffectedEntities == new[] { Entity.Enemy } &&
s.GivenStatLines == new string[0] &&
s.GivenModifiers == new[] { intermediateModifier })
};
var actual = GivenStatsParser.Parse(Mock.Of <IParser>(), givenStats);
Assert.AreEqual(expected, actual);
}
public PartialItemParserParameter(
Item item, ItemSlot itemSlot, BaseItemDefinition baseItemDefinition,
ModifierSource.Local localSource, ModifierSource.Global globalSource)
=> (Item, ItemSlot, BaseItemDefinition, LocalSource, GlobalSource) =
