Gitlab to Gitea Migration

AutoGen/Clothing/BasicBackpack.cs

@@ -0,0 +1,56 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(100)]      
+    public partial class BasicBackpackItem :
+        ClothingItem        
+    {
+
+        public override string FriendlyName     { get { return "Basic Backpack"; } }
+        public override string Description      { get { return "Can Carry 10KG more with this one little helper"; } }
+        public override string Slot             { get { return ClothingSlot.Back; } }             
+        public override bool Starter            { get { return false ; } }                       
+
+        private static Dictionary<UserStatType, float> flatStats = new Dictionary<UserStatType, float>()
+    {
+                { UserStatType.MaxCarryWeight, 10000f },
+    };
+public override Dictionary<UserStatType, float> GetFlatStats() { return flatStats; }
+    }
+
+    
+    [RequiresSkill(typeof(ClothesmakingSkill), 1)]
+    public class BasicBackpackRecipe : Recipe
+    {
+        public BasicBackpackRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BasicBackpackItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LeatherHideItem>(typeof(ClothesmakingEfficiencySkill), 4, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ClothItem>(typeof(ClothesmakingEfficiencySkill), 5, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = new ConstantValue(1);
+            this.Initialize("Basic Backpack", typeof(BasicBackpackRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    } 
+}

AutoGen/Clothing/Bearpack.cs

@@ -0,0 +1,57 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(100)]      
+    public partial class BearpackItem :
+        ClothingItem        
+    {
+
+        public override string FriendlyName     { get { return "Bearpack"; } }
+        public override string Description      { get { return "Lets you carry as much as a bear! Not really, but it does help you carry 20KG more."; } }
+        public override string Slot             { get { return ClothingSlot.Back; } }             
+        public override bool Starter            { get { return false ; } }                       
+
+        private static Dictionary<UserStatType, float> flatStats = new Dictionary<UserStatType, float>()
+    {
+                { UserStatType.MaxCarryWeight, 20000f },
+    };
+public override Dictionary<UserStatType, float> GetFlatStats() { return flatStats; }
+    }
+
+    
+    [RequiresSkill(typeof(ClothesmakingSkill), 4)]
+    public class BearpackRecipe : Recipe
+    {
+        public BearpackRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BearpackItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CelluloseFiberItem>(typeof(ClothesmakingEfficiencySkill), 40, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ClothItem>(typeof(ClothesmakingEfficiencySkill), 30, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<FurPeltItem>(typeof(ClothesmakingEfficiencySkill), 50, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = new ConstantValue(1);
+            this.Initialize("Bearpack", typeof(BearpackRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    } 
+}

AutoGen/Clothing/BigBackpack.cs

@@ -0,0 +1,56 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(100)]      
+    public partial class BigBackpackItem :
+        ClothingItem        
+    {
+
+        public override string FriendlyName     { get { return "Big Backpack"; } }
+        public override string Description      { get { return "A normal Backpack. Just... bigger. Let's you carry 15KG more"; } }
+        public override string Slot             { get { return ClothingSlot.Back; } }             
+        public override bool Starter            { get { return false ; } }                       
+
+        private static Dictionary<UserStatType, float> flatStats = new Dictionary<UserStatType, float>()
+    {
+                { UserStatType.MaxCarryWeight, 15000f },
+    };
+public override Dictionary<UserStatType, float> GetFlatStats() { return flatStats; }
+    }
+
+    
+    [RequiresSkill(typeof(ClothesmakingSkill), 2)]
+    public class BigBackpackRecipe : Recipe
+    {
+        public BigBackpackRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BigBackpackItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LeatherHideItem>(typeof(ClothesmakingEfficiencySkill), 4, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ClothItem>(typeof(ClothesmakingEfficiencySkill), 10, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = new ConstantValue(1);
+            this.Initialize("Big Backpack", typeof(BigBackpackRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    } 
+}

AutoGen/Clothing/LightBackpack.cs

@@ -0,0 +1,57 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(100)]      
+    public partial class LightBackpackItem :
+        ClothingItem        
+    {
+
+        public override string FriendlyName     { get { return "Light Backpack"; } }
+        public override string Description      { get { return "Light Backpack. Increasing Movement Speed by 150% but you just can carry 5KG"; } }
+        public override string Slot             { get { return ClothingSlot.Back; } }             
+        public override bool Starter            { get { return false ; } }                       
+
+        private static Dictionary<UserStatType, float> flatStats = new Dictionary<UserStatType, float>()
+    {
+                { UserStatType.MaxCarryWeight, 5000f },
+                { UserStatType.MovementSpeed, 1.5f },
+    };
+public override Dictionary<UserStatType, float> GetFlatStats() { return flatStats; }
+    }
+
+    
+    [RequiresSkill(typeof(ClothesmakingSkill), 3)]
+    public class LightBackpackRecipe : Recipe
+    {
+        public LightBackpackRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<LightBackpackItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ClothItem>(typeof(ClothesmakingEfficiencySkill), 20, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CelluloseFiberItem>(typeof(ClothesmakingEfficiencySkill), 20, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = new ConstantValue(1);
+            this.Initialize("Light Backpack", typeof(LightBackpackRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    } 
+}

AutoGen/Clothing/RunningShoes.cs

@@ -0,0 +1,56 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(100)]      
+    public partial class RunningShoesItem :
+        ClothingItem        
+    {
+
+        public override string FriendlyName     { get { return "Running Shoes"; } }
+        public override string Description      { get { return "Running Shoes. Increasing Movement Speed by 70%"; } }
+        public override string Slot             { get { return ClothingSlot.Shoes; } }             
+        public override bool Starter            { get { return false ; } }                       
+
+        private static Dictionary<UserStatType, float> flatStats = new Dictionary<UserStatType, float>()
+    {
+                { UserStatType.MovementSpeed, 0.7f },
+    };
+public override Dictionary<UserStatType, float> GetFlatStats() { return flatStats; }
+    }
+
+    
+    [RequiresSkill(typeof(ClothesmakingSkill), 1)]
+    public class RunningShoesRecipe : Recipe
+    {
+        public RunningShoesRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<RunningShoesItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LeatherHideItem>(typeof(ClothesmakingEfficiencySkill), 10, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ClothItem>(typeof(ClothesmakingEfficiencySkill), 5, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = new ConstantValue(1);
+            this.Initialize("Running Shoes", typeof(RunningShoesRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    } 
+}

AutoGen/Clothing/WorkBackpack.cs

@@ -0,0 +1,57 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(100)]      
+    public partial class WorkBackpackItem :
+        ClothingItem        
+    {
+
+        public override string FriendlyName     { get { return "Work Backpack"; } }
+        public override string Description      { get { return "Lighter pack that causes lower calorie consumption by -20%. Let's you carry 8KG"; } }
+        public override string Slot             { get { return ClothingSlot.Back; } }             
+        public override bool Starter            { get { return false ; } }                       
+
+        private static Dictionary<UserStatType, float> flatStats = new Dictionary<UserStatType, float>()
+    {
+                { UserStatType.MaxCarryWeight, 8000f },
+                { UserStatType.CalorieRate, -0.2f },
+    };
+public override Dictionary<UserStatType, float> GetFlatStats() { return flatStats; }
+    }
+
+    
+    [RequiresSkill(typeof(ClothesmakingSkill), 3)]
+    public class WorkBackpackRecipe : Recipe
+    {
+        public WorkBackpackRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WorkBackpackItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LeatherHideItem>(typeof(ClothesmakingEfficiencySkill), 10, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CelluloseFiberItem>(typeof(ClothesmakingEfficiencySkill), 20, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = new ConstantValue(1);
+            this.Initialize("Work Backpack", typeof(WorkBackpackRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    } 
+}

AutoGen/Clothing/WorkBoots.cs

@@ -0,0 +1,56 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(100)]      
+    public partial class WorkBootsItem :
+        ClothingItem        
+    {
+
+        public override string FriendlyName     { get { return "Work Boots"; } }
+        public override string Description      { get { return "Sport shoes. Decreasing Calorie Consumption by 15%"; } }
+        public override string Slot             { get { return ClothingSlot.Shoes; } }             
+        public override bool Starter            { get { return false ; } }                       
+
+        private static Dictionary<UserStatType, float> flatStats = new Dictionary<UserStatType, float>()
+    {
+                { UserStatType.CalorieRate, -0.15f },
+    };
+public override Dictionary<UserStatType, float> GetFlatStats() { return flatStats; }
+    }
+
+    
+    [RequiresSkill(typeof(ClothesmakingSkill), 3)]
+    public class WorkBootsRecipe : Recipe
+    {
+        public WorkBootsRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<WorkBootsItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CelluloseFiberItem>(typeof(ClothesmakingEfficiencySkill), 20, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<LeatherHideItem>(typeof(ClothesmakingEfficiencySkill), 30, ClothesmakingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = new ConstantValue(1);
+            this.Initialize("Work Boots", typeof(WorkBootsRecipe));
+            CraftingComponent.AddRecipe(typeof(TailoringTableObject), this);
+        }
+    } 
+}

AutoGen/Food/BaconCheeseBurger.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(10)]                                          
+    public partial class BaconCheeseBurgerItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Bacon CheeseBurger"; } }
+        public override string FriendlyNamePlural               { get { return "Bacon CheeseBurger"; } } 
+        public override string Description                      { get { return "We HAVE the skill to make the best burgers, with the best meat and now.. with CHEESE!"; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 20, Fat = 22, Protein = 20, Vitamins = 16};
+        public override float Calories                          { get { return 2100; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+    [RequiresSkill(typeof(MolecularGastronomySkill), 4)]
+    public partial class BaconCheeseBurgerRecipe : Recipe
+    {
+        public BaconCheeseBurgerRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BaconCheeseBurgerItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BreadItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<MilkItem>(typeof(MolecularGastronomyEfficiencySkill), 10, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CrispyBaconItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<WildMixItem>(typeof(MolecularGastronomyEfficiencySkill), 10, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<PrimeCutItem>(typeof(MolecularGastronomyEfficiencySkill), 5, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(BaconCheeseBurgerRecipe), Item.Get<BaconCheeseBurgerItem>().UILink(), 10, typeof(MolecularGastronomySpeedSkill));
+            this.Initialize("Bacon CheeseBurger", typeof(BaconCheeseBurgerRecipe));
+            CraftingComponent.AddRecipe(typeof(KitchenObject), this);
+        }
+    }
+}

AutoGen/Food/BakedSalmon.cs

@@ -0,0 +1,53 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Localization;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(500)]                                          
+    public partial class BakedSalmonItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Baked Salmon"; } }
+        public override string FriendlyNamePlural               { get { return "Baked Salmon"; } } 
+        public override string Description                      { get { return "You ARE cooking this with Salmon....Right?"; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 8, Fat = 12, Protein = 18, Vitamins = 8};
+        public override float Calories                          { get { return 1200; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(LeavenedBakingSkill), 4)]    
+    public partial class BakedSalmonRecipe : Recipe
+    {
+        public BakedSalmonRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BakedSalmonItem>(),
+               
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<FishFilletItem>(typeof(LeavenedBakingEfficiencySkill), 10, LeavenedBakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<InfusedOilItem>(typeof(LeavenedBakingEfficiencySkill), 5, LeavenedBakingEfficiencySkill.MultiplicativeStrategy),
+                
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(BakedSalmonRecipe), Item.Get<BakedSalmonItem>().UILink(), 3, typeof(LeavenedBakingSpeedSkill)); 
+            this.Initialize("Baked Salmon", typeof(BakedSalmonRecipe));
+            CraftingComponent.AddRecipe(typeof(BakeryOvenObject), this);
+        }
+    }
+}

AutoGen/Food/BurritoSupreme.cs

@@ -0,0 +1,53 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+    [Serialized]
+    [Weight(10)]                                          
+    public partial class BurritoSupremeItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Burrito Supreme"; } }
+        public override string FriendlyNamePlural               { get { return "Burrito Supreme"; } } 
+        public override string Description                      { get { return "Tacos may make you run to the Latrine, but this won't, I hope..."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 17, Fat = 28, Protein = 26, Vitamins = 18};
+        public override float Calories                          { get { return 2000; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+    [RequiresSkill(typeof(MolecularGastronomySkill), 4)]
+    public partial class BurritoSupremeRecipe : Recipe
+    {
+        public BurritoSupremeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BurritoSupremeItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BeanPasteItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<MilkItem>(typeof(MolecularGastronomyEfficiencySkill), 10, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TortillaItem>(typeof(MolecularGastronomyEfficiencySkill), 5, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<ScrapMeatItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(BurritoSupremeRecipe), Item.Get<BurritoSupremeItem>().UILink(), 10, typeof(MolecularGastronomySpeedSkill));
+            this.Initialize("Burrito Supreme", typeof(BurritoSupremeRecipe));
+            CraftingComponent.AddRecipe(typeof(KitchenObject), this);
+        }
+    }
+}

AutoGen/Food/Cake.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(10)]                                          
+    public partial class CakeItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Cake"; } }
+        public override string FriendlyNamePlural               { get { return "Cake"; } } 
+        public override string Description                      { get { return "After all this time, it is STILL a lie."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 19, Fat = 25, Protein = 15, Vitamins = 20};
+        public override float Calories                          { get { return 1800; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+    [RequiresSkill(typeof(MolecularGastronomySkill), 3)]
+    public partial class CakeRecipe : Recipe
+    {
+        public CakeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CakeItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<MilkItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<FlourItem>(typeof(MolecularGastronomyEfficiencySkill), 30, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<YeastItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TallowItem>(typeof(MolecularGastronomyEfficiencySkill), 10, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<SimpleSyrupItem>(typeof(MolecularGastronomyEfficiencySkill), 10, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CakeRecipe), Item.Get<CakeItem>().UILink(), 30, typeof(MolecularGastronomySpeedSkill));
+            this.Initialize("Cake", typeof(CakeRecipe));
+            CraftingComponent.AddRecipe(typeof(KitchenObject), this);
+        }
+    }
+}

AutoGen/Food/ElkTaco.cs

@@ -0,0 +1,52 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(200)]                                          
+    public partial class ElkTacoItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Elk Cookie Taco"; } }
+        public override string Description                      { get { return "A tasty treat made from cookies, corn tortillas and meat.\n\nPart of STC custom ECO tweaks by Atoru"; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 12, Fat = 7, Protein = 8, Vitamins = 13};
+        public override float Calories                          { get { return 650; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(CulinaryArtsSkill), 3)]    
+    public partial class ElkTacoRecipe : Recipe
+    {
+        public ElkTacoRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ElkTacoItem>(),
+               
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ScrapMeatItem>(typeof(CulinaryArtsEfficiencySkill), 30, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TortillaItem>(typeof(CulinaryArtsEfficiencySkill), 5, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<WildMixItem>(typeof(CulinaryArtsEfficiencySkill), 5, CulinaryArtsEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ElkTacoRecipe), Item.Get<ElkTacoItem>().UILink(), 15, typeof(CulinaryArtsSpeedSkill)); 
+            this.Initialize("Elk Cookie Taco", typeof(ElkTacoRecipe));
+            CraftingComponent.AddRecipe(typeof(StoveObject), this);
+        }
+    }
+}

AutoGen/Food/FishFillet.cs

@@ -0,0 +1,51 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(500)]                                          
+    public partial class FishFilletItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "FishFillet"; } }
+        public override string Description                      { get { return "Carefully butchered fish, ready to cook."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 0, Fat = 6, Protein = 4, Vitamins = 0};
+        public override float Calories                          { get { return 600; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(MeatPrepSkill), 3)]    
+    public partial class FishFilletRecipe : Recipe
+    {
+        public FishFilletRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<FishFilletItem>(),
+               
+               
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<RawFishItem>(typeof(MeatPrepEfficiencySkill), 20, MeatPrepEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(FishFilletRecipe), Item.Get<FishFilletItem>().UILink(), 2, typeof(MeatPrepSpeedSkill)); 
+            this.Initialize("Fish Fillet", typeof(FishFilletRecipe));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Food/FishHeadSoup.cs

@@ -0,0 +1,52 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(500)]                                          
+    public partial class FishHeadSoupItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Fish Head Soup"; } }
+        public override string FriendlyNamePlural               { get { return "Fish Head Soup"; } } 
+        public override string Description                      { get { return "Fish heads, fish heads, rolly polly fish heads!"; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 3, Fat = 3, Protein = 12, Vitamins = 6};
+        public override float Calories                          { get { return 800; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(HomeCookingSkill), 3)]    
+    public partial class FishHeadSoupRecipe : Recipe
+    {
+        public FishHeadSoupRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<FishHeadSoupItem>(),
+               
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<RawFishItem>(typeof(HomeCookingEfficiencySkill), 5, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<VegetableStockItem>(typeof(HomeCookingEfficiencySkill), 5, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(FishHeadSoupRecipe), Item.Get<FishHeadSoupItem>().UILink(), 3, typeof(HomeCookingSpeedSkill)); 
+            this.Initialize("Fish Head Soup", typeof(FishHeadSoupRecipe));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Food/FishTaco.cs

@@ -0,0 +1,52 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+
+    [Serialized]
+    [Weight(200)]
+    public partial class FishTacoItem :
+        FoodItem
+    {
+        public override string FriendlyName { get { return "Fish Cookie Taco"; } }
+        public override string Description { get { return "A tasty treat made from cookies, corn tortillas and fish.\n\nPart of STC custom ECO tweaks by Atoru"; } }
+
+        private static Nutrients nutrition = new Nutrients() { Carbs = 13, Fat = 3, Protein = 10, Vitamins = 14 };
+        public override float Calories { get { return 650; } }
+        public override Nutrients Nutrition { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(CulinaryArtsSkill), 4)]
+    public partial class FishTacoRecipe : Recipe
+    {
+        public FishTacoRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<FishTacoItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<RawFishItem>(typeof(CulinaryArtsEfficiencySkill), 30, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TortillaItem>(typeof(CulinaryArtsEfficiencySkill), 5, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<WildMixItem>(typeof(CulinaryArtsEfficiencySkill), 5, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(FishTacoRecipe), Item.Get<FishTacoItem>().UILink(), 15, typeof(CulinaryArtsSpeedSkill));
+            this.Initialize("Fish Cookie Taco", typeof(FishTacoRecipe));
+            CraftingComponent.AddRecipe(typeof(StoveObject), this);
+        }
+    }
+}

AutoGen/Food/Fishsticks.cs

@@ -0,0 +1,52 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(500)]                                          
+    public partial class FishsticksItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Fishsticks"; } }
+        public override string FriendlyNamePlural               { get { return "Fishsticks"; } } 
+        public override string Description                      { get { return "Kanye West still does not understand this."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 10, Fat = 6, Protein = 10, Vitamins = 3};
+        public override float Calories                          { get { return 1000; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(BasicBakingSkill), 2)]    
+    public partial class FishsticksRecipe : Recipe
+    {
+        public FishsticksRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<FishsticksItem>(),
+               
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<FishFilletItem>(typeof(BasicBakingEfficiencySkill), 5, BasicBakingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CornmealItem>(typeof(BasicBakingEfficiencySkill), 20, BasicBakingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(FishsticksRecipe), Item.Get<FishsticksItem>().UILink(), 3, typeof(BasicBakingSpeedSkill)); 
+            this.Initialize("Fishsticks", typeof(FishsticksRecipe));
+            CraftingComponent.AddRecipe(typeof(BakeryOvenObject), this);
+        }
+    }
+}

AutoGen/Food/GrillSalmon.cs

@@ -0,0 +1,53 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(500)]                                          
+    public partial class GrillSalmonItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Grilled Salmon"; } }
+        public override string FriendlyNamePlural               { get { return "Grill Salmon"; } } 
+        public override string Description                      { get { return "You ARE cooking this with Salmon....Right, Pam?"; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 12, Fat = 3, Protein = 4, Vitamins = 8};
+        public override float Calories                          { get { return 1100; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(CampfireCreationsSkill), 4)]    
+    public partial class GrillSalmonRecipe : Recipe
+    {
+        public GrillSalmonRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BakedSalmonItem>(),
+               
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<FishFilletItem>(typeof(CampfireCreationsEfficiencySkill), 10, CampfireCreationsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<OilItem>(typeof(CampfireCreationsEfficiencySkill), 5, CampfireCreationsEfficiencySkill.MultiplicativeStrategy),
+                
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(GrillSalmonRecipe), Item.Get<GrillSalmonItem>().UILink(), 3, typeof(CampfireCreationsSpeedSkill)); 
+            this.Initialize("Grill Salmon", typeof(GrillSalmonRecipe));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Food/Milk.cs

@@ -0,0 +1,51 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(10)]                                          
+    public partial class MilkItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Milk"; } }
+        public override string FriendlyNamePlural               { get { return "Milk"; } } 
+        public override string Description                      { get { return "Milk, although maybe not from an animal."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 3, Fat = 7, Protein = 10, Vitamins = 0};
+        public override float Calories                          { get { return 120; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+    [RequiresSkill(typeof(MolecularGastronomySkill), 2)]
+    public partial class MilkRecipe : Recipe
+    {
+        public MilkRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<MilkItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BeansItem>(typeof(MolecularGastronomyEfficiencySkill), 24, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+               
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(MilkRecipe), Item.Get<MilkItem>().UILink(), 10, typeof(MolecularGastronomySpeedSkill));
+            this.Initialize("Soy Milk", typeof(MilkRecipe));
+            CraftingComponent.AddRecipe(typeof(KitchenObject), this);
+        }
+    }
+}

AutoGen/Food/ModTest.cs

@@ -0,0 +1,55 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(5)]                                          
+    public partial class ModTestItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "ModTest"; } } //Name des Produkts
+        public override string Description                      { get { return "Ich teste neue Nahrungsoptionen"; } } //Beschreibung des Produkts
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 25, Fat = 25, Protein = 25, Vitamins = 25}; //Selbsterklärend
+        public override float Calories                          { get { return 500; } } //Siehe eine Zeile weiter oben
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    //[RequiresSkill(typeof(CulinaryArtsSkill), 2)]   <- Skill muss gelernt sein zum herstellen
+		//Recipe muss Umbenannt werden
+    public partial class ModTestRecipe : Recipe
+    {
+        public ModTestRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ModTestItem>(), //Item das dabei rauskommt brauch einen Namen (auch bei Item.get weiter unten)
+               
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+				// Material das gebraucht wird + Effizienz eines Skills + Anzahl + Anweisung für die Effizienz Berechnung  
+				// new CraftingElement<MilkItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy), 
+            };
+            //default crafting speed 5
+            var craftingspeed = 5.0f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ModTestRecipe), Item.Get<ModTestItem>().UILink(), craftingspeed, typeof(CulinaryArtsSpeedSkill));
+				//Initialize & Serialized muss umbenannt werden
+            this.Initialize("ModTest", typeof(ModTestRecipe));
+			//CraftingComponent.AddRecipe(typeof(KitchenObject), this); Wo das Objekt/Item hergestellt werden soll
+        }
+    }
+}

AutoGen/Food/Oil.cs

@@ -0,0 +1,162 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(100)]                                          
+    [Fuel(4000)]                                              
+    public partial class OilItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Oil"; } }
+        public override string FriendlyNamePlural               { get { return "Oil"; } } 
+        public override string Description                      { get { return "A plant fat extracted for use in cooking."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 0, Fat = 15, Protein = 0, Vitamins = 0};
+        public override float Calories                          { get { return 120; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(MillProcessingSkill), 2)]
+
+    public partial class OilRecipe : Recipe
+    {
+        public OilRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<OilItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CerealGermItem>(typeof(MillProcessingEfficiencySkill), 30, MillProcessingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(OilRecipe), Item.Get<OilItem>().UILink(), 5, typeof(MillProcessingSpeedSkill));
+            this.Initialize("Oil", typeof(OilRecipe));
+            CraftingComponent.AddRecipe(typeof(MillObject), this);
+        }
+    }
+    public partial class OilRecipe2 : Recipe
+    {
+        public OilRecipe2()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<OilItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<HuckleberrySeedItem>(typeof(MillProcessingEfficiencySkill), 40, MillProcessingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(OilRecipe2), Item.Get<OilItem>().UILink(), 5, typeof(MillProcessingSpeedSkill));
+            this.Initialize("Oil from Huckberry Seeds", typeof(OilRecipe2));
+            CraftingComponent.AddRecipe(typeof(MillObject), this);
+        }
+    }
+    public partial class OilRecipe3 : Recipe
+    {
+        public OilRecipe3()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<OilItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<WheatSeedItem>(typeof(MillProcessingEfficiencySkill), 40, MillProcessingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(OilRecipe3), Item.Get<OilItem>().UILink(), 5, typeof(MillProcessingSpeedSkill));
+            this.Initialize("Oil from Wheat Seeds", typeof(OilRecipe3));
+            CraftingComponent.AddRecipe(typeof(MillObject), this);
+        }
+    }
+    public partial class OilRecipe4 : Recipe
+    {
+        public OilRecipe4()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<OilItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CornSeedItem>(typeof(MillProcessingEfficiencySkill), 40, MillProcessingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(OilRecipe4), Item.Get<OilItem>().UILink(), 5, typeof(MillProcessingSpeedSkill));
+            this.Initialize("Oil from Corn Seeds", typeof(OilRecipe4));
+            CraftingComponent.AddRecipe(typeof(MillObject), this);
+        }
+    }
+    public partial class OilRecipe5 : Recipe
+    {
+        public OilRecipe5()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<OilItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BeetSeedItem>(typeof(MillProcessingEfficiencySkill), 40, MillProcessingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(OilRecipe5), Item.Get<OilItem>().UILink(), 5, typeof(MillProcessingSpeedSkill));
+            this.Initialize("Oil from Beet Seeds", typeof(OilRecipe5));
+            CraftingComponent.AddRecipe(typeof(MillObject), this);
+        }
+    }
+    public partial class OilRecipe6 : Recipe
+    {
+        public OilRecipe6()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<OilItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<TomatoSeedItem>(typeof(MillProcessingEfficiencySkill), 40, MillProcessingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(OilRecipe6), Item.Get<OilItem>().UILink(), 5, typeof(MillProcessingSpeedSkill));
+            this.Initialize("Oil from Tomato Seeds", typeof(OilRecipe6));
+            CraftingComponent.AddRecipe(typeof(MillObject), this);
+        }
+    }
+
+    public partial class OilRecipe7 : Recipe
+    {
+        public OilRecipe7()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<OilItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<PricklyPearSeedItem>(typeof(MillProcessingEfficiencySkill), 40, MillProcessingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(OilRecipe7), Item.Get<OilItem>().UILink(), 5, typeof(MillProcessingSpeedSkill));
+            this.Initialize("Oil from Prickly Pear Seed", typeof(OilRecipe7));
+            CraftingComponent.AddRecipe(typeof(MillObject), this);
+        }
+    }
+}

