diff options
Diffstat (limited to 'kekztech/src')
125 files changed, 6091 insertions, 0 deletions
diff --git a/kekztech/src/main/java/client/ClientProxy.java b/kekztech/src/main/java/client/ClientProxy.java new file mode 100644 index 0000000000..9dfaea0d33 --- /dev/null +++ b/kekztech/src/main/java/client/ClientProxy.java @@ -0,0 +1,19 @@ +package client; + +import common.CommonProxy; + +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; + +public class ClientProxy extends CommonProxy { + + @Override + public void preInit(final FMLPreInitializationEvent e) { + super.preInit(e); + } + + @Override + public void init(final FMLInitializationEvent e) { + super.init(e); + } +} diff --git a/kekztech/src/main/java/client/gui/KT_UITextures.java b/kekztech/src/main/java/client/gui/KT_UITextures.java new file mode 100644 index 0000000000..6f28a0280b --- /dev/null +++ b/kekztech/src/main/java/client/gui/KT_UITextures.java @@ -0,0 +1,17 @@ +package client.gui; + +import com.gtnewhorizons.modularui.api.drawable.UITexture; + +import kekztech.KekzCore; + +public class KT_UITextures { + + public static final UITexture OVERLAY_BUTTON_WIRELESS_ON = UITexture + .fullImage(KekzCore.MODID, "gui/overlay_button/wireless_on"); + + public static final UITexture OVERLAY_BUTTON_WIRELESS_OFF = UITexture + .fullImage(KekzCore.MODID, "gui/overlay_button/wireless_off"); + + public static final UITexture OVERLAY_BUTTON_WIRELESS_OFF_DISABLED = UITexture + .fullImage(KekzCore.MODID, "gui/overlay_button/wireless_off_disabled"); +} diff --git a/kekztech/src/main/java/common/Blocks.java b/kekztech/src/main/java/common/Blocks.java new file mode 100644 index 0000000000..4003e8e9e4 --- /dev/null +++ b/kekztech/src/main/java/common/Blocks.java @@ -0,0 +1,59 @@ +package common; + +import net.minecraft.block.Block; + +import common.blocks.Block_GDCUnit; +import common.blocks.Block_IchorJar; +import common.blocks.Block_LapotronicEnergyUnit; +import common.blocks.Block_LargeHexPlate; +import common.blocks.Block_TFFTStorageField; +import common.blocks.Block_ThaumiumReinforcedJar; +import common.blocks.Block_YSZUnit; + +import kekztech.KekzCore; + +public class Blocks { + + public static Block yszUnit; + public static Block gdcUnit; + public static Block tfftStorageField; + public static Block jarThaumiumReinforced; + public static Block jarIchor; + public static Block lscLapotronicEnergyUnit; + + public static Block largeHexPlate; + + public static void preInit() { + KekzCore.LOGGER.info("Registering blocks..."); + + registerBlocks_SOFC(); + registerBlocks_TFFT(); + registerBlocks_Jars(); + registerBlocks_LSC(); + registerBlocks_Cosmetics(); + + KekzCore.LOGGER.info("Finished registering blocks"); + } + + private static void registerBlocks_SOFC() { + yszUnit = Block_YSZUnit.registerBlock(); + gdcUnit = Block_GDCUnit.registerBlock(); + } + + private static void registerBlocks_TFFT() { + tfftStorageField = Block_TFFTStorageField.registerBlock(); + } + + private static void registerBlocks_Jars() { + jarThaumiumReinforced = Block_ThaumiumReinforcedJar.registerBlock(); + jarIchor = Block_IchorJar.registerBlock(); + } + + private static void registerBlocks_LSC() { + lscLapotronicEnergyUnit = Block_LapotronicEnergyUnit.registerBlock(); + } + + private static void registerBlocks_Cosmetics() { + largeHexPlate = Block_LargeHexPlate.registerBlock(); + } +} diff --git a/kekztech/src/main/java/common/CommonProxy.java b/kekztech/src/main/java/common/CommonProxy.java new file mode 100644 index 0000000000..777a8af268 --- /dev/null +++ b/kekztech/src/main/java/common/CommonProxy.java @@ -0,0 +1,42 @@ +package common; + +import common.items.ErrorItem; +import common.items.MetaItem_CraftingComponent; +import common.tileentities.GTMTE_TFFTHatch; + +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; +import kekztech.Items; + +public class CommonProxy { + + public void preInit(final FMLPreInitializationEvent e) { + // Items + ErrorItem.getInstance() + .registerItem(); + MetaItem_CraftingComponent.getInstance() + .registerItem(); + Items.registerOreDictNames(); + // Blocks + Blocks.preInit(); + // TileEntities + TileEntities.preInit(); + // TC Research + Researches.preInit(); + } + + public void init(final FMLInitializationEvent e) { + // GregTech Meta TileEntities + TileEntities.init(); + } + + public void postInit(final FMLPostInitializationEvent e) { + // Recipes + Recipes.postInit(); + // Research + Researches.postInit(); + + GTMTE_TFFTHatch.registerAEIntegration(); + } +} diff --git a/kekztech/src/main/java/common/Recipes.java b/kekztech/src/main/java/common/Recipes.java new file mode 100644 index 0000000000..2560e8dc37 --- /dev/null +++ b/kekztech/src/main/java/common/Recipes.java @@ -0,0 +1,141 @@ +package common; + +import static gregtech.api.enums.Mods.ThaumicTinkerer; + +import java.util.HashMap; + +import net.minecraft.item.ItemStack; + +import common.recipeLoaders.AlloySmelter; +import common.recipeLoaders.Assembler; +import common.recipeLoaders.AssemblyLine; +import common.recipeLoaders.ChemicalReactor; +import common.recipeLoaders.Crafting; +import common.recipeLoaders.FormingPress; +import common.recipeLoaders.Mixer; +import common.recipeLoaders.ResearchableAssemblyLine; +import common.recipeLoaders.Unpackager; + +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import kekztech.KekzCore; +import thaumcraft.api.ItemApi; +import thaumcraft.api.ThaumcraftApi; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.AspectList; +import thaumcraft.api.crafting.InfusionRecipe; + +public class Recipes { + + public static final HashMap<String, InfusionRecipe> infusionRecipes = new HashMap<>(); + + public static void postInit() { + KekzCore.LOGGER.info("Registering recipes..."); + + new AlloySmelter().run(); + new Assembler().run(); + new AssemblyLine().run(); + new ChemicalReactor().run(); + new Crafting().run(); + new FormingPress().run(); + new Mixer().run(); + new ResearchableAssemblyLine().run(); + new Unpackager().run(); + + registerRecipes_Jars(); + + KekzCore.LOGGER.info("Finished registering recipes"); + } + + private static void registerRecipes_Jars() { + + // Thaumium Reinforced Jar + final ItemStack[] recipe_jarthaumiumreinforced = { + GameRegistry.makeItemStack("Thaumcraft:ItemResource", 15, 1, null), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Thaumium, 1), + new ItemStack(net.minecraft.init.Blocks.glass_pane), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Thaumium, 1), + new ItemStack(net.minecraft.init.Blocks.glass_pane), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Titanium, 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Thaumium, 1), + new ItemStack(net.minecraft.init.Blocks.glass_pane), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Thaumium, 1), + new ItemStack(net.minecraft.init.Blocks.glass_pane), }; + final AspectList aspects_jarthaumiumreinforced = new AspectList().add(Aspect.ARMOR, 64) + .add(Aspect.ORDER, 32) + .add(Aspect.WATER, 32) + .add(Aspect.GREED, 16) + .add(Aspect.VOID, 16) + .add(Aspect.AIR, 8); + infusionRecipes.put( + "THAUMIUMREINFORCEDJAR", + ThaumcraftApi.addInfusionCraftingRecipe( + "THAUMIUMREINFORCEDJAR", + new ItemStack(Blocks.jarThaumiumReinforced, 1, 0), + 5, + aspects_jarthaumiumreinforced, + ItemApi.getBlock("blockJar", 0), + recipe_jarthaumiumreinforced)); + // Thaumium Reinforced Void Jar + final ItemStack[] recipe_voidjarupgrade = { + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.Obsidian, 1), + GT_OreDictUnificator.get(OrePrefixes.dust, Materials.Blaze, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.EnderEye, 1), ItemApi.getItem("itemNugget", 5) }; + final AspectList aspects_voidjarupgrade = new AspectList().add(Aspect.VOID, 14) + .add(Aspect.MAGIC, 14) + .add(Aspect.ENTROPY, 14) + .add(Aspect.WATER, 14); + infusionRecipes.put( + "THAUMIUMREINFORCEDVOIDJAR", + ThaumcraftApi.addInfusionCraftingRecipe( + "THAUMIUMREINFORCEDJAR", + new ItemStack(Blocks.jarThaumiumReinforced, 1, 3), + 2, + aspects_voidjarupgrade, + new ItemStack(Blocks.jarThaumiumReinforced, 1, 0), + recipe_voidjarupgrade)); + + final ItemStack[] recipe_jarichor = { GT_ModHandler.getModItem(ThaumicTinkerer.ID, "kamiResource", 1, 0), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Diamond, 1), + new ItemStack(net.minecraft.init.Blocks.glass_pane), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Osmiridium, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Diamond, 1), + new ItemStack(net.minecraft.init.Blocks.glass_pane), + GT_OreDictUnificator.get(OrePrefixes.gemExquisite, Materials.Diamond, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Diamond, 1), + new ItemStack(net.minecraft.init.Blocks.glass_pane), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.Osmiridium, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Diamond, 1), + new ItemStack(net.minecraft.init.Blocks.glass_pane), }; + final AspectList aspects_jarichor = new AspectList().add(Aspect.ARMOR, 256) + .add(Aspect.ELDRITCH, 128) + .add(Aspect.ORDER, 128) + .add(Aspect.WATER, 128) + .add(Aspect.GREED, 64) + .add(Aspect.VOID, 64) + .add(Aspect.AIR, 32); + infusionRecipes.put( + "ICHORJAR", + ThaumcraftApi.addInfusionCraftingRecipe( + "ICHORJAR", + new ItemStack(Blocks.jarIchor, 1, 0), + 15, + aspects_jarichor, + ItemApi.getBlock("blockJar", 0), + recipe_jarichor)); + // Ichor Void Jar + infusionRecipes.put( + "ICHORVOIDJAR", + ThaumcraftApi.addInfusionCraftingRecipe( + "ICHORJAR", + new ItemStack(Blocks.jarIchor, 1, 3), + 5, + aspects_voidjarupgrade, + new ItemStack(Blocks.jarIchor, 1, 0), + recipe_voidjarupgrade)); + } + +} diff --git a/kekztech/src/main/java/common/Researches.java b/kekztech/src/main/java/common/Researches.java new file mode 100644 index 0000000000..0ebe161da4 --- /dev/null +++ b/kekztech/src/main/java/common/Researches.java @@ -0,0 +1,71 @@ +package common; + +import net.minecraft.item.ItemStack; + +import kekztech.KekzCore; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.AspectList; +import thaumcraft.api.research.ResearchItem; +import thaumcraft.api.research.ResearchPage; +import thaumic.tinkerer.common.research.KamiResearchItem; + +public class Researches { + + public static final String THAUMIUMREINFORCEDJAR = "THAUMIUMREINFORCEDJAR"; + public static final String ICHORJAR = "ICHORJAR"; + + public static void preInit() { + // Blacklist these researches from being a requirement to unlock TTKami + KekzCore.LOGGER.info("Blacklisting research " + THAUMIUMREINFORCEDJAR + " from /iskamiunlocked"); + KamiResearchItem.Blacklist.add(ICHORJAR); + KekzCore.LOGGER.info("Blacklisting research" + ICHORJAR + "from /iskamiunlocked"); + KamiResearchItem.Blacklist.add(ICHORJAR); + } + + public static void postInit() { + final AspectList aspects_jarthaumiumreinforced = new AspectList().add(Aspect.ARMOR, 3) + .add(Aspect.WATER, 3) + .add(Aspect.GREED, 3) + .add(Aspect.VOID, 3); + @SuppressWarnings("unused") + final ResearchItem jar_thaumiumreinforced = new ResearchItem( + "THAUMIUMREINFORCEDJAR", + "ALCHEMY", + aspects_jarthaumiumreinforced, + 3, + -4, + 2, + new ItemStack(Blocks.jarThaumiumReinforced, 1)) + .setPages( + new ResearchPage("kekztech.research_page.THAUMIUMREINFORCEDJAR.0"), + new ResearchPage(Recipes.infusionRecipes.get("THAUMIUMREINFORCEDJAR")), + new ResearchPage(Recipes.infusionRecipes.get("THAUMIUMREINFORCEDVOIDJAR")), + new ResearchPage("kekztech.research_page.THAUMIUMREINFORCEDJAR.1")) + .setConcealed() + .setParents("JARLABEL") + .registerResearchItem(); + + final AspectList aspects_jarichor = new AspectList().add(Aspect.ARMOR, 3) + .add(Aspect.ELDRITCH, 3) + .add(Aspect.WATER, 3) + .add(Aspect.GREED, 5) + .add(Aspect.VOID, 5); + @SuppressWarnings("unused") + final ResearchItem jar_ichor = new ResearchItem( + "ICHORJAR", + "ALCHEMY", + aspects_jarichor, + 2, + -5, + 3, + new ItemStack(Blocks.jarIchor, 1)) + .setPages( + new ResearchPage("kekztech.research_page.ICHORJAR.0"), + new ResearchPage(Recipes.infusionRecipes.get("ICHORJAR")), + new ResearchPage(Recipes.infusionRecipes.get("ICHORVOIDJAR"))) + .setConcealed() + .setParents("THAUMIUMREINFORCEDJAR") + .setParentsHidden("ICHOR") + .registerResearchItem(); + } +} diff --git a/kekztech/src/main/java/common/TileEntities.java b/kekztech/src/main/java/common/TileEntities.java new file mode 100644 index 0000000000..31246ac5d8 --- /dev/null +++ b/kekztech/src/main/java/common/TileEntities.java @@ -0,0 +1,43 @@ +package common; + +import common.tileentities.GTMTE_LapotronicSuperCapacitor; +import common.tileentities.GTMTE_SOFuelCellMK1; +import common.tileentities.GTMTE_SOFuelCellMK2; +import common.tileentities.GTMTE_TFFT; +import common.tileentities.GTMTE_TFFTHatch; +import common.tileentities.TE_IchorJar; +import common.tileentities.TE_IchorVoidJar; +import common.tileentities.TE_ThaumiumReinforcedJar; +import common.tileentities.TE_ThaumiumReinforcedVoidJar; + +import cpw.mods.fml.common.registry.GameRegistry; + +public class TileEntities { + + // Multiblock controllers + public static GTMTE_SOFuelCellMK1 sofc1; + public static GTMTE_SOFuelCellMK2 sofc2; + public static GTMTE_TFFT tfft; + public static GTMTE_LapotronicSuperCapacitor lsc; + + // Singleblocks + public static GTMTE_TFFTHatch tfftHatch; + + public static void preInit() { + GameRegistry.registerTileEntity(TE_ThaumiumReinforcedJar.class, "kekztech_thaumiumreinforcedjar"); + GameRegistry.registerTileEntity(TE_ThaumiumReinforcedVoidJar.class, "kekztech_thaumiumreinforcedvoidjar"); + GameRegistry.registerTileEntity(TE_IchorJar.class, "kekztech_ichorjar"); + GameRegistry.registerTileEntity(TE_IchorVoidJar.class, "kekztech_ichorvoidjar"); + } + + public static void init() { + // Multiblock controllers + sofc1 = new GTMTE_SOFuelCellMK1(13101, "multimachine.fuelcellmk1", "Solid-Oxide Fuel Cell Mk I"); + sofc2 = new GTMTE_SOFuelCellMK2(13102, "multimachine.fuelcellmk2", "Solid-Oxide Fuel Cell Mk II"); + tfft = new GTMTE_TFFT(13104, "multimachine.tfft", "T.F.F.T"); + lsc = new GTMTE_LapotronicSuperCapacitor(13106, "multimachine.supercapacitor", "Lapotronic Supercapacitor"); + + // Singleblocks + tfftHatch = new GTMTE_TFFTHatch(13109, "machine.tffthatch", "T.F.F.T Multi I/O Hatch"); + } +} diff --git a/kekztech/src/main/java/common/blocks/BaseGTUpdateableBlock.java b/kekztech/src/main/java/common/blocks/BaseGTUpdateableBlock.java new file mode 100644 index 0000000000..ef61327dd7 --- /dev/null +++ b/kekztech/src/main/java/common/blocks/BaseGTUpdateableBlock.java @@ -0,0 +1,57 @@ +package common.blocks; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +import gregtech.api.GregTech_API; + +/** + * Any blocks that are used as structure parts for GregTech multi machines have to inherit from this class. Otherwise + * the checkMachine() method that verifies a machine's structure won't be called correctly. + */ +public abstract class BaseGTUpdateableBlock extends Block { + + protected BaseGTUpdateableBlock(Material material) { + super(material); + GregTech_API.registerMachineBlock(this, -1); + super.setHarvestLevel("wrench", 2); + } + + @Override + public int damageDropped(int meta) { + return meta; + } + + @Override + public boolean canBeReplacedByLeaves(IBlockAccess world, int x, int y, int z) { + return false; + } + + @Override + public boolean canEntityDestroy(IBlockAccess world, int x, int y, int z, Entity entity) { + return false; + } + + @Override + public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) { + return false; + } + + @Override + public void onBlockAdded(World aWorld, int aX, int aY, int aZ) { + if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } + + @Override + public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) { + if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } +} diff --git a/kekztech/src/main/java/common/blocks/Block_GDCUnit.java b/kekztech/src/main/java/common/blocks/Block_GDCUnit.java new file mode 100644 index 0000000000..27bc95759d --- /dev/null +++ b/kekztech/src/main/java/common/blocks/Block_GDCUnit.java @@ -0,0 +1,29 @@ +package common.blocks; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; + +public class Block_GDCUnit extends BaseGTUpdateableBlock { + + private static final Block_GDCUnit instance = new Block_GDCUnit(); + + private Block_GDCUnit() { + super(Material.iron); + } + + public static Block registerBlock() { + final String blockName = "kekztech_gdcceramicelectrolyteunit_block"; + instance.setBlockName(blockName); + instance.setCreativeTab(CreativeTabs.tabMisc); + instance.setBlockTextureName(KekzCore.MODID + ":" + "GDCCeramicElectrolyteUnit"); + instance.setHardness(5.0f); + instance.setResistance(6.0f); + GameRegistry.registerBlock(instance, blockName); + + return instance; + } +} diff --git a/kekztech/src/main/java/common/blocks/Block_IchorJar.java b/kekztech/src/main/java/common/blocks/Block_IchorJar.java new file mode 100644 index 0000000000..a82f9862f0 --- /dev/null +++ b/kekztech/src/main/java/common/blocks/Block_IchorJar.java @@ -0,0 +1,230 @@ +package common.blocks; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.Explosion; +import net.minecraft.world.World; + +import common.itemBlocks.IB_IchorJar; +import common.tileentities.TE_IchorJar; +import common.tileentities.TE_IchorVoidJar; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.AspectList; +import thaumcraft.common.blocks.BlockJar; +import thaumcraft.common.config.ConfigBlocks; +import thaumcraft.common.config.ConfigItems; +import thaumcraft.common.items.ItemEssence; +import thaumcraft.common.tiles.TileJarFillable; + +public class Block_IchorJar extends BlockJar { + + private static final Block_IchorJar INSTANCE = new Block_IchorJar(); + + private Block_IchorJar() { + super(); + + super.setHardness(12.0F); + super.setResistance(3.0f); + } + + public static Block registerBlock() { + final String blockName = "kekztech_ichorjar_block"; + INSTANCE.setBlockName(blockName); + INSTANCE.setHarvestLevel("pickaxe", 3); + GameRegistry.registerBlock(INSTANCE, IB_IchorJar.class, blockName); + + return INSTANCE; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister ir) { + super.iconLiquid = ir.registerIcon("thaumcraft:animatedglow"); + super.iconJarSide = ir.registerIcon("kekztech:ichor_jar_side"); + super.iconJarTop = ir.registerIcon("kekztech:ichor_jar_top"); + super.iconJarTopVoid = ir.registerIcon("kekztech:ichor_jar_top_void"); + super.iconJarSideVoid = ir.registerIcon("kekztech:ichor_jar_side_void"); + super.iconJarBottom = ir.registerIcon("kekztech:ichor_jar_bottom"); + } + + @Override + @SideOnly(Side.CLIENT) + @SuppressWarnings({ "unchecked" }) + public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) { + par3List.add(new ItemStack(par1, 1, 0)); // Normal jar + par3List.add(new ItemStack(par1, 1, 3)); // Void jar + } + + @Override + public TileEntity createTileEntity(World world, int meta) { + if (meta == 3) { + return new TE_IchorVoidJar(); + } else { + return new TE_IchorJar(); + } + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float f1, float f2, + float f3) { + // Call parent method to handle jar emptying, labels stuff etc + super.onBlockActivated(world, x, y, z, player, side, f1, f2, f3); + // Interact with Essentia Phials if the player holds one + final ItemStack heldItem = player.getHeldItem(); + if (heldItem != null && heldItem.getItem() == ConfigItems.itemEssence) { + final TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof TE_IchorJar) { + return dealWithPhial(world, player, x, y, z); + } else if (te instanceof TE_IchorVoidJar) { + return dealWithPhial(world, player, x, y, z); + } + } + + return true; + } + + /** + * Handle compatibility with Essentia Phials + * + * @param world Pass through from onBlockActivated() + * @param player Pass through from onBlockActivated() + * @param x Pass through from onBlockActivated() + * @param y Pass through from onBlockActivated() + * @param z Pass through from onBlockActivated() + * @return Not sure tbh + */ + private boolean dealWithPhial(World world, EntityPlayer player, int x, int y, int z) { + final TileJarFillable jarTE = (TileJarFillable) world.getTileEntity(x, y, z); + final ItemStack heldItem = player.getHeldItem(); + // Check whether to fill or to drain the phial + if (heldItem.getItemDamage() == 0) { + if (jarTE.amount >= 8) { + if (world.isRemote) { + player.swingItem(); + return false; + } + + final Aspect jarAspect = Aspect.getAspect(jarTE.aspect.getTag()); + if (jarTE.takeFromContainer(jarAspect, 8)) { + // Take an empty phial from the player's inventory + heldItem.stackSize--; + // Fill a new phial + final ItemStack filledPhial = new ItemStack(ConfigItems.itemEssence, 1, 1); + final AspectList phialContent = new AspectList().add(jarAspect, 8); + ((ItemEssence) ConfigItems.itemEssence).setAspects(filledPhial, phialContent); + // Drop on ground if there's no inventory space + if (!player.inventory.addItemStackToInventory(filledPhial)) { + world.spawnEntityInWorld( + new EntityItem(world, (float) x + 0.5F, (float) y + 0.5F, (float) z + 0.5F, filledPhial)); + } + + world.playSoundAtEntity(player, "game.neutral.swim", 0.25F, 1.0F); + player.inventoryContainer.detectAndSendChanges(); + return true; + } + } + } else { + final AspectList phialContent = ((ItemEssence) ConfigItems.itemEssence).getAspects(heldItem); + if (phialContent != null && phialContent.size() == 1) { + final Aspect phialAspect = phialContent.getAspects()[0]; + if (jarTE.amount + 8 <= jarTE.maxAmount && jarTE.doesContainerAccept(phialAspect)) { + if (world.isRemote) { + player.swingItem(); + return false; + } + + if (jarTE.addToContainer(phialAspect, 8) == 0) { + world.markBlockForUpdate(x, y, z); + jarTE.markDirty(); + heldItem.stackSize--; + // Drop on ground if there's no inventory space + if (!player.inventory.addItemStackToInventory(new ItemStack(ConfigItems.itemEssence, 1, 0))) { + world.spawnEntityInWorld( + new EntityItem( + world, + (float) x + 0.5F, + (float) y + 0.5F, + (float) z + 0.5F, + new ItemStack(ConfigItems.itemEssence, 1, 0))); + } + + world.playSoundAtEntity(player, "game.neutral.swim", 0.25F, 1.0F); + player.inventoryContainer.detectAndSendChanges(); + return true; + } + } + } + } + + return true; + } + + @Override + public void breakBlock(World world, int x, int y, int z, Block par5, int par6) { + final TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof TE_IchorJar) { + final TE_IchorJar ite = (TE_IchorJar) te; + breakBlockWarpy(world, x, y, z, ite.amount, 200, 6.0F); + } else if (te instanceof TE_IchorVoidJar) { + final TE_IchorVoidJar ite = (TE_IchorVoidJar) te; + breakBlockWarpy(world, x, y, z, ite.amount, 200, 6.0F); + } + super.breakBlock(world, x, y, z, par5, par6); + } + + private void breakBlockWarpy(World world, int x, int y, int z, int fillAmount, int iterations, + float explosionStrength) { + if (fillAmount > 0) { + // Create a decent explosion in the center of the block (TNT has strength 4.0F) + world.createExplosion(null, x + 0.5D, y + 0.5D, z + 0.5D, explosionStrength, false); + + // Place a lot of Flux in the area + final int limit = fillAmount / 16; + int created = 0; + for (int i = 0; i < iterations; i++) { + final int xf = x + world.rand.nextInt(7) - world.rand.nextInt(7); + final int yf = x + world.rand.nextInt(7) - world.rand.nextInt(7); + final int zf = x + world.rand.nextInt(7) - world.rand.nextInt(7); + if (world.isAirBlock(xf, yf, zf)) { + if (yf > y) { + world.setBlock(xf, yf, zf, ConfigBlocks.blockFluxGas, 8, 3); + } else { + world.setBlock(xf, yf, zf, ConfigBlocks.blockFluxGoo, 8, 3); + } + + if (created++ > limit) { + break; + } + } + } + } + } + + @Override + public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int meta, int fortune) { + return new ArrayList<>(Collections.singleton(new ItemStack(this, 1, (meta == 3) ? 3 : 0))); + } + + @Override + public void onBlockHarvested(World par1World, int par2, int par3, int par4, int par5, + EntityPlayer par6EntityPlayer) {} + + @Override + public boolean canDropFromExplosion(Explosion e) { + return false; + } +} diff --git a/kekztech/src/main/java/common/blocks/Block_LapotronicEnergyUnit.java b/kekztech/src/main/java/common/blocks/Block_LapotronicEnergyUnit.java new file mode 100644 index 0000000000..653c99216b --- /dev/null +++ b/kekztech/src/main/java/common/blocks/Block_LapotronicEnergyUnit.java @@ -0,0 +1,173 @@ +package common.blocks; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; + +import common.itemBlocks.IB_LapotronicEnergyUnit; + +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Utility; + +public class Block_LapotronicEnergyUnit extends BaseGTUpdateableBlock { + + private static final Block_LapotronicEnergyUnit INSTANCE = new Block_LapotronicEnergyUnit(); + + public enum IconBaseSide implements IIconContainer { + + INSTANCE; + + @Override + public IIcon getIcon() { + return Block_LapotronicEnergyUnit.INSTANCE.iconBaseSide; + } + + @Override + public IIcon getOverlayIcon() { + return null; + } + + @Override + public ResourceLocation getTextureFile() { + return TextureMap.locationBlocksTexture; + } + } + + static { + // technically, this page is owned by me, glee8e, however, I'm kind enough to spare 1 for kekztech since + // this is basically abandon ware by now. + GT_Utility.addTexturePage((byte) 42); + Textures.BlockIcons.setCasingTexture((byte) 42, (byte) 127, TextureFactory.of(IconBaseSide.INSTANCE)); + } + + private IIcon iconBaseSide; + private IIcon iconBaseTop; + + private IIcon iconLapoEmptySide; + private IIcon iconLapoEmptyTop; + private IIcon iconLapoEVSide; + private IIcon iconLapoEVTop; + private IIcon iconLapoIVSide; + private IIcon iconLapoIVTop; + private IIcon iconLapoLuVSide; + private IIcon iconLapoLuVTop; + private IIcon iconLapoZPMSide; + private IIcon iconLapoZPMTop; + private IIcon iconLapoUVSide; + private IIcon iconLapoUVTop; + private IIcon iconUltimateSide; + private IIcon iconUltimateTop; + private IIcon iconUltimateExtremeSide; + private IIcon iconUltimateExtremeTop; + private IIcon iconUltimateInsaneSide; + private IIcon iconUltimateInsaneTop; + private IIcon iconUltimateMegaSide; + private IIcon iconUltimateMegaTop; + + private Block_LapotronicEnergyUnit() { + super(Material.iron); + } + + public static Block registerBlock() { + final String blockName = "kekztech_lapotronicenergyunit_block"; + INSTANCE.setBlockName(blockName); + INSTANCE.setCreativeTab(CreativeTabs.tabMisc); + INSTANCE.setHardness(5.0f); + INSTANCE.setResistance(6.0f); + GameRegistry.registerBlock(INSTANCE, IB_LapotronicEnergyUnit.class, blockName); + + return INSTANCE; + } + + @Override + public void registerBlockIcons(IIconRegister ir) { + iconBaseSide = ir.registerIcon("kekztech:LSCBase_side"); + iconBaseTop = ir.registerIcon("kekztech:LSCBase_top"); + + iconLapoEmptySide = ir.registerIcon("kekztech:LapotronicEnergyUnit6_side"); + iconLapoEmptyTop = ir.registerIcon("kekztech:LapotronicEnergyUnit6_top"); + iconLapoEVSide = ir.registerIcon("kekztech:LapotronicEnergyUnit7_side"); + iconLapoEVTop = ir.registerIcon("kekztech:LapotronicEnergyUnit7_top"); + iconLapoIVSide = ir.registerIcon("kekztech:LapotronicEnergyUnit1_side"); + iconLapoIVTop = ir.registerIcon("kekztech:LapotronicEnergyUnit1_top"); + iconLapoLuVSide = ir.registerIcon("kekztech:LapotronicEnergyUnit2_side"); + iconLapoLuVTop = ir.registerIcon("kekztech:LapotronicEnergyUnit2_top"); + iconLapoZPMSide = ir.registerIcon("kekztech:LapotronicEnergyUnit3_side"); + iconLapoZPMTop = ir.registerIcon("kekztech:LapotronicEnergyUnit3_top"); + iconLapoUVSide = ir.registerIcon("kekztech:LapotronicEnergyUnit4_side"); + iconLapoUVTop = ir.registerIcon("kekztech:LapotronicEnergyUnit4_top"); + + iconUltimateSide = ir.registerIcon("kekztech:UltimateEnergyUnit_side"); + iconUltimateTop = ir.registerIcon("kekztech:UltimateEnergyUnit_top"); + iconUltimateExtremeSide = ir.registerIcon("kekztech:ReallyUltimateEnergyUnit_side"); + iconUltimateExtremeTop = ir.registerIcon("kekztech:ReallyUltimateEnergyUnit_top"); + iconUltimateInsaneSide = ir.registerIcon("kekztech:InsanelyUltimateEnergyUnit_side"); + iconUltimateInsaneTop = ir.registerIcon("kekztech:InsanelyUltimateEnergyUnit_top"); + iconUltimateMegaSide = ir.registerIcon("kekztech:MegaUltimateEnergyUnit_side"); + iconUltimateMegaTop = ir.registerIcon("kekztech:MegaUltimateEnergyUnit_top"); + } + + @Override + @SuppressWarnings({ "unchecked" }) + public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) { + // Multi casing + par3List.add(new ItemStack(par1, 1, 0)); + // Empty capacitor + par3List.add(new ItemStack(par1, 1, 6)); + // Lapo capacitors EV - UV + par3List.add(new ItemStack(par1, 1, 7)); + par3List.add(new ItemStack(par1, 1, 1)); + par3List.add(new ItemStack(par1, 1, 2)); + par3List.add(new ItemStack(par1, 1, 3)); + par3List.add(new ItemStack(par1, 1, 4)); + // Ultimate battery + par3List.add(new ItemStack(par1, 1, 5)); + // UEV Cap + par3List.add(new ItemStack(par1, 1, 8)); + // UIV Cap + par3List.add(new ItemStack(par1, 1, 9)); + // UMV Cap + par3List.add(new ItemStack(par1, 1, 10)); + } + + @Override + public IIcon getIcon(int side, int meta) { + switch (meta) { + case 0: + return (side < 2) ? iconBaseTop : iconBaseSide; + case 1: + return (side < 2) ? iconLapoIVTop : iconLapoIVSide; + case 2: + return (side < 2) ? iconLapoLuVTop : iconLapoLuVSide; + case 3: + return (side < 2) ? iconLapoZPMTop : iconLapoZPMSide; + case 4: + return (side < 2) ? iconLapoUVTop : iconLapoUVSide; + case 5: + return (side < 2) ? iconUltimateTop : iconUltimateSide; + case 6: + return (side < 2) ? iconLapoEmptyTop : iconLapoEmptySide; + case 7: + return (side < 2) ? iconLapoEVTop : iconLapoEVSide; + case 8: + return (side < 2) ? iconUltimateExtremeTop : iconUltimateExtremeSide; + case 9: + return (side < 2) ? iconUltimateInsaneTop : iconUltimateInsaneSide; + case 10: + return (side < 2) ? iconUltimateMegaTop : iconUltimateMegaSide; + default: + return iconUltimateTop; + } + } +} diff --git a/kekztech/src/main/java/common/blocks/Block_LargeHexPlate.java b/kekztech/src/main/java/common/blocks/Block_LargeHexPlate.java new file mode 100644 index 0000000000..ac8174ff34 --- /dev/null +++ b/kekztech/src/main/java/common/blocks/Block_LargeHexPlate.java @@ -0,0 +1,65 @@ +package common.blocks; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; + +import cpw.mods.fml.common.registry.GameRegistry; + +public class Block_LargeHexPlate extends Block { + + private static final Block_LargeHexPlate INSTANCE = new Block_LargeHexPlate(); + private static final int BATCH_SIZE = 4; + + private final IIcon[][] parts = new IIcon[BATCH_SIZE][BATCH_SIZE]; + + private Block_LargeHexPlate() { + super(Material.rock); + } + + public static Block registerBlock() { + final String blockName = "kekztech_largehextile_block"; + INSTANCE.setBlockName(blockName); + INSTANCE.setCreativeTab(CreativeTabs.tabMisc); + INSTANCE.setHardness(6.0f); + INSTANCE.setResistance(10.0f); + GameRegistry.registerBlock(INSTANCE, blockName); + + return INSTANCE; + } + + @Override + public void registerBlockIcons(IIconRegister ir) { + for (int x = 0; x < BATCH_SIZE; x++) { + for (int z = 0; z < BATCH_SIZE; z++) { + parts[x][z] = ir.registerIcon("kekztech:LargeHexTile_" + x + "_" + z); + } + } + } + + @Override + public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) { + final int xMod = x >= 0 ? Math.abs(x % BATCH_SIZE) + : Math.abs((Math.abs(x) % BATCH_SIZE) - BATCH_SIZE) % BATCH_SIZE; + final int yMod = y >= 0 ? Math.abs(y % BATCH_SIZE) + : Math.abs((Math.abs(y) % BATCH_SIZE) - BATCH_SIZE) % BATCH_SIZE; + final int zMod = z >= 0 ? Math.abs(z % BATCH_SIZE) + : Math.abs((Math.abs(z) % BATCH_SIZE) - BATCH_SIZE) % BATCH_SIZE; + + if (side == 0 || side == 1) { + return parts[xMod][zMod]; + } else if (side == 2 || side == 3) { + return parts[xMod][yMod]; + } else { + return parts[zMod][yMod]; + } + } + + @Override + public IIcon getIcon(int side, int meta) { + return parts[(int) Math.ceil(BATCH_SIZE / 2)][(int) Math.ceil(BATCH_SIZE / 2)]; + } +} diff --git a/kekztech/src/main/java/common/blocks/Block_TFFTStorageField.java b/kekztech/src/main/java/common/blocks/Block_TFFTStorageField.java new file mode 100644 index 0000000000..069dd40dca --- /dev/null +++ b/kekztech/src/main/java/common/blocks/Block_TFFTStorageField.java @@ -0,0 +1,92 @@ +package common.blocks; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.ResourceLocation; + +import common.itemBlocks.IB_TFFTStorageField; +import common.tileentities.GTMTE_TFFT; + +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Utility; +import kekztech.KekzCore; + +public class Block_TFFTStorageField extends BaseGTUpdateableBlock { + + private static final Block_TFFTStorageField INSTANCE = new Block_TFFTStorageField(); + private static final int SUB_BLOCK_COUNT = GTMTE_TFFT.Field.VALUES.length + 1; + private static final IIcon[] textures = new IIcon[SUB_BLOCK_COUNT]; + + public enum TFFTCasingIcon implements IIconContainer { + + INSTANCE; + + @Override + public IIcon getIcon() { + return textures[0]; + } + + @Override + public IIcon getOverlayIcon() { + return null; + } + + @Override + public ResourceLocation getTextureFile() { + return TextureMap.locationBlocksTexture; + } + } + + // I guess glodblock won't mind + static { + GT_Utility.addTexturePage((byte) 12); + Textures.BlockIcons + .setCasingTexture((byte) 12, (byte) 127, TextureFactory.of(Block_TFFTStorageField.TFFTCasingIcon.INSTANCE)); + } + + private Block_TFFTStorageField() { + super(Material.iron); + } + + public static Block registerBlock() { + final String blockName = "kekztech_tfftstoragefield_block"; + INSTANCE.setBlockName(blockName); + INSTANCE.setCreativeTab(CreativeTabs.tabMisc); + INSTANCE.setHardness(5.0f); + INSTANCE.setResistance(6.0f); + GameRegistry.registerBlock(INSTANCE, IB_TFFTStorageField.class, blockName); + + return INSTANCE; + } + + @Override + public void registerBlockIcons(IIconRegister ir) { + textures[0] = ir.registerIcon(KekzCore.MODID + ":" + "TFFTCasing"); + for (int i = 1; i < SUB_BLOCK_COUNT; i++) { + textures[i] = ir.registerIcon(KekzCore.MODID + ":" + "TFFTStorageFieldBlock" + i); + } + } + + @Override + public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) { + for (int i = 0; i < SUB_BLOCK_COUNT; i++) { + par3List.add(new ItemStack(par1, 1, i)); + } + } + + @Override + public IIcon getIcon(int side, int meta) { + return textures[meta]; + } +} diff --git a/kekztech/src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java b/kekztech/src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java new file mode 100644 index 0000000000..3c91ac6d0d --- /dev/null +++ b/kekztech/src/main/java/common/blocks/Block_ThaumiumReinforcedJar.java @@ -0,0 +1,252 @@ +package common.blocks; + +import java.util.ArrayList; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.Explosion; +import net.minecraft.world.World; + +import common.itemBlocks.IB_ThaumiumReinforcedJar; +import common.tileentities.TE_ThaumiumReinforcedJar; +import common.tileentities.TE_ThaumiumReinforcedVoidJar; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.AspectList; +import thaumcraft.common.blocks.BlockJar; +import thaumcraft.common.config.ConfigBlocks; +import thaumcraft.common.config.ConfigItems; +import thaumcraft.common.items.ItemEssence; +import thaumcraft.common.tiles.TileJarFillable; + +public class Block_ThaumiumReinforcedJar extends BlockJar { + + private static final Block_ThaumiumReinforcedJar INSTANCE = new Block_ThaumiumReinforcedJar(); + + private Block_ThaumiumReinforcedJar() { + super(); + + super.setHardness(6.0F); + super.setResistance(6.0F); + } + + public static Block registerBlock() { + final String blockName = "kekztech_thaumiumreinforcedjar_block"; + INSTANCE.setBlockName(blockName); + INSTANCE.setHarvestLevel("pickaxe", 2); + GameRegistry.registerBlock(INSTANCE, IB_ThaumiumReinforcedJar.class, blockName); + + return INSTANCE; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister ir) { + super.iconLiquid = ir.registerIcon("thaumcraft:animatedglow"); + super.iconJarSide = ir.registerIcon("kekztech:thaumreinforced_jar_side"); + super.iconJarTop = ir.registerIcon("kekztech:thaumreinforced_jar_top"); + super.iconJarTopVoid = ir.registerIcon("kekztech:thaumreinforced_jar_top_void"); + super.iconJarSideVoid = ir.registerIcon("kekztech:thaumreinforced_jar_side_void"); + super.iconJarBottom = ir.registerIcon("kekztech:thaumreinforced_jar_bottom"); + } + + @Override + @SideOnly(Side.CLIENT) + @SuppressWarnings({ "unchecked" }) + public void getSubBlocks(Item par1, CreativeTabs par2CreativeTabs, List par3List) { + par3List.add(new ItemStack(par1, 1, 0)); // Normal jar + par3List.add(new ItemStack(par1, 1, 3)); // Void jar + } + + @Override + public TileEntity createTileEntity(World world, int meta) { + if (meta == 3) { + return new TE_ThaumiumReinforcedVoidJar(); + } else { + return new TE_ThaumiumReinforcedJar(); + } + } + + @Override + public void breakBlock(World world, int x, int y, int z, Block par5, int par6) { + final TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof TE_ThaumiumReinforcedJar) { + final TE_ThaumiumReinforcedJar ite = (TE_ThaumiumReinforcedJar) te; + breakBlockWarpy(world, x, y, z, ite.amount, 50, 1.0F); + } else if (te instanceof TE_ThaumiumReinforcedVoidJar) { + final TE_ThaumiumReinforcedVoidJar ite = (TE_ThaumiumReinforcedVoidJar) te; + breakBlockWarpy(world, x, y, z, ite.amount, 50, 1.0F); + } + super.breakBlock(world, x, y, z, par5, par6); + } + + private void breakBlockWarpy(World world, int x, int y, int z, int fillAmount, int iterations, + float explosionStrength) { + if (fillAmount > 0) { + // Create a decent explosion in the center of the block (TNT has strength 4.0F) + world.createExplosion(null, x + 0.5D, y + 0.5D, z + 0.5D, explosionStrength, false); + + // Place a lot of Flux in the area + final int limit = fillAmount / 16; + int created = 0; + for (int i = 0; i < iterations; i++) { + final int xf = x + world.rand.nextInt(7) - world.rand.nextInt(7); + final int yf = x + world.rand.nextInt(7) - world.rand.nextInt(7); + final int zf = x + world.rand.nextInt(7) - world.rand.nextInt(7); + if (world.isAirBlock(xf, yf, zf)) { + if (yf > y) { + world.setBlock(xf, yf, zf, ConfigBlocks.blockFluxGas, 8, 3); + } else { + world.setBlock(xf, yf, zf, ConfigBlocks.blockFluxGoo, 8, 3); + } + + if (created++ > limit) { + break; + } + } + } + } + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float f1, float f2, + float f3) { + // Call parent method to handle jar emptying, labels stuff etc + super.onBlockActivated(world, x, y, z, player, side, f1, f2, f3); + // Interact with Essentia Phials if the player holds one + final ItemStack heldItem = player.getHeldItem(); + if (heldItem != null && heldItem.getItem() == ConfigItems.itemEssence) { + final TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof TE_ThaumiumReinforcedJar) { + return dealWithPhial(world, player, x, y, z); + } else if (te instanceof TE_ThaumiumReinforcedVoidJar) { + return dealWithPhial(world, player, x, y, z); + } + } + + return true; + } + + /** + * Handle compatibility with Essentia Phials + * + * @param world Pass through from onBlockActivated() + * @param player Pass through from onBlockActivated() + * @param x Pass through from onBlockActivated() + * @param y Pass through from onBlockActivated() + * @param z Pass through from onBlockActivated() + * @return Not sure tbh + */ + private boolean dealWithPhial(World world, EntityPlayer player, int x, int y, int z) { + final TileJarFillable kte = (TileJarFillable) world.getTileEntity(x, y, z); + final ItemStack heldItem = player.getHeldItem(); + // Check whether to fill or to drain the phial + if (heldItem.getItemDamage() == 0) { + if (kte.amount >= 8) { + if (world.isRemote) { + player.swingItem(); + return false; + } + + final Aspect jarAspect = Aspect.getAspect(kte.aspect.getTag()); + if (kte.takeFromContainer(jarAspect, 8)) { + // Take an empty phial from the player's inventory + heldItem.stackSize--; + // Fill a new phial + final ItemStack filledPhial = new ItemStack(ConfigItems.itemEssence, 1, 1); + final AspectList phialContent = new AspectList().add(jarAspect, 8); + ((ItemEssence) ConfigItems.itemEssence).setAspects(filledPhial, phialContent); + // Drop on ground if there's no inventory space + if (!player.inventory.addItemStackToInventory(filledPhial)) { + world.spawnEntityInWorld( + new EntityItem(world, (float) x + 0.5F, (float) y + 0.5F, (float) z + 0.5F, filledPhial)); + } + + world.playSoundAtEntity(player, "game.neutral.swim", 0.25F, 1.0F); + player.inventoryContainer.detectAndSendChanges(); + return true; + } + } + } else { + final AspectList phialContent = ((ItemEssence) ConfigItems.itemEssence).getAspects(heldItem); + if (phialContent != null && phialContent.size() == 1) { + final Aspect phialAspect = phialContent.getAspects()[0]; + if (kte.amount + 8 <= kte.maxAmount && kte.doesContainerAccept(phialAspect)) { + if (world.isRemote) { + player.swingItem(); + return false; + } + + if (kte.addToContainer(phialAspect, 8) == 0) { + world.markBlockForUpdate(x, y, z); + kte.markDirty(); + heldItem.stackSize--; + // Drop on ground if there's no inventory space + if (!player.inventory.addItemStackToInventory(new ItemStack(ConfigItems.itemEssence, 1, 0))) { + world.spawnEntityInWorld( + new EntityItem( + world, + (float) x + 0.5F, + (float) y + 0.5F, + (float) z + 0.5F, + new ItemStack(ConfigItems.itemEssence, 1, 0))); + } + + world.playSoundAtEntity(player, "game.neutral.swim", 0.25F, 1.0F); + player.inventoryContainer.detectAndSendChanges(); + return true; + } + } + } + } + + return true; + } + + @Override + public ArrayList<ItemStack> getDrops(World world, int x, int y, int z, int meta, int fortune) { + final ArrayList<ItemStack> drops = new ArrayList<>(); + drops.add(new ItemStack(this, 1, (meta == 3) ? 3 : 0)); + final TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof TE_ThaumiumReinforcedJar) { + final TE_ThaumiumReinforcedJar ite = (TE_ThaumiumReinforcedJar) te; + if (ite.aspectFilter != null) { + final ItemStack droppedLabel = new ItemStack(ConfigItems.itemResource, 1, 13); + droppedLabel.setTagCompound(new NBTTagCompound()); + final AspectList aspect = new AspectList().add(ite.aspectFilter, 0); + aspect.writeToNBT(droppedLabel.getTagCompound()); + drops.add(droppedLabel); + } + } else if (te instanceof TE_ThaumiumReinforcedVoidJar) { + final TE_ThaumiumReinforcedVoidJar ite = (TE_ThaumiumReinforcedVoidJar) te; + if (ite.aspectFilter != null) { + final ItemStack droppedLabel = new ItemStack(ConfigItems.itemResource, 1, 13); + droppedLabel.setTagCompound(new NBTTagCompound()); + final AspectList aspect = new AspectList().add(ite.aspectFilter, 0); + aspect.writeToNBT(droppedLabel.getTagCompound()); + drops.add(droppedLabel); + } + } + return drops; + } + + @Override + public void onBlockHarvested(World par1World, int par2, int par3, int par4, int par5, + EntityPlayer par6EntityPlayer) {} + + @Override + public boolean canDropFromExplosion(Explosion e) { + return false; + } +} diff --git a/kekztech/src/main/java/common/blocks/Block_YSZUnit.java b/kekztech/src/main/java/common/blocks/Block_YSZUnit.java new file mode 100644 index 0000000000..312d3250a4 --- /dev/null +++ b/kekztech/src/main/java/common/blocks/Block_YSZUnit.java @@ -0,0 +1,29 @@ +package common.blocks; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.creativetab.CreativeTabs; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; + +public class Block_YSZUnit extends BaseGTUpdateableBlock { + + private static final Block_YSZUnit instance = new Block_YSZUnit(); + + private Block_YSZUnit() { + super(Material.iron); + } + + public static Block registerBlock() { + final String blockName = "kekztech_yszceramicelectrolyteunit_block"; + instance.setBlockName(blockName); + instance.setCreativeTab(CreativeTabs.tabMisc); + instance.setBlockTextureName(KekzCore.MODID + ":" + "YSZCeramicElectrolyteUnit"); + instance.setHardness(5.0f); + instance.setResistance(6.0f); + GameRegistry.registerBlock(instance, blockName); + + return instance; + } +} diff --git a/kekztech/src/main/java/common/itemBlocks/IB_IchorJar.java b/kekztech/src/main/java/common/itemBlocks/IB_IchorJar.java new file mode 100644 index 0000000000..6e2d806a7e --- /dev/null +++ b/kekztech/src/main/java/common/itemBlocks/IB_IchorJar.java @@ -0,0 +1,27 @@ +package common.itemBlocks; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; + +public class IB_IchorJar extends ItemBlock { + + public IB_IchorJar(Block block) { + super(block); + } + + @Override + public int getMetadata(int meta) { + return meta; + } + + @Override + public boolean getHasSubtypes() { + return true; + } + + @Override + public String getUnlocalizedName(ItemStack stack) { + return super.getUnlocalizedName() + "." + stack.getItemDamage(); + } +} diff --git a/kekztech/src/main/java/common/itemBlocks/IB_LapotronicEnergyUnit.java b/kekztech/src/main/java/common/itemBlocks/IB_LapotronicEnergyUnit.java new file mode 100644 index 0000000000..971aac494a --- /dev/null +++ b/kekztech/src/main/java/common/itemBlocks/IB_LapotronicEnergyUnit.java @@ -0,0 +1,190 @@ +package common.itemBlocks; + +import static com.google.common.math.LongMath.pow; + +import java.math.BigInteger; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; + +import gregtech.api.enums.GT_Values; +import gregtech.api.util.GT_Utility; + +public class IB_LapotronicEnergyUnit extends ItemBlock { + + public IB_LapotronicEnergyUnit(Block block) { + super(block); + } + + @Override + public int getMetadata(int meta) { + return meta; + } + + @Override + public boolean getHasSubtypes() { + return true; + } + + @Override + public String getUnlocalizedName(ItemStack stack) { + return super.getUnlocalizedName() + "." + stack.getItemDamage(); + } + + // 5 Minutes, 5 mins * 60s * 20 ticks. + public static long LSC_time_between_wireless_rebalance_in_ticks = 5L * 60L * 20L; + + // 60 Trillion EU. + public static BigInteger LSC_wireless_eu_cap = BigInteger.valueOf(60 * pow(10, 12)); + + // 10 Billion EU/t + private static final BigInteger UHV_cap_eu_per_tick = LSC_wireless_eu_cap + .divide(BigInteger.valueOf(LSC_time_between_wireless_rebalance_in_ticks)); + + // 6 Quadrillion EU. + public static BigInteger UEV_wireless_eu_cap = BigInteger.valueOf(100 * 60 * pow(10, 12)); + + // 1 Trillion EU/t + private static final BigInteger UEV_cap_eu_per_tick = UEV_wireless_eu_cap + .divide(BigInteger.valueOf(LSC_time_between_wireless_rebalance_in_ticks)); + + // 600 Quadrillion EU. + public static BigInteger UIV_wireless_eu_cap = BigInteger.valueOf(60 * pow(10, 16)); + + // 100 Trillion EU/t + private static final BigInteger UIV_cap_eu_per_tick = UIV_wireless_eu_cap + .divide(BigInteger.valueOf(LSC_time_between_wireless_rebalance_in_ticks)); + + // 60 Quintillion EU. + public static BigInteger UMV_wireless_eu_cap = UIV_wireless_eu_cap.multiply(BigInteger.valueOf(100)); + + // 10 Quadrillion EU/t + private static final BigInteger UMV_cap_eu_per_tick = UMV_wireless_eu_cap + .divide(BigInteger.valueOf(LSC_time_between_wireless_rebalance_in_ticks)); + + public static long EV_cap_storage = 60_000_000L; + public static long IV_cap_storage = 600_000_000L; + public static long LuV_cap_storage = 6_000_000_000L; + public static long ZPM_cap_storage = 60_000_000_000L; + public static long UV_cap_storage = 600_000_000_000L; + public static long UHV_cap_storage = Long.MAX_VALUE; + public static long UEV_cap_storage = Long.MAX_VALUE; + public static long UIV_cap_storage = Long.MAX_VALUE; + public static BigInteger UMV_cap_storage = BigInteger.valueOf(UIV_cap_storage) + .pow(2); + + @SuppressWarnings("unchecked") + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List lines, boolean advancedTooltips) { + lines.add(StatCollector.translateToLocal("tile.kekztech_lapotronicenergyunit_block.desc")); + switch (stack.getItemDamage()) { + case 1: + lines.add( + "Capacity: " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(IV_cap_storage) + + EnumChatFormatting.GRAY + + "EU"); + break; + case 2: + lines.add( + "Capacity: " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(LuV_cap_storage) + + EnumChatFormatting.GRAY + + "EU"); + break; + case 3: + lines.add( + "Capacity: " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(ZPM_cap_storage) + + EnumChatFormatting.GRAY + + "EU"); + break; + case 4: + lines.add( + "Capacity: " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(UV_cap_storage) + + EnumChatFormatting.GRAY + + "EU"); + break; + case 5: + lines.add( + "Capacity: " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(UHV_cap_storage) + + EnumChatFormatting.GRAY + + "EU"); + lines.add( + "Supports up to " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(UHV_cap_eu_per_tick) + + EnumChatFormatting.GRAY + + "EU/t of wireless transfer per " + + GT_Values.TIER_COLORS[9] + + GT_Values.VN[9] + + EnumChatFormatting.GRAY + + " capacitor."); + break; + case 6: + lines.add("Capacity: None"); + break; + case 7: + lines.add( + "Capacity: " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(EV_cap_storage) + + EnumChatFormatting.GRAY + + " EU"); + break; + case 8: + lines.add( + "Capacity: " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(UEV_cap_storage) + + EnumChatFormatting.GRAY + + "EU"); + lines.add( + "Supports up to " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(UEV_cap_eu_per_tick) + + EnumChatFormatting.GRAY + + "EU/t of wireless transfer per " + + GT_Values.TIER_COLORS[10] + + GT_Values.VN[10] + + EnumChatFormatting.GRAY + + " capacitor."); + break; + case 9: + lines.add( + "Capacity: " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(UIV_cap_storage) + + EnumChatFormatting.GRAY + + "EU"); + lines.add( + "Supports up to " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(UIV_cap_eu_per_tick) + + EnumChatFormatting.GRAY + + "EU/t of wireless transfer per " + + GT_Values.TIER_COLORS[11] + + GT_Values.VN[11] + + EnumChatFormatting.GRAY + + " capacitor."); + break; + case 10: + lines.add( + "Capacity: " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(UMV_cap_storage) + + EnumChatFormatting.GRAY + + "EU"); + lines.add( + "Supports up to " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(UMV_cap_eu_per_tick) + + EnumChatFormatting.GRAY + + "EU/t of wireless transfer per " + + GT_Values.TIER_COLORS[12] + + GT_Values.VN[12] + + EnumChatFormatting.GRAY + + " capacitor."); + break; + } + } +} diff --git a/kekztech/src/main/java/common/itemBlocks/IB_TFFTStorageField.java b/kekztech/src/main/java/common/itemBlocks/IB_TFFTStorageField.java new file mode 100644 index 0000000000..43f4523f27 --- /dev/null +++ b/kekztech/src/main/java/common/itemBlocks/IB_TFFTStorageField.java @@ -0,0 +1,63 @@ +package common.itemBlocks; + +import java.text.NumberFormat; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; + +import common.tileentities.GTMTE_TFFT; + +public class IB_TFFTStorageField extends ItemBlock { + + private static final int UNIQUE_FLUIDS_PER_CELL = 25; + + public IB_TFFTStorageField(Block block) { + super(block); + } + + @Override + public int getMetadata(int meta) { + return meta; + } + + @Override + public boolean getHasSubtypes() { + return true; + } + + @Override + public String getUnlocalizedName(ItemStack stack) { + return super.getUnlocalizedName() + "." + stack.getItemDamage(); + } + + @SuppressWarnings("unchecked") + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List lines, boolean advancedTooltips) { + int meta = stack.getItemDamage(); + if (meta > 0) { + lines.add(StatCollector.translateToLocal("tile.kekztech_tfftstoragefield_block.desc")); + lines.add( + "Capacity: " + EnumChatFormatting.BLUE + + NumberFormat.getNumberInstance() + .format(GTMTE_TFFT.Field.VALUES[meta - 1].getCapacity()) + + EnumChatFormatting.GRAY + + " L"); + lines.add( + "Per Fluid Capacity: " + EnumChatFormatting.BLUE + + NumberFormat.getNumberInstance() + .format(GTMTE_TFFT.Field.VALUES[meta - 1].getCapacity() / UNIQUE_FLUIDS_PER_CELL) + + EnumChatFormatting.GRAY + + " L"); + lines.add( + "Power Draw: " + EnumChatFormatting.BLUE + + GTMTE_TFFT.Field.VALUES[meta - 1].getCost() + + EnumChatFormatting.GRAY + + " EU/t"); + } + } +} diff --git a/kekztech/src/main/java/common/itemBlocks/IB_ThaumiumReinforcedJar.java b/kekztech/src/main/java/common/itemBlocks/IB_ThaumiumReinforcedJar.java new file mode 100644 index 0000000000..9299126d67 --- /dev/null +++ b/kekztech/src/main/java/common/itemBlocks/IB_ThaumiumReinforcedJar.java @@ -0,0 +1,27 @@ +package common.itemBlocks; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; + +public class IB_ThaumiumReinforcedJar extends ItemBlock { + + public IB_ThaumiumReinforcedJar(Block block) { + super(block); + } + + @Override + public int getMetadata(int meta) { + return meta; + } + + @Override + public boolean getHasSubtypes() { + return true; + } + + @Override + public String getUnlocalizedName(ItemStack stack) { + return super.getUnlocalizedName() + "." + stack.getItemDamage(); + } +} diff --git a/kekztech/src/main/java/common/items/ErrorItem.java b/kekztech/src/main/java/common/items/ErrorItem.java new file mode 100644 index 0000000000..997686a114 --- /dev/null +++ b/kekztech/src/main/java/common/items/ErrorItem.java @@ -0,0 +1,48 @@ +package common.items; + +import java.util.List; + +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; + +public class ErrorItem extends Item { + + private static final ErrorItem INSTANCE = new ErrorItem(); + + private ErrorItem() {} + + public static ErrorItem getInstance() { + return INSTANCE; + } + + public void registerItem() { + super.setHasSubtypes(false); + final String unlocalizedName = "kekztech_error_item"; + super.setUnlocalizedName(unlocalizedName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setMaxStackSize(64); + super.setTextureName(KekzCore.MODID + ":" + "Error"); + GameRegistry.registerItem(getInstance(), unlocalizedName); + } + + @SuppressWarnings({ "unchecked" }) + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean b) { + list.add("REMINDER: KekzTech recipes are only tested to work in GTNH!"); + list.add("Placeholder item in case something went wrong"); + list.add("If this item shows up in GTNH, you may report it to:"); + list.add("https://github.com/kekzdealer/KekzTech"); + } + + @Override + public ItemStack onItemRightClick(ItemStack item, World world, EntityPlayer player) { + player.swingItem(); + return item; + } +} diff --git a/kekztech/src/main/java/common/items/MetaItem_CraftingComponent.java b/kekztech/src/main/java/common/items/MetaItem_CraftingComponent.java new file mode 100644 index 0000000000..205e7392c5 --- /dev/null +++ b/kekztech/src/main/java/common/items/MetaItem_CraftingComponent.java @@ -0,0 +1,89 @@ +package common.items; + +import java.util.List; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +import cpw.mods.fml.common.registry.GameRegistry; +import kekztech.KekzCore; + +public class MetaItem_CraftingComponent extends Item { + + private static final MetaItem_CraftingComponent INSTANCE = new MetaItem_CraftingComponent(); + private final IIcon[] icons = new IIcon[16]; + + private MetaItem_CraftingComponent() {} + + public static MetaItem_CraftingComponent getInstance() { + return INSTANCE; + } + + public void registerItem() { + super.setHasSubtypes(true); + final String unlocalizedName = "kekztech_crafting_item"; + super.setUnlocalizedName(unlocalizedName); + super.setCreativeTab(CreativeTabs.tabMisc); + super.setMaxStackSize(64); + GameRegistry.registerItem(getInstance(), unlocalizedName); + } + + @Override + public void registerIcons(IIconRegister reg) { + int counter = 9; + // Ceramics + icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "YSZCeramicDust"); + icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "GDCCeramicDust"); + icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "YttriaDust"); + icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "ZirconiaDust"); + icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "CeriaDust"); + icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "YSZCeramicPlate"); + icons[counter++] = reg.registerIcon(KekzCore.MODID + ":" + "GDCCeramicPlate"); + } + + @Override + public IIcon getIconFromDamage(int meta) { + return icons[meta]; + } + + @SuppressWarnings({ "unchecked" }) + @Override + public void getSubItems(Item item, CreativeTabs tab, List list) { + for (int i = 9; i < icons.length; i++) { + list.add(new ItemStack(item, 1, i)); + } + } + + @Override + public String getUnlocalizedName(ItemStack stack) { + return super.getUnlocalizedName() + "." + stack.getItemDamage(); + } + + @SuppressWarnings({ "unchecked" }) + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean b) { + list.add("Crafting component for KekzTech things"); + } + + @Override + public double getDurabilityForDisplay(ItemStack stack) { + return 0.0d; + } + + @Override + public boolean showDurabilityBar(ItemStack stack) { + return false; + } + + public ItemStack getStackFromDamage(int meta) { + return new ItemStack(getInstance(), 1, meta); + } + + public ItemStack getStackOfAmountFromDamage(int meta, int amount) { + return new ItemStack(getInstance(), amount, meta); + } +} diff --git a/kekztech/src/main/java/common/recipeLoaders/AlloySmelter.java b/kekztech/src/main/java/common/recipeLoaders/AlloySmelter.java new file mode 100644 index 0000000000..2737d98f4a --- /dev/null +++ b/kekztech/src/main/java/common/recipeLoaders/AlloySmelter.java @@ -0,0 +1,32 @@ +package common.recipeLoaders; + +import static gregtech.api.enums.Mods.BartWorks; +import static gregtech.api.recipe.RecipeMaps.alloySmelterRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import common.items.MetaItem_CraftingComponent; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.TierEU; +import kekztech.Items; + +public class AlloySmelter implements Runnable { + + @Override + public void run() { + if (BartWorks.isModLoaded()) { + final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance(); + + // YSZ Cermic Plate + GT_Values.RA.stdBuilder() + .itemInputs( + craftingItem.getStackOfAmountFromDamage(Items.YSZCeramicDust.getMetaID(), 3), + ItemList.Shape_Mold_Plate.get(0)) + .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.YSZCeramicPlate.getMetaID(), 1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(alloySmelterRecipes); + } + } +} diff --git a/kekztech/src/main/java/common/recipeLoaders/Assembler.java b/kekztech/src/main/java/common/recipeLoaders/Assembler.java new file mode 100644 index 0000000000..da6c863689 --- /dev/null +++ b/kekztech/src/main/java/common/recipeLoaders/Assembler.java @@ -0,0 +1,295 @@ +package common.recipeLoaders; + +import static gregtech.api.recipe.RecipeMaps.assemblerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidRegistry; + +import common.Blocks; +import common.TileEntities; +import common.items.ErrorItem; +import common.items.MetaItem_CraftingComponent; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import kekztech.Items; + +public class Assembler implements Runnable { + + @Override + public void run() { + // TFFT Casing + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(6), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.StainlessSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.DarkSteel, 3), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.EnderPearl, 3)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1)) + .fluidInputs(Materials.Polytetrafluoroethylene.getMolten(144)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // TFFT Multi Hatch + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Hull_HV.get(1), + ItemList.Cover_FluidStorageMonitor.get(1), + ItemList.Field_Generator_LV.get(4), + GT_OreDictUnificator.get(OrePrefixes.pipeTiny, Materials.Polytetrafluoroethylene, 25)) + .itemOutputs(TileEntities.tfftHatch.getStackForm(1)) + .fluidInputs(Materials.Plastic.getMolten(432)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // TFFTStorageField1 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(6), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CrudeSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CrudeSteel, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Steel, 3), + ItemList.FluidRegulator_LV.get(1)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 1)) + .fluidInputs(Materials.Glass.getMolten(144)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // TFFTStorageField2 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(6), + ItemList.Casing_Tank_1.get(1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.EnergeticSilver, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Plastic, 3), + ItemList.FluidRegulator_MV.get(1)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 2)) + .fluidInputs(Materials.Plastic.getMolten(288)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // TFFTStorageField3 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(6), + ItemList.Casing_Tank_3.get(1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.VividAlloy, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.StainlessSteel, 3), + ItemList.Field_Generator_LV.get(1), + ItemList.FluidRegulator_HV.get(1)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 3)) + .fluidInputs(Materials.Plastic.getMolten(432)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // TFFTStorageField4 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(6), + ItemList.Casing_Tank_5.get(1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Enderium, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Polytetrafluoroethylene, 3), + ItemList.Field_Generator_MV.get(2), + ItemList.FluidRegulator_EV.get(1)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 4)) + .fluidInputs(Materials.Epoxid.getMolten(864)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + // TFFTStorageField5 + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(6), + ItemList.Casing_Tank_7.get(1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CrystallineAlloy, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Enderium, 3), + ItemList.Field_Generator_HV.get(4), + ItemList.FluidRegulator_IV.get(1)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 5)) + .fluidInputs(Materials.Epoxid.getMolten(1152)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + // LSC Casing + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Tantalum, 4), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.TungstenSteel, 2), + GT_OreDictUnificator.get(OrePrefixes.stickLong, Materials.TungstenSteel, 2), + GT_OreDictUnificator.get(OrePrefixes.block, Materials.Lapis, 1)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 0)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // EV Capacitor alt recipe + + GT_Values.RA.stdBuilder() + .itemInputs( + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6), + GT_ModHandler.getIC2Item("lapotronCrystal", 1L, GT_Values.W), + GT_Utility.getIntegratedCircuit(7)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 7)) + .duration(10 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // IV Capacitor alt recipe + + GT_Values.RA.stdBuilder() + .itemInputs( + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6), + ItemList.Energy_LapotronicOrb.get(1L), + GT_Utility.getIntegratedCircuit(1)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 1)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + // LuV Capacitor alt recipe + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Energy_LapotronicOrb2.get(1), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmiridium, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Osmiridium, 24), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 2)) + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_IV) + .addTo(assemblerRecipes); + // ZPM Capacitor alt recipe + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Energy_Module.get(1), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.NaquadahAlloy, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.NaquadahAlloy, 24), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 3)) + .duration(1 * MINUTES + 20 * SECONDS) + .eut(TierEU.RECIPE_LuV) + .addTo(assemblerRecipes); + // UV Capacitor alt recipe + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.Energy_Cluster.get(1), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Neutronium, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Neutronium, 24), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 4)) + .duration(2 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_ZPM) + .addTo(assemblerRecipes); + // UHV Capacitor alt recipe + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.ZPM3.get(1), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.CosmicNeutronium, 24), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 5)) + .duration(5 * MINUTES + 20 * SECONDS) + .eut(TierEU.RECIPE_UV) + .addTo(assemblerRecipes); + // UEV Capacitor alt recipe + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.ZPM4.get(1), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Infinity, 24), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 8)) + .duration(10 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_UHV) + .addTo(assemblerRecipes); + // UIV Capacitor alt recipe + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.ZPM5.get(1), + GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.TranscendentMetal, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.TranscendentMetal, 24), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 9)) + .duration(10 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_UEV) + .addTo(assemblerRecipes); + // UMV Capacitor alt recipe + + GT_Values.RA.stdBuilder() + .itemInputs( + ItemList.ZPM6.get(1), + GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.SpaceTime, 24), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 10)) + .duration(10 * MINUTES + 40 * SECONDS) + .eut(TierEU.RECIPE_UIV) + .addTo(assemblerRecipes); + + final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance(); + + // YSZ Unit + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(6), + craftingItem.getStackOfAmountFromDamage(Items.YSZCeramicPlate.getMetaID(), 4), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Yttrium, 1), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.StainlessSteel, 1), + ItemList.Electric_Motor_HV.get(1L)) + .itemOutputs(new ItemStack(Blocks.yszUnit, 1)) + .fluidInputs(Materials.Hydrogen.getGas(4000)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(assemblerRecipes); + // GDC Unit + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(6), + craftingItem.getStackOfAmountFromDamage(Items.GDCCeramicPlate.getMetaID(), 8), + GT_OreDictUnificator + .get(OrePrefixes.frameGt, Materials.Gadolinium, new ItemStack(ErrorItem.getInstance(), 1), 1), + GT_OreDictUnificator + .get(OrePrefixes.rotor, Materials.Desh, new ItemStack(ErrorItem.getInstance(), 1), 1), + ItemList.Electric_Motor_IV.get(1L)) + .itemOutputs(new ItemStack(Blocks.gdcUnit, 1)) + .fluidInputs(Materials.Hydrogen.getGas(16000)) + .duration(2 * MINUTES) + .eut(TierEU.RECIPE_EV) + .addTo(assemblerRecipes); + // Hex Tiles + + GT_Values.RA.stdBuilder() + .itemInputs( + GT_Utility.getIntegratedCircuit(6), + GT_OreDictUnificator.get(OrePrefixes.stone, Materials.Concrete, 1), + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Steel, 1), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.DarkSteel, 2)) + .itemOutputs(new ItemStack(Blocks.largeHexPlate, 2)) + .fluidInputs(FluidRegistry.getFluidStack("molten.plastic", 36)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_MV) + .addTo(assemblerRecipes); + + } +} diff --git a/kekztech/src/main/java/common/recipeLoaders/AssemblyLine.java b/kekztech/src/main/java/common/recipeLoaders/AssemblyLine.java new file mode 100644 index 0000000000..cad3b4ec04 --- /dev/null +++ b/kekztech/src/main/java/common/recipeLoaders/AssemblyLine.java @@ -0,0 +1,227 @@ +package common.recipeLoaders; + +import static gregtech.api.enums.Mods.Avaritia; +import static gregtech.api.enums.Mods.EnderIO; +import static gregtech.api.enums.Mods.EternalSingularity; +import static gregtech.api.enums.Mods.GTPlusPlus; +import static gregtech.api.enums.Mods.GoodGenerator; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; +import static gregtech.api.enums.Mods.UniversalSingularities; +import static gregtech.api.util.GT_RecipeBuilder.HOURS; +import static gregtech.api.util.GT_RecipeBuilder.MINUTES; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeConstants.AssemblyLine; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_ITEM; +import static gregtech.api.util.GT_RecipeConstants.RESEARCH_TIME; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import common.Blocks; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; + +public class AssemblyLine implements Runnable { + + @Override + public void run() { + final Fluid radoxPoly = FluidRegistry.getFluid("molten.radoxpoly") != null + ? FluidRegistry.getFluid("molten.radoxpoly") + : FluidRegistry.getFluid("molten.polybenzimidazole"); + + final Fluid solderIndalloy = FluidRegistry.getFluid("molten.indalloy140") != null + ? FluidRegistry.getFluid("molten.indalloy140") + : FluidRegistry.getFluid("molten.solderingalloy"); + + // TFFTStorageField6 + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 5)) + .metadata(RESEARCH_TIME, 1 * HOURS + 6 * MINUTES + 40 * SECONDS) + .itemInputs( + ItemList.Casing_Tank_7.get(4), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.CrystallinePinkSlime, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Naquadah, 3), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.ChromeBars", 6), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.Quantium, 6), + ItemList.Field_Generator_EV.get(8), + ItemList.FluidRegulator_LuV.get(1), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EngineeringProcessorFluidEmeraldCore", 4)) + .fluidInputs(Materials.Enderium.getMolten(1440), Materials.Polybenzimidazole.getMolten(1584)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 6)) + .eut(TierEU.RECIPE_LuV) + .duration(30 * SECONDS) + .addTo(AssemblyLine); + + // TFFTStorageField7 + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 6)) + .metadata(RESEARCH_TIME, 1 * HOURS + 6 * MINUTES + 40 * SECONDS) + .itemInputs( + ItemList.Casing_Tank_10.get(16), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.MelodicAlloy, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.NetherStar, 3), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.OsmiumBars", 6), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.MysteriousCrystal, 6), + ItemList.Field_Generator_IV.get(16), + ItemList.Field_Generator_LuV.get(4), + ItemList.FluidRegulator_UV.get(1), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.EngineeringProcessorFluidEmeraldCore", 16)) + .fluidInputs(Materials.CrystallineAlloy.getMolten(2880), Materials.Polybenzimidazole.getMolten(2016)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 7)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_UV) + .addTo(AssemblyLine); + + // TFFTStorageField8 + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 7)) + .metadata(RESEARCH_TIME, 2 * HOURS + 40 * MINUTES) + .itemInputs( + ItemList.Quantum_Tank_IV.get(1), + GT_ModHandler.getModItem(Avaritia.ID, "Neutronium_Compressor", 1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StellarAlloy, 6), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StellarAlloy, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.DraconiumAwakened, 3), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.NeutroniumBars", 6), + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.InfinityCatalyst, 6), + ItemList.Field_Generator_ZPM.get(16), + ItemList.Field_Generator_UV.get(4), + GT_ModHandler.getModItem(GoodGenerator.ID, "huiCircuit", 4, 2), + GT_ModHandler.getModItem(UniversalSingularities.ID, "universal.tinkersConstruct.singularity", 1, 4)) + .fluidInputs(Materials.CrystallinePinkSlime.getMolten(4320), new FluidStack(radoxPoly, 2880)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 8)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_UEV) + .addTo(AssemblyLine); + + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 8)) + .metadata(RESEARCH_TIME, 2 * HOURS + 13 * MINUTES + 20 * SECONDS) + .itemInputs( + ItemList.Quantum_Tank_IV.get(4), + GT_ModHandler.getModItem(Avaritia.ID, "Neutronium_Compressor", 2), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 6), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, Materials.Infinity, 3), + ItemList.EnergisedTesseract.get(1), + GT_ModHandler.getModItem(GTPlusPlus.ID, "itemRotorHypogen", 6), + ItemList.Field_Generator_UHV.get(16), + ItemList.Field_Generator_UEV.get(4), + GT_ModHandler.getModItem(GoodGenerator.ID, "huiCircuit", 4, 3), + GT_ModHandler.getModItem(UniversalSingularities.ID, "universal.tinkersConstruct.singularity", 1, 4)) + .fluidInputs(Materials.MelodicAlloy.getMolten(5760), new FluidStack(radoxPoly, 3456)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 9)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_UMV) + .addTo(AssemblyLine); + + // TFFTStorageField10 + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, new ItemStack(Blocks.tfftStorageField, 1, 9)) + .metadata(RESEARCH_TIME, 2 * HOURS + 46 * MINUTES + 40 * SECONDS) + .itemInputs( + ItemList.Quantum_Tank_IV.get(16), + GT_ModHandler.getModItem(Avaritia.ID, "Neutronium_Compressor", 4), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 6), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 6), + GT_OreDictUnificator.get(OrePrefixes.pipeNonuple, MaterialsUEVplus.SpaceTime, 3), + ItemList.EnergisedTesseract.get(6), + GT_OreDictUnificator.get(OrePrefixes.rotor, MaterialsUEVplus.SpaceTime, 6), + ItemList.Field_Generator_UEV.get(16), + ItemList.Field_Generator_UIV.get(4), + GT_ModHandler.getModItem(GoodGenerator.ID, "huiCircuit", 4, 4), + GT_ModHandler.getModItem(GoodGenerator.ID, "huiCircuit", 4, 4), + GT_ModHandler.getModItem(EnderIO.ID, "itemBasicCapacitor", 64, 6), + GT_ModHandler.getModItem(EternalSingularity.ID, "eternal_singularity", 1)) + .fluidInputs(Materials.StellarAlloy.getMolten(7200), new FluidStack(radoxPoly, 4608)) + .itemOutputs(new ItemStack(Blocks.tfftStorageField, 1, 10)) + .duration(30 * SECONDS) + .eut(TierEU.RECIPE_UXV) + .addTo(AssemblyLine); + + // LuV Capacitor + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 1)) + .metadata(RESEARCH_TIME, 4 * HOURS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Osmiridium, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Osmiridium, 24), + ItemList.Circuit_Board_Elite.get(1), + GT_OreDictUnificator.get(OrePrefixes.foil, Materials.NaquadahAlloy, 64), + new Object[] { OrePrefixes.circuit.get(Materials.Master), 4 }, + ItemList.Circuit_Parts_Crystal_Chip_Master.get(36), + ItemList.Circuit_Parts_Crystal_Chip_Master.get(36), + ItemList.Circuit_Chip_HPIC.get(64), + ItemList.Circuit_Parts_DiodeASMD.get(8), + ItemList.Circuit_Parts_CapacitorASMD.get(8), + ItemList.Circuit_Parts_ResistorASMD.get(8), + ItemList.Circuit_Parts_TransistorASMD.get(8), + GT_OreDictUnificator.get(OrePrefixes.wireFine, Materials.Platinum, 64)) + .fluidInputs(new FluidStack(solderIndalloy, 720)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 2)) + .duration(50 * SECONDS) + .eut(80_000) + .addTo(AssemblyLine); + + // ZPM Capacitor + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 2)) + .metadata(RESEARCH_TIME, 4 * HOURS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.NaquadahAlloy, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.NaquadahAlloy, 24), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Europium, 16L), + new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Ultimate), 1 }, + ItemList.Energy_LapotronicOrb2.get(8L), + ItemList.Field_Generator_LuV.get(2), + ItemList.Circuit_Wafer_SoC2.get(64), + ItemList.Circuit_Wafer_SoC2.get(64), + ItemList.Circuit_Parts_DiodeASMD.get(8), + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.Naquadah, 32)) + .fluidInputs( + new FluidStack(solderIndalloy, 2880), + new FluidStack(FluidRegistry.getFluid("ic2coolant"), 16000)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 3)) + .duration(1 * MINUTES + 40 * SECONDS) + .eut(100_000) + .addTo(AssemblyLine); + + // UV Capacitor + GT_Values.RA.stdBuilder() + .metadata(RESEARCH_ITEM, new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 3)) + .metadata(RESEARCH_TIME, 4 * HOURS) + .itemInputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Neutronium, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Neutronium, 24), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Americium, 32L), + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.SuperconductorUHV), 1 }, + ItemList.Energy_Module.get(8L), + ItemList.Field_Generator_ZPM.get(2), + ItemList.Circuit_Wafer_HPIC.get(64), + ItemList.Circuit_Wafer_HPIC.get(64), + ItemList.Circuit_Parts_DiodeASMD.get(16), + GT_OreDictUnificator.get(OrePrefixes.cableGt01, Materials.NaquadahAlloy, 32)) + .fluidInputs( + new FluidStack(solderIndalloy, 2880), + new FluidStack(FluidRegistry.getFluid("ic2coolant"), 16000)) + .itemOutputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 4)) + .eut(200_000) + .duration(1 * MINUTES + 40 * SECONDS) + .addTo(AssemblyLine); + } +} diff --git a/kekztech/src/main/java/common/recipeLoaders/ChemicalReactor.java b/kekztech/src/main/java/common/recipeLoaders/ChemicalReactor.java new file mode 100644 index 0000000000..f67dd253fc --- /dev/null +++ b/kekztech/src/main/java/common/recipeLoaders/ChemicalReactor.java @@ -0,0 +1,30 @@ +package common.recipeLoaders; + +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; +import static gregtech.api.util.GT_RecipeConstants.UniversalChemical; + +import common.items.MetaItem_CraftingComponent; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_Utility; +import kekztech.Items; + +public class ChemicalReactor implements Runnable { + + @Override + public void run() { + final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance(); + + // Ceria Dust + GT_Values.RA.stdBuilder() + .itemInputs(Materials.Cerium.getDust(2), GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.CeriaDust.getMetaID(), 2)) + .fluidInputs(Materials.Oxygen.getGas(3000)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(UniversalChemical); + + } +} diff --git a/kekztech/src/main/java/common/recipeLoaders/Crafting.java b/kekztech/src/main/java/common/recipeLoaders/Crafting.java new file mode 100644 index 0000000000..72985fd8ad --- /dev/null +++ b/kekztech/src/main/java/common/recipeLoaders/Crafting.java @@ -0,0 +1,72 @@ +package common.recipeLoaders; + +import net.minecraft.item.ItemStack; + +import common.Blocks; +import common.TileEntities; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; +import util.Util; + +public class Crafting implements Runnable { + + @Override + public void run() { + // TFFT Controller + GT_ModHandler.addCraftingRecipe( + TileEntities.tfft.getStackForm(1), + new Object[] { "ESE", "FTF", "CVC", 'E', GT_OreDictUnificator.get(OrePrefixes.screw, Materials.EnderEye, 1), + 'S', ItemList.Cover_Screen.get(1), 'F', ItemList.Field_Generator_LV.get(1), 'T', + new ItemStack(Blocks.tfftStorageField, 1), 'C', "circuitData", 'V', + GT_OreDictUnificator.get(OrePrefixes.rotor, Materials.VibrantAlloy, 1), }); + + // SOFC Controller mk1 + final Object[] mk1_recipe = { "CCC", "PHP", "FBL", 'C', OrePrefixes.circuit.get(Materials.Advanced), 'P', + ItemList.Electric_Pump_HV.get(1L), 'H', ItemList.Hull_HV.get(1L), 'F', + GT_OreDictUnificator.get(OrePrefixes.pipeSmall, Materials.StainlessSteel, 1), 'B', + GT_OreDictUnificator.get(OrePrefixes.cableGt02, Materials.Gold, 1), 'L', + GT_OreDictUnificator.get(OrePrefixes.pipeLarge, Materials.StainlessSteel, 1) }; + GT_ModHandler.addCraftingRecipe(TileEntities.sofc1.getStackForm(1), mk1_recipe); + + // SOFC Controller mk2 + final Object[] mk2_recipe = { "CCC", "PHP", "FBL", 'C', OrePrefixes.circuit.get(Materials.Master), 'P', + ItemList.Electric_Pump_IV.get(1L), 'H', ItemList.Hull_IV.get(1L), 'F', + GT_OreDictUnificator.get(OrePrefixes.pipeSmall, Materials.Ultimate, 1), 'B', + Util.getStackofAmountFromOreDict("wireGt04SuperconductorEV", 1), 'L', + GT_OreDictUnificator.get(OrePrefixes.pipeMedium, Materials.Ultimate, 1) }; + GT_ModHandler.addCraftingRecipe(TileEntities.sofc2.getStackForm(1), mk2_recipe); + + // LSC Controller + final Object[] lsc_recipe = { "LPL", "CBC", "LPL", 'L', ItemList.IC2_LapotronCrystal.getWildcard(1L), 'P', + ItemList.Circuit_Chip_PIC.get(1L), 'C', OrePrefixes.circuit.get(Materials.Master), 'B', + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 0), }; + GT_ModHandler.addCraftingRecipe(TileEntities.lsc.getStackForm(1), lsc_recipe); + + // LSC casing + final Object[] lcBase_recipe = { "WBW", "RLR", "WBW", 'W', OrePrefixes.plate.get(Materials.Tantalum), 'B', + OrePrefixes.frameGt.get(Materials.TungstenSteel), 'R', OrePrefixes.stickLong.get(Materials.TungstenSteel), + 'L', OrePrefixes.block.get(Materials.Lapis) }; + GT_ModHandler.addCraftingRecipe(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 0), lcBase_recipe); + + // Empty Capacitor + final Object[] lcEmpty_recipe = { "SLS", "L L", "SLS", 'S', OrePrefixes.screw.get(Materials.Lapis), 'L', + OrePrefixes.plate.get(Materials.Lapis) }; + GT_ModHandler.addCraftingRecipe(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6), lcEmpty_recipe); + + // EV Capacitor + final Object[] lcEV_recipe = { "SLS", "LCL", "SLS", 'S', OrePrefixes.screw.get(Materials.Lapis), 'L', + OrePrefixes.plate.get(Materials.Lapis), 'C', GT_ModHandler.getIC2Item("lapotronCrystal", 1L, GT_Values.W) }; + GT_ModHandler.addCraftingRecipe(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 7), lcEV_recipe); + + // IV Capacitor + final Object[] lcIV_recipe = { "SLS", "LOL", "SLS", 'S', OrePrefixes.screw.get(Materials.Lapis), 'L', + OrePrefixes.plate.get(Materials.Lapis), 'O', ItemList.Energy_LapotronicOrb.get(1L) }; + GT_ModHandler.addCraftingRecipe(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 1), lcIV_recipe); + + } +} diff --git a/kekztech/src/main/java/common/recipeLoaders/FormingPress.java b/kekztech/src/main/java/common/recipeLoaders/FormingPress.java new file mode 100644 index 0000000000..d226ebf2a9 --- /dev/null +++ b/kekztech/src/main/java/common/recipeLoaders/FormingPress.java @@ -0,0 +1,29 @@ +package common.recipeLoaders; + +import static gregtech.api.recipe.RecipeMaps.formingPressRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import common.items.MetaItem_CraftingComponent; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.TierEU; +import kekztech.Items; + +public class FormingPress implements Runnable { + + @Override + public void run() { + final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance(); + + // YSZ Ceramic Plate + GT_Values.RA.stdBuilder() + .itemInputs( + craftingItem.getStackOfAmountFromDamage(Items.GDCCeramicDust.getMetaID(), 10), + ItemList.Shape_Mold_Plate.get(0)) + .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.GDCCeramicPlate.getMetaID(), 1)) + .duration(40 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(formingPressRecipes); + } +} diff --git a/kekztech/src/main/java/common/recipeLoaders/Mixer.java b/kekztech/src/main/java/common/recipeLoaders/Mixer.java new file mode 100644 index 0000000000..0fd329a01b --- /dev/null +++ b/kekztech/src/main/java/common/recipeLoaders/Mixer.java @@ -0,0 +1,48 @@ +package common.recipeLoaders; + +import static gregtech.api.recipe.RecipeMaps.mixerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.item.ItemStack; + +import common.items.ErrorItem; +import common.items.MetaItem_CraftingComponent; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Utility; +import kekztech.Items; + +public class Mixer implements Runnable { + + @Override + public void run() { + final MetaItem_CraftingComponent craftingItem = MetaItem_CraftingComponent.getInstance(); + + // YSZ Ceramic Dust + GT_Values.RA.stdBuilder() + .itemInputs( + Items.YttriaDust.getOreDictedItemStack(1), + Items.ZirconiaDust.getOreDictedItemStack(5), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.YSZCeramicDust.getMetaID(), 6)) + .duration(20 * SECONDS) + .eut(96) + .addTo(mixerRecipes); + + // GDC Ceramic Dust + GT_Values.RA.stdBuilder() + .itemInputs( + GT_OreDictUnificator + .get(OrePrefixes.dust, Materials.Gadolinium, new ItemStack(ErrorItem.getInstance(), 1), 1), + craftingItem.getStackOfAmountFromDamage(Items.CeriaDust.getMetaID(), 9), + GT_Utility.getIntegratedCircuit(6)) + .itemOutputs(craftingItem.getStackOfAmountFromDamage(Items.GDCCeramicDust.getMetaID(), 10)) + .duration(20 * SECONDS) + .eut(TierEU.RECIPE_EV) + .addTo(mixerRecipes); + } +} diff --git a/kekztech/src/main/java/common/recipeLoaders/ResearchableAssemblyLine.java b/kekztech/src/main/java/common/recipeLoaders/ResearchableAssemblyLine.java new file mode 100644 index 0000000000..fe1aaaf70e --- /dev/null +++ b/kekztech/src/main/java/common/recipeLoaders/ResearchableAssemblyLine.java @@ -0,0 +1,137 @@ +package common.recipeLoaders; + +import static gregtech.api.enums.Mods.GTPlusPlus; +import static gregtech.api.enums.Mods.NewHorizonsCoreMod; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.github.technus.tectech.recipe.TT_recipeAdder; +import common.Blocks; + +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; + +public class ResearchableAssemblyLine implements Runnable { + + @Override + public void run() { + final Fluid solderUEV = FluidRegistry.getFluid("molten.mutatedlivingsolder") != null + ? FluidRegistry.getFluid("molten.mutatedlivingsolder") + : FluidRegistry.getFluid("molten.solderingalloy"); + + // Extremely Ultimate Capacitor (UEV) + TT_recipeAdder.addResearchableAssemblylineRecipe( + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 5), + 1200000, + 128, + 8000000, + 16, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.Infinity, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Infinity, 24), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.InfinityCatalyst, 32L), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.InfinityCatalyst, 32L), + new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Optical), 1 }, ItemList.ZPM3.get(8L), + ItemList.Field_Generator_UEV.get(4), ItemList.Circuit_Wafer_PPIC.get(64), + ItemList.Circuit_Wafer_PPIC.get(64), ItemList.Circuit_Wafer_SoC2.get(64), + ItemList.Circuit_Parts_DiodeXSMD.get(64), + GT_OreDictUnificator.get(OrePrefixes.wireGt04, Materials.SuperconductorUEV, 64) }, + new FluidStack[] { new FluidStack(solderUEV, 9216), Materials.Quantium.getMolten(18432), + Materials.Naquadria.getMolten(18432), Materials.SuperCoolant.getFluid(64000) }, + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 8), + 250 * 20, + (int) TierEU.RECIPE_UEV); + + if (GTPlusPlus.isModLoaded()) { + // Insanely Ultimate Capacitor (UIV) + TT_recipeAdder.addResearchableAssemblylineRecipe( + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 8), + 24_000_000, + 1_280, + 32_000_000, + 32, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.TranscendentMetal, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.TranscendentMetal, 24), + GT_ModHandler.getModItem(GTPlusPlus.ID, "itemPlateDoubleHypogen", 32), + GT_ModHandler.getModItem(GTPlusPlus.ID, "itemPlateDoubleHypogen", 32), + new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Piko), 1 }, ItemList.ZPM4.get(8L), + ItemList.Field_Generator_UIV.get(4), ItemList.Circuit_Wafer_QPIC.get(64), + ItemList.Circuit_Wafer_QPIC.get(64), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.RawPicoWafer", 64), + ItemList.Circuit_Parts_DiodeXSMD.get(64), ItemList.Circuit_Parts_InductorXSMD.get(32), + GT_OreDictUnificator.get(OrePrefixes.wireGt08, Materials.SuperconductorUIV, 64) }, + new FluidStack[] { new FluidStack(solderUEV, 18_432), + new FluidStack(FluidRegistry.getFluid("molten.celestialtungsten"), 18432), + Materials.Quantium.getMolten(18_432), Materials.SuperCoolant.getFluid(128_000) }, + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 9), + 300 * 20, + (int) TierEU.RECIPE_UIV); + + // Mega Ultimate Capacitor (UMV) + TT_recipeAdder.addResearchableAssemblylineRecipe( + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 9), + 480_000_000, + 12_288, + 128_000_000, + 64, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, MaterialsUEVplus.SpaceTime, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.SpaceTime, 24), + GT_ModHandler.getModItem(GTPlusPlus.ID, "itemPlateDoubleDragonblood", 32), + GT_ModHandler.getModItem(GTPlusPlus.ID, "itemPlateDoubleDragonblood", 32), + new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Quantum), 1 }, ItemList.ZPM5.get(8L), + ItemList.Field_Generator_UMV.get(4), ItemList.Circuit_Wafer_QPIC.get(64), + ItemList.Circuit_Wafer_QPIC.get(64), + GT_ModHandler.getModItem(NewHorizonsCoreMod.ID, "item.PicoWafer", 64), + ItemList.Circuit_Parts_DiodeXSMD.get(64), ItemList.Circuit_Parts_InductorXSMD.get(64), + GT_OreDictUnificator.get(OrePrefixes.wireGt16, Materials.SuperconductorUMV, 64) }, + new FluidStack[] { new FluidStack(solderUEV, 36_864), + new FluidStack(FluidRegistry.getFluid("molten.astraltitanium"), 36_864), + new FluidStack(FluidRegistry.getFluid("molten.celestialtungsten"), 36_864), + Materials.SuperCoolant.getFluid(256_000) }, + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 10), + 350 * 20, + (int) TierEU.RECIPE_UMV); + } + + // Ultimate Capacitor (UHV) + TT_recipeAdder.addResearchableAssemblylineRecipe( + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 4), + 12000, + 16, + 300000, + 3, + new Object[] { GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CosmicNeutronium, 4), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.CosmicNeutronium, 24), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Neutronium, 32L), + GT_OreDictUnificator.get(OrePrefixes.plateDouble, Materials.Neutronium, 32L), + new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1 }, + new Object[] { OrePrefixes.circuit.get(Materials.Bio), 1 }, ItemList.ZPM2.get(8L), + ItemList.Field_Generator_UHV.get(4), ItemList.Circuit_Wafer_UHPIC.get(64), + ItemList.Circuit_Wafer_UHPIC.get(64), ItemList.Circuit_Wafer_SoC2.get(32), + ItemList.Circuit_Parts_DiodeASMD.get(64), + GT_OreDictUnificator.get(OrePrefixes.wireGt02, Materials.SuperconductorUHV, 64) }, + new FluidStack[] { new FluidStack(solderUEV, 4608), Materials.Naquadria.getMolten(9216), + new FluidStack(FluidRegistry.getFluid("ic2coolant"), 32000) }, + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 5), + 4000, + 1600000); + } +} diff --git a/kekztech/src/main/java/common/recipeLoaders/Unpackager.java b/kekztech/src/main/java/common/recipeLoaders/Unpackager.java new file mode 100644 index 0000000000..ec25f5c89c --- /dev/null +++ b/kekztech/src/main/java/common/recipeLoaders/Unpackager.java @@ -0,0 +1,200 @@ +package common.recipeLoaders; + +import static gregtech.api.recipe.RecipeMaps.unpackagerRecipes; +import static gregtech.api.util.GT_RecipeBuilder.SECONDS; + +import net.minecraft.item.ItemStack; + +import common.Blocks; + +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Materials; +import gregtech.api.enums.MaterialsUEVplus; +import gregtech.api.enums.OrePrefixes; +import gregtech.api.enums.TierEU; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_OreDictUnificator; + +public class Unpackager implements Runnable { + + @Override + public void run() { + + // TFFT Recycling + { + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 1)) + .itemOutputs( + GT_OreDictUnificator.get(OrePrefixes.frameGt, Materials.CrudeSteel, 1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CrudeSteel, 6)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 2)) + .itemOutputs( + ItemList.Casing_Tank_1.get(1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.EnergeticSilver, 6)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 3)) + .itemOutputs( + ItemList.Casing_Tank_3.get(1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.VividAlloy, 6)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 4)) + .itemOutputs( + ItemList.Casing_Tank_5.get(1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.Enderium, 6)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 5)) + .itemOutputs( + ItemList.Casing_Tank_7.get(1), + GT_OreDictUnificator.get(OrePrefixes.plate, Materials.CrystallineAlloy, 6)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 6)) + .itemOutputs( + ItemList.Casing_Tank_7.get(4), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.CrystallinePinkSlime, 6)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 7)) + .itemOutputs( + ItemList.Casing_Tank_10.get(16), + GT_OreDictUnificator.get(OrePrefixes.plateQuadruple, Materials.MelodicAlloy, 6)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 8)) + .itemOutputs( + ItemList.Quantum_Tank_IV.get(1), + GT_OreDictUnificator.get(OrePrefixes.plateDense, Materials.StellarAlloy, 12)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 9)) + .itemOutputs( + ItemList.Quantum_Tank_IV.get(4), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.TranscendentMetal, 12)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.tfftStorageField, 1, 10)) + .itemOutputs( + ItemList.Quantum_Tank_IV.get(16), + GT_OreDictUnificator.get(OrePrefixes.plateDense, MaterialsUEVplus.SpaceTime, 12)) + .duration(5 * SECONDS) + .eut(TierEU.RECIPE_HV) + .addTo(unpackagerRecipes); + + } + + // Capacitor recycling + { + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 7)) + .itemOutputs( + GT_ModHandler.getIC2Item("lapotronCrystal", 1L, 26), + new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 1)) + .itemOutputs(ItemList.Energy_LapotronicOrb.get(1L), new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 6)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 2)) + .itemOutputs( + ItemList.Energy_LapotronicOrb2.get(1L), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Osmiridium, 24)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 3)) + .itemOutputs( + ItemList.Energy_Module.get(1L), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.NaquadahAlloy, 24)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 4)) + .itemOutputs( + ItemList.Energy_Cluster.get(1L), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Neutronium, 24)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 5)) + .itemOutputs( + ItemList.ZPM3.get(1L), + GT_OreDictUnificator.get(OrePrefixes.screw, Materials.CosmicNeutronium, 24)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 8)) + .itemOutputs(ItemList.ZPM4.get(1L), GT_OreDictUnificator.get(OrePrefixes.screw, Materials.Infinity, 24)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 9)) + .itemOutputs( + ItemList.ZPM5.get(1L), + GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.TranscendentMetal, 24)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(unpackagerRecipes); + + GT_Values.RA.stdBuilder() + .itemInputs(new ItemStack(Blocks.lscLapotronicEnergyUnit, 1, 10)) + .itemOutputs( + ItemList.ZPM6.get(1L), + GT_OreDictUnificator.get(OrePrefixes.screw, MaterialsUEVplus.SpaceTime, 24)) + .duration(60 * SECONDS) + .eut(TierEU.RECIPE_LV) + .addTo(unpackagerRecipes); + + } + } +} diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_LapotronicSuperCapacitor.java b/kekztech/src/main/java/common/tileentities/GTMTE_LapotronicSuperCapacitor.java new file mode 100644 index 0000000000..40fbb656c8 --- /dev/null +++ b/kekztech/src/main/java/common/tileentities/GTMTE_LapotronicSuperCapacitor.java @@ -0,0 +1,1189 @@ +package common.tileentities; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.onlyIf; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.withChannel; +import static common.itemBlocks.IB_LapotronicEnergyUnit.EV_cap_storage; +import static common.itemBlocks.IB_LapotronicEnergyUnit.IV_cap_storage; +import static common.itemBlocks.IB_LapotronicEnergyUnit.LSC_time_between_wireless_rebalance_in_ticks; +import static common.itemBlocks.IB_LapotronicEnergyUnit.LSC_wireless_eu_cap; +import static common.itemBlocks.IB_LapotronicEnergyUnit.LuV_cap_storage; +import static common.itemBlocks.IB_LapotronicEnergyUnit.UEV_wireless_eu_cap; +import static common.itemBlocks.IB_LapotronicEnergyUnit.UIV_cap_storage; +import static common.itemBlocks.IB_LapotronicEnergyUnit.UIV_wireless_eu_cap; +import static common.itemBlocks.IB_LapotronicEnergyUnit.UMV_cap_storage; +import static common.itemBlocks.IB_LapotronicEnergyUnit.UMV_wireless_eu_cap; +import static common.itemBlocks.IB_LapotronicEnergyUnit.UV_cap_storage; +import static common.itemBlocks.IB_LapotronicEnergyUnit.ZPM_cap_storage; +import static gregtech.api.enums.GT_HatchElement.Maintenance; +import static gregtech.api.metatileentity.BaseTileEntity.TOOLTIP_DELAY; +import static gregtech.api.util.GT_StructureUtility.buildHatchAdder; +import static gregtech.api.util.GT_StructureUtility.filterByMTEClass; +import static java.lang.Math.min; +import static util.Util.toPercentageFrom; +import static util.Util.toStandardForm; + +import java.math.BigInteger; +import java.text.NumberFormat; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Comparator; +import java.util.HashSet; +import java.util.LinkedList; +import java.util.List; +import java.util.Queue; +import java.util.Set; +import java.util.UUID; +import java.util.function.Consumer; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.IChatComponent; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import com.github.bartimaeusnek.bartworks.API.BorosilicateGlass; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoMulti; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoTunnel; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyTunnel; +import com.google.common.collect.ImmutableList; +import com.gtnewhorizon.structurelib.StructureLibAPI; +import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor; +import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable; +import com.gtnewhorizon.structurelib.structure.IItemSource; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.IStructureElement; +import com.gtnewhorizon.structurelib.structure.StructureUtility; +import com.gtnewhorizon.structurelib.util.ItemStackPredicate.NBTMode; +import com.gtnewhorizons.modularui.api.drawable.IDrawable; +import com.gtnewhorizons.modularui.api.drawable.UITexture; +import com.gtnewhorizons.modularui.api.screen.ModularWindow; +import com.gtnewhorizons.modularui.api.screen.UIBuildContext; +import com.gtnewhorizons.modularui.common.widget.ButtonWidget; +import com.gtnewhorizons.modularui.common.widget.FakeSyncWidget; +import common.Blocks; + +import client.gui.KT_UITextures; +import gregtech.api.enums.Dyes; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Textures.BlockIcons; +import gregtech.api.gui.modularui.GT_UITextures; +import gregtech.api.interfaces.IHatchElement; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Dynamo; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Maintenance; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.IGT_HatchAdder; +import gregtech.common.misc.WirelessNetworkManager; + +public class GTMTE_LapotronicSuperCapacitor + extends GT_MetaTileEntity_EnhancedMultiBlockBase<GTMTE_LapotronicSuperCapacitor> implements ISurvivalConstructable { + + private enum TopState { + MayBeTop, + Top, + NotTop + } + + private boolean canUseWireless = false; + private boolean wireless_mode = false; + private boolean not_processed_lsc = true; + private int counter = 1; + + private final Queue<Long> energyInputValues = new LinkedList<>(); + private final Queue<Long> energyOutputValues = new LinkedList<>(); + + private final long max_passive_drain_eu_per_tick_per_uhv_cap = 1_000_000; + private final long max_passive_drain_eu_per_tick_per_uev_cap = 100_000_000; + private final long max_passive_drain_eu_per_tick_per_uiv_cap = (long) Math.pow(10, 10); + private final long max_passive_drain_eu_per_tick_per_umv_cap = (long) Math.pow(10, 12); + + private enum Capacitor { + + IV(2, BigInteger.valueOf(IV_cap_storage)), + LuV(3, BigInteger.valueOf(LuV_cap_storage)), + ZPM(4, BigInteger.valueOf(ZPM_cap_storage)), + UV(5, BigInteger.valueOf(UV_cap_storage)), + UHV(6, MAX_LONG), + None(0, BigInteger.ZERO), + EV(1, BigInteger.valueOf(EV_cap_storage)), + UEV(7, MAX_LONG), + UIV(8, BigInteger.valueOf(UIV_cap_storage)), + UMV(9, UMV_cap_storage); + + private final int minimalGlassTier; + private final BigInteger providedCapacity; + static final Capacitor[] VALUES = values(); + static final Capacitor[] VALUES_BY_TIER = Arrays.stream(values()) + .sorted(Comparator.comparingInt(Capacitor::getMinimalGlassTier)) + .toArray(Capacitor[]::new); + + Capacitor(int minimalGlassTier, BigInteger providedCapacity) { + this.minimalGlassTier = minimalGlassTier; + this.providedCapacity = providedCapacity; + } + + public int getMinimalGlassTier() { + return minimalGlassTier; + } + + public BigInteger getProvidedCapacity() { + return providedCapacity; + } + + public static int getIndexFromGlassTier(int glassTier) { + for (int index = 0; index < values().length; index++) { + if (values()[index].getMinimalGlassTier() == glassTier) { + return index; + } + } + return -1; + } + } + + private static final String STRUCTURE_PIECE_BASE = "base"; + private static final String STRUCTURE_PIECE_LAYER = "slice"; + private static final String STRUCTURE_PIECE_TOP = "top"; + private static final String STRUCTURE_PIECE_MID = "mid"; + private static final int GLASS_TIER_UNSET = -2; + + private static final Block LSC_PART = Blocks.lscLapotronicEnergyUnit; + private static final Item LSC_PART_ITEM = Item.getItemFromBlock(LSC_PART); + private static final int CASING_META = 0; + private static final int CASING_TEXTURE_ID = (42 << 7) | 127; + + private static final int DURATION_AVERAGE_TICKS = 100; + + // height channel for height. + // glass channel for glass + // capacitor channel for capacitor, but it really just pick whatever capacitor it can find in survival + private static final IStructureDefinition<GTMTE_LapotronicSuperCapacitor> STRUCTURE_DEFINITION = IStructureDefinition + .<GTMTE_LapotronicSuperCapacitor>builder() + .addShape( + STRUCTURE_PIECE_BASE, + transpose( + new String[][] { { "bbbbb", "bbbbb", "bbbbb", "bbbbb", "bbbbb", }, + { "bb~bb", "bbbbb", "bbbbb", "bbbbb", "bbbbb", }, })) + .addShape( + STRUCTURE_PIECE_LAYER, + transpose(new String[][] { { "ggggg", "gcccg", "gcccg", "gcccg", "ggggg", }, })) + .addShape(STRUCTURE_PIECE_TOP, transpose(new String[][] { { "ggggg", "ggggg", "ggggg", "ggggg", "ggggg", }, })) + .addShape(STRUCTURE_PIECE_MID, transpose(new String[][] { { "ggggg", "gCCCg", "gCCCg", "gCCCg", "ggggg", }, })) + .addElement( + 'b', + buildHatchAdder(GTMTE_LapotronicSuperCapacitor.class) + .atLeast(LSCHatchElement.Energy, LSCHatchElement.Dynamo, Maintenance) + .hatchItemFilterAnd( + (t, h) -> ChannelDataAccessor.getChannelData(h, "glass") < 6 + ? filterByMTEClass( + ImmutableList.of( + GT_MetaTileEntity_Hatch_EnergyTunnel.class, + GT_MetaTileEntity_Hatch_DynamoTunnel.class)).negate() + : s -> true) + .casingIndex(CASING_TEXTURE_ID) + .dot(1) + .buildAndChain(onElementPass(te -> te.casingAmount++, ofBlock(LSC_PART, CASING_META)))) + .addElement( + 'g', + withChannel( + "glass", + BorosilicateGlass + .ofBoroGlass((byte) GLASS_TIER_UNSET, (te, t) -> te.glassTier = t, te -> te.glassTier))) + .addElement( + 'c', + ofChain( + onlyIf( + te -> te.topState != TopState.NotTop, + onElementPass( + te -> te.topState = TopState.Top, + withChannel( + "glass", + BorosilicateGlass.ofBoroGlass( + (byte) GLASS_TIER_UNSET, + (te, t) -> te.glassTier = t, + te -> te.glassTier)))), + onlyIf( + te -> te.topState != TopState.Top, + onElementPass( + te -> te.topState = TopState.NotTop, + new IStructureElement<GTMTE_LapotronicSuperCapacitor>() { + + @Override + public boolean check(GTMTE_LapotronicSuperCapacitor t, World world, int x, int y, int z) { + Block worldBlock = world.getBlock(x, y, z); + int meta = worldBlock.getDamageValue(world, x, y, z); + if (LSC_PART != worldBlock || meta == 0) return false; + t.capacitors[meta - 1]++; + return true; + } + + private int getHint(ItemStack stack) { + return Capacitor.VALUES_BY_TIER[Math.min( + Capacitor.VALUES_BY_TIER.length, + ChannelDataAccessor.getChannelData(stack, "capacitor")) - 1].getMinimalGlassTier() + + 1; + } + + @Override + public boolean spawnHint(GTMTE_LapotronicSuperCapacitor t, World world, int x, int y, int z, + ItemStack trigger) { + StructureLibAPI.hintParticle(world, x, y, z, LSC_PART, getHint(trigger)); + return true; + } + + @Override + public boolean placeBlock(GTMTE_LapotronicSuperCapacitor t, World world, int x, int y, + int z, ItemStack trigger) { + world.setBlock(x, y, z, LSC_PART, getHint(trigger), 3); + return true; + } + + @Override + public PlaceResult survivalPlaceBlock(GTMTE_LapotronicSuperCapacitor t, World world, int x, + int y, int z, ItemStack trigger, IItemSource source, EntityPlayerMP actor, + Consumer<IChatComponent> chatter) { + if (check(t, world, x, y, z)) return PlaceResult.SKIP; + int glassTier = ChannelDataAccessor.getChannelData(trigger, "glass") + 2; + ItemStack targetStack = source + .takeOne( + s -> s != null && s.stackSize >= 0 + && s.getItem() == LSC_PART_ITEM + && Capacitor.VALUES[Math.min(s.getItemDamage(), Capacitor.VALUES.length) + - 1].getMinimalGlassTier() > glassTier, + true); + if (targetStack == null) return PlaceResult.REJECT; + return StructureUtility.survivalPlaceBlock( + targetStack, + NBTMode.EXACT, + targetStack.stackTagCompound, + true, + world, + x, + y, + z, + source, + actor, + chatter); + } + })))) + .addElement('C', ofBlock(LSC_PART, 1)) + .build(); + + private static final BigInteger MAX_LONG = BigInteger.valueOf(Long.MAX_VALUE); + + private final Set<GT_MetaTileEntity_Hatch_EnergyMulti> mEnergyHatchesTT = new HashSet<>(); + private final Set<GT_MetaTileEntity_Hatch_DynamoMulti> mDynamoHatchesTT = new HashSet<>(); + private final Set<GT_MetaTileEntity_Hatch_EnergyTunnel> mEnergyTunnelsTT = new HashSet<>(); + private final Set<GT_MetaTileEntity_Hatch_DynamoTunnel> mDynamoTunnelsTT = new HashSet<>(); + /** + * Count the amount of capacitors of each tier in each slot. Index = meta - 1 + */ + private final int[] capacitors = new int[10]; + + private BigInteger capacity = BigInteger.ZERO; + private BigInteger stored = BigInteger.ZERO; + private long passiveDischargeAmount = 0; + private long inputLastTick = 0; + private long outputLastTick = 0; + private int repairStatusCache = 0; + + private byte glassTier = -1; + private int casingAmount = 0; + private TopState topState = TopState.MayBeTop; + + private long mMaxEUIn = 0; + private long mMaxEUOut = 0; + + public GTMTE_LapotronicSuperCapacitor(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GTMTE_LapotronicSuperCapacitor(String aName) { + super(aName); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) { + return new GTMTE_LapotronicSuperCapacitor(super.mName); + } + + @Override + public IStructureDefinition<GTMTE_LapotronicSuperCapacitor> getStructureDefinition() { + return STRUCTURE_DEFINITION; + } + + private void processInputHatch(GT_MetaTileEntity_Hatch aHatch, int aBaseCasingIndex) { + mMaxEUIn += aHatch.maxEUInput() * aHatch.maxAmperesIn(); + aHatch.updateTexture(aBaseCasingIndex); + } + + private void processOutputHatch(GT_MetaTileEntity_Hatch aHatch, int aBaseCasingIndex) { + mMaxEUOut += aHatch.maxEUOutput() * aHatch.maxAmperesOut(); + aHatch.updateTexture(aBaseCasingIndex); + } + + private boolean addBottomHatches(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) { + if (aTileEntity == null || aTileEntity.isDead()) return false; + IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity(); + if (!(aMetaTileEntity instanceof GT_MetaTileEntity_Hatch)) return false; + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Maintenance) { + ((GT_MetaTileEntity_Hatch) aMetaTileEntity).updateTexture(aBaseCasingIndex); + return GTMTE_LapotronicSuperCapacitor.this.mMaintenanceHatches + .add((GT_MetaTileEntity_Hatch_Maintenance) aMetaTileEntity); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) { + // Add GT hatches + final GT_MetaTileEntity_Hatch_Energy tHatch = ((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity); + processInputHatch(tHatch, aBaseCasingIndex); + return mEnergyHatches.add(tHatch); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyTunnel) { + // Add TT Laser hatches + final GT_MetaTileEntity_Hatch_EnergyTunnel tHatch = ((GT_MetaTileEntity_Hatch_EnergyTunnel) aMetaTileEntity); + processInputHatch(tHatch, aBaseCasingIndex); + return mEnergyTunnelsTT.add(tHatch); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) { + // Add TT hatches + final GT_MetaTileEntity_Hatch_EnergyMulti tHatch = (GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity; + processInputHatch(tHatch, aBaseCasingIndex); + return mEnergyHatchesTT.add(tHatch); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Dynamo) { + // Add GT hatches + final GT_MetaTileEntity_Hatch_Dynamo tDynamo = (GT_MetaTileEntity_Hatch_Dynamo) aMetaTileEntity; + processOutputHatch(tDynamo, aBaseCasingIndex); + return mDynamoHatches.add(tDynamo); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_DynamoTunnel) { + // Add TT Laser hatches + final GT_MetaTileEntity_Hatch_DynamoTunnel tDynamo = (GT_MetaTileEntity_Hatch_DynamoTunnel) aMetaTileEntity; + processOutputHatch(tDynamo, aBaseCasingIndex); + return mDynamoTunnelsTT.add(tDynamo); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_DynamoMulti) { + // Add TT hatches + final GT_MetaTileEntity_Hatch_DynamoMulti tDynamo = (GT_MetaTileEntity_Hatch_DynamoMulti) aMetaTileEntity; + processOutputHatch(tDynamo, aBaseCasingIndex); + return mDynamoHatchesTT.add(tDynamo); + } + return false; + } + + private int getUHVCapacitorCount() { + return capacitors[4]; + } + + private int getUEVCapacitorCount() { + return capacitors[7]; + } + + private int getUIVCapacitorCount() { + return capacitors[8]; + } + + private int getUMVCapacitorCount() { + return capacitors[9]; + } + + private int wirelessCapableCapacitors() { + return capacitors[4] + capacitors[7] + capacitors[8] + capacitors[9]; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Energy Storage") + .addInfo("Loses energy equal to 1% of the total capacity every 24 hours.") + .addInfo( + "Capped at " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(max_passive_drain_eu_per_tick_per_uhv_cap) + + EnumChatFormatting.GRAY + + " EU/t passive loss per " + + GT_Values.TIER_COLORS[9] + + GT_Values.VN[9] + + EnumChatFormatting.GRAY + + " capacitor.") + .addInfo( + "The passive loss increases " + EnumChatFormatting.DARK_RED + + "100" + + EnumChatFormatting.GRAY + + "-fold" + + " for every capacitor tier above.") + .addInfo("Passive loss is multiplied by the number of maintenance issues present.") + .addSeparator() + .addInfo("Glass shell has to be Tier - 3 of the highest capacitor tier.") + .addInfo( + GT_Values.TIER_COLORS[8] + GT_Values.VN[8] + + EnumChatFormatting.GRAY + + "-tier glass required for " + + EnumChatFormatting.BLUE + + "Tec" + + EnumChatFormatting.DARK_BLUE + + "Tech" + + EnumChatFormatting.GRAY + + " Laser Hatches.") + .addInfo("Add more or better capacitors to increase capacity.") + .addSeparator() + .addInfo("Wireless mode can be enabled by right clicking with a screwdriver.") + .addInfo( + "This mode can only be enabled if you have a " + GT_Values.TIER_COLORS[9] + + GT_Values.VN[9] + + EnumChatFormatting.GRAY + + "+ capacitor in the multiblock.") + .addInfo( + "When enabled every " + EnumChatFormatting.BLUE + + GT_Utility.formatNumbers(LSC_time_between_wireless_rebalance_in_ticks) + + EnumChatFormatting.GRAY + + " ticks the LSC will attempt to re-balance against your") + .addInfo("wireless EU network.") + .addInfo( + "If there is less than " + EnumChatFormatting.RED + + GT_Utility.formatNumbers(LSC_wireless_eu_cap) + + EnumChatFormatting.GRAY + + "(" + + GT_Values.TIER_COLORS[9] + + GT_Values.VN[9] + + EnumChatFormatting.GRAY + + ") EU in the LSC") + .addInfo("it will withdraw from the network and add to the LSC.") + .addInfo("If there is more it will add the EU to the network and remove it from the LSC.") + .addInfo( + "The threshold increases " + EnumChatFormatting.DARK_RED + + "100" + + EnumChatFormatting.GRAY + + "-fold" + + " for every capacitor tier above.") + .addSeparator() + .beginVariableStructureBlock(5, 5, 4, 50, 5, 5, false) + .addStructureInfo("Modular height of 4-50 blocks.") + .addController("Front center bottom") + .addOtherStructurePart("Lapotronic Super Capacitor Casing", "5x2x5 base (at least 17x)") + .addOtherStructurePart( + "Lapotronic Capacitor (" + GT_Values.TIER_COLORS[4] + + GT_Values.VN[4] + + EnumChatFormatting.GRAY + + "-" + + GT_Values.TIER_COLORS[8] + + GT_Values.VN[8] + + EnumChatFormatting.GRAY + + "), Ultimate Capacitor (" + + GT_Values.TIER_COLORS[9] + + GT_Values.VN[9] + + EnumChatFormatting.GRAY + + "-" + + GT_Values.TIER_COLORS[12] + + GT_Values.VN[12] + + EnumChatFormatting.GRAY + + ")", + "Center 3x(1-47)x3 above base (9-423 blocks)") + .addStructureInfo( + "You can also use the Empty Capacitor to save materials if you use it for less than half the blocks") + .addOtherStructurePart("Borosilicate Glass (any)", "41-777x, Encase capacitor pillar") + .addEnergyHatch("Any casing") + .addDynamoHatch("Any casing") + .addOtherStructurePart( + "Laser Target/Source Hatches", + "Any casing, must be using " + GT_Values.TIER_COLORS[8] + + GT_Values.VN[8] + + EnumChatFormatting.GRAY + + "-tier glass") + .addStructureInfo("You can have several I/O Hatches") + .addSubChannelUsage("glass", "Borosilicate Glass Tier") + .addSubChannelUsage("capacitor", "Maximum Capacitor Tier") + .addSubChannelUsage("height", "Height of structure") + .addMaintenanceHatch("Any casing") + .toolTipFinisher("KekzTech"); + return tt; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, + ForgeDirection forgeDirectionacing, int colorIndex, boolean aActive, boolean aRedstone) { + ITexture[] sTexture = new ITexture[] { + TextureFactory.of(BlockIcons.MACHINE_CASING_FUSION_GLASS, Dyes.getModulation(-1, Dyes._NULL.mRGBa)) }; + if (side == forgeDirectionacing && aActive) { + sTexture = new ITexture[] { TextureFactory + .of(BlockIcons.MACHINE_CASING_FUSION_GLASS_YELLOW, Dyes.getModulation(-1, Dyes._NULL.mRGBa)) }; + } + return sTexture; + } + + private UUID global_energy_user_uuid; + + @Override + public void onPreTick(IGregTechTileEntity tileEntity, long aTick) { + super.onPreTick(tileEntity, aTick); + + // On first tick (aTick restarts from 0 upon world reload). + if (not_processed_lsc && tileEntity.isServerSide()) { + // Add user to wireless network. + WirelessNetworkManager.strongCheckOrAddUser(tileEntity.getOwnerUuid()); + + // Get team UUID. + global_energy_user_uuid = tileEntity.getOwnerUuid(); + + not_processed_lsc = false; + } + } + + @Override + public boolean isCorrectMachinePart(ItemStack stack) { + return true; + } + + @Override + public boolean checkRecipe(ItemStack stack) { + this.mProgresstime = 1; + this.mMaxProgresstime = 1; + this.mEUt = 0; + this.mEfficiencyIncrease = 10000; + return true; + } + + @Override + public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) { + WirelessNetworkManager.strongCheckOrAddUser(thisController.getOwnerUuid()); + + // Reset capacitor counts + Arrays.fill(capacitors, 0); + // Clear TT hatches + mEnergyHatchesTT.clear(); + mDynamoHatchesTT.clear(); + mEnergyTunnelsTT.clear(); + mDynamoTunnelsTT.clear(); + + mMaxEUIn = 0; + mMaxEUOut = 0; + + glassTier = GLASS_TIER_UNSET; + casingAmount = 0; + + if (!checkPiece(STRUCTURE_PIECE_BASE, 2, 1, 0)) return false; + + if (casingAmount < 17) return false; + + topState = TopState.NotTop; // need at least one layer of capacitor to form, obviously + int layer = 2; + while (true) { + if (!checkPiece(STRUCTURE_PIECE_LAYER, 2, layer, 0)) return false; + layer++; + if (topState == TopState.Top) break; // top found, break out + topState = TopState.MayBeTop; + if (layer > 50) return false; // too many layers + } + + // Make sure glass tier is T-2 of the highest tier capacitor in the structure + // Count down from the highest tier until an entry is found + // Borosilicate glass after 5 are just recolours of 0 + for (int highestGlassTier = capacitors.length - 1; highestGlassTier >= 0; highestGlassTier--) { + int highestCapacitor = Capacitor.getIndexFromGlassTier(highestGlassTier); + if (capacitors[highestCapacitor] > 0) { + if (Capacitor.VALUES[highestCapacitor].getMinimalGlassTier() > glassTier) return false; + break; + } + } + + // Glass has to be at least UV-tier to allow TT Laser hatches + if (glassTier < 8) { + if (mEnergyTunnelsTT.size() > 0 || mDynamoTunnelsTT.size() > 0) return false; + } + + // Check if enough (more than 50%) non-empty caps + if (capacitors[5] > capacitors[0] + capacitors[1] + + capacitors[2] + + capacitors[3] + + getUHVCapacitorCount() + + capacitors[6] + + getUEVCapacitorCount() + + getUIVCapacitorCount() + + getUMVCapacitorCount()) return false; + + // Calculate total capacity + capacity = BigInteger.ZERO; + for (int i = 0; i < capacitors.length; i++) { + int count = capacitors[i]; + capacity = capacity.add( + Capacitor.VALUES[i].getProvidedCapacity() + .multiply(BigInteger.valueOf(count))); + } + // Calculate how much energy to void each tick + passiveDischargeAmount = recalculateLossWithMaintenance(getRepairStatus()); + return mMaintenanceHatches.size() == 1; + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + int layer = min(stackSize.stackSize + 3, 50); + buildPiece(STRUCTURE_PIECE_BASE, stackSize, hintsOnly, 2, 1, 0); + for (int i = 2; i < layer - 1; i++) buildPiece(STRUCTURE_PIECE_MID, stackSize, hintsOnly, 2, i, 0); + buildPiece(STRUCTURE_PIECE_TOP, stackSize, hintsOnly, 2, layer - 1, 0); + } + + @Override + public int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) { + if (mMachine) return -1; + int layer = Math.min(ChannelDataAccessor.getChannelData(stackSize, "height") + 3, 50); + int built; + built = survivialBuildPiece( + STRUCTURE_PIECE_BASE, + stackSize, + 2, + 1, + 0, + elementBudget, + source, + actor, + false, + true); + if (built >= 0) return built; + for (int i = 2; i < layer - 1; i++) built = survivialBuildPiece( + STRUCTURE_PIECE_MID, + stackSize, + 2, + i, + 0, + elementBudget, + source, + actor, + false, + true); + if (built >= 0) return built; + return survivialBuildPiece( + STRUCTURE_PIECE_TOP, + stackSize, + 2, + layer - 1, + 0, + elementBudget, + source, + actor, + false, + true); + } + + @Override + public boolean onRunningTick(ItemStack stack) { + // Reset I/O cache + inputLastTick = 0; + outputLastTick = 0; + + long temp_stored = 0L; + + // Draw energy from GT hatches + for (GT_MetaTileEntity_Hatch_Energy eHatch : super.mEnergyHatches) { + if (eHatch == null || !eHatch.isValid()) { + continue; + } + final long power = getPowerToDraw(eHatch.maxEUInput() * eHatch.maxAmperesIn()); + if (eHatch.getEUVar() >= power) { + eHatch.setEUVar(eHatch.getEUVar() - power); + temp_stored += power; + inputLastTick += power; + } + } + + // Output energy to GT hatches + for (GT_MetaTileEntity_Hatch_Dynamo eDynamo : super.mDynamoHatches) { + if (eDynamo == null || !eDynamo.isValid()) { + continue; + } + final long power = getPowerToPush(eDynamo.maxEUOutput() * eDynamo.maxAmperesOut()); + if (power <= eDynamo.maxEUStore() - eDynamo.getEUVar()) { + eDynamo.setEUVar(eDynamo.getEUVar() + power); + temp_stored -= power; + outputLastTick += power; + } + } + + // Draw energy from TT hatches + for (GT_MetaTileEntity_Hatch_EnergyMulti eHatch : mEnergyHatchesTT) { + if (eHatch == null || !eHatch.isValid()) { + continue; + } + final long power = getPowerToDraw(eHatch.maxEUInput() * eHatch.maxAmperesIn()); + if (eHatch.getEUVar() >= power) { + eHatch.setEUVar(eHatch.getEUVar() - power); + temp_stored += power; + inputLastTick += power; + } + } + + // Output energy to TT hatches + for (GT_MetaTileEntity_Hatch_DynamoMulti eDynamo : mDynamoHatchesTT) { + if (eDynamo == null || !eDynamo.isValid()) { + continue; + } + final long power = getPowerToPush(eDynamo.maxEUOutput() * eDynamo.maxAmperesOut()); + if (power <= eDynamo.maxEUStore() - eDynamo.getEUVar()) { + eDynamo.setEUVar(eDynamo.getEUVar() + power); + temp_stored -= power; + outputLastTick += power; + } + } + + // Draw energy from TT Laser hatches + for (GT_MetaTileEntity_Hatch_EnergyTunnel eHatch : mEnergyTunnelsTT) { + if (eHatch == null || !eHatch.isValid()) { + continue; + } + final long ttLaserWattage = eHatch.maxEUInput() * eHatch.Amperes - (eHatch.Amperes / 20); + final long power = getPowerToDraw(ttLaserWattage); + if (eHatch.getEUVar() >= power) { + eHatch.setEUVar(eHatch.getEUVar() - power); + temp_stored += power; + inputLastTick += power; + } + } + + // Output energy to TT Laser hatches + for (GT_MetaTileEntity_Hatch_DynamoTunnel eDynamo : mDynamoTunnelsTT) { + if (eDynamo == null || !eDynamo.isValid()) { + continue; + } + final long ttLaserWattage = eDynamo.maxEUOutput() * eDynamo.Amperes - (eDynamo.Amperes / 20); + final long power = getPowerToPush(ttLaserWattage); + if (power <= eDynamo.maxEUStore() - eDynamo.getEUVar()) { + eDynamo.setEUVar(eDynamo.getEUVar() + power); + temp_stored -= power; + outputLastTick += power; + } + } + + if (wirelessCapableCapacitors() <= 0) { + wireless_mode = false; + } + + // Every LSC_time_between_wireless_rebalance_in_ticks check against wireless network for re-balancing. + counter++; + if (wireless_mode && (counter >= LSC_time_between_wireless_rebalance_in_ticks)) { + + // Reset tick counter. + counter = 1; + + // Find difference. + BigInteger transferred_eu = stored.subtract( + (LSC_wireless_eu_cap.multiply(BigInteger.valueOf(getUHVCapacitorCount()))) + .add(UEV_wireless_eu_cap.multiply(BigInteger.valueOf(getUEVCapacitorCount()))) + .add(UIV_wireless_eu_cap.multiply(BigInteger.valueOf(getUIVCapacitorCount()))) + .add(UMV_wireless_eu_cap.multiply(BigInteger.valueOf(getUMVCapacitorCount())))); + + if (transferred_eu.signum() == 1) { + inputLastTick += transferred_eu.longValue(); + } else { + outputLastTick += transferred_eu.longValue(); + } + + // If that difference can be added then do so. + if (WirelessNetworkManager.addEUToGlobalEnergyMap(global_energy_user_uuid, transferred_eu)) { + // If it succeeds there was sufficient energy so set the internal capacity as such. + stored = LSC_wireless_eu_cap.multiply(BigInteger.valueOf(getUHVCapacitorCount())) + .add( + UEV_wireless_eu_cap.multiply(BigInteger.valueOf(getUEVCapacitorCount())) + .add(UIV_wireless_eu_cap.multiply(BigInteger.valueOf(getUIVCapacitorCount()))) + .add(UMV_wireless_eu_cap.multiply(BigInteger.valueOf(getUMVCapacitorCount())))); + } + } + + // Lose some energy. + // Re-calculate if the repair status changed. + if (super.getRepairStatus() != repairStatusCache) { + passiveDischargeAmount = recalculateLossWithMaintenance(super.getRepairStatus()); + } + + // This will break if you transfer more than 2^63 EU/t, so don't do that. Thanks <3 + temp_stored -= passiveDischargeAmount; + stored = stored.add(BigInteger.valueOf(temp_stored)); + + // Check that the machine has positive EU stored. + stored = (stored.compareTo(BigInteger.ZERO) <= 0) ? BigInteger.ZERO : stored; + + IGregTechTileEntity tBMTE = this.getBaseMetaTileEntity(); + + tBMTE.injectEnergyUnits(ForgeDirection.UNKNOWN, inputLastTick, 1L); + tBMTE.drainEnergyUnits(ForgeDirection.UNKNOWN, outputLastTick, 1L); + + // Add I/O values to Queues + if (energyInputValues.size() > DURATION_AVERAGE_TICKS) { + energyInputValues.remove(); + } + energyInputValues.offer(inputLastTick); + + if (energyOutputValues.size() > DURATION_AVERAGE_TICKS) { + energyOutputValues.remove(); + } + + energyOutputValues.offer(outputLastTick); + + return true; + } + + /** + * To be called whenever the maintenance status changes or the capacity was recalculated + * + * @param repairStatus This machine's repair status + * @return new BigInteger instance for passiveDischargeAmount + */ + private long recalculateLossWithMaintenance(int repairStatus) { + repairStatusCache = repairStatus; + + long temp_capacity_divided = 0; + + if (wirelessCapableCapacitors() == 0) { + temp_capacity_divided = capacity.divide(BigInteger.valueOf(100L * 86400L * 20L)) + .longValue(); + } + + // Passive loss is multiplied by number of UHV+ caps. Minimum of 1 otherwise loss is 0 for non-UHV+ caps + // calculations. + if (wirelessCapableCapacitors() != 0) { + temp_capacity_divided = getUHVCapacitorCount() * max_passive_drain_eu_per_tick_per_uhv_cap + + getUEVCapacitorCount() * max_passive_drain_eu_per_tick_per_uev_cap + + getUIVCapacitorCount() * max_passive_drain_eu_per_tick_per_uiv_cap + + getUMVCapacitorCount() * max_passive_drain_eu_per_tick_per_umv_cap; + } + + // Passive loss is multiplied by number of maintenance issues. + long total_passive_loss = temp_capacity_divided * (getIdealStatus() - repairStatus + 1); + + // Maximum of 100,000 EU/t drained per UHV cell. The logic is 1% of EU capacity should be drained every 86400 + // seconds (1 day). + return total_passive_loss; + } + + /** + * Calculate how much EU to draw from an Energy Hatch + * + * @param hatchWatts Hatch amperage * voltage + * @return EU amount + */ + private long getPowerToDraw(long hatchWatts) { + final BigInteger remcapActual = capacity.subtract(stored); + final BigInteger recampLimited = (MAX_LONG.compareTo(remcapActual) > 0) ? remcapActual : MAX_LONG; + return min(hatchWatts, recampLimited.longValue()); + } + + /** + * Calculate how much EU to push into a Dynamo Hatch + * + * @param hatchWatts Hatch amperage * voltage + * @return EU amount + */ + private long getPowerToPush(long hatchWatts) { + final BigInteger remStoredLimited = (MAX_LONG.compareTo(stored) > 0) ? stored : MAX_LONG; + return min(hatchWatts, remStoredLimited.longValue()); + } + + private long getAvgIn() { + long sum = 0L; + for (long l : energyInputValues) { + sum += l; + } + return sum / Math.max(energyInputValues.size(), 1); + } + + private long getAvgOut() { + long sum = 0L; + for (long l : energyOutputValues) { + sum += l; + } + return sum / Math.max(energyOutputValues.size(), 1); + } + + @Override + public String[] getInfoData() { + NumberFormat nf = NumberFormat.getNumberInstance(); + int secInterval = DURATION_AVERAGE_TICKS / 20; + + // Caching avgin and avgout + double avgIn = getAvgIn(); + double avgOut = getAvgOut(); + + final ArrayList<String> ll = new ArrayList<>(); + ll.add(EnumChatFormatting.YELLOW + "Operational Data:" + EnumChatFormatting.RESET); + ll.add("EU Stored: " + nf.format(stored) + " EU"); + ll.add("EU Stored: " + toStandardForm(stored) + " EU"); + ll.add("Used Capacity: " + toPercentageFrom(stored, capacity)); + ll.add("Total Capacity: " + nf.format(capacity) + " EU"); + ll.add("Total Capacity: " + toStandardForm(capacity) + " EU"); + ll.add("Passive Loss: " + nf.format(passiveDischargeAmount) + " EU/t"); + ll.add("EU IN: " + GT_Utility.formatNumbers(inputLastTick) + " EU/t"); + ll.add("EU OUT: " + GT_Utility.formatNumbers(outputLastTick) + " EU/t"); + ll.add("Avg EU IN: " + nf.format(avgIn) + " (last " + secInterval + " seconds)"); + ll.add("Avg EU OUT: " + nf.format(avgOut) + " (last " + secInterval + " seconds)"); + + // Check if the system is charging or discharging + if (avgIn > avgOut) { + // Calculate time to full if charging + if (avgIn != 0) { + double timeToFull = (capacity.longValue() - stored.longValue()) / avgIn / 20; + String timeToFullString = formatTime(timeToFull); + ll.add("Time to Full: " + timeToFullString); + } + } else { + // Calculate time to empty if discharging + if (avgOut != 0) { + double timeToEmpty = stored.longValue() / avgOut / 20; + String timeToEmptyString = formatTime(timeToEmpty); + ll.add("Time to Empty: " + timeToEmptyString); + } + } + ll.add( + "Maintenance Status: " + ((super.getRepairStatus() == super.getIdealStatus()) + ? EnumChatFormatting.GREEN + "Working perfectly" + EnumChatFormatting.RESET + : EnumChatFormatting.RED + "Has Problems" + EnumChatFormatting.RESET)); + ll.add( + "Wireless mode: " + (wireless_mode ? EnumChatFormatting.GREEN + "enabled" + EnumChatFormatting.RESET + : EnumChatFormatting.RED + "disabled" + EnumChatFormatting.RESET)); + ll.add( + GT_Values.TIER_COLORS[9] + GT_Values.VN[9] + + EnumChatFormatting.RESET + + " Capacitors detected: " + + getUHVCapacitorCount()); + ll.add( + GT_Values.TIER_COLORS[10] + GT_Values.VN[10] + + EnumChatFormatting.RESET + + " Capacitors detected: " + + getUEVCapacitorCount()); + ll.add( + GT_Values.TIER_COLORS[11] + GT_Values.VN[11] + + EnumChatFormatting.RESET + + " Capacitors detected: " + + getUIVCapacitorCount()); + ll.add( + GT_Values.TIER_COLORS[12] + GT_Values.VN[12] + + EnumChatFormatting.RESET + + " Capacitors detected: " + + getUMVCapacitorCount()); + ll.add( + "Total wireless EU: " + EnumChatFormatting.RED + + nf.format(WirelessNetworkManager.getUserEU(global_energy_user_uuid)) + + " EU"); + ll.add( + "Total wireless EU: " + EnumChatFormatting.RED + + toStandardForm(WirelessNetworkManager.getUserEU(global_energy_user_uuid)) + + " EU"); + + final String[] a = new String[ll.size()]; + return ll.toArray(a); + } + + // Method to format time in seconds, minutes, days, and years + private String formatTime(double time) { + if (time < 1) { + return "Completely " + (time < 0 ? "empty" : "full"); + } else if (time < 60) { + return String.format("%.2f seconds", time); + } else if (time < 3600) { + return String.format("%.2f minutes", time / 60); + } else if (time < 86400) { + return String.format("%.2f hours", time / 3600); + } else if (time < 31536000) { + return String.format("%.2f days", time / 86400); + } else { + return String.format("%.2f years", time / 31536000); + } + } + + @Override + public void saveNBTData(NBTTagCompound nbt) { + nbt = (nbt == null) ? new NBTTagCompound() : nbt; + + nbt.setByteArray("capacity", capacity.toByteArray()); + nbt.setByteArray("stored", stored.toByteArray()); + nbt.setBoolean("wireless_mode", wireless_mode); + nbt.setInteger("wireless_mode_cooldown", counter); + + super.saveNBTData(nbt); + } + + @Override + public void loadNBTData(NBTTagCompound nbt) { + nbt = (nbt == null) ? new NBTTagCompound() : nbt; + + capacity = new BigInteger(nbt.getByteArray("capacity")); + stored = new BigInteger(nbt.getByteArray("stored")); + wireless_mode = nbt.getBoolean("wireless_mode"); + counter = nbt.getInteger("wireless_mode_cooldown"); + + super.loadNBTData(nbt); + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public int getMaxEfficiency(ItemStack stack) { + return 10000; + } + + @Override + public int getPollutionPerTick(ItemStack stack) { + return 0; + } + + @Override + public int getDamageToComponent(ItemStack stack) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack stack) { + return false; + } + + // called by the getEUCapacity() function in BaseMetaTileEntity + @Override + public long maxEUStore() { + return capacity.longValue(); + } + + // called by the getEUStored() function in BaseMetaTileEntity + @Override + public long getEUVar() { + return stored.longValue(); + } + + /* + * all of these are needed for the injectEnergyUnits() and drainEnergyUnits() in IGregTechTileEntity + */ + @Override + public long maxEUInput() { + if (wireless_mode) { + return Long.MAX_VALUE; + } else { + return mMaxEUIn; + } + } + + @Override + public long maxAmperesIn() { + return 1L; + } + + @Override + public long maxEUOutput() { + if (wireless_mode) { + return Long.MAX_VALUE; + } else { + return mMaxEUOut; + } + } + + @Override + public long maxAmperesOut() { + return 1L; + } + + @Override + public boolean isEnetInput() { + return true; + } + + @Override + public boolean isEnetOutput() { + return true; + } + + protected boolean canUseWireless() { + return wirelessCapableCapacitors() != 0; + } + + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + if (canUseWireless()) { + wireless_mode = !wireless_mode; + GT_Utility.sendChatToPlayer(aPlayer, "Wireless network mode " + (wireless_mode ? "enabled." : "disabled.")); + } else { + GT_Utility.sendChatToPlayer( + aPlayer, + "Wireless mode cannot be enabled without at least 1 " + GT_Values.TIER_COLORS[9] + + GT_Values.VN[9] + + EnumChatFormatting.RESET + + "+ capacitor."); + wireless_mode = false; + } + } + + @Override + public void addUIWidgets(ModularWindow.Builder builder, UIBuildContext buildContext) { + super.addUIWidgets(builder, buildContext); + builder.widget(new ButtonWidget().setOnClick((clickData, widget) -> { + if (!widget.isClient()) { + canUseWireless = canUseWireless(); + } + if (canUseWireless) { + wireless_mode = !wireless_mode; + } + }) + .setPlayClickSound(true) + .setBackground(() -> { + List<UITexture> ret = new ArrayList<>(); + ret.add(GT_UITextures.BUTTON_STANDARD); + if (canUseWireless) { + if (wireless_mode) { + ret.add(KT_UITextures.OVERLAY_BUTTON_WIRELESS_ON); + } else { + ret.add(KT_UITextures.OVERLAY_BUTTON_WIRELESS_OFF); + } + } else { + ret.add(KT_UITextures.OVERLAY_BUTTON_WIRELESS_OFF_DISABLED); + } + return ret.toArray(new IDrawable[0]); + }) + .setPos(80, 91) + .setSize(16, 16) + .addTooltip(StatCollector.translateToLocal("gui.kekztech_lapotronicenergyunit.wireless")) + .setTooltipShowUpDelay(TOOLTIP_DELAY)) + .widget(new FakeSyncWidget.BooleanSyncer(() -> wireless_mode, val -> wireless_mode = val)) + .widget(new FakeSyncWidget.BooleanSyncer(this::canUseWireless, val -> canUseWireless = val)); + } + + private enum LSCHatchElement implements IHatchElement<GTMTE_LapotronicSuperCapacitor> { + + Energy(GT_MetaTileEntity_Hatch_EnergyMulti.class, GT_MetaTileEntity_Hatch_Energy.class) { + + @Override + public long count(GTMTE_LapotronicSuperCapacitor t) { + return t.mEnergyHatches.size() + t.mEnergyHatchesTT.size() + t.mEnergyTunnelsTT.size(); + } + }, + Dynamo(GT_MetaTileEntity_Hatch_DynamoMulti.class, GT_MetaTileEntity_Hatch_Dynamo.class) { + + @Override + public long count(GTMTE_LapotronicSuperCapacitor t) { + return t.mDynamoHatches.size() + t.mDynamoHatchesTT.size() + t.mDynamoTunnelsTT.size(); + } + },; + + private final List<? extends Class<? extends IMetaTileEntity>> mteClasses; + + @SafeVarargs + LSCHatchElement(Class<? extends IMetaTileEntity>... mteClasses) { + this.mteClasses = Arrays.asList(mteClasses); + } + + @Override + public List<? extends Class<? extends IMetaTileEntity>> mteClasses() { + return mteClasses; + } + + @Override + public IGT_HatchAdder<? super GTMTE_LapotronicSuperCapacitor> adder() { + return GTMTE_LapotronicSuperCapacitor::addBottomHatches; + } + } +} diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java b/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java new file mode 100644 index 0000000000..8ec9d43ddd --- /dev/null +++ b/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK1.java @@ -0,0 +1,221 @@ +package common.tileentities; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAnyMeta; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_GLOW; +import static gregtech.api.util.GT_StructureUtility.ofHatchAdder; + +import java.util.ArrayList; +import java.util.Collection; + +import javax.annotation.Nonnull; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; + +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import common.Blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.recipe.check.CheckRecipeResult; +import gregtech.api.recipe.check.CheckRecipeResultRegistry; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_ModHandler; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; + +public class GTMTE_SOFuelCellMK1 extends GT_MetaTileEntity_EnhancedMultiBlockBase<GTMTE_SOFuelCellMK1> { + + private final int OXYGEN_PER_SEC = 100; + private final int EU_PER_TICK = 2048; + private final int STEAM_PER_SEC = 20000; + + public GTMTE_SOFuelCellMK1(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GTMTE_SOFuelCellMK1(String aName) { + super(aName); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) { + return new GTMTE_SOFuelCellMK1(super.mName); + } + + private int mCasing = 0; + + private static final int CASING_TEXTURE_ID = 49; + private static final String STRUCTURE_PIECE_MAIN = "main"; + private static final IStructureDefinition<GTMTE_SOFuelCellMK1> STRUCTURE_DEFINITION = IStructureDefinition + .<GTMTE_SOFuelCellMK1>builder() + .addShape( + STRUCTURE_PIECE_MAIN, + transpose( + new String[][] { { "ccc", "ccc", "ccc", "ccc", "ccc" }, { "c~c", "geg", "geg", "geg", "cdc" }, + { "ccc", "ccc", "ccc", "ccc", "ccc" } })) + .addElement( + 'c', + ofChain( + onElementPass(te -> te.mCasing++, ofBlock(GregTech_API.sBlockCasings4, 1)), + ofHatchAdder(GTMTE_SOFuelCellMK1::addInputToMachineList, CASING_TEXTURE_ID, 1), + ofHatchAdder(GTMTE_SOFuelCellMK1::addMaintenanceToMachineList, CASING_TEXTURE_ID, 1), + ofHatchAdder(GTMTE_SOFuelCellMK1::addOutputToMachineList, CASING_TEXTURE_ID, 1))) + .addElement('d', ofHatchAdder(GTMTE_SOFuelCellMK1::addDynamoToMachineList, CASING_TEXTURE_ID, 1)) + .addElement('g', ofBlockAnyMeta(GameRegistry.findBlock("IC2", "blockAlloyGlass"))) + .addElement('e', ofBlockAnyMeta(Blocks.yszUnit)) + .build(); + + @Override + public IStructureDefinition<GTMTE_SOFuelCellMK1> getStructureDefinition() { + return STRUCTURE_DEFINITION; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Gas Turbine") + .addInfo("Oxidizes gas fuels to generate electricity without polluting the environment") + .addInfo( + "Consumes up to " + GT_Utility.formatNumbers(EU_PER_TICK * 20) + + "EU worth of fuel with up to 100% efficiency each second") + .addInfo("Steam production requires the SOFC to heat up completely first") + .addInfo("Outputs " + EU_PER_TICK + "EU/t and " + STEAM_PER_SEC + "L/s Steam") + .addInfo("Additionally, requires " + OXYGEN_PER_SEC + "L/s Oxygen gas") + .addSeparator() + .beginStructureBlock(3, 3, 5, false) + .addController("Front center") + .addCasingInfoMin("Clean Stainless Steel Casing", 12, false) + .addOtherStructurePart("YSZ Ceramic Electrolyte Unit", "3x, Center 1x1x3") + .addOtherStructurePart("Reinforced Glass", "6x, touching the electrolyte units on the horizontal sides") + .addDynamoHatch("Back center", 1) + .addMaintenanceHatch("Any casing") + .addInputHatch("Fuel, any casing") + .addInputHatch("Oxygen, any casing") + .addOutputHatch("Steam, any casing") + .toolTipFinisher("KekzTech"); + return tt; + } + + @Override + public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final ForgeDirection side, + final ForgeDirection facing, final int colorIndex, final boolean aActive, final boolean aRedstone) { + if (side == facing) { + if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW) + .extFacing() + .glow() + .build() }; + return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_GLOW) + .extFacing() + .glow() + .build() }; + } + return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID) }; + } + + @Override + public boolean isCorrectMachinePart(ItemStack stack) { + return true; + } + + @Nonnull + @Override + public CheckRecipeResult checkProcessing() { + final ArrayList<FluidStack> storedFluids = super.getStoredFluids(); + Collection<GT_Recipe> recipeList = RecipeMaps.gasTurbineFuels.getAllRecipes(); + + for (FluidStack hatchFluid : storedFluids) { + for (GT_Recipe aFuel : recipeList) { + FluidStack liquid; + if ((liquid = GT_Utility.getFluidForFilledItem(aFuel.getRepresentativeInput(0), true)) != null + && hatchFluid.isFluidEqual(liquid)) { + + liquid.amount = (EU_PER_TICK * 20) / aFuel.mSpecialValue; + + if (super.depleteInput(liquid)) { + + if (!super.depleteInput(Materials.Oxygen.getGas(OXYGEN_PER_SEC))) { + super.mEUt = 0; + super.mEfficiency = 0; + return CheckRecipeResultRegistry.NO_FUEL_FOUND; + } + + super.mEUt = EU_PER_TICK; + super.mMaxProgresstime = 20; + super.mEfficiencyIncrease = 40; + if (super.mEfficiency == getMaxEfficiency(null)) { + super.addOutput(GT_ModHandler.getSteam(STEAM_PER_SEC)); + } + return CheckRecipeResultRegistry.GENERATING; + } + } + } + } + + super.mEUt = 0; + super.mEfficiency = 0; + return CheckRecipeResultRegistry.NO_FUEL_FOUND; + } + + @Override + public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) { + this.mCasing = 0; + + if (!checkPiece(STRUCTURE_PIECE_MAIN, 1, 1, 0)) return false; + + return (this.mCasing >= 12 && this.mMaintenanceHatches.size() == 1 && this.mInputHatches.size() >= 2); + } + + @Override + public int getMaxEfficiency(ItemStack stack) { + return 10000; + } + + @Override + public int getPollutionPerTick(ItemStack stack) { + return 0; + } + + @Override + public int getDamageToComponent(ItemStack stack) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack stack) { + return false; + } + + @Override + public void construct(ItemStack itemStack, boolean b) { + buildPiece(STRUCTURE_PIECE_MAIN, itemStack, b, 1, 1, 0); + } +} diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java b/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java new file mode 100644 index 0000000000..01150ab910 --- /dev/null +++ b/kekztech/src/main/java/common/tileentities/GTMTE_SOFuelCellMK2.java @@ -0,0 +1,222 @@ +package common.tileentities; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockAnyMeta; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_HEAT_EXCHANGER_GLOW; +import static gregtech.api.util.GT_StructureUtility.ofHatchAdder; + +import java.util.ArrayList; +import java.util.Collection; + +import javax.annotation.Nonnull; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; + +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import common.Blocks; + +import cpw.mods.fml.common.registry.GameRegistry; +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.recipe.check.CheckRecipeResult; +import gregtech.api.recipe.check.CheckRecipeResultRegistry; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; + +public class GTMTE_SOFuelCellMK2 extends GT_MetaTileEntity_EnhancedMultiBlockBase<GTMTE_SOFuelCellMK2> { + + private final int OXYGEN_PER_SEC = 2000; + private final int EU_PER_TICK = 24576; // 100% Efficiency, 3A IV + private final int STEAM_PER_SEC = 96000; // SH Steam (10,800EU/t @ 150% Efficiency) + + public GTMTE_SOFuelCellMK2(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GTMTE_SOFuelCellMK2(String aName) { + super(aName); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity var1) { + return new GTMTE_SOFuelCellMK2(super.mName); + } + + private int mCasing = 0; + + private static final int CASING_TEXTURE_ID = 48; + private static final String STRUCTURE_PIECE_MAIN = "main"; + private static final IStructureDefinition<GTMTE_SOFuelCellMK2> STRUCTURE_DEFINITION = IStructureDefinition + .<GTMTE_SOFuelCellMK2>builder() + .addShape( + STRUCTURE_PIECE_MAIN, + transpose( + new String[][] { { "ccc", "ccc", "ccc", "ccc", "ccc" }, { "c~c", "geg", "geg", "geg", "cdc" }, + { "ccc", "ccc", "ccc", "ccc", "ccc" } })) + .addElement( + 'c', + ofChain( + onElementPass(te -> te.mCasing++, ofBlock(GregTech_API.sBlockCasings4, 0)), + ofHatchAdder(GTMTE_SOFuelCellMK2::addInputToMachineList, CASING_TEXTURE_ID, 1), + ofHatchAdder(GTMTE_SOFuelCellMK2::addMaintenanceToMachineList, CASING_TEXTURE_ID, 1), + ofHatchAdder(GTMTE_SOFuelCellMK2::addOutputToMachineList, CASING_TEXTURE_ID, 1))) + .addElement('d', ofHatchAdder(GTMTE_SOFuelCellMK2::addDynamoToMachineList, CASING_TEXTURE_ID, 1)) + .addElement('g', ofBlockAnyMeta(GameRegistry.findBlock("IC2", "blockAlloyGlass"))) + .addElement('e', ofBlockAnyMeta(Blocks.gdcUnit)) + .build(); + + @Override + public IStructureDefinition<GTMTE_SOFuelCellMK2> getStructureDefinition() { + return STRUCTURE_DEFINITION; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Gas Turbine") + .addInfo("Oxidizes gas fuels to generate electricity without polluting the environment") + .addInfo( + "Consumes up to " + GT_Utility.formatNumbers(EU_PER_TICK * 20) + + "EU worth of fuel with up to 100% efficiency each second") + .addInfo("Nitrobenzene and other gas fuels above 1M EU/bucket are more efficient") + .addInfo("Steam production requires the SOFC to heat up completely first") + .addInfo("Outputs " + EU_PER_TICK + "EU/t and " + STEAM_PER_SEC + "L/s Steam") + .addInfo("Additionally, requires " + OXYGEN_PER_SEC + "L/s Oxygen gas") + .addSeparator() + .beginStructureBlock(3, 3, 5, false) + .addController("Front center") + .addCasingInfoMin("Robust Tungstensteel Machine Casing", 12, false) + .addOtherStructurePart("GDC Ceramic Electrolyte Unit", "3x, Center 1x1x3") + .addOtherStructurePart("Reinforced Glass", "6x, touching the electrolyte units on the horizontal sides") + .addDynamoHatch("Back center", 1) + .addMaintenanceHatch("Any casing") + .addInputHatch("Fuel, any casing") + .addInputHatch("Oxygen, any casing") + .addOutputHatch("Superheated Steam, any casing") + .toolTipFinisher("KekzTech"); + return tt; + } + + @Override + public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final ForgeDirection side, + final ForgeDirection facing, final int colorIndex, final boolean aActive, final boolean aRedstone) { + if (side == facing) { + if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_ACTIVE_GLOW) + .extFacing() + .glow() + .build() }; + return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_HEAT_EXCHANGER_GLOW) + .extFacing() + .glow() + .build() }; + } + return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID) }; + } + + @Override + public boolean isCorrectMachinePart(ItemStack stack) { + return true; + } + + @Nonnull + @Override + public CheckRecipeResult checkProcessing() { + final ArrayList<FluidStack> storedFluids = super.getStoredFluids(); + Collection<GT_Recipe> recipeList = RecipeMaps.gasTurbineFuels.getAllRecipes(); + + for (FluidStack hatchFluid : storedFluids) { + for (GT_Recipe aFuel : recipeList) { + FluidStack liquid; + if ((liquid = GT_Utility.getFluidForFilledItem(aFuel.getRepresentativeInput(0), true)) != null + && hatchFluid.isFluidEqual(liquid)) { + + liquid.amount = (EU_PER_TICK * 20) / aFuel.mSpecialValue / Math.max(1, aFuel.mSpecialValue / 1000); + + if (super.depleteInput(liquid)) { + + if (!super.depleteInput(Materials.Oxygen.getGas(OXYGEN_PER_SEC))) { + super.mEUt = 0; + super.mEfficiency = 0; + return CheckRecipeResultRegistry.NO_FUEL_FOUND; + } + + super.mEUt = EU_PER_TICK; + super.mMaxProgresstime = 20; + super.mEfficiencyIncrease = 80; + if (super.mEfficiency == getMaxEfficiency(null)) { + super.addOutput(FluidRegistry.getFluidStack("ic2superheatedsteam", STEAM_PER_SEC)); + } + return CheckRecipeResultRegistry.GENERATING; + } + } + } + } + + super.mEUt = 0; + super.mEfficiency = 0; + return CheckRecipeResultRegistry.NO_FUEL_FOUND; + } + + @Override + public boolean checkMachine(IGregTechTileEntity thisController, ItemStack guiSlotItem) { + this.mCasing = 0; + + if (!checkPiece(STRUCTURE_PIECE_MAIN, 1, 1, 0)) return false; + + return (this.mCasing >= 12 && this.mMaintenanceHatches.size() == 1 && this.mInputHatches.size() >= 2); + } + + @Override + public int getMaxEfficiency(ItemStack stack) { + return 10000; + } + + @Override + public int getPollutionPerTick(ItemStack stack) { + return 0; + } + + @Override + public int getDamageToComponent(ItemStack stack) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack stack) { + return false; + } + + @Override + public void construct(ItemStack itemStack, boolean b) { + buildPiece(STRUCTURE_PIECE_MAIN, itemStack, b, 1, 1, 0); + } +} diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_TFFT.java b/kekztech/src/main/java/common/tileentities/GTMTE_TFFT.java new file mode 100644 index 0000000000..18867c0656 --- /dev/null +++ b/kekztech/src/main/java/common/tileentities/GTMTE_TFFT.java @@ -0,0 +1,787 @@ +package common.tileentities; + +import static com.github.bartimaeusnek.bartworks.util.BW_Util.ofGlassTieredMixed; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlock; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofBlockUnlocalizedName; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.ofChain; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.onElementPass; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.transpose; +import static gregtech.api.enums.GT_HatchElement.Energy; +import static gregtech.api.enums.GT_HatchElement.InputHatch; +import static gregtech.api.enums.GT_HatchElement.Maintenance; +import static gregtech.api.enums.GT_HatchElement.OutputHatch; +import static gregtech.api.util.GT_StructureUtility.buildHatchAdder; +import static java.lang.Math.min; +import static net.minecraft.util.StatCollector.translateToLocal; + +import java.math.BigInteger; +import java.text.MessageFormat; +import java.text.NumberFormat; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; + +import com.gtnewhorizon.structurelib.StructureLibAPI; +import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor; +import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable; +import com.gtnewhorizon.structurelib.structure.AutoPlaceEnvironment; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.IStructureElement; +import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment; +import com.gtnewhorizon.structurelib.structure.StructureUtility; +import com.gtnewhorizon.structurelib.util.ItemStackPredicate; +import common.Blocks; + +import gregtech.api.enums.Textures; +import gregtech.api.fluid.FluidTankGT; +import gregtech.api.interfaces.IHatchElement; +import gregtech.api.interfaces.IIconContainer; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_EnhancedMultiBlockBase; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.IGT_HatchAdder; +import gregtech.common.items.GT_IntegratedCircuit_Item; + +public class GTMTE_TFFT extends GT_MetaTileEntity_EnhancedMultiBlockBase<GTMTE_TFFT> implements ISurvivalConstructable { + + public enum Field { + + T1(1_000_000L, 1), // LV + T2(4_000_000L, 2), // MV + T3(16_000_000L, 5), // HV + T4(64_000_000L, 14), // EV + T5(256_000_000L, 42), // IV + + T6(2_048_000_000L, 132), // LuV + T7(131_072_000_000L, 429), // UV + T8(8_388_608_000_000L, 1430), // UEV + T9(536_870_912_000_000L, 4862), // UMV + + T10(1_099_511_627_776_000_000L, 0); // UXV + + public static final GTMTE_TFFT.Field[] VALUES = values(); + private final long capacity; + private final int cost; + + Field(long capacity, int cost) { + this.capacity = capacity; + this.cost = cost; + } + + public long getCapacity() { + return capacity; + } + + public int getCost() { + return cost; + } + } + + private enum TFFTMultiHatch implements IHatchElement<GTMTE_TFFT> { + + INSTANCE; + + private final List<? extends Class<? extends IMetaTileEntity>> mteClasses; + + @SafeVarargs + TFFTMultiHatch(Class<? extends IMetaTileEntity>... mteClasses) { + this.mteClasses = Arrays.asList(mteClasses); + } + + @Override + public List<? extends Class<? extends IMetaTileEntity>> mteClasses() { + return mteClasses; + } + + @Override + public IGT_HatchAdder<? super GTMTE_TFFT> adder() { + return GTMTE_TFFT::addMultiHatchToMachineList; + } + + @Override + public long count(GTMTE_TFFT t) { + return t.tfftHatch == null ? 0 : 1; + } + } + + private enum TFFTStorageFieldElement implements IStructureElement<GTMTE_TFFT> { + + INSTANCE; + + @Override + public boolean check(GTMTE_TFFT t, World world, int x, int y, int z) { + Block worldBlock = world.getBlock(x, y, z); + int meta = worldBlock.getDamageValue(world, x, y, z); + if (TFFT_FIELD != worldBlock || meta == 0) return false; + t.FIELDS[meta - 1]++; + return true; + } + + private int getHint(ItemStack stack) { + return Math.min(Field.VALUES.length, ChannelDataAccessor.getChannelData(stack, "field")); + } + + @Override + public boolean spawnHint(GTMTE_TFFT t, World world, int x, int y, int z, ItemStack trigger) { + StructureLibAPI.hintParticle(world, x, y, z, TFFT_FIELD, getHint(trigger)); + return true; + } + + @Override + public boolean placeBlock(GTMTE_TFFT t, World world, int x, int y, int z, ItemStack trigger) { + world.setBlock(x, y, z, TFFT_FIELD, getHint(trigger), 3); + return true; + } + + @Override + public PlaceResult survivalPlaceBlock(GTMTE_TFFT t, World world, int x, int y, int z, ItemStack trigger, + AutoPlaceEnvironment env) { + if (check(t, world, x, y, z)) return PlaceResult.SKIP; + int fieldTier = getHint(trigger); + ItemStack result = env.getSource() + .takeOne( + s -> s != null && s.stackSize >= 0 + && s.getItem() == TFFT_FIELD_ITEM + && s.getItemDamage() != CASING_META + && s.getItemDamage() <= fieldTier, + true); + if (result == null) return PlaceResult.REJECT; + + return StructureUtility.survivalPlaceBlock( + result, + ItemStackPredicate.NBTMode.EXACT, + null, + true, + world, + x, + y, + z, + env.getSource(), + env.getActor(), + env.getChatter()); + } + } + + private static final IIconContainer TEXTURE_TFFT = new Textures.BlockIcons.CustomIcon("iconsets/TFFT"); + private static final IIconContainer TEXTURE_TFFT_ACTIVE = new Textures.BlockIcons.CustomIcon( + "iconsets/TFFT_ACTIVE"); + private static final IIconContainer TEXTURE_TFFT_ACTIVE_GLOW = new Textures.BlockIcons.CustomIcon( + "iconsets/TFFT_ACTIVE_GLOW"); + private static final int CASING_TEXTURE_ID_1 = (12 << 7) | 127; + private static final int CASING_TEXTURE_ID_2 = 176; + + private static final Block TFFT_FIELD = Blocks.tfftStorageField; + private static final Item TFFT_FIELD_ITEM = Item.getItemFromBlock(TFFT_FIELD); + public static final int MAX_DISTINCT_FLUIDS = 25; + private static final BigInteger MAX_CAPACITY = BigInteger.valueOf(Long.MAX_VALUE) + .multiply(BigInteger.valueOf(25)); + private static final int CASING_META = 0; + private static final int MIN_CASING_AMOUNT = 20; + private static final int MAX_LAYER_AMOUNT = 13; + private static final int DEFAULT_LAYER_AMOUNT = 3; + + private static final String STRUCTURE_PIECE_TOP = "top"; + private static final String STRUCTURE_PIECE_MID = "mid"; + private static final String STRUCTURE_PIECE_BOTTOM = "bottom"; + + @Override + public String[] getStructureDescription(ItemStack stackSize) { + return description; + } + + private static final String[] description = new String[] { + translateToLocal("tile.kekztech_tfftstoragefield_block.hint.1"), // Casing + translateToLocal("tile.kekztech_tfftstoragefield_block.hint.2"), // Casing, Maintenance Hatch, T.F.F.T Multi + // I/O Hatch, Input/Output Hatch, Energy + // Hatch + translateToLocal("tile.kekztech_tfftstoragefield_block.hint.3"), // Glass, T.F.F.T Multi I/O Hatch, + // Input/Output Hatch + translateToLocal("tile.kekztech_tfftstoragefield_block.hint.4"), // Glass + }; + + // height channel for height + // field channel for field + private static final IStructureDefinition<GTMTE_TFFT> STRUCTURE_DEFINITION = IStructureDefinition + .<GTMTE_TFFT>builder() + .addShape( + STRUCTURE_PIECE_TOP, + transpose(new String[][] { { "ccccc" }, { "cCCCc" }, { "cC~Cc" }, { "cCCCc" }, { "ccccc" } })) + .addShape( + STRUCTURE_PIECE_MID, + transpose(new String[][] { { "gGGGg" }, { "GfffG" }, { "GfffG" }, { "GfffG" }, { "gGGGg" } })) + .addShape( + STRUCTURE_PIECE_BOTTOM, + transpose(new String[][] { { "ccccc" }, { "cCCCc" }, { "cCCCc" }, { "cCCCc" }, { "ccccc" } })) + .addElement( + 'c', + buildHatchAdder(GTMTE_TFFT.class).atLeast(Energy, Maintenance) + .casingIndex(CASING_TEXTURE_ID_1) + .dot(1) + .buildAndChain(onElementPass(te -> te.casingAmount++, ofBlock(TFFT_FIELD, CASING_META)))) + .addElement( + 'C', + buildHatchAdder(GTMTE_TFFT.class).casingIndex(CASING_TEXTURE_ID_1) + .atLeast( + Energy, + Maintenance, + InputHatch.or(TFFTMultiHatch.INSTANCE), + OutputHatch.or(TFFTMultiHatch.INSTANCE)) + .dot(2) + .buildAndChain(onElementPass(te -> te.casingAmount++, ofBlock(TFFT_FIELD, CASING_META)))) + .addElement( + 'G', + buildHatchAdder(GTMTE_TFFT.class) + .atLeast(InputHatch.or(TFFTMultiHatch.INSTANCE), OutputHatch.or(TFFTMultiHatch.INSTANCE)) + .casingIndex(CASING_TEXTURE_ID_2) + .dot(3) + .buildAndChain( + ofBlockUnlocalizedName("Thaumcraft", "blockCosmeticOpaque", 2, false), + ofGlassTieredMixed((byte) 4, (byte) 127, 3))) + .addElement( + 'g', + ofChain( + ofBlockUnlocalizedName("Thaumcraft", "blockCosmeticOpaque", 2, false), + ofGlassTieredMixed((byte) 4, (byte) 127, 4))) + .addElement('f', ofChain(TFFTStorageFieldElement.INSTANCE)) + .build(); + + public final FluidTankGT[] STORE = new FluidTankGT[MAX_DISTINCT_FLUIDS]; + + { + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + STORE[i] = new FluidTankGT(0); + } + } + + private final int[] FIELDS = new int[Field.VALUES.length]; + + private BigInteger capacity = BigInteger.ZERO; + private long capacityPerFluid = 0L; + private int casingAmount = 0; + private int runningCost = 0; + + private boolean locked = true; + private boolean doVoidExcess = false; + private byte fluidSelector = -1; + + private GTMTE_TFFTHatch tfftHatch = null; + + public GTMTE_TFFT(String aName) { + super(aName); + } + + public GTMTE_TFFT(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional); + } + + @Override + public IStructureDefinition<GTMTE_TFFT> getStructureDefinition() { + return STRUCTURE_DEFINITION; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GTMTE_TFFT(super.mName); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean aActive, boolean aRedstone) { + if (side == facing) { + if (aActive) return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID_1), + TextureFactory.builder() + .addIcon(TEXTURE_TFFT_ACTIVE) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(TEXTURE_TFFT_ACTIVE_GLOW) + .extFacing() + .glow() + .build() }; + return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID_1), + TextureFactory.builder() + .addIcon(TEXTURE_TFFT) + .extFacing() + .build() }; + } + return new ITexture[] { Textures.BlockIcons.getCasingTextureForId(CASING_TEXTURE_ID_1) }; + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Fluid Tank") + .addInfo("High-Tech fluid tank that can hold up to 25 different fluids!") + .addInfo("Has 1/25th of the total capacity as capacity for each fluid.") + .addInfo("Right clicking the controller with a screwdriver will turn on excess voiding.") + .addInfo("Fluid storage amount and running cost depends on the storage field blocks used.") + .addSeparator() + .addInfo("Note on hatch locking:") + .addInfo("Use an Integrated Circuit in the GUI slot to limit which fluid is output.") + .addInfo("The index of a stored fluid can be obtained through the Tricorder.") + .addSeparator() + .beginVariableStructureBlock(5, 5, 5, 15, 5, 5, false) + .addController("Top Center") + .addCasingInfoMin("T.F.F.T Casing", MIN_CASING_AMOUNT, false) + .addOtherStructurePart("Storage Field Blocks (Tier I-X)", "Inner 3xhx3 solid pillar") + .addStructureInfo("Energy hatch is not required when running cost is 0") + .addOtherStructurePart("EV+ Tier Glass/Warded Glass/Reinforced Glass", "Outer 5xhx5 glass shell") + .addMaintenanceHatch("Any top or bottom casing") + .addEnergyHatch("Any top or bottom casing") + .addInputHatch("Instead of any casing or glass, has to touch storage field block") + .addOutputHatch("Instead of any casing or glass, has to touch storage field block") + .addStructureInfo("You can have a bunch of hatches") + .addOtherStructurePart( + "Multi I/O Hatches", + "Instead of any casing or glass, has to touch storage field block") + .addStructureInfo("Use MIOH with conduits or fluid storage busses to see all fluids at once.") + .addSubChannelUsage("field", "Maximum Field Tier") + .addSubChannelUsage("height", "Height of structure") + .toolTipFinisher("KekzTech"); + return tt; + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + int layer = min(stackSize.stackSize + DEFAULT_LAYER_AMOUNT, MAX_LAYER_AMOUNT + 1); + buildPiece(STRUCTURE_PIECE_TOP, stackSize, hintsOnly, 2, 2, 0); + for (int i = -1; i >= 1 - layer; i--) buildPiece(STRUCTURE_PIECE_MID, stackSize, hintsOnly, 2, 2, i); + buildPiece(STRUCTURE_PIECE_BOTTOM, stackSize, hintsOnly, 2, 2, -layer); + } + + @Override + public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) { + if (mMachine) return -1; + int build = survivialBuildPiece(STRUCTURE_PIECE_TOP, stackSize, 2, 2, 0, elementBudget, env, false, true); + if (build >= 0) return build; + int layer = min(stackSize.stackSize + DEFAULT_LAYER_AMOUNT, MAX_LAYER_AMOUNT + 1); + for (int i = -1; i >= 1 - layer; i--) { + build = survivialBuildPiece(STRUCTURE_PIECE_MID, stackSize, 2, 2, i, elementBudget, env, false, true); + if (build >= 0) return build; + } + return survivialBuildPiece(STRUCTURE_PIECE_BOTTOM, stackSize, 2, 2, -layer, elementBudget, env, false, true); + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + @Override + public void clearHatches() { + super.clearHatches(); + if (tfftHatch != null) { + tfftHatch.unbind(); + tfftHatch = null; + } + } + + @Override + public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + Arrays.fill(FIELDS, 0); + + this.capacity = BigInteger.ZERO; + this.capacityPerFluid = 0L; + this.casingAmount = 0; + this.runningCost = 0; + + if (!checkPiece(STRUCTURE_PIECE_TOP, 2, 2, 0)) return false; + + int layer = 1; + while (checkPiece(STRUCTURE_PIECE_MID, 2, 2, -layer)) layer++; + if (layer - 1 > MAX_LAYER_AMOUNT || layer - 1 < DEFAULT_LAYER_AMOUNT) return false; + if (!checkPiece(STRUCTURE_PIECE_BOTTOM, 2, 2, -layer)) return false; + if (casingAmount >= MIN_CASING_AMOUNT + && (tfftHatch != null || (!mInputHatches.isEmpty() && !mOutputHatches.isEmpty())) + && mInputHatches.size() + mOutputHatches.size() <= MAX_DISTINCT_FLUIDS * 2 + && mMaintenanceHatches.size() == 1) { + BigInteger tempCap = BigInteger.ZERO; + for (int i = 0; i < this.FIELDS.length; i++) { + tempCap = tempCap.add( + BigInteger.valueOf(Field.VALUES[i].getCapacity()) + .multiply(BigInteger.valueOf(this.FIELDS[i]))); + this.runningCost += Field.VALUES[i].getCost() * this.FIELDS[i]; + } + this.setCapacity(tempCap); + + if (tfftHatch != null) tfftHatch.bind(this); + + if (this.runningCost == 0) { + return true; + } + + return !mEnergyHatches.isEmpty(); + } + return false; + } + + @Override + public boolean checkRecipe(ItemStack itemStack) { + mEfficiency = getCurrentEfficiency(null); + mEfficiencyIncrease = 10000; + mEUt = this.runningCost; + mMaxProgresstime = 20; + + this.fluidSelector = (itemStack != null && itemStack.getItem() instanceof GT_IntegratedCircuit_Item) + ? (byte) itemStack.getItemDamage() + : -1; + + // Suck in fluids + final ArrayList<FluidStack> inputFluids = getStoredFluids(); + + if (!inputFluids.isEmpty()) { + for (FluidStack aFluid : inputFluids) { + final FluidStack toDeplete = aFluid.copy(); + toDeplete.amount = this.pull(aFluid, true); + depleteInput(toDeplete); + } + } + + // Push out fluids + if (!this.mOutputHatches.isEmpty()) { + final FluidTankGT sFluid = this.getSelectedFluid(); + boolean isFluidSelected = this.fluidSelector != -1; + + if (!isFluidSelected || !sFluid.isEmpty()) { + for (GT_MetaTileEntity_Hatch_Output tHatch : this.mOutputHatches) { + int hatchCapacity = tHatch.getCapacity(); + int hatchAmount = tHatch.getFluidAmount(); + int remaining = hatchCapacity - hatchAmount; + + if (remaining <= 0) continue; + + final FluidStack tFluid = tHatch.getFluid(); + + String lockedFluidName = tHatch.getLockedFluidName() == null ? "" : tHatch.getLockedFluidName(); + String tFluidName = tFluid == null ? "" + : tFluid.getFluid() + .getName(); + + boolean isFluidLocked = tHatch.isFluidLocked(); + boolean isFluidEmpty = tFluid == null || tHatch.getFluidAmount() == 0; + + if (isFluidLocked && !this.contains(lockedFluidName)) continue; + if (!isFluidEmpty && !this.contains(tFluid)) continue; + if ((isFluidLocked && !isFluidEmpty) && !lockedFluidName.equals(tFluidName)) continue; + + if (isFluidSelected) { + if (isFluidLocked && !lockedFluidName.equals(sFluid.name())) continue; + if (!isFluidEmpty && !sFluid.contains(tFluid)) continue; + + tHatch.fill(this.push(sFluid.get(remaining), true), true); + } else if (isFluidLocked) { + if (!isFluidEmpty && !lockedFluidName.equals( + tFluid.getFluid() + .getName())) + continue; + + FluidStack aFluid = FluidRegistry.getFluidStack(lockedFluidName, remaining); + tHatch.fill(this.push(aFluid, true), true); + } else if (isFluidEmpty) { + if (this.firstNotNull() != null) tHatch.fill(this.push(hatchCapacity, true), true); + } else { + tHatch.fill(this.push(new FluidStack(tFluid, remaining), true), true); + } + } + } + } + + if (this.mEUt > 0) this.mEUt = -this.mEUt; + + return true; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + super.onPostTick(aBaseMetaTileEntity, aTick); + if (aBaseMetaTileEntity.isServerSide()) this.locked = !aBaseMetaTileEntity.isActive(); + } + + @Override + public String[] getInfoData() { + ArrayList<String> ll = new ArrayList<>(); + NumberFormat nf = NumberFormat.getNumberInstance(); + + ll.add(EnumChatFormatting.YELLOW + "Stored Fluids:" + EnumChatFormatting.RESET); + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + FluidTankGT tank = STORE[i]; + if (tank.isEmpty()) { + ll.add(MessageFormat.format("{0} - {1}: {2}L ({3}%)", i, "NULL", 0, 0)); + } else { + String localizedName = STORE[i].get() + .getLocalizedName(); + String amount = nf.format(STORE[i].amount()); + String percentage = capacityPerFluid > 0 ? String.valueOf(STORE[i].amount() * 100 / capacityPerFluid) + : ""; + + ll.add(MessageFormat.format("{0} - {1}: {2}L ({3}%)", i, localizedName, amount, percentage)); + } + } + ll.add(EnumChatFormatting.YELLOW + "Operational Data:" + EnumChatFormatting.RESET); + ll.add("Used Capacity: " + nf.format(getStoredAmount()) + "L"); + ll.add("Total Capacity: " + nf.format(capacity) + "L"); + ll.add("Per-Fluid Capacity: " + nf.format(capacityPerFluid) + "L"); + ll.add("Running Cost: " + getActualEnergyUsage() + "EU/t"); + ll.add("Auto-voiding: " + doVoidExcess); + ll.add( + "Maintenance Status: " + ((getRepairStatus() == getIdealStatus()) + ? EnumChatFormatting.GREEN + "Working perfectly" + EnumChatFormatting.RESET + : EnumChatFormatting.RED + "Has Problems" + EnumChatFormatting.RESET)); + ll.add("---------------------------------------------"); + + return ll.toArray(new String[0]); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setByteArray("capacity", capacity.toByteArray()); + aNBT.setBoolean("doVoidExcess", doVoidExcess); + aNBT.setInteger("runningCost", runningCost); + aNBT.setBoolean("lockFluid", locked); + aNBT.setByte("fluidSelector", fluidSelector); + + NBTTagCompound fluidNBT = new NBTTagCompound(); + aNBT.setTag("STORE", fluidNBT); + + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + STORE[i].writeToNBT(fluidNBT, String.valueOf(i)); + } + + super.saveNBTData(aNBT); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + this.setCapacity(new BigInteger(aNBT.getByteArray("capacity"))); + this.setDoVoidExcess(aNBT.getBoolean("doVoidExcess")); + this.runningCost = aNBT.getInteger("runningCost"); + this.locked = aNBT.getBoolean("lockFluid"); + this.fluidSelector = aNBT.getByte("fluidSelector"); + + NBTTagCompound fluidNBT = (NBTTagCompound) aNBT.getTag("STORE"); + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + STORE[i].readFromNBT(fluidNBT, String.valueOf(i)); + } + + super.loadNBTData(aNBT); + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public int getMaxEfficiency(ItemStack stack) { + return 10000; + } + + @Override + public int getPollutionPerTick(ItemStack stack) { + return 0; + } + + @Override + public int getDamageToComponent(ItemStack stack) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack stack) { + return false; + } + + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + super.onScrewdriverRightClick(side, aPlayer, aX, aY, aZ); + this.setDoVoidExcess(!doVoidExcess); + GT_Utility.sendChatToPlayer(aPlayer, "Auto-voiding " + (this.doVoidExcess ? "enabled" : "disabled")); + } + + private boolean addMultiHatchToMachineList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) { + if (aTileEntity != null) { + final IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity(); + if (aMetaTileEntity instanceof GTMTE_TFFTHatch) { + if (this.tfftHatch != null) return false; + this.tfftHatch = (GTMTE_TFFTHatch) aMetaTileEntity; + this.tfftHatch.updateTexture(aBaseCasingIndex); + return true; + } + } + return false; + } + + public int pull(FluidStack aFluid, boolean doPull) { + if (locked) return 0; + int index = getFluidPosition(aFluid); + if (index >= 0) { + return STORE[index].fill(aFluid, doPull); + } else if (fluidCount() < MAX_DISTINCT_FLUIDS) { + return STORE[getNullSlot()].setCapacity(capacityPerFluid) + .fill(aFluid, doPull); + } + return 0; + } + + public long pull(FluidStack aFluid, long amount, boolean doPull) { + if (locked) return 0; + int index = getFluidPosition(aFluid); + if (index >= 0) { + FluidTankGT tank = STORE[index]; + if (doPull) return tank.add(amount); + return doVoidExcess ? amount + : tank.amount() + amount > tank.capacity() ? tank.capacity() - tank.amount() : amount; + } else if (fluidCount() < MAX_DISTINCT_FLUIDS) { + FluidTankGT tank = STORE[getNullSlot()]; + if (doPull) return tank.add(amount, aFluid); + return doVoidExcess ? amount : Math.min(amount, tank.capacity()); + } + return 0; + } + + public FluidStack push(FluidStack aFluid, boolean doPush) { + if (locked) return null; + int index = getFluidPosition(aFluid); + if (index < 0) return null; + return STORE[index].drain(aFluid.amount, doPush); + } + + public FluidStack push(int amount, boolean doPush) { + if (locked) return null; + int index = firstNotNullSlot(); + if (index < 0) return null; + return STORE[index].drain(amount, doPush); + } + + public long push(FluidStack aFluid, long amount, boolean doPush) { + if (locked) return 0; + int index = getFluidPosition(aFluid); + if (index < 0) return 0; + if (doPush) return STORE[index].remove(amount); + return STORE[index].amount(amount); + } + + public long getCapacityPerFluid() { + return this.capacityPerFluid; + } + + public void setCapacity(BigInteger capacity) { + if (capacity.compareTo(MAX_CAPACITY) > 0) { + this.capacity = MAX_CAPACITY; + this.capacityPerFluid = Long.MAX_VALUE; + } else { + this.capacity = capacity; + this.capacityPerFluid = capacity.divide(BigInteger.valueOf(MAX_DISTINCT_FLUIDS)) + .longValue(); + } + + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + FluidTankGT tank = STORE[i]; + if (tank.setCapacity(capacityPerFluid) + .amount() > capacityPerFluid) { + STORE[i] = new FluidTankGT(tank.get(), capacityPerFluid, capacityPerFluid); + } + } + } + + public int fluidCount() { + int tCount = 0; + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + if (!STORE[i].isEmpty()) tCount++; + } + return tCount; + } + + public int getFluidPosition(String fluidName) { + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + if (!STORE[i].isEmpty() && STORE[i].name() + .equals(fluidName)) return i; + } + return -1; + } + + public int getFluidPosition(FluidStack aFluid) { + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + if (STORE[i].contains(aFluid)) return i; + } + return -1; + } + + public int getNullSlot() { + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + if (STORE[i].isEmpty()) return i; + } + return -1; + } + + public boolean contains(String fluidName) { + return getFluidPosition(fluidName) >= 0; + } + + public boolean contains(FluidStack aFluid) { + return getFluidPosition(aFluid) >= 0; + } + + public int firstNotNullSlot() { + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + if (!STORE[i].isEmpty()) return i; + } + return -1; + } + + public FluidTankGT firstNotNull() { + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + if (!STORE[i].isEmpty()) return STORE[i]; + } + return null; + } + + public BigInteger getStoredAmount() { + BigInteger amount = BigInteger.ZERO; + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + amount = amount.add(BigInteger.valueOf(STORE[i].amount())); + } + return amount; + } + + public byte getFluidSelector() { + return fluidSelector; + } + + public FluidTankGT getSelectedFluid() { + return fluidSelector != -1 ? STORE[fluidSelector] : null; + } + + public void setDoVoidExcess(boolean doVoidExcess) { + this.doVoidExcess = doVoidExcess; + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + STORE[i].setVoidExcess(doVoidExcess); + } + } + + public FluidTankInfo[] getTankInfo() { + FluidTankInfo[] info = new FluidTankInfo[MAX_DISTINCT_FLUIDS]; + for (int i = 0; i < MAX_DISTINCT_FLUIDS; i++) { + STORE[i].getFluid(); // + info[i] = STORE[i].getInfo(); + } + return info; + } +} diff --git a/kekztech/src/main/java/common/tileentities/GTMTE_TFFTHatch.java b/kekztech/src/main/java/common/tileentities/GTMTE_TFFTHatch.java new file mode 100644 index 0000000000..39eb6dee64 --- /dev/null +++ b/kekztech/src/main/java/common/tileentities/GTMTE_TFFTHatch.java @@ -0,0 +1,271 @@ +package common.tileentities; + +import java.util.HashMap; + +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidTankInfo; + +import appeng.api.AEApi; +import appeng.api.config.AccessRestriction; +import appeng.api.config.Actionable; +import appeng.api.networking.security.BaseActionSource; +import appeng.api.storage.IExternalStorageHandler; +import appeng.api.storage.IMEInventory; +import appeng.api.storage.IMEMonitor; +import appeng.api.storage.IMEMonitorHandlerReceiver; +import appeng.api.storage.StorageChannel; +import appeng.api.storage.data.IAEFluidStack; +import appeng.api.storage.data.IItemList; +import appeng.util.item.AEFluidStack; +import appeng.util.item.FluidList; +import cpw.mods.fml.common.Optional; +import gregtech.api.enums.Textures; +import gregtech.api.fluid.FluidTankGT; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.BaseMetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch; +import gregtech.api.render.TextureFactory; + +@Optional.Interface(iface = "appeng.api.storage.IMEMonitor", modid = "appliedenergistics2", striprefs = true) +public class GTMTE_TFFTHatch extends GT_MetaTileEntity_Hatch implements IMEMonitor<IAEFluidStack> { + + @Optional.Interface( + iface = "appeng.api.storage.IExternalStorageHandler", + modid = "appliedenergistics2", + striprefs = true) + private static class AE2TFFTHatchHandler implements IExternalStorageHandler { + + @Override + @Optional.Method(modid = "appliedenergistics2") + public boolean canHandle(TileEntity te, ForgeDirection d, StorageChannel channel, BaseActionSource mySrc) { + return channel == StorageChannel.FLUIDS && te instanceof BaseMetaTileEntity + && ((BaseMetaTileEntity) te).getMetaTileEntity() instanceof GTMTE_TFFTHatch; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public IMEInventory getInventory(TileEntity te, ForgeDirection d, StorageChannel channel, + BaseActionSource src) { + if (channel == StorageChannel.FLUIDS) { + return ((GTMTE_TFFTHatch) (((BaseMetaTileEntity) te).getMetaTileEntity())); + } + return null; + } + } + + private static final Textures.BlockIcons.CustomIcon TEXTURE_TFFT_HATCH = new Textures.BlockIcons.CustomIcon( + "iconsets/TFFT_HATCH"); + + private HashMap<IMEMonitorHandlerReceiver<IAEFluidStack>, Object> listeners = new HashMap<>(); + private GTMTE_TFFT controller; + + public GTMTE_TFFTHatch(int aID, String aName, String aNameRegional) { + super(aID, aName, aNameRegional, 3, 0, "All-in-one access for the T.F.F.T"); + } + + public GTMTE_TFFTHatch(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection side, ForgeDirection facing, + int colorIndex, boolean aActive, boolean aRedstone) { + return super.getTexture(aBaseMetaTileEntity, side, facing, colorIndex, aActive, aRedstone); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, TextureFactory.of(Textures.BlockIcons.OVERLAY_PIPE_IN), + TextureFactory.builder() + .addIcon(TEXTURE_TFFT_HATCH) + .extFacing() + .build() }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, TextureFactory.of(Textures.BlockIcons.OVERLAY_PIPE_IN), + TextureFactory.builder() + .addIcon(TEXTURE_TFFT_HATCH) + .extFacing() + .build() }; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GTMTE_TFFTHatch(mName, mTier, mDescriptionArray, mTextures); + } + + @Override + public int fill(ForgeDirection from, FluidStack resource, boolean doFill) { + return (controller != null) ? controller.pull(resource, doFill) : 0; + } + + @Override + public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) { + if (controller != null) { + final FluidTankGT sFluid = controller.getSelectedFluid(); + if (controller.getFluidSelector() == -1 || (sFluid != null && sFluid.contains(resource))) { + return controller.push(resource, doDrain); + } + } + return null; + } + + @Override + public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) { + if (controller != null) { + final FluidTankGT sFluid = controller.getSelectedFluid(); + if (controller.getFluidSelector() == -1) return controller.push(maxDrain, doDrain); + if (sFluid != null) return controller.push(sFluid.get(maxDrain), doDrain); + } + return null; + } + + @Override + public FluidTankInfo[] getTankInfo(ForgeDirection from) { + return (controller != null) ? controller.getTankInfo() : null; + } + + public void bind(GTMTE_TFFT controller) { + this.controller = controller; + } + + public void unbind() { + this.controller = null; + } + + @Optional.Method(modid = "appliedenergistics2") + public static void registerAEIntegration() { + AEApi.instance() + .registries() + .externalStorage() + .addExternalStorageInterface(new AE2TFFTHatchHandler()); + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public IItemList<IAEFluidStack> getAvailableItems(IItemList out) { + if (controller != null) { + for (int i = 0; i < GTMTE_TFFT.MAX_DISTINCT_FLUIDS; i++) { + if (!controller.STORE[i].isEmpty()) { + IAEFluidStack s = AEFluidStack.create(controller.STORE[i].get()); + s.setStackSize(controller.STORE[i].amount()); + out.add(s); + } + } + } + return out; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public IItemList<IAEFluidStack> getStorageList() { + IItemList<IAEFluidStack> fluidList = new FluidList(); + if (controller != null) { + for (int i = 0; i < GTMTE_TFFT.MAX_DISTINCT_FLUIDS; i++) { + if (!controller.STORE[i].isEmpty()) { + IAEFluidStack s = AEFluidStack.create(controller.STORE[i].get()); + s.setStackSize(controller.STORE[i].amount()); + fluidList.add(s); + } + } + } + return fluidList; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public void addListener(IMEMonitorHandlerReceiver<IAEFluidStack> l, Object verificationToken) { + if (listeners == null) listeners = new HashMap<>(); + listeners.put(l, verificationToken); + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public void removeListener(IMEMonitorHandlerReceiver<IAEFluidStack> l) { + if (listeners == null) listeners = new HashMap<>(); + listeners.remove(l); + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public AccessRestriction getAccess() { + return AccessRestriction.READ_WRITE; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public boolean isPrioritized(IAEFluidStack input) { + if (controller == null || input == null) return false; + return controller.contains(input.getFluidStack()) || controller.fluidCount() < GTMTE_TFFT.MAX_DISTINCT_FLUIDS; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public boolean canAccept(IAEFluidStack input) { + if (controller == null || input == null) return false; + return controller.contains(input.getFluidStack()) || controller.fluidCount() < GTMTE_TFFT.MAX_DISTINCT_FLUIDS; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public int getPriority() { + return 0; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public int getSlot() { + return 0; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public boolean validForPass(int i) { + return true; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public IAEFluidStack injectItems(IAEFluidStack input, Actionable mode, BaseActionSource src) { + final FluidStack inputStack = input.getFluidStack(); + if (inputStack == null) return null; + if (controller == null || getBaseMetaTileEntity() == null) return input; + if (mode != Actionable.SIMULATE) getBaseMetaTileEntity().markDirty(); + long amount = controller.pull(input.getFluidStack(), input.getStackSize(), mode != Actionable.SIMULATE); + if (amount == 0) return input; + if (amount == input.getStackSize()) return null; + IAEFluidStack result = AEFluidStack.create(input.getFluidStack()); + result.setStackSize(input.getStackSize() - amount); + return result; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public IAEFluidStack extractItems(IAEFluidStack request, Actionable mode, BaseActionSource src) { + if (controller == null || getBaseMetaTileEntity() == null) return null; + if (mode != Actionable.SIMULATE) getBaseMetaTileEntity().markDirty(); + long amount = controller.push(request.getFluidStack(), request.getStackSize(), mode != Actionable.SIMULATE); + if (amount == 0) return null; + if (amount == request.getStackSize()) return request.copy(); + IAEFluidStack result = AEFluidStack.create(request.getFluidStack()); + result.setStackSize(amount); + return result; + } + + @Override + @Optional.Method(modid = "appliedenergistics2") + public StorageChannel getChannel() { + return StorageChannel.FLUIDS; + } +} diff --git a/kekztech/src/main/java/common/tileentities/TE_IchorJar.java b/kekztech/src/main/java/common/tileentities/TE_IchorJar.java new file mode 100644 index 0000000000..b5e85a9f2b --- /dev/null +++ b/kekztech/src/main/java/common/tileentities/TE_IchorJar.java @@ -0,0 +1,10 @@ +package common.tileentities; + +import thaumcraft.common.tiles.TileJarFillable; + +public class TE_IchorJar extends TileJarFillable { + + public TE_IchorJar() { + super.maxAmount = 4096; + } +} diff --git a/kekztech/src/main/java/common/tileentities/TE_IchorVoidJar.java b/kekztech/src/main/java/common/tileentities/TE_IchorVoidJar.java new file mode 100644 index 0000000000..9046b2bc33 --- /dev/null +++ b/kekztech/src/main/java/common/tileentities/TE_IchorVoidJar.java @@ -0,0 +1,10 @@ +package common.tileentities; + +import thaumcraft.common.tiles.TileJarFillableVoid; + +public class TE_IchorVoidJar extends TileJarFillableVoid { + + public TE_IchorVoidJar() { + super.maxAmount = 4096; + } +} diff --git a/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedJar.java b/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedJar.java new file mode 100644 index 0000000000..e54324220f --- /dev/null +++ b/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedJar.java @@ -0,0 +1,10 @@ +package common.tileentities; + +import thaumcraft.common.tiles.TileJarFillable; + +public class TE_ThaumiumReinforcedJar extends TileJarFillable { + + public TE_ThaumiumReinforcedJar() { + super.maxAmount = 256; + } +} diff --git a/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedVoidJar.java b/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedVoidJar.java new file mode 100644 index 0000000000..dd0166fe6e --- /dev/null +++ b/kekztech/src/main/java/common/tileentities/TE_ThaumiumReinforcedVoidJar.java @@ -0,0 +1,10 @@ +package common.tileentities; + +import thaumcraft.common.tiles.TileJarFillableVoid; + +public class TE_ThaumiumReinforcedVoidJar extends TileJarFillableVoid { + + public TE_ThaumiumReinforcedVoidJar() { + super.maxAmount = 256; + } +} diff --git a/kekztech/src/main/java/kekztech/Items.java b/kekztech/src/main/java/kekztech/Items.java new file mode 100644 index 0000000000..426dfb7f58 --- /dev/null +++ b/kekztech/src/main/java/kekztech/Items.java @@ -0,0 +1,70 @@ +package kekztech; + +import java.util.Arrays; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.OreDictionary; + +import common.items.MetaItem_CraftingComponent; + +import util.Util; + +public enum Items { + + // Ceramics + YSZCeramicDust(9, 1), + GDCCeramicDust(10, 1), + YttriaDust(11, 1), + ZirconiaDust(12, 1), + CeriaDust(13, 1), + YSZCeramicPlate(14, 1), + GDCCeramicPlate(15, 1), + // Error Item + Error(0, 1); + + static { + YttriaDust.setOreDictName("dustYttriumOxide"); + ZirconiaDust.setOreDictName("dustCubicZirconia"); + } + + private final int metaID; + private final int identifier; + + Items(int metaID, int identifier) { + this.metaID = metaID; + this.identifier = identifier; + } + + public int getMetaID() { + return metaID; + } + + String OreDictName; + + private void registerOreDict() { + OreDictionary.registerOre(getOreDictName(), getNonOreDictedItemStack(1)); + } + + public static void registerOreDictNames() { + Arrays.stream(Items.values()) + .filter(e -> e.getOreDictName() != null) + .forEach(Items::registerOreDict); + } + + public ItemStack getNonOreDictedItemStack(int amount) { + return new ItemStack(MetaItem_CraftingComponent.getInstance(), amount, this.getMetaID()); + } + + public ItemStack getOreDictedItemStack(int amount) { + return this.getOreDictName() != null ? Util.getStackofAmountFromOreDict(this.getOreDictName(), amount) + : new ItemStack(MetaItem_CraftingComponent.getInstance(), amount, this.getMetaID()); + } + + public String getOreDictName() { + return OreDictName; + } + + public void setOreDictName(String oreDictName) { + OreDictName = oreDictName; + } +} diff --git a/kekztech/src/main/java/kekztech/KekzCore.java b/kekztech/src/main/java/kekztech/KekzCore.java new file mode 100644 index 0000000000..7505cffd8c --- /dev/null +++ b/kekztech/src/main/java/kekztech/KekzCore.java @@ -0,0 +1,83 @@ +package kekztech; + +import java.util.List; +import java.util.Set; + +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import com.google.common.collect.ImmutableSet; +import common.CommonProxy; + +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.SidedProxy; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLMissingMappingsEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; +import cpw.mods.fml.common.event.FMLPreInitializationEvent; +import gregtech.api.enums.Mods; + +/** + * My GT-Meta-IDs are: 13101 - 13500 + * + * @author kekzdealer + */ +@Mod( + modid = KekzCore.MODID, + name = KekzCore.NAME, + version = KekzCore.VERSION, + dependencies = "required-after:IC2;" + "required-after:gregtech;" + + "required-after:tectech;" + + "required-after:Thaumcraft;" + + "required-after:ThaumicTinkerer;" + + "after:bartworks;" + + "after:dreamcraft") +public class KekzCore { + + public static final String NAME = "KekzTech"; + public static final String MODID = Mods.Names.KEKZ_TECH; + public static final String VERSION = "GRADLETOKEN_VERSION"; + + public static final Logger LOGGER = LogManager.getLogger(NAME); + + @Mod.Instance(Mods.Names.KEKZ_TECH) + public static KekzCore instance; + + @SidedProxy(clientSide = "client.ClientProxy", serverSide = "kekztech.ServerProxy") + public static CommonProxy proxy; + + @Mod.EventHandler + public void preInit(FMLPreInitializationEvent event) { + proxy.preInit(event); + } + + @Mod.EventHandler + public void init(FMLInitializationEvent event) { + proxy.init(event); + } + + @Mod.EventHandler + public void postInit(FMLPostInitializationEvent event) { + proxy.postInit(event); + } + + @Mod.EventHandler + public void onMissingMapping(FMLMissingMappingsEvent event) { + List<FMLMissingMappingsEvent.MissingMapping> missingMappings = event.get(); + + // intentionally not a static final field to save a bit of ram. + Set<String> removedStuff = ImmutableSet.of( + MODID + ":kekztech_tfftcasingblock_block", + MODID + ":kekztech_tfftmultihatch_block", + MODID + ":kekztech_tfftstoragefieldblock1_block", + MODID + ":kekztech_tfftstoragefieldblock2_block", + MODID + ":kekztech_tfftstoragefieldblock3_block", + MODID + ":kekztech_tfftstoragefieldblock4_block", + MODID + ":kekztech_tfftstoragefieldblock5_block"); + + for (FMLMissingMappingsEvent.MissingMapping mapping : missingMappings) { + if (removedStuff.contains(mapping.name)) mapping.ignore(); + else mapping.warn(); // we don't know what happened. probably warn the user. + } + } +} diff --git a/kekztech/src/main/java/kekztech/ServerProxy.java b/kekztech/src/main/java/kekztech/ServerProxy.java new file mode 100644 index 0000000000..e509ab1722 --- /dev/null +++ b/kekztech/src/main/java/kekztech/ServerProxy.java @@ -0,0 +1,6 @@ +package kekztech; + +import common.CommonProxy; + +public class ServerProxy extends CommonProxy { +} diff --git a/kekztech/src/main/java/util/Util.java b/kekztech/src/main/java/util/Util.java new file mode 100644 index 0000000000..a1a9e4c0ba --- /dev/null +++ b/kekztech/src/main/java/util/Util.java @@ -0,0 +1,93 @@ +package util; + +import java.math.BigDecimal; +import java.math.BigInteger; +import java.math.RoundingMode; +import java.text.DecimalFormat; +import java.text.DecimalFormatSymbols; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Locale; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.oredict.OreDictionary; + +import common.items.ErrorItem; + +public class Util { + + protected static final DecimalFormat percentFormatRound_6 = new DecimalFormat("0.000000%"); + protected static final DecimalFormat percentFormatRound_2 = new DecimalFormat("0.00%"); + protected static final BigDecimal Threshold_1 = BigDecimal.valueOf(0.01); + protected static DecimalFormat standardFormat; + + static { + DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US); + dfs.setExponentSeparator("x10^"); + standardFormat = new DecimalFormat("0.00E0", dfs); + } + + public static ItemStack getStackofAmountFromOreDict(String oredictName, final int amount) { + final ArrayList<ItemStack> list = OreDictionary.getOres(oredictName); + if (!list.isEmpty()) { + final ItemStack ret = list.get(0) + .copy(); + ret.stackSize = amount; + return ret; + } + System.err.println("Failed to find " + oredictName + " in OreDict"); + return new ItemStack(ErrorItem.getInstance(), amount); + } + + public static ItemStack[] toItemStackArray(List<ItemStack> stacksList) { + if (stacksList.size() == 0) { + return null; + } + + ItemStack[] ret = new ItemStack[stacksList.size()]; + Iterator<ItemStack> iterator = stacksList.iterator(); + for (int i = 0; i < ret.length; i++) { + ret[i] = iterator.next(); + } + return ret; + } + + public static FluidStack[] toFluidStackArray(List<FluidStack> stacksList) { + if (stacksList.size() == 0) { + return null; + } + + FluidStack[] ret = new FluidStack[stacksList.size()]; + Iterator<FluidStack> iterator = stacksList.iterator(); + for (int i = 0; i < ret.length; i++) { + ret[i] = iterator.next(); + } + return ret; + } + + /* If the number is less than 1, we round by the 6, otherwise to 2 */ + public static String toPercentageFrom(BigInteger value, BigInteger maxValue) { + if (BigInteger.ZERO.equals(maxValue)) { + return "0.00%"; + } + BigDecimal result = new BigDecimal(value).setScale(6, RoundingMode.HALF_UP) + .divide(new BigDecimal(maxValue), RoundingMode.HALF_UP); + if (result.compareTo(Threshold_1) < 0) { + return percentFormatRound_6.format(result); + } else { + return percentFormatRound_2.format(result); + } + } + + /* Get a string like this: 4.56*10^25 */ + public static String toStandardForm(BigInteger number) { + if (BigInteger.ZERO.equals(number)) { + return "0"; + } + + return standardFormat.format(number); + } + +} diff --git a/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT.png b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT.png Binary files differnew file mode 100644 index 0000000000..f00e6d571f --- /dev/null +++ b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT.png diff --git a/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE.png b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE.png Binary files differnew file mode 100644 index 0000000000..69cea70d75 --- /dev/null +++ b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE.png diff --git a/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE.png.mcmeta b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE.png.mcmeta new file mode 100644 index 0000000000..3de4a0bdd8 --- /dev/null +++ b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE.png.mcmeta @@ -0,0 +1,5 @@ +{ + "animation": { + "frametime": 8 + } +} diff --git a/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE_GLOW.png b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE_GLOW.png Binary files differnew file mode 100644 index 0000000000..30557c19a1 --- /dev/null +++ b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE_GLOW.png diff --git a/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE_GLOW.png.mcmeta b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE_GLOW.png.mcmeta new file mode 100644 index 0000000000..f16b74ddb1 --- /dev/null +++ b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_ACTIVE_GLOW.png.mcmeta @@ -0,0 +1,6 @@ +{ + "animation": { + "frametime": 8 + } +} + diff --git a/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_HATCH.png b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_HATCH.png Binary files differnew file mode 100644 index 0000000000..ea3a35a5f0 --- /dev/null +++ b/kekztech/src/main/resources/assets/gregtech/textures/blocks/iconsets/TFFT_HATCH.png diff --git a/kekztech/src/main/resources/assets/kekztech/lang/en_US.lang b/kekztech/src/main/resources/assets/kekztech/lang/en_US.lang new file mode 100644 index 0000000000..a77f21bcbe --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/lang/en_US.lang @@ -0,0 +1,109 @@ +item.kekztech_error_item.name=KekzTech Error Coin + +# -------- Multiblock Tooltip Builder Keywords +# -------- Context can be found in the class util.MultiBlockTooltipBuilder +mbdesc.beginStructureBlock.Dimensions=Dimensions +mbdesc.beginStructureBlock.Structure=Structure +mbdesc.addController.Controller=Controller +mbdesc.addCasing.atleast=(at least) +mbdesc.addEnergyHatch.EnergyHatch=Energy Hatch +mbdesc.addDynamoHatch.DynamoHatch=Dynamo Hatch +mbdesc.addMaintenanceHatch.MaintenanceHatch=Maintenance Hatch +mbdesc.addIOHatches.IOHatches=I/O Hatches +mbdesc.addInputBus.InputBus=Input Bus/ses +mbdesc.addInputHatch.InputHatch=Input Hatch/es +mbdesc.addOutputBus.OutputBus=Output Bus/ses +mbdesc.addOutputHatch.OutputHatch=Output Hatch/es +mbdesc.signAndFinalize.Hold=Hold +mbdesc.signAndFinalize.todisplay=to display structure guidelines +mbdesc.signAndFinalize.createdby=Created by + +# -------- Fuel Cell: Structure Blocks +tile.kekztech_gdcceramicelectrolyteunit_block.name=GDC Ceramic Electrolyte Unit +tile.kekztech_yszceramicelectrolyteunit_block.name=YSZ Ceramic Electrolyte Unit + +# -------- Fuel Cell: Crafting Components +item.kekztech_crafting_item.9.name=YSZ Ceramic Dust +item.kekztech_crafting_item.10.name=GDC Ceramic Dust +item.kekztech_crafting_item.11.name=Yttria Dust +item.kekztech_crafting_item.12.name=Zirconia Dust +item.kekztech_crafting_item.13.name=Ceria Dust +item.kekztech_crafting_item.14.name=YSZ Ceramic Plate +item.kekztech_crafting_item.15.name=GDC Ceramic Plate + +# -------- TFFT: Structure Blocks +tile.kekztech_tfftstoragefield_block.0.name=T.F.F.T Casing +tile.kekztech_tfftstoragefield_block.1.name=T.F.F.T Storage Field Block (Tier I) +tile.kekztech_tfftstoragefield_block.2.name=T.F.F.T Storage Field Block (Tier II) +tile.kekztech_tfftstoragefield_block.3.name=T.F.F.T Storage Field Block (Tier III) +tile.kekztech_tfftstoragefield_block.4.name=T.F.F.T Storage Field Block (Tier IV) +tile.kekztech_tfftstoragefield_block.5.name=T.F.F.T Storage Field Block (Tier V) +tile.kekztech_tfftstoragefield_block.6.name=T.F.F.T Storage Field Block (Tier VI) +tile.kekztech_tfftstoragefield_block.7.name=T.F.F.T Storage Field Block (Tier VII) +tile.kekztech_tfftstoragefield_block.8.name=T.F.F.T Storage Field Block (Tier VIII) +tile.kekztech_tfftstoragefield_block.9.name=T.F.F.T Storage Field Block (Tier IX) +tile.kekztech_tfftstoragefield_block.10.name=T.F.F.T Storage Field Block (Tier X) +tile.kekztech_tfftstoragefield_block.desc=This is not a fluid tank +tile.kekztech_tfftstoragefield_block.hint.1=Hint 1 Dot: T.F.F.T Casing +tile.kekztech_tfftstoragefield_block.hint.2=Hint 2 Dot: T.F.F.T Casing, Maintenance Hatch, T.F.F.T Multi I/O Hatch, Input/Output Hatch, Energy Hatch +tile.kekztech_tfftstoragefield_block.hint.3=Hint 3 Dot: EV+ Tier Glass, T.F.F.T Multi I/O Hatch, Input/Output Hatch +tile.kekztech_tfftstoragefield_block.hint.4=Hint 4 Dot: EV+ Tier Glass + +# -------- Lapotronic Super Capacitor: Structure Blocks +tile.kekztech_lapotronicenergyunit_block.0.name=Lapotronic Super Capacitor Casing +tile.kekztech_lapotronicenergyunit_block.1.name=Lapotronic Capacitor (IV) +tile.kekztech_lapotronicenergyunit_block.2.name=Lapotronic Capacitor (LuV) +tile.kekztech_lapotronicenergyunit_block.3.name=Lapotronic Capacitor (ZPM) +tile.kekztech_lapotronicenergyunit_block.4.name=Lapotronic Capacitor (UV) +tile.kekztech_lapotronicenergyunit_block.5.name=Ultimate Capacitor (UHV) +tile.kekztech_lapotronicenergyunit_block.6.name=Empty Capacitor (-) +tile.kekztech_lapotronicenergyunit_block.7.name=Lapotron Capacitor (EV) +tile.kekztech_lapotronicenergyunit_block.8.name=Extremely Ultimate Capacitor (UEV) +tile.kekztech_lapotronicenergyunit_block.9.name=Insanely Ultimate Capacitor (UIV) +tile.kekztech_lapotronicenergyunit_block.10.name=Mega Ultimate Capacitor (UMV) +tile.kekztech_lapotronicenergyunit_block.desc=Part of the Lapotronic Super Capacitor + +# -------- Thaumium Reinforced Jar: Block +tile.kekztech_thaumiumreinforcedjar_block.0.name=Thaumium Reinforced Jar +tile.kekztech_thaumiumreinforcedjar_block.3.name=Thaumium Reinforced Void Jar + +# -------- Thaumium Reinforced Jar: Research +# This is the name of the research +tc.research_name.THAUMIUMREINFORCEDJAR=Thaumium Reinforced Jars +# This is the subtext for the research note +tc.research_text.THAUMIUMREINFORCEDJAR=Slightly better jars +# Lore text for the research pages +kekztech.research_page.THAUMIUMREINFORCEDJAR.0=You have heard your fellow Thaumaturges talk about the benefits of digitized Essentia Storage.<BR><BR>Storing enough Essentia for your advanced infusions has indeed been an issue for you too. However those jars are simply too pleasing to look at to even consider the idea of replacing them with some compact technological construct.<BR><BR>Thanks to this new discovery, you have managed to quadruple the capacity of your jars by improving them with a thick Thaumium lining. This should buy you some more time to come up with a better solution. +kekztech.research_page.THAUMIUMREINFORCEDJAR.1=Compressing this much Essentia in such a tiny space causes some volatility. Picking up reinforced jars is probably a bad idea...<BR><BR>You imagine that you could get even more out of your jars if only you had some kind of material harder than even diamond or any of the other magical metal you have seen so far. + +# -------- Ichor Jar: Block +tile.kekztech_ichorjar_block.0.name=Ichor Jar +tile.kekztech_ichorjar_block.3.name=Ichor Void Jar + +# -------- Ichor Jar: Research +tc.research_name.ICHORJAR=Ichor Jars +tc.research_text.ICHORJAR=Much better jars +kekztech.research_page.ICHORJAR.0=This is it!<BR><BR>By infusing a jar with just a single piece of Ichor you have created something to rival digitized Essentia storage without sacrificing any of the beauty of Warded Jars.<BR><BR>Ichor Jars can hold an astounding 4096 Essentia and fit nicely into your recently aquired set of Ichor based achievements.<BR><BR>You definitely don't want to disturb these jars. Luckily Ichor is resilient enough to make accidentially destroying one unlikely. + +# -------- Cosmetic Blocks +tile.kekztech_largehextile_block.name=Large Hex Tile + +# -------- Achievements +achievement.tile.kekztech_lapotronicenergyunit_block.2.desc=Pickup this item to see the recipe in NEI +achievement.tile.kekztech_lapotronicenergyunit_block.2=Lapotronic Capacitor (LuV) +achievement.tile.kekztech_lapotronicenergyunit_block.3.desc=Pickup this item to see the recipe in NEI +achievement.tile.kekztech_lapotronicenergyunit_block.3=Lapotronic Capacitor (ZPM) +achievement.tile.kekztech_lapotronicenergyunit_block.4.desc=Pickup this item to see the recipe in NEI +achievement.tile.kekztech_lapotronicenergyunit_block.4=Lapotronic Capacitor (UV) +achievement.tile.kekztech_lapotronicenergyunit_block.5.desc=Pickup this item to see the recipe in NEI +achievement.tile.kekztech_lapotronicenergyunit_block.5=Ultimate Capacitor (UHV) +achievement.tile.kekztech_lapotronicenergyunit_block.8.desc=Beyond the ranks of Gods +achievement.tile.kekztech_lapotronicenergyunit_block.8=Extremely Ultimate Capacitor (UEV) +achievement.tile.kekztech_lapotronicenergyunit_block.9.desc=Insanity ensues! +achievement.tile.kekztech_lapotronicenergyunit_block.9=Insanely Ultimate Capacitor (UIV) +achievement.tile.kekztech_lapotronicenergyunit_block.10.desc=How far can we go? +achievement.tile.kekztech_lapotronicenergyunit_block.10=Mega Ultimate Capacitor (UMV) + + +# -------- GUI +gui.kekztech_lapotronicenergyunit.wireless=Wireless mode diff --git a/kekztech/src/main/resources/assets/kekztech/lang/zh_CN.lang b/kekztech/src/main/resources/assets/kekztech/lang/zh_CN.lang new file mode 100644 index 0000000000..360e4d540f --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/lang/zh_CN.lang @@ -0,0 +1,93 @@ +item.kekztech_error_item.name=KekzTech错误硬币 + +# -------- Multiblock Tooltip Builder Keywords +# -------- Context can be found in the class util.MultiBlockTooltipBuilder +mbdesc.beginStructureBlock.Dimensions=外型尺寸 +mbdesc.beginStructureBlock.Structure=结构 +mbdesc.addController.Controller=控制器 +mbdesc.addCasing.atleast=(至少) +mbdesc.addEnergyHatch.EnergyHatch=能源仓 +mbdesc.addDynamoHatch.DynamoHatch=动力仓 +mbdesc.addMaintenanceHatch.MaintenanceHatch=维护仓 +mbdesc.addIOHatches.IOHatches=输入/出仓(TFFT) +mbdesc.addInputBus.InputBus=输入总线 +mbdesc.addInputHatch.InputHatch=输入仓 +mbdesc.addOutputBus.OutputBus=输出总线 +mbdesc.addOutputHatch.OutputHatch=输出仓 +mbdesc.signAndFinalize.Hold=按住 +mbdesc.signAndFinalize.todisplay=以显示结构指导 +mbdesc.signAndFinalize.createdby=添加者: + +# -------- Fuel Cell: Structure Blocks +tile.kekztech_gdcceramicelectrolyteunit_block.name=钆铈陶瓷电解质单元 +tile.kekztech_yszceramicelectrolyteunit_block.name=钇锆陶瓷电解质单元 + +# -------- Fuel Cell: Crafting Components +item.kekztech_crafting_item.9.name=钇锆陶瓷粉 +item.kekztech_crafting_item.10.name=钆铈陶瓷粉 +item.kekztech_crafting_item.11.name=氧化钇粉 +item.kekztech_crafting_item.12.name=氧化锆粉 +item.kekztech_crafting_item.13.name=氧化铈粉 +item.kekztech_crafting_item.14.name=钇锆陶瓷板 +item.kekztech_crafting_item.15.name=钆铈陶瓷板 + +# -------- TFFT: Structure Blocks +tile.kekztech_tfftstoragefield_block.0.name=T.F.F.T机械方块 +tile.kekztech_tfftstoragefield_block.1.name=T.F.F.T存储库方块(T1) +tile.kekztech_tfftstoragefield_block.2.name=T.F.F.T存储库方块(T2) +tile.kekztech_tfftstoragefield_block.3.name=T.F.F.T存储库方块(T3) +tile.kekztech_tfftstoragefield_block.4.name=T.F.F.T存储库方块(T4) +tile.kekztech_tfftstoragefield_block.5.name=T.F.F.T存储库方块(T5) +tile.kekztech_tfftstoragefield_block.6.name=T.F.F.T存储库方块(T6) +tile.kekztech_tfftstoragefield_block.7.name=T.F.F.T存储库方块(T7) +tile.kekztech_tfftstoragefield_block.8.name=T.F.F.T存储库方块(T8) +tile.kekztech_tfftstoragefield_block.9.name=T.F.F.T存储库方块(T9) +tile.kekztech_tfftstoragefield_block.10.name=T.F.F.T存储库方块(T10) +tile.kekztech_tfftstoragefield_block.desc=这不是流体储罐 + +# -------- Lapotronic Super Capacitor: Structure Blocks +tile.kekztech_lapotronicenergyunit_block.0.name=兰波顿超级电容机械方块 +tile.kekztech_lapotronicenergyunit_block.1.name=兰波顿电容(IV) +tile.kekztech_lapotronicenergyunit_block.2.name=兰波顿电容(LuV) +tile.kekztech_lapotronicenergyunit_block.3.name=兰波顿电容(ZPM) +tile.kekztech_lapotronicenergyunit_block.4.name=兰波顿电容(UV) +tile.kekztech_lapotronicenergyunit_block.5.name=终极电容(UHV) +tile.kekztech_lapotronicenergyunit_block.6.name=空电容(-) +tile.kekztech_lapotronicenergyunit_block.7.name=兰波顿电容(EV) +tile.kekztech_lapotronicenergyunit_block.desc=兰波顿超级电容库的组成部分 + +# -------- Thaumium Reinforced Jar: Block +tile.kekztech_thaumiumreinforcedjar_block.0.name=神秘源质罐子 +tile.kekztech_thaumiumreinforcedjar_block.3.name=神秘虚空罐子 + +# -------- Thaumium Reinforced Jar: Research +# This is the name of the research +tc.research_name.THAUMIUMREINFORCEDJAR=神秘源质罐子 +# This is the subtext for the research note +tc.research_text.THAUMIUMREINFORCEDJAR=略好的罐子 +# Lore text for the research pages +kekztech.research_page.THAUMIUMREINFORCEDJAR.0=你曾听你的神秘使伙伴谈起过数字化源质存储的便利.<BR><BR>为高阶注魔存储足够的源质,你现在面临着同样的问题.但是这些源质罐子实在太讨人喜欢了,你甚至没有考虑用某种更紧凑的技术结构来代替它们.<BR><BR>随着研究的深入,你发现有了一层厚厚的神秘锭内衬,罐子的容量可以变为原来的4倍.要是有充足的时间,你相信还有更好的解决方式. +kekztech.research_page.THAUMIUMREINFORCEDJAR.1=在如此狭小的空间中压缩这么多的源质会导致一些不稳定性.所以捡起这种加强罐子可能是个糟糕的主意...<BR><BR>可以想象,如果有某种材料比钻石,或比目前为止你所见过的任何其他神秘金属更坚硬的话,以此制成的源质罐子一定能给你惊喜. + +# -------- Ichor Jar: Block +tile.kekztech_ichorjar_block.0.name=灵液源质罐子 +tile.kekztech_ichorjar_block.3.name=灵液虚空罐子 + +# -------- Ichor Jar: Research +tc.research_name.ICHORJAR=灵液源质罐子 +tc.research_text.ICHORJAR=非常好的罐子 +kekztech.research_page.ICHORJAR.0=就是这个!<BR><BR>将一点灵液注魔进源质罐子,你获得了可以与数字化源质存储相匹敌,同时还不用牺牲美感的新罐子.<BR><BR>灵液源质罐子可以装下惊人的4096点源质,非常适合你刚解锁的这些基于灵液的注魔.<BR><BR>你绝对不会想打扰这些罐子的.不过幸运的是,灵液源质罐子拥有足够的柔韧性,不太容易被误操作摧毁. + +# -------- Cosmetic Blocks +tile.kekztech_largehextile_block.name=大六角瓷砖 + +# -------- Achievements +achievement.tile.kekztech_lapotronicenergyunit_block.2.desc=捡起这个物品以在NEI内查看配方 +achievement.tile.kekztech_lapotronicenergyunit_block.2=兰波顿电容(LuV) +achievement.tile.kekztech_lapotronicenergyunit_block.3.desc=捡起这个物品以在NEI内查看配方 +achievement.tile.kekztech_lapotronicenergyunit_block.3=兰波顿电容(ZPM) +achievement.tile.kekztech_lapotronicenergyunit_block.4.desc=捡起这个物品以在NEI内查看配方 +achievement.tile.kekztech_lapotronicenergyunit_block.4=兰波顿电容(UV) +achievement.tile.kekztech_lapotronicenergyunit_block.5.desc=捡起这个物品以在NEI内查看配方 +achievement.tile.kekztech_lapotronicenergyunit_block.5=终极电容(UHV) + diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/GDCCeramicElectrolyteUnit.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/GDCCeramicElectrolyteUnit.png Binary files differnew file mode 100644 index 0000000000..fe83dcba26 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/GDCCeramicElectrolyteUnit.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/InsanelyUltimateEnergyUnit_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/InsanelyUltimateEnergyUnit_side.png Binary files differnew file mode 100644 index 0000000000..1ff488f081 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/InsanelyUltimateEnergyUnit_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/InsanelyUltimateEnergyUnit_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/InsanelyUltimateEnergyUnit_top.png Binary files differnew file mode 100644 index 0000000000..2e800c9201 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/InsanelyUltimateEnergyUnit_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LSCBase_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LSCBase_side.png Binary files differnew file mode 100644 index 0000000000..97e08ea590 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LSCBase_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LSCBase_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LSCBase_top.png Binary files differnew file mode 100644 index 0000000000..0442310031 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LSCBase_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit1_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit1_side.png Binary files differnew file mode 100644 index 0000000000..852873db1d --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit1_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit1_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit1_top.png Binary files differnew file mode 100644 index 0000000000..1c99201a9f --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit1_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit2_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit2_side.png Binary files differnew file mode 100644 index 0000000000..d462a774a1 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit2_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit2_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit2_top.png Binary files differnew file mode 100644 index 0000000000..2f1f4299eb --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit2_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit3_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit3_side.png Binary files differnew file mode 100644 index 0000000000..a8894d382e --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit3_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit3_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit3_top.png Binary files differnew file mode 100644 index 0000000000..96d56ac6a6 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit3_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit4_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit4_side.png Binary files differnew file mode 100644 index 0000000000..3827b174c0 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit4_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit4_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit4_top.png Binary files differnew file mode 100644 index 0000000000..68e03929d8 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit4_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit6_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit6_side.png Binary files differnew file mode 100644 index 0000000000..852873db1d --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit6_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit6_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit6_top.png Binary files differnew file mode 100644 index 0000000000..c5034dfd93 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit6_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit7_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit7_side.png Binary files differnew file mode 100644 index 0000000000..852873db1d --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit7_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit7_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit7_top.png Binary files differnew file mode 100644 index 0000000000..06a1bd064f --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LapotronicEnergyUnit7_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_0.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_0.png Binary files differnew file mode 100644 index 0000000000..066845e231 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_0.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_1.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_1.png Binary files differnew file mode 100644 index 0000000000..7da38a599a --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_1.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_2.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_2.png Binary files differnew file mode 100644 index 0000000000..b71361b6e6 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_2.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_3.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_3.png Binary files differnew file mode 100644 index 0000000000..6dde5d88ce --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_0_3.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_0.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_0.png Binary files differnew file mode 100644 index 0000000000..c59f06e48b --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_0.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_1.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_1.png Binary files differnew file mode 100644 index 0000000000..15ada67d51 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_1.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_2.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_2.png Binary files differnew file mode 100644 index 0000000000..fa7cb6610d --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_2.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_3.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_3.png Binary files differnew file mode 100644 index 0000000000..9802f4c45f --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_1_3.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_0.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_0.png Binary files differnew file mode 100644 index 0000000000..b96eae723e --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_0.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_1.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_1.png Binary files differnew file mode 100644 index 0000000000..30023e5987 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_1.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_2.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_2.png Binary files differnew file mode 100644 index 0000000000..496fb235cb --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_2.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_3.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_3.png Binary files differnew file mode 100644 index 0000000000..03544d84d1 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_2_3.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_0.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_0.png Binary files differnew file mode 100644 index 0000000000..cc9a5f89da --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_0.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_1.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_1.png Binary files differnew file mode 100644 index 0000000000..2586c16072 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_1.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_2.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_2.png Binary files differnew file mode 100644 index 0000000000..7bc5006d3d --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_2.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_3.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_3.png Binary files differnew file mode 100644 index 0000000000..2966ccb079 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/LargeHexTile_3_3.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/MegaUltimateEnergyUnit_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/MegaUltimateEnergyUnit_side.png Binary files differnew file mode 100644 index 0000000000..93e7e5d5b2 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/MegaUltimateEnergyUnit_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/MegaUltimateEnergyUnit_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/MegaUltimateEnergyUnit_top.png Binary files differnew file mode 100644 index 0000000000..66cadfbfb0 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/MegaUltimateEnergyUnit_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/ReallyUltimateEnergyUnit_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ReallyUltimateEnergyUnit_side.png Binary files differnew file mode 100644 index 0000000000..ae861e1d8a --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ReallyUltimateEnergyUnit_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/ReallyUltimateEnergyUnit_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ReallyUltimateEnergyUnit_top.png Binary files differnew file mode 100644 index 0000000000..61ecab2e40 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ReallyUltimateEnergyUnit_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTCasing.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTCasing.png Binary files differnew file mode 100644 index 0000000000..6f0375c310 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTCasing.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock1.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock1.png Binary files differnew file mode 100644 index 0000000000..55b4a17c56 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock1.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock10.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock10.png Binary files differnew file mode 100644 index 0000000000..26aee7ef63 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock10.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock10.png.mcmeta b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock10.png.mcmeta new file mode 100644 index 0000000000..33611385bd --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock10.png.mcmeta @@ -0,0 +1,45 @@ +{ + "animation": { + "frametime": 1, + "frames": [ + 0, + 1, + 2, + 3, + 4, + 5, + 6, + 7, + 8, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 18, + 19, + 18, + 17, + 16, + 15, + 14, + 13, + 12, + 11, + 10, + 9, + 8, + 7, + 6, + 5, + 4, + 3, + 2, + 1 + ] + } +}
\ No newline at end of file diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock2.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock2.png Binary files differnew file mode 100644 index 0000000000..8176f2e44b --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock2.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock3.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock3.png Binary files differnew file mode 100644 index 0000000000..bc03da1fee --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock3.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock4.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock4.png Binary files differnew file mode 100644 index 0000000000..09738a5211 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock4.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock5.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock5.png Binary files differnew file mode 100644 index 0000000000..20ad0ba3c6 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock5.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock6.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock6.png Binary files differnew file mode 100644 index 0000000000..126536a973 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock6.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock7.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock7.png Binary files differnew file mode 100644 index 0000000000..f7461e84d5 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock7.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock8.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock8.png Binary files differnew file mode 100644 index 0000000000..9b59f3cd3c --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock8.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock9.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock9.png Binary files differnew file mode 100644 index 0000000000..608c2ee0d7 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/TFFTStorageFieldBlock9.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/UltimateEnergyUnit_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/UltimateEnergyUnit_side.png Binary files differnew file mode 100644 index 0000000000..53443e6c9a --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/UltimateEnergyUnit_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/UltimateEnergyUnit_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/UltimateEnergyUnit_top.png Binary files differnew file mode 100644 index 0000000000..f71387ef03 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/UltimateEnergyUnit_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/YSZCeramicElectrolyteUnit.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/YSZCeramicElectrolyteUnit.png Binary files differnew file mode 100644 index 0000000000..e0533fcfb4 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/YSZCeramicElectrolyteUnit.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_bottom.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_bottom.png Binary files differnew file mode 100644 index 0000000000..075e490985 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_bottom.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_side.png Binary files differnew file mode 100644 index 0000000000..002df614b8 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_side_void.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_side_void.png Binary files differnew file mode 100644 index 0000000000..9e5c7126c0 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_side_void.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_top.png Binary files differnew file mode 100644 index 0000000000..794995c9de --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_top_void.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_top_void.png Binary files differnew file mode 100644 index 0000000000..c11b12c968 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/ichor_jar_top_void.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_bottom.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_bottom.png Binary files differnew file mode 100644 index 0000000000..08c88b06c8 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_bottom.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_side.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_side.png Binary files differnew file mode 100644 index 0000000000..16f5ae1946 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_side.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_side_void.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_side_void.png Binary files differnew file mode 100644 index 0000000000..bcf2fb8f6c --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_side_void.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_top.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_top.png Binary files differnew file mode 100644 index 0000000000..f7afb2e4b3 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_top.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_top_void.png b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_top_void.png Binary files differnew file mode 100644 index 0000000000..083e8a1d0b --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/blocks/thaumreinforced_jar_top_void.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/gui/overlay_button/wireless_off.png b/kekztech/src/main/resources/assets/kekztech/textures/gui/overlay_button/wireless_off.png Binary files differnew file mode 100644 index 0000000000..dc7f50d04b --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/gui/overlay_button/wireless_off.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/gui/overlay_button/wireless_off_disabled.png b/kekztech/src/main/resources/assets/kekztech/textures/gui/overlay_button/wireless_off_disabled.png Binary files differnew file mode 100644 index 0000000000..aa4ab54220 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/gui/overlay_button/wireless_off_disabled.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/gui/overlay_button/wireless_on.png b/kekztech/src/main/resources/assets/kekztech/textures/gui/overlay_button/wireless_on.png Binary files differnew file mode 100644 index 0000000000..1691c4b32e --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/gui/overlay_button/wireless_on.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/items/CeriaDust.png b/kekztech/src/main/resources/assets/kekztech/textures/items/CeriaDust.png Binary files differnew file mode 100644 index 0000000000..9c488d0fff --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/items/CeriaDust.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/items/Error.png b/kekztech/src/main/resources/assets/kekztech/textures/items/Error.png Binary files differnew file mode 100644 index 0000000000..520b19651c --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/items/Error.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/items/GDCCeramicDust.png b/kekztech/src/main/resources/assets/kekztech/textures/items/GDCCeramicDust.png Binary files differnew file mode 100644 index 0000000000..15761a2ead --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/items/GDCCeramicDust.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/items/GDCCeramicPlate.png b/kekztech/src/main/resources/assets/kekztech/textures/items/GDCCeramicPlate.png Binary files differnew file mode 100644 index 0000000000..3d564d516f --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/items/GDCCeramicPlate.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/items/YSZCeramicDust.png b/kekztech/src/main/resources/assets/kekztech/textures/items/YSZCeramicDust.png Binary files differnew file mode 100644 index 0000000000..da612bddd7 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/items/YSZCeramicDust.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/items/YSZCeramicPlate.png b/kekztech/src/main/resources/assets/kekztech/textures/items/YSZCeramicPlate.png Binary files differnew file mode 100644 index 0000000000..2e6e7e7e79 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/items/YSZCeramicPlate.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/items/YttriaDust.png b/kekztech/src/main/resources/assets/kekztech/textures/items/YttriaDust.png Binary files differnew file mode 100644 index 0000000000..74762bd870 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/items/YttriaDust.png diff --git a/kekztech/src/main/resources/assets/kekztech/textures/items/ZirconiaDust.png b/kekztech/src/main/resources/assets/kekztech/textures/items/ZirconiaDust.png Binary files differnew file mode 100644 index 0000000000..52ce919978 --- /dev/null +++ b/kekztech/src/main/resources/assets/kekztech/textures/items/ZirconiaDust.png diff --git a/kekztech/src/main/resources/mcmod.info b/kekztech/src/main/resources/mcmod.info new file mode 100644 index 0000000000..4967006f06 --- /dev/null +++ b/kekztech/src/main/resources/mcmod.info @@ -0,0 +1,18 @@ +[ + { + "modid": "${modId}", + "name": "${modName}", + "description": "", + "version": "${modVersion}", + "mcversion": "${minecraftVersion}", + "url": "", + "updateUrl": "", + "authorList": [""], + "credits": "", + "logoFile": "", + "screenshots": [], + "requiredMods": [ "IC2", "gregtech", "tectech", "Thaumcraft", "ThaumicTinkerer" ], + "dependencies": [ "IC2", "gregtech", "tectech", "Thaumcraft", "ThaumicTinkerer", "bartworks", "dreamcraft" ], + "useDependencyInformation": true + } +] |
