Pakobbix/EcoGSCE-Modpack
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Gitlab to Gitea Migration

Browse Source
This commit is contained in:
Pakobbix
2022-07-02 13:02:05 +02:00
parent 3d070e36e6
commit 0fd1c1acf2
196 changed files with 14059 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
AutoGen/Item/AsphaltRamp.cs Normal file
View File

@@ -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
{ }
}

51
AutoGen/Item/AsphaltRampUpgrade.cs Normal file
View File

@@ -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
{ }
}

64
AutoGen/Item/AsphaltRoad.cs Normal file
View File

@@ -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."; } }
}
}

64
AutoGen/Item/AsphaltRoadUpgrade.cs Normal file
View File

@@ -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."; } }
}
}

63
AutoGen/Item/Barrel.cs Normal file
View File

@@ -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."; } }
}
}

63
AutoGen/Item/Biodiesel.cs Normal file
View File

@@ -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."; } }
}
}

54
AutoGen/Item/Board.cs Normal file
View File

@@ -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."; } }
}
}

54
AutoGen/Item/Charcoal.cs Normal file
View File

@@ -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."; } }
}
}

56
AutoGen/Item/Coal.cs Normal file
View File

@@ -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
}

56
AutoGen/Item/CombustionEngine.cs Normal file
View File

@@ -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."; } }
}
}

55
AutoGen/Item/Concrete.cs Normal file
View File

@@ -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."; } }
}
}

54
AutoGen/Item/CopperIngot.cs Normal file
View File

@@ -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."; } }
}
}

55
AutoGen/Item/CopperOre.cs Normal file
View File

@@ -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
}

54
AutoGen/Item/CopperWiring.cs Normal file
View File

@@ -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."; } }
}
}

54
AutoGen/Item/Gearbox.cs Normal file
View File

@@ -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"; } }
}
}

54
AutoGen/Item/GoldIngot.cs Normal file
View File

@@ -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."; } }
}
}

55
AutoGen/Item/GoldOre.cs Normal file
View File

@@ -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
}

72
AutoGen/Item/HewnLog.cs Normal file
View File

@@ -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
}

54
AutoGen/Item/IronIngot.cs Normal file
View File

@@ -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."; } }
}
}

55
AutoGen/Item/IronOre.cs Normal file
View File

@@ -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
}

54
AutoGen/Item/Log.cs Normal file
View File

@@ -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
}

76
AutoGen/Item/Lumber.cs Normal file
View File

@@ -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
}

72
AutoGen/Item/MortaredStone.cs Normal file
View File

@@ -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
}

54
AutoGen/Item/Piston.cs Normal file
View File

@@ -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."; } }
}
}

76
AutoGen/Item/ReinforcedConcrete.cs Normal file
View File

@@ -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
}

55
AutoGen/Item/Steel.cs Normal file
View File

@@ -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."; } }
}
}

51
AutoGen/Item/StoneRampUpgrade.cs Normal file
View File

@@ -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
{ }
}