AutoGen/Food/RicePilaf.cs

@@ -0,0 +1,52 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(10)]                                          
+    public partial class RicePilafItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Rice Pilaf"; } }
+        public override string FriendlyNamePlural               { get { return "Rice Pilaf"; } } 
+        public override string Description                      { get { return "Pilaf is a dish in which rice is cooked in a seasoned broth."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 17, Fat = 13, Protein = 20, Vitamins = 10};
+        public override float Calories                          { get { return 650; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+    [RequiresSkill(typeof(MolecularGastronomySkill), 2)]
+    public partial class RicePilafRecipe : Recipe
+    {
+        public RicePilafRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<RicePilafItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<RiceItem>(typeof(MolecularGastronomyEfficiencySkill), 30, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<VegetableMedleyItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<MeatStockItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(RicePilafRecipe), Item.Get<RicePilafItem>().UILink(), 10, typeof(MolecularGastronomySpeedSkill));
+            this.Initialize("Rice Pilaf", typeof(RicePilafRecipe));
+            CraftingComponent.AddRecipe(typeof(KitchenObject), this);
+        }
+    }
+}

AutoGen/Food/RicePudding.cs

@@ -0,0 +1,51 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+    [Serialized]
+    [Weight(10)]                                          
+    public partial class RicePuddingItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Rice Pudding"; } }
+        public override string FriendlyNamePlural               { get { return "Rice Pudding"; } } 
+        public override string Description                      { get { return "Using Rice and Milk, you made Rice Pudding, not some kid's cereal."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 21, Fat = 10, Protein = 17, Vitamins = 10};
+        public override float Calories                          { get { return 500; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+    [RequiresSkill(typeof(MolecularGastronomySkill), 1)]
+    public partial class RicePuddingRecipe : Recipe
+    {
+        public RicePuddingRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<RicePuddingItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<RiceItem>(typeof(MolecularGastronomyEfficiencySkill), 20, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<MilkItem>(typeof(MolecularGastronomyEfficiencySkill), 10, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(RicePuddingRecipe), Item.Get<RicePuddingItem>().UILink(), 5, typeof(MolecularGastronomySpeedSkill));
+            this.Initialize("Rice Pudding", typeof(RicePuddingRecipe));
+            CraftingComponent.AddRecipe(typeof(KitchenObject), this);
+        }
+    }
+}

AutoGen/Food/SpicyClamChowder.cs

@@ -0,0 +1,52 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+    [Serialized]
+    [Weight(600)]
+    public partial class SpicyClamChowderItem :
+        FoodItem
+    {
+        public override string FriendlyName { get { return "Spicy Clam Chowder"; } }
+        public override string Description { get { return "Spicy!!(also Clam and Chowder)"; } }
+
+        private static Nutrients nutrition = new Nutrients() { Carbs = 10, Fat = 14, Protein = 15, Vitamins = 18 };
+        public override float Calories { get { return 1500; } }
+        public override Nutrients Nutrition { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(CulinaryArtsSkill), 4)]
+    public partial class SpicyClamChowderRecipe : Recipe
+    {
+        public SpicyClamChowderRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SpicyClamChowderItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<RawFishItem>(typeof(CulinaryArtsEfficiencySkill), 20, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<VegetableStockItem>(typeof(CulinaryArtsEfficiencySkill), 10, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CamasMashItem>(typeof(CulinaryArtsEfficiencySkill), 5, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<FireweedShootsItem>(typeof(CulinaryArtsEfficiencySkill), 10, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(SpicyClamChowderRecipe), Item.Get<SpicyClamChowderItem>().UILink(), 10, typeof(CulinaryArtsSpeedSkill));
+            this.Initialize("Spicy Clam Chowder", typeof(SpicyClamChowderRecipe));
+            CraftingComponent.AddRecipe(typeof(KitchenObject), this);
+        }
+    }
+}

AutoGen/Food/Tallow.cs

@@ -0,0 +1,33 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(20)]                                          
+    [Fuel(10000)]                                              
+    public partial class TallowItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Tallow"; } }
+        public override string FriendlyNamePlural               { get { return "Tallow"; } } 
+        public override string Description                      { get { return "Rendered animal fat useful for more than just cooking."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 0, Fat = 20, Protein = 0, Vitamins = 0};
+        public override float Calories                          { get { return 200; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+}

AutoGen/Food/Tortilla.cs

@@ -0,0 +1,57 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    
+    [Serialized]
+    [Weight(100)]                                          
+    public partial class TortillaItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Cookie"; } }
+        public override string Description                      { get { return "Just the perfect food to start a day!\n\nPart of STC custom ECO tweaks by Atoru"; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 25, Fat = 1, Protein = 25, Vitamins = 35};
+        public override float Calories                          { get { return 666; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(CulinaryArtsSkill), 2)]    
+    public partial class TortillaRecipe : Recipe
+    {
+        public TortillaRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<TortillaItem>(),
+               
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CornmealItem>(typeof(CulinaryArtsEfficiencySkill), 3, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<SugarItem>(typeof(CulinaryArtsEfficiencySkill), 2, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<MilkItem>(typeof(MolecularGastronomyEfficiencySkill), 1, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<FlourItem>(typeof(MolecularGastronomyEfficiencySkill), 1, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<YeastItem>(typeof(MolecularGastronomyEfficiencySkill), 1, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<SimpleSyrupItem>(typeof(MolecularGastronomyEfficiencySkill), 2, MolecularGastronomyEfficiencySkill.MultiplicativeStrategy),
+            };
+            //default crafting speed 5
+            var craftingspeed = 2.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(TortillaRecipe), Item.Get<TortillaItem>().UILink(), craftingspeed, typeof(CulinaryArtsSpeedSkill)); 
+            this.Initialize("Cookie", typeof(TortillaRecipe));
+            CraftingComponent.AddRecipe(typeof(KitchenObject), this);
+        }
+    }
+}

AutoGen/Food/TunaCasserole.cs

@@ -0,0 +1,52 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+    [Serialized]
+    [Weight(500)]                                          
+    public partial class TunaCasseroleItem :
+        FoodItem            
+    {
+        public override string FriendlyName                     { get { return "Tuna Casserole"; } }
+        public override string FriendlyNamePlural               { get { return "Tuna Casserole"; } } 
+        public override string Description                      { get { return "A fishy smelling casserole."; } }
+
+        private static Nutrients nutrition = new Nutrients()    { Carbs = 15, Fat = 10, Protein = 10, Vitamins = 1};
+        public override float Calories                          { get { return 1250; } }
+        public override Nutrients Nutrition                     { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(CulinaryArtsSkill), 3)]    
+    public partial class TunaCasseroleRecipe : Recipe
+    {
+        public TunaCasseroleRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<TunaCasseroleItem>(),
+               
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<FlourItem>(typeof(CulinaryArtsEfficiencySkill), 5, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<RawFishItem>(typeof(CulinaryArtsEfficiencySkill), 20, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<WildMixItem>(typeof(CulinaryArtsEfficiencySkill), 20, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(TunaCasseroleRecipe), Item.Get<TunaCasseroleItem>().UILink(), 3, typeof(CulinaryArtsSpeedSkill)); 
+            this.Initialize("Tuna Casserole", typeof(TunaCasseroleRecipe));
+            CraftingComponent.AddRecipe(typeof(StoveObject), this);
+        }
+    }
+}

AutoGen/Food/TunaSalad.cs

@@ -0,0 +1,52 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(500)]
+    public partial class TunaSaladItem :
+        FoodItem
+    {
+        public override string FriendlyName { get { return "Tuna Salad"; } }
+        public override string FriendlyNamePlural { get { return "Tuna Salad"; } }
+        public override string Description { get { return "Don't be a Tuna head, eat more green!"; } }
+
+        private static Nutrients nutrition = new Nutrients() { Carbs = 3, Fat = 3, Protein = 8, Vitamins = 8 };
+        public override float Calories { get { return 600; } }
+        public override Nutrients Nutrition { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(HomeCookingSkill), 4)]
+    public partial class TunaSaladRecipe : Recipe
+    {
+        public TunaSaladRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<TunaSaladItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<RawFishItem>(typeof(HomeCookingEfficiencySkill), 10, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<OilItem>(typeof(HomeCookingEfficiencySkill), 5, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(TunaSaladRecipe), Item.Get<TunaSaladItem>().UILink(), 3, typeof(HomeCookingSpeedSkill));
+            this.Initialize("Tuna Salad", typeof(TunaSaladRecipe));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Food/TunafishSandwich.cs

@@ -0,0 +1,53 @@
+namespace Eco.Mods.TechTree
+{
+    using System.Collections.Generic;
+    using System.Linq;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Mods.TechTree;
+    using Eco.Shared.Items;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.Shared.View;
+    using Eco.Shared.Localization;
+
+    [Serialized]
+    [Weight(600)]
+    public partial class TunafishSandwichItem :
+        FoodItem
+    {
+        public override string FriendlyName { get { return "Tunafish Sandwich"; } }
+        public override string Description { get { return "Sure beats Hucklebutter and Jelly Sandwiches!"; } }
+
+        private static Nutrients nutrition = new Nutrients() { Carbs = 10, Fat = 14, Protein = 20, Vitamins = 21 };
+        public override float Calories { get { return 1200; } }
+        public override Nutrients Nutrition { get { return nutrition; } }
+    }
+
+    [RequiresSkill(typeof(CulinaryArtsSkill), 1)]
+    public partial class TunafishSandwichRecipe : Recipe
+    {
+        public TunafishSandwichRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<TunafishSandwichItem>(),
+
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BreadItem>(typeof(CulinaryArtsEfficiencySkill), 5, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TunaSaladItem>(typeof(CulinaryArtsEfficiencySkill), 5, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<WildMixItem>(typeof(CulinaryArtsEfficiencySkill), 5, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TomatoItem>(typeof(CulinaryArtsEfficiencySkill), 10, CulinaryArtsEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(TunafishSandwichRecipe), Item.Get<TunafishSandwichItem>().UILink(), 10, typeof(CulinaryArtsSpeedSkill));
+            this.Initialize("Tunafish Sandwich", typeof(TunafishSandwichRecipe));
+            CraftingComponent.AddRecipe(typeof(KitchenObject), this);
+        }
+    }
+}

AutoGen/Item/AsphaltRamp.cs

@@ -0,0 +1,51 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(RoadConstructionSkill), 3)]   
+    public partial class AsphaltRampRecipe : Recipe
+    {
+        public AsphaltRampRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<AsphaltRampItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ConcreteItem>(typeof(RoadConstructionEfficiencySkill), 3, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<StoneItem>(typeof(RoadConstructionEfficiencySkill), 3, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<DirtItem>(typeof(RoadConstructionEfficiencySkill), 3, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(AsphaltRampRecipe), Item.Get<AsphaltRampItem>().UILink(), 5, typeof(RoadConstructionSkill));    
+            this.Initialize("Asphalt Ramp", typeof(AsphaltRampRecipe));
+
+            CraftingComponent.AddRecipe(typeof(WainwrightTableObject), this);
+        }
+    }
+
+    [Serialized]
+    [Constructed]
+    [Road(1)]                                          
+    [RequiresSkill(typeof(RoadConstructionEfficiencySkill), 3)]   
+    public partial class AsphaltRampBlock :
+        Block           
+    { }
+
+}

AutoGen/Item/AsphaltRampUpgrade.cs

@@ -0,0 +1,51 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(RoadConstructionSkill), 3)]   
+    public partial class AsphaltRampUpgradeRecipe : Recipe
+    {
+        public AsphaltRampUpgradeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<AsphaltRampItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ConcreteItem>(typeof(RoadConstructionEfficiencySkill), 3, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<StoneRampItem>(typeof(RoadConstructionEfficiencySkill), 3, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<DirtItem>(typeof(RoadConstructionEfficiencySkill), 3, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(AsphaltRampUpgradeRecipe), Item.Get<AsphaltRampItem>().UILink(), 5, typeof(RoadConstructionSkill));    
+            this.Initialize("Asphalt Ramp Upgrade", typeof(AsphaltRampUpgradeRecipe));
+
+            CraftingComponent.AddRecipe(typeof(WainwrightTableObject), this);
+        }
+    }
+
+    [Serialized]
+    [Constructed]
+    [Road(1)]                                          
+    [RequiresSkill(typeof(RoadConstructionEfficiencySkill), 3)]   
+    public partial class AsphaltRampUpgradeBlock :
+        Block           
+    { }
+
+}

AutoGen/Item/AsphaltRoad.cs

@@ -0,0 +1,64 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(RoadConstructionSkill), 3)]   
+    public partial class AsphaltRoadRecipe : Recipe
+    {
+        public AsphaltRoadRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<AsphaltRoadItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ConcreteItem>(typeof(RoadConstructionEfficiencySkill), 1, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<StoneItem>(typeof(RoadConstructionEfficiencySkill), 1, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<DirtItem>(typeof(RoadConstructionEfficiencySkill), 1, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(AsphaltRoadRecipe), Item.Get<AsphaltRoadItem>().UILink(), 1, typeof(RoadConstructionSkill));    
+            this.Initialize("Asphalt Road", typeof(AsphaltRoadRecipe));
+
+            CraftingComponent.AddRecipe(typeof(WainwrightTableObject), this);
+        }
+    }
+
+    [Serialized]
+    [Solid, Wall, Constructed]
+    [Road(1)]                                          
+    [UsesRamp(typeof(AsphaltRoadWorldObjectBlock))]              
+    [RequiresSkill(typeof(RoadConstructionEfficiencySkill), 3)]   
+    public partial class AsphaltRoadBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(10)]                                       
+    [Weight(10000)]      
+    [MakesRoads]                                            
+    public partial class AsphaltRoadItem :
+    RoadItem<AsphaltRoadBlock>
+    {
+        public override string FriendlyName { get { return "Asphalt Road"; } }
+        public override string Description { get { return "A paved surface constructed with asphalt and concrete. It's durable and extremely efficient for any wheeled vehicle."; } }
+
+    }
+
+}

AutoGen/Item/AsphaltRoadUpgrade.cs

@@ -0,0 +1,64 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(RoadConstructionSkill), 3)]   
+    public partial class AsphaltRoadUpgradeRecipe : Recipe
+    {
+        public AsphaltRoadUpgradeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<AsphaltRoadItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ConcreteItem>(typeof(RoadConstructionEfficiencySkill), 1, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<StoneRoadItem>(typeof(RoadConstructionEfficiencySkill), 1, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<DirtItem>(typeof(RoadConstructionEfficiencySkill), 1, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(AsphaltRoadUpgradeRecipe), Item.Get<AsphaltRoadUpgradeItem>().UILink(), 1, typeof(RoadConstructionSkill));    
+            this.Initialize("Asphalt Road", typeof(AsphaltRoadUpgradeRecipe));
+
+            CraftingComponent.AddRecipe(typeof(WainwrightTableObject), this);
+        }
+    }
+
+    [Serialized]
+    [Solid, Wall, Constructed]
+    [Road(1)]                                          
+    [UsesRamp(typeof(AsphaltRoadWorldObjectBlock))]              
+    [RequiresSkill(typeof(RoadConstructionEfficiencySkill), 3)]   
+    public partial class AsphaltRoadUpgradeBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(10)]                                       
+    [Weight(10000)]      
+    [MakesRoads]                                            
+    public partial class AsphaltRoadUpgradeItem :
+    RoadItem<AsphaltRoadBlock>
+    {
+        public override string FriendlyName { get { return "Asphalt Road"; } }
+        public override string Description { get { return "A paved surface constructed with asphalt and concrete. It's durable and extremely efficient for any wheeled vehicle."; } }
+
+    }
+
+}

