namespace Eco.Mods.TechTree
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using Eco.Gameplay.Blocks;
    using Eco.Gameplay.Components;
    using Eco.Gameplay.Components.Auth;
    using Eco.Gameplay.DynamicValues;
    using Eco.Gameplay.Economy;
    using Eco.Gameplay.Housing;
    using Eco.Gameplay.Interactions;
    using Eco.Gameplay.Items;
    using Eco.Gameplay.Minimap;
    using Eco.Gameplay.Objects;
    using Eco.Gameplay.Players;
    using Eco.Gameplay.Property;
    using Eco.Gameplay.Skills;
    using Eco.Gameplay.Systems.TextLinks;
    using Eco.Gameplay.Pipes.LiquidComponents;
    using Eco.Gameplay.Pipes.Gases;
    using Eco.Gameplay.Systems.Tooltip;
    using Eco.Shared;
    using Eco.Shared.Math;
	using Eco.Shared.Localization;
    using Eco.Shared.Serialization;
    using Eco.Shared.Utils;
    using Eco.Shared.View;
    using Eco.Shared.Items;
    using Eco.Gameplay.Pipes;
    using Eco.World.Blocks;
    

	
		
	//Red Flower Pot ====================================================	
	
	
	
    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerRed01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Red Flower Pot"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerRed01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerRed01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerRed01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerRed01Item : WorldObjectItem<Arashi_Plants_FlowerRed01Object>
    {
        public override string FriendlyName { get { return "Red Flower Pot"; } } 
        public override string Description { get { return""; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerRed01Recipe : Recipe
    {
        public Arashi_Plants_FlowerRed01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerRed01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerRed01Recipe), Item.Get<Arashi_Plants_FlowerRed01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerRed01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Red Flower Pot", typeof(Arashi_Plants_FlowerRed01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
		
	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerRed02Object : WorldObject
    {	
        public override string FriendlyName { get { return "Red Flower Pot 02"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerRed02Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerRed02Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerRed02Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerRed02Item : WorldObjectItem<Arashi_Plants_FlowerRed02Object>
    {
        public override string FriendlyName { get { return "Red Flower Pot 02"; } } 
        public override string Description { get { return" "; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerRed02Recipe : Recipe
    {
        public Arashi_Plants_FlowerRed02Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerRed02Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerRed02Recipe), Item.Get<Arashi_Plants_FlowerRed02Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerRed02Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Red Flower Pot 02", typeof(Arashi_Plants_FlowerRed02Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	


//Yellow Flower Pot ====================================================	
		
	
		
    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerYellow01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Yellow Flower Pot"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerYellow01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerYellow01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerYellow01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerYellow01Item : WorldObjectItem<Arashi_Plants_FlowerYellow01Object>
    {
        public override string FriendlyName { get { return "Yellow Flower Pot"; } } 
        public override string Description { get { return" Yellow Flower Pot."; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerYellow01Recipe : Recipe
    {
        public Arashi_Plants_FlowerYellow01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerYellow01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				 				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerYellow01Recipe), Item.Get<Arashi_Plants_FlowerYellow01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerYellow01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Yellow Flower Pot", typeof(Arashi_Plants_FlowerYellow01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerYellow02Object : WorldObject
    {	
        public override string FriendlyName { get { return "Yellow Flower Pot 02"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerYellow02Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerYellow02Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerYellow02Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerYellow02Item : WorldObjectItem<Arashi_Plants_FlowerYellow02Object>
    {
        public override string FriendlyName { get { return "Yellow Flower Pot 02"; } } 
        public override string Description { get { return" "; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerYellow02Recipe : Recipe
    {
        public Arashi_Plants_FlowerYellow02Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerYellow02Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerYellow02Recipe), Item.Get<Arashi_Plants_FlowerYellow02Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerYellow02Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Yellow Flower Pot 02", typeof(Arashi_Plants_FlowerYellow02Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	
		
//Purple Flower Pot ====================================================			
		
    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerPurple01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Purple Flower Pot"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerPurple01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerPurple01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerPurple01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerPurple01Item : WorldObjectItem<Arashi_Plants_FlowerPurple01Object>
    {
        public override string FriendlyName { get { return "Purple Flower Pot"; } } 
        public override string Description { get { return" Purple Flower Pot."; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerPurple01Recipe : Recipe
    {
        public Arashi_Plants_FlowerPurple01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerPurple01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				 				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerPurple01Recipe), Item.Get<Arashi_Plants_FlowerPurple01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerPurple01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Purple Flower Pot", typeof(Arashi_Plants_FlowerPurple01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerPurple02Object : WorldObject
    {	
        public override string FriendlyName { get { return "Purple Flower Pot 02"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerPurple02Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerPurple02Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerPurple02Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerPurple02Item : WorldObjectItem<Arashi_Plants_FlowerPurple02Object>
    {
        public override string FriendlyName { get { return "Purple Flower Pot 02"; } } 
        public override string Description { get { return" Flower Pot."; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerPurple02Recipe : Recipe
    {
        public Arashi_Plants_FlowerPurple02Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerPurple02Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerPurple02Recipe), Item.Get<Arashi_Plants_FlowerPurple02Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerPurple02Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Purple Flower Pot 02", typeof(Arashi_Plants_FlowerPurple02Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	
//Pink Flower Pot ====================================================	
		
    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerPink01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Pink Flower Pot"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerPink01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerPink01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerPink01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerPink01Item : WorldObjectItem<Arashi_Plants_FlowerPink01Object>
    {
        public override string FriendlyName { get { return "Pink Flower Pot"; } } 
        public override string Description { get { return" Pink Flower Pot."; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerPink01Recipe : Recipe
    {
        public Arashi_Plants_FlowerPink01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerPink01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				 				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerPink01Recipe), Item.Get<Arashi_Plants_FlowerPink01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerPink01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Pink Flower Pot", typeof(Arashi_Plants_FlowerPink01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
		
//White Flower Pot ====================================================	
		
			
    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerWhite01Object : WorldObject
    {	
        public override string FriendlyName { get { return "White Flower Pot"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerWhite01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerWhite01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerWhite01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerWhite01Item : WorldObjectItem<Arashi_Plants_FlowerWhite01Object>
    {
        public override string FriendlyName { get { return "White Flower Pot"; } } 
        public override string Description { get { return" White Flower Pot."; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerWhite01Recipe : Recipe
    {
        public Arashi_Plants_FlowerWhite01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerWhite01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				 				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
                new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerWhite01Recipe), Item.Get<Arashi_Plants_FlowerWhite01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerWhite01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("White Flower Pot", typeof(Arashi_Plants_FlowerWhite01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerWhite02Object : WorldObject
    {	
        public override string FriendlyName { get { return "White Flower Pot 02"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerWhite02Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerWhite02Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerWhite02Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerWhite02Item : WorldObjectItem<Arashi_Plants_FlowerWhite02Object>
    {
        public override string FriendlyName { get { return "White Flower Pot 02"; } } 
        public override string Description { get { return"  Flower Pot."; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerWhite02Recipe : Recipe
    {
        public Arashi_Plants_FlowerWhite02Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerWhite02Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerWhite02Recipe), Item.Get<Arashi_Plants_FlowerWhite02Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerWhite02Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("White Flower Pot 02", typeof(Arashi_Plants_FlowerWhite02Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	
//Mixed Flower Pot ====================================================		
	
    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerMix01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Mixed Flower Pot 02"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerMix01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerMix01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerMix01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerMix01Item : WorldObjectItem<Arashi_Plants_FlowerMix01Object>
    {
        public override string FriendlyName { get { return "Mixed Flower Pot 02"; } } 
        public override string Description { get { return" Flower Pot."; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerMix01Recipe : Recipe
    {
        public Arashi_Plants_FlowerMix01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerMix01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerMix01Recipe), Item.Get<Arashi_Plants_FlowerMix01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerMix01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Mixed Flower Pot 02", typeof(Arashi_Plants_FlowerMix01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
		
	
	
	//Bamboo ====================================================		
	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_Bamboo01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Bamboo Pot"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_Bamboo01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_Bamboo01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_Bamboo01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,1,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_Bamboo01Item : WorldObjectItem<Arashi_Plants_Bamboo01Object>
    {
        public override string FriendlyName { get { return "Bamboo Pot"; } } 
        public override string Description { get { return"  "; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_Bamboo01Recipe : Recipe
    {
        public Arashi_Plants_Bamboo01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_Bamboo01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_Bamboo01Recipe), Item.Get<Arashi_Plants_Bamboo01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_Bamboo01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Bamboo Pot", typeof(Arashi_Plants_Bamboo01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	
	
	
	
//Bonsai ====================================================		
	
	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_BonsaiTree01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Bonsai Tree"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_BonsaiTree01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_BonsaiTree01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_BonsaiTree01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_BonsaiTree01Item : WorldObjectItem<Arashi_Plants_BonsaiTree01Object>
    {
        public override string FriendlyName { get { return "Bonsai Tree"; } } 
        public override string Description { get { return" "; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_BonsaiTree01Recipe : Recipe
    {
        public Arashi_Plants_BonsaiTree01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_BonsaiTree01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_BonsaiTree01Recipe), Item.Get<Arashi_Plants_BonsaiTree01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_BonsaiTree01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Bonsai Tree", typeof(Arashi_Plants_BonsaiTree01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	
	
	
	
//Ficus ====================================================		
	
	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_Ficus01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Ficus"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_Ficus01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_Ficus01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_Ficus01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,1,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_Ficus01Item : WorldObjectItem<Arashi_Plants_Ficus01Object>
    {
        public override string FriendlyName { get { return "Ficus"; } } 
        public override string Description { get { return" "; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_Ficus01Recipe : Recipe
    {
        public Arashi_Plants_Ficus01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_Ficus01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_Ficus01Recipe), Item.Get<Arashi_Plants_Ficus01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_Ficus01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Ficus", typeof(Arashi_Plants_Ficus01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	
//Maceta ====================================================	

    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_Maceta01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Maceta Pot"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_Maceta01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_Maceta01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_Maceta01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_Maceta01Item : WorldObjectItem<Arashi_Plants_Maceta01Object>
    {
        public override string FriendlyName { get { return "Maceta Pot"; } } 
        public override string Description { get { return" "; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_Maceta01Recipe : Recipe
    {
        public Arashi_Plants_Maceta01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_Maceta01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_Maceta01Recipe), Item.Get<Arashi_Plants_Maceta01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_Maceta01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Maceta Pot", typeof(Arashi_Plants_Maceta01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	

	

//Tropical Shrub ====================================================	


	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_TropicalShrub01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Tropical Shrub"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_TropicalShrub01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_TropicalShrub01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_TropicalShrub01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_TropicalShrub01Item : WorldObjectItem<Arashi_Plants_TropicalShrub01Object>
    {
        public override string FriendlyName { get { return "Tropical Shrub"; } } 
        public override string Description { get { return" "; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_TropicalShrub01Recipe : Recipe
    {
        public Arashi_Plants_TropicalShrub01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_TropicalShrub01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_TropicalShrub01Recipe), Item.Get<Arashi_Plants_TropicalShrub01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_TropicalShrub01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Tropical Shrub", typeof(Arashi_Plants_TropicalShrub01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	

    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_TropicalShrub02Object : WorldObject
    {	
        public override string FriendlyName { get { return "Tropical Shrub 02"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_TropicalShrub02Item.HousingVal);                                
        }
		
		 static Arashi_Plants_TropicalShrub02Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_TropicalShrub02Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_TropicalShrub02Item : WorldObjectItem<Arashi_Plants_TropicalShrub02Object>
    {
        public override string FriendlyName { get { return "Tropical Shrub 02"; } } 
        public override string Description { get { return" "; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_TropicalShrub02Recipe : Recipe
    {
        public Arashi_Plants_TropicalShrub02Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_TropicalShrub02Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_TropicalShrub02Recipe), Item.Get<Arashi_Plants_TropicalShrub02Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_TropicalShrub02Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Tropical Shrub 02", typeof(Arashi_Plants_TropicalShrub02Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
		
		    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_FlowerStand01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Flower Pot Stand"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_FlowerStand01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_FlowerStand01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_FlowerStand01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_FlowerStand01Item : WorldObjectItem<Arashi_Plants_FlowerStand01Object>
    {
        public override string FriendlyName { get { return "Flower Pot Stand"; } } 
        public override string Description { get { return" Flower Pot Stand."; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 1,
                                                    TypeForRoomLimit = "FlowerStand",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_FlowerStand01Recipe : Recipe
    {
        public Arashi_Plants_FlowerStand01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_FlowerStand01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),

            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_FlowerStand01Recipe), Item.Get<Arashi_Plants_FlowerStand01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_FlowerStand01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Flower Pot Stand", typeof(Arashi_Plants_FlowerStand01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
		    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_TropicalShrub03Object : WorldObject
    {	
        public override string FriendlyName { get { return "Tropical Shrub 03"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_TropicalShrub03Item.HousingVal);                                
        }
		
		 static Arashi_Plants_TropicalShrub03Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_TropicalShrub03Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_TropicalShrub03Item : WorldObjectItem<Arashi_Plants_TropicalShrub03Object>
    {
        public override string FriendlyName { get { return "Tropical Shrub 03"; } } 
        public override string Description { get { return" "; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_TropicalShrub03Recipe : Recipe
    {
        public Arashi_Plants_TropicalShrub03Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_TropicalShrub03Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_TropicalShrub03Recipe), Item.Get<Arashi_Plants_TropicalShrub03Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_TropicalShrub03Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Tropical Shrub 03", typeof(Arashi_Plants_TropicalShrub03Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_TropicalShrub04Object : WorldObject
    {	
        public override string FriendlyName { get { return "Tropical Shrub 04"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_TropicalShrub04Item.HousingVal);                                
        }
		
		 static Arashi_Plants_TropicalShrub04Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_TropicalShrub04Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_TropicalShrub04Item : WorldObjectItem<Arashi_Plants_TropicalShrub04Object>
    {
        public override string FriendlyName { get { return "Tropical Shrub 04"; } } 
        public override string Description { get { return""; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_TropicalShrub04Recipe : Recipe
    {
        public Arashi_Plants_TropicalShrub04Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_TropicalShrub04Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_TropicalShrub04Recipe), Item.Get<Arashi_Plants_TropicalShrub04Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_TropicalShrub04Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Tropical Shrub 04", typeof(Arashi_Plants_TropicalShrub04Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_TropicalShrub05Object : WorldObject
    {	
        public override string FriendlyName { get { return "Tropical Shrub 05"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_TropicalShrub05Item.HousingVal);                                
        }
		
		 static Arashi_Plants_TropicalShrub05Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_TropicalShrub05Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_TropicalShrub05Item : WorldObjectItem<Arashi_Plants_TropicalShrub05Object>
    {
        public override string FriendlyName { get { return "Tropical Shrub 05"; } } 
        public override string Description { get { return""; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Plants",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_TropicalShrub05Recipe : Recipe
    {
        public Arashi_Plants_TropicalShrub05Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_TropicalShrub05Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
                 new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 8, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_TropicalShrub05Recipe), Item.Get<Arashi_Plants_TropicalShrub05Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_TropicalShrub05Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Tropical Shrub 05", typeof(Arashi_Plants_TropicalShrub05Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	
	
	
	
//Hedge ====================================================	

    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_HedgeArch01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Hedge Arch"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_HedgeArch01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_HedgeArch01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_HedgeArch01Object), new BlockOccupancy(new Vector3i(0,0,1), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,0,-1), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,1,0), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,1,1), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,1,-1), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,2,0), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,2,1), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,2,-1), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_HedgeArch01Item : WorldObjectItem<Arashi_Plants_HedgeArch01Object>
    {
        public override string FriendlyName { get { return "Hedge Arch"; } } 
        public override string Description { get { return""; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Hedge",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }


    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_HedgeArch01Recipe : Recipe
    {
        public Arashi_Plants_HedgeArch01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_HedgeArch01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 20, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 20, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 15, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_HedgeArch01Recipe), Item.Get<Arashi_Plants_HedgeArch01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_HedgeArch01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Hedge Arch", typeof(Arashi_Plants_HedgeArch01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
	
	
	
	
	
	
	    [Serialized]    
    [RequireComponent(typeof(PropertyAuthComponent))]
    [RequireComponent(typeof(MinimapComponent))]                
    [RequireComponent(typeof(HousingComponent))]                  
    [RequireComponent(typeof(SolidGroundComponent))]                      
    public partial class Arashi_Plants_HedgeLong01Object : WorldObject
    {	
        public override string FriendlyName { get { return "Hedge Long"; } } 

		
        protected override void Initialize()
        {
            this.GetComponent<MinimapComponent>().Initialize("Housing");     
            this.GetComponent<HousingComponent>().Set(Arashi_Plants_HedgeLong01Item.HousingVal);                                
        }
		
		 static Arashi_Plants_HedgeLong01Object()
    {
        AddOccupancyList(typeof(Arashi_Plants_HedgeLong01Object), new BlockOccupancy(new Vector3i(0,0,0), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,0,1), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,0,-1), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,1,0), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,1,1), typeof(WorldObjectBlock)), new BlockOccupancy(new Vector3i(0,1,-1), typeof(WorldObjectBlock)));
    }
		
        public override void Destroy()
        {
            base.Destroy();
        }
    }   
	 
    [Serialized]
    public partial class Arashi_Plants_HedgeLong01Item : WorldObjectItem<Arashi_Plants_HedgeLong01Object>
    {
        public override string FriendlyName { get { return "Hedge Long"; } } 
        public override string Description { get { return""; } }

        
        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
                                                {
                                                    Category = "General",
                                                    Val = 2,
                                                    TypeForRoomLimit = "Hedge",
                                                    DiminishingReturnPercent = 0.75f
                                                };}}       
    }
 

    [RequiresSkill(typeof(FarmingSkill), 1)]
    public partial class Arashi_Plants_HedgeLong01Recipe : Recipe
    {
        public Arashi_Plants_HedgeLong01Recipe()
        {
            this.Products = new CraftingElement[]
            {
                new CraftingElement<Arashi_Plants_HedgeLong01Item>(),
            };

            this.Ingredients = new CraftingElement[]
            {
				new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 20, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
				new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 20, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
			   new CraftingElement<WoodPulpItem>(typeof(BasicCraftingEfficiencySkill), 15, BasicCraftingEfficiencySkill.MultiplicativeStrategy), 
            };
            SkillModifiedValue value = new SkillModifiedValue(10, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
            SkillModifiedValueManager.AddBenefitForObject(typeof(Arashi_Plants_HedgeLong01Recipe), Item.Get<Arashi_Plants_HedgeLong01Item>().UILink(), value);
            SkillModifiedValueManager.AddSkillBenefit(Item.Get<Arashi_Plants_HedgeLong01Item>().UILink(), value);
            this.CraftMinutes = value;
            this.Initialize("Hedge Long", typeof(Arashi_Plants_HedgeLong01Recipe));
            CraftingComponent.AddRecipe(typeof(FarmersTableObject), this);
        }
    }
	
	
	
		

	
	
		

	
	
	
	
	
	
	
	

	
	
}