Пример #1
0
        private static PassiveNodeParser CreateSut(PassiveNodeDefinition nodeDefinition, ICoreParser coreParser = null)
        {
            coreParser = coreParser ?? Mock.Of <ICoreParser>();
            var treeDefinition = new PassiveTreeDefinition(new[] { nodeDefinition });

            return(new PassiveNodeParser(treeDefinition, CreateBuilderFactories(), coreParser));
        }
Пример #2
0
        public void JsonPassiveNode_Convert(float _x, float _y, float zoomLevel, int orbitRadiiIndex, float[] orbitRadii, int skillsPerOrbitIndex, float[] skillsPerOrbit)
        {
            var group = new JsonPassiveNodeGroup
            {
                OriginalX = _x,
                OriginalY = _y,
                ZoomLevel = zoomLevel,
            };

            var node = new JsonPassiveNode
            {
                PassiveNodeGroup    = group,
                OrbitRadiiIndex     = orbitRadiiIndex,
                OrbitRadii          = orbitRadii,
                SkillsPerOrbitIndex = skillsPerOrbitIndex,
                SkillsPerOrbit      = skillsPerOrbit,
                ZoomLevel           = zoomLevel,
            };

            var nodeDefinition = PassiveNodeDefinition.Convert(node);
            var nodePosition   = node.PositionAtZoomLevel(1f);

            Assert.AreEqual(nodePosition.X, nodeDefinition.Position.X);
            Assert.AreEqual(nodePosition.Y, nodeDefinition.Position.Y);
        }
Пример #3
0
        public void TransformationResultIsThatOfMatchingComponentGivenAComponentMatches()
        {
            var expected      = new[] { new TransformedNodeModifier("", Mock.Of <IValueBuilder>()), };
            var nodesInRadius = new PassiveNodeDefinition[0];
            var component     = Mock.Of <ITransformationJewelParser>(p =>
                                                                     p.IsTransformationJewelModifier(JewelModifier) &&
                                                                     p.ApplyTransformation(JewelModifier, nodesInRadius) == expected);
            var sut = new CompositeTransformationJewelParser(component);

            var actual = sut.ApplyTransformation(JewelModifier, nodesInRadius);

            actual.Should().Equal(expected);
        }
Пример #4
0
        public void ReturnsCorrectModifier(ushort nodeId)
        {
            var definition = new PassiveNodeDefinition(nodeId, PassiveNodeType.Normal, "", false,
                                                       true, 0, new string[0]);
            var expected = new[]
            {
                CreateModifier($"{nodeId}.Skilled", Form.TotalOverride, 1, CreateGlobalSource(definition))
            };
            var treeDefinition = new PassiveTreeDefinition(new[] { definition });
            var sut            = new SkilledPassiveNodeParser(treeDefinition, CreateBuilderFactories());

            var result = sut.Parse(nodeId);

            Assert.AreEqual(expected, result.Modifiers);
        }
Пример #5
0
 private static ModifierSource.Global CreateGlobalSource(PassiveNodeDefinition nodeDefinition)
 => new ModifierSource.Global(new ModifierSource.Local.Tree(nodeDefinition.Name));
Пример #6
0
 private static Modifier CreateConditionalModifier(
     PassiveNodeDefinition nodeDefinition, string stat, Form form, double value)
 => CreateModifier(stat, form, new FunctionalValue(null,
                                                   $"Character.{nodeDefinition.Id}.Skilled.Value(Total, Global).IsSet ? {value} : null"),
                   CreateGlobalSource(nodeDefinition));