AutoGen/Item/Barrel.cs

@@ -0,0 +1,63 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+    using Eco.Gameplay.Pipes.LiquidComponents; 
+
+    [RequiresSkill(typeof(PetrolRefiningSkill), 0)]   
+    public partial class BarrelRecipe : Recipe
+    {
+        public BarrelRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BarrelItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(PetrolRefiningEfficiencySkill), 5, PetrolRefiningEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CopperIngotItem>(typeof(PetrolRefiningEfficiencySkill), 3, PetrolRefiningEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<LumberItem>(typeof(PetrolRefiningEfficiencySkill), 6, PetrolRefiningEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(BarrelRecipe), Item.Get<BarrelItem>().UILink(), 1, typeof(PetrolRefiningSpeedSkill));    
+            this.Initialize("Barrel", typeof(BarrelRecipe));
+
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+
+    [Serialized]
+    [Solid]
+    [RequiresSkill(typeof(PetrolRefiningEfficiencySkill), 0)]   
+    public partial class BarrelBlock :
+        PickupableBlock     
+    { }
+
+    [Serialized]
+    [MaxStackSize(10)]                                       
+    [Weight(2000)]      
+    [Currency]              
+    public partial class BarrelItem :
+    BlockItem<BarrelBlock>
+    {
+        public override string FriendlyName { get { return "Barrel"; } }
+        public override string Description { get { return "Expertly crafted from smoothed boards and metal bands, this can carry a variety of substances."; } }
+
+    }
+
+}

AutoGen/Item/Biodiesel.cs

@@ -0,0 +1,63 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+    using Eco.Gameplay.Pipes.LiquidComponents; 
+
+    [RequiresSkill(typeof(PetrolRefiningSkill), 2)]   
+    public partial class BiodieselRecipe : Recipe
+    {
+        public BiodieselRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BiodieselItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<TallowItem>(typeof(PetrolRefiningEfficiencySkill), 10, PetrolRefiningEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(BiodieselRecipe), Item.Get<BiodieselItem>().UILink(), 2, typeof(PetrolRefiningSpeedSkill));    
+            this.Initialize("Biodiesel", typeof(BiodieselRecipe));
+
+            CraftingComponent.AddRecipe(typeof(OilRefineryObject), this);
+        }
+    }
+
+    [Serialized]
+    [Solid]
+    [RequiresSkill(typeof(PetrolRefiningEfficiencySkill), 2)]   
+    public partial class BiodieselBlock :
+        PickupableBlock     
+    { }
+
+    [Serialized]
+    [MaxStackSize(10)]                                       
+    [Weight(30000)]      
+    [Fuel(60000)]          
+    [Currency]              
+    public partial class BiodieselItem :
+    BlockItem<BiodieselBlock>
+    {
+        public override string FriendlyName { get { return "Biodiesel"; } }
+        public override string FriendlyNamePlural { get { return "Biodiesel"; } } 
+        public override string Description { get { return "A vegetable or animal fat-based diesel fuel."; } }
+
+    }
+
+}

