diff options
Diffstat (limited to 'src/main/java')
5 files changed, 333 insertions, 6 deletions
diff --git a/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java b/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java index 3fd83472d8..64a8b38f3d 100644 --- a/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java +++ b/src/main/java/goodgenerator/blocks/tileEntity/MultiNqGenerator.java @@ -392,11 +392,11 @@ public class MultiNqGenerator extends GT_MetaTileEntity_MultiblockBase_EM implem .addOutputHatch("Any bottom layer casing") .addMaintenanceHatch("Any bottom layer casing") .toolTipFinisher("Good Generator"); - if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { - return tt.getInformation(); - } else { - return tt.getStructureInformation(); - } + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } } @Override diff --git a/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java b/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java new file mode 100644 index 0000000000..e225feabce --- /dev/null +++ b/src/main/java/goodgenerator/blocks/tileEntity/PreciseAssembler.java @@ -0,0 +1,316 @@ +package goodgenerator.blocks.tileEntity; + +import com.github.technus.tectech.thing.metaTileEntity.hatch.*; +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 cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import goodgenerator.loader.Loaders; +import goodgenerator.util.DescTextLocalization; +import gregtech.api.GregTech_API; +import gregtech.api.enums.Materials; +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.*; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import ic2.core.Ic2Items; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import org.lwjgl.input.Keyboard; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.*; +import static goodgenerator.util.DescTextLocalization.BLUE_PRINT_INFO; +import static goodgenerator.util.StructureHelper.addTieredBlock; +import static gregtech.api.util.GT_StructureUtility.ofFrame; +import static gregtech.api.util.GT_StructureUtility.ofHatchAdder; + +public class PreciseAssembler extends GT_MetaTileEntity_MultiblockBase_EM implements IConstructable { + + private static final IIconContainer textureFontOn = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QTANK"); + private static final IIconContainer textureFontOn_Glow = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QTANK_GLOW"); + private static final IIconContainer textureFontOff = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QCHEST"); + private static final IIconContainer textureFontOff_Glow = new Textures.BlockIcons.CustomIcon("iconsets/OVERLAY_QCHEST_GLOW"); + + protected IStructureDefinition<PreciseAssembler> multiDefinition = null; + protected int casingAmount; + protected int casingTier; + protected int machineTier; + + public PreciseAssembler(String name) { + super(name); + } + + public PreciseAssembler(int id, String name, String nameRegional) { + super(id, name, nameRegional); + } + + @Override + public IStructureDefinition<PreciseAssembler> getStructure_EM() { + if (multiDefinition == null) { + multiDefinition = StructureDefinition + .<PreciseAssembler>builder() + .addShape(mName, + transpose(new String[][]{ + {"CCCCCCCCC", "CCCCCCCCC", "CCCCCCCCC", "CCCCCCCCC", "CCCCCCCCC"}, + {"F F", "CGGGGGGGC", "C-------C", "CGGGGGGGC", "F F"}, + {"F F", "CGGGGGGGC", "C-------C", "CGGGGGGGC", "F F"}, + {"F F", "CGGGGGGGC", "C-------C", "CGGGGGGGC", "F F"}, + {"CCCC~CCCC", "CMMMMMMMC", "CMMMMMMMC", "CMMMMMMMC", "CCCCCCCCC"} + }) + ) + .addElement( + 'C', + ofChain( + ofHatchAdder( + PreciseAssembler::addToPAssList, 0, 1 + ), + onElementPass( + x -> x.casingAmount++, + addTieredBlock( + Loaders.preciseUnitCasing, PreciseAssembler::setCasingTier, PreciseAssembler::getCasingTier, 3 + ) + ) + ) + ) + .addElement( + 'F', + ofFrame( + Materials.TungstenSteel + ) + ) + .addElement( + 'G', + ofBlock( + Block.getBlockFromItem(Ic2Items.reinforcedGlass.getItem()), 0 + ) + ) + .addElement( + 'M', + addTieredBlock( + GregTech_API.sBlockCasings1, PreciseAssembler::setMachineTier, PreciseAssembler::getMachineTier, 10 + ) + ) + .build(); + } + return multiDefinition; + } + + public boolean addToPAssList(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) { + if (aTileEntity == null) { + return false; + } + IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity(); + if (aMetaTileEntity == null) { + return false; + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Input) { + ((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity).mRecipeMap = this.getRecipeMap(); + return mInputHatches.add((GT_MetaTileEntity_Hatch_Input) aMetaTileEntity); + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_InputBus) { + ((GT_MetaTileEntity_Hatch_InputBus) aMetaTileEntity).mRecipeMap = this.getRecipeMap(); + return mInputBusses.add((GT_MetaTileEntity_Hatch_InputBus) aMetaTileEntity); + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Output) { + return mOutputHatches.add((GT_MetaTileEntity_Hatch_Output) aMetaTileEntity); + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_OutputBus) { + return mOutputBusses.add((GT_MetaTileEntity_Hatch_OutputBus) aMetaTileEntity); + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Energy) { + return mEnergyHatches.add((GT_MetaTileEntity_Hatch_Energy) aMetaTileEntity); + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Maintenance) { + return mMaintenanceHatches.add((GT_MetaTileEntity_Hatch_Maintenance) aMetaTileEntity); + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_Muffler) { + return mMufflerHatches.add((GT_MetaTileEntity_Hatch_Muffler) aMetaTileEntity); + } + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_EnergyMulti) { + return eEnergyMulti.add((GT_MetaTileEntity_Hatch_EnergyMulti) aMetaTileEntity); + } + return false; + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + casingTier = aNBT.getInteger("casingTier"); + machineTier = aNBT.getInteger("machineTier"); + super.loadNBTData(aNBT); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + aNBT.setInteger("casingTier", casingTier); + aNBT.setInteger("machineTier", machineTier); + super.saveNBTData(aNBT); + } + + @Override + public void construct(ItemStack stackSize, boolean hintsOnly) { + structureBuild_EM(mName, 4, 4, 0, hintsOnly, stackSize); + } + + @Override + public boolean checkMachine_EM(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) { + this.machineTier = 0; + this.casingAmount = 0; + this.casingTier = 0; + if (structureCheck_EM(mName, 4, 4, 0)) { + if (casingTier != 0) { + reUpdate(1538 + casingTier); + } + return casingAmount >= 12 && machineTier != 0 && casingTier != 0 && mMaintenanceHatches.size() == 1 && !mMufflerHatches.isEmpty(); + } + return false; + } + + @Override + public String[] getDescription() { + final GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Precise Assembler/Assembler") + .addInfo("Controller block for the Precise Assembler") + .addInfo("The error is no more than 0.03mm.") + .addInfo("Can assemble precise component in Precise Mode.") + .addInfo("Can work like a normal assembler in Normal Mode.") + .addInfo("Use screwdriver to change mode.") + .addInfo("The Machine Casing limits the voltage tier the machine can work on.") + .addInfo("UHV Machine Casing will unlock all voltage.") + .addInfo("Precise Electronic Unit Casing won't lock recipe in Normal Mode.") + .addInfo("But gives more parallel with more advanced one.") + .addInfo("MK-I = 32x, MK-II = 64x, MK-III = 128x") + .addInfo("Providing 10L/s Lubricant can make it 50% faster.") + .addPollutionAmount(getPollutionPerSecond(null)) + .addInfo("The structure is too complex!") + .addInfo(BLUE_PRINT_INFO) + .addSeparator() + .addController("Front bottom") + .addInputHatch("Any Casing") + .addInputBus("Any Casing") + .addOutputHatch("Any Casing") + .addOutputBus("Any Casing") + .addEnergyHatch("Any Casing") + .addMufflerHatch("Any Casing") + .addMaintenanceHatch("Any Casing") + .toolTipFinisher("Good Generator"); + if (!Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) { + return tt.getInformation(); + } else { + return tt.getStructureInformation(); + } + } + + @Override + public int getPollutionPerSecond(ItemStack aStack){ + return 120; + } + + @Override + public String[] getStructureDescription(ItemStack stackSize) { + return DescTextLocalization.addText("PreciseAssembler.hint", 6); + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new PreciseAssembler(this.mName); + } + + public int getCasingTier() { + return casingTier; + } + + public void setCasingTier(int i) { + casingTier = i; + } + + public int getMachineTier() { + return machineTier; + } + + public void setMachineTier(int i) { + machineTier = i; + } + + public void reUpdate(int texture) { + for (GT_MetaTileEntity_Hatch hatch : mInputHatches) { + hatch.updateTexture(texture); + } + for (GT_MetaTileEntity_Hatch hatch : mInputBusses) { + hatch.updateTexture(texture); + } + for (GT_MetaTileEntity_Hatch hatch : mOutputHatches) { + hatch.updateTexture(texture); + } + for (GT_MetaTileEntity_Hatch hatch : mOutputBusses) { + hatch.updateTexture(texture); + } + for (GT_MetaTileEntity_Hatch hatch : mEnergyHatches) { + hatch.updateTexture(texture); + } + for (GT_MetaTileEntity_Hatch hatch : mMaintenanceHatches) { + hatch.updateTexture(texture); + } + for (GT_MetaTileEntity_Hatch hatch : mMufflerHatches) { + hatch.updateTexture(texture); + } + for (GT_MetaTileEntity_Hatch hatch : eEnergyMulti) { + hatch.updateTexture(texture); + } + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone){ + int t = 1; + if (getCasingTier() != 0) t = getCasingTier(); + if (aSide == aFacing) { + if (aActive) return new ITexture[] { + Textures.BlockIcons.getCasingTextureForId(1538 + t), + TextureFactory.of(textureFontOn), + TextureFactory.builder().addIcon(textureFontOn_Glow).glow().build() + }; + else return new ITexture[] { + Textures.BlockIcons.getCasingTextureForId(1538 + t), + TextureFactory.of(textureFontOff), + TextureFactory.builder().addIcon(textureFontOff_Glow).glow().build() + }; + } + else return new ITexture[] {Textures.BlockIcons.getCasingTextureForId(1538 + t)}; + } + + @SideOnly(Side.CLIENT) + public int getCasingTierClient() { + if (this.getBaseMetaTileEntity().getWorld() == null) { + return 0; + } + try { + for (byte i = 0; i < 6; i++) { + Block casing = getBaseMetaTileEntity().getBlockAtSide(i); + if (casing != null && casing.equals(Loaders.preciseUnitCasing)) { + return getBaseMetaTileEntity().getMetaIDAtSide(i) + 1; + } + } + } + catch (Throwable t) { + return 0; + } + return 0; + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isClientSide()) { + if (this.getBaseMetaTileEntity() != null && this.getBaseMetaTileEntity().getWorld() != null) { + this.casingTier = getCasingTierClient(); + markDirty(); + } + } + super.onPostTick(aBaseMetaTileEntity, aTick); + } +} diff --git a/src/main/java/goodgenerator/loader/Loaders.java b/src/main/java/goodgenerator/loader/Loaders.java index 68dc3f4f66..a81ce3672c 100644 --- a/src/main/java/goodgenerator/loader/Loaders.java +++ b/src/main/java/goodgenerator/loader/Loaders.java @@ -87,6 +87,7 @@ public class Loaders { public static final Block yottaFluidTankCasing = new ComplexTextureCasing("yottaFluidTankCasing", new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCasing_SIDE"}, new String[]{GoodGenerator.MOD_ID+":yottaFluidTankCasing_TOP"}); public static final Block supercriticalFluidTurbineCasing = new TurbineCasing("supercriticalFluidTurbineCasing", "supercriticalFluidTurbineCasing"); public static final Block pressureResistantWalls = new Casing("pressureResistantWalls", new String[]{GoodGenerator.MOD_ID+":pressureResistantWalls"}); + public static final Block preciseUnitCasing = new Casing("preciseUnitCasing", new String[]{GoodGenerator.MOD_ID+":preciseUnitCasing/1", GoodGenerator.MOD_ID+":preciseUnitCasing/2", GoodGenerator.MOD_ID+":preciseUnitCasing/3"}); public static Block essentiaHatch; @@ -100,6 +101,7 @@ public class Loaders { public static ItemStack YFH; public static ItemStack SCTurbine; public static ItemStack XHE; + public static ItemStack PA; public static ItemStack[] NeutronAccelerators = new ItemStack[9]; public static ItemStack[] Generator_Diesel = new ItemStack[2]; @@ -119,6 +121,7 @@ public class Loaders { Loaders.YFH = new YOTTAHatch(IDOffset + 14, "YottaFluidTankHatch", "YOTHatch", 5).getStackForm(1L); Loaders.SCTurbine = new SupercriticalFluidTurbine(IDOffset + 15, "SupercriticalSteamTurbine", "SC Steam Turbine").getStackForm(1L); Loaders.XHE = new ExtremeHeatExchanger(IDOffset + 16, "ExtremeHeatExchanger", "Extreme Heat Exchanger").getStackForm(1L); + Loaders.PA = new PreciseAssembler(IDOffset + 17, "PreciseAssembler", "Precise Auto-Assembler MT-3662").getStackForm(1L); Loaders.Generator_Diesel[0] = new DieselGenerator(1113, "basicgenerator.diesel.tier.04", "Turbo Supercharging Combustion Generator", 4).getStackForm(1L); Loaders.Generator_Diesel[1] = new DieselGenerator(1114, "basicgenerator.diesel.tier.05", "Ultimate Chemical Energy Releaser", 5).getStackForm(1L); CrackRecipeAdder.registerPipe(30995, MyMaterial.incoloy903, 15000, 8000, true); @@ -145,6 +148,7 @@ public class Loaders { GameRegistry.registerBlock(yottaFluidTankCasing, MyItemBlocks.class, "yottaFluidTankCasing"); GameRegistry.registerBlock(supercriticalFluidTurbineCasing, MyItemBlocks.class, "supercriticalFluidTurbineCasing"); GameRegistry.registerBlock(pressureResistantWalls, MyItemBlocks.class, "pressureResistantWalls"); + GameRegistry.registerBlock(preciseUnitCasing, MyItemBlocks.class, "preciseUnitCasing"); GameRegistry.registerItem(radiationProtectionPlate, "radiationProtectionPlate", GoodGenerator.MOD_ID); GameRegistry.registerItem(wrappedUraniumIngot, "wrappedUraniumIngot", GoodGenerator.MOD_ID); GameRegistry.registerItem(highDensityUraniumNugget, "highDensityUraniumNugget", GoodGenerator.MOD_ID); @@ -199,6 +203,9 @@ public class Loaders { Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage] = new ITexture[128]; Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][1] = TextureFactory.of(yottaFluidTankCasing); Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][2] = TextureFactory.of(supercriticalFluidTurbineCasing); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][3] = TextureFactory.of(preciseUnitCasing, 0); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][4] = TextureFactory.of(preciseUnitCasing, 1); + Textures.BlockIcons.casingTexturePages[GoodGeneratorTexturePage][5] = TextureFactory.of(preciseUnitCasing, 2); } } diff --git a/src/main/java/goodgenerator/util/ItemRefer.java b/src/main/java/goodgenerator/util/ItemRefer.java index a492df95d6..1ee474abe7 100644 --- a/src/main/java/goodgenerator/util/ItemRefer.java +++ b/src/main/java/goodgenerator/util/ItemRefer.java @@ -111,6 +111,9 @@ public final class ItemRefer { public static ItemRefer YOTTank_Cell_T10 = getItemStack(yottaFluidTankCell, 9); public static ItemRefer SC_Turbine_Casing = getItemStack(supercriticalFluidTurbineCasing); public static ItemRefer Pressure_Resistant_Wall = getItemStack(pressureResistantWalls); + public static ItemRefer Precise_Electronic_Unit_T1 = getItemStack(preciseUnitCasing, 0); + public static ItemRefer Precise_Electronic_Unit_T2 = getItemStack(preciseUnitCasing, 1); + public static ItemRefer Precise_Electronic_Unit_T3 = getItemStack(preciseUnitCasing, 2); public static ItemRefer Large_Naquadah_Reactor = getItemStack(MAR); public static ItemRefer Naquadah_Fuel_Refinery = getItemStack(FRF); @@ -121,6 +124,7 @@ public final class ItemRefer { public static ItemRefer Combustion_Generator_IV = getItemStack(Generator_Diesel[1]); public static ItemRefer SC_Fluid_Turbine = getItemStack(SCTurbine); public static ItemRefer Extreme_Heat_Exchanger = getItemStack(XHE); + public static ItemRefer Precise_Assembler = getItemStack(PA); private Item mItem = null; private Block mBlock = null; diff --git a/src/main/java/goodgenerator/util/StructureHelper.java b/src/main/java/goodgenerator/util/StructureHelper.java index e1f5b69981..f9c6de38e1 100644 --- a/src/main/java/goodgenerator/util/StructureHelper.java +++ b/src/main/java/goodgenerator/util/StructureHelper.java @@ -102,7 +102,7 @@ public class StructureHelper { } private int getMeta(ItemStack trigger) { - int meta = trigger.stackSize; + int meta = trigger.stackSize - 1; if (meta <= 0) meta = 0; if (meta >= maxMeta) meta = maxMeta - 1; return meta; |