Gitlab to Gitea Migration

AutoGen/WorldObject/Anvil.cs

@@ -0,0 +1,106 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class AnvilObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Anvil"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<HousingComponent>().Set(AnvilItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class AnvilItem : WorldObjectItem<AnvilObject>
+    {
+        public override string FriendlyName { get { return "Anvil"; } } 
+        public override string Description  { get { return  "A solid shaped piece of metal used to hammer ingots into tools and other useful things."; } }
+
+        static AnvilItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 1)]
+    public partial class AnvilRecipe : Recipe
+    {
+        public AnvilRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<AnvilItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<MortaredStoneItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<HewnLogItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+            };
+            SkillModifiedValue value = new SkillModifiedValue(20, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(AnvilRecipe), Item.Get<AnvilItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<AnvilItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Anvil", typeof(AnvilRecipe));
+            CraftingComponent.AddRecipe(typeof(BloomeryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/BakeryOven.cs

@@ -0,0 +1,125 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(45)]                              
+    [RequireRoomMaterialTier(2, 32)]        
+    public partial class BakeryOvenObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Bakery Oven"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Cooking");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(10);                    
+            this.GetComponent<HousingComponent>().Set(BakeryOvenItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class BakeryOvenItem : WorldObjectItem<BakeryOvenObject>
+    {
+        public override string FriendlyName { get { return "Bakery Oven"; } } 
+        public override string Description  { get { return  "A solidly built brick oven useful for baking all manner of treats."; } }
+
+        static BakeryOvenItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Kitchen",
+                                                    Val = 3,                                   
+                                                    TypeForRoomLimit = "Baking", 
+                                                    DiminishingReturnPercent = 0.3f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(StoneworkingSkill), 2)]
+    public partial class BakeryOvenRecipe : Recipe
+    {
+        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),   
+                new CraftingElement<BoardItem>(typeof(StoneworkingEfficiencySkill), 20, 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);
+        }
+    }
+}

AutoGen/WorldObject/BlastFurnace.cs

@@ -0,0 +1,134 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(PipeComponent))]                    
+    [RequireComponent(typeof(AttachmentComponent))]                            
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class BlastFurnaceObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Blast Furnace"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(HewnLogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(50);                    
+            this.GetComponent<HousingComponent>().Set(BlastFurnaceItem.HousingVal);                                
+
+
+            var tankList = new List<LiquidTank>();
+            
+            tankList.Add(new LiquidProducer("Chimney", typeof(SmogItem), 100,
+                    null,                                                                
+                    this.Occupancy.Find(x => x.Name == "ChimneyOut"),   
+                        (float)(0.25f * SmogItem.SmogItemsPerCO2PPM) / TimeUtil.SecondsPerHour)); 
+            
+            
+            
+            this.GetComponent<PipeComponent>().Initialize(tankList);
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class BlastFurnaceItem : WorldObjectItem<BlastFurnaceObject>
+    {
+        public override string FriendlyName { get { return "Blast Furnace"; } } 
+        public override string Description  { get { return  "A superior replacement for the bloomery that can produce steel."; } }
+
+        static BlastFurnaceItem()
+        {
+            
+            
+            
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 4)]
+    public partial class BlastFurnaceRecipe : Recipe
+    {
+        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), 25, 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);
+        }
+    }
+}

AutoGen/WorldObject/Bloomery.cs