AutoGen/Item/Board.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(WoodworkingSkill), 0)]   
+    public partial class BoardRecipe : Recipe
+    {
+        public BoardRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<BoardItem>(2),  
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(WoodworkingEfficiencySkill), 4, WoodworkingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(BoardRecipe), Item.Get<BoardItem>().UILink(), 0.5f, typeof(WoodworkingSpeedSkill));    
+            this.Initialize("Board", typeof(BoardRecipe));
+
+            CraftingComponent.AddRecipe(typeof(CarpentryTableObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(500)]      
+    [Fuel(2500)]          
+    [Currency]              
+    public partial class BoardItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Board"; } }
+        public override string Description { get { return "Can be used in simple crafts, or used to create workbenches."; } }
+
+    }
+
+}

AutoGen/Item/Charcoal.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(AdvancedSmeltingSkill), 1)]   
+    public partial class CharcoalRecipe : Recipe
+    {
+        public CharcoalRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CharcoalItem>(2),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LumberItem>(typeof(AlloySmeltingEfficiencySkill), 10, AlloySmeltingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CharcoalRecipe), Item.Get<CharcoalItem>().UILink(), 1, typeof(AlloySmeltingEfficiencySkill));    
+            this.Initialize("Charcoal", typeof(CharcoalRecipe));
+
+            CraftingComponent.AddRecipe(typeof(BlastFurnaceObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(1000)]      
+    [Fuel(25000)]          
+    [Currency]              
+    public partial class CharcoalItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Charcoal"; } }
+        public override string Description { get { return "A black residue, consisting of carbon and any remaining ash."; } }
+
+    }
+
+}

AutoGen/Item/Coal.cs

@@ -0,0 +1,56 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+
+    [Serialized]
+    [Minable, Solid,Wall]
+    public partial class CoalBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(20)]                           
+    [Weight(5000)]      
+    [Fuel(20000)]          
+    [ResourcePile]                                          
+    [Currency]              
+    public partial class CoalItem :
+    BlockItem<CoalBlock>
+    {
+        public override string FriendlyName { get { return "Coal"; } }
+        public override string FriendlyNamePlural { get { return "Coal"; } } 
+        public override string Description { get { return "A combustible mineral which when used as a fuel provides lots of energy but generates lots of pollution."; } }
+
+        public override bool CanStickToWalls { get { return false; } }  
+
+        private static Type[] blockTypes = new Type[] {
+            typeof(CoalStacked1Block),
+            typeof(CoalStacked2Block),
+            typeof(CoalStacked3Block),
+            typeof(CoalStacked4Block)
+        };
+        public override Type[] BlockTypes { get { return blockTypes; } }
+    }
+
+    [Serialized, Solid] public class CoalStacked1Block : PickupableBlock { }
+    [Serialized, Solid] public class CoalStacked2Block : PickupableBlock { }
+    [Serialized, Solid] public class CoalStacked3Block : PickupableBlock { }
+    [Serialized, Solid,Wall] public class CoalStacked4Block : PickupableBlock { } //Only a wall if it's all 4 Coal
+}

AutoGen/Item/CombustionEngine.cs

