diff options
Diffstat (limited to 'src/main/java/goodgenerator/blocks')
10 files changed, 2230 insertions, 91 deletions
diff --git a/src/main/java/goodgenerator/blocks/regularBlock/ITextureBlock.java b/src/main/java/goodgenerator/blocks/regularBlock/ITextureBlock.java index d889c0f69c..eba7c2c890 100644 --- a/src/main/java/goodgenerator/blocks/regularBlock/ITextureBlock.java +++ b/src/main/java/goodgenerator/blocks/regularBlock/ITextureBlock.java @@ -6,8 +6,12 @@ import net.minecraft.world.IBlockAccess; public interface ITextureBlock { - ITexture[] getTexture(Block aBlock, byte aSide); + default ITexture[] getTexture(Block aBlock, byte aSide) { + return getTexture(aBlock, 0, aSide); + } ITexture[] getTexture(Block aBlock, byte aSide, IBlockAccess aWorld, int xCoord, int yCoord, int zCoord); + ITexture[] getTexture(Block aBlock, int aMeta, byte aSide); + } diff --git a/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java b/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java index f0fc14f28f..6fd25af048 100644 --- a/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java +++ b/src/main/java/goodgenerator/blocks/regularBlock/TurbineCasing.java @@ -48,13 +48,6 @@ public class TurbineCasing extends Casing implements ITextureBlock{ } @Override - public ITexture[] getTexture(Block aBlock, byte aSide) { - return new ITexture[] { - TextureFactory.of(base) - }; - } - - @Override public ITexture[] getTexture(Block aBlock, byte aSide, IBlockAccess aWorld, int xCoord, int yCoord, int zCoord) { int tInvertLeftRightMod = aSide % 2 * 2 - 1; switch (aSide / 2) { @@ -99,6 +92,13 @@ public class TurbineCasing extends Casing implements ITextureBlock{ } @Override + public ITexture[] getTexture(Block aBlock, int aMeta, byte aSide) { + return new ITexture[] { + TextureFactory.of(base) + }; + } + + @Override public int getRenderType() { if (BlockRenderHandler.INSTANCE == null) { return super.getRenderType(); diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer.java deleted file mode 100644 index 807e0af620..0000000000 --- a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer.java +++ /dev/null @@ -1,83 +0,0 @@ -package goodgenerator.blocks.tileEntity; - -import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM; -import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable; -import com.gtnewhorizon.structurelib.structure.IStructureDefinition; -import gregtech.api.interfaces.metatileentity.IMetaTileEntity; -import gregtech.api.interfaces.tileentity.IGregTechTileEntity; -import gregtech.api.objects.GT_ChunkManager; -import net.minecraft.item.ItemStack; -import net.minecraft.tileentity.TileEntity; -import net.minecraft.world.ChunkCoordIntPair; - -public class LargeFusionComputer extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable { - - private boolean isLoadedChunk; - - public LargeFusionComputer(String name) { - super(name); - } - - @Override - public IStructureDefinition<? extends GT_MetaTileEntity_MultiblockBase_EM> getStructure_EM() { - return null; - } - - public LargeFusionComputer(int id, String name, String nameRegional) { - super(id,name,nameRegional); - } - - @Override - public void construct(ItemStack itemStack, boolean b) { - - } - - @Override - public String[] getStructureDescription(ItemStack itemStack) { - return new String[0]; - } - - @Override - public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { - return null; - } - - @Override - public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { - super.onPostTick(aBaseMetaTileEntity, aTick); - if (aBaseMetaTileEntity.isServerSide() && !aBaseMetaTileEntity.isAllowedToWork()) { - // if machine has stopped, stop chunkloading - GT_ChunkManager.releaseTicket((TileEntity)aBaseMetaTileEntity); - this.isLoadedChunk = false; - } - else if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isAllowedToWork() && !this.isLoadedChunk) { - //load a 3x3 area when machine is running - GT_ChunkManager.releaseTicket((TileEntity)aBaseMetaTileEntity); - GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + 1, getChunkZ() + 1)); - GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + 1, getChunkZ())); - GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + 1, getChunkZ() - 1)); - GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() - 1, getChunkZ() + 1)); - GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() - 1, getChunkZ())); - GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() - 1, getChunkZ() - 1)); - GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX(), getChunkZ() + 1)); - GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX(), getChunkZ() - 1)); - this.isLoadedChunk = true; - } - } - - @Override - public void onRemoval() { - if (this.isLoadedChunk) - GT_ChunkManager.releaseTicket((TileEntity)getBaseMetaTileEntity()); - super.onRemoval(); - } - - public int getChunkX() { - return getBaseMetaTileEntity().getXCoord() >> 4; - } - - public int getChunkZ() { - return getBaseMetaTileEntity().getZCoord() >> 4; - } - -} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java new file mode 100644 index 0000000000..805bfd73e7 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer1.java @@ -0,0 +1,143 @@ +package goodgenerator.blocks.tileEntity; + +import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry; +import goodgenerator.blocks.tileEntity.base.LargeFusionComputer; +import goodgenerator.loader.Loaders; +import goodgenerator.util.DescTextLocalization; +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import org.lwjgl.input.Keyboard; + +import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION1; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION1_GLOW; + +public class LargeFusionComputer1 extends LargeFusionComputer { + + private static final ITexture textureOverlay = TextureFactory.of( + TextureFactory.builder().addIcon(OVERLAY_FUSION1).extFacing().build(), + TextureFactory.builder().addIcon(OVERLAY_FUSION1_GLOW).extFacing().glow().build()); + + public LargeFusionComputer1(int id, String name, String nameRegional) { + super(id,name,nameRegional); + } + + public LargeFusionComputer1(String name) { + super(name); + } + + @Override + public String[] getDescription() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Fusion Reactor") + .addInfo("Millions of nuclear.") + .addInfo("Controller block for the Compact Fusion Reactor MK-I Prototype.") + .addInfo("131,072EU/t and 5M EU capacity per Energy Hatch") + .addInfo("If the recipe has a startup cost greater than the") + .addInfo("number of energy hatches * cap, you can't do it") + .addInfo("Make sure the whole structure is built in the 3x3") + .addInfo("chuck area of the ring center (not controller).") + .addInfo("It can run 64x recipes at most.") + .addInfo("Support" + EnumChatFormatting.BLUE + " Tec" + EnumChatFormatting.DARK_BLUE + "Tech" + EnumChatFormatting.GRAY + " Energy/Laser Hatches!") + .addInfo("The structure is too complex!") + .addInfo(BLUE_PRINT_INFO) + .addSeparator() + .addCasingInfo("LuV Machine Casing", 1666) + .addCasingInfo("Ameliorated Superconduct Coil", 558) + .addCasingInfo("Naquadah Alloy Frame Boxes", 128) + .addCasingInfo("Chrome Reinforced Borosilicate Glass Block", 63) + .addEnergyHatch("1-32, Hint block with dot 3", 3) + .addInputHatch("2-16, Hint block with dot 1", 1) + .addOutputHatch("1-16, Hint block with dot 2", 2) + .addStructureInfo("ALL Hatches must be LuV or better") + .toolTipFinisher("Good Generator"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } + } + + @Override + public long maxEUStore() { + return 160008000L * (Math.min(32, this.mEnergyHatches.size() + this.eEnergyMulti.size())) / 32L; + } + + @Override + public Block getCasingBlock() { + return GregTech_API.sBlockCasings1; + } + + @Override + public int getCasingMeta() { + return 6; + } + + @Override + public Block getCoilBlock() { + return Loaders.compactFusionCoil; + } + + @Override + public int getCoilMeta() { + return 0; + } + + @Override + public Block getGlassBlock() { + return ItemRegistry.bw_realglas; + } + + @Override + public int getGlassMeta() { + return 3; + } + + @Override + public int hatchTier() { + return 6; + } + + @Override + public Materials getFrameBox() { + return Materials.NaquadahAlloy; + } + + @Override + public int getMaxPara() { + return 64; + } + + @Override + public int extraPara(int startEnergy) { + return 1; + } + + @Override + public ITexture getTextureOverlay() { + return textureOverlay; + } + + @Override + public int tierOverclock() { + return 1; + } + + @Override + public String[] getStructureDescription(ItemStack stackSize) { + return DescTextLocalization.addText("LargeFusion1.hint", 9); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new LargeFusionComputer1(mName); + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer2.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer2.java new file mode 100644 index 0000000000..a1dad85531 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer2.java @@ -0,0 +1,144 @@ +package goodgenerator.blocks.tileEntity; + +import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry; +import goodgenerator.blocks.tileEntity.base.LargeFusionComputer; +import goodgenerator.loader.Loaders; +import goodgenerator.util.DescTextLocalization; +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import org.lwjgl.input.Keyboard; + +import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION2; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION2_GLOW; + +public class LargeFusionComputer2 extends LargeFusionComputer { + + private static final ITexture textureOverlay = TextureFactory.of( + TextureFactory.builder().addIcon(OVERLAY_FUSION2).extFacing().build(), + TextureFactory.builder().addIcon(OVERLAY_FUSION2_GLOW).extFacing().glow().build()); + + public LargeFusionComputer2(int id, String name, String nameRegional) { + super(id,name,nameRegional); + } + + public LargeFusionComputer2(String name) { + super(name); + } + + @Override + public String[] getDescription() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Fusion Reactor") + .addInfo("Millions of nuclear.") + .addInfo("Controller block for the Compact Fusion Reactor MK-II.") + .addInfo("524,288EU/t and 10M EU capacity per Energy Hatch") + .addInfo("If the recipe has a startup cost greater than the") + .addInfo("number of energy hatches * cap, you can't do it") + .addInfo("Make sure the whole structure is built in the 3x3") + .addInfo("chuck area of the ring center (not controller).") + .addInfo("Startup < 160,000,000 EU: 128x Parallel") + .addInfo("Startup < 320,000,000 EU: 64x Parallel") + .addInfo("Support" + EnumChatFormatting.BLUE + " Tec" + EnumChatFormatting.DARK_BLUE + "Tech" + EnumChatFormatting.GRAY + " Energy/Laser Hatches!") + .addInfo("The structure is too complex!") + .addInfo(BLUE_PRINT_INFO) + .addSeparator() + .addCasingInfo("Fusion Machine Casing", 1666) + .addCasingInfo("Compact Fusion Coil", 558) + .addCasingInfo("Duranium Frame Box", 128) + .addCasingInfo("Iridium Reinforced Borosilicate Glass Block", 63) + .addEnergyHatch("1-32, Hint block with dot 3", 3) + .addInputHatch("2-16, Hint block with dot 1", 1) + .addOutputHatch("1-16, Hint block with dot 2", 2) + .addStructureInfo("ALL Hatches must be ZPM or better") + .toolTipFinisher("Good Generator"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } + } + + @Override + public long maxEUStore() { + return 320006000L * (Math.min(32, this.mEnergyHatches.size() + this.eEnergyMulti.size())) / 32L; + } + + @Override + public Block getCasingBlock() { + return GregTech_API.sBlockCasings4; + } + + @Override + public int getCasingMeta() { + return 6; + } + + @Override + public Block getCoilBlock() { + return Loaders.compactFusionCoil; + } + + @Override + public int getCoilMeta() { + return 1; + } + + @Override + public Block getGlassBlock() { + return ItemRegistry.bw_realglas; + } + + @Override + public int getGlassMeta() { + return 4; + } + + @Override + public int hatchTier() { + return 7; + } + + @Override + public Materials getFrameBox() { + return Materials.Duranium; + } + + @Override + public int getMaxPara() { + return 64; + } + + @Override + public int extraPara(int startEnergy) { + return startEnergy < 160000000 ? 2 : 1; + } + + @Override + public ITexture getTextureOverlay() { + return textureOverlay; + } + + @Override + public int tierOverclock() { + return 2; + } + + @Override + public String[] getStructureDescription(ItemStack stackSize) { + return DescTextLocalization.addText("LargeFusion2.hint", 9); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new LargeFusionComputer2(mName); + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer3.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer3.java new file mode 100644 index 0000000000..30e141bece --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer3.java @@ -0,0 +1,145 @@ +package goodgenerator.blocks.tileEntity; + +import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry; +import goodgenerator.blocks.tileEntity.base.LargeFusionComputer; +import goodgenerator.loader.Loaders; +import goodgenerator.util.DescTextLocalization; +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import org.lwjgl.input.Keyboard; + +import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION3; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FUSION3_GLOW; + +public class LargeFusionComputer3 extends LargeFusionComputer { + + private static final ITexture textureOverlay = TextureFactory.of( + TextureFactory.builder().addIcon(OVERLAY_FUSION3).extFacing().build(), + TextureFactory.builder().addIcon(OVERLAY_FUSION3_GLOW).extFacing().glow().build()); + + public LargeFusionComputer3(int id, String name, String nameRegional) { + super(id,name,nameRegional); + } + + public LargeFusionComputer3(String name) { + super(name); + } + + @Override + public String[] getDescription() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Fusion Reactor") + .addInfo("Millions of nuclear.") + .addInfo("Controller block for the Compact Fusion Reactor MK-III.") + .addInfo("1,572,864EU/t and 20M EU capacity per Energy Hatch") + .addInfo("If the recipe has a startup cost greater than the") + .addInfo("number of energy hatches * cap, you can't do it") + .addInfo("Make sure the whole structure is built in the 3x3") + .addInfo("chuck area of the ring center (not controller).") + .addInfo("Startup < 160,000,000 EU: 192x Parallel") + .addInfo("Startup < 320,000,000 EU: 128x Parallel") + .addInfo("Startup < 640,000,000 EU: 64x Parallel") + .addInfo("Support" + EnumChatFormatting.BLUE + " Tec" + EnumChatFormatting.DARK_BLUE + "Tech" + EnumChatFormatting.GRAY + " Energy/Laser Hatches!") + .addInfo("The structure is too complex!") + .addInfo(BLUE_PRINT_INFO) + .addSeparator() + .addCasingInfo("Fusion Machine Casing MK II", 1666) + .addCasingInfo("Advanced Compact Fusion Coil", 558) + .addCasingInfo("Neutronium Frame Box", 128) + .addCasingInfo("Osmium Reinforced Borosilicate Glass Block", 63) + .addEnergyHatch("1-32, Hint block with dot 3", 3) + .addInputHatch("2-16, Hint block with dot 1", 1) + .addOutputHatch("1-16, Hint block with dot 2", 2) + .addStructureInfo("ALL Hatches must be UV or better") + .toolTipFinisher("Good Generator"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } + } + + @Override + public long maxEUStore() { + return 640060000L * (Math.min(32, this.mEnergyHatches.size() + this.eEnergyMulti.size())) / 32L; + } + + @Override + public Block getCasingBlock() { + return GregTech_API.sBlockCasings4; + } + + @Override + public int getCasingMeta() { + return 8; + } + + @Override + public Block getCoilBlock() { + return Loaders.compactFusionCoil; + } + + @Override + public int getCoilMeta() { + return 2; + } + + @Override + public Block getGlassBlock() { + return ItemRegistry.bw_realglas; + } + + @Override + public int getGlassMeta() { + return 5; + } + + @Override + public int hatchTier() { + return 8; + } + + @Override + public Materials getFrameBox() { + return Materials.Neutronium; + } + + @Override + public int getMaxPara() { + return 64; + } + + @Override + public int extraPara(int startEnergy) { + return (startEnergy < 160000000 ? 3 : (startEnergy < 320000000 ? 2 : 1)); + } + + @Override + public ITexture getTextureOverlay() { + return textureOverlay; + } + + @Override + public int tierOverclock() { + return 4; + } + + @Override + public String[] getStructureDescription(ItemStack stackSize) { + return DescTextLocalization.addText("LargeFusion3.hint", 9); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new LargeFusionComputer3(mName); + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java new file mode 100644 index 0000000000..76ff59d65d --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer4.java @@ -0,0 +1,216 @@ +package goodgenerator.blocks.tileEntity; + +import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti; +import goodgenerator.blocks.tileEntity.base.LargeFusionComputerPP; +import goodgenerator.loader.Loaders; +import goodgenerator.util.DescTextLocalization; +import gregtech.api.enums.Materials; +import gregtech.api.enums.TAE; +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_Hatch_Energy; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gtPlusPlus.core.block.ModBlocks; +import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import org.lwjgl.input.Keyboard; + +import java.lang.reflect.Field; + +import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO; +import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS; + +public class LargeFusionComputer4 extends LargeFusionComputerPP { + + public LargeFusionComputer4(int id, String name, String nameRegional) { + super(id,name,nameRegional); + } + + public LargeFusionComputer4(String name) { + super(name); + } + + //Some hacky shit + public static Block mMK4Casing = null; + public static int mMK4CasingMeta; + + @Override + public String[] getDescription() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Fusion Reactor") + .addInfo("Galaxy Collapse.") + .addInfo("Controller block for the Compact Fusion Reactor MK-IV Prototype.") + .addInfo("33,554,432EU/t and 80M EU capacity per Energy Hatch") + .addInfo("If the recipe has a startup cost greater than the") + .addInfo("number of energy hatches * cap, you can't do it") + .addInfo("Make sure the whole structure is built in the 3x3") + .addInfo("chuck area of the ring center (not controller).") + .addInfo("Performs 4/4 overclock.") + .addInfo("Startup < 160,000,000 EU: 256x Parallel") + .addInfo("Startup < 320,000,000 EU: 192x Parallel") + .addInfo("Startup < 640,000,000 EU: 128x Parallel") + .addInfo("Startup < 1,200,000,000 EU: 64x Parallel") + .addInfo("Support" + EnumChatFormatting.BLUE + " Tec" + EnumChatFormatting.DARK_BLUE + "Tech" + EnumChatFormatting.GRAY + " Energy/Laser Hatches!") + .addInfo("The structure is too complex!") + .addInfo(BLUE_PRINT_INFO) + .addSeparator() + .addCasingInfo("Fusion Machine Casing MK III", 1666) + .addCasingInfo("Compact Fusion Coil MK-II Prototype", 558) + .addCasingInfo("Infinity Catalyst Frame Box", 128) + .addCasingInfo("Uranium Reinforced Borosilicate Glass Block", 63) + .addEnergyHatch("1-32, Hint block with dot 3", 3) + .addInputHatch("2-16, Hint block with dot 1", 1) + .addOutputHatch("1-16, Hint block with dot 2", 2) + .addStructureInfo("ALL Hatches must be UHV or better") + .toolTipFinisher("Good Generator"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } + } + + @Override + public long maxEUStore() { + return 2560060000L * (Math.min(32, this.mEnergyHatches.size() + this.eEnergyMulti.size())) / 32L; + } + + @Override + public Block getCasingBlock() { + if (mMK4Casing == null) + doCasingInit(); + return mMK4Casing; + } + + @Override + public int getCasingMeta() { + if (mMK4Casing == null) + doCasingInit(); + return mMK4CasingMeta; + } + + private void doCasingInit() { + try { + Field f = ModBlocks.class.getDeclaredField("blockCasings6Misc"); + mMK4Casing = (Block) f.get(null); + mMK4CasingMeta = 0; + } catch (NoSuchFieldException | IllegalAccessException e) { + mMK4Casing = ModBlocks.blockCasings3Misc; + mMK4CasingMeta = 12; + } + } + + @Override + public Block getCoilBlock() { + return Loaders.compactFusionCoil; + } + + @Override + public int getCoilMeta() { + return 3; + } + + @Override + public Block getGlassBlock() { + return ItemRegistry.bw_realglas; + } + + @Override + public int getGlassMeta() { + return 13; + } + + @Override + public int hatchTier() { + return 9; + } + + @Override + public Materials getFrameBox() { + return Materials.InfinityCatalyst; + } + + @Override + public ITexture getTextureOverlay() { + if (this.mMaxProgresstime > 0) + return TextureFactory.of(TextureFactory.builder().addIcon(TexturesGtBlock.Casing_Machine_Screen_3).extFacing().build()); + else + return TextureFactory.of(TextureFactory.builder().addIcon(TexturesGtBlock.Casing_Machine_Screen_1).extFacing().build()); + } + + @Override + public int getMaxPara() { + return 64; + } + + @Override + public int tierOverclock() { + return 64; + } + + @Override + public int overclock(int mStartEnergy) { + return (mStartEnergy < 160000000) ? 64 : ((mStartEnergy < 320000000) ? 16 : (mStartEnergy < 640000000) ? 4 : 1); + } + + @Override + public int extraPara(int startEnergy) { + if (startEnergy < 160000000) + return 4; + if (startEnergy < 320000000) + return 3; + if (startEnergy < 640000000) + return 2; + return 1; + } + + @Override + public String[] getStructureDescription(ItemStack stackSize) { + return DescTextLocalization.addText("LargeFusion4.hint", 9); + } + + @Override + public boolean turnCasingActive(boolean status) { + if (this.mEnergyHatches != null) { + for (GT_MetaTileEntity_Hatch_Energy hatch : this.mEnergyHatches) { + hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53); + } + } + if (this.eEnergyMulti != null) { + for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : this.eEnergyMulti) { + hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53); + } + } + if (this.mOutputHatches != null) { + for (GT_MetaTileEntity_Hatch_Output hatch : this.mOutputHatches) { + hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53); + } + } + if (this.mInputHatches != null) { + for (GT_MetaTileEntity_Hatch_Input hatch : this.mInputHatches) { + hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53); + } + } + return true; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + if (aSide == aFacing) return new ITexture[]{TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS).extFacing().build(), getTextureOverlay()}; + if (!aActive) return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(52)}; + return new ITexture[]{TextureFactory.builder().addIcon(TexturesGtBlock.TEXTURE_CASING_FUSION_CASING_ULTRA).extFacing().build()}; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new LargeFusionComputer4(mName); + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java new file mode 100644 index 0000000000..c26a0f2477 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/LargeFusionComputer5.java @@ -0,0 +1,198 @@ +package goodgenerator.blocks.tileEntity; + +import com.github.bartimaeusnek.bartworks.common.loaders.ItemRegistry; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti; +import goodgenerator.blocks.tileEntity.base.LargeFusionComputerPP; +import goodgenerator.loader.Loaders; +import goodgenerator.util.DescTextLocalization; +import gregtech.api.enums.Materials; +import gregtech.api.enums.TAE; +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_Hatch_Energy; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gtPlusPlus.core.block.ModBlocks; +import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumChatFormatting; +import org.lwjgl.input.Keyboard; + +import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO; +import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS; + +public class LargeFusionComputer5 extends LargeFusionComputerPP { + + public LargeFusionComputer5(int id, String name, String nameRegional) { + super(id,name,nameRegional); + } + + public LargeFusionComputer5(String name) { + super(name); + } + + @Override + public String[] getDescription() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Fusion Reactor") + .addInfo("Galaxy Collapse.") + .addInfo("Controller block for the Compact Fusion Reactor MK-V.") + .addInfo("167,772,160EU/t and 320M EU capacity per Energy Hatch") + .addInfo("If the recipe has a startup cost greater than the") + .addInfo("number of energy hatches * cap, you can't do it") + .addInfo("Make sure the whole structure is built in the 3x3") + .addInfo("chuck area of the ring center (not controller).") + .addInfo("Performs 4/4 overclock.") + .addInfo("Startup < 160,000,000 EU: 320x Parallel") + .addInfo("Startup < 320,000,000 EU: 256x Parallel") + .addInfo("Startup < 640,000,000 EU: 192x Parallel") + .addInfo("Startup < 1,200,000,000 EU: 128x Parallel") + .addInfo("Startup < 2,000,000,000 EU: 64x Parallel") + .addInfo("Support" + EnumChatFormatting.BLUE + " Tec" + EnumChatFormatting.DARK_BLUE + "Tech" + EnumChatFormatting.GRAY + " Energy/Laser Hatches!") + .addInfo("The structure is too complex!") + .addInfo(BLUE_PRINT_INFO) + .addSeparator() + .addCasingInfo("Fusion Machine Casing MK IV", 1666) + .addCasingInfo("Compact Fusion Coil MK-II Finaltype", 558) + .addCasingInfo("Infinity Frame Box", 128) + .addCasingInfo("Europium Reinforced Borosilicate Glass Block", 63) + .addEnergyHatch("1-32, Hint block with dot 3", 3) + .addInputHatch("2-16, Hint block with dot 1", 1) + .addOutputHatch("1-16, Hint block with dot 2", 2) + .addStructureInfo("ALL Hatches must be UEV or better") + .toolTipFinisher("Good Generator"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } + } + + @Override + public long maxEUStore() { + return 10240800000L * (Math.min(32, this.mEnergyHatches.size() + this.eEnergyMulti.size())) / 32L; + } + + @Override + public Block getCasingBlock() { + return ModBlocks.blockCasings3Misc; + } + + @Override + public int getCasingMeta() { + return 12; + } + + @Override + public Block getCoilBlock() { + return Loaders.compactFusionCoil; + } + + @Override + public int getCoilMeta() { + return 4; + } + + @Override + public Block getGlassBlock() { + return ItemRegistry.bw_realglas; + } + + @Override + public int getGlassMeta() { + return 14; + } + + @Override + public int hatchTier() { + return 10; + } + + @Override + public Materials getFrameBox() { + return Materials.Infinity; + } + + @Override + public ITexture getTextureOverlay() { + if (this.mMaxProgresstime > 0) + return TextureFactory.of(TextureFactory.builder().addIcon(TexturesGtBlock.Casing_Machine_Screen_3).extFacing().build()); + else + return TextureFactory.of(TextureFactory.builder().addIcon(TexturesGtBlock.Casing_Machine_Screen_1).extFacing().build()); + } + + @Override + public int getMaxPara() { + return 64; + } + + @Override + public int tierOverclock() { + return 256; + } + + @Override + public int overclock(int mStartEnergy) { + return (mStartEnergy < 160000000) ? 256 : ((mStartEnergy < 320000000) ? 64 : ((mStartEnergy < 640000000) ? 16 : ((mStartEnergy < 1200000000) ? 4 : 1))); + } + + @Override + public int extraPara(int startEnergy) { + if (startEnergy < 160000000) + return 5; + if (startEnergy < 320000000) + return 4; + if (startEnergy < 640000000) + return 3; + if (startEnergy < 1200000000) + return 2; + return 1; + } + + @Override + public String[] getStructureDescription(ItemStack stackSize) { + return DescTextLocalization.addText("LargeFusion5.hint", 9); + } + + @Override + public boolean turnCasingActive(boolean status) { + if (this.mEnergyHatches != null) { + for (GT_MetaTileEntity_Hatch_Energy hatch : this.mEnergyHatches) { + hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53); + } + } + if (this.eEnergyMulti != null) { + for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : this.eEnergyMulti) { + hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53); + } + } + if (this.mOutputHatches != null) { + for (GT_MetaTileEntity_Hatch_Output hatch : this.mOutputHatches) { + hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53); + } + } + if (this.mInputHatches != null) { + for (GT_MetaTileEntity_Hatch_Input hatch : this.mInputHatches) { + hatch.updateTexture(status ? TAE.getIndexFromPage(2, 14) : 53); + } + } + return true; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + if (aSide == aFacing) return new ITexture[]{TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS).extFacing().build(), getTextureOverlay()}; + if (!aActive) return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(52)}; + return new ITexture[]{TextureFactory.builder().addIcon(TexturesGtBlock.TEXTURE_CASING_FUSION_CASING_ULTRA).extFacing().build()}; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new LargeFusionComputer5(mName); + } +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java b/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java new file mode 100644 index 0000000000..7de1215597 --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputer.java @@ -0,0 +1,693 @@ +package goodgenerator.blocks.tileEntity.base; + +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti; +import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM; +import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; +import goodgenerator.client.GUI.LargeFusionComputerGUIClient; +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_Hatch_Energy; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output; +import gregtech.api.objects.GT_ChunkManager; +import gregtech.api.objects.GT_ItemStack; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import net.minecraft.block.Block; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraft.world.ChunkCoordIntPair; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; + +import java.util.ArrayList; + +import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.getMultiOutput; +import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.handleParallelRecipe; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.*; +import static gregtech.api.enums.Textures.BlockIcons.*; +import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS; +import static gregtech.api.util.GT_StructureUtility.ofFrame; +import static gregtech.api.util.GT_StructureUtility.ofHatchAdderOptional; + +public abstract class LargeFusionComputer extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable { + + public static final String MAIN_NAME = "largeFusion"; + private boolean isLoadedChunk; + public GT_Recipe mLastRecipe; + public int para; + public int mEUStore; + private static final ClassValue<IStructureDefinition<LargeFusionComputer>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<LargeFusionComputer>>() { + @Override + protected IStructureDefinition<LargeFusionComputer> computeValue(Class<?> type) { + return StructureDefinition.<LargeFusionComputer>builder() + .addShape(MAIN_NAME, transpose(new String[][]{ + L0, L1, L2, L3, L2, L1, L0 + })) + .addElement( + 'H', lazy(x -> ofBlock(x.getCoilBlock(), x.getCoilMeta())) + ) + .addElement( + 'C', lazy(x -> ofBlock(x.getCasingBlock(), x.getCasingMeta())) + ) + .addElement( + 'B', lazy(x -> ofBlock(x.getGlassBlock(), x.getGlassMeta())) + ) + .addElement( + 'I', lazy(x -> ofHatchAdderOptional(LargeFusionComputer::addInjector, x.textureIndex(), 1, x.getGlassBlock(), x.getGlassMeta())) + ) + .addElement( + 'O', lazy(x -> ofHatchAdderOptional(LargeFusionComputer::addExtractor, x.textureIndex(), 2, x.getGlassBlock(), x.getGlassMeta())) + ) + .addElement( + 'E', lazy(x -> ofHatchAdderOptional(LargeFusionComputer::addEnergyInjector, x.textureIndex(), 3, x.getCasingBlock(), x.getCasingMeta())) + ) + .addElement( + 'F', lazy(x -> ofFrame(x.getFrameBox())) + ) + .build(); + } + }; + + static { + Textures.BlockIcons.setCasingTextureForId(52, + TextureFactory.of( + TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW).extFacing().build(), + TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW).extFacing().glow().build() + )); + } + + public LargeFusionComputer(String name) { + super(name); + } + + public LargeFusionComputer(int id, String name, String nameRegional) { + super(id,name,nameRegional); + } + + @Override + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new LargeFusionComputerGUIClient(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "EMDisplay.png"); + } + + @Override + public abstract long maxEUStore(); + + public abstract Block getCasingBlock(); + + public abstract int getCasingMeta(); + + public abstract Block getCoilBlock(); + + public abstract int getCoilMeta(); + + public abstract Block getGlassBlock(); + + public abstract int getGlassMeta(); + + public abstract int hatchTier(); + + public abstract Materials getFrameBox(); + + public abstract int getMaxPara(); + + public abstract int extraPara(int startEnergy); + + public int textureIndex() { + return 53; + }; + + public abstract ITexture getTextureOverlay(); + + @Override + public boolean allowCoverOnSide(byte aSide, GT_ItemStack aStack) { + return aSide != getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + this.eEnergyMulti.clear(); + if (structureCheck_EM(MAIN_NAME, 23, 3, 40) && mInputHatches.size() > 1 && !mOutputHatches.isEmpty() && (mEnergyHatches.size() + eEnergyMulti.size()) != 0) { + fixAllIssue(); + return true; + } + return false; + } + + public void fixAllIssue() { + mWrench = true; + mScrewdriver = true; + mSoftHammer = true; + mHardHammer = true; + mSolderingTool = true; + mCrowbar = true; + } + + @Override + public void construct(ItemStack itemStack, boolean b) { + structureBuild_EM(MAIN_NAME, 23, 3, 40, itemStack, b); + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide() && !aBaseMetaTileEntity.isAllowedToWork()) { + // if machine has stopped, stop chunkloading + GT_ChunkManager.releaseTicket((TileEntity)aBaseMetaTileEntity); + this.isLoadedChunk = false; + } + else if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isAllowedToWork() && !this.isLoadedChunk) { + //load a 3x3 area when machine is running + GT_ChunkManager.releaseTicket((TileEntity)aBaseMetaTileEntity); + int offX = ForgeDirection.getOrientation(aBaseMetaTileEntity.getFrontFacing()).offsetX; + int offZ = ForgeDirection.getOrientation(aBaseMetaTileEntity.getFrontFacing()).offsetZ; + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() + 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() - 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() + 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() - 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() + 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() - 1 + offZ)); + this.isLoadedChunk = true; + } + + if (aBaseMetaTileEntity.isServerSide()) { + if (aTick % 400 == 0) fixAllIssue(); + if (mEfficiency < 0) + mEfficiency = 0; + if (mRunningOnLoad && checkMachine(aBaseMetaTileEntity, mInventory[1])) { + this.mEUStore = (int) aBaseMetaTileEntity.getStoredEU(); + checkRecipe(mInventory[1]); + } + if (--mUpdate == 0 || --mStartUpCheck == 0) { + checkStructure(true, aBaseMetaTileEntity); + } + if (mStartUpCheck < 0) { + if (mMachine) { + if (this.mEnergyHatches != null) { + for (GT_MetaTileEntity_Hatch_Energy tHatch : mEnergyHatches) + if (isValidMetaTileEntity(tHatch)) { + if (aBaseMetaTileEntity.getStoredEU() + (2048L * tierOverclock() * getMaxPara() * extraPara(100)) < maxEUStore() + && tHatch.getBaseMetaTileEntity().decreaseStoredEnergyUnits(2048L * tierOverclock() * getMaxPara() * extraPara(100), false)) { + aBaseMetaTileEntity.increaseStoredEnergyUnits(2048L * tierOverclock() * getMaxPara() * extraPara(100), true); + } else if (aBaseMetaTileEntity.getStoredEU() + (2048L * tierOverclock()) < maxEUStore() + && tHatch.getBaseMetaTileEntity().decreaseStoredEnergyUnits(2048L * tierOverclock(), false)) { + aBaseMetaTileEntity.increaseStoredEnergyUnits(2048L * tierOverclock(), true); + } + } + } + if (this.eEnergyMulti != null) { + for (GT_MetaTileEntity_Hatch_EnergyMulti tHatch : eEnergyMulti) + if (isValidMetaTileEntity(tHatch)) { + if (aBaseMetaTileEntity.getStoredEU() + (2048L * tierOverclock() * getMaxPara() * extraPara(100)) < maxEUStore() + && tHatch.getBaseMetaTileEntity().decreaseStoredEnergyUnits(2048L * tierOverclock() * getMaxPara() * extraPara(100), false)) { + aBaseMetaTileEntity.increaseStoredEnergyUnits(2048L * tierOverclock() * getMaxPara() * extraPara(100), true); + } else if (aBaseMetaTileEntity.getStoredEU() + (2048L * tierOverclock()) < maxEUStore() + && tHatch.getBaseMetaTileEntity().decreaseStoredEnergyUnits(2048L * tierOverclock(), false)) { + aBaseMetaTileEntity.increaseStoredEnergyUnits(2048L * tierOverclock(), true); + } + } + } + if (this.mEUStore <= 0 && mMaxProgresstime > 0) { + stopMachine(); + } + if (mMaxProgresstime > 0) { + this.getBaseMetaTileEntity().decreaseStoredEnergyUnits(mEUt, true); + if (mMaxProgresstime > 0 && ++mProgresstime >= mMaxProgresstime) { + if (mOutputItems != null) + for (ItemStack tStack : mOutputItems) if (tStack != null) addOutput(tStack); + if (mOutputFluids != null) + for (FluidStack tStack : mOutputFluids) if (tStack != null) addOutput(tStack); + mEfficiency = Math.max(0, Math.min(mEfficiency + mEfficiencyIncrease, getMaxEfficiency(mInventory[1]))); + mOutputItems = null; + mProgresstime = 0; + mMaxProgresstime = 0; + mEfficiencyIncrease = 0; + this.mEUStore = (int) getBaseMetaTileEntity().getStoredEU(); + if (aBaseMetaTileEntity.isAllowedToWork()) + checkRecipe(mInventory[1]); + } + } else { + if (aTick % 100 == 0 || aBaseMetaTileEntity.hasWorkJustBeenEnabled() || aBaseMetaTileEntity.hasInventoryBeenModified()) { + turnCasingActive(mMaxProgresstime > 0); + if (aBaseMetaTileEntity.isAllowedToWork()) { + this.mEUStore = (int) getBaseMetaTileEntity().getStoredEU(); + if (checkRecipe(mInventory[1])) { + if (this.mEUStore < this.mLastRecipe.mSpecialValue - this.mEUt) { + mMaxProgresstime = 0; + turnCasingActive(false); + } + getBaseMetaTileEntity().decreaseStoredEnergyUnits(this.mLastRecipe.mSpecialValue - this.mEUt, false); + } + } + if (mMaxProgresstime <= 0) + mEfficiency = Math.max(0, mEfficiency - 1000); + } + } + } else { + turnCasingActive(false); + this.mLastRecipe = null; + stopMachine(); + } + } + aBaseMetaTileEntity.setErrorDisplayID((aBaseMetaTileEntity.getErrorDisplayID() & ~127) | (mMachine ? 0 : 64)); + aBaseMetaTileEntity.setActive(mMaxProgresstime > 0); + } + } + + public boolean turnCasingActive(boolean status) { + if (this.mEnergyHatches != null) { + for (GT_MetaTileEntity_Hatch_Energy hatch : this.mEnergyHatches) { + hatch.updateTexture(status ? 52 : 53); + } + } + if (this.eEnergyMulti != null) { + for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : this.eEnergyMulti) { + hatch.updateTexture(status ? 52 : 53); + } + } + if (this.mOutputHatches != null) { + for (GT_MetaTileEntity_Hatch_Output hatch : this.mOutputHatches) { + hatch.updateTexture(status ? 52 : 53); + } + } + if (this.mInputHatches != null) { + for (GT_MetaTileEntity_Hatch_Input hatch : this.mInputHatches) { + hatch.updateTexture(status ? 52 : 53); + } + } + return true; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + if (aSide == aFacing) return new ITexture[]{TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS).extFacing().build(), getTextureOverlay()}; + if (aActive) return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(52)}; + return new ITexture[]{TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS).extFacing().build()}; + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + @Override + public void onMachineBlockUpdate() { + mUpdate = 100; + } + + @Override + public boolean onRunningTick(ItemStack aStack) { + if (mEUt < 0) { + if (!drainEnergyInput(((long) -mEUt * 10000) / Math.max(1000, mEfficiency))) { + this.mLastRecipe = null; + this.para = 0; + stopMachine(); + return false; + } + } + if (this.mEUStore <= 0) { + this.mLastRecipe = null; + this.para = 0; + stopMachine(); + return false; + } + return true; + } + + public abstract int tierOverclock(); + + public int overclock(int mStartEnergy) { + if (tierOverclock() == 1) { + return 1; + } + if (tierOverclock() == 2) { + return mStartEnergy < 160000000 ? 2 : 1; + } + if (tierOverclock() == 4) { + return (mStartEnergy < 160000000 ? 4 : (mStartEnergy < 320000000 ? 2 : 1)); + } + if (tierOverclock() == 8) { + return (mStartEnergy < 160000000) ? 8 : ((mStartEnergy < 320000000) ? 4 : (mStartEnergy < 640000000) ? 2 : 1); + } + return (mStartEnergy < 160000000) ? 16 : ((mStartEnergy < 320000000) ? 8 : ((mStartEnergy < 640000000) ? 4 : (mStartEnergy < 1280000000) ? 2 : 1)); + } + + @Override + public boolean checkRecipe_EM(ItemStack aStack) { + ArrayList<FluidStack> tFluidList = getStoredFluids(); + + if (tFluidList.size() > 1) { + FluidStack[] tFluids = tFluidList.toArray(new FluidStack[0]); + GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sFusionRecipes.findRecipe(this.getBaseMetaTileEntity(), this.mLastRecipe, false, Integer.MAX_VALUE, tFluids); + if ((tRecipe == null && !mRunningOnLoad) || (maxEUStore() < tRecipe.mSpecialValue)) { + turnCasingActive(false); + this.mLastRecipe = null; + return false; + } + int pall = handleParallelRecipe(tRecipe, tFluids, null, Math.min(getMaxPara() * extraPara(tRecipe.mSpecialValue), (int) (getMaxEUInput() / tRecipe.mEUt / overclock(tRecipe.mSpecialValue)))); + this.para = pall; + if (mRunningOnLoad || pall > 0) { + this.mLastRecipe = tRecipe; + this.mEUt = (this.mLastRecipe.mEUt * overclock(this.mLastRecipe.mSpecialValue) * pall); + this.mMaxProgresstime = Math.max(this.mLastRecipe.mDuration / overclock(this.mLastRecipe.mSpecialValue), 1); + this.mEfficiencyIncrease = 10000; + this.mOutputFluids = getMultiOutput(mLastRecipe, pall).getKey().toArray(new FluidStack[0]); + turnCasingActive(true); + mRunningOnLoad = false; + return true; + } + } + return false; + } + + public long getMaxEUInput() { + long sum = 0; + for (GT_MetaTileEntity_Hatch_Energy hatch : mEnergyHatches) { + if (isValidMetaTileEntity(hatch)) { + sum += Math.min(2048L * tierOverclock() * getMaxPara() * extraPara(100), hatch.maxEUInput() * hatch.maxAmperesIn()); + } + } + for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : eEnergyMulti) { + if (isValidMetaTileEntity(hatch)) { + sum += Math.min(2048L * tierOverclock() * getMaxPara() * extraPara(100), hatch.maxEUInput() * hatch.maxAmperesIn()); + } + } + return sum; + } + + @Override + public void onRemoval() { + if (this.isLoadedChunk) + GT_ChunkManager.releaseTicket((TileEntity)getBaseMetaTileEntity()); + super.onRemoval(); + } + + public int getChunkX() { + return getBaseMetaTileEntity().getXCoord() >> 4; + } + + public int getChunkZ() { + return getBaseMetaTileEntity().getZCoord() >> 4; + } + + private boolean addEnergyInjector(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) { + IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) return false; + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) { + GT_MetaTileEntity_Hatch_Energy tHatch = (GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity; + if (tHatch.mTier < hatchTier()) return false; + tHatch.updateTexture(aBaseCasingIndex); + return mEnergyHatches.add(tHatch); + } + else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) { + GT_MetaTileEntity_Hatch_EnergyMulti tHatch = (GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity; + if (tHatch.mTier < hatchTier()) return false; + tHatch.updateTexture(aBaseCasingIndex); + return eEnergyMulti.add(tHatch); + } + return false; + } + + private boolean addInjector(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) { + IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) return false; + if (!(aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input)) return false; + GT_MetaTileEntity_Hatch_Input tHatch = (GT_MetaTileEntity_Hatch_Input) aMetaTileEntity; + if (tHatch.mTier < hatchTier()) return false; + tHatch.updateTexture(aBaseCasingIndex); + tHatch.mRecipeMap = getRecipeMap(); + return mInputHatches.add(tHatch); + } + + private boolean addExtractor(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) { + if (aBaseMetaTileEntity == null) return false; + IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) return false; + if (!(aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output)) return false; + GT_MetaTileEntity_Hatch_Output tHatch = (GT_MetaTileEntity_Hatch_Output) aMetaTileEntity; + if (tHatch.mTier < hatchTier()) return false; + tHatch.updateTexture(aBaseCasingIndex); + return mOutputHatches.add(tHatch); + } + + @Override + public IStructureDefinition<LargeFusionComputer> getStructure_EM() { + return STRUCTURE_DEFINITION.get(getClass()); + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public int getMaxEfficiency(ItemStack aStack) { + return 10000; + } + + @Override + public int getDamageToComponent(ItemStack aStack) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack aStack) { + return false; + } + + @Override + public String[] getInfoData() { + String tier = hatchTier() == 6 ? EnumChatFormatting.RED+"I"+EnumChatFormatting.RESET : hatchTier() == 7 ? EnumChatFormatting.YELLOW+"II"+EnumChatFormatting.RESET : hatchTier() == 8 ? EnumChatFormatting.GRAY+"III" + EnumChatFormatting.RESET : "IV"; + float plasmaOut = 0; + int powerRequired = 0; + if (this.mLastRecipe != null) { + powerRequired = this.mLastRecipe.mEUt * this.para; + if (this.mLastRecipe.getFluidOutput(0) != null) { + plasmaOut = (float)this.mLastRecipe.getFluidOutput(0).amount / (float)this.mLastRecipe.mDuration * this.para; + } + } + + return new String[]{ + EnumChatFormatting.BLUE + "Fusion Reactor MK " + EnumChatFormatting.RESET + tier, + StatCollector.translateToLocal("scanner.info.UX.0") + ": " + + EnumChatFormatting.LIGHT_PURPLE + GT_Utility.formatNumbers(this.para) + EnumChatFormatting.RESET, + StatCollector.translateToLocal("GT5U.fusion.req") + ": " + + EnumChatFormatting.RED + GT_Utility.formatNumbers(powerRequired) + EnumChatFormatting.RESET + "EU/t", + StatCollector.translateToLocal("GT5U.multiblock.energy") + ": " + + EnumChatFormatting.GREEN + GT_Utility.formatNumbers(mEUStore) + EnumChatFormatting.RESET + " EU / " + + EnumChatFormatting.YELLOW + GT_Utility.formatNumbers(maxEUStore()) + EnumChatFormatting.RESET + " EU", + StatCollector.translateToLocal("GT5U.fusion.plasma") + ": " + + EnumChatFormatting.YELLOW + GT_Utility.formatNumbers(plasmaOut) + EnumChatFormatting.RESET + "L/t"}; + } + + public static final String[] L0 = { + " ", + " ", + " FCCCCCF ", + " FCIBICF ", + " FCCCCCF ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " FFF FFF ", + " CCC CCC ", + " CIC CIC ", + " CBC CBC ", + " CIC CIC ", + " CCC CCC ", + " FFF FFF ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " FCCCCCF ", + " FCIBICF ", + " FCCCCCF ", + " ", + " ", + }; + + public static final String[] L1 = { + " ", + " FCBBBCF ", + " CC CC ", + " CCCCC CCCCC ", + " CCCCCCC CCCCCCC ", + " CCCCCCC FCBBBCF CCCCCCC ", + " CCCCC CCCCC ", + " CCCC CCCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " FCCCF FCCCF ", + " C C C C ", + " B B B B ", + " B B B B ", + " B B B B ", + " C C C C ", + " FCCCF FCCCF ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCCC CCCC ", + " CCCCC CCCCC ", + " CCCCCCC FCBBBCF CCCCCCC ", + " CCCCCCC CCCCCCC ", + " CCCCC CCCCC ", + " CC CC ", + " FCBBBCF ", + " ", + }; + + public static final String[] L2 = { + " FCCCCCF ", + " CC CC ", + " CCCCC CCCCC ", + " CCCCCHHHHHHHHHCCCCC ", + " CCCCHHHCC CCHHHCCCC ", + " CCCHHCCCCC CCCCCHHCCC ", + " ECHHCCCCC FCCCCCF CCCCCHHCE ", + " CCHCCCC CCCCHCC ", + " CCHCCC CCCHCC ", + " CCHCE ECHCC ", + " ECHCC CCHCE ", + " CCHCE ECHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + "FCCHCCF FCCHCCF", + "C H C C H C", + "C H C C H C", + "C H C C H C", + "C H C C H C", + "C H C C H C", + "FCCHCCF FCCHCCF", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCE ECHCC ", + " ECHCC CCHCE ", + " CCHCE ECHCC ", + " CCHCCC CCCHCC ", + " CCHCCCC CCCCHCC ", + " ECHHCCCCC FCCCCCF CCCCCHHCE ", + " CCCHHCCCCC CCCCCHHCCC ", + " CCCCHHHCC CCHHHCCCC ", + " CCCCCHHHHHHHHHCCCCC ", + " CCCCC CCCCC ", + " CC CC ", + " FCCCCCF ", + }; + + public static final String[] L3 = { + " FCOBOCF ", + " CC CC ", + " CCCHHHHHHHHHCCC ", + " CCHHHHHHHHHHHHHHCCC ", + " CCHHHHHHHHHHHHHHHHHHHCC ", + " CHHHHHHHCC CCHHHHHHHC ", + " CHHHHHCCC FCOBOCF CCCHHHHHC ", + " CHHHHCC CCHHHHC ", + " CHHHCC CCHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + "FCHHHCF FCHHHCF", + "C HHH C C HHH C", + "O HHH O O HHH O", + "B HHH B B HHH B", + "O HHH O O HHH O", + "C HHH C C HHH C", + "FCHHHCF FCHHHCF", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHCC CCHHHC ", + " CHHHHCC CCHHHHC ", + " CHHHHHCCC FCO~OCF CCCHHHHHC ", + " CHHHHHHHCC CCHHHHHHHC ", + " CCHHHHHHHHHHHHHHHHHHHCC ", + " CCHHHHHHHHHHHHHHCCC ", + " CCCHHHHHHHHHCCC ", + " CC CC ", + " FCOBOCF ", + }; +} diff --git a/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java b/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java new file mode 100644 index 0000000000..179108925b --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/base/LargeFusionComputerPP.java @@ -0,0 +1,679 @@ +package goodgenerator.blocks.tileEntity.base; + +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_EnergyMulti; +import com.github.technus.tectech.thing.metaTileEntity.multi.base.GT_MetaTileEntity_MultiblockBase_EM; +import com.gtnewhorizon.structurelib.alignment.constructable.IConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; +import goodgenerator.client.GUI.LargeFusionComputerGUIClient; +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_Hatch_Energy; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Input; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Output; +import gregtech.api.objects.GT_ChunkManager; +import gregtech.api.objects.GT_ItemStack; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import net.minecraft.block.Block; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraft.world.ChunkCoordIntPair; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.fluids.FluidStack; + +import java.util.ArrayList; + +import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.getMultiOutput; +import static com.github.bartimaeusnek.bartworks.util.RecipeFinderForParallel.handleParallelRecipe; +import static com.gtnewhorizon.structurelib.structure.StructureUtility.*; +import static gregtech.api.enums.Textures.BlockIcons.*; +import static gregtech.api.enums.Textures.BlockIcons.MACHINE_CASING_FUSION_GLASS; +import static gregtech.api.util.GT_StructureUtility.ofFrame; +import static gregtech.api.util.GT_StructureUtility.ofHatchAdderOptional; + +public abstract class LargeFusionComputerPP extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable { + + public static final String MAIN_NAME = "largeFusionPP"; + private boolean isLoadedChunk; + public GT_Recipe mLastRecipe; + public int para; + public long mEUStore; + private static final ClassValue<IStructureDefinition<LargeFusionComputerPP>> STRUCTURE_DEFINITION = new ClassValue<IStructureDefinition<LargeFusionComputerPP>>() { + @Override + protected IStructureDefinition<LargeFusionComputerPP> computeValue(Class<?> type) { + return StructureDefinition.<LargeFusionComputerPP>builder() + .addShape(MAIN_NAME, transpose(new String[][]{ + L0, L1, L2, L3, L2, L1, L0 + })) + .addElement( + 'H', lazy(x -> ofBlock(x.getCoilBlock(), x.getCoilMeta())) + ) + .addElement( + 'C', lazy(x -> ofBlock(x.getCasingBlock(), x.getCasingMeta())) + ) + .addElement( + 'B', lazy(x -> ofBlock(x.getGlassBlock(), x.getGlassMeta())) + ) + .addElement( + 'I', lazy(x -> ofHatchAdderOptional(LargeFusionComputerPP::addInjector, x.textureIndex(), 1, x.getGlassBlock(), x.getGlassMeta())) + ) + .addElement( + 'O', lazy(x -> ofHatchAdderOptional(LargeFusionComputerPP::addExtractor, x.textureIndex(), 2, x.getGlassBlock(), x.getGlassMeta())) + ) + .addElement( + 'E', lazy(x -> ofHatchAdderOptional(LargeFusionComputerPP::addEnergyInjector, x.textureIndex(), 3, x.getCasingBlock(), x.getCasingMeta())) + ) + .addElement( + 'F', lazy(x -> ofFrame(x.getFrameBox())) + ) + .build(); + } + }; + + static { + Textures.BlockIcons.setCasingTextureForId(52, + TextureFactory.of( + TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW).extFacing().build(), + TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS_YELLOW_GLOW).extFacing().glow().build() + )); + } + + public LargeFusionComputerPP(String name) { + super(name); + } + + public LargeFusionComputerPP(int id, String name, String nameRegional) { + super(id,name,nameRegional); + } + + @Override + public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) { + return new LargeFusionComputerGUIClient(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "EMDisplay.png"); + } + + @Override + public abstract long maxEUStore(); + + public abstract Block getCasingBlock(); + + public abstract int getCasingMeta(); + + public abstract Block getCoilBlock(); + + public abstract int getCoilMeta(); + + public abstract Block getGlassBlock(); + + public abstract int getGlassMeta(); + + public abstract int hatchTier(); + + public abstract Materials getFrameBox(); + + public int textureIndex() { + return 53; + }; + + public abstract ITexture getTextureOverlay(); + + public abstract int getMaxPara(); + + @Override + public boolean allowCoverOnSide(byte aSide, GT_ItemStack aStack) { + return aSide != getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + this.eEnergyMulti.clear(); + if (structureCheck_EM(MAIN_NAME, 23, 3, 40) && mInputHatches.size() > 1 && !mOutputHatches.isEmpty() && (mEnergyHatches.size() + eEnergyMulti.size()) != 0) { + fixAllIssue(); + return true; + } + return false; + } + + public void fixAllIssue() { + mWrench = true; + mScrewdriver = true; + mSoftHammer = true; + mHardHammer = true; + mSolderingTool = true; + mCrowbar = true; + } + + @Override + public void construct(ItemStack itemStack, boolean b) { + structureBuild_EM(MAIN_NAME, 23, 3, 40, itemStack, b); + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide() && !aBaseMetaTileEntity.isAllowedToWork()) { + // if machine has stopped, stop chunkloading + GT_ChunkManager.releaseTicket((TileEntity)aBaseMetaTileEntity); + this.isLoadedChunk = false; + } + else if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isAllowedToWork() && !this.isLoadedChunk) { + //load a 3x3 area when machine is running + GT_ChunkManager.releaseTicket((TileEntity)aBaseMetaTileEntity); + int offX = ForgeDirection.getOrientation(aBaseMetaTileEntity.getFrontFacing()).offsetX; + int offZ = ForgeDirection.getOrientation(aBaseMetaTileEntity.getFrontFacing()).offsetZ; + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() + 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + 1 + offX, getChunkZ() - 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() + 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() - 1 + offX, getChunkZ() - 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() + 1 + offZ)); + GT_ChunkManager.requestChunkLoad((TileEntity)aBaseMetaTileEntity, new ChunkCoordIntPair(getChunkX() + offX, getChunkZ() - 1 + offZ)); + this.isLoadedChunk = true; + } + + if (aBaseMetaTileEntity.isServerSide()) { + if (aTick % 400 == 0) fixAllIssue(); + if (mEfficiency < 0) + mEfficiency = 0; + if (mRunningOnLoad && checkMachine(aBaseMetaTileEntity, mInventory[1])) { + this.mEUStore = aBaseMetaTileEntity.getStoredEU(); + checkRecipe(mInventory[1]); + } + if (--mUpdate == 0 || --mStartUpCheck == 0) { + checkStructure(true, aBaseMetaTileEntity); + } + if (mStartUpCheck < 0) { + if (mMachine) { + if (this.mEnergyHatches != null) { + for (GT_MetaTileEntity_Hatch_Energy tHatch : mEnergyHatches) + if (isValidMetaTileEntity(tHatch)) { + if (aBaseMetaTileEntity.getStoredEU() + (2048L * tierOverclock() * getMaxPara() * extraPara(100)) < maxEUStore() + && tHatch.getBaseMetaTileEntity().decreaseStoredEnergyUnits(2048L * tierOverclock() * getMaxPara() * extraPara(100), false)) { + aBaseMetaTileEntity.increaseStoredEnergyUnits(2048L * tierOverclock() * getMaxPara() * extraPara(100), true); + } else if (aBaseMetaTileEntity.getStoredEU() + (2048L * tierOverclock()) < maxEUStore() + && tHatch.getBaseMetaTileEntity().decreaseStoredEnergyUnits(2048L * tierOverclock(), false)) { + aBaseMetaTileEntity.increaseStoredEnergyUnits(2048L * tierOverclock(), true); + } + } + } + if (this.eEnergyMulti != null) { + for (GT_MetaTileEntity_Hatch_EnergyMulti tHatch : eEnergyMulti) + if (isValidMetaTileEntity(tHatch)) { + if (aBaseMetaTileEntity.getStoredEU() + (2048L * tierOverclock() * getMaxPara() * extraPara(100)) < maxEUStore() + && tHatch.getBaseMetaTileEntity().decreaseStoredEnergyUnits(2048L * tierOverclock() * getMaxPara() * extraPara(100), false)) { + aBaseMetaTileEntity.increaseStoredEnergyUnits(2048L * tierOverclock() * getMaxPara() * extraPara(100), true); + } else if (aBaseMetaTileEntity.getStoredEU() + (2048L * tierOverclock()) < maxEUStore() + && tHatch.getBaseMetaTileEntity().decreaseStoredEnergyUnits(2048L * tierOverclock(), false)) { + aBaseMetaTileEntity.increaseStoredEnergyUnits(2048L * tierOverclock(), true); + } + } + } + if (this.mEUStore <= 0 && mMaxProgresstime > 0) { + stopMachine(); + } + if (mMaxProgresstime > 0) { + this.getBaseMetaTileEntity().decreaseStoredEnergyUnits(mEUt, true); + if (mMaxProgresstime > 0 && ++mProgresstime >= mMaxProgresstime) { + if (mOutputItems != null) + for (ItemStack tStack : mOutputItems) if (tStack != null) addOutput(tStack); + if (mOutputFluids != null) + for (FluidStack tStack : mOutputFluids) if (tStack != null) addOutput(tStack); + mEfficiency = Math.max(0, Math.min(mEfficiency + mEfficiencyIncrease, getMaxEfficiency(mInventory[1]))); + mOutputItems = null; + mProgresstime = 0; + mMaxProgresstime = 0; + mEfficiencyIncrease = 0; + this.mEUStore = getBaseMetaTileEntity().getStoredEU(); + if (aBaseMetaTileEntity.isAllowedToWork()) + checkRecipe(mInventory[1]); + } + } else { + if (aTick % 100 == 0 || aBaseMetaTileEntity.hasWorkJustBeenEnabled() || aBaseMetaTileEntity.hasInventoryBeenModified()) { + turnCasingActive(mMaxProgresstime > 0); + if (aBaseMetaTileEntity.isAllowedToWork()) { + this.mEUStore = getBaseMetaTileEntity().getStoredEU(); + if (checkRecipe(mInventory[1])) { + if (this.mEUStore < this.mLastRecipe.mSpecialValue - this.mEUt) { + mMaxProgresstime = 0; + turnCasingActive(false); + } + getBaseMetaTileEntity().decreaseStoredEnergyUnits(this.mLastRecipe.mSpecialValue - this.mEUt, false); + } + } + if (mMaxProgresstime <= 0) + mEfficiency = Math.max(0, mEfficiency - 1000); + } + } + } else { + turnCasingActive(false); + this.mLastRecipe = null; + stopMachine(); + } + } + aBaseMetaTileEntity.setErrorDisplayID((aBaseMetaTileEntity.getErrorDisplayID() & ~127) | (mMachine ? 0 : 64)); + aBaseMetaTileEntity.setActive(mMaxProgresstime > 0); + } + } + + public boolean turnCasingActive(boolean status) { + if (this.mEnergyHatches != null) { + for (GT_MetaTileEntity_Hatch_Energy hatch : this.mEnergyHatches) { + hatch.updateTexture(status ? 52 : 53); + } + } + if (this.eEnergyMulti != null) { + for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : this.eEnergyMulti) { + hatch.updateTexture(status ? 52 : 53); + } + } + if (this.mOutputHatches != null) { + for (GT_MetaTileEntity_Hatch_Output hatch : this.mOutputHatches) { + hatch.updateTexture(status ? 52 : 53); + } + } + if (this.mInputHatches != null) { + for (GT_MetaTileEntity_Hatch_Input hatch : this.mInputHatches) { + hatch.updateTexture(status ? 52 : 53); + } + } + return true; + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) { + if (aSide == aFacing) return new ITexture[]{TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS).extFacing().build(), getTextureOverlay()}; + if (aActive) return new ITexture[]{Textures.BlockIcons.getCasingTextureForId(52)}; + return new ITexture[]{TextureFactory.builder().addIcon(MACHINE_CASING_FUSION_GLASS).extFacing().build()}; + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + @Override + public void onMachineBlockUpdate() { + mUpdate = 100; + } + + @Override + public boolean onRunningTick(ItemStack aStack) { + if (mEUt < 0) { + if (!drainEnergyInput(((long) -mEUt * 10000) / Math.max(1000, mEfficiency))) { + this.mLastRecipe = null; + this.para = 0; + stopMachine(); + return false; + } + } + if (this.mEUStore <= 0) { + this.mLastRecipe = null; + this.para = 0; + stopMachine(); + return false; + } + return true; + } + + public abstract int tierOverclock(); + + public abstract int overclock(int mStartEnergy); + + public abstract int extraPara(int startEnergy); + + @Override + public boolean checkRecipe_EM(ItemStack aStack) { + ArrayList<FluidStack> tFluidList = getStoredFluids(); + + if (tFluidList.size() > 1) { + FluidStack[] tFluids = tFluidList.toArray(new FluidStack[0]); + GT_Recipe tRecipe = GT_Recipe.GT_Recipe_Map.sFusionRecipes.findRecipe(this.getBaseMetaTileEntity(), this.mLastRecipe, false, Integer.MAX_VALUE, tFluids); + if ((tRecipe == null && !mRunningOnLoad) || (maxEUStore() < tRecipe.mSpecialValue)) { + turnCasingActive(false); + this.mLastRecipe = null; + return false; + } + int pall = handleParallelRecipe(tRecipe, tFluids, null, Math.min(getMaxPara() * extraPara(tRecipe.mSpecialValue), (int) (getMaxEUInput() / tRecipe.mEUt / overclock(tRecipe.mSpecialValue)))); + this.para = pall; + if (mRunningOnLoad || pall > 0) { + this.mLastRecipe = tRecipe; + this.mEUt = (this.mLastRecipe.mEUt * overclock(this.mLastRecipe.mSpecialValue) * pall); + this.mMaxProgresstime = Math.max(this.mLastRecipe.mDuration / overclock(this.mLastRecipe.mSpecialValue), 1); + this.mEfficiencyIncrease = 10000; + this.mOutputFluids = getMultiOutput(mLastRecipe, pall).getKey().toArray(new FluidStack[0]); + turnCasingActive(true); + mRunningOnLoad = false; + return true; + } + } + return false; + } + + public long getMaxEUInput() { + long sum = 0; + for (GT_MetaTileEntity_Hatch_Energy hatch : mEnergyHatches) { + if (isValidMetaTileEntity(hatch)) { + sum += Math.min(2048L * tierOverclock() * getMaxPara() * extraPara(100), hatch.maxEUInput() * hatch.maxAmperesIn()); + } + } + for (GT_MetaTileEntity_Hatch_EnergyMulti hatch : eEnergyMulti) { + if (isValidMetaTileEntity(hatch)) { + sum += Math.min(2048L * tierOverclock() * getMaxPara() * extraPara(100), hatch.maxEUInput() * hatch.maxAmperesIn()); + } + } + return sum; + } + + @Override + public void onRemoval() { + if (this.isLoadedChunk) + GT_ChunkManager.releaseTicket((TileEntity)getBaseMetaTileEntity()); + super.onRemoval(); + } + + public int getChunkX() { + return getBaseMetaTileEntity().getXCoord() >> 4; + } + + public int getChunkZ() { + return getBaseMetaTileEntity().getZCoord() >> 4; + } + + private boolean addEnergyInjector(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) { + IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) return false; + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) { + GT_MetaTileEntity_Hatch_Energy tHatch = (GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity; + if (tHatch.mTier < hatchTier()) return false; + tHatch.updateTexture(aBaseCasingIndex); + return mEnergyHatches.add(tHatch); + } + else if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) { + GT_MetaTileEntity_Hatch_EnergyMulti tHatch = (GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity; + if (tHatch.mTier < hatchTier()) return false; + tHatch.updateTexture(aBaseCasingIndex); + return eEnergyMulti.add(tHatch); + } + return false; + } + + private boolean addInjector(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) { + IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) return false; + if (!(aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input)) return false; + GT_MetaTileEntity_Hatch_Input tHatch = (GT_MetaTileEntity_Hatch_Input) aMetaTileEntity; + if (tHatch.mTier < hatchTier()) return false; + tHatch.updateTexture(aBaseCasingIndex); + tHatch.mRecipeMap = getRecipeMap(); + return mInputHatches.add(tHatch); + } + + private boolean addExtractor(IGregTechTileEntity aBaseMetaTileEntity, int aBaseCasingIndex) { + if (aBaseMetaTileEntity == null) return false; + IMetaTileEntity aMetaTileEntity = aBaseMetaTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) return false; + if (!(aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output)) return false; + GT_MetaTileEntity_Hatch_Output tHatch = (GT_MetaTileEntity_Hatch_Output) aMetaTileEntity; + if (tHatch.mTier < hatchTier()) return false; + tHatch.updateTexture(aBaseCasingIndex); + return mOutputHatches.add(tHatch); + } + + @Override + public IStructureDefinition<LargeFusionComputerPP> getStructure_EM() { + return STRUCTURE_DEFINITION.get(getClass()); + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public int getMaxEfficiency(ItemStack aStack) { + return 10000; + } + + @Override + public int getDamageToComponent(ItemStack aStack) { + return 0; + } + + @Override + public boolean explodesOnComponentBreak(ItemStack aStack) { + return false; + } + + @Override + public String[] getInfoData() { + String tier = hatchTier() == 9 ? EnumChatFormatting.BLUE+"IV"+EnumChatFormatting.RESET : EnumChatFormatting.GOLD+"V"+EnumChatFormatting.RESET; + float plasmaOut = 0; + int powerRequired = 0; + if (this.mLastRecipe != null) { + powerRequired = this.mLastRecipe.mEUt * this.para; + if (this.mLastRecipe.getFluidOutput(0) != null) { + plasmaOut = (float)this.mLastRecipe.getFluidOutput(0).amount / (float)this.mLastRecipe.mDuration * this.para; + } + } + + return new String[]{ + EnumChatFormatting.BLUE + "Fusion Reactor MK " + EnumChatFormatting.RESET + tier, + StatCollector.translateToLocal("scanner.info.UX.0") + ": " + + EnumChatFormatting.LIGHT_PURPLE + GT_Utility.formatNumbers(this.para) + EnumChatFormatting.RESET, + StatCollector.translateToLocal("GT5U.fusion.req") + ": " + + EnumChatFormatting.RED + GT_Utility.formatNumbers(powerRequired) + EnumChatFormatting.RESET + "EU/t", + StatCollector.translateToLocal("GT5U.multiblock.energy") + ": " + + EnumChatFormatting.GREEN + GT_Utility.formatNumbers(mEUStore) + EnumChatFormatting.RESET + " EU / " + + EnumChatFormatting.YELLOW + GT_Utility.formatNumbers(maxEUStore()) + EnumChatFormatting.RESET + " EU", + StatCollector.translateToLocal("GT5U.fusion.plasma") + ": " + + EnumChatFormatting.YELLOW + GT_Utility.formatNumbers(plasmaOut) + EnumChatFormatting.RESET + "L/t"}; + } + + public static final String[] L0 = { + " ", + " ", + " FCCCCCF ", + " FCIBICF ", + " FCCCCCF ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " FFF FFF ", + " CCC CCC ", + " CIC CIC ", + " CBC CBC ", + " CIC CIC ", + " CCC CCC ", + " FFF FFF ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " ", + " FCCCCCF ", + " FCIBICF ", + " FCCCCCF ", + " ", + " ", + }; + + public static final String[] L1 = { + " ", + " FCBBBCF ", + " CC CC ", + " CCCCC CCCCC ", + " CCCCCCC CCCCCCC ", + " CCCCCCC FCBBBCF CCCCCCC ", + " CCCCC CCCCC ", + " CCCC CCCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " FCCCF FCCCF ", + " C C C C ", + " B B B B ", + " B B B B ", + " B B B B ", + " C C C C ", + " FCCCF FCCCF ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCC CCC ", + " CCCC CCCC ", + " CCCCC CCCCC ", + " CCCCCCC FCBBBCF CCCCCCC ", + " CCCCCCC CCCCCCC ", + " CCCCC CCCCC ", + " CC CC ", + " FCBBBCF ", + " ", + }; + + public static final String[] L2 = { + " FCCCCCF ", + " CC CC ", + " CCCCC CCCCC ", + " CCCCCHHHHHHHHHCCCCC ", + " CCCCHHHCC CCHHHCCCC ", + " CCCHHCCCCC CCCCCHHCCC ", + " ECHHCCCCC FCCCCCF CCCCCHHCE ", + " CCHCCCC CCCCHCC ", + " CCHCCC CCCHCC ", + " CCHCE ECHCC ", + " ECHCC CCHCE ", + " CCHCE ECHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + "FCCHCCF FCCHCCF", + "C H C C H C", + "C H C C H C", + "C H C C H C", + "C H C C H C", + "C H C C H C", + "FCCHCCF FCCHCCF", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCC CCHCC ", + " CCHCE ECHCC ", + " ECHCC CCHCE ", + " CCHCE ECHCC ", + " CCHCCC CCCHCC ", + " CCHCCCC CCCCHCC ", + " ECHHCCCCC FCCCCCF CCCCCHHCE ", + " CCCHHCCCCC CCCCCHHCCC ", + " CCCCHHHCC CCHHHCCCC ", + " CCCCCHHHHHHHHHCCCCC ", + " CCCCC CCCCC ", + " CC CC ", + " FCCCCCF ", + }; + + public static final String[] L3 = { + " FCOBOCF ", + " CC CC ", + " CCCHHHHHHHHHCCC ", + " CCHHHHHHHHHHHHHHCCC ", + " CCHHHHHHHHHHHHHHHHHHHCC ", + " CHHHHHHHCC CCHHHHHHHC ", + " CHHHHHCCC FCOBOCF CCCHHHHHC ", + " CHHHHCC CCHHHHC ", + " CHHHCC CCHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + "FCHHHCF FCHHHCF", + "C HHH C C HHH C", + "O HHH O O HHH O", + "B HHH B B HHH B", + "O HHH O O HHH O", + "C HHH C C HHH C", + "FCHHHCF FCHHHCF", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHC CHHHC ", + " CHHHCC CCHHHC ", + " CHHHHCC CCHHHHC ", + " CHHHHHCCC FCO~OCF CCCHHHHHC ", + " CHHHHHHHCC CCHHHHHHHC ", + " CCHHHHHHHHHHHHHHHHHHHCC ", + " CCHHHHHHHHHHHHHHCCC ", + " CCCHHHHHHHHHCCC ", + " CC CC ", + " FCOBOCF ", + }; +} |