Gitlab to Gitea Migration

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);
+        }
+    }
+}