@@ -0,0 +1,56 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(MechanicalEngineeringSkill), 3)]   
+    public partial class CombustionEngineRecipe : Recipe
+    {
+        public CombustionEngineRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CombustionEngineItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<PistonItem>(typeof(MechanicsAssemblyEfficiencySkill), 10, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<GearboxItem>(typeof(MechanicsAssemblyEfficiencySkill), 5, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<IronIngotItem>(typeof(MechanicsAssemblyEfficiencySkill), 20, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<SteelItem>(typeof(MechanicsAssemblyEfficiencySkill), 5, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CombustionEngineRecipe), Item.Get<CombustionEngineItem>().UILink(), 5, typeof(MechanicsAssemblySpeedSkill));    
+            this.Initialize("Combustion Engine", typeof(CombustionEngineRecipe));
+
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(1000)]      
+    [Currency]              
+    public partial class CombustionEngineItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Combustion Engine"; } }
+        public override string Description { get { return "An engine that generates power by combustion of fuel."; } }
+
+    }
+
+}

AutoGen/Item/Concrete.cs

@@ -0,0 +1,55 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(CementSkill), 1)]   
+    public partial class ConcreteRecipe : Recipe
+    {
+        public ConcreteRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ConcreteItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(CementProductionEfficiencySkill), 40, CementProductionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<WoodPulpItem>(typeof(CementProductionEfficiencySkill), 25, CementProductionEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ConcreteRecipe), Item.Get<ConcreteItem>().UILink(), 2, typeof(CementProductionSpeedSkill));    
+            this.Initialize("Concrete", typeof(ConcreteRecipe));
+
+            CraftingComponent.AddRecipe(typeof(CementKilnObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(10000)]      
+    [Currency]              
+    public partial class ConcreteItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Concrete"; } }
+        public override string FriendlyNamePlural { get { return "Concrete"; } } 
+        public override string Description { get { return "A very strong building material made from cement and an aggregate like crushed stone."; } }
+
+    }
+
+}

AutoGen/Item/CopperIngot.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(BasicSmeltingSkill), 1)]   
+    public partial class CopperIngotRecipe : Recipe
+    {
+        public CopperIngotRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CopperIngotItem>(),          
+            new CraftingElement<TailingsItem>(3),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CopperOreItem>(typeof(BasicSmeltingEfficiencySkill), 25, BasicSmeltingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CopperIngotRecipe), Item.Get<CopperIngotItem>().UILink(), 2, typeof(BasicSmeltingSpeedSkill));    
+            this.Initialize("Copper Ingot", typeof(CopperIngotRecipe));
+
+            CraftingComponent.AddRecipe(typeof(BloomeryObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(4000)]      
+    [Currency]              
+    public partial class CopperIngotItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Copper Ingot"; } }
+        public override string Description { get { return "A hefty block of copper."; } }
+
+    }
+
+}

AutoGen/Item/CopperOre.cs

@@ -0,0 +1,55 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+
+    [Serialized]
+    [Minable, Solid,Wall]
+    public partial class CopperOreBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(20)]                           
+    [Weight(10000)]      
+    [ResourcePile]                                          
+    [Currency]              
+    public partial class CopperOreItem :
+    BlockItem<CopperOreBlock>
+    {
+        public override string FriendlyName { get { return "Copper Ore"; } }
+        public override string FriendlyNamePlural { get { return "Copper Ore"; } } 
+        public override string Description { get { return "Unrefined ore with traces of copper."; } }
+
+        public override bool CanStickToWalls { get { return false; } }  
+
+        private static Type[] blockTypes = new Type[] {
+            typeof(CopperOreStacked1Block),
+            typeof(CopperOreStacked2Block),
+            typeof(CopperOreStacked3Block),
+            typeof(CopperOreStacked4Block)
+        };
+        public override Type[] BlockTypes { get { return blockTypes; } }
+    }
+
+    [Serialized, Solid] public class CopperOreStacked1Block : PickupableBlock { }
+    [Serialized, Solid] public class CopperOreStacked2Block : PickupableBlock { }
+    [Serialized, Solid] public class CopperOreStacked3Block : PickupableBlock { }
+    [Serialized, Solid,Wall] public class CopperOreStacked4Block : PickupableBlock { } //Only a wall if it's all 4 CopperOre
+}

AutoGen/Item/CopperWiring.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(MechanicalEngineeringSkill), 2)]   
+    public partial class CopperWiringRecipe : Recipe
+    {
+        public CopperWiringRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<CopperWiringItem>(4),  
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CopperIngotItem>(typeof(MechanicsComponentsEfficiencySkill), 5, MechanicsComponentsEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CopperWiringRecipe), Item.Get<CopperWiringItem>().UILink(), 2, typeof(MechanicsComponentsSpeedSkill));    
+            this.Initialize("Copper Wiring", typeof(CopperWiringRecipe));
+
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(200)]      
+    [Currency]              
+    public partial class CopperWiringItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Copper Wiring"; } }
+        public override string FriendlyNamePlural { get { return "Copper Wiring"; } } 
+        public override string Description { get { return "A length of conductive wire useful for a variety of purposes."; } }
+
+    }
+
+}

AutoGen/Item/Gearbox.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(MechanicalEngineeringSkill), 1)]   
+    public partial class GearboxRecipe : Recipe
+    {
+        public GearboxRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<GearboxItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(typeof(MechanicsAssemblyEfficiencySkill), 7, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<GearItem>(typeof(MechanicsAssemblyEfficiencySkill), 5, MechanicsAssemblyEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(GearboxRecipe), Item.Get<GearboxItem>().UILink(), 2, typeof(MechanicsAssemblySpeedSkill));    
+            this.Initialize("Gearbox", typeof(GearboxRecipe));
+
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(1000)]      
+    [Currency]              
+    public partial class GearboxItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Gearbox"; } }
+        public override string Description { get { return "Provides speed and torque conversions from a rotating power source to another device"; } }
+
+    }
+
+}

AutoGen/Item/GoldIngot.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(BasicSmeltingSkill), 3)]   
+    public partial class GoldIngotRecipe : Recipe
+    {
+        public GoldIngotRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<GoldIngotItem>(),          
+            new CraftingElement<TailingsItem>(3),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<GoldOreItem>(typeof(BasicSmeltingEfficiencySkill), 25, BasicSmeltingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(GoldIngotRecipe), Item.Get<GoldIngotItem>().UILink(), 2, typeof(BasicSmeltingSpeedSkill));    
+            this.Initialize("Gold Ingot", typeof(GoldIngotRecipe));
+
+            CraftingComponent.AddRecipe(typeof(BloomeryObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(4000)]      
+    [Currency]              
+    public partial class GoldIngotItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Gold Ingot"; } }
+        public override string Description { get { return "A shiny, refined gold ingot."; } }
+
+    }
+
+}

AutoGen/Item/GoldOre.cs

@@ -0,0 +1,55 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+
+    [Serialized]
+    [Minable, Solid,Wall]
+    public partial class GoldOreBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(20)]                           
+    [Weight(10000)]      
+    [ResourcePile]                                          
+    [Currency]              
+    public partial class GoldOreItem :
+    BlockItem<GoldOreBlock>
+    {
+        public override string FriendlyName { get { return "Gold Ore"; } }
+        public override string FriendlyNamePlural { get { return "Gold Ore"; } } 
+        public override string Description { get { return "Unrefined ore with traces of gold."; } }
+
+        public override bool CanStickToWalls { get { return false; } }  
+
+        private static Type[] blockTypes = new Type[] {
+            typeof(GoldOreStacked1Block),
+            typeof(GoldOreStacked2Block),
+            typeof(GoldOreStacked3Block),
+            typeof(GoldOreStacked4Block)
+        };
+        public override Type[] BlockTypes { get { return blockTypes; } }
+    }
+
+    [Serialized, Solid] public class GoldOreStacked1Block : PickupableBlock { }
+    [Serialized, Solid] public class GoldOreStacked2Block : PickupableBlock { }
+    [Serialized, Solid] public class GoldOreStacked3Block : PickupableBlock { }
+    [Serialized, Solid,Wall] public class GoldOreStacked4Block : PickupableBlock { } //Only a wall if it's all 4 GoldOre
+}

AutoGen/Item/HewnLog.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.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(BasicCraftingSkill), 0)]   
+    public partial class HewnLogRecipe : Recipe
+    {
+        public HewnLogRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<HewnLogItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(HewnLogProcessingEfficiencySkill), 2, HewnLogProcessingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(HewnLogRecipe), Item.Get<HewnLogItem>().UILink(), 0.2f, typeof(HewnLogProcessingSpeedSkill));    
+            this.Initialize("Hewn Log", typeof(HewnLogRecipe));
+
+            CraftingComponent.AddRecipe(typeof(WorkbenchObject), this);
+        }
+    }
+
+    [Serialized]
+    [Solid, Wall, Constructed,BuildRoomMaterialOption]
+    [Tier(1)]                                          
+    [RequiresSkill(typeof(HewnLogProcessingEfficiencySkill), 0)]   
+    public partial class HewnLogBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(20)]                           
+    [Weight(10000)]  
+    [Fuel(2000)]    
+    [Currency]              
+    public partial class HewnLogItem :
+    BlockItem<HewnLogBlock>
+    {
+        public override string FriendlyName { get { return "Hewn Log"; } }
+        public override string Description { get { return "A log hewn and shaped to be a building material."; } }
+
+
+        private static Type[] blockTypes = new Type[] {
+            typeof(HewnLogStacked1Block),
+            typeof(HewnLogStacked2Block),
+            typeof(HewnLogStacked3Block)
+        };
+        public override Type[] BlockTypes { get { return blockTypes; } }
+    }
+
+    [Serialized, Solid] public class HewnLogStacked1Block : PickupableBlock { }
+    [Serialized, Solid] public class HewnLogStacked2Block : PickupableBlock { }
+    [Serialized, Solid,Wall] public class HewnLogStacked3Block : PickupableBlock { } //Only a wall if it's all 4 HewnLog
+}

AutoGen/Item/IronIngot.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(BasicSmeltingSkill), 2)]   
+    public partial class IronIngotRecipe : Recipe
+    {
+        public IronIngotRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(),          
+            new CraftingElement<TailingsItem>(3),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronOreItem>(typeof(BasicSmeltingEfficiencySkill), 25, BasicSmeltingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(IronIngotRecipe), Item.Get<IronIngotItem>().UILink(), 2, typeof(BasicSmeltingSpeedSkill));    
+            this.Initialize("Iron Ingot", typeof(IronIngotRecipe));
+
+            CraftingComponent.AddRecipe(typeof(BloomeryObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(4000)]      
+    [Currency]              
+    public partial class IronIngotItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Iron Ingot"; } }
+        public override string Description { get { return "Refined block of iron."; } }
+
+    }
+
+}

AutoGen/Item/IronOre.cs

@@ -0,0 +1,55 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+
+    [Serialized]
+    [Minable, Solid,Wall]
+    public partial class IronOreBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(20)]                           
+    [Weight(10000)]      
+    [ResourcePile]                                          
+    [Currency]              
+    public partial class IronOreItem :
+    BlockItem<IronOreBlock>
+    {
+        public override string FriendlyName { get { return "Iron Ore"; } }
+        public override string FriendlyNamePlural { get { return "Iron Ore"; } } 
+        public override string Description { get { return "Unrefined ore with traces of iron."; } }
+
+        public override bool CanStickToWalls { get { return false; } }  
+
+        private static Type[] blockTypes = new Type[] {
+            typeof(IronOreStacked1Block),
+            typeof(IronOreStacked2Block),
+            typeof(IronOreStacked3Block),
+            typeof(IronOreStacked4Block)
+        };
+        public override Type[] BlockTypes { get { return blockTypes; } }
+    }
+
+    [Serialized, Solid] public class IronOreStacked1Block : PickupableBlock { }
+    [Serialized, Solid] public class IronOreStacked2Block : PickupableBlock { }
+    [Serialized, Solid] public class IronOreStacked3Block : PickupableBlock { }
+    [Serialized, Solid,Wall] public class IronOreStacked4Block : PickupableBlock { } //Only a wall if it's all 4 IronOre
+}

