public void Roll20_VerifyTotal_Test()
        {
            var calc = new Calculator();
            var bag  = new ModifierBag()
            {
                new Modifier()
                {
                    Type = ModifierType.Ability, Value = 2
                },
                new Modifier()
                {
                    Type = ModifierType.Item, Value = 4
                },
                new Modifier()
                {
                    Type = ModifierType.Status, Value = 1
                },
                new Modifier()
                {
                    Type = ModifierType.UntypedPenalty, Value = -2
                }
            };
            var result = calc.Rolld20(bag, 15, false);

            Assert.AreEqual(result.DieResult + result.TotalModifiers, result.TotalResult);
        }
Beispiel #2
0
        public void Add_TypeAndValue_ReturnsId_Test()
        {
            var bag = new ModifierBag();
            var id  = bag.Add(ModifierType.Ability, 1);

            Assert.AreEqual(id, bag[0].Id);
        }
        public void Roll_ThreeArgs_WithModifiers_Test()
        {
            var calc = new Calculator();
            var bag  = new ModifierBag()
            {
                new Modifier()
                {
                    Type = ModifierType.Ability, Value = 2
                },
                new Modifier()
                {
                    Type = ModifierType.Item, Value = 4
                },
                new Modifier()
                {
                    Type = ModifierType.Status, Value = 1
                },
                new Modifier()
                {
                    Type = ModifierType.UntypedPenalty, Value = -2
                }
            };
            var result = calc.Roll(2, 2, bag);

            Assert.IsTrue(result.TotalResult > 6 && result.TotalResult < 10);
            Assert.AreEqual(5, result.TotalModifiers);
            int total = result.TotalModifiers;

            foreach (var r in result.DieResults)
            {
                total += r;
            }
            Assert.AreEqual(total, result.TotalResult);
        }
Beispiel #4
0
        public void Remove_ByTypeAndValue_Test()
        {
            var   type  = ModifierType.Ability;
            short value = 1;
            var   bag   = new ModifierBag();
            var   id    = bag.Add(type, value);

            Assert.IsTrue(1 == bag.Count);
            Assert.AreEqual(id, bag[0].Id);
        }
Beispiel #5
0
        public void Add_Modifier_IsAdded_Test()
        {
            var mod = new Modifier()
            {
                Type = ModifierType.Ability, Value = 1
            };
            var bag = new ModifierBag();

            bag.Add(mod);
            Assert.AreEqual(mod, bag[0]);
        }
Beispiel #6
0
        public void GetTotalModifiers_UntypedPenaltiesStack_Test()
        {
            var bag = new ModifierBag();

            bag.Add(ModifierType.Ability, 0);
            bag.Add(ModifierType.Proficiency, 4);
            bag.Add(ModifierType.Circumstance, 1);
            bag.Add(ModifierType.UntypedPenalty, -2);
            bag.Add(ModifierType.UntypedPenalty, -1);
            Assert.AreEqual(5, bag.Count);
            Assert.AreEqual(2, bag.GetTotalModifiers());
        }
Beispiel #7
0
        public void Remove_ById_Test()
        {
            var   type  = ModifierType.Ability;
            short value = 1;
            var   bag   = new ModifierBag();
            var   id    = bag.Add(type, value);

            Assert.IsTrue(1 == bag.Count);
            var isRemoved = bag.Remove(id);

            Assert.IsTrue(isRemoved);
            Assert.AreEqual(0, bag.Count);
        }
Beispiel #8
0
        public void Remove_ByModifierType_Test()
        {
            var bag = new ModifierBag();

            bag.Add(ModifierType.Ability, 0);
            bag.Add(ModifierType.Proficiency, 4);
            bag.Add(ModifierType.Circumstance, 1);
            bag.Add(ModifierType.Circumstance, -2);
            bag.Add(ModifierType.Status, -1);
            Assert.AreEqual(5, bag.Count);
            var numRemoved = bag.Remove(ModifierType.Circumstance);

            Assert.AreEqual(2, numRemoved);
            Assert.AreEqual(3, bag.Count);
            Assert.AreEqual(0, bag.Count(m => m.Type == ModifierType.Circumstance));
        }
        public void CheckResult_WithAdjustments_IsCriticalFailure_Test()
        {
            short rollValue = 10;
            short dc        = 25;
            var   modifiers = new ModifierBag()
            {
                new Modifier()
                {
                    Type = ModifierType.Ability, Value = 4
                },
                new Modifier()
                {
                    Type = ModifierType.Status, Value = 1
                }
            };

            Assert.AreEqual(CheckResult.CriticalFailure, new RollResult().GetResult(rollValue, modifiers, dc));
        }
Beispiel #10
0
        public void CheckResult_WithAdjustments_IsSuccess_Test()
        {
            short rollValue = 9;
            short dc        = 5;
            var   modifiers = new ModifierBag()
            {
                new Modifier()
                {
                    Type = ModifierType.Ability, Value = 4
                },
                new Modifier()
                {
                    Type = ModifierType.Status, Value = 1
                }
            };

            Assert.AreEqual(CheckResult.Success, new RollResult().GetResult(rollValue, modifiers, dc));
        }