Esempio n. 1
0
        private Item GetItemWithPossibleOption()
        {
            var item = MockRepository.GenerateStub <Item>();

            item.Stub(i => i.ItemOptions).Return(new List <ItemOptionLink>());
            item.Definition = MockRepository.GenerateStub <ItemDefinition>();
            item.Definition.Stub(d => d.PossibleItemOptions).Return(new List <ItemOptionDefinition>());
            item.Definition.Stub(d => d.BasePowerUpAttributes).Return(new List <ItemBasePowerUpDefinition>());
            item.Durability        = 1;
            item.Definition.Width  = 1;
            item.Definition.Height = 2;
            var option = MockRepository.GenerateStub <ItemOptionDefinition>();

            option.Stub(o => o.PossibleOptions).Return(new List <IncreasableItemOption>());
            option.MaximumOptionsPerItem = 4;
            option.AddsRandomly          = true;
            option.Name = "Damage Option";

            var possibleOption = MockRepository.GenerateStub <IncreasableItemOption>();

            possibleOption.OptionType = ItemOptionTypes.Option;
            possibleOption.Stub(o => o.LevelDependentOptions).Return(new List <ItemOptionOfLevel>());
            option.PossibleOptions.Add(possibleOption);
            for (int level = 1; level <= 4; level++)
            {
                var levelDependentOption = new ItemOptionOfLevel();
                levelDependentOption.Level = level;
                possibleOption.LevelDependentOptions.Add(levelDependentOption);
            }

            item.Definition.PossibleItemOptions.Add(option);
            return(item);
        }
Esempio n. 2
0
        private Item GetItemWithPossibleOption()
        {
            var item = new Mock <Item>();

            item.SetupAllProperties();
            item.Setup(i => i.ItemOptions).Returns(new List <ItemOptionLink>());
            var definition = new Mock <ItemDefinition>();

            definition.SetupAllProperties();
            definition.Setup(d => d.PossibleItemOptions).Returns(new List <ItemOptionDefinition>());
            definition.Setup(d => d.BasePowerUpAttributes).Returns(new List <ItemBasePowerUpDefinition>());
            definition.Object.MaximumItemLevel = 15;
            var itemSlot = new Mock <ItemSlotType>();

            itemSlot.Setup(s => s.ItemSlots).Returns(new List <int> {
                InventoryConstants.LeftHandSlot
            });
            definition.Setup(d => d.ItemSlot).Returns(itemSlot.Object);
            item.Object.Definition        = definition.Object;
            item.Object.Durability        = 1;
            item.Object.Definition.Width  = 1;
            item.Object.Definition.Height = 2;
            var option = new Mock <ItemOptionDefinition>();

            option.SetupAllProperties();
            option.Setup(o => o.PossibleOptions).Returns(new List <IncreasableItemOption>());
            option.Object.MaximumOptionsPerItem = 4;
            option.Object.AddsRandomly          = true;
            option.Name = "Damage Option";

            var possibleOption = new Mock <IncreasableItemOption>();

            possibleOption.SetupAllProperties();
            possibleOption.Setup(o => o.LevelDependentOptions).Returns(new List <ItemOptionOfLevel>());
            possibleOption.Object.OptionType = ItemOptionTypes.Option;
            option.Object.PossibleOptions.Add(possibleOption.Object);
            for (int level = 1; level <= 4; level++)
            {
                var levelDependentOption = new ItemOptionOfLevel();
                levelDependentOption.Level = level;
                possibleOption.Object.LevelDependentOptions.Add(levelDependentOption);
            }

            item.Object.Definition.PossibleItemOptions.Add(option.Object);
            return(item.Object);
        }