AutoGen/Item/Log.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+
+    [Serialized]
+    [Solid, Wall, Constructed]
+    public partial class LogBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(20)]                           
+    [Weight(5000)]      
+    [Fuel(2000)]          
+    [ResourcePile]                                          
+    [Currency]              
+    public partial class LogItem :
+    BlockItem<LogBlock>
+    {
+        public override string FriendlyName { get { return "Log"; } }
+        public override string Description { get { return "A stack of logs."; } }
+
+
+        private static Type[] blockTypes = new Type[] {
+            typeof(LogStacked1Block),
+            typeof(LogStacked2Block),
+            typeof(LogStacked3Block),
+            typeof(LogStacked4Block)
+        };
+        public override Type[] BlockTypes { get { return blockTypes; } }
+    }
+
+    [Serialized, Solid] public class LogStacked1Block : PickupableBlock { }
+    [Serialized, Solid] public class LogStacked2Block : PickupableBlock { }
+    [Serialized, Solid] public class LogStacked3Block : PickupableBlock { }
+    [Serialized, Solid,Wall] public class LogStacked4Block : PickupableBlock { } //Only a wall if it's all 4 Log
+}

AutoGen/Item/Lumber.cs

@@ -0,0 +1,76 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(LumberSkill), 1)]   
+    public partial class LumberRecipe : Recipe
+    {
+        public LumberRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<LumberItem>(),          
+            new CraftingElement<WoodPulpItem>(3),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<LogItem>(typeof(LumberProcessingEfficiencySkill), 4, LumberProcessingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BoardItem>(typeof(LumberProcessingEfficiencySkill), 5, LumberProcessingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(LumberRecipe), Item.Get<LumberItem>().UILink(), 1, typeof(LumberProcessingSpeedSkill));    
+            this.Initialize("Lumber", typeof(LumberRecipe));
+
+            CraftingComponent.AddRecipe(typeof(SawmillObject), this);
+        }
+    }
+
+    [Serialized]
+    [Solid, Wall, Constructed,BuildRoomMaterialOption]
+    [Tier(2)]                                          
+    [RequiresSkill(typeof(LumberProcessingEfficiencySkill), 1)]   
+    public partial class LumberBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(20)]                           
+    [Weight(10000)]      
+    [Fuel(4000)]          
+    [Currency]              
+    public partial class LumberItem :
+    BlockItem<LumberBlock>
+    {
+        public override string FriendlyName { get { return "Lumber"; } }
+        public override string Description { get { return "Can be fashioned into various usable equipment."; } }
+
+
+        private static Type[] blockTypes = new Type[] {
+            typeof(LumberStacked1Block),
+            typeof(LumberStacked2Block),
+            typeof(LumberStacked3Block),
+            typeof(LumberStacked4Block)
+        };
+        public override Type[] BlockTypes { get { return blockTypes; } }
+    }
+
+    [Serialized, Solid] public class LumberStacked1Block : PickupableBlock { }
+    [Serialized, Solid] public class LumberStacked2Block : PickupableBlock { }
+    [Serialized, Solid] public class LumberStacked3Block : PickupableBlock { }
+    [Serialized, Solid,Wall] public class LumberStacked4Block : PickupableBlock { } //Only a wall if it's all 4 Lumber
+}

AutoGen/Item/MortaredStone.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.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(MortarProductionSkill), 0)]   
+    public partial class MortaredStoneRecipe : Recipe
+    {
+        public MortaredStoneRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<MortaredStoneItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(MortarProductionEfficiencySkill), 8, MortarProductionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<PitchItem>(typeof(MortarProductionEfficiencySkill), 3, MortarProductionEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(MortaredStoneRecipe), Item.Get<MortaredStoneItem>().UILink(), 0.3f, typeof(MortarProductionSpeedSkill));    
+            this.Initialize("Mortared Stone", typeof(MortaredStoneRecipe));
+
+            CraftingComponent.AddRecipe(typeof(MasonryTableObject), this);
+        }
+    }
+
+    [Serialized]
+    [Solid, Wall, Constructed,BuildRoomMaterialOption]
+    [Tier(1)]                                          
+    [RequiresSkill(typeof(MortarProductionEfficiencySkill), 0)]   
+    public partial class MortaredStoneBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(20)]                           
+    [Weight(10000)]      
+    [Currency]              
+    public partial class MortaredStoneItem :
+    BlockItem<MortaredStoneBlock>
+    {
+        public override string FriendlyName { get { return "Mortared Stone"; } }
+        public override string Description { get { return "Used to create tough but rudimentary buildings."; } }
+
+
+        private static Type[] blockTypes = new Type[] {
+            typeof(MortaredStoneStacked1Block),
+            typeof(MortaredStoneStacked2Block),
+            typeof(MortaredStoneStacked3Block)
+        };
+        public override Type[] BlockTypes { get { return blockTypes; } }
+    }
+
+    [Serialized, Solid] public class MortaredStoneStacked1Block : PickupableBlock { }
+    [Serialized, Solid] public class MortaredStoneStacked2Block : PickupableBlock { }
+    [Serialized, Solid,Wall] public class MortaredStoneStacked3Block : PickupableBlock { } //Only a wall if it's all 4 MortaredStone
+}

AutoGen/Item/Piston.cs

@@ -0,0 +1,54 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(MechanicalEngineeringSkill), 2)]   
+    public partial class PistonRecipe : Recipe
+    {
+        public PistonRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<PistonItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronPipeItem>(typeof(MechanicsComponentsEfficiencySkill), 5, MechanicsComponentsEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<SteelItem>(typeof(MechanicsComponentsEfficiencySkill), 7, MechanicsComponentsEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(PistonRecipe), Item.Get<PistonItem>().UILink(), 2, typeof(MechanicsComponentsSpeedSkill));    
+            this.Initialize("Piston", typeof(PistonRecipe));
+
+            CraftingComponent.AddRecipe(typeof(MachineShopObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(1000)]      
+    [Currency]              
+    public partial class PistonItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Piston"; } }
+        public override string Description { get { return "A moving component that transfers force. Can also function as a valve occasionally."; } }
+
+    }
+
+}

AutoGen/Item/ReinforcedConcrete.cs

@@ -0,0 +1,76 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(CementSkill), 1)]   
+    public partial class ReinforcedConcreteRecipe : Recipe
+    {
+        public ReinforcedConcreteRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ReinforcedConcreteItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ConcreteItem>(typeof(CementProductionEfficiencySkill), 1, CementProductionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<RebarItem>(typeof(CementProductionEfficiencySkill), 2, CementProductionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<MortaredStoneItem>(typeof(CementProductionEfficiencySkill), 2, CementProductionEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ReinforcedConcreteRecipe), Item.Get<ReinforcedConcreteItem>().UILink(), 2, typeof(CementProductionSpeedSkill));    
+            this.Initialize("Reinforced Concrete", typeof(ReinforcedConcreteRecipe));
+
+            CraftingComponent.AddRecipe(typeof(CementKilnObject), this);
+        }
+    }
+
+    [Serialized]
+    [Solid, Wall, Constructed,BuildRoomMaterialOption]
+    [Tier(3)]                                          
+    [RequiresSkill(typeof(CementProductionEfficiencySkill), 1)]   
+    public partial class ReinforcedConcreteBlock :
+        Block           
+    { }
+
+    [Serialized]
+    [MaxStackSize(20)]                           
+    [Weight(10000)]      
+    [Currency]              
+    public partial class ReinforcedConcreteItem :
+    BlockItem<ReinforcedConcreteBlock>
+    {
+        public override string FriendlyName { get { return "Reinforced Concrete"; } }
+        public override string FriendlyNamePlural { get { return "Reinforced Concrete"; } } 
+        public override string Description { get { return "A study construction material poured around a latice of rebar."; } }
+
+
+        private static Type[] blockTypes = new Type[] {
+            typeof(ReinforcedConcreteStacked1Block),
+            typeof(ReinforcedConcreteStacked2Block),
+            typeof(ReinforcedConcreteStacked3Block),
+            typeof(ReinforcedConcreteStacked4Block)
+        };
+        public override Type[] BlockTypes { get { return blockTypes; } }
+    }
+
+    [Serialized, Solid] public class ReinforcedConcreteStacked1Block : PickupableBlock { }
+    [Serialized, Solid] public class ReinforcedConcreteStacked2Block : PickupableBlock { }
+    [Serialized, Solid] public class ReinforcedConcreteStacked3Block : PickupableBlock { }
+    [Serialized, Solid,Wall] public class ReinforcedConcreteStacked4Block : PickupableBlock { } //Only a wall if it's all 4 ReinforcedConcrete
+}

AutoGen/Item/Steel.cs

@@ -0,0 +1,55 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(AlloySmeltingSkill), 2)]   
+    public partial class SteelRecipe : Recipe
+    {
+        public SteelRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronIngotItem>(typeof(AlloySmeltingEfficiencySkill), 6, AlloySmeltingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CharcoalItem>(typeof(AlloySmeltingEfficiencySkill), 2, AlloySmeltingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TailingsItem>(typeof(AlloySmeltingEfficiencySkill), 2, AlloySmeltingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(SteelRecipe), Item.Get<SteelItem>().UILink(), 5, typeof(AlloySmeltingSpeedSkill));    
+            this.Initialize("Steel", typeof(SteelRecipe));
+
+            CraftingComponent.AddRecipe(typeof(BlastFurnaceObject), this);
+        }
+    }
+
+
+    [Serialized]
+    [Weight(4000)]      
+    [Currency]              
+    public partial class SteelItem :
+    Item                                     
+    {
+        public override string FriendlyName { get { return "Steel"; } }
+        public override string Description { get { return "A strong alloy of iron and other elements."; } }
+
+    }
+
+}

AutoGen/Item/StoneRampUpgrade.cs

@@ -0,0 +1,51 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Objects;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Localization;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(RoadConstructionSkill), 1)]   
+    public partial class StoneRampUpgradeRecipe : Recipe
+    {
+        public StoneRampUpgradeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<StoneRampItem>(),          
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(RoadConstructionEfficiencySkill), 20, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<DirtRampItem>(typeof(RoadConstructionEfficiencySkill), 3, RoadConstructionEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.CraftMinutes = CreateCraftTimeValue(typeof(StoneRampUpgradeRecipe), Item.Get<StoneRampItem>().UILink(), 1, typeof(RoadConstructionSkill));    
+            this.Initialize("Stone Ramp", typeof(StoneRampUpgradeRecipe));
+
+            CraftingComponent.AddRecipe(typeof(WainwrightTableObject), this);
+            CraftingComponent.AddRecipe(typeof(MasonryTableObject), this);
+        }
+    }
+
+    [Serialized]
+    [Constructed]
+    [Road(1)]                                          
+    [RequiresSkill(typeof(RoadConstructionEfficiencySkill), 1)]   
+    public partial class StoneRampUpgradeBlock :
+        Block           
+    { }
+
+}

AutoGen/Recipe/BakedPitch.cs

@@ -0,0 +1,32 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(MortarProductionSkill), 3)] 
+    public class BakedPitchRecipe : Recipe
+    {
+        public BakedPitchRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<PitchItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<DirtItem>(typeof(BasicCraftingEfficiencySkill), 20, BasicCraftingEfficiencySkill.MultiplicativeStrategy),
+            };
+            this.Initialize("Baked Pitch", typeof(BakedPitchRecipe));
+            this.CraftMinutes = CreateCraftTimeValue(typeof(BakedPitchRecipe), this.UILink(), 0.1f, typeof(BasicCraftingEfficiencySkill));
+            CraftingComponent.AddRecipe(typeof(BakeryOvenObject), this);
+        }
+    }
+}

