From 92238a0f3b06a80683f50dfd2d6e9164d2d0f1ab Mon Sep 17 00:00:00 2001 From: GlodBlock <1356392126@qq.com> Date: Tue, 7 Dec 2021 23:02:17 +0800 Subject: rename package --- .../goodgenerator/blocks/myFluids/BaseFluid.java | 54 + .../blocks/myFluids/FluidsBuilder.java | 176 ++ .../goodgenerator/blocks/regularBlock/Casing.java | 123 ++ .../blocks/regularBlock/ComplexTextureCasing.java | 58 + .../goodgenerator/blocks/regularBlock/Frame.java | 36 + .../goodgenerator/blocks/regularBlock/TEBlock.java | 180 ++ .../blocks/tileEntity/EssentiaHatch.java | 225 +++ .../blocks/tileEntity/FuelRefineFactory.java | 368 ++++ .../GTMetaTileEntity/NeutronAccelerator.java | 66 + .../tileEntity/GTMetaTileEntity/NeutronSensor.java | 168 ++ .../blocks/tileEntity/LargeEssentiaGenerator.java | 539 ++++++ .../blocks/tileEntity/MegaPlasmaTurbine.java | 50 + .../blocks/tileEntity/MetalVaporTurbine.java | 5 + .../blocks/tileEntity/MultiNqGenerator.java | 427 +++++ .../blocks/tileEntity/NeutronActivator.java | 441 +++++ .../tileEntity/UniversalChemicalFuelEngine.java | 348 ++++ .../blocks/tileEntity/YottaFluidTank.java | 424 +++++ .../java/goodgenerator/client/ClientProxy.java | 21 + .../client/GUI/NeutronActivatorGUIClient.java | 43 + .../client/GUI/NeutronSensorGUIClient.java | 110 ++ .../goodgenerator/client/GUI/YOTTankGUIClient.java | 28 + .../java/goodgenerator/common/CommonProxy.java | 11 + .../container/NeutronActivatorGUIContainer.java | 80 + .../container/NeutronSensorGUIContainer.java | 12 + .../common/container/YOTTankGUIContainer.java | 133 ++ .../java/goodgenerator/crossmod/nei/IMCForNEI.java | 24 + .../goodgenerator/crossmod/nei/NEI_Config.java | 38 + .../crossmod/nei/NeutronActivatorHandler.java | 43 + .../thaumcraft/LargeEssentiaEnergyData.java | 124 ++ .../crossmod/thaumcraft/Research.java | 620 +++++++ src/main/java/goodgenerator/items/FuelRod.java | 183 ++ .../java/goodgenerator/items/MyItemBlocks.java | 89 + src/main/java/goodgenerator/items/MyItems.java | 112 ++ src/main/java/goodgenerator/items/MyMaterial.java | 1015 +++++++++++ .../java/goodgenerator/items/RadioactiveItem.java | 40 + .../items/nuclear/IsotopeMaterial.java | 55 + .../items/nuclear/IsotopeMaterialLoader.java | 16 + .../items/nuclear/NuclearMetaItemGenerator.java | 103 ++ .../items/nuclear/NuclearTextures.java | 31 + .../goodgenerator/loader/AchievementLoader.java | 4 + .../goodgenerator/loader/FuelRecipeLoader.java | 79 + .../java/goodgenerator/loader/FuelRodLoader.java | 56 + src/main/java/goodgenerator/loader/Loaders.java | 215 +++ .../loader/NaquadahReworkRecipeLoader.java | 1125 ++++++++++++ .../loader/NeutronActivatorLoader.java | 24 + .../java/goodgenerator/loader/RecipeLoader.java | 1904 ++++++++++++++++++++ .../java/goodgenerator/loader/RecipeLoader_02.java | 670 +++++++ .../java/goodgenerator/main/GG_Config_Loader.java | 69 + .../java/goodgenerator/main/GoodGenerator.java | 76 + .../java/goodgenerator/network/MessageMTEBase.java | 98 + .../network/MessageOpenNeutronSensorGUI.java | 50 + .../network/MessageSetNeutronSensorData.java | 52 + src/main/java/goodgenerator/tabs/MyTabs.java | 16 + src/main/java/goodgenerator/tabs/NuclearTab.java | 16 + .../java/goodgenerator/util/CharExchanger.java | 124 ++ .../java/goodgenerator/util/CrackRecipeAdder.java | 78 + .../goodgenerator/util/DescTextLocalization.java | 17 + src/main/java/goodgenerator/util/ItemRefer.java | 152 ++ src/main/java/goodgenerator/util/MaterialFix.java | 50 + .../java/goodgenerator/util/MyRecipeAdder.java | 100 + .../java/goodgenerator/util/StructureHelper.java | 112 ++ 61 files changed, 11706 insertions(+) create mode 100644 src/main/java/goodgenerator/blocks/myFluids/BaseFluid.java create mode 100644 src/main/java/goodgenerator/blocks/myFluids/FluidsBuilder.java create mode 100644 src/main/java/goodgenerator/blocks/regularBlock/Casing.java create mode 100644 src/main/java/goodgenerator/blocks/regularBlock/ComplexTextureCasing.java create mode 100644 src/main/java/goodgenerator/blocks/regularBlock/Frame.java create mode 100644 src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/LargeEssentiaGenerator.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/MegaPlasmaTurbine.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/MetalVaporTurbine.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/NeutronActivator.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/UniversalChemicalFuelEngine.java create mode 100644 src/main/java/goodgenerator/blocks/tileEntity/YottaFluidTank.java create mode 100644 src/main/java/goodgenerator/client/ClientProxy.java create mode 100644 src/main/java/goodgenerator/client/GUI/NeutronActivatorGUIClient.java create mode 100644 src/main/java/goodgenerator/client/GUI/NeutronSensorGUIClient.java create mode 100644 src/main/java/goodgenerator/client/GUI/YOTTankGUIClient.java create mode 100644 src/main/java/goodgenerator/common/CommonProxy.java create mode 100644 src/main/java/goodgenerator/common/container/NeutronActivatorGUIContainer.java create mode 100644 src/main/java/goodgenerator/common/container/NeutronSensorGUIContainer.java create mode 100644 src/main/java/goodgenerator/common/container/YOTTankGUIContainer.java create mode 100644 src/main/java/goodgenerator/crossmod/nei/IMCForNEI.java create mode 100644 src/main/java/goodgenerator/crossmod/nei/NEI_Config.java create mode 100644 src/main/java/goodgenerator/crossmod/nei/NeutronActivatorHandler.java create mode 100644 src/main/java/goodgenerator/crossmod/thaumcraft/LargeEssentiaEnergyData.java create mode 100644 src/main/java/goodgenerator/crossmod/thaumcraft/Research.java create mode 100644 src/main/java/goodgenerator/items/FuelRod.java create mode 100644 src/main/java/goodgenerator/items/MyItemBlocks.java create mode 100644 src/main/java/goodgenerator/items/MyItems.java create mode 100644 src/main/java/goodgenerator/items/MyMaterial.java create mode 100644 src/main/java/goodgenerator/items/RadioactiveItem.java create mode 100644 src/main/java/goodgenerator/items/nuclear/IsotopeMaterial.java create mode 100644 src/main/java/goodgenerator/items/nuclear/IsotopeMaterialLoader.java create mode 100644 src/main/java/goodgenerator/items/nuclear/NuclearMetaItemGenerator.java create mode 100644 src/main/java/goodgenerator/items/nuclear/NuclearTextures.java create mode 100644 src/main/java/goodgenerator/loader/AchievementLoader.java create mode 100644 src/main/java/goodgenerator/loader/FuelRecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/FuelRodLoader.java create mode 100644 src/main/java/goodgenerator/loader/Loaders.java create mode 100644 src/main/java/goodgenerator/loader/NaquadahReworkRecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/NeutronActivatorLoader.java create mode 100644 src/main/java/goodgenerator/loader/RecipeLoader.java create mode 100644 src/main/java/goodgenerator/loader/RecipeLoader_02.java create mode 100644 src/main/java/goodgenerator/main/GG_Config_Loader.java create mode 100644 src/main/java/goodgenerator/main/GoodGenerator.java create mode 100644 src/main/java/goodgenerator/network/MessageMTEBase.java create mode 100644 src/main/java/goodgenerator/network/MessageOpenNeutronSensorGUI.java create mode 100644 src/main/java/goodgenerator/network/MessageSetNeutronSensorData.java create mode 100644 src/main/java/goodgenerator/tabs/MyTabs.java create mode 100644 src/main/java/goodgenerator/tabs/NuclearTab.java create mode 100644 src/main/java/goodgenerator/util/CharExchanger.java create mode 100644 src/main/java/goodgenerator/util/CrackRecipeAdder.java create mode 100644 src/main/java/goodgenerator/util/DescTextLocalization.java create mode 100644 src/main/java/goodgenerator/util/ItemRefer.java create mode 100644 src/main/java/goodgenerator/util/MaterialFix.java create mode 100644 src/main/java/goodgenerator/util/MyRecipeAdder.java create mode 100644 src/main/java/goodgenerator/util/StructureHelper.java (limited to 'src/main/java/goodgenerator') diff --git a/src/main/java/goodgenerator/blocks/myFluids/BaseFluid.java b/src/main/java/goodgenerator/blocks/myFluids/BaseFluid.java new file mode 100644 index 0000000000..9ccbd27e70 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/myFluids/BaseFluid.java @@ -0,0 +1,54 @@ +package goodgenerator.blocks.myFluids; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.util.IIcon; +import net.minecraftforge.fluids.BlockFluidClassic; +import net.minecraftforge.fluids.Fluid; +import net.minecraftforge.fluids.FluidRegistry; + +import static goodgenerator.main.GoodGenerator.MOD_ID; + +public class BaseFluid extends BlockFluidClassic{ + @SideOnly( Side.CLIENT ) + protected IIcon stillIcon; + @SideOnly( Side.CLIENT ) + protected IIcon flowingIcon; + private String stillTexture; + private String flowingTexture; + + public BaseFluid(Fluid fluid, Material material) + { + super( fluid, material ); + } + + public void SetTexture(String fluidName) + { + stillTexture = MOD_ID + ":fluids/" + fluidName + ".still"; + flowingTexture = MOD_ID + ":fluids/" + fluidName + ".flowing"; + } + + public static Fluid BuildFluid(String fluidName){ + Fluid tFluid = new Fluid(fluidName); + FluidRegistry.registerFluid(tFluid); + return tFluid; + } + + @SideOnly( Side.CLIENT ) + @Override + public void registerBlockIcons( IIconRegister register ) + { + stillIcon = register.registerIcon(stillTexture); + flowingIcon = register.registerIcon(flowingTexture); + + super.getFluid().setIcons( stillIcon, flowingIcon ); + } + + @Override + public IIcon getIcon( int side, int meta ) + { + return ( side == 0 || side == 1 ) ? stillIcon : flowingIcon; + } +} diff --git a/src/main/java/goodgenerator/blocks/myFluids/FluidsBuilder.java b/src/main/java/goodgenerator/blocks/myFluids/FluidsBuilder.java new file mode 100644 index 0000000000..94857b73f6 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/myFluids/FluidsBuilder.java @@ -0,0 +1,176 @@ +package goodgenerator.blocks.myFluids; + +import goodgenerator.crossmod.nei.NEI_Config; +import cpw.mods.fml.common.registry.GameRegistry; +import net.minecraft.block.material.Material; +import net.minecraftforge.fluids.Fluid; + +public class FluidsBuilder { + public FluidsBuilder(){ + } + + public static void Register() { + crackedNaquadahGas_Lightly(); + crackedNaquadahGas_Moderately(); + crackedNaquadahGas_Heavily(); + crackedLightNaquadahFuel_Lightly(); + crackedLightNaquadahFuel_Moderately(); + crackedLightNaquadahFuel_Heavily(); + crackedHeavyNaquadahFuel_Lightly(); + crackedHeavyNaquadahFuel_Moderately(); + crackedHeavyNaquadahFuel_Heavily(); + crackedNaquadahAsphalt_Lightly(); + crackedNaquadahAsphalt_Moderately(); + crackedNaquadahAsphalt_Heavily(); + combustionPromotor(); + } + + public static void crackedNaquadahGas_Lightly(){ + Fluid tmp = BaseFluid.BuildFluid("lightlyCrackedNaquadahGas"); + tmp.setGaseous(true) + .setTemperature(800); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("lightlyCrackedNaquadahGas"); + tmp2.setBlockName("lightlyCrackedNaquadahGas"); + GameRegistry.registerBlock(tmp2,"lightlyCrackedNaquadahGas"); + NEI_Config.hide(tmp2); + } + + public static void crackedNaquadahGas_Moderately(){ + Fluid tmp = BaseFluid.BuildFluid("moderatelyCrackedNaquadahGas"); + tmp.setGaseous(true) + .setTemperature(800); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("moderatelyCrackedNaquadahGas"); + tmp2.setBlockName("moderatelyCrackedNaquadahGas"); + GameRegistry.registerBlock(tmp2,"moderatelyCrackedNaquadahGas"); + NEI_Config.hide(tmp2); + } + + public static void crackedNaquadahGas_Heavily(){ + Fluid tmp = BaseFluid.BuildFluid("heavilyCrackedNaquadahGas"); + tmp.setGaseous(true) + .setTemperature(800); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("heavilyCrackedNaquadahGas"); + tmp2.setBlockName("heavilyCrackedNaquadahGas"); + GameRegistry.registerBlock(tmp2,"heavilyCrackedNaquadahGas"); + NEI_Config.hide(tmp2); + } + + public static void crackedLightNaquadahFuel_Lightly(){ + Fluid tmp = BaseFluid.BuildFluid("lightlyCrackedLightNaquadahFuel"); + tmp.setGaseous(false) + .setTemperature(1200); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("lightlyCrackedLightNaquadahFuel"); + tmp2.setBlockName("lightlyCrackedLightNaquadahFuel"); + GameRegistry.registerBlock(tmp2,"lightlyCrackedLightNaquadahFuel"); + NEI_Config.hide(tmp2); + } + + public static void crackedLightNaquadahFuel_Moderately(){ + Fluid tmp = BaseFluid.BuildFluid("moderatelyCrackedLightNaquadahFuel"); + tmp.setGaseous(false) + .setTemperature(1200); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("moderatelyCrackedLightNaquadahFuel"); + tmp2.setBlockName("moderatelyCrackedLightNaquadahFuel"); + GameRegistry.registerBlock(tmp2,"moderatelyCrackedLightNaquadahFuel"); + NEI_Config.hide(tmp2); + } + + public static void crackedLightNaquadahFuel_Heavily(){ + Fluid tmp = BaseFluid.BuildFluid("heavilyCrackedLightNaquadahFuel"); + tmp.setGaseous(false) + .setTemperature(1200); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("heavilyCrackedLightNaquadahFuel"); + tmp2.setBlockName("heavilyCrackedLightNaquadahFuel"); + GameRegistry.registerBlock(tmp2,"heavilyCrackedLightNaquadahFuel"); + NEI_Config.hide(tmp2); + } + + public static void crackedHeavyNaquadahFuel_Lightly(){ + Fluid tmp = BaseFluid.BuildFluid("lightlyCrackedHeavyNaquadahFuel"); + tmp.setGaseous(false) + .setTemperature(1200); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("lightlyCrackedHeavyNaquadahFuel"); + tmp2.setBlockName("lightlyCrackedHeavyNaquadahFuel"); + GameRegistry.registerBlock(tmp2,"lightlyCrackedHeavyNaquadahFuel"); + NEI_Config.hide(tmp2); + } + + public static void crackedHeavyNaquadahFuel_Moderately(){ + Fluid tmp = BaseFluid.BuildFluid("moderatelyCrackedHeavyNaquadahFuel"); + tmp.setGaseous(false) + .setTemperature(1200); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("moderatelyCrackedHeavyNaquadahFuel"); + tmp2.setBlockName("moderatelyCrackedHeavyNaquadahFuel"); + GameRegistry.registerBlock(tmp2,"moderatelyCrackedHeavyNaquadahFuel"); + NEI_Config.hide(tmp2); + } + + public static void crackedHeavyNaquadahFuel_Heavily(){ + Fluid tmp = BaseFluid.BuildFluid("heavilyCrackedHeavyNaquadahFuel"); + tmp.setGaseous(false) + .setTemperature(1200); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("heavilyCrackedHeavyNaquadahFuel"); + tmp2.setBlockName("heavilyCrackedHeavyNaquadahFuel"); + GameRegistry.registerBlock(tmp2,"heavilyCrackedHeavyNaquadahFuel"); + NEI_Config.hide(tmp2); + } + + public static void crackedNaquadahAsphalt_Lightly(){ + Fluid tmp = BaseFluid.BuildFluid("lightlyCrackedNaquadahAsphalt"); + tmp.setGaseous(false) + .setTemperature(1800) + .setDensity(20000) + .setViscosity(20000); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("lightlyCrackedNaquadahAsphalt"); + tmp2.setBlockName("lightlyCrackedNaquadahAsphalt"); + GameRegistry.registerBlock(tmp2,"lightlyCrackedNaquadahAsphalt"); + NEI_Config.hide(tmp2); + } + + public static void crackedNaquadahAsphalt_Moderately(){ + Fluid tmp = BaseFluid.BuildFluid("moderatelyCrackedNaquadahAsphalt"); + tmp.setGaseous(false) + .setTemperature(1800) + .setDensity(20000) + .setViscosity(20000); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("moderatelyCrackedNaquadahAsphalt"); + tmp2.setBlockName("moderatelyCrackedNaquadahAsphalt"); + GameRegistry.registerBlock(tmp2,"moderatelyCrackedNaquadahAsphalt"); + NEI_Config.hide(tmp2); + } + + public static void crackedNaquadahAsphalt_Heavily(){ + Fluid tmp = BaseFluid.BuildFluid("heavilyCrackedNaquadahAsphalt"); + tmp.setGaseous(false) + .setTemperature(1800) + .setDensity(20000) + .setViscosity(20000); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("heavilyCrackedNaquadahAsphalt"); + tmp2.setBlockName("heavilyCrackedNaquadahAsphalt"); + GameRegistry.registerBlock(tmp2,"heavilyCrackedNaquadahAsphalt"); + NEI_Config.hide(tmp2); + } + + public static void combustionPromotor(){ + Fluid tmp = BaseFluid.BuildFluid("combustionPromotor"); + tmp.setGaseous(false) + .setTemperature(300); + BaseFluid tmp2 = new BaseFluid(tmp, Material.water); + tmp2.SetTexture("combustionPromotor"); + tmp2.setBlockName("combustionPromotor"); + GameRegistry.registerBlock(tmp2,"combustionPromotor"); + NEI_Config.hide(tmp2); + } +} diff --git a/src/main/java/goodgenerator/blocks/regularBlock/Casing.java b/src/main/java/goodgenerator/blocks/regularBlock/Casing.java new file mode 100644 index 0000000000..7a1db3278d --- /dev/null +++ b/src/main/java/goodgenerator/blocks/regularBlock/Casing.java @@ -0,0 +1,123 @@ +package goodgenerator.blocks.regularBlock; + +import goodgenerator.main.GoodGenerator; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +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.entity.Entity; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +import java.util.List; + +public class Casing extends Block { + + @SideOnly(Side.CLIENT) + protected IIcon[] texture; + String[] textureNames; + protected String name; + + public Casing(String name) { + super(Material.iron); + this.setHardness(9.0F); + this.setResistance(5.0F); + this.name = name; + this.setHarvestLevel("wrench",2); + this.setCreativeTab(GoodGenerator.GG); + GregTech_API.registerMachineBlock(this, -1); + } + + public Casing(String name, String[] texture){ + super(Material.iron); + this.setHardness(9.0F); + this.setResistance(5.0F); + this.name = name; + this.textureNames = texture; + this.setHarvestLevel("wrench",2); + this.setCreativeTab(GoodGenerator.GG); + GregTech_API.registerMachineBlock(this, -1); + } + + public Casing(String name, String[] texture, Material material){ + super(material); + this.setHardness(9.0F); + this.setResistance(5.0F); + this.name = name; + this.textureNames = texture; + this.setHarvestLevel("wrench",2); + this.setCreativeTab(GoodGenerator.GG); + GregTech_API.registerMachineBlock(this, -1); + } + + @Override + public int damageDropped(int meta) { + return meta; + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(int side, int meta) { + return meta < this.texture.length ? this.texture[meta] : this.texture[0]; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister par1IconRegister) { + this.texture = new IIcon[this.textureNames.length]; + for (int i = 0; i < this.textureNames.length; i++) { + this.texture[i] = par1IconRegister.registerIcon(this.textureNames[i]); + } + } + + @Override + @SideOnly(Side.CLIENT) + @SuppressWarnings("unchecked") + public void getSubBlocks(Item item, CreativeTabs tab, List list) { + for (int i = 0; i < this.textureNames.length; i++) { + list.add(new ItemStack(item, 1, i)); + } + } + + @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); + } + } + + @Override + public String getUnlocalizedName() { + return this.name; + } + + @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; + } + +} diff --git a/src/main/java/goodgenerator/blocks/regularBlock/ComplexTextureCasing.java b/src/main/java/goodgenerator/blocks/regularBlock/ComplexTextureCasing.java new file mode 100644 index 0000000000..18a1629cbf --- /dev/null +++ b/src/main/java/goodgenerator/blocks/regularBlock/ComplexTextureCasing.java @@ -0,0 +1,58 @@ +package goodgenerator.blocks.regularBlock; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; + +import java.util.List; + +public class ComplexTextureCasing extends Casing{ + + @SideOnly(Side.CLIENT) + protected IIcon[] texture1, texture2; + String[] textureSide; + String[] textureTopAndDown; + + public ComplexTextureCasing(String name, String[] textureSide, String[] textureTopAndDown){ + super(name); + this.textureSide = textureSide; + this.textureTopAndDown = textureTopAndDown; + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(int side, int meta) { + if (side < 2) { + return meta < this.texture2.length ? this.texture2[meta] : this.texture2[0]; + } + else { + return meta < this.texture1.length ? this.texture1[meta] : this.texture1[0]; + } + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister par1IconRegister) { + this.texture1 = new IIcon[this.textureSide.length]; + for (int i = 0; i < this.textureSide.length; i++) { + this.texture1[i] = par1IconRegister.registerIcon(this.textureSide[i]); + } + this.texture2 = new IIcon[this.textureTopAndDown.length]; + for (int i = 0; i < this.textureTopAndDown.length; i++) { + this.texture2[i] = par1IconRegister.registerIcon(this.textureTopAndDown[i]); + } + } + + @Override + @SideOnly(Side.CLIENT) + @SuppressWarnings("unchecked") + public void getSubBlocks(Item item, CreativeTabs tab, List list) { + for (int i = 0; i < Math.max(this.textureSide.length, this.textureTopAndDown.length); i++) { + list.add(new ItemStack(item, 1, i)); + } + } +} diff --git a/src/main/java/goodgenerator/blocks/regularBlock/Frame.java b/src/main/java/goodgenerator/blocks/regularBlock/Frame.java new file mode 100644 index 0000000000..90c38c4cce --- /dev/null +++ b/src/main/java/goodgenerator/blocks/regularBlock/Frame.java @@ -0,0 +1,36 @@ +package goodgenerator.blocks.regularBlock; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import net.minecraft.block.material.Material; +import net.minecraft.world.IBlockAccess; + +public class Frame extends Casing{ + public Frame(String name,String[] texture){ + super(name,texture, Material.iron); + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public boolean shouldSideBeRendered(IBlockAccess worldClient, int xCoord, int yCoord, int zCoord, int aSide) { + if (worldClient.getBlock(xCoord, yCoord, zCoord) instanceof Frame) + return false; + return super.shouldSideBeRendered(worldClient, xCoord, yCoord, zCoord, aSide); + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderBlockPass() { + return 1; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } +} diff --git a/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java b/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java new file mode 100644 index 0000000000..b33dbffdec --- /dev/null +++ b/src/main/java/goodgenerator/blocks/regularBlock/TEBlock.java @@ -0,0 +1,180 @@ +package goodgenerator.blocks.regularBlock; + +import goodgenerator.blocks.tileEntity.EssentiaHatch; +import goodgenerator.main.GoodGenerator; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +import gregtech.api.util.GT_Utility; +import net.minecraft.block.Block; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.util.StatCollector; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.IEssentiaContainerItem; + +import java.util.List; + +public class TEBlock extends BlockContainer { + + @SideOnly(Side.CLIENT) + protected IIcon[] texture; + String[] textureNames; + protected String name; + protected int index; + + public TEBlock(String name, String[] texture, CreativeTabs Tab){ + super(Material.iron); + this.setHardness(9.0F); + this.setResistance(5.0F); + this.name = name; + this.textureNames = texture; + this.setHarvestLevel("wrench",2); + this.setCreativeTab(GoodGenerator.GG); + GregTech_API.registerMachineBlock(this, -1); + } + + public TEBlock(String name, String[] texture, int index){ + super(Material.iron); + this.setHardness(9.0F); + this.setResistance(5.0F); + this.name = name; + this.textureNames = texture; + this.setHarvestLevel("wrench",2); + this.index = index; + this.setCreativeTab(GoodGenerator.GG); + GregTech_API.registerMachineBlock(this, -1); + } + + public TEBlock(String name, String[] texture, Material material){ + super(material); + this.setHardness(9.0F); + this.setResistance(5.0F); + this.name = name; + this.textureNames = texture; + this.setHarvestLevel("wrench",2); + this.setCreativeTab(GoodGenerator.GG); + GregTech_API.registerMachineBlock(this, -1); + } + + public int getIndex() { + return this.index; + } + + @Override + public int damageDropped(int meta) { + return meta; + } + + @Override + @SideOnly(Side.CLIENT) + public IIcon getIcon(int side, int meta) { + return meta < this.texture.length ? this.texture[meta] : this.texture[0]; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister par1IconRegister) { + this.texture = new IIcon[this.textureNames.length]; + for (int i = 0; i < this.textureNames.length; i++) { + this.texture[i] = par1IconRegister.registerIcon(this.textureNames[i]); + } + } + + @Override + @SideOnly(Side.CLIENT) + @SuppressWarnings("unchecked") + public void getSubBlocks(Item item, CreativeTabs tab, List list) { + for (int i = 0; i < this.textureNames.length; i++) { + list.add(new ItemStack(item, 1, i)); + } + } + + @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); + } + aWorld.removeTileEntity(aX, aY, aZ); + } + + @Override + public String getUnlocalizedName() { + return this.name; + } + + @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 TileEntity createTileEntity(World world, int meta) { + if (index == 1) + return new EssentiaHatch(); + return null; + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par6, float par7, float par8, float par9) { + if (world.isRemote) { + return false; + } else { + TileEntity tile = world.getTileEntity(x, y, z); + if (index == 1) { + if (tile instanceof EssentiaHatch) { + ItemStack tItemStack = player.getHeldItem(); + if (tItemStack != null) { + Item tItem = tItemStack.getItem(); + if (tItem instanceof IEssentiaContainerItem && ((IEssentiaContainerItem) tItem).getAspects(player.getHeldItem()) != null && ((IEssentiaContainerItem) tItem).getAspects(player.getHeldItem()).size() > 0) { + Aspect tLocked = ((IEssentiaContainerItem) tItem).getAspects(player.getHeldItem()).getAspects()[0]; + ((EssentiaHatch) tile).setLockedAspect(tLocked); + GT_Utility.sendChatToPlayer(player, String.format(StatCollector.translateToLocal("essentiahatch.chat.0"), tLocked.getLocalizedDescription())); + } + } + else { + ((EssentiaHatch) tile).setLockedAspect(null); + GT_Utility.sendChatToPlayer(player, StatCollector.translateToLocal("essentiahatch.chat.1")); + } + world.markBlockForUpdate(x, y, z); + return true; + } + else return false; + } + else return false; + } + } + + @Override + public TileEntity createNewTileEntity(World p_149915_1_, int p_149915_2_) { + return null; + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java b/src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java new file mode 100644 index 0000000000..c8a4b1c713 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/EssentiaHatch.java @@ -0,0 +1,225 @@ +package goodgenerator.blocks.tileEntity; + +import goodgenerator.crossmod.thaumcraft.LargeEssentiaEnergyData; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.nbt.NBTTagList; +import net.minecraft.network.NetworkManager; +import net.minecraft.network.Packet; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.util.ForgeDirection; +import thaumcraft.api.ThaumcraftApiHelper; +import thaumcraft.api.aspects.Aspect; +import thaumcraft.api.aspects.AspectList; +import thaumcraft.api.aspects.IAspectContainer; +import thaumcraft.api.aspects.IEssentiaTransport; + +import java.util.ArrayList; + +public class EssentiaHatch extends TileEntity implements IAspectContainer, IEssentiaTransport { + + private Aspect mLocked; + private AspectList current = new AspectList(); + public int mState = 0; + + public void setLockedAspect(Aspect aAspect) { + this.mLocked = aAspect; + } + + @Override + public void readFromNBT(NBTTagCompound tagCompound) { + super.readFromNBT(tagCompound); + + this.mLocked = Aspect.getAspect(tagCompound.getString("mLocked")); + this.mState = tagCompound.getInteger("mState"); + current = new AspectList(); + NBTTagList tlist = tagCompound.getTagList("Aspects", 10); + for (int j = 0; j < tlist.tagCount(); ++j) { + NBTTagCompound rs = tlist.getCompoundTagAt(j); + if (rs.hasKey("key")) { + current.add(Aspect.getAspect(rs.getString("key")), rs.getInteger("amount")); + } + } + } + + @Override + public void writeToNBT(NBTTagCompound tagCompound) { + super.writeToNBT(tagCompound); + + tagCompound.setString("mLocked", this.mLocked == null ? "" : this.mLocked.getTag()); + tagCompound.setInteger("mState", mState); + NBTTagList tlist = new NBTTagList(); + Aspect[] aspectA = current.getAspects(); + for (Aspect aspect : aspectA) { + if (aspect != null) { + NBTTagCompound f = new NBTTagCompound(); + f.setString("key", aspect.getTag()); + f.setInteger("amount", current.getAmount(aspect)); + tlist.appendTag(f); + } + } + tagCompound.setTag("Aspects", tlist); + } + + public final Packet getDescriptionPacket() { + NBTTagCompound nbt = new NBTTagCompound(); + writeToNBT(nbt); + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 0, nbt); + } + + public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) { + NBTTagCompound nbt = pkt.func_148857_g(); + readFromNBT(nbt); + } + + public void markDirty() { + super.markDirty(); + if (this.worldObj.isRemote) { + return; + } + this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); + } + + @Override + public void updateEntity() { + fillfrompipe(); + } + + public void fillfrompipe() { + if (getEssentiaAmount(null) > 1000) + return; + TileEntity[] te = new TileEntity[ForgeDirection.VALID_DIRECTIONS.length]; + for (int i = 0; i < ForgeDirection.VALID_DIRECTIONS.length; i++) { + te[i] = ThaumcraftApiHelper.getConnectableTile(this.worldObj, this.xCoord, this.yCoord, this.zCoord, ForgeDirection.VALID_DIRECTIONS[i]); + if (te[i] != null) { + IEssentiaTransport pipe = (IEssentiaTransport) te[i]; + if (!pipe.canOutputTo(ForgeDirection.VALID_DIRECTIONS[i])) { + return; + } + if ((pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i].getOpposite()) != null) && (pipe.getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i]) < getSuctionAmount(ForgeDirection.VALID_DIRECTIONS[i]))) { + Aspect readyInput = pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i].getOpposite()); + int type = LargeEssentiaEnergyData.getAspectTypeIndex(readyInput); + if (type != -1 && (mState & (1 << type)) == 0) continue; + if (readyInput.equals(mLocked)) { + addToContainer(mLocked, pipe.takeEssentia(mLocked, 1, ForgeDirection.VALID_DIRECTIONS[i])); + } + if (mLocked == null) + addToContainer(pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]), pipe.takeEssentia(pipe.getEssentiaType(ForgeDirection.VALID_DIRECTIONS[i]), 1, ForgeDirection.VALID_DIRECTIONS[i])); + } + } + } + } + + @Override + public AspectList getAspects() { + return current; + } + + @Override + public void setAspects(AspectList aspectList) { + this.current.add(aspectList); + } + + @Override + public boolean doesContainerAccept(Aspect aspect) { + return mLocked == null || mLocked.equals(aspect); + } + + @Override + public int addToContainer(Aspect aspect, int i) { + current.add(aspect, i); + this.markDirty(); + return 0; + } + + @Override + public boolean takeFromContainer(Aspect aspect, int i) { + return false; + } + + @Override + public boolean takeFromContainer(AspectList aspectList) { + return false; + } + + @Override + public boolean doesContainerContainAmount(Aspect aspect, int i) { + return current.aspects.containsKey(aspect) && i <= current.getAmount(aspect); + } + + @Override + public boolean doesContainerContain(AspectList aspectList) { + ArrayList ret = new ArrayList(); + for (Aspect a : aspectList.aspects.keySet()) + ret.add(current.aspects.containsKey(a)); + return !ret.contains(false); + } + + @Override + public int containerContains(Aspect aspect) { + return current.aspects.containsKey(aspect) ? current.getAmount(aspect) : 0; + } + + @Override + public boolean isConnectable(ForgeDirection forgeDirection) { + return true; + } + + @Override + public boolean canInputFrom(ForgeDirection forgeDirection) { + return true; + } + + @Override + public boolean canOutputTo(ForgeDirection forgeDirection) { + return false; + } + + @Override + public void setSuction(Aspect aspect, int i) { } + + @Override + public Aspect getSuctionType(ForgeDirection forgeDirection) { + return this.mLocked; + } + + @Override + public int getSuctionAmount(ForgeDirection forgeDirection) { + return 256; + } + + @Override + public int takeEssentia(Aspect aspect, int i, ForgeDirection forgeDirection) { + return 0; + } + + @Override + public int addEssentia(Aspect aspect, int i, ForgeDirection forgeDirection) { + current.add(aspect, i); + return 0; + } + + @Override + public Aspect getEssentiaType(ForgeDirection forgeDirection) { + return current.getAspects()[0]; + } + + @Override + public int getEssentiaAmount(ForgeDirection forgeDirection) { + int ret = 0; + for (final Aspect A : current.aspects.keySet()) { + ret += current.getAmount(A); + } + return ret; + } + + @Override + public int getMinimumSuction() { + return Integer.MAX_VALUE; + } + + @Override + public boolean renderExtendedTube() { + return true; + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java b/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java new file mode 100644 index 0000000000..e68c92f8e8 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/FuelRefineFactory.java @@ -0,0 +1,368 @@ +package goodgenerator.blocks.tileEntity; + +import goodgenerator.loader.Loaders; +import goodgenerator.util.DescTextLocalization; +import goodgenerator.util.MyRecipeAdder; +import com.github.bartimaeusnek.crossmod.tectech.TecTechEnabledMulti; +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.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM; +import com.gtnewhorizon.structurelib.StructureLibAPI; +import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.IStructureElement; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; +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.*; +import gregtech.api.objects.GT_RenderedTexture; +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; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.fluids.FluidStack; +import org.lwjgl.input.Keyboard; + +import java.util.ArrayList; +import java.util.List; + +import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.*; +import static gregtech.api.util.GT_StructureUtility.*; +import static gregtech.api.enums.GT_Values.V; + +public class FuelRefineFactory extends GT_MetaTileEntity_MultiblockBase_EM implements TecTechEnabledMulti, IConstructable { + + private IStructureDefinition multiDefinition = null; + private int Tier = -1; + private int[] cnt = new int[]{0,0,0}; + private static final Block[] coils = new Block[]{Loaders.FRF_Coil_1,Loaders.FRF_Coil_2,Loaders.FRF_Coil_3}; + + public FuelRefineFactory(String name){super(name);} + + public FuelRefineFactory(int id, String name, String nameRegional){ + super(id,name,nameRegional); + } + + @Override + public List getVanillaEnergyHatches() { + return this.mEnergyHatches; + } + + @Override + public List getTecTechEnergyTunnels() { + return new ArrayList<>(); + } + + @Override + public List getTecTechEnergyMultis() { + return new ArrayList<>(); + } + + @Override + public void construct(ItemStack itemStack, boolean hintsOnly) { + structureBuild_EM(mName, 7, 12, 1, hintsOnly, itemStack); + } + + @Override + public IStructureDefinition getStructure_EM() { + if(multiDefinition == null) { + multiDefinition = StructureDefinition + .builder() + .addShape(mName, + transpose(new String[][]{ + {" "," CCC "," "}, + {" XGX "," CCFFFCC "," XGX "}, + {" CC CC "," CFFCCCFFC "," CC CC "}, + {" C C "," CFCC CCFC "," C C "}, + {" C C "," CFC CFC "," C C "}, + {" C C "," CFC CFC "," C C "}, + {" X X ","CFC CFC"," X X "}, + {" G G ","CFC CFC"," G G "}, + {" X X ","CFC CFC"," X X "}, + {" C C "," CFC CFC "," C C "}, + {" C C "," CFC CFC "," C C "}, + {" C C "," CFCC CCFC "," C C "}, + {" CC CC "," CFFC~CFFC "," CC CC "}, + {" XGX "," CCFFFCC "," XGX "}, + {" "," CCC "," "} + }) + ).addElement( + 'X', + ofChain( + ofHatchAdder( + FuelRefineFactory::addToFRFList,179, + Loaders.FRF_Casings,0 + ), + ofBlock( + Loaders.FRF_Casings,0 + ) + ) + ).addElement( + 'C', + ofBlock( + Loaders.FRF_Casings,0 + ) + ).addElement( + 'G', + ofBlock( + Loaders.fieldRestrictingGlass,0 + ) + ).addElement( + 'F', + ofChain( + onElementPass( + x -> ++x.cnt[0], + ofFieldCoil(0) + ), + onElementPass( + x -> ++x.cnt[1], + ofFieldCoil(1) + ), + onElementPass( + x -> ++x.cnt[2], + ofFieldCoil(2) + ) + ) + ) + .build(); + } + return multiDefinition; + } + + public static IStructureElement ofFieldCoil(int aIndex) { + return new IStructureElement() { + @Override + public boolean check(T t, World world, int x, int y, int z) { + Block block = world.getBlock(x, y, z); + return block.equals(coils[aIndex]); + } + + @Override + public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) { + StructureLibAPI.hintParticle(world, x, y, z, coils[getIndex(trigger)], 0); + return true; + } + + private int getIndex(ItemStack trigger) { + int s = trigger.stackSize; + if (s > 3 || s <= 0) s = 3; + return s - 1; + } + + @Override + public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) { + return world.setBlock(x, y, z, coils[getIndex(trigger)], 0, 3); + } + }; + } + + @Override + public String[] getDescription(){ + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Naquadah Fuel Refinery") + .addInfo("Controller block for the Naquadah Fuel Refinery") + .addInfo("But at what cost?") + .addInfo("Produce the endgame naquadah fuel.") + .addInfo("Need field restriction coil to control the fatal radiation.") + .addInfo("Use higher tier coil to unlock more fuel and reduce the process time.") + .addInfo("The structure is too complex!") + .addInfo(BLUE_PRINT_INFO) + .addSeparator() + .beginStructureBlock(3, 15, 15, false) + .addInputHatch("The casings adjoin the field restriction glass.") + .addInputBus("The casings adjoin the field restriction glass.") + .addOutputHatch("The casings adjoin the field restriction glass.") + .addEnergyHatch("The casings adjoin the field restriction glass.") + .toolTipFinisher("Good Generator"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } + } + + @Override + public void loadNBTData(NBTTagCompound aNBT){ + this.Tier = aNBT.getInteger("mTier"); + super.loadNBTData(aNBT); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT){ + aNBT.setInteger("mTier", this.Tier); + super.saveNBTData(aNBT); + } + + @Override + public String[] getStructureDescription(ItemStack itemStack){ + return DescTextLocalization.addText("FuelRefineFactory.hint", 8); + } + + @Override + public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + cnt[0] = 0;cnt[1] = 0;cnt[2] = 0; + mWrench = true; + mScrewdriver = true; + mSoftHammer = true; + mHardHammer = true; + mSolderingTool = true; + mCrowbar = true; + return structureCheck_EM(mName, 7,12,1) && getTier() != -1; + } + + public int getTier(){ + for (int i = 0; i < 3; i ++) { + if (cnt[i] == 32) { + Tier = i + 1; + return i; + } + } + Tier = -1; + return -1; + } + + @Override + public boolean checkRecipe_EM(ItemStack aStack){ + + mWrench = true; + mScrewdriver = true; + mSoftHammer = true; + mHardHammer = true; + mSolderingTool = true; + mCrowbar = true; + + ArrayList tFluids = getStoredFluids(); + ArrayList tItems = getStoredInputs(); + MyRecipeAdder.NaqFuelRefineMapper tRecipes = MyRecipeAdder.instance.FRF; + + for (int i = 0; i < tFluids.size() - 1; i++) { + for (int j = i + 1; j < tFluids.size(); j++) { + if (GT_Utility.areFluidsEqual(tFluids.get(i), tFluids.get(j))) { + if ((tFluids.get(i)).amount >= (tFluids.get(j)).amount) { + tFluids.remove(j--); + } else { + tFluids.remove(i--); + break; + } + } + } + } + + for (int i = 0; i < tItems.size() - 1; i++) { + for (int j = i + 1; j < tItems.size(); j++) { + if (GT_Utility.areStacksEqual(tItems.get(i), tItems.get(j))) { + if ((tItems.get(i)).stackSize >= (tItems.get(j)).stackSize) { + tItems.remove(j--); + } else { + tItems.remove(i--); + break; + } + } + } + } + + FluidStack[] inFluids = tFluids.toArray(new FluidStack[0]); + ItemStack[] inItems = tItems.toArray(new ItemStack[0]); + this.mEfficiency = 10000; + + long tPower = getMaxInputEnergy_EM(); + byte tTier = (byte) Math.max(1, GT_Utility.getTier(tPower)); + GT_Recipe recipe = tRecipes.findRecipe(this.getBaseMetaTileEntity(), false, V[tTier], inFluids, inItems); + if (recipe != null) { + if (recipe.mSpecialValue > Tier) return false; + if (recipe.isRecipeInputEqual(true, inFluids, inItems)){ + mEUt = recipe.mEUt * (1 << (Tier - recipe.mSpecialValue)); + mEUt = -Math.abs(mEUt); + mMaxProgresstime = recipe.mDuration / (1 << (Tier - recipe.mSpecialValue)); + this.mOutputFluids = recipe.mFluidOutputs; + this.updateSlots(); + return true; + } + } + return false; + } + + public final boolean addToFRFList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex){ + if (aTileEntity == null) { + return false; + } else { + IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) { + return false; + } else { + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch) { + ((GT_MetaTileEntity_Hatch)aMetaTileEntity).updateTexture(aBaseCasingIndex); + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) { + return this.mInputHatches.add((GT_MetaTileEntity_Hatch_Input)aMetaTileEntity); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) { + return this.mOutputHatches.add((GT_MetaTileEntity_Hatch_Output)aMetaTileEntity); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_InputBus) { + return this.mInputBusses.add((GT_MetaTileEntity_Hatch_InputBus)aMetaTileEntity); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) { + return this.mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy)aMetaTileEntity); + } else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) { + return this.eEnergyMulti.add((GT_MetaTileEntity_Hatch_EnergyMulti)aMetaTileEntity); + } else { + return false; + } + } + } + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new FuelRefineFactory(this.mName); + } + + @Override + public int getMaxEfficiency(ItemStack aStack) { + return 10000; + } + + @Override + public int getPollutionPerTick(ItemStack aStack) { + return 0; + } + + @Override + public int getDamageToComponent(ItemStack aStack) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack aStack) { + return true; + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + @Override + public String[] getInfoData() { + String[] infoData = new String[super.getInfoData().length + 1]; + System.arraycopy(super.getInfoData(),0,infoData,0, super.getInfoData().length); + infoData[super.getInfoData().length] = StatCollector.translateToLocal("scanner.info.FRF") + " " + this.Tier; + return infoData; + } + + @Override + @SuppressWarnings("ALL") + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + if(aSide == aFacing){ + if(aActive) return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(179), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE), TextureFactory.builder().addIcon(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE_GLOW).glow().build()}; + return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(179), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE), TextureFactory.builder().addIcon(Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_GLOW).glow().build()}; + } + return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(179)}; + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java b/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java new file mode 100644 index 0000000000..1ee64e26c4 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronAccelerator.java @@ -0,0 +1,66 @@ +package goodgenerator.blocks.tileEntity.GTMetaTileEntity; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy; +import net.minecraft.nbt.NBTTagCompound; + +import static gregtech.api.enums.GT_Values.V; + +public class NeutronAccelerator extends GT_MetaTileEntity_Hatch_Energy { + + public boolean isRunning; + + public NeutronAccelerator(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier); + } + + public NeutronAccelerator(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + public int getMaxEUConsume() { + return (int)(V[mTier] * 8 / 10); + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + this.isRunning = aNBT.getBoolean("isRunning"); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + aNBT.setBoolean("isRunning", this.isRunning); + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new NeutronAccelerator(mName, mTier, this.getDescription(), mTextures); + } + + @Override + public String[] getDescription() { + return new String[]{ + "Input EU to Accelerate the Neutron!", + "Max EU input: " + this.maxEUInput(), + "Max EU consumption: " + this.getMaxEUConsume(), + "Every EU can be transformed into 10~20 eV Neutron Kinetic Energy." + }; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (this.getBaseMetaTileEntity().isServerSide()) { + if (aBaseMetaTileEntity.getStoredEU() >= getMaxEUConsume() && aBaseMetaTileEntity.isAllowedToWork()) { + setEUVar(aBaseMetaTileEntity.getStoredEU() - getMaxEUConsume()); + isRunning = true; + } else { + isRunning = false; + } + } + super.onPostTick(aBaseMetaTileEntity, aTick); + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java b/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java new file mode 100644 index 0000000000..d69f0b75f8 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/GTMetaTileEntity/NeutronSensor.java @@ -0,0 +1,168 @@ +package goodgenerator.blocks.tileEntity.GTMetaTileEntity; + +import goodgenerator.client.GUI.NeutronSensorGUIClient; +import goodgenerator.common.container.NeutronSensorGUIContainer; +import goodgenerator.main.GoodGenerator; +import goodgenerator.network.MessageOpenNeutronSensorGUI; +import gregtech.api.enums.Textures; +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_Hatch; +import gregtech.api.render.TextureFactory; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; + +public class NeutronSensor extends GT_MetaTileEntity_Hatch { + + private static final IIconContainer textureFont = new Textures.BlockIcons.CustomIcon("icons/NeutronSensorFont"); + private static final IIconContainer textureFont_Glow = new Textures.BlockIcons.CustomIcon("icons/NeutronSensorFont_GLOW"); + + protected String texts = ""; + boolean isOn = false; + + public NeutronSensor(int aID, String aName, String aNameRegional, int aTier) { + super(aID, aName, aNameRegional, aTier, 0, "Detect Neutron Kinetic Energy."); + } + + public NeutronSensor(String aName, int aTier, String[] aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + } + + @Override + public String[] getDescription() { + return new String[]{ + "Can be installed in Neutron Activator.", + "Output Redstone Signal according to the Neutron Kinetic Energy.", + "Right click to open the GUI and setting." + }; + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + texts = aNBT.getString("mBoxContext"); + super.loadNBTData(aNBT); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setString("mBoxContext", texts); + super.saveNBTData(aNBT); + } + + @Override + public void initDefaultModes(NBTTagCompound aNBT) { + getBaseMetaTileEntity().setActive(true); + } + + @Override + public boolean isValidSlot(int aIndex) { + return false; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean isFacingValid(byte aFacing) { + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new NeutronSensorGUIClient(aPlayerInventory, aBaseMetaTileEntity, GoodGenerator.MOD_ID + ":textures/gui/NeutronSensorGUI.png", this.texts); + } + + @Override + public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new NeutronSensorGUIContainer(aPlayerInventory, aBaseMetaTileEntity); + } + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer, byte aSide, float aX, float aY, float aZ) { + if (aBaseMetaTileEntity.isClientSide()) return true; + if (aSide == aBaseMetaTileEntity.getFrontFacing() && aPlayer instanceof EntityPlayerMP) { + GoodGenerator.CHANNEL.sendTo(new MessageOpenNeutronSensorGUI(aBaseMetaTileEntity, texts), (EntityPlayerMP) aPlayer); + return true; + } + return false; + } + + public void setText(String text) { + texts = text == null ? "" : text; + } + + public String getText() { + return texts == null ? "" : texts; + } + + public void outputRedstoneSignal(){ + isOn = true; + } + + public void stopOutputRedstoneSignal(){ + isOn = false; + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { + aBaseTexture, + TextureFactory.of(textureFont), + TextureFactory.builder().addIcon(textureFont_Glow).glow