@@ -0,0 +1,121 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class BloomeryObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Bloomery"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(HewnLogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(10);                    
+            this.GetComponent<HousingComponent>().Set(BloomeryItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class BloomeryItem : WorldObjectItem<BloomeryObject>
+    {
+        public override string FriendlyName { get { return "Bloomery"; } } 
+        public override string Description  { get { return  "A chimney-shaped furnace for smelting ores."; } }
+
+        static BloomeryItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(StoneworkingSkill), 2)]
+    public partial class BloomeryRecipe : Recipe
+    {
+        public BloomeryRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BloomeryItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(StoneworkingEfficiencySkill), 20, StoneworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BrickItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(StoneworkingEfficiencySkill), 50, StoneworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<SandItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(10, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(BloomeryRecipe), Item.Get<BloomeryItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<BloomeryItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Bloomery", typeof(BloomeryRecipe));
+            CraftingComponent.AddRecipe(typeof(KilnObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Bookshelf.cs

@@ -0,0 +1,111 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(PublicStorageComponent))]                
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class BookshelfObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Bookshelf"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Misc");                                 
+            this.GetComponent<HousingComponent>().Set(BookshelfItem.HousingVal);                                
+
+            var storage = this.GetComponent<PublicStorageComponent>();
+            storage.Initialize(8);
+            storage.Storage.AddRestriction(new NotCarriedRestriction()); // can't store block or large items
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class BookshelfItem : WorldObjectItem<BookshelfObject>
+    {
+        public override string FriendlyName { get { return "Bookshelf"; } } 
+        public override string Description  { get { return  "A place to store knowledge and information; leads to the town hall."; } }
+
+        static BookshelfItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Shelves", 
+                                                    DiminishingReturnPercent = 0.7f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(LumberWoodworkingSkill), 2)]
+    public partial class BookshelfRecipe : Recipe
+    {
+        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),   
+                new CraftingElement<IronIngotItem>(typeof(LumberWoodworkingEfficiencySkill), 5, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(1, LumberWoodworkingSpeedSkill.MultiplicativeStrategy, typeof(LumberWoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(BookshelfRecipe), Item.Get<BookshelfItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<BookshelfItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Bookshelf", typeof(BookshelfRecipe));
+            CraftingComponent.AddRecipe(typeof(SawmillObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Brazier.cs

@@ -0,0 +1,120 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class BrazierObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Brazier"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(HewnLogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(1);                    
+            this.GetComponent<HousingComponent>().Set(BrazierItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class BrazierItem : WorldObjectItem<BrazierObject>
+    {
+        public override string FriendlyName { get { return "Brazier"; } } 
+        public override string Description  { get { return  "A metal stand which can hold burning fuel to provide light."; } }
+
+        static BrazierItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 4)]
+    public partial class BrazierRecipe : Recipe
+    {
+        public BrazierRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BrazierItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(MetalworkingEfficiencySkill), 10, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<MortaredStoneItem>(typeof(MetalworkingEfficiencySkill), 5, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(1, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(BrazierRecipe), Item.Get<BrazierItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<BrazierItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Brazier", typeof(BrazierRecipe));
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/WorldObject/ButcheryTable.cs

@@ -0,0 +1,112 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(1, 18)]        
+    public partial class ButcheryTableObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Butchery Table"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Cooking");                                 
+            this.GetComponent<HousingComponent>().Set(ButcheryTableItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class ButcheryTableItem : WorldObjectItem<ButcheryTableObject>
+    {
+        public override string FriendlyName { get { return "Butchery Table"; } } 
+        public override string Description  { get { return  "A block and cleaver to process raw meat into fancier dishes."; } }
+
+        static ButcheryTableItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Kitchen",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Cooking", 
+                                                    DiminishingReturnPercent = 0.3f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 3)]
+    public partial class ButcheryTableRecipe : Recipe
+    {
+        public ButcheryTableRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ButcheryTableItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BoardItem>(typeof(WoodworkingEfficiencySkill), 20, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<LogItem>(typeof(WoodworkingEfficiencySkill), 20, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<MortaredStoneItem>(typeof(WoodworkingEfficiencySkill), 20, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(ButcheryTableRecipe), Item.Get<ButcheryTableItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<ButcheryTableItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Butchery Table", typeof(ButcheryTableRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Campfire.cs

@@ -0,0 +1,111 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class CampfireObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Campfire"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(HewnLogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Cooking");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(10);                    
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class CampfireItem : WorldObjectItem<CampfireObject>
+    {
+        public override string FriendlyName { get { return "Campfire"; } } 
+        public override string Description  { get { return  "Cook like a caveman on an uneven fire."; } }
+
+        static CampfireItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(BasicCraftingSkill), 0)]
+    public partial class CampfireRecipe : Recipe
+    {
+        public CampfireRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CampfireItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(BasicCraftingEfficiencySkill), 5, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(1, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(CampfireRecipe), Item.Get<CampfireItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<CampfireItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Campfire", typeof(CampfireRecipe));
+            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
+        }
+    }
+}

AutoGen/WorldObject/CandleStand.cs

@@ -0,0 +1,116 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class CandleStandObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Candle Stand"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(TallowItem),
+            typeof(OilItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(1);                    
+            this.GetComponent<HousingComponent>().Set(CandleStandItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class CandleStandItem : WorldObjectItem<CandleStandObject>
+    {
+        public override string FriendlyName { get { return "Candle Stand"; } } 
+        public override string Description  { get { return  "A fancy candelabra for providing small amounts of light."; } }
+
+        static CandleStandItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 1)]
+    public partial class CandleStandRecipe : Recipe
+    {
+        public CandleStandRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CandleStandItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(MetalworkingEfficiencySkill), 5, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ClothItem>(typeof(MetalworkingEfficiencySkill), 5, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<TallowItem>(typeof(MetalworkingEfficiencySkill), 2, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(1, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(CandleStandRecipe), Item.Get<CandleStandItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<CandleStandItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Candle Stand", typeof(CandleStandRecipe));
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/WorldObject/CarpentryTable.cs

@@ -0,0 +1,101 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    public partial class CarpentryTableObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Carpentry Table"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class CarpentryTableItem : WorldObjectItem<CarpentryTableObject>
+    {
+        public override string FriendlyName { get { return "Carpentry Table"; } } 
+        public override string Description  { get { return  "A table for basic wooden crafts for home improvement and progress."; } }
+
+        static CarpentryTableItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 0)]
+    public partial class CarpentryTableRecipe : Recipe
+    {
+        public CarpentryTableRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CarpentryTableItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<HewnLogItem>(typeof(WoodworkingEfficiencySkill), 20, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<StoneItem>(typeof(WoodworkingEfficiencySkill), 20, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(1, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(CarpentryTableRecipe), Item.Get<CarpentryTableItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<CarpentryTableItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Carpentry Table", typeof(CarpentryTableRecipe));
+            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
+        }
+    }
+}

AutoGen/WorldObject/CastIronStove.cs

@@ -0,0 +1,127 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(45)]                              
+    [RequireRoomMaterialTier(2, 32)]        
+    public partial class CastIronStoveObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Cast Iron Stove"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+			typeof(HewnLogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Cooking");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(10);                    
+            this.GetComponent<HousingComponent>().Set(CastIronStoveItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class CastIronStoveItem : WorldObjectItem<CastIronStoveObject>
+    {
+        public override string FriendlyName { get { return "Cast Iron Stove"; } } 
+        public override string Description  { get { return  "The perfect stove for the fledgling chef."; } }
+
+        static CastIronStoveItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Kitchen",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Cooking", 
+                                                    DiminishingReturnPercent = 0.3f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 1)]
+    public partial class CastIronStoveRecipe : Recipe
+    {
+        public CastIronStoveRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CastIronStoveItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<MortaredStoneItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(MetalworkingEfficiencySkill), 20, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+            };
+            SkillModifiedValue value = new SkillModifiedValue(15, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(CastIronStoveRecipe), Item.Get<CastIronStoveItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<CastIronStoveItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Cast Iron Stove", typeof(CastIronStoveRecipe));
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/WorldObject/CeilingCandle.cs

@@ -0,0 +1,116 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class CeilingCandleObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Ceiling Candle"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(TallowItem),
+            typeof(OilItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(1);                    
+            this.GetComponent<HousingComponent>().Set(CeilingCandleItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class CeilingCandleItem : WorldObjectItem<CeilingCandleObject>
+    {
+        public override string FriendlyName { get { return "Ceiling Candle"; } } 
+        public override string Description  { get { return  "A fancy hanging candelabra."; } }
+
+        static CeilingCandleItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 3)]
+    public partial class CeilingCandleRecipe : Recipe
+    {
+        public CeilingCandleRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CeilingCandleItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(MetalworkingEfficiencySkill), 5, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ClothItem>(typeof(MetalworkingEfficiencySkill), 5, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<TallowItem>(typeof(MetalworkingEfficiencySkill), 2, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(1, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(CeilingCandleRecipe), Item.Get<CeilingCandleItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<CeilingCandleItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Ceiling Candle", typeof(CeilingCandleRecipe));
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/WorldObject/CementKiln.cs

@@ -0,0 +1,139 @@
+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;
+    
+    [Serialized]
+    [RequireComponent(typeof(PipeComponent))]
+    [RequireComponent(typeof(AttachmentComponent))]
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]
+    [RequireComponent(typeof(LinkComponent))]
+    [RequireComponent(typeof(CraftingComponent))]
+    [RequireComponent(typeof(FuelSupplyComponent))]
+    [RequireComponent(typeof(FuelConsumptionComponent))]
+    [RequireComponent(typeof(HousingComponent))]
+    [RequireComponent(typeof(SolidGroundComponent))]
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(45)]
+    [RequireRoomMaterialTier(2, 32)]
+    public partial class CementKilnObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Cement Kiln"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(50);                    
+            this.GetComponent<HousingComponent>().Set(CementKilnItem.HousingVal);                                
+
+
+            var tankList = new List<LiquidTank>();
+            
+            tankList.Add(new LiquidProducer("Chimney", typeof(SmogItem), 100,
+                    null,                                                                
+                    this.Occupancy.Find(x => x.Name == "ChimneyOut"),   
+                        (float)(0.2f * SmogItem.SmogItemsPerCO2PPM) / TimeUtil.SecondsPerHour)); 
+            
+            
+            
+            this.GetComponent<PipeComponent>().Initialize(tankList);
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class CementKilnItem : WorldObjectItem<CementKilnObject>
+    {
+        public override string FriendlyName { get { return "Cement Kiln"; } } 
+        public override string Description  { get { return  "A rotary kiln that produces cement and concrete products."; } }
+
+        static CementKilnItem()
+        {
+            
+            
+            
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 1)]
+    public partial class CementKilnRecipe : Recipe
+    {
+        public CementKilnRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CementKilnItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<MortaredStoneItem>(typeof(MetalworkingEfficiencySkill), 50, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<IronIngotItem>(typeof(MetalworkingEfficiencySkill), 30, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<GearboxItem>(typeof(MetalworkingEfficiencySkill), 10, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<PistonItem>(typeof(MetalworkingEfficiencySkill), 5, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(240, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(CementKilnRecipe), Item.Get<CementKilnItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<CementKilnItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Cement Kiln", typeof(CementKilnRecipe));
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/WorldObject/CombustionGenerator.cs

@@ -0,0 +1,127 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerGeneratorComponent))]         
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class CombustionGeneratorObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Combustion Generator"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+            typeof(PetroleumItem),
+            typeof(GasolineItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Power");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(100);                    
+            this.GetComponent<PowerGridComponent>().Initialize(30, new ElectricPower());        
+            this.GetComponent<PowerGeneratorComponent>().Initialize(1500);                       
+            this.GetComponent<HousingComponent>().Set(CombustionGeneratorItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class CombustionGeneratorItem : WorldObjectItem<CombustionGeneratorObject>
+    {
+        public override string FriendlyName { get { return "Combustion Generator"; } } 
+        public override string Description  { get { return  "Consumes most fuels to produce energy."; } }
+
+        static CombustionGeneratorItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MechanicalEngineeringSkill), 3)]
+    public partial class CombustionGeneratorRecipe : Recipe
+    {
+        public CombustionGeneratorRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CombustionGeneratorItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(MechanicsAssemblyEfficiencySkill), 20, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<PistonItem>(typeof(MechanicsAssemblyEfficiencySkill), 5, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+				new CraftingElement<MortaredStoneItem>(typeof(MechanicsAssemblyEfficiencySkill), 10, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CombustionEngineItem>(typeof(MechanicsAssemblyEfficiencySkill), 1, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),				
+            };
+            SkillModifiedValue value = new SkillModifiedValue(30, MechanicsAssemblySpeedSkill.MultiplicativeStrategy, typeof(MechanicsAssemblySpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(CombustionGeneratorRecipe), Item.Get<CombustionGeneratorItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<CombustionGeneratorItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Combustion Generator", typeof(CombustionGeneratorRecipe));
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+}

AutoGen/WorldObject/ComputerLab.cs

@@ -0,0 +1,72 @@
+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;
+    
+
+    [Serialized]
+    public partial class ComputerLabItem : WorldObjectItem<ComputerLabObject>
+    {
+        public override string FriendlyName { get { return "Computer Lab"; } } 
+        public override string Description  { get { return  "A place where you can sit all day and play video games! Or work on expert-level research."; } }
+
+        static ComputerLabItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(IndustrialEngineeringSkill), 4)]
+    public partial class ComputerLabRecipe : Recipe
+    {
+        public ComputerLabRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ComputerLabItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(IndustrialEngineeringEfficiencySkill), 50, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CircuitItem>(typeof(IndustrialEngineeringEfficiencySkill), 30, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ConcreteItem>(typeof(IndustrialEngineeringEfficiencySkill), 40, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(260, ElectronicEngineeringSpeedSkill.MultiplicativeStrategy, typeof(ElectronicEngineeringSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(ComputerLabRecipe), Item.Get<ComputerLabItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<ComputerLabItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Computer Lab", typeof(ComputerLabRecipe));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/ConstructionPost.cs

@@ -0,0 +1,97 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class ConstructionPostObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Construction Post"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Economy");                                 
+
+
+
+            this.AddAsPOI("Marker");  
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+            this.RemoveAsPOI("Marker");  
+        }
+       
+    }
+
+    [Serialized]
+    public partial class ConstructionPostItem : WorldObjectItem<ConstructionPostObject>
+    {
+        public override string FriendlyName { get { return "Construction Post"; } } 
+        public override string Description  { get { return  "For contruction contracts."; } }
+
+        static ConstructionPostItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(BasicCraftingSkill), 1)]
+    public partial class ConstructionPostRecipe : Recipe
+    {
+        public ConstructionPostRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ConstructionPostItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(BasicCraftingEfficiencySkill), 1, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(2, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(ConstructionPostRecipe), Item.Get<ConstructionPostItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<ConstructionPostItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Construction Post", typeof(ConstructionPostRecipe));
+            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
+        }
+    }
+}

AutoGen/WorldObject/ContractBoard.cs

@@ -0,0 +1,95 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class ContractBoardObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Contract Board"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Economy");                                 
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class ContractBoardItem : WorldObjectItem<ContractBoardObject>
+    {
+        public override string FriendlyName { get { return "Contract Board"; } } 
+        public override string Description  { get { return  "A board to post contracts."; } }
+
+        static ContractBoardItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 1)]
+    public partial class ContractBoardRecipe : Recipe
+    {
+        public ContractBoardRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ContractBoardItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(WoodworkingEfficiencySkill), 20, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(15, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(ContractBoardRecipe), Item.Get<ContractBoardItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<ContractBoardItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Contract Board", typeof(ContractBoardRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Couch.cs

@@ -0,0 +1,108 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class CouchObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Couch"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Housing");                                 
+            this.GetComponent<HousingComponent>().Set(CouchItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class CouchItem : WorldObjectItem<CouchObject>
+    {
+        public override string FriendlyName { get { return "Couch"; } } 
+        public override string Description  { get { return  "A sweet couch to lounge on. Now with room for your friends!"; } }
+
+        static CouchItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Living",
+                                                    Val = 3,                                   
+                                                    TypeForRoomLimit = "Seating", 
+                                                    DiminishingReturnPercent = 0.6f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(ClothProductionSkill), 4)]
+    public partial class CouchRecipe : Recipe
+    {
+        public CouchRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CouchItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LumberItem>(typeof(ClothProductionEfficiencySkill), 10, ClothProductionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(ClothProductionEfficiencySkill), 20, ClothProductionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<RivetItem>(typeof(ClothProductionEfficiencySkill), 10, ClothProductionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ClothItem>(typeof(ClothProductionEfficiencySkill), 20, ClothProductionEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, ClothProductionSpeedSkill.MultiplicativeStrategy, typeof(ClothProductionSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(CouchRecipe), Item.Get<CouchItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<CouchItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Couch", typeof(CouchRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/CurrencyExchange.cs

@@ -0,0 +1,100 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(45)]                              
+    [RequireRoomMaterialTier(2, 32)]        
+    public partial class CurrencyExchangeObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Currency Exchange"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Economy");                                 
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class CurrencyExchangeItem : WorldObjectItem<CurrencyExchangeObject>
+    {
+        public override string FriendlyName { get { return "Currency Exchange"; } } 
+        public override string Description  { get { return  "Allows players to exchange currency."; } }
+
+        static CurrencyExchangeItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 3)]
+    public partial class CurrencyExchangeRecipe : Recipe
+    {
+        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);
+        }
+    }
+}

AutoGen/WorldObject/Door.cs

@@ -0,0 +1,96 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class DoorObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Door"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Misc");                                 
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class DoorItem : WorldObjectItem<DoorObject>
+    {
+        public override string FriendlyName { get { return "Door"; } } 
+        public override string Description  { get { return  "A sturdy wooden door. Can be locked for certain players."; } }
+
+        static DoorItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 0)]
+    public partial class DoorRecipe : Recipe
+    {
+        public DoorRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<DoorItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(WoodworkingEfficiencySkill), 6, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(DoorRecipe), Item.Get<DoorItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<DoorItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Door", typeof(DoorRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/EckoStatue.cs

@@ -0,0 +1,98 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class EckoStatueObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Ecko Statue"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<HousingComponent>().Set(EckoStatueItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class EckoStatueItem : WorldObjectItem<EckoStatueObject>
+    {
+        public override string FriendlyName { get { return "Ecko Statue"; } } 
+        public override string Description  { get { return  "A statue of a dolphin. What could it mean?"; } }
+
+        static EckoStatueItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 100,                                   
+                                                    TypeForRoomLimit = "Decoration", 
+                                                    DiminishingReturnPercent = 1.5f    
+        };}}
+    }
+
+
+    public partial class EckoStatueRecipe : Recipe
+    {
+        public EckoStatueRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<EckoStatueItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+            };
+            this.CraftMinutes = new ConstantValue(); 
+            this.Initialize("Ecko Statue", typeof(EckoStatueRecipe));
+            CraftingComponent.AddRecipe(typeof(Object), this);
+        }
+    }
+}

AutoGen/WorldObject/ElectricWallLamp.cs

@@ -0,0 +1,111 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class ElectricWallLampObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Electric Wall Lamp"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(35);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+            this.GetComponent<HousingComponent>().Set(ElectricWallLampItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class ElectricWallLampItem : WorldObjectItem<ElectricWallLampObject>
+    {
+        public override string FriendlyName { get { return "Electric Wall Lamp"; } } 
+        public override string Description  { get { return  "A wall mounted lamp that requires electricity to turn on."; } }
+
+        static ElectricWallLampItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 4,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(ElectronicEngineeringSkill), 3)]
+    public partial class ElectricWallLampRecipe : Recipe
+    {
+        public ElectricWallLampRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ElectricWallLampItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(ElectronicEngineeringEfficiencySkill), 10, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<CopperWiringItem>(typeof(ElectronicEngineeringEfficiencySkill), 4, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<GlassItem>(typeof(ElectronicEngineeringEfficiencySkill), 4, 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);
+        }
+    }
+}

AutoGen/WorldObject/ElectronicsAssembly.cs

@@ -0,0 +1,111 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(2, 18)]        
+    public partial class ElectronicsAssemblyObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Electronics Assembly"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<HousingComponent>().Set(ElectronicsAssemblyItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class ElectronicsAssemblyItem : WorldObjectItem<ElectronicsAssemblyObject>
+    {
+        public override string FriendlyName { get { return "Electronics Assembly"; } } 
+        public override string Description  { get { return  "A set of machinery to create electronics."; } }
+
+        static ElectronicsAssemblyItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(ElectronicEngineeringSkill), 0)]
+    public partial class ElectronicsAssemblyRecipe : Recipe
+    {
+        public ElectronicsAssemblyRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ElectronicsAssemblyItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(ElectronicEngineeringEfficiencySkill), 20, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<CopperWiringItem>(typeof(ElectronicEngineeringEfficiencySkill), 2, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<BoardItem>(typeof(ElectronicEngineeringEfficiencySkill), 6, 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);
+        }
+    }
+}

AutoGen/WorldObject/FramedGlassDoor.cs

@@ -0,0 +1,94 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class FramedGlassDoorObject : 
+        DoorObject 
+    {
+        public override string FriendlyName { get { return "Framed Glass Door"; } } 
+
+
+        protected override void Initialize()
+        {
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class FramedGlassDoorItem : WorldObjectItem<FramedGlassDoorObject>
+    {
+        public override string FriendlyName { get { return "Framed Glass Door"; } } 
+        public override string Description  { get { return  "A beautiful glass door made of steel and glass."; } }
+
+        static FramedGlassDoorItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(GlassworkingSkill), 1)]
+    public partial class FramedGlassDoorRecipe : Recipe
+    {
+        public FramedGlassDoorRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<FramedGlassDoorItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<FramedGlassItem>(typeof(GlassProductionEfficiencySkill), 10, GlassProductionEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<SteelItem>(typeof(GlassProductionEfficiencySkill), 5, GlassProductionEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(20, GlassProductionSpeedSkill.MultiplicativeStrategy, typeof(GlassProductionSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(FramedGlassDoorRecipe), Item.Get<FramedGlassDoorItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<FramedGlassDoorItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Framed Glass Door", typeof(FramedGlassDoorRecipe));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Icebox.cs

@@ -0,0 +1,112 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(PublicStorageComponent))]                
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class IceboxObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Icebox"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Housing");                                 
+            this.GetComponent<HousingComponent>().Set(IceboxItem.HousingVal);                                
+
+            var storage = this.GetComponent<PublicStorageComponent>();
+            storage.Initialize(8);
+            storage.Storage.AddRestriction(new NotCarriedRestriction()); // can't store block or large items
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class IceboxItem : WorldObjectItem<IceboxObject>
+    {
+        public override string FriendlyName { get { return "Icebox"; } } 
+        public override string Description  { get { return  "A box of ice. It's in the name!"; } }
+
+        static IceboxItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Kitchen",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Food Storage", 
+                                                    DiminishingReturnPercent = 0.3f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 4)]
+    public partial class IceboxRecipe : Recipe
+    {
+        public IceboxRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<IceboxItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(WoodworkingEfficiencySkill), 10, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(WoodworkingEfficiencySkill), 10, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<IronIngotItem>(typeof(WoodworkingEfficiencySkill), 10, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(IceboxRecipe), Item.Get<IceboxItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<IceboxItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Icebox", typeof(IceboxRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Kiln.cs

@@ -0,0 +1,116 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(45)]                              
+    [RequireRoomMaterialTier(1, 32)]        
+    public partial class KilnObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Kiln"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(50);                    
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class KilnItem : WorldObjectItem<KilnObject>
+    {
+        public override string FriendlyName { get { return "Kiln"; } } 
+        public override string Description  { get { return  "Useful for baking bricks and finishing pottery."; } }
+
+        static KilnItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(StoneworkingSkill), 4)]
+    public partial class KilnRecipe : Recipe
+    {
+        public KilnRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<KilnItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<MortaredStoneItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(StoneworkingEfficiencySkill), 20, StoneworkingEfficiencySkill.MultiplicativeStrategy),
+            };
+            SkillModifiedValue value = new SkillModifiedValue(30, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(KilnRecipe), Item.Get<KilnItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<KilnItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Kiln", typeof(KilnRecipe));
+            CraftingComponent.AddRecipe(typeof(MasonryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Kitchen.cs

@@ -0,0 +1,113 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(2, 18)]        
+    public partial class KitchenObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Kitchen"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Cooking");                                 
+            this.GetComponent<HousingComponent>().Set(KitchenItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class KitchenItem : WorldObjectItem<KitchenObject>
+    {
+        public override string FriendlyName { get { return "Kitchen"; } } 
+        public override string Description  { get { return  "A prep area for food which allows for more complex dishes."; } }
+
+        static KitchenItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Kitchen",
+                                                    Val = 3,                                   
+                                                    TypeForRoomLimit = "Cooking", 
+                                                    DiminishingReturnPercent = 0.3f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(LumberWoodworkingSkill), 1)]
+    public partial class KitchenRecipe : Recipe
+    {
+        public KitchenRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<KitchenItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(LumberWoodworkingEfficiencySkill), 20, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<LumberItem>(typeof(LumberWoodworkingEfficiencySkill), 40, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<MortaredStoneItem>(typeof(LumberWoodworkingEfficiencySkill), 10, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(120, LumberWoodworkingSpeedSkill.MultiplicativeStrategy, typeof(LumberWoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(KitchenRecipe), Item.Get<KitchenItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<KitchenItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Kitchen", typeof(KitchenRecipe));
+            CraftingComponent.AddRecipe(typeof(SawmillObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Laboratory.cs

@@ -0,0 +1,106 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(3, 18)]        
+    public partial class LaboratoryObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Laboratory"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Cooking");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(250);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class LaboratoryItem : WorldObjectItem<LaboratoryObject>
+    {
+        public override string FriendlyName { get { return "Laboratory"; } } 
+        public override string Description  { get { return  "For researching the science side of cooking. Science rules!"; } }
+
+        static LaboratoryItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(IndustrialEngineeringSkill), 2)]
+    public partial class LaboratoryRecipe : Recipe
+    {
+        public LaboratoryRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<LaboratoryItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(IndustrialEngineeringEfficiencySkill), 30, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<GlassItem>(typeof(IndustrialEngineeringEfficiencySkill), 20, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(120, IndustrialEngineeringSpeedSkill.MultiplicativeStrategy, typeof(IndustrialEngineeringSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(LaboratoryRecipe), Item.Get<LaboratoryItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<LaboratoryItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Laboratory", typeof(LaboratoryRecipe));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Laser.cs

@@ -0,0 +1,80 @@
+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;
+    
+
+    [Serialized]
+    public partial class LaserItem : WorldObjectItem<LaserObject>
+    {
+        public override string FriendlyName { get { return "Laser"; } } 
+        public override string Description  { get { return  "AVOID DIRECT EYE EXPOSURE"; } }
+
+        static LaserItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(ElectronicEngineeringSkill), 4)]
+    public partial class LaserRecipe : Recipe
+    {
+        public LaserRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<LaserItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<GoldIngotItem>(typeof(ElectronicEngineeringEfficiencySkill), 150, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<SteelItem>(typeof(ElectronicEngineeringEfficiencySkill), 150, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CircuitItem>(typeof(ElectronicEngineeringEfficiencySkill), 150, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ReinforcedConcreteItem>(typeof(ElectronicEngineeringEfficiencySkill), 150, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<LumberItem>(typeof(ElectronicEngineeringEfficiencySkill), 150, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+            };
+            SkillModifiedValue value = new SkillModifiedValue(240, ElectronicEngineeringSpeedSkill.MultiplicativeStrategy, typeof(ElectronicEngineeringSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(LaserRecipe), Item.Get<LaserItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<LaserItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Laser", typeof(LaserRecipe));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/MachineShop.cs

@@ -0,0 +1,112 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(2, 18)]        
+    public partial class MachineShopObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Machine Shop"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<HousingComponent>().Set(MachineShopItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class MachineShopItem : WorldObjectItem<MachineShopObject>
+    {
+        public override string FriendlyName { get { return "Machine Shop"; } } 
+        public override string Description  { get { return  "A fancy toolbench that creates equally fancy toys."; } }
+
+        static MachineShopItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MechanicalEngineeringSkill), 0)]
+    public partial class MachineShopRecipe : Recipe
+    {
+        public MachineShopRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<MachineShopItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LumberItem>(typeof(MechanicsAssemblyEfficiencySkill), 20, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(MechanicsAssemblyEfficiencySkill), 30, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<MortaredStoneItem>(typeof(MechanicsAssemblyEfficiencySkill), 15, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<IronIngotItem>(typeof(MechanicsAssemblyEfficiencySkill), 40, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(120, MechanicsAssemblySpeedSkill.MultiplicativeStrategy, typeof(MechanicsAssemblySpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(MachineShopRecipe), Item.Get<MachineShopItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<MachineShopItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Machine Shop", typeof(MachineShopRecipe));
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/WorldObject/OilRefinery.cs

@@ -0,0 +1,136 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(PipeComponent))]                    
+              
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class OilRefineryObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Oil Refinery"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(HewnLogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(50);                    
+            this.GetComponent<HousingComponent>().Set(OilRefineryItem.HousingVal);                                
+
+
+            var tankList = new List<LiquidTank>();
+            
+            tankList.Add(new LiquidProducer("Chimney", typeof(SmogItem), 100,
+                    null,                                                                
+                    this.Occupancy.Find(x => x.Name == "ChimneyOut"),   
+                        (float)(0.25f * SmogItem.SmogItemsPerCO2PPM) / TimeUtil.SecondsPerHour)); 
+            
+            
+            
+            this.GetComponent<PipeComponent>().Initialize(tankList);
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class OilRefineryItem : WorldObjectItem<OilRefineryObject>
+    {
+        public override string FriendlyName { get { return "Oil Refinery"; } } 
+        public override string Description  { get { return  "Sets of pipes and tanks which refine crude petroleum into usable products."; } }
+
+        static OilRefineryItem()
+        {
+            
+            
+            
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MechanicalEngineeringSkill), 4)]
+    public partial class OilRefineryRecipe : Recipe
+    {
+        public OilRefineryRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<OilRefineryItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BrickItem>(typeof(MechanicsAssemblyEfficiencySkill), 10, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<GearItem>(typeof(MechanicsAssemblyEfficiencySkill), 10, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<IronIngotItem>(typeof(MechanicsAssemblyEfficiencySkill), 35, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<WindmillItem>(typeof(MechanicsAssemblyEfficiencySkill), 1, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(50, MechanicsAssemblySpeedSkill.MultiplicativeStrategy, typeof(MechanicsAssemblySpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(OilRefineryRecipe), Item.Get<OilRefineryItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<OilRefineryItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Oil Refinery", typeof(OilRefineryRecipe));
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+}

AutoGen/WorldObject/PaddedChair.cs

@@ -0,0 +1,108 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class PaddedChairObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Padded Chair"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Housing");                                 
+            this.GetComponent<HousingComponent>().Set(PaddedChairItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class PaddedChairItem : WorldObjectItem<PaddedChairObject>
+    {
+        public override string FriendlyName { get { return "Padded Chair"; } } 
+        public override string Description  { get { return  "A comfy chair to rest in."; } }
+
+        static PaddedChairItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Living",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Seating", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(ClothProductionSkill), 3)]
+    public partial class PaddedChairRecipe : Recipe
+    {
+        public PaddedChairRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<PaddedChairItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(ClothProductionEfficiencySkill), 5, ClothProductionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(ClothProductionEfficiencySkill), 20, ClothProductionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ClothItem>(typeof(ClothProductionEfficiencySkill), 10, ClothProductionEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<RivetItem>(typeof(ClothProductionEfficiencySkill), 5, ClothProductionEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, ClothProductionSpeedSkill.MultiplicativeStrategy, typeof(ClothProductionSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(PaddedChairRecipe), Item.Get<PaddedChairItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<PaddedChairItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Padded Chair", typeof(PaddedChairRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/PlanterPotRound.cs

@@ -0,0 +1,106 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class PlanterPotRoundObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Round Pot"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Housing");                                 
+            this.GetComponent<HousingComponent>().Set(PlanterPotRoundItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class PlanterPotRoundItem : WorldObjectItem<PlanterPotRoundObject>
+    {
+        public override string FriendlyName { get { return "Round Pot"; } } 
+        public override string Description  { get { return  "Sometimes you just want to bring a little bit of nature into your house."; } }
+
+        static PlanterPotRoundItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 1,                                   
+                                                    TypeForRoomLimit = "Decoration", 
+                                                    DiminishingReturnPercent = 0.9f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(StoneworkingSkill), 3)]
+    public partial class PlanterPotRoundRecipe : Recipe
+    {
+        public PlanterPotRoundRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<PlanterPotRoundItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<DirtItem>(typeof(StoneworkingEfficiencySkill), 2, StoneworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.Do("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);
+        }
+    }
+}

AutoGen/WorldObject/PlanterPotSquare.cs

@@ -0,0 +1,106 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class PlanterPotSquareObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Square Pot"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Housing");                                 
+            this.GetComponent<HousingComponent>().Set(PlanterPotSquareItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class PlanterPotSquareItem : WorldObjectItem<PlanterPotSquareObject>
+    {
+        public override string FriendlyName { get { return "Square Pot"; } } 
+        public override string Description  { get { return  "Sometimes you just want to bring a little bit of nature into your house."; } }
+
+        static PlanterPotSquareItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 1,                                   
+                                                    TypeForRoomLimit = "Decoration", 
+                                                    DiminishingReturnPercent = 0.9f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(StoneworkingSkill), 3)]
+    public partial class PlanterPotSquareRecipe : Recipe
+    {
+        public PlanterPotSquareRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<PlanterPotSquareItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<DirtItem>(typeof(StoneworkingEfficiencySkill), 2, StoneworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(PlanterPotSquareRecipe), Item.Get<PlanterPotSquareItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<PlanterPotSquareItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Planter Pot Square", typeof(PlanterPotSquareRecipe));
+            CraftingComponent.AddRecipe(typeof(KilnObject), this);
+        }
+    }
+}

AutoGen/WorldObject/PumpJack.cs

@@ -0,0 +1,112 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class PumpJackObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Pump Jack"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(100);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+            this.GetComponent<HousingComponent>().Set(PumpJackItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class PumpJackItem : WorldObjectItem<PumpJackObject>
+    {
+        public override string FriendlyName { get { return "Pump Jack"; } } 
+        public override string Description  { get { return  "Drill, baby! Drill!"; } }
+
+        static PumpJackItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MechanicalEngineeringSkill), 4)]
+    public partial class PumpJackRecipe : Recipe
+    {
+        public PumpJackRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<PumpJackItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ConcreteItem>(typeof(MechanicsAssemblyEfficiencySkill), 20, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<SteelItem>(typeof(MechanicsAssemblyEfficiencySkill), 30, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<GearboxItem>(typeof(MechanicsAssemblyEfficiencySkill), 5, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<PistonItem>(typeof(MechanicsAssemblyEfficiencySkill), 10, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(50, MechanicsAssemblySpeedSkill.MultiplicativeStrategy, typeof(MechanicsAssemblySpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(PumpJackRecipe), Item.Get<PumpJackItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<PumpJackItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Pump Jack", typeof(PumpJackRecipe));
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Refrigerator.cs

@@ -0,0 +1,117 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(PublicStorageComponent))]                
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class RefrigeratorObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Refrigerator"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Housing");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(100);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+            this.GetComponent<HousingComponent>().Set(RefrigeratorItem.HousingVal);                                
+
+            var storage = this.GetComponent<PublicStorageComponent>();
+            storage.Initialize(8);
+            storage.Storage.AddRestriction(new NotCarriedRestriction()); // can't store block or large items
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class RefrigeratorItem : WorldObjectItem<RefrigeratorObject>
+    {
+        public override string FriendlyName { get { return "Refrigerator"; } } 
+        public override string Description  { get { return  "An icebox from the future with significantly better cooling properties."; } }
+
+        static RefrigeratorItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Kitchen",
+                                                    Val = 10,                                   
+                                                    TypeForRoomLimit = "Food Storage", 
+                                                    DiminishingReturnPercent = 0.3f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(IndustrialEngineeringSkill), 3)]
+    public partial class RefrigeratorRecipe : Recipe
+    {
+        public RefrigeratorRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<RefrigeratorItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(IndustrialEngineeringEfficiencySkill), 18, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<RivetItem>(typeof(IndustrialEngineeringEfficiencySkill), 10, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CircuitItem>(typeof(IndustrialEngineeringEfficiencySkill), 5, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<PlasticItem>(typeof(IndustrialEngineeringEfficiencySkill), 5, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(10, IndustrialEngineeringSpeedSkill.MultiplicativeStrategy, typeof(IndustrialEngineeringSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(RefrigeratorRecipe), Item.Get<RefrigeratorItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<RefrigeratorItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Refrigerator", typeof(RefrigeratorRecipe));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/ResearchTable.cs

@@ -0,0 +1,104 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(1, 18)]        
+    public partial class ResearchTableObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Research Table"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Research");                                 
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class ResearchTableItem : WorldObjectItem<ResearchTableObject>
+    {
+        public override string FriendlyName { get { return "Research Table"; } } 
+        public override string Description  { get { return  "A basic table for researching new technologies and skills."; } }
+
+        static ResearchTableItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(BasicCraftingSkill), 1)]
+    public partial class ResearchTableRecipe : Recipe
+    {
+        public ResearchTableRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ResearchTableItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(BasicCraftingEfficiencySkill), 30, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 40, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<PlantFibersItem>(typeof(BasicCraftingEfficiencySkill), 30, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<ResearchTableItem>(typeof(BasicCraftingEfficiencySkill), 1, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(ResearchTableRecipe), Item.Get<ResearchTableItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<ResearchTableItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Research Table", typeof(ResearchTableRecipe));
+            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
+        }
+    }
+}

AutoGen/WorldObject/RollingMill.cs

@@ -0,0 +1,106 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(2, 18)]        
+    public partial class RollingMillObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Rolling Mill"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(250);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class RollingMillItem : WorldObjectItem<RollingMillObject>
+    {
+        public override string FriendlyName { get { return "Rolling Mill"; } } 
+        public override string Description  { get { return  "For rolling steel into more buildable materials."; } }
+
+        static RollingMillItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(SteelworkingSkill), 1)]
+    public partial class RollingMillRecipe : Recipe
+    {
+        public RollingMillRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<RollingMillItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 20, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<MortaredStoneItem>(typeof(SteelworkingEfficiencySkill), 15, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(45, SteelworkingSpeedSkill.MultiplicativeStrategy, typeof(SteelworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(RollingMillRecipe), Item.Get<RollingMillItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<RollingMillItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Rolling Mill", typeof(RollingMillRecipe));
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Sawmill.cs

@@ -0,0 +1,106 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(1, 18)]        
+    public partial class SawmillObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Sawmill"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(100);                      
+            this.GetComponent<PowerGridComponent>().Initialize(5, new MechanicalPower());        
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class SawmillItem : WorldObjectItem<SawmillObject>
+    {
+        public override string FriendlyName { get { return "Sawmill"; } } 
+        public override string Description  { get { return  "Used to saw wood into lumber."; } }
+
+        static SawmillItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(LumberWoodworkingSkill), 0)]
+    public partial class SawmillRecipe : Recipe
+    {
+        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);
+        }
+    }
+}

AutoGen/WorldObject/ShelfCabinet.cs

@@ -0,0 +1,112 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(PublicStorageComponent))]                
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class ShelfCabinetObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Shelf Cabinet"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Housing");                                 
+            this.GetComponent<HousingComponent>().Set(ShelfCabinetItem.HousingVal);                                
+
+            var storage = this.GetComponent<PublicStorageComponent>();
+            storage.Initialize(8);
+            storage.Storage.AddRestriction(new NotCarriedRestriction()); // can't store block or large items
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class ShelfCabinetItem : WorldObjectItem<ShelfCabinetObject>
+    {
+        public override string FriendlyName { get { return "Shelf Cabinet"; } } 
+        public override string Description  { get { return  "When a shelf and a cabinet aren't enough individually."; } }
+
+        static ShelfCabinetItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Shelves", 
+                                                    DiminishingReturnPercent = 0.7f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(LumberWoodworkingSkill), 3)]
+    public partial class ShelfCabinetRecipe : Recipe
+    {
+        public ShelfCabinetRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ShelfCabinetItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LumberItem>(typeof(LumberWoodworkingEfficiencySkill), 20, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<PaperItem>(typeof(LumberWoodworkingEfficiencySkill), 100, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<IronIngotItem>(typeof(LumberWoodworkingEfficiencySkill), 5, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, LumberWoodworkingSpeedSkill.MultiplicativeStrategy, typeof(LumberWoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(ShelfCabinetRecipe), Item.Get<ShelfCabinetItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<ShelfCabinetItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Shelf Cabinet", typeof(ShelfCabinetRecipe));
+            CraftingComponent.AddRecipe(typeof(SawmillObject), this);
+        }
+    }
+}

AutoGen/WorldObject/SmallTable.cs

@@ -0,0 +1,106 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class SmallTableObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Small Table"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Misc");                                 
+            this.GetComponent<HousingComponent>().Set(SmallTableItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class SmallTableItem : WorldObjectItem<SmallTableObject>
+    {
+        public override string FriendlyName { get { return "Small Table"; } } 
+        public override string Description  { get { return  "More of a nightstand than a table, really."; } }
+
+        static SmallTableItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 1,                                   
+                                                    TypeForRoomLimit = "Table", 
+                                                    DiminishingReturnPercent = 0.7f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 2)]
+    public partial class SmallTableRecipe : Recipe
+    {
+        public SmallTableRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SmallTableItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(WoodworkingEfficiencySkill), 8, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(WoodworkingEfficiencySkill), 15, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(SmallTableRecipe), Item.Get<SmallTableItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<SmallTableItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Small Table", typeof(SmallTableRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/SmallWoodSign.cs

@@ -0,0 +1,70 @@
+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;
+    
+
+    [Serialized]
+    public partial class SmallWoodSignItem : WorldObjectItem<SmallWoodSignObject>
+    {
+        public override string FriendlyName { get { return "Small Wood Sign"; } } 
+        public override string Description  { get { return  "A small wooden sign for all your small text needs."; } }
+
+        static SmallWoodSignItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 1)]
+    public partial class SmallWoodSignRecipe : Recipe
+    {
+        public SmallWoodSignRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SmallWoodSignItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BoardItem>(typeof(WoodworkingEfficiencySkill), 8, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(1, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(SmallWoodSignRecipe), Item.Get<SmallWoodSignItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<SmallWoodSignItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Small Wood Sign", typeof(SmallWoodSignRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/SolarGenerator.cs

@@ -0,0 +1,112 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerGeneratorComponent))]         
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class SolarGeneratorObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Solar Generator"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Power");                                 
+            this.GetComponent<PowerGridComponent>().Initialize(30, new ElectricPower());        
+            this.GetComponent<PowerGeneratorComponent>().Initialize(1000);                       
+            this.GetComponent<HousingComponent>().Set(SolarGeneratorItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class SolarGeneratorItem : WorldObjectItem<SolarGeneratorObject>
+    {
+        public override string FriendlyName { get { return "Solar Generator"; } } 
+        public override string Description  { get { return  "Generates electrical power from the sun! It also stores energy to work at night."; } }
+
+        static SolarGeneratorItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(ElectronicEngineeringSkill), 4)]
+    public partial class SolarGeneratorRecipe : Recipe
+    {
+        public SolarGeneratorRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SolarGeneratorItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(ElectronicEngineeringEfficiencySkill), 20, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<GearboxItem>(typeof(ElectronicEngineeringEfficiencySkill), 10, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CircuitItem>(typeof(ElectronicEngineeringEfficiencySkill), 10, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ReinforcedConcreteItem>(typeof(ElectronicEngineeringEfficiencySkill), 4, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),
+            };
+            SkillModifiedValue value = new SkillModifiedValue(50, ElectronicEngineeringSpeedSkill.MultiplicativeStrategy, typeof(ElectronicEngineeringSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(SolarGeneratorRecipe), Item.Get<SolarGeneratorItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<SolarGeneratorItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Solar Generator", typeof(SolarGeneratorRecipe));
+            CraftingComponent.AddRecipe(typeof(ElectronicsAssemblyObject), this);
+        }
+    }
+}

AutoGen/WorldObject/SteelCeilingLight.cs

@@ -0,0 +1,111 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class SteelCeilingLightObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Steel Ceiling Light"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(35);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+            this.GetComponent<HousingComponent>().Set(SteelCeilingLightItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class SteelCeilingLightItem : WorldObjectItem<SteelCeilingLightObject>
+    {
+        public override string FriendlyName { get { return "Steel Ceiling Light"; } } 
+        public override string Description  { get { return  "A more modern way to light up a room."; } }
+
+        static SteelCeilingLightItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 5,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(SteelworkingSkill), 3)]
+    public partial class SteelCeilingLightRecipe : Recipe
+    {
+        public SteelCeilingLightRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelCeilingLightItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 10, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<CopperWiringItem>(typeof(SteelworkingEfficiencySkill), 2, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<GlassItem>(typeof(SteelworkingEfficiencySkill), 5, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(10, SteelworkingSpeedSkill.MultiplicativeStrategy, typeof(SteelworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(SteelCeilingLightRecipe), Item.Get<SteelCeilingLightItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<SteelCeilingLightItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Steel Ceiling Light", typeof(SteelCeilingLightRecipe));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/SteelFloorLamp.cs

@@ -0,0 +1,112 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class SteelFloorLampObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Steel Floor Lamp"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(35);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+            this.GetComponent<HousingComponent>().Set(SteelFloorLampItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class SteelFloorLampItem : WorldObjectItem<SteelFloorLampObject>
+    {
+        public override string FriendlyName { get { return "Steel Floor Lamp"; } } 
+        public override string Description  { get { return  "A more modern way to light up a room. This time from the floor."; } }
+
+        static SteelFloorLampItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 5,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(SteelworkingSkill), 2)]
+    public partial class SteelFloorLampRecipe : Recipe
+    {
+        public SteelFloorLampRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelFloorLampItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 10, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<CopperWiringItem>(typeof(SteelworkingEfficiencySkill), 2, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<GlassItem>(typeof(SteelworkingEfficiencySkill), 5, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(10, SteelworkingSpeedSkill.MultiplicativeStrategy, typeof(SteelworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(SteelFloorLampRecipe), Item.Get<SteelFloorLampItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<SteelFloorLampItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Steel Floor Lamp", typeof(SteelFloorLampRecipe));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/SteelTableLamp.cs

@@ -0,0 +1,111 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class SteelTableLampObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Steel Table Lamp"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(35);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+            this.GetComponent<HousingComponent>().Set(SteelTableLampItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class SteelTableLampItem : WorldObjectItem<SteelTableLampObject>
+    {
+        public override string FriendlyName { get { return "Steel Table Lamp"; } } 
+        public override string Description  { get { return  "For late night studying. Or working. Or anything, really."; } }
+
+        static SteelTableLampItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 4,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(SteelworkingSkill), 1)]
+    public partial class SteelTableLampRecipe : Recipe
+    {
+        public SteelTableLampRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelTableLampItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 8, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<CopperWiringItem>(typeof(SteelworkingEfficiencySkill), 2, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<GlassItem>(typeof(SteelworkingEfficiencySkill), 3, SteelworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(10, SteelworkingSpeedSkill.MultiplicativeStrategy, typeof(SteelworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(SteelTableLampRecipe), Item.Get<SteelTableLampItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<SteelTableLampItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Steel Table Lamp", typeof(SteelTableLampRecipe));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/StoneBrazier.cs

@@ -0,0 +1,120 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class StoneBrazierObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Stone Brazier"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(HewnLogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(1);                    
+            this.GetComponent<HousingComponent>().Set(StoneBrazierItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class StoneBrazierItem : WorldObjectItem<StoneBrazierObject>
+    {
+        public override string FriendlyName { get { return "Stone Brazier"; } } 
+        public override string Description  { get { return  "A stone stand which can hold burning fuel to provide light."; } }
+
+        static StoneBrazierItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(StoneworkingSkill), 1)]
+    public partial class StoneBrazierRecipe : Recipe
+    {
+        public StoneBrazierRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<StoneBrazierItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(StoneworkingEfficiencySkill), 10, StoneworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(10, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(StoneBrazierRecipe), Item.Get<StoneBrazierItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<StoneBrazierItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Stone Brazier", typeof(StoneBrazierRecipe));
+            CraftingComponent.AddRecipe(typeof(MasonryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/StoneWell.cs

@@ -0,0 +1,66 @@
+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;
+    
+
+    [Serialized]
+    [Category("Hidden")] 
+    public partial class StoneWellItem : WorldObjectItem<StoneWellObject>
+    {
+        public override string FriendlyName { get { return "Stone Well"; } } 
+        public override string Description  { get { return  "PLACEHOLDER"; } }
+
+        static StoneWellItem()
+        {
+            
+        }
+
+    }
+
+
+    public partial class StoneWellRecipe : Recipe
+    {
+        public StoneWellRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<StoneWellItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+            };
+            this.CraftMinutes = new ConstantValue(); 
+            this.Initialize("Stone Well", typeof(StoneWellRecipe));
+            CraftingComponent.AddRecipe(typeof(Object), this);
+        }
+    }
+}

AutoGen/WorldObject/StorageChest.cs

@@ -0,0 +1,100 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(PublicStorageComponent))]                
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class StorageChestObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Storage Chest"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Storage");                                 
+
+            var storage = this.GetComponent<PublicStorageComponent>();
+            storage.Initialize(16);
+            storage.Storage.AddRestriction(new NotCarriedRestriction()); // can't store block or large items
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class StorageChestItem : WorldObjectItem<StorageChestObject>
+    {
+        public override string FriendlyName { get { return "Storage Chest"; } } 
+        public override string Description  { get { return  "A container you can store items in."; } }
+
+        static StorageChestItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(BasicCraftingSkill), 1)]
+    public partial class StorageChestRecipe : Recipe
+    {
+        public StorageChestRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<StorageChestItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(2, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(StorageChestRecipe), Item.Get<StorageChestItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<StorageChestItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Storage Chest", typeof(StorageChestRecipe));
+            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Store.cs

@@ -0,0 +1,101 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(1, 18)]        
+    public partial class StoreObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Store"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Economy");                                 
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class StoreItem : WorldObjectItem<StoreObject>
+    {
+        public override string FriendlyName { get { return "Store"; } } 
+        public override string Description  { get { return  "Allows the selling and trading of items."; } }
+
+        static StoreItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(BasicCraftingSkill), 1)]
+    public partial class StoreRecipe : Recipe
+    {
+        public StoreRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<StoreItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(15, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(StoreRecipe), Item.Get<StoreItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<StoreItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Store", typeof(StoreRecipe));
+            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Stove.cs

@@ -0,0 +1,143 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(PipeComponent))]                    
+
+    [RequireComponent(typeof(AttachmentComponent))]              
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(2, 18)]        
+    public partial class StoveObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Stove"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(LogItem),
+            typeof(HewnLogItem),
+            typeof(LumberItem),
+            typeof(CharcoalItem),
+            typeof(ArrowItem),
+            typeof(BoardItem),
+            typeof(CoalItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Cooking");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(10);                    
+            this.GetComponent<HousingComponent>().Set(StoveItem.HousingVal);                                
+
+
+            var tankList = new List<LiquidTank>();
+            
+            tankList.Add(new LiquidProducer("Chimney", typeof(SmogItem), 100,
+                    null,                                                                
+                    this.Occupancy.Find(x => x.Name == "ChimneyOut"),   
+                        (float)(0.1f * SmogItem.SmogItemsPerCO2PPM) / TimeUtil.SecondsPerHour)); 
+            
+            
+            
+            this.GetComponent<PipeComponent>().Initialize(tankList);
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class StoveItem : WorldObjectItem<StoveObject>
+    {
+        public override string FriendlyName { get { return "Stove"; } } 
+        public override string Description  { get { return  "A heavy stove for cooking more complex dishes."; } }
+
+        static StoveItem()
+        {
+            
+            
+            
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Kitchen",
+                                                    Val = 4,                                   
+                                                    TypeForRoomLimit = "Cooking", 
+                                                    DiminishingReturnPercent = 0.3f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 1)]
+    public partial class StoveRecipe : Recipe
+    {
+        public StoveRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<StoveItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(MetalworkingEfficiencySkill), 45, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+				new CraftingElement<SteelItem>(typeof(MetalworkingEfficiencySkill),30, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+				new CraftingElement<RivetItem>(typeof(MetalworkingEfficiencySkill),30, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+				new CraftingElement<MortaredStoneItem>(typeof(MetalworkingEfficiencySkill),10, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+            };
+            SkillModifiedValue value = new SkillModifiedValue(20, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("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(MachineShopObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Streetlamp.cs

@@ -0,0 +1,112 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class StreetlampObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Streetlamp"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(35);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+            this.GetComponent<HousingComponent>().Set(StreetlampItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class StreetlampItem : WorldObjectItem<StreetlampObject>
+    {
+        public override string FriendlyName { get { return "Streetlamp"; } } 
+        public override string Description  { get { return  "A towering metal lightpost that requires electricity to run."; } }
+
+        static StreetlampItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 4,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(ElectronicEngineeringSkill), 3)]
+    public partial class StreetlampRecipe : Recipe
+    {
+        public StreetlampRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<StreetlampItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(ElectronicEngineeringEfficiencySkill), 20, ElectronicEngineeringEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<CopperWiringItem>(typeof(ElectronicEngineeringEfficiencySkill), 6, 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(StreetlampRecipe), Item.Get<StreetlampItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<StreetlampItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Streetlamp", typeof(StreetlampRecipe));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Table.cs

@@ -0,0 +1,104 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class TableObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Table"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<HousingComponent>().Set(TableItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class TableItem : WorldObjectItem<TableObject>
+    {
+        public override string FriendlyName { get { return "Table"; } } 
+        public override string Description  { get { return  "A large table for placing things on."; } }
+
+        static TableItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Table", 
+                                                    DiminishingReturnPercent = 0.6f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 2)]
+    public partial class TableRecipe : Recipe
+    {
+        public TableRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<TableItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(WoodworkingEfficiencySkill), 10, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(WoodworkingEfficiencySkill), 30, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(TableRecipe), Item.Get<TableItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<TableItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Table", typeof(TableRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/TailoringTable.cs

@@ -0,0 +1,102 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(45)]                              
+    [RequireRoomMaterialTier(1, 32)]        
+    public partial class TailoringTableObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Tailoring Table"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class TailoringTableItem : WorldObjectItem<TailoringTableObject>
+    {
+        public override string FriendlyName { get { return "Tailoring Table"; } } 
+        public override string Description  { get { return  "Spearhead the fashion movement with the finest clothes and<6E> hair!"; } }
+
+        static TailoringTableItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 1)]
+    public partial class TailoringTableRecipe : Recipe
+    {
+        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);
+        }
+    }
+}

AutoGen/WorldObject/TallowCandle.cs

@@ -0,0 +1,117 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class TallowCandleObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Tallow Candle"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(TallowItem),
+            typeof(OilItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(1);                    
+            this.GetComponent<HousingComponent>().Set(TallowCandleItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class TallowCandleItem : WorldObjectItem<TallowCandleObject>
+    {
+        public override string FriendlyName { get { return "Tallow Candle"; } } 
+        public override string Description  { get { return  "A candle which can burn tallow to produce a small amount of light."; } }
+
+        static TallowCandleItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 1,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(BasicCraftingSkill), 2)]
+    public partial class TallowCandleRecipe : Recipe
+    {
+        public TallowCandleRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<TallowCandleItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<TallowItem>(typeof(BasicCraftingEfficiencySkill), 3, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<IronIngotItem>(typeof(BasicCraftingEfficiencySkill), 3, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<ClothItem>(typeof(BasicCraftingEfficiencySkill), 2, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(2.5f, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(TallowCandleRecipe), Item.Get<TallowCandleItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<TallowCandleItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Tallow Candle", typeof(TallowCandleRecipe));
+            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
+        }
+    }
+}

AutoGen/WorldObject/TallowLamp.cs

@@ -0,0 +1,114 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class TallowLampObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Tallow Lamp"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(TallowItem),
+            typeof(OilItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(1);                    
+            this.GetComponent<HousingComponent>().Set(TallowLampItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class TallowLampItem : WorldObjectItem<TallowLampObject>
+    {
+        public override string FriendlyName { get { return "Tallow Lamp"; } } 
+        public override string Description  { get { return  "A pottery lamp. Fuel with tallow."; } }
+
+        static TallowLampItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    TypeForRoomLimit = "Lights", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(StoneworkingSkill), 1)]
+    public partial class TallowLampRecipe : Recipe
+    {
+        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),   
+                new CraftingElement<ClothItem>(typeof(StoneworkingEfficiencySkill), 2, StoneworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(2, StoneworkingSpeedSkill.MultiplicativeStrategy, typeof(StoneworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(TallowLampRecipe), Item.Get<TallowLampItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<TallowLampItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Tallow Lamp", typeof(TallowLampRecipe));
+            CraftingComponent.AddRecipe(typeof(KilnObject), this);
+        }
+    }
+}

AutoGen/WorldObject/TallowWallLamp.cs

@@ -0,0 +1,116 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class TallowWallLampObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Tallow Wall Lamp"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(TallowItem),
+            typeof(OilItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(1);                    
+            this.GetComponent<HousingComponent>().Set(TallowWallLampItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class TallowWallLampItem : WorldObjectItem<TallowWallLampObject>
+    {
+        public override string FriendlyName { get { return "Tallow Wall Lamp"; } } 
+        public override string Description  { get { return  "A candle mounted on a wall bracket which can burn tallow to produce a small amount of light."; } }
+
+        static TallowWallLampItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 2)]
+    public partial class TallowWallLampRecipe : Recipe
+    {
+        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<ClothItem>(typeof(MetalworkingEfficiencySkill), 2, 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);
+        }
+    }
+}

AutoGen/WorldObject/TorchStand.cs

@@ -0,0 +1,116 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class TorchStandObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Torch Stand"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(TorchItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(0.5f);                    
+            this.GetComponent<HousingComponent>().Set(TorchStandItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class TorchStandItem : WorldObjectItem<TorchStandObject>
+    {
+        public override string FriendlyName { get { return "Torch Stand"; } } 
+        public override string Description  { get { return  "A stand for a torch."; } }
+
+        static TorchStandItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 1,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(BasicCraftingSkill), 1)]
+    public partial class TorchStandRecipe : Recipe
+    {
+        public TorchStandRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<TorchStandItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(BasicCraftingEfficiencySkill), 10, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<StoneItem>(typeof(BasicCraftingEfficiencySkill), 5, BasicCraftingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(2, BasicCraftingSpeedSkill.MultiplicativeStrategy, typeof(BasicCraftingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(TorchStandRecipe), Item.Get<TorchStandItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<TorchStandItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Torch Stand", typeof(TorchStandRecipe));
+            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
+        }
+    }
+}

AutoGen/WorldObject/WainwrightTable.cs

@@ -0,0 +1,103 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    [RequireComponent(typeof(RoomRequirementsComponent))]
+    [RequireRoomContainment]
+    [RequireRoomVolume(25)]                              
+    [RequireRoomMaterialTier(1, 18)]        
+    public partial class WainwrightTableObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Wainwright Table"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WainwrightTableItem : WorldObjectItem<WainwrightTableObject>
+    {
+        public override string FriendlyName { get { return "Wainwright Table"; } } 
+        public override string Description  { get { return  "A set of smoothing and woodworking tools that assist in creating wheels and transportation."; } }
+
+        static WainwrightTableItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 0)]
+    public partial class WainwrightTableRecipe : Recipe
+    {
+        public WainwrightTableRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WainwrightTableItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BoardItem>(typeof(WoodworkingEfficiencySkill), 50, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<LogItem>(typeof(WoodworkingEfficiencySkill), 40, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<MortaredStoneItem>(typeof(WoodworkingEfficiencySkill), 25, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+            };
+            SkillModifiedValue value = new SkillModifiedValue(10, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(WainwrightTableRecipe), Item.Get<WainwrightTableItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<WainwrightTableItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Wainwright Table", typeof(WainwrightTableRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/WallCandle.cs

@@ -0,0 +1,116 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(FuelSupplyComponent))]                      
+    [RequireComponent(typeof(FuelConsumptionComponent))]                 
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class WallCandleObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Wall Candle"; } } 
+
+        private static Type[] fuelTypeList = new Type[]
+        {
+            typeof(TallowItem),
+            typeof(OilItem),
+        };
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Lights");                                 
+            this.GetComponent<FuelSupplyComponent>().Initialize(2, fuelTypeList);                           
+            this.GetComponent<FuelConsumptionComponent>().Initialize(1);                    
+            this.GetComponent<HousingComponent>().Set(WallCandleItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WallCandleItem : WorldObjectItem<WallCandleObject>
+    {
+        public override string FriendlyName { get { return "Wall Candle"; } } 
+        public override string Description  { get { return  "A wall mounted candle."; } }
+
+        static WallCandleItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "General",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Lights", 
+                                                    DiminishingReturnPercent = 0.8f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MetalworkingSkill), 3)]
+    public partial class WallCandleRecipe : Recipe
+    {
+        public WallCandleRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WallCandleItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(MetalworkingEfficiencySkill), 5, MetalworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TallowItem>(typeof(MetalworkingEfficiencySkill), 2, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<ClothItem>(typeof(MetalworkingEfficiencySkill), 2, MetalworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(1, MetalworkingSpeedSkill.MultiplicativeStrategy, typeof(MetalworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(WallCandleRecipe), Item.Get<WallCandleItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<WallCandleItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Wall Candle", typeof(WallCandleRecipe));
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Washboard.cs

@@ -0,0 +1,105 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class WashboardObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Washboard"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Housing");                                 
+            this.GetComponent<HousingComponent>().Set(WashboardItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WashboardItem : WorldObjectItem<WashboardObject>
+    {
+        public override string FriendlyName { get { return "Washboard"; } } 
+        public override string Description  { get { return  "Sometimes it can be nice to have clean clothes."; } }
+
+        static WashboardItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Bathroom",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Washing", 
+                                                    DiminishingReturnPercent = 0.5f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(ClothProductionSkill), 1)]
+    public partial class WashboardRecipe : Recipe
+    {
+        public WashboardRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WashboardItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BoardItem>(typeof(ClothProductionEfficiencySkill), 10, ClothProductionEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, ClothProductionSpeedSkill.MultiplicativeStrategy, typeof(ClothProductionSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(WashboardRecipe), Item.Get<WashboardItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<WashboardItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Washboard", typeof(WashboardRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/WashingMachine.cs

@@ -0,0 +1,111 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerConsumptionComponent))]                     
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class WashingMachineObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Washing Machine"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Housing");                                 
+            this.GetComponent<PowerConsumptionComponent>().Initialize(100);                      
+            this.GetComponent<PowerGridComponent>().Initialize(10, new ElectricPower());        
+            this.GetComponent<HousingComponent>().Set(WashingMachineItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WashingMachineItem : WorldObjectItem<WashingMachineObject>
+    {
+        public override string FriendlyName { get { return "Washing Machine"; } } 
+        public override string Description  { get { return  "Why hand scrub your clothes on a washboard when you could throw them into this magical cleaning machine?"; } }
+
+        static WashingMachineItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Bathroom",
+                                                    Val = 20,                                   
+                                                    TypeForRoomLimit = "Washing", 
+                                                    DiminishingReturnPercent = 0.3f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(IndustrialEngineeringSkill), 3)]
+    public partial class WashingMachineRecipe : Recipe
+    {
+        public WashingMachineRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WashingMachineItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(IndustrialEngineeringEfficiencySkill), 20, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<RivetItem>(typeof(IndustrialEngineeringEfficiencySkill), 15, 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);
+        }
+    }
+}

AutoGen/WorldObject/Waterwheel.cs

@@ -0,0 +1,106 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerGeneratorComponent))]         
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class WaterwheelObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Waterwheel"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Power");                                 
+            this.GetComponent<PowerGridComponent>().Initialize(10, new MechanicalPower());        
+            this.GetComponent<PowerGeneratorComponent>().Initialize(200);                       
+            this.GetComponent<HousingComponent>().Set(WaterwheelItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WaterwheelItem : WorldObjectItem<WaterwheelObject>
+    {
+        public override string FriendlyName { get { return "Waterwheel"; } } 
+        public override string Description  { get { return  "Use the power of flowing water to produce mechanical power."; } }
+
+        static WaterwheelItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(PrimitiveMechanicsSkill), 2)]
+    public partial class WaterwheelRecipe : Recipe
+    {
+        public WaterwheelRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WaterwheelItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(PrimitiveMechanicsEfficiencySkill), 20, PrimitiveMechanicsEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(30, PrimitiveMechanicsSpeedSkill.MultiplicativeStrategy, typeof(PrimitiveMechanicsSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(WaterwheelRecipe), Item.Get<WaterwheelItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<WaterwheelItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Waterwheel", typeof(WaterwheelRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/WindTurbine.cs

@@ -0,0 +1,113 @@
+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;
+    
+    [Serialized]    
+    [RequireComponent(typeof(OnOffComponent))]                   
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerGeneratorComponent))]         
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class WindTurbineObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Wind Turbine"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Power");                                 
+            this.GetComponent<PowerGridComponent>().Initialize(30, new ElectricPower());        
+            this.GetComponent<PowerGeneratorComponent>().Initialize(750);                       
+            this.GetComponent<HousingComponent>().Set(WindTurbineItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WindTurbineItem : WorldObjectItem<WindTurbineObject>
+    {
+        public override string FriendlyName { get { return "Wind Turbine"; } } 
+        public override string Description  { get { return  "Generates electrical power from the wind."; } }
+
+        static WindTurbineItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(MechanicalEngineeringSkill), 4)]
+    public partial class WindTurbineRecipe : Recipe
+    {
+        public WindTurbineRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WindTurbineItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(MechanicsAssemblyEfficiencySkill), 15, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<RivetItem>(typeof(MechanicsAssemblyEfficiencySkill), 15, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<GearboxItem>(typeof(MechanicsAssemblyEfficiencySkill), 10, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CircuitItem>(typeof(MechanicsAssemblyEfficiencySkill), 10, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<ReinforcedConcreteItem>(typeof(MechanicsAssemblyEfficiencySkill), 4, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+            };
+            SkillModifiedValue value = new SkillModifiedValue(50, MechanicsAssemblySpeedSkill.MultiplicativeStrategy, typeof(MechanicsAssemblySpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(WindTurbineRecipe), Item.Get<WindTurbineItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<WindTurbineItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Wind Turbine", typeof(WindTurbineRecipe));
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Windmill.cs

@@ -0,0 +1,108 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(PowerGridComponent))]              
+    [RequireComponent(typeof(PowerGeneratorComponent))]         
+    [RequireComponent(typeof(HousingComponent))]                  
+    public partial class WindmillObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Windmill"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Power");                                 
+            this.GetComponent<PowerGridComponent>().Initialize(10, new MechanicalPower());        
+            this.GetComponent<PowerGeneratorComponent>().Initialize(200);                       
+            this.GetComponent<HousingComponent>().Set(WindmillItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WindmillItem : WorldObjectItem<WindmillObject>
+    {
+        public override string FriendlyName { get { return "Windmill"; } } 
+        public override string Description  { get { return  "Use wind to produce mechanical power."; } }
+
+        static WindmillItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Industrial",
+                                                    TypeForRoomLimit = "", 
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(PrimitiveMechanicsSkill), 3)]
+    public partial class WindmillRecipe : Recipe
+    {
+        public WindmillRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WindmillItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(PrimitiveMechanicsEfficiencySkill), 15, PrimitiveMechanicsEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<MortaredStoneItem>(typeof(PrimitiveMechanicsEfficiencySkill), 5, PrimitiveMechanicsEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<HewnLogItem>(typeof(PrimitiveMechanicsEfficiencySkill), 10, PrimitiveMechanicsEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(30, PrimitiveMechanicsSpeedSkill.MultiplicativeStrategy, typeof(PrimitiveMechanicsSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(WindmillRecipe), Item.Get<WindmillItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<WindmillItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Windmill", typeof(WindmillRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/WoodSign.cs

@@ -0,0 +1,97 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    public partial class WoodSignObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Wood Sign"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Misc");                                 
+
+
+
+            this.AddAsPOI("Marker");  
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+            this.RemoveAsPOI("Marker");  
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WoodSignItem : WorldObjectItem<WoodSignObject>
+    {
+        public override string FriendlyName { get { return "Wood Sign"; } } 
+        public override string Description  { get { return  "A large sign for all your large text needs!"; } }
+
+        static WoodSignItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(LumberWoodworkingSkill), 1)]
+    public partial class WoodSignRecipe : Recipe
+    {
+        public WoodSignRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WoodSignItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LumberItem>(typeof(LumberWoodworkingEfficiencySkill), 4, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<IronIngotItem>(typeof(LumberWoodworkingEfficiencySkill), 4, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(1, LumberWoodworkingSpeedSkill.MultiplicativeStrategy, typeof(LumberWoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(WoodSignRecipe), Item.Get<WoodSignItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<WoodSignItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Wood Sign", typeof(WoodSignRecipe));
+            CraftingComponent.AddRecipe(typeof(SawmillObject), this);
+        }
+    }
+}

AutoGen/WorldObject/WoodenFabricBed.cs

@@ -0,0 +1,107 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class WoodenFabricBedObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Wooden Fabric Bed"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Misc");                                 
+            this.GetComponent<HousingComponent>().Set(WoodenFabricBedItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WoodenFabricBedItem : WorldObjectItem<WoodenFabricBedObject>
+    {
+        public override string FriendlyName { get { return "Wooden Fabric Bed"; } } 
+        public override string Description  { get { return  "A much more comfortable bed made with fabric."; } }
+
+        static WoodenFabricBedItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Bedroom",
+                                                    Val = 4,                                   
+                                                    TypeForRoomLimit = "Bed", 
+                                                    DiminishingReturnPercent = 0.4f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(LumberWoodworkingSkill), 4)]
+    public partial class WoodenFabricBedRecipe : Recipe
+    {
+        public WoodenFabricBedRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WoodenFabricBedItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LumberItem>(typeof(LumberWoodworkingEfficiencySkill), 20, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ClothItem>(typeof(LumberWoodworkingEfficiencySkill), 20, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),   
+                new CraftingElement<IronIngotItem>(typeof(LumberWoodworkingEfficiencySkill), 5, LumberWoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, LumberWoodworkingSpeedSkill.MultiplicativeStrategy, typeof(LumberWoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(WoodenFabricBedRecipe), Item.Get<WoodenFabricBedItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<WoodenFabricBedItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Wooden Fabric Bed", typeof(WoodenFabricBedRecipe));
+            CraftingComponent.AddRecipe(typeof(SawmillObject), this);
+        }
+    }
+}

AutoGen/WorldObject/WoodenStrawBed.cs

@@ -0,0 +1,107 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(HousingComponent))]                  
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class WoodenStrawBedObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Wooden Straw Bed"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Misc");                                 
+            this.GetComponent<HousingComponent>().Set(WoodenStrawBedItem.HousingVal);                                
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WoodenStrawBedItem : WorldObjectItem<WoodenStrawBedObject>
+    {
+        public override string FriendlyName { get { return "Wooden Straw Bed"; } } 
+        public override string Description  { get { return  "A nice, scratchy and horrible uncomfortable bed. But at least it keeps you off the ground."; } }
+
+        static WoodenStrawBedItem()
+        {
+            
+        }
+
+        [TooltipChildren] public HousingValue HousingTooltip { get { return HousingVal; } }
+        [TooltipChildren] public static HousingValue HousingVal { get { return new HousingValue() 
+                                                {
+                                                    Category = "Bedroom",
+                                                    Val = 2,                                   
+                                                    TypeForRoomLimit = "Bed", 
+                                                    DiminishingReturnPercent = 0.4f    
+        };}}
+    }
+
+
+    [RequiresSkill(typeof(WoodworkingSkill), 3)]
+    public partial class WoodenStrawBedRecipe : Recipe
+    {
+        public WoodenStrawBedRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WoodenStrawBedItem>(),
+            };
+
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(WoodworkingEfficiencySkill), 10, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(WoodworkingEfficiencySkill), 20, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<PlantFibersItem>(typeof(WoodworkingEfficiencySkill), 20, WoodworkingEfficiencySkill.MultiplicativeStrategy),   
+            };
+            SkillModifiedValue value = new SkillModifiedValue(5, WoodworkingSpeedSkill.MultiplicativeStrategy, typeof(WoodworkingSpeedSkill), Localizer.Do("craft time"));
+            SkillModifiedValueManager.AddBenefitForObject(typeof(WoodenStrawBedRecipe), Item.Get<WoodenStrawBedItem>().UILink(), value);
+            SkillModifiedValueManager.AddSkillBenefit(Item.Get<WoodenStrawBedItem>().UILink(), value);
+            this.CraftMinutes = value;
+            this.Initialize("Wooden Straw Bed", typeof(WoodenStrawBedRecipe));
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+}

AutoGen/WorldObject/Workbench.cs

@@ -0,0 +1,98 @@
+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;
+    
+    [Serialized]    
+
+    [RequireComponent(typeof(PropertyAuthComponent))]
+    [RequireComponent(typeof(MinimapComponent))]                
+    [RequireComponent(typeof(LinkComponent))]                   
+    [RequireComponent(typeof(CraftingComponent))]               
+    [RequireComponent(typeof(SolidGroundComponent))]            
+    public partial class WorkbenchObject : 
+        WorldObject    
+    {
+        public override string FriendlyName { get { return "Workbench"; } } 
+
+
+        protected override void Initialize()
+        {
+            this.GetComponent<MinimapComponent>().Initialize("Crafting");                                 
+
+
+
+        }
+
+        public override void Destroy()
+        {
+            base.Destroy();
+        }
+       
+    }
+
+    [Serialized]
+    public partial class WorkbenchItem : WorldObjectItem<WorkbenchObject>
+    {
+        public override string FriendlyName { get { return "Workbench"; } } 
+        public override string Description  { get { return  "A bench for the basics and making even more benches."; } }
+
+        static WorkbenchItem()
+        {
+            
+        }
+
+    }
+
+
+    [RequiresSkill(typeof(BasicCraftingSkill), 0)]
+    public partial class WorkbenchRecipe : Recipe
+    {
+        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);
+        }
+    }
+}