AutoGen/Recipe/ButcherBison.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(LargeButcherySkill), 3)] 
+    public class ButcherBisonRecipe : Recipe
+    {
+        public ButcherBisonRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<RawMeatItem>(20),
+               new CraftingElement<LeatherHideItem>(3),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BisonCarcassItem>(typeof(LargeButcheryEfficiencySkill), 1, LargeButcheryEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Butcher Bison", typeof(ButcherBisonRecipe));
+            //default crafting speed 3
+            var craftingspeed = 1;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ButcherBisonRecipe), this.UILink(), craftingspeed, typeof(LargeButcherySpeedSkill));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/ButcherElk.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(LargeButcherySkill), 1)] 
+    public class ButcherElkRecipe : Recipe
+    {
+        public ButcherElkRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<RawMeatItem>(10),
+               new CraftingElement<LeatherHideItem>(2),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ElkCarcassItem>(typeof(LargeButcheryEfficiencySkill), 1, LargeButcheryEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Butcher Elk", typeof(ButcherElkRecipe));
+            //default crafting speed 1
+            var craftingspeed = 1;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ButcherElkRecipe), this.UILink(), craftingspeed, typeof(LargeButcherySpeedSkill));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/ButcherFox.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(SmallButcherySkill), 3)] 
+    public class ButcherFoxRecipe : Recipe
+    {
+        public ButcherFoxRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<RawMeatItem>(3),
+               new CraftingElement<FurPeltItem>(2),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<FoxCarcassItem>(typeof(SmallButcheryEfficiencySkill), 1, SmallButcheryEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Butcher Fox", typeof(ButcherFoxRecipe));
+            //default crafting speed 1
+            var craftingspeed = 1;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ButcherFoxRecipe), this.UILink(), craftingspeed, typeof(SmallButcherySpeedSkill));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/ButcherHare.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(SmallButcherySkill), 1)] 
+    public class ButcherHareRecipe : Recipe
+    {
+        public ButcherHareRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<RawMeatItem>(1),
+               new CraftingElement<FurPeltItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<HareCarcassItem>(typeof(SmallButcheryEfficiencySkill), 1, SmallButcheryEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Butcher Hare", typeof(ButcherHareRecipe));
+            //default crafting speed 1
+            var craftingspeed = 1;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ButcherHareRecipe), this.UILink(), craftingspeed, typeof(SmallButcherySpeedSkill));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/ButcherTurkey.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(SmallButcherySkill), 1)] 
+    public class ButcherTurkeyRecipe : Recipe
+    {
+        public ButcherTurkeyRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<RawMeatItem>(2),
+               new CraftingElement<LeatherHideItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<TurkeyCarcassItem>(typeof(SmallButcheryEfficiencySkill), 1, SmallButcheryEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Butcher Turkey", typeof(ButcherTurkeyRecipe));
+            //default crafting speed 1
+            var craftingspeed = 1;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ButcherTurkeyRecipe), this.UILink(), craftingspeed, typeof(SmallButcherySpeedSkill));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/ButcherWolf.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(LargeButcherySkill), 2)] 
+    public class ButcherWolfRecipe : Recipe
+    {
+        public ButcherWolfRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<RawMeatItem>(4),
+               new CraftingElement<FurPeltItem>(3),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<WolfCarcassItem>(typeof(LargeButcheryEfficiencySkill), 1, LargeButcheryEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Butcher Wolf", typeof(ButcherWolfRecipe));
+            //default crafting speed 1.5f
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ButcherWolfRecipe), this.UILink(), craftingspeed, typeof(LargeButcherySpeedSkill));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/CampfireBison.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(CampfireCookingSkill), 4)] 
+    public class CampfireBisonRecipe : Recipe
+    {
+        public CampfireBisonRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CharredMeatItem>(16),
+               new CraftingElement<TallowItem>(7),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BisonCarcassItem>(typeof(CampfireCookingEfficiencySkill), 1, CampfireCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Campfire Bison", typeof(CampfireBisonRecipe));
+            //default crafting speed 20
+            var craftingspeed = 2;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CampfireBisonRecipe), this.UILink(), craftingspeed, typeof(CampfireCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Recipe/CampfireElk.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(CampfireCookingSkill), 2)] 
+    public class CampfireElkRecipe : Recipe
+    {
+        public CampfireElkRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CharredMeatItem>(7),
+               new CraftingElement<TallowItem>(4),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<ElkCarcassItem>(typeof(CampfireCookingEfficiencySkill), 1, CampfireCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Campfire Elk", typeof(CampfireElkRecipe));
+            //default crafting speed 10
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CampfireElkRecipe), this.UILink(), craftingspeed, typeof(CampfireCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Recipe/CampfireFox.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(CampfireCookingSkill), 3)] 
+    public class CampfireFoxRecipe : Recipe
+    {
+        public CampfireFoxRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CharredMeatItem>(2),
+               new CraftingElement<TallowItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<FoxCarcassItem>(typeof(CampfireCookingEfficiencySkill), 1, CampfireCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Campfire Fox", typeof(CampfireFoxRecipe));
+            //default crafting speed 4
+            var craftingspeed = 1;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CampfireFoxRecipe), this.UILink(), craftingspeed, typeof(CampfireCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Recipe/CampfireHare.cs

@@ -0,0 +1,34 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(CampfireCookingSkill), 1)] 
+    public class CampfireHareRecipe : Recipe
+    {
+        public CampfireHareRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CharredMeatItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<HareCarcassItem>(typeof(CampfireCookingEfficiencySkill), 1, CampfireCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Campfire Hare", typeof(CampfireHareRecipe));
+            //default crafting speed 1
+            var craftingspeed = 0.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CampfireHareRecipe), this.UILink(), craftingspeed, typeof(CampfireCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Recipe/CampfireSalmon.cs

@@ -0,0 +1,34 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(CampfireCookingSkill), 2)] 
+    public class CampfireSalmonRecipe : Recipe
+    {
+        public CampfireSalmonRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CharredFishItem>(2),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SalmonItem>(typeof(CampfireCookingEfficiencySkill), 1, CampfireCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Campfire Salmon", typeof(CampfireSalmonRecipe));
+            //default crafting speed 5
+            var craftingspeed = 2;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CampfireSalmonRecipe), this.UILink(), craftingspeed, typeof(CampfireCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Recipe/CampfireTrout.cs

@@ -0,0 +1,34 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(CampfireCookingSkill), 1)] 
+    public class CampfireTroutRecipe : Recipe
+    {
+        public CampfireTroutRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CharredFishItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<TroutItem>(typeof(CampfireCookingEfficiencySkill), 1, CampfireCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Campfire Trout", typeof(CampfireTroutRecipe));
+            //default crafting speed 3
+            var craftingspeed = 1.1f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CampfireTroutRecipe), this.UILink(), craftingspeed, typeof(CampfireCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Recipe/CampfireTuna.cs

@@ -0,0 +1,34 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(CampfireCookingSkill), 4)] 
+    public class CampfireTunaRecipe : Recipe
+    {
+        public CampfireTunaRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CharredFishItem>(3),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<TunaItem>(typeof(CampfireCookingEfficiencySkill), 1, CampfireCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Campfire Tuna", typeof(CampfireTunaRecipe));
+            //default crafting speed 10
+            var craftingspeed = 2.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CampfireTunaRecipe), this.UILink(), craftingspeed, typeof(CampfireCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Recipe/CampfireTurkey.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(CampfireCookingSkill), 1)] 
+    public class CampfireTurkeyRecipe : Recipe
+    {
+        public CampfireTurkeyRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CharredMeatItem>(2),
+               new CraftingElement<TallowItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<TurkeyCarcassItem>(typeof(CampfireCookingEfficiencySkill), 1, CampfireCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Campfire Turkey", typeof(CampfireTurkeyRecipe));
+            //default crafting speed 5
+            var craftingspeed = 1.2f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CampfireTurkeyRecipe), this.UILink(), craftingspeed, typeof(CampfireCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Recipe/CampfireWolf.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(CampfireCookingSkill), 3)] 
+    public class CampfireWolfRecipe : Recipe
+    {
+        public CampfireWolfRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CharredMeatItem>(3),
+               new CraftingElement<TallowItem>(2),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<WolfCarcassItem>(typeof(CampfireCookingEfficiencySkill), 1, CampfireCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Campfire Wolf", typeof(CampfireWolfRecipe));
+            //default crafting speed 2
+            var craftingspeed = 0.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CampfireWolfRecipe), this.UILink(), craftingspeed, typeof(CampfireCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CampfireObject), this);
+        }
+    }
+}

AutoGen/Recipe/CleanSalmon.cs

@@ -0,0 +1,34 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(SmallButcherySkill), 2)] 
+    public class CleanSalmonRecipe : Recipe
+    {
+        public CleanSalmonRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<RawFishItem>(5),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SalmonItem>(typeof(SmallButcheryEfficiencySkill), 1, SmallButcheryEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Clean Salmon", typeof(CleanSalmonRecipe));
+            //default crafting speed 1
+            var craftingspeed = 1;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CleanSalmonRecipe), this.UILink(), craftingspeed, typeof(SmallButcherySpeedSkill));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/CleanTrout.cs

@@ -0,0 +1,34 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(SmallButcherySkill), 1)] 
+    public class CleanTroutRecipe : Recipe
+    {
+        public CleanTroutRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<RawFishItem>(3),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<TroutItem>(typeof(SmallButcheryEfficiencySkill), 1, SmallButcheryEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Clean Trout", typeof(CleanTroutRecipe));
+            //default crafting speed 1.5
+            var craftingspeed = 1;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CleanTroutRecipe), this.UILink(), craftingspeed, typeof(SmallButcherySpeedSkill));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/CleanTuna.cs

