Example #1
0
        public VinylPlayerRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <VinylPlayerItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <SteelItem>(typeof(MetalworkingEfficiencySkill), 10, MetalworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <LogItem>(typeof(MetalworkingEfficiencySkill), 10, MetalworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(10, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(VinylPlayerRecipe), Item.Get <VinylPlayerItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <VinylPlayerItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Vinyl Player", typeof(VinylPlayerRecipe));
            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
        }
Example #2
0
        public CurrencyExchangeRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <CurrencyExchangeItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <BrickItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <LumberItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(30, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(CurrencyExchangeRecipe), Item.Get <CurrencyExchangeItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <CurrencyExchangeItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Currency Exchange", typeof(CurrencyExchangeRecipe));
            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
        }
Example #3
0
        public AngelStatueRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <AngelStatueItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <CeramicItem>(typeof(ClayProductionEfficiencySkill), 20, ClayProductionEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <CeramicPolishItem>(typeof(ClayProductionEfficiencySkill), 5, ClayProductionEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(40, ClayProductionSpeedSkill.MultiplicativeStrategy, typeof(ClayProductionSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(AngelStatueRecipe), Item.Get <AngelStatueItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <AngelStatueItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Angel Statue", typeof(AngelStatueRecipe));
            CraftingComponent.AddRecipe(typeof(KilnObject), this);
        }
Example #4
0
        public BlastFurnaceRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <BlastFurnaceItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <BrickItem>(typeof(MetalworkingEfficiencySkill), 10, MetalworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <IronIngotItem>(typeof(MetalworkingEfficiencySkill), 10, MetalworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(60, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(BlastFurnaceRecipe), Item.Get <BlastFurnaceItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <BlastFurnaceItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Blast Furnace", typeof(BlastFurnaceRecipe));
            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
        }
Example #5
0
        public StorageWardrobeRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <StorageWardrobeItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <LogItem>(typeof(WoodworkingEfficiencySkill), 10, WoodworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <BoardItem>(typeof(WoodworkingEfficiencySkill), 30, WoodworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(10, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(StorageWardrobeRecipe), Item.Get <StorageWardrobeItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <StorageWardrobeItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Old Fashion Wardrobe", typeof(StorageWardrobeRecipe));
            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
        }
Example #6
0
        public TallPotRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <TallPotItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <ClayItem>(typeof(ClayProductionEfficiencySkill), 5, ClayProductionEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <WoodPulpItem>(typeof(ClayProductionEfficiencySkill), 5, ClayProductionEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(10, ClayProductionSpeedSkill.MultiplicativeStrategy, typeof(ClayProductionSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(TallPotRecipe), Item.Get <TallPotItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <TallPotItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Tall Pot", typeof(TallPotRecipe));
            CraftingComponent.AddRecipe(typeof(KilnObject), this);
        }
Example #7
0
        public StreetlampRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <StreetlampItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <LightBulbItem>(1),
                new CraftingElement <SteelItem>(typeof(ElectronicEngineeringEfficiencySkill), 20, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(1, ElectronicEngineeringSpeedSkill.MultiplicativeStrategy, typeof(ElectronicEngineeringSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(StreetlampRecipe), Item.Get <StreetlampItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <StreetlampItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Streetlamp", typeof(StreetlampRecipe));
            CraftingComponent.AddRecipe(typeof(RoboticAssemblyLineObject), this);
        }
Example #8
0
        public CampsiteRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <CampsiteItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <ClothItem>(typeof(ClothProductionEfficiencySkill), 10, ClothProductionEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <LogItem>(typeof(ClothProductionEfficiencySkill), 10, ClothProductionEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(15, ClothProductionSpeedSkill.MultiplicativeStrategy, typeof(ClothProductionSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(CampsiteRecipe), Item.Get <CampsiteItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <CampsiteItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize(Localizer.DoStr("Campsite"), typeof(CampsiteRecipe));
            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
        }
        public ShaperRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <ShaperItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <IronPlateItem>(typeof(MechanicsAssemblyEfficiencySkill), 20, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <ScrewsItem>(typeof(MechanicsAssemblyEfficiencySkill), 40, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(10, MechanicsAssemblySpeedSkill.MultiplicativeStrategy, typeof(MechanicsAssemblySpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(ShaperRecipe), Item.Get <ShaperItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <ShaperItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize(Localizer.DoStr("Shaper"), typeof(ShaperRecipe));
            CraftingComponent.AddRecipe(typeof(MachinistTableObject), this);
        }
Example #10
0
        public ElectronicsAssemblyRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <ElectronicsAssemblyItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <SteelItem>(typeof(ElectronicEngineeringEfficiencySkill), 20, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <RivetItem>(typeof(ElectronicEngineeringEfficiencySkill), 10, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(60, ElectronicEngineeringSpeedSkill.MultiplicativeStrategy, typeof(ElectronicEngineeringSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(ElectronicsAssemblyRecipe), Item.Get <ElectronicsAssemblyItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <ElectronicsAssemblyItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Electronics Assembly", typeof(ElectronicsAssemblyRecipe));
            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
        }
        public SmallStandingLumberSignRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <SmallStandingLumberSignItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <BoardItem>(typeof(LumberWoodworkingEfficiencySkill), 10, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <LumberItem>(typeof(LumberWoodworkingEfficiencySkill), 4, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(10, LumberWoodworkingSpeedSkill.MultiplicativeStrategy, typeof(LumberWoodworkingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(SmallStandingLumberSignRecipe), Item.Get <SmallStandingLumberSignItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <SmallStandingLumberSignItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Small Standing Lumber Sign", typeof(SmallStandingLumberSignRecipe));
            CraftingComponent.AddRecipe(typeof(SawmillObject), this);
        }
Example #12
0
        public TailoringTableRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <TailoringTableItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <BoardItem>(typeof(WoodworkingEfficiencySkill), 40, WoodworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <PlantFibersItem>(typeof(WoodworkingEfficiencySkill), 50, WoodworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(60, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(TailoringTableRecipe), Item.Get <TailoringTableItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <TailoringTableItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Tailoring Table", typeof(TailoringTableRecipe));
            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
        }
        public WashingMachineRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <WashingMachineItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <SteelItem>(typeof(IndustrialEngineeringEfficiencySkill), 20, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <CircuitItem>(typeof(IndustrialEngineeringEfficiencySkill), 5, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(10, IndustrialEngineeringSpeedSkill.MultiplicativeStrategy, typeof(IndustrialEngineeringSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(WashingMachineRecipe), Item.Get <WashingMachineItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <WashingMachineItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Washing Machine", typeof(WashingMachineRecipe));
            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
        }
Example #14
0
        public SaltBasketRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <SaltBasketItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <BoardItem>(typeof(FertilizerEfficiencySkill), 10, FertilizerEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <RopeItem>(typeof(FertilizerEfficiencySkill), 6, FertilizerEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(5, FertilizerSpeedSkill.MultiplicativeStrategy, typeof(FertilizerSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(SaltBasketRecipe), Item.Get <SaltBasketItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <SaltBasketItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Salt Basket", typeof(SaltBasketRecipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
Example #15
0
        public CardboardBoxRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <CardboardBoxItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <PaperItem>(typeof(PaperEfficiencySkill), 10, PaperEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <GlueItem>(typeof(PaperEfficiencySkill), 1, PaperEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(2, PaperSpeedSkill.MultiplicativeStrategy, typeof(PaperSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(CardboardBoxRecipe), Item.Get <CardboardBoxItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <CardboardBoxItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Cardboard Box", typeof(CardboardBoxRecipe));
            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
        }
Example #16
0
        public SawmillRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <SawmillItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <IronIngotItem>(typeof(LumberWoodworkingEfficiencySkill), 20, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <LogItem>(typeof(LumberWoodworkingEfficiencySkill), 30, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(15, LumberWoodworkingSpeedSkill.MultiplicativeStrategy, typeof(LumberWoodworkingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(SawmillRecipe), Item.Get <SawmillItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <SawmillItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Sawmill", typeof(SawmillRecipe));
            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
        }
Example #17
0
        public BakeryOvenRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <BakeryOvenItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <BrickItem>(typeof(StoneworkingEfficiencySkill), 30, StoneworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <IronIngotItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(20, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(BakeryOvenRecipe), Item.Get <BakeryOvenItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <BakeryOvenItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Bakery Oven", typeof(BakeryOvenRecipe));
            CraftingComponent.AddRecipe(typeof(MasonryTableObject), this);
        }
        public BookshelfRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <BookshelfItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <LumberItem>(typeof(LumberWoodworkingEfficiencySkill), 20, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <PaperItem>(typeof(LumberWoodworkingEfficiencySkill), 100, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(1, LumberWoodworkingSpeedSkill.MultiplicativeStrategy, typeof(LumberWoodworkingSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(BookshelfRecipe), Item.Get <BookshelfItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <BookshelfItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize(Localizer.DoStr("Bookshelf"), typeof(BookshelfRecipe));
            CraftingComponent.AddRecipe(typeof(SawmillObject), this);
        }
        public StoveRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <StoveItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <SteelPlateItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <RivetItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(20, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(StoveRecipe), Item.Get <StoveItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <StoveItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Stove", typeof(StoveRecipe));
            CraftingComponent.AddRecipe(typeof(ElectricMachinistTableObject), this);
        }
Example #20
0
        public WorkbenchRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <WorkbenchItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <LogItem>(typeof(BasicCraftingEfficiencySkill), 30, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <StoneItem>(typeof(BasicCraftingEfficiencySkill), 20, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(5, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(WorkbenchRecipe), Item.Get <WorkbenchItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <WorkbenchItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Workbench", typeof(WorkbenchRecipe));
            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
        }
Example #21
0
        public MasonryTableRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <MasonryTableItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <StoneItem>(typeof(StoneworkingEfficiencySkill), 40, StoneworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <LogItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(1, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(MasonryTableRecipe), Item.Get <MasonryTableItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <MasonryTableItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Masonry Table", typeof(MasonryTableRecipe));
            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
        }
Example #22
0
        public LargeHangingHewnLogSignRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <LargeHangingHewnLogSignItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <HewnLogItem>(typeof(WoodworkingEfficiencySkill), 25, WoodworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <NailsItem>(typeof(WoodworkingEfficiencySkill), 8, WoodworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(10, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(LargeHangingHewnLogSignRecipe), Item.Get <LargeHangingHewnLogSignItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <LargeHangingHewnLogSignItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Large Hanging Hewn Log Sign", typeof(LargeHangingHewnLogSignRecipe));
            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
        }
Example #23
0
        public FishTrapRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <FishTrapItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <LogItem>(typeof(FishingSkill), 20, FishingSkill.MultiplicativeStrategy),
                new CraftingElement <RopeItem>(typeof(FishingSkill), 4, FishingSkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(10, FishingSkill.MultiplicativeStrategy, typeof(FishingSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(FishTrapRecipe), Item.Get <FishTrapItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <FishTrapItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Fish Trap", typeof(FishTrapRecipe));
            CraftingComponent.AddRecipe(typeof(FisheryObject), this);
        }
Example #24
0
        public WolfTrapRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <WolfTrapItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <RawMeatItem>(typeof(WoodworkingSkill), 15, WoodworkingSkill.MultiplicativeStrategy),                    //requires Raw Meat         to make
                new CraftingElement <LumberItem>(typeof(WoodworkingEfficiencySkill), 20, WoodworkingEfficiencySkill.MultiplicativeStrategy), //requires Lumber           to make
            };
            SkillModifiedValue value = new SkillModifiedValue(40, WoodworkingSkill.MultiplicativeStrategy, typeof(WoodworkingSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(WolfTrapRecipe), Item.Get <WolfTrapItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <WolfTrapItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize(Localizer.DoStr("Wolf Trap"), typeof(WolfTrapRecipe));
            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
        }
Example #25
0
        public PlanterPotRoundRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <PlanterPotRoundItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <StoneItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <PulpFillerItem>(typeof(StoneworkingEfficiencySkill), 5, StoneworkingEfficiencySkill.MultiplicativeStrategy)
            };
            SkillModifiedValue value = new SkillModifiedValue(5, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(PlanterPotRoundRecipe), Item.Get <PlanterPotRoundItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <PlanterPotRoundItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Planter Pot Round", typeof(PlanterPotRoundRecipe));
            CraftingComponent.AddRecipe(typeof(KilnObject), this);
        }
Example #26
0
        public TallowLampRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <TallowLampItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <SandItem>(typeof(StoneworkingEfficiencySkill), 4, StoneworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <TallowItem>(typeof(StoneworkingEfficiencySkill), 2, StoneworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(2, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(TallowLampRecipe), Item.Get <TallowLampItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <TallowLampItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize(Localizer.DoStr("Tallow Lamp"), typeof(TallowLampRecipe));
            CraftingComponent.AddRecipe(typeof(KilnObject), this);
        }
Example #27
0
        public TreasuryRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <TreasuryItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <HingeItem>(typeof(MetalworkingEfficiencySkill), 10, MetalworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <SteelItem>(typeof(MetalworkingEfficiencySkill), 30, MetalworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <GoldIngotItem>(typeof(MetalworkingEfficiencySkill), 10, MetalworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(60, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(TreasuryRecipe), Item.Get <TreasuryItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <TreasuryItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Treasury", typeof(TreasuryRecipe));
            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
        }
Example #28
0
        public ConveyorReceiverRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <ConveyorReceiverItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <IronIngotItem>(typeof(MechanicsAssemblyEfficiencySkill), 10, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <GearboxItem>(typeof(MechanicsAssemblyEfficiencySkill), 4, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <PistonItem>(typeof(MechanicsAssemblyEfficiencySkill), 2, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(1, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.DoStr("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(ConveyorReceiverRecipe), Item.Get <ConveyorReceiverItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <ConveyorReceiverItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Conveyor Exit Point", typeof(ConveyorReceiverRecipe));
            CraftingComponent.AddRecipe(typeof(AssemblyLineObject), this);
        }
Example #29
0
        public ElectricWallLampRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <ElectricWallLampItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <SteelItem>(typeof(ElectronicEngineeringEfficiencySkill), 6, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <CopperWiringItem>(typeof(ElectronicEngineeringEfficiencySkill), 10, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <GlassItem>(typeof(ElectronicEngineeringEfficiencySkill), 6, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(1, ElectronicEngineeringSpeedSkill.MultiplicativeStrategy, typeof(ElectronicEngineeringSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(ElectricWallLampRecipe), Item.Get <ElectricWallLampItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <ElectricWallLampItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Electric Wall Lamp", typeof(ElectricWallLampRecipe));
            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
        }
Example #30
0
        public TallowWallLampRecipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement <TallowWallLampItem>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                new CraftingElement <IronIngotItem>(typeof(MetalworkingEfficiencySkill), 5, MetalworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <TallowItem>(typeof(MetalworkingEfficiencySkill), 2, MetalworkingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement <OilItem>(typeof(MetalworkingEfficiencySkill), 5, MetalworkingEfficiencySkill.MultiplicativeStrategy),
            };
            SkillModifiedValue value = new SkillModifiedValue(1, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));

            SkillModifiedValueManager.AddBenefitForObject(typeof(TallowWallLampRecipe), Item.Get <TallowWallLampItem>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get <TallowWallLampItem>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Tallow Wall Lamp", typeof(TallowWallLampRecipe));
            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
        }