@@ -0,0 +1,34 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(SmallButcherySkill), 3)] 
+    public class CleanTunaRecipe : Recipe
+    {
+        public CleanTunaRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<RawFishItem>(10),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<TunaItem>(typeof(SmallButcheryEfficiencySkill), 1, SmallButcheryEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Clean Tuna", typeof(CleanTunaRecipe));
+            //default crafting speed 2
+            var craftingspeed = 1;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(CleanTunaRecipe), this.UILink(), craftingspeed, typeof(SmallButcherySpeedSkill));
+            CraftingComponent.AddRecipe(typeof(ButcheryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/ExoticFruitSalad.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(HomeCookingSkill), 3)] 
+    public class ExoticFruitSaladRecipe : Recipe
+    {
+        public ExoticFruitSaladRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<FruitSaladItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<PricklyPearFruitItem>(typeof(HomeCookingEfficiencySkill), 15, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TomatoItem>(typeof(HomeCookingEfficiencySkill), 20, HomeCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Exotic Fruit Salad", typeof(ExoticFruitSaladRecipe));
+            //default crafting speed 2
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ExoticFruitSaladRecipe), this.UILink(), craftingspeed, typeof(HomeCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Recipe/ExoticSalad.cs

@@ -0,0 +1,36 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(HomeCookingSkill), 2)] 
+    public class ExoticSaladRecipe : Recipe
+    {
+        public ExoticSaladRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<BasicSaladItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<PricklyPearFruitItem>(typeof(HomeCookingEfficiencySkill), 10, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CriminiMushroomsItem>(typeof(HomeCookingEfficiencySkill), 10, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<RiceItem>(typeof(HomeCookingEfficiencySkill), 20, HomeCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Exotic Salad", typeof(ExoticSaladRecipe));
+            //default crafting speed 2
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ExoticSaladRecipe), this.UILink(), craftingspeed, typeof(HomeCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Recipe/ExoticVegetableMedley.cs

@@ -0,0 +1,36 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(HomeCookingSkill), 3)] 
+    public class ExoticVegetableMedleyRecipe : Recipe
+    {
+        public ExoticVegetableMedleyRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<VegetableMedleyItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<BeansItem>(typeof(HomeCookingEfficiencySkill), 20, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TomatoItem>(typeof(HomeCookingEfficiencySkill), 15, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BeetItem>(typeof(HomeCookingEfficiencySkill), 10, HomeCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Exotic Vegetable Medley", typeof(ExoticVegetableMedleyRecipe));
+            //default crafting speed 2
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ExoticVegetableMedleyRecipe), this.UILink(), craftingspeed, typeof(HomeCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Recipe/ForestSalad.cs

@@ -0,0 +1,36 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(HomeCookingSkill), 1)] 
+    public class ForestSaladRecipe : Recipe
+    {
+        public ForestSaladRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<BasicSaladItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<FiddleheadsItem>(typeof(HomeCookingEfficiencySkill), 20, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<HuckleberriesItem>(typeof(HomeCookingEfficiencySkill), 30, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BeansItem>(typeof(HomeCookingEfficiencySkill), 20, HomeCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Forest Salad", typeof(ForestSaladRecipe));
+            //default crafting speed 2
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(ForestSaladRecipe), this.UILink(), craftingspeed, typeof(HomeCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Recipe/GrasslandSalad.cs

@@ -0,0 +1,36 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(HomeCookingSkill), 1)] 
+    public class GrasslandSaladRecipe : Recipe
+    {
+        public GrasslandSaladRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<BasicSaladItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CornItem>(typeof(HomeCookingEfficiencySkill), 15, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TomatoItem>(typeof(HomeCookingEfficiencySkill), 15, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BeetItem>(typeof(HomeCookingEfficiencySkill), 15, HomeCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Grassland Salad", typeof(GrasslandSaladRecipe));
+            //default crafting speed 2
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(GrasslandSaladRecipe), this.UILink(), craftingspeed, typeof(HomeCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Recipe/GrindStoneToDirt.cs

@@ -0,0 +1,32 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(MortarProductionSkill), 1)] 
+    public class GrindStoneToDirtRecipe : Recipe
+    {
+        public GrindStoneToDirtRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<DirtItem>(2),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(MortarProductionEfficiencySkill), 4, MortarProductionEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Grind Stone To Dirt", typeof(GrindStoneToDirtRecipe));
+            this.CraftMinutes = CreateCraftTimeValue(typeof(GrindStoneToDirtRecipe), this.UILink(), 3, typeof(MortarProductionSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(MasonryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/GrindStoneToSand.cs

@@ -0,0 +1,32 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(MortarProductionSkill), 1)] 
+    public class GrindStoneToSandRecipe : Recipe
+    {
+        public GrindStoneToSandRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<SandItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<StoneItem>(typeof(MortarProductionEfficiencySkill), 5, MortarProductionEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Grind Stone To Sand", typeof(GrindStoneToSandRecipe));
+            this.CraftMinutes = CreateCraftTimeValue(typeof(GrindStoneToSandRecipe), this.UILink(), 5, typeof(MortarProductionSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(MasonryTableObject), this);
+        }
+    }
+}

AutoGen/Recipe/MassCutWire.cs

@@ -0,0 +1,32 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(IndustrialEngineeringSkill), 2)] 
+    public class MassCutWireRecipe : Recipe
+    {
+        public MassCutWireRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CopperWiringItem>(20),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CopperIngotItem>(typeof(IndustrialEngineeringEfficiencySkill), 20, IndustrialEngineeringEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Mass Cut Wire", typeof(MassCutWireRecipe));
+            this.CraftMinutes = CreateCraftTimeValue(typeof(MassCutWireRecipe), this.UILink(), 5, typeof(IndustrialEngineeringSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/Recipe/MixedFruitSalad.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(HomeCookingSkill), 2)] 
+    public class MixedFruitSaladRecipe : Recipe
+    {
+        public MixedFruitSaladRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<FruitSaladItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<HuckleberriesItem>(typeof(HomeCookingEfficiencySkill), 40, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<BeetItem>(typeof(HomeCookingEfficiencySkill), 20, HomeCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Mixed Fruit Salad", typeof(MixedFruitSaladRecipe));
+            //default crafting speed 2
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(MixedFruitSaladRecipe), this.UILink(), craftingspeed, typeof(HomeCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Recipe/MixedSalad.cs

@@ -0,0 +1,36 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(HomeCookingSkill), 2)] 
+    public class MixedSaladRecipe : Recipe
+    {
+        public MixedSaladRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<BasicSaladItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<FiddleheadsItem>(typeof(HomeCookingEfficiencySkill), 20, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<TomatoItem>(typeof(HomeCookingEfficiencySkill), 15, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<FireweedShootsItem>(typeof(HomeCookingEfficiencySkill), 15, HomeCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Mixed Salad", typeof(MixedSaladRecipe));
+            //default crafting speed 2
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(MixedSaladRecipe), this.UILink(), craftingspeed, typeof(HomeCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Recipe/MixedVegetableMedley.cs

@@ -0,0 +1,35 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(HomeCookingSkill), 2)] 
+    public class MixedVegetableMedleyRecipe : Recipe
+    {
+        public MixedVegetableMedleyRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<VegetableMedleyItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CornItem>(typeof(HomeCookingEfficiencySkill), 15, HomeCookingEfficiencySkill.MultiplicativeStrategy),
+                new CraftingElement<CamasBulbItem>(typeof(HomeCookingEfficiencySkill), 15, HomeCookingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Mixed Vegetable Medley", typeof(MixedVegetableMedleyRecipe));
+            //default crafting speed 2
+            var craftingspeed = 1.5f;
+            this.CraftMinutes = CreateCraftTimeValue(typeof(MixedVegetableMedleyRecipe), this.UILink(), craftingspeed, typeof(HomeCookingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(CastIronStoveObject), this);
+        }
+    }
+}

AutoGen/Recipe/SmeltCopper.cs

@@ -0,0 +1,32 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(BasicSmeltingSkill), 2)] 
+    public class SmeltCopperRecipe : Recipe
+    {
+        public SmeltCopperRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<CopperIngotItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<CopperOreItem>(typeof(BasicSmeltingEfficiencySkill), 20, BasicSmeltingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Smelt Copper", typeof(SmeltCopperRecipe));
+            this.CraftMinutes = CreateCraftTimeValue(typeof(SmeltCopperRecipe), this.UILink(), 0.5f, typeof(BasicSmeltingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(BlastFurnaceObject), this);
+        }
+    }
+}

AutoGen/Recipe/SmeltGold.cs

@@ -0,0 +1,32 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(BasicSmeltingSkill), 4)] 
+    public class SmeltGoldRecipe : Recipe
+    {
+        public SmeltGoldRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<GoldIngotItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<GoldOreItem>(typeof(BasicSmeltingEfficiencySkill), 20, BasicSmeltingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Smelt Gold", typeof(SmeltGoldRecipe));
+            this.CraftMinutes = CreateCraftTimeValue(typeof(SmeltGoldRecipe), this.UILink(), 0.5f, typeof(BasicSmeltingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(BlastFurnaceObject), this);
+        }
+    }
+}

AutoGen/Recipe/SmeltIron.cs

@@ -0,0 +1,32 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Skills;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Gameplay.Systems.TextLinks;
+
+    [RequiresSkill(typeof(BasicSmeltingSkill), 3)] 
+    public class SmeltIronRecipe : Recipe
+    {
+        public SmeltIronRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+               new CraftingElement<IronIngotItem>(1),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronOreItem>(typeof(BasicSmeltingEfficiencySkill), 20, BasicSmeltingEfficiencySkill.MultiplicativeStrategy), 
+            };
+            this.Initialize("Smelt Iron", typeof(SmeltIronRecipe));
+            this.CraftMinutes = CreateCraftTimeValue(typeof(SmeltIronRecipe), this.UILink(), 0.5f, typeof(BasicSmeltingSpeedSkill));
+            CraftingComponent.AddRecipe(typeof(BlastFurnaceObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeIronAx.cs

@@ -0,0 +1,43 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 1)]
+
+    public partial class UpgradeIronAxeRecipe : Recipe
+    {
+        public UpgradeIronAxeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelAxeItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronAxeItem>(1),
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeIronAxeRecipe), Item.Get<SteelAxeItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+            
+            );
+            this.Initialize("Upgrade Iron Axe", typeof(UpgradeIronAxeRecipe));
+
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeIronHammer.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 4)]
+    public partial class UpgradeIronHammerRecipe : Recipe
+    {
+        public UpgradeIronHammerRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelHammerItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronHammerItem>(1),
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeIronHammerRecipe), Item.Get<SteelHammerItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+            
+            );
+            this.Initialize("Upgrade Iron Hammer", typeof(UpgradeIronHammerRecipe));
+
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeIronHoe.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 3)]
+    public partial class UpgradeIronHoeRecipe : Recipe
+    {
+        public UpgradeIronHoeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelHoeItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronHoeItem>(1),
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeIronHoeRecipe), Item.Get<SteelHoeItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Iron Hoe", typeof(UpgradeIronHoeRecipe));
+
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeIronPickaxe.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 1)]
+    public partial class UpgradeIronPickaxeRecipe : Recipe
+    {
+        public UpgradeIronPickaxeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelPickaxeItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronPickaxeItem>(1),
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeIronPickaxeRecipe), Item.Get<SteelPickaxeItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Iron Pickaxe", typeof(UpgradeIronPickaxeRecipe));
+
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeIronScythe.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 3)]
+    public partial class UpgradeIronScytheRecipe : Recipe
+    {
+        public UpgradeIronScytheRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelScytheItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronScytheItem>(1),
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeIronScytheRecipe), Item.Get<SteelScytheItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Iron Scythe", typeof(UpgradeIronScytheRecipe));
+
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeIronShovel.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 2)]
+    public partial class UpgradeIronShovelRecipe : Recipe
+    {
+        public UpgradeIronShovelRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<SteelShovelItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<IronShovelItem>(1),
+                new CraftingElement<SteelItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeIronShovelRecipe), Item.Get<SteelShovelItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Iron Shovel", typeof(UpgradeIronShovelRecipe));
+
+            CraftingComponent.AddRecipe(typeof(AnvilObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeSteelAx.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 3)]
+    public partial class UpgradeSteelAxeRecipe : Recipe
+    {
+        public UpgradeSteelAxeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ModernAxeItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelAxeItem>(1),
+                new CraftingElement<FiberglassItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeSteelAxeRecipe), Item.Get<ModernAxeItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Steel Axe", typeof(UpgradeSteelAxeRecipe));
+
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeSteelHammer.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 3)]
+    public partial class UpgradeSteelHammerRecipe : Recipe
+    {
+        public UpgradeSteelHammerRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ModernHammerItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelHammerItem>(1),
+                new CraftingElement<FiberglassItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeSteelHammerRecipe), Item.Get<ModernHammerItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Steel Hammer", typeof(UpgradeSteelHammerRecipe));
+
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeSteelHoe.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 3)]
+    public partial class UpgradeSteelHoeRecipe : Recipe
+    {
+        public UpgradeSteelHoeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ModernHoeItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelHoeItem>(1),
+                new CraftingElement<FiberglassItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeSteelHoeRecipe), Item.Get<ModernHoeItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Steel Hoe", typeof(UpgradeSteelHoeRecipe));
+
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeSteelPickaxe.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 3)]
+    public partial class UpgradeSteelPickaxeRecipe : Recipe
+    {
+        public UpgradeSteelPickaxeRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ModernPickaxeItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelPickaxeItem>(1),
+                new CraftingElement<FiberglassItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeSteelPickaxeRecipe), Item.Get<ModernPickaxeItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Steel Pickaxe", typeof(UpgradeSteelPickaxeRecipe));
+
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeSteelScythe.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 3)]
+    public partial class UpgradeSteelScytheRecipe : Recipe
+    {
+        public UpgradeSteelScytheRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ModernScytheItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelScytheItem>(1),
+                new CraftingElement<FiberglassItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeSteelScytheRecipe), Item.Get<ModernScytheItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Steel Scythe", typeof(UpgradeSteelScytheRecipe));
+
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}

AutoGen/Tool/UpgradeSteelShovel.cs

@@ -0,0 +1,42 @@
+namespace Eco.Mods.TechTree
+{
+    using System;
+    using System.Collections.Generic;
+    using System.ComponentModel;
+    using Eco.Gameplay.Blocks;
+    using Eco.Gameplay.Components;
+    using Eco.Gameplay.DynamicValues;
+    using Eco.Gameplay.Items;
+    using Eco.Gameplay.Players;
+    using Eco.Gameplay.Skills;
+    using Eco.Gameplay.Systems.TextLinks;
+    using Eco.Shared.Serialization;
+    using Eco.Shared.Utils;
+    using Eco.World;
+    using Eco.World.Blocks;
+    using Eco.Gameplay.Pipes;
+
+    [RequiresSkill(typeof(SteelworkingSkill), 3)]
+    public partial class UpgradeSteelShovelRecipe : Recipe
+    {
+        public UpgradeSteelShovelRecipe()
+        {
+            this.Products = new CraftingElement[]
+            {
+                new CraftingElement<ModernShovelItem>(),
+            };
+            this.Ingredients = new CraftingElement[]
+            {
+                new CraftingElement<SteelShovelItem>(1),
+                new CraftingElement<FiberglassItem>(typeof(SteelworkingEfficiencySkill), 20 ,SteelworkingEfficiencySkill.MultiplicativeStrategy)
+            };
+            this.CraftMinutes = new MultiDynamicValue(MultiDynamicOps.Multiply
+            , CreateCraftTimeValue(typeof(UpgradeSteelShovelRecipe), Item.Get<ModernShovelItem>().UILink(), .5f, typeof(SteelworkingSpeedSkill))
+
+            );
+            this.Initialize("Upgrade Steel Shovel", typeof(UpgradeSteelShovelRecipe));
+
+            CraftingComponent.AddRecipe(typeof(FactoryObject), this);
+        }
+    }
+}