From 8b077c28bea7bcc046be1e4b8485d69b4c245a43 Mon Sep 17 00:00:00 2001 From: Raven Szewczyk Date: Sat, 20 Jul 2024 15:35:26 +0100 Subject: Beamline (#2619) * Beamline * Remove hardcoded dreamcraft items and spotless * Remove logs and fix auto structure check * Remove logs and fix auto structure check * Fix typo and synchrotron high MF scaling * sa (cherry picked from commit b2796d95538a1b683b4a98bf6cb0f8fe21404fbd) * Add multi textures, add structuredesc info, remove test TC input, add synchrotron/input/output recipes * Spotless * Prevent mob spawning on casings * Fix LINAC glass requirement, make synchrotron structure less ugly, add last recipe * Spotless * Add placeholder particle textures * Add some mask recipes I missed * Spotless apply for branch lanth-beamline for #2619 (#2630) spotlessApply Co-authored-by: GitHub GTNH Actions <> * Add further error messages to LINAC and Synchrotron, fix MM & LaB6 recipes * Spotless apply for branch lanth-beamline for #2619 (#2648) spotlessApply Co-authored-by: GitHub GTNH Actions <> * Minor changes, add more multi error messages & 9x U-238 SC recipe * Spotless apply for branch lanth-beamline for #2619 (#2651) spotlessApply Co-authored-by: GitHub GTNH Actions <> * Missed a change * Spotless apply for branch lanth-beamline for #2619 (#2652) spotlessApply Co-authored-by: GitHub GTNH Actions <> * Update beamline desc * Remove comments, move coolant fluid check to Util class * Spotless * Spotless apply for branch lanth-beamline for #2619 (#2666) spotlessApply Co-authored-by: GitHub GTNH Actions <> * Fix Mu-Metal recipe output amount, tool stats for MM & LaB6 * Spotless * Fix multi hatch textures * Spotless apply for branch lanth-beamline for #2619 (#2676) spotlessApply Co-authored-by: GitHub GTNH Actions <> * Increase Synchrotron output rate eut & antenna tier scaling, in general improve output rates, buff all TC recipes' processing time * Fix misleading BL tooltip * update * remove import * Buff higher-tier wafer recipes for each IC, from a 4x to 3x increase of recipe amount per two wafer tier increases * Remove RA1 calls in beamline (#2716) * Spotless apply for branch lanth-beamline for #2619 (#2717) spotlessApply Co-authored-by: GitHub GTNH Actions <> * fix * Spotless apply for branch lanth-beamline for #2619 (#2733) spotlessApply Co-authored-by: GitHub GTNH Actions <> --------- Co-authored-by: unknown Co-authored-by: Elisis Co-authored-by: Martin Robertz Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com> --- .../java/com/elisis/gtnhlanth/GTNHLanthanides.java | 53 +- .../gtnhlanth/common/beamline/BeamInformation.java | 51 + .../gtnhlanth/common/beamline/BeamLinePacket.java | 51 + .../common/beamline/IConnectsToBeamline.java | 14 + .../elisis/gtnhlanth/common/beamline/Particle.java | 71 ++ .../gtnhlanth/common/beamline/TileBeamline.java | 256 +++++ .../gtnhlanth/common/block/AntennaCasing.java | 15 + .../com/elisis/gtnhlanth/common/block/Casing.java | 80 ++ .../gtnhlanth/common/block/ShieldedAccGlass.java | 68 ++ .../gtnhlanth/common/hatch/TileBusInputFocus.java | 85 ++ .../common/hatch/TileHatchBeamlineConnector.java | 136 +++ .../common/hatch/TileHatchInputBeamline.java | 131 +++ .../common/hatch/TileHatchOutputBeamline.java | 138 +++ .../elisis/gtnhlanth/common/item/ICanFocus.java | 5 + .../elisis/gtnhlanth/common/item/LanthItem.java | 15 + .../com/elisis/gtnhlanth/common/item/MaskList.java | 147 +++ .../elisis/gtnhlanth/common/item/ParticleItem.java | 124 +++ .../common/item/PhotolithographicMask.java | 38 + .../gtnhlanth/common/register/LanthItemList.java | 157 ++- .../common/register/WerkstoffMaterialPool.java | 174 +++- .../elisis/gtnhlanth/common/tileentity/LINAC.java | 729 +++++++++++++ .../gtnhlanth/common/tileentity/SourceChamber.java | 412 ++++++++ .../gtnhlanth/common/tileentity/Synchrotron.java | 1068 ++++++++++++++++++++ .../gtnhlanth/common/tileentity/TargetChamber.java | 479 +++++++++ .../recipe/beamline/BeamlineRecipeAdder2.java | 166 +++ .../recipe/beamline/BeamlineRecipeLoader.java | 191 ++++ .../tileentity/recipe/beamline/RecipeSC.java | 53 + .../tileentity/recipe/beamline/RecipeTC.java | 72 ++ .../recipe/beamline/SourceChamberFrontend.java | 24 + .../recipe/beamline/TargetChamberFrontend.java | 109 ++ .../com/elisis/gtnhlanth/loader/BotRecipes.java | 13 +- .../com/elisis/gtnhlanth/loader/RecipeLoader.java | 766 +++++++++++++- .../gtnhlanth/util/DescTextLocalization.java | 16 +- src/main/java/com/elisis/gtnhlanth/util/Util.java | 55 + .../com/elisis/gtnhlanth/xmod/nei/NEI_Config.java | 1 + .../GT_TileEntity_ElectricImplosionCompressor.java | 19 +- .../blocks/tileEntity/FuelRefineFactory.java | 5 +- .../loader/NeutronActivatorLoader.java | 7 +- src/main/java/gregtech/api/enums/ItemList.java | 3 +- src/main/java/gregtech/api/enums/Textures.java | 2 + .../api/util/GT_Multiblock_Tooltip_Builder.java | 14 + .../gregtech/common/blocks/GT_Block_Casings5.java | 2 + .../machines/multiblock/LayeredCokeBattery.java | 9 +- 43 files changed, 5965 insertions(+), 59 deletions(-) create mode 100644 src/main/java/com/elisis/gtnhlanth/common/beamline/BeamInformation.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/beamline/BeamLinePacket.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/beamline/IConnectsToBeamline.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/beamline/Particle.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/beamline/TileBeamline.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/block/AntennaCasing.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/block/Casing.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/block/ShieldedAccGlass.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/hatch/TileBusInputFocus.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchBeamlineConnector.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchInputBeamline.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchOutputBeamline.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/item/ICanFocus.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/item/LanthItem.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/item/MaskList.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/item/ParticleItem.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/item/PhotolithographicMask.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/LINAC.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/SourceChamber.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/Synchrotron.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/TargetChamber.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/recipe/beamline/BeamlineRecipeAdder2.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/recipe/beamline/BeamlineRecipeLoader.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/recipe/beamline/RecipeSC.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/recipe/beamline/RecipeTC.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/recipe/beamline/SourceChamberFrontend.java create mode 100644 src/main/java/com/elisis/gtnhlanth/common/tileentity/recipe/beamline/TargetChamberFrontend.java create mode 100644 src/main/java/com/elisis/gtnhlanth/util/Util.java (limited to 'src/main/java') diff --git a/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java b/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java index 275e8ae107..8ffdc0b5a1 100644 --- a/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java +++ b/src/main/java/com/elisis/gtnhlanth/GTNHLanthanides.java @@ -1,18 +1,15 @@ package com.elisis.gtnhlanth; -import java.util.Arrays; import java.util.logging.Logger; -import net.minecraftforge.oredict.OreDictionary; - import com.elisis.gtnhlanth.common.CommonProxy; import com.elisis.gtnhlanth.common.register.BotWerkstoffMaterialPool; import com.elisis.gtnhlanth.common.register.LanthItemList; import com.elisis.gtnhlanth.common.register.WerkstoffMaterialPool; +import com.elisis.gtnhlanth.common.tileentity.recipe.beamline.BeamlineRecipeLoader; import com.elisis.gtnhlanth.loader.BotRecipes; import com.elisis.gtnhlanth.loader.RecipeLoader; import com.github.bartimaeusnek.bartworks.API.WerkstoffAdderRegistry; -import com.github.bartimaeusnek.bartworks.system.material.Werkstoff; import cpw.mods.fml.common.Mod; import cpw.mods.fml.common.Mod.EventHandler; @@ -21,8 +18,6 @@ import cpw.mods.fml.common.event.FMLInitializationEvent; import cpw.mods.fml.common.event.FMLLoadCompleteEvent; import cpw.mods.fml.common.event.FMLPostInitializationEvent; import cpw.mods.fml.common.event.FMLPreInitializationEvent; -import gregtech.api.enums.OrePrefixes; -import gregtech.api.util.GT_Log; @Mod( modid = Tags.MODID, @@ -46,9 +41,13 @@ public class GTNHLanthanides { @EventHandler public static void preInit(FMLPreInitializationEvent e) { + WerkstoffAdderRegistry.addWerkstoffAdder(new WerkstoffMaterialPool()); WerkstoffAdderRegistry.addWerkstoffAdder(new BotWerkstoffMaterialPool()); - LanthItemList.register(); + + LanthItemList.registerTypical(); + LanthItemList.registerGTMTE(); + // GregTech_API.sAfterGTPostload.add(new ZPMRubberChanges()); proxy.preInit(e); } @@ -61,37 +60,45 @@ public class GTNHLanthanides { @EventHandler public static void postInit(FMLPostInitializationEvent e) { + RecipeLoader.loadGeneral(); RecipeLoader.loadLanthanideRecipes(); RecipeLoader.addRandomChemCrafting(); + RecipeLoader.loadAccelerator(); + + BeamlineRecipeLoader.load(); + BotRecipes.addGTRecipe(); // RecipeLoader.loadZylonRecipes(); proxy.postInit(e); // GT_Log.out.print(FluidRegistry.getFluid("Sodium Tungstate").getName()); - GT_Log.out.print( - Arrays.toString( - Werkstoff.werkstoffNameHashMap.keySet() - .toArray())); - GT_Log.out.print( - Arrays.toString( - Werkstoff.werkstoffHashMap.keySet() - .toArray())); - - GT_Log.out.print( - "HMMM " + Arrays.toString( - OreDictionary - .getOreIDs(WerkstoffMaterialPool.DephosphatedSamariumConcentrate.get(OrePrefixes.dust, 1)))); + // GT_Log.out.print(Arrays.toString(Werkstoff.werkstoffNameHashMap.keySet().toArray())); + // GT_Log.out.print(Arrays.toString(Werkstoff.werkstoffHashMap.keySet().toArray())); + + /* + * GT_Log.out.print("HMMM " + Arrays.toString(OreDictionary.getOreIDs( + * WerkstoffMaterialPool.DephosphatedSamariumConcentrate.get(OrePrefixes.dust, 1)))); + */ } @EventHandler public static void onModLoadingComplete(FMLLoadCompleteEvent e) { - GT_Log.out.print("AAAAAAAAAAAAAA"); + // GT_Log.out.print("AAAAAAAAAAAAAA " + new + // ItemStack(LanthItemList.maskMap.get(MaskList.CPU)).getUnlocalizedName()); // - GT_Log.out.print("We are done loading"); + // GT_Log.out.print("We are done loading"); BotRecipes.removeRecipes(); RecipeLoader.removeCeriumSources(); - GT_Log.out.print("blah blah " + WerkstoffMaterialPool.PTMEGElastomer.hasGenerationFeature(OrePrefixes.ingot)); + /* + * for (GT_ItemStack stack : BeamlineRecipeAdder.instance.TargetChamberRecipes.mRecipeItemMap.keySet()) { + * GT_Log.out.print(" Recipes for: " + stack.mItem.getUnlocalizedName() + ": "); for (GT_Recipe recipe : + * BeamlineRecipeAdder.instance.TargetChamberRecipes.mRecipeItemMap.get(stack)) { + * GT_Log.out.print(Arrays.toString(recipe.mOutputs)); } } + */ + + // GT_Log.out.print("blah blah " + + // WerkstoffMaterialPool.PTMEGElastomer.hasGenerationFeature(OrePrefixes.ingot)); } } diff --git a/src/main/java/com/elisis/gtnhlanth/common/beamline/BeamInformation.java b/src/main/java/com/elisis/gtnhlanth/common/beamline/BeamInformation.java new file mode 100644 index 0000000000..9c10703c2e --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/beamline/BeamInformation.java @@ -0,0 +1,51 @@ +package com.elisis.gtnhlanth.common.beamline; + +public class BeamInformation { + + private float energy; // in keV + private int rate; + + private Particle particle; + private int particleId; + + private float focus; + + public BeamInformation(float energy, int rate, int particleId, float focus) { + this.energy = energy; + this.rate = rate; + this.particleId = particleId; + this.particle = Particle.values()[particleId]; + this.focus = focus; + } + + public float getEnergy() { + return this.energy; + } + + public int getRate() { + return this.rate; + } + + public Particle getParticle() { + return this.particle; + } + + public int getParticleId() { + return this.particleId; + } + + public float getFocus() { + return this.focus; + } + + @Override + public String toString() { + return "Energy=" + this.getEnergy() + + ",Rate=" + + this.getRate() + + ",Particle=" + + this.getParticleId() + + ",Focus=" + + this.getFocus(); + } +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/beamline/BeamLinePacket.java b/src/main/java/com/elisis/gtnhlanth/common/beamline/BeamLinePacket.java new file mode 100644 index 0000000000..bbd712a9b0 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/beamline/BeamLinePacket.java @@ -0,0 +1,51 @@ +package com.elisis.gtnhlanth.common.beamline; + +import net.minecraft.nbt.NBTTagCompound; + +import com.github.technus.tectech.mechanics.dataTransport.DataPacket; + +public class BeamLinePacket extends DataPacket { + + public BeamLinePacket(BeamInformation content) { + super(content); + } + + public BeamLinePacket(NBTTagCompound compound) { + super(compound); + } + + @Override + protected BeamInformation contentFromNBT(NBTTagCompound nbt) { + /* + * NBTTagCompound compound = nbt.getCompoundTag("beamline"); + */ + return new BeamInformation( + nbt.getFloat("energy"), + nbt.getInteger("rate"), + nbt.getInteger("particleId"), + nbt.getInteger("focus")); + } + + @Override + protected NBTTagCompound contentToNBT() { + + NBTTagCompound compound = new NBTTagCompound(); + + compound.setFloat("energy", content.getEnergy()); + compound.setInteger("rate", content.getRate()); + compound.setInteger("particleId", content.getParticleId()); + compound.setFloat("focus", content.getFocus()); + + return compound; + } + + @Override + public boolean extraCheck() { + return true; + } + + @Override + protected BeamInformation unifyContentWith(BeamInformation arg0) { + throw new NoSuchMethodError("Unavailable to unify beam info data packet"); + } +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/beamline/IConnectsToBeamline.java b/src/main/java/com/elisis/gtnhlanth/common/beamline/IConnectsToBeamline.java new file mode 100644 index 0000000000..763365647c --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/beamline/IConnectsToBeamline.java @@ -0,0 +1,14 @@ +package com.elisis.gtnhlanth.common.beamline; + +import net.minecraftforge.common.util.ForgeDirection; + +import gregtech.api.interfaces.metatileentity.IMetaTileEntity; + +public interface IConnectsToBeamline extends IMetaTileEntity { + + boolean canConnect(ForgeDirection side); + + IConnectsToBeamline getNext(IConnectsToBeamline source); + + boolean isDataInputFacing(ForgeDirection side); +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/beamline/Particle.java b/src/main/java/com/elisis/gtnhlanth/common/beamline/Particle.java new file mode 100644 index 0000000000..f6bc2517f4 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/beamline/Particle.java @@ -0,0 +1,71 @@ +package com.elisis.gtnhlanth.common.beamline; + +import net.minecraft.util.StatCollector; + +public enum Particle { + + ELECTRON(true, 0, 0.511f, 5000, "electron", "e\u207B", -1, null), + PHOTON(false, 1, 0, 0, "photon", "\u03B3", 0, null), + NEUTRON(false, 2, 939.57f, 15000, "neutron", "n\u2070", 0, null), + PROTON(true, 3, 938.27f, 15000, "proton", "p\u207A", 1, null), + ALPHA(true, 4, 3727.38f, 8000, "alpha", "\u03B1", 2, null); + + private boolean canAcc; + + private float restMass; // in MeV + + private float maxSourceEnergy; // in keV + + private String name; + private String shortName; + + private float charge; // in multiples of elemental charge + + private String chargeSpecial; + + private Particle(boolean canAcc, int id, float restMass, float maxSourceEnergy, String name, String shortName, + float charge, String chargeSpecial) { // ID + // is + // symbolic + // only + this.canAcc = canAcc; + this.restMass = restMass; + this.maxSourceEnergy = maxSourceEnergy; + this.name = name; + this.shortName = shortName; + this.charge = charge; + this.chargeSpecial = chargeSpecial; + } + + public float getMass() { + return this.restMass; + } + + public float getCharge() { + return this.charge; + } + + public String getChargeSpecial() { + return this.chargeSpecial; + } + + public boolean canAccelerate() { + return this.canAcc; + } + + public float maxSourceEnergy() { + return this.maxSourceEnergy; + } + + public String getName() { + return this.name; + } + + public String getLocalisedName() { + return StatCollector.translateToLocal("particle." + this.name) + " (" + this.shortName + ")"; + } + + public static Particle getParticleFromId(int id) { + return Particle.values()[id]; + } +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/beamline/TileBeamline.java b/src/main/java/com/elisis/gtnhlanth/common/beamline/TileBeamline.java new file mode 100644 index 0000000000..058234d2bb --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/beamline/TileBeamline.java @@ -0,0 +1,256 @@ +package com.elisis.gtnhlanth.common.beamline; + +import static gregtech.api.enums.Dyes.MACHINE_METAL; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.GT_Mod; +import gregtech.api.enums.Dyes; +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.BaseMetaPipeEntity; +import gregtech.api.metatileentity.MetaPipeEntity; +import gregtech.common.GT_Client; +import gregtech.common.render.GT_TextureBuilder; + +public class TileBeamline extends MetaPipeEntity implements IConnectsToBeamline { + + private static Textures.BlockIcons.CustomIcon pipe; + + private byte connectionCount = 0; + + private boolean active; + + public TileBeamline(int id, String name, String nameRegional) { + super(id, name, nameRegional, 0); + } + + public TileBeamline(String name) { + super(name, 0); + } + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + if ((aTick & 31) == 31) { + mConnections = 0; + connectionCount = 0; + + for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) { + ForgeDirection d1 = dir.getOpposite(); + TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(dir); + if (tTileEntity instanceof IConnectsToBeamline) { + if (((IConnectsToBeamline) tTileEntity).canConnect(d1)) { + mConnections |= 1 << dir.ordinal(); + connectionCount++; + } + } else if (tTileEntity instanceof IGregTechTileEntity) { + IMetaTileEntity meta = ((IGregTechTileEntity) tTileEntity).getMetaTileEntity(); + if (meta instanceof IConnectsToBeamline) { + if (((IConnectsToBeamline) meta).canConnect(d1)) { + mConnections |= 1 << dir.ordinal(); + connectionCount++; + } + } + } + } + } + } else if (aBaseMetaTileEntity.isClientSide() && GT_Client.changeDetected == 4) { + aBaseMetaTileEntity.issueTextureUpdate(); + } + } + + @Override + public byte getTileEntityBaseType() { + return 7; + } + + @Override + public void loadNBTData(NBTTagCompound arg0) {} + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity arg0) { + return new TileBeamline(mName); + } + + @Override + public void saveNBTData(NBTTagCompound arg0) {} + + @Override + public float getThickNess() { + if (GT_Mod.instance.isClientSide() && GT_Client.hideValue == 1) { + return 0.0625F; + } + return 0.5f; + } + + @Override + public boolean renderInside(ForgeDirection arg0) { + return false; + } + + @Override + public boolean canConnect(ForgeDirection side) { + return true; + } + + // Largely taken from Tec's DataPipe + + @Override + public IConnectsToBeamline getNext(IConnectsToBeamline source) { + + for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) { + + if ((mConnections & 1 << dir.ordinal()) == 0) { + continue; + } + + TileEntity next = this.getBaseMetaTileEntity() + .getTileEntityAtSide(dir); + if (next instanceof IConnectsToBeamline && next != source) { + + if (((IConnectsToBeamline) next).isDataInputFacing(dir.getOpposite())) { + return (IConnectsToBeamline) next; + } + + } else if (next instanceof IGregTechTileEntity) { + + IMetaTileEntity meta = ((IGregTechTileEntity) next).getMetaTileEntity(); + if (meta instanceof IConnectsToBeamline && meta != source) { + + if (meta instanceof TileBeamline && (((TileBeamline) meta).connectionCount == 2)) { + + ((TileBeamline) meta).markUsed(); + return (IConnectsToBeamline) meta; + } + + if (((IConnectsToBeamline) meta).isDataInputFacing(dir.getOpposite())) { + + return (IConnectsToBeamline) meta; + } + } + } + } + + return null; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IIconRegister aBlockIconRegister) { + pipe = new Textures.BlockIcons.CustomIcon("iconsets/pipe"); + super.registerIcons(aBlockIconRegister); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, ForgeDirection aSide, int aConnections, + int aColorIndex, boolean aConnected, boolean aRedstone) { + return new ITexture[] { new GT_TextureBuilder().addIcon(pipe) + .build(), + new GT_TextureBuilder().addIcon(pipe) + .setRGBA(Dyes.getModulation((byte) aColorIndex, MACHINE_METAL.getRGBA())) + .build() }; + } + + public void markUsed() { + this.active = true; + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return true; + } + + @Override + public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) { + float tSpace = (1f - 0.375f) / 2; + float tSide0 = tSpace; + float tSide1 = 1f - tSpace; + float tSide2 = tSpace; + float tSide3 = 1f - tSpace; + float tSide4 = tSpace; + float tSide5 = 1f - tSpace; + + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.DOWN) != 0) { + tSide0 = tSide2 = tSide4 = 0; + tSide3 = tSide5 = 1; + } + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.UP) != 0) { + tSide2 = tSide4 = 0; + tSide1 = tSide3 = tSide5 = 1; + } + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.NORTH) != 0) { + tSide0 = tSide2 = tSide4 = 0; + tSide1 = tSide5 = 1; + } + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.SOUTH) != 0) { + tSide0 = tSide4 = 0; + tSide1 = tSide3 = tSide5 = 1; + } + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.WEST) != 0) { + tSide0 = tSide2 = tSide4 = 0; + tSide1 = tSide3 = 1; + } + if (getBaseMetaTileEntity().getCoverIDAtSide(ForgeDirection.EAST) != 0) { + tSide0 = tSide2 = 0; + tSide1 = tSide3 = tSide5 = 1; + } + + byte tConn = ((BaseMetaPipeEntity) getBaseMetaTileEntity()).mConnections; + if ((tConn & 1 << ForgeDirection.DOWN.ordinal()) != 0) { + tSide0 = 0f; + } + if ((tConn & 1 << ForgeDirection.UP.ordinal()) != 0) { + tSide1 = 1f; + } + if ((tConn & 1 << ForgeDirection.NORTH.ordinal()) != 0) { + tSide2 = 0f; + } + if ((tConn & 1 << ForgeDirection.SOUTH.ordinal()) != 0) { + tSide3 = 1f; + } + if ((tConn & 1 << ForgeDirection.WEST.ordinal()) != 0) { + tSide4 = 0f; + } + if ((tConn & 1 << ForgeDirection.EAST.ordinal()) != 0) { + tSide5 = 1f; + } + + return AxisAlignedBB + .getBoundingBox(aX + tSide4, aY + tSide0, aZ + tSide2, aX + tSide5, aY + tSide1, aZ + tSide3); + } + + @Override + public String[] getDescription() { + return new String[] { StatCollector.translateToLocal("beamline.pipe.desc.0"), // Beamline pipe + EnumChatFormatting.AQUA + StatCollector.translateToLocal("beamline.pipe.desc.1"), // Does not cross, split + // or turn + "Added by " + EnumChatFormatting.GREEN + "GTNH: Lanthanides" + + }; + } + + @Override + public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } + + @Override + public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, ForgeDirection side, + ItemStack aStack) { + return false; + } +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/block/AntennaCasing.java b/src/main/java/com/elisis/gtnhlanth/common/block/AntennaCasing.java new file mode 100644 index 0000000000..ea7d8423df --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/block/AntennaCasing.java @@ -0,0 +1,15 @@ +package com.elisis.gtnhlanth.common.block; + +public class AntennaCasing extends Casing { + + private int antennaTier; + + public AntennaCasing(int tier) { + super("antenna_t" + tier); + this.antennaTier = tier; + } + + public int getTier() { + return this.antennaTier; + } +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/block/Casing.java b/src/main/java/com/elisis/gtnhlanth/common/block/Casing.java new file mode 100644 index 0000000000..71f581efbe --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/block/Casing.java @@ -0,0 +1,80 @@ +package com.elisis.gtnhlanth.common.block; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.init.Blocks; +import net.minecraft.util.IIcon; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +import com.elisis.gtnhlanth.Tags; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; + +public class Casing extends Block { + + @SideOnly(Side.CLIENT) + protected IIcon[] texture; + + private String name; + + public Casing(String name) { + super(Material.iron); + this.name = name; + this.setBlockTextureName(Tags.MODID + ":casing." + name); + GregTech_API.registerMachineBlock(this, -1); + } + + public Casing(String name, Material material) { + super(material); + this.name = name; + this.setBlockTextureName(Tags.MODID + ":casing." + name); + GregTech_API.registerMachineBlock(this, -1); + } + + @Override + public int damageDropped(int meta) { + return meta; + } + + @Override + public String getHarvestTool(int aMeta) { + return "wrench"; + } + + @Override + public int getHarvestLevel(int aMeta) { + return 2; + } + + @Override + public float getBlockHardness(World aWorld, int aX, int aY, int aZ) { + return Blocks.iron_block.getBlockHardness(aWorld, aX, aY, aZ); + } + + @Override + public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + super.breakBlock(aWorld, aX, aY, aZ, aBlock, aMetaData); + } + + @Override + public void onBlockAdded(World aWorld, int aX, int aY, int aZ) { + super.onBlockAdded(aWorld, aX, aY, aZ); + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + + @Override + public String getUnlocalizedName() { + return "casing." + this.name; + } + + @Override + public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) { + return false; + } + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/block/ShieldedAccGlass.java b/src/main/java/com/elisis/gtnhlanth/common/block/ShieldedAccGlass.java new file mode 100644 index 0000000000..41bebcf170 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/block/ShieldedAccGlass.java @@ -0,0 +1,68 @@ +package com.elisis.gtnhlanth.common.block; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.entity.EnumCreatureType; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +import com.elisis.gtnhlanth.Tags; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; + +public class ShieldedAccGlass extends Block { + + private static final String name = "shielded_accelerator_glass"; + + public ShieldedAccGlass() { + super(Material.glass); + this.setBlockName("casing." + name); + this.setBlockTextureName(Tags.MODID + ":casing." + name); + GregTech_API.registerMachineBlock(this, -1); + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public int getRenderBlockPass() { + return 1; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public void onBlockAdded(World aWorld, int aX, int aY, int aZ) { + if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } + + @Override + public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) { + if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } + + @Override + @SideOnly(Side.CLIENT) + public boolean shouldSideBeRendered(IBlockAccess worldClient, int xCoord, int yCoord, int zCoord, int aSide) { + if (worldClient.getBlock(xCoord, yCoord, zCoord) instanceof ShieldedAccGlass) return false; + return super.shouldSideBeRendered(worldClient, xCoord, yCoord, zCoord, aSide); + } + + @Override + public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) { + return false; + } + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/hatch/TileBusInputFocus.java b/src/main/java/com/elisis/gtnhlanth/common/hatch/TileBusInputFocus.java new file mode 100644 index 0000000000..43a6df9366 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/hatch/TileBusInputFocus.java @@ -0,0 +1,85 @@ +package com.elisis.gtnhlanth.common.hatch; + +import net.minecraft.item.ItemStack; +import net.minecraftforge.common.util.ForgeDirection; + +import com.elisis.gtnhlanth.common.item.ICanFocus; +import com.elisis.gtnhlanth.util.Util; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.objects.GT_RenderedTexture; +import gtPlusPlus.api.objects.data.AutoMap; +import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.nbthandlers.GT_MetaTileEntity_Hatch_NbtConsumable; +import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock; + +public class TileBusInputFocus extends GT_MetaTileEntity_Hatch_NbtConsumable { + + private static final int INPUT_SLOTS = 4; + + public TileBusInputFocus(int id, String name, String nameRegional) { + super(id, name, nameRegional, 0, INPUT_SLOTS, "Input Bus for Foci", false); + } + + public TileBusInputFocus(String name, String[] descriptionArray, ITexture[][][] textures) { + super(name, 0, INPUT_SLOTS, descriptionArray, false, textures); + } + + @Override + public int getInputSlotCount() { + return INPUT_SLOTS; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public AutoMap getItemsValidForUsageSlots() { + return new AutoMap<>(); + } + + @Override + public boolean isItemValidForUsageSlot(ItemStack aStack) { + + if (this.getContentUsageSlots() + .size() == 0) { + return aStack.getItem() instanceof ICanFocus; + } else { + return false; + } + + } + + @Override + public String getNameGUI() { + return "Focus Input Bus"; + } + + public void depleteFocusDurability(int damage) { + + ItemStack stack = this.getContentUsageSlots() + .toArray()[0]; + + Util.depleteDurabilityOfStack(stack, damage); + + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, new GT_RenderedTexture(TexturesGtBlock.Overlay_Bus_Catalyst) }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, new GT_RenderedTexture(TexturesGtBlock.Overlay_Bus_Catalyst) }; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new TileBusInputFocus(mName, mDescriptionArray, mTextures); + } + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchBeamlineConnector.java b/src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchBeamlineConnector.java new file mode 100644 index 0000000000..c0fa41774b --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchBeamlineConnector.java @@ -0,0 +1,136 @@ +package com.elisis.gtnhlanth.common.hatch; + +import static com.github.technus.tectech.util.CommonValues.MOVE_AT; +import static net.minecraft.util.StatCollector.translateToLocalFormatted; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumChatFormatting; +import net.minecraftforge.fluids.FluidStack; + +import org.apache.commons.lang3.reflect.FieldUtils; + +import com.elisis.gtnhlanth.common.beamline.IConnectsToBeamline; +import com.github.technus.tectech.mechanics.dataTransport.DataPacket; +import com.github.technus.tectech.util.TT_Utility; + +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch; + +public abstract class TileHatchBeamlineConnector extends GT_MetaTileEntity_Hatch + implements IConnectsToBeamline { + + private String clientLocale = "en_US"; + + public T q; + + public short id = -1; + + protected TileHatchBeamlineConnector(int aID, String aName, String aNameRegional, int aTier, String descr) { + super(aID, aName, aNameRegional, aTier, 0, descr); + TT_Utility.setTier(aTier, this); + } + + protected TileHatchBeamlineConnector(String aName, int aTier, String aDescription, ITexture[][][] aTextures) { + super(aName, aTier, 0, aDescription, aTextures); + } + + @Override + public void saveNBTData(NBTTagCompound aNBT) { + super.saveNBTData(aNBT); + aNBT.setShort("eID", id); + if (q != null) { + aNBT.setTag("eDATA", q.toNbt()); + } + } + + @Override + public void loadNBTData(NBTTagCompound aNBT) { + super.loadNBTData(aNBT); + id = aNBT.getShort("eID"); + if (aNBT.hasKey("eDATA")) { + q = loadPacketFromNBT(aNBT.getCompoundTag("eDATA")); + } + } + + protected abstract T loadPacketFromNBT(NBTTagCompound nbt); + + @Override + public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) { + if (aBaseMetaTileEntity.isServerSide()) { + if (MOVE_AT == aTick % 20) { + if (q == null) { + getBaseMetaTileEntity().setActive(false); + } else { + getBaseMetaTileEntity().setActive(true); + moveAround(aBaseMetaTileEntity); + } + } + } + } + + public abstract void moveAround(IGregTechTileEntity aBaseMetaTileEntity); + + @Override + public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) { + if (aBaseMetaTileEntity.isClientSide()) { + return true; + } + try { + EntityPlayerMP player = (EntityPlayerMP) aPlayer; + clientLocale = (String) FieldUtils.readField(player, "translator", true); + } catch (Exception e) { + clientLocale = "en_US"; + } + return true; + } + + @Override + public boolean isAccessAllowed(EntityPlayer aPlayer) { + return true; + } + + @Override + public boolean isFluidInputAllowed(FluidStack aFluid) { + return false; + } + + @Override + public boolean isValidSlot(int aIndex) { + return false; + } + + @Override + public boolean isGivingInformation() { + return true; + } + + @Override + public String[] getInfoData() { + if (id > 0) { + return new String[] { + translateToLocalFormatted("tt.keyword.ID", clientLocale) + ": " + EnumChatFormatting.AQUA + id, + translateToLocalFormatted("tt.keyword.Content", clientLocale) + ": " + + EnumChatFormatting.AQUA + + (q != null ? q.getContentString() : 0), + translateToLocalFormatted("tt.keyword.PacketHistory", clientLocale) + ": " + + EnumChatFormatting.RED + + (q != null ? q.getTraceSize() : 0), }; + } + return new String[] { + translateToLocalFormatted("tt.keyword.Content", clientLocale) + ": " + + EnumChatFormatting.AQUA + + (q != null ? q.getContentString() : 0), + translateToLocalFormatted("tt.keyword.PacketHistory", clientLocale) + ": " + + EnumChatFormatting.RED + + (q != null ? q.getTraceSize() : 0), }; + } + + @Override + public String[] getDescription() { + return new String[] { "Text description shouldn't be seen, report to Tec", "High speed fibre optics connector.", + EnumChatFormatting.AQUA + "Must be painted to work" }; + } +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchInputBeamline.java b/src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchInputBeamline.java new file mode 100644 index 0000000000..e5a5c9df2f --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchInputBeamline.java @@ -0,0 +1,131 @@ +package com.elisis.gtnhlanth.common.hatch; + +import static gregtech.api.enums.Dyes.MACHINE_METAL; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import com.elisis.gtnhlanth.common.beamline.BeamLinePacket; +import com.elisis.gtnhlanth.common.beamline.IConnectsToBeamline; +import com.github.technus.tectech.util.TT_Utility; + +import gregtech.api.enums.Dyes; +import gregtech.api.enums.Textures; +import gregtech.api.interfaces.ITexture; +import gregtech.api.interfaces.tileentity.IGregTechTileEntity; +import gregtech.api.metatileentity.MetaTileEntity; +import gregtech.api.objects.GT_RenderedTexture; + +public class TileHatchInputBeamline extends TileHatchBeamlineConnector { + + private boolean delay = true; + + private static final String activeIconPath = "iconsets/OVERLAY_BI_ACTIVE"; + private static final String sideIconPath = "iconsets/OVERLAY_BI_SIDES"; + private static final String connIconPath = "iconsets/BI_CONN"; + + private static final Textures.BlockIcons.CustomIcon activeIcon = new Textures.BlockIcons.CustomIcon(activeIconPath); + private static final Textures.BlockIcons.CustomIcon sideIcon = new Textures.BlockIcons.CustomIcon(sideIconPath); + private static final Textures.BlockIcons.CustomIcon connIcon = new Textures.BlockIcons.CustomIcon(connIconPath); + + public TileHatchInputBeamline(int id, String name, String nameRegional, int tier) { + + super(id, name, nameRegional, tier, ""); + TT_Utility.setTier(tier, this); + } + + public TileHatchInputBeamline(String name, int tier, String desc, ITexture[][][] textures) { + super(name, tier, desc, textures); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GT_RenderedTexture( + activeIcon, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GT_RenderedTexture(connIcon) }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GT_RenderedTexture( + sideIcon, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GT_RenderedTexture(connIcon) }; + } + + @Override + public MetaTileEntity newMetaEntity(IGregTechTileEntity tile) { + return new TileHatchInputBeamline(mName, mTier, mDescription, mTextures); + } + + @Override + protected BeamLinePacket loadPacketFromNBT(NBTTagCompound tag) { + return new BeamLinePacket(tag); + } + + @Override + public boolean isInputFacing(ForgeDirection side) { + return side == getBaseMetaTileEntity().getFrontFacing(); + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return isInputFacing(side); + } + + @Override + public boolean isOutputFacing(ForgeDirection aSide) { + return false; + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isSimpleMachine() { + return true; + } + + @Override + public boolean canConnect(ForgeDirection side) { + return isInputFacing(side); + } + + @Override + public IConnectsToBeamline getNext(IConnectsToBeamline source) { + return null; + } + + @Override + public String[] getDescription() { + return null; + } + + public void setContents(BeamLinePacket in) { + if (in == null) { + this.q = null; + } else { + if (in.getContent() + .getRate() > 0) { + this.q = in; + delay = true; + } else { + this.q = null; + } + } + } + + @Override + public void moveAround(IGregTechTileEntity tile) { + if (delay) { + delay = false; + } else { + this.setContents(null); + } + } +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchOutputBeamline.java b/src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchOutputBeamline.java new file mode 100644 index 0000000000..5483ee1d0f --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/hatch/TileHatchOutputBeamline.java @@ -0,0 +1,138 @@ +package com.elisis.gtnhlanth.common.hatch; + +import static gregtech.api.enums.Dyes.MACHINE_METAL; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraftforge.common.util.ForgeDirection; + +import com.elisis.gtnhlanth.common.beamline.BeamLinePacket; +import com.elisis.gtnhlanth.common.beamline.IConnectsToBeamline; +import com.elisis.gtnhlanth.common.beamline.TileBeamline; +import com.github.technus.tectech.util.TT_Utility; + +import gregtech.api.enums.Dyes; +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.objects.GT_RenderedTexture; + +public class TileHatchOutputBeamline extends TileHatchBeamlineConnector implements IConnectsToBeamline { + + private static final String activeIconPath = "iconsets/OVERLAY_BO_ACTIVE"; + private static final String sideIconPath = "iconsets/OVERLAY_BO_SIDES"; + private static final String connIconPath = "iconsets/BO_CONN"; + + private static final Textures.BlockIcons.CustomIcon activeIcon = new Textures.BlockIcons.CustomIcon(activeIconPath); + private static final Textures.BlockIcons.CustomIcon sideIcon = new Textures.BlockIcons.CustomIcon(sideIconPath); + private static final Textures.BlockIcons.CustomIcon connIcon = new Textures.BlockIcons.CustomIcon(connIconPath); + + public TileHatchOutputBeamline(int id, String name, String nameRegional, int tier) { + super(id, name, nameRegional, tier, ""); + TT_Utility.setTier(tier, this); + } + + public TileHatchOutputBeamline(String aName, int aTier, String aDescription, ITexture[][][] aTextures) { + super(aName, aTier, aDescription, aTextures); + } + + @Override + public ITexture[] getTexturesActive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GT_RenderedTexture( + activeIcon, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GT_RenderedTexture(connIcon) }; + } + + @Override + public ITexture[] getTexturesInactive(ITexture aBaseTexture) { + return new ITexture[] { aBaseTexture, + new GT_RenderedTexture( + sideIcon, + Dyes.getModulation(getBaseMetaTileEntity().getColorization(), MACHINE_METAL.getRGBA())), + new GT_RenderedTexture(connIcon) }; + } + + @Override + public IConnectsToBeamline getNext(IConnectsToBeamline source) { + + IGregTechTileEntity base = this.getBaseMetaTileEntity(); + IGregTechTileEntity next = base.getIGregTechTileEntityAtSide(base.getFrontFacing()); + + if (next == null) { + return null; + } + + IMetaTileEntity meta = next.getMetaTileEntity(); + if (meta instanceof TileBeamline) { + + ((TileBeamline) meta).markUsed(); + return (IConnectsToBeamline) meta; + + } else if (meta instanceof TileHatchInputBeamline && ((TileHatchInputBeamline) meta).canConnect( + base.getFrontFacing() + .getOpposite())) { + + return (IConnectsToBeamline) meta; + } + + return null; + } + + @Override + public void moveAround(IGregTechTileEntity aBaseMetaTileEntity) { + IConnectsToBeamline current = this, source = this, next; + int range = 0; + while ((next = current.getNext(source)) != null && range++ < 100) { + if (next instanceof TileHatchInputBeamline) { + ((TileHatchInputBeamline) next).setContents(q); + break; + } + source = current; + current = next; + } + q = null; + } + + @Override + protected BeamLinePacket loadPacketFromNBT(NBTTagCompound nbt) { + return new BeamLinePacket(nbt); + } + + @Override + public boolean canConnect(ForgeDirection side) { + return this.isOutputFacing(side); + } + + @Override + public boolean isDataInputFacing(ForgeDirection side) { + return this.isInputFacing(side); + } + + @Override + public boolean isFacingValid(ForgeDirection facing) { + return true; + } + + @Override + public boolean isInputFacing(ForgeDirection aSide) { + return false; + } + + @Override + public boolean isOutputFacing(ForgeDirection side) { + return side == this.getBaseMetaTileEntity() + .getFrontFacing(); + } + + @Override + public String[] getDescription() { + return null; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity arg0) { + return new TileHatchOutputBeamline(mName, mTier, mDescription, mTextures); + } +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/item/ICanFocus.java b/src/main/java/com/elisis/gtnhlanth/common/item/ICanFocus.java new file mode 100644 index 0000000000..21cdb636c5 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/item/ICanFocus.java @@ -0,0 +1,5 @@ +package com.elisis.gtnhlanth.common.item; + +public interface ICanFocus { + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/item/LanthItem.java b/src/main/java/com/elisis/gtnhlanth/common/item/LanthItem.java new file mode 100644 index 0000000000..062b9b1a91 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/item/LanthItem.java @@ -0,0 +1,15 @@ +package com.elisis.gtnhlanth.common.item; + +import net.minecraft.item.Item; + +import com.elisis.gtnhlanth.Tags; + +public class LanthItem extends Item { + + public LanthItem(String name) { + super(); + this.setUnlocalizedName(name); + this.setTextureName(Tags.MODID + ":" + name); + } + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/item/MaskList.java b/src/main/java/com/elisis/gtnhlanth/common/item/MaskList.java new file mode 100644 index 0000000000..bbc2d1c18a --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/item/MaskList.java @@ -0,0 +1,147 @@ +package com.elisis.gtnhlanth.common.item; + +import net.minecraft.item.ItemStack; + +import gregtech.api.enums.Dyes; +import gregtech.api.enums.ItemList; + +public enum MaskList { + + // There are absolutely better ways of doing this than a GT Materials-esque Enum, some method of automatically + // scraping the wafer types would be preferable in particular + // Use Dyes._NULL to indicate a wafer's lack of a dedicated lens instead of null, if the wafer's mask is to be + // generated + // Ignore last argument if using all wafers + ERROR("error", "ERROR", 0, "", null, null, 0, 0, 0, 0, null), + BLANK1("blank1", "T1 Blank", 0, "VISIBLE", null, null, 0, 0, 0, 0, null), + BLANK2("blank2", "T2 Blank", 0, "UV", null, null, 0, 0, 0, 0, null), + BLANK3("blank3", "T3 Blank", 0, "X-RAY", null, null, 0, 0, 0, 0, null), + ILC("ilc", "Integrated Logic Circuit", 100, "", BLANK1, Dyes.dyeRed, 0.5e-3f, 4e-3f, 50, 1, + ItemList.Circuit_Wafer_ILC.get(1)), + RAM("ram", "Random Access Memory", 200, "", BLANK1, Dyes.dyeCyan, 2e-3f, 4e-3f, 60, 2, + ItemList.Circuit_Wafer_Ram.get(1), ItemList.Circuit_Silicon_Wafer), + NAND("nand", "NAND", 200, "", BLANK2, Dyes._NULL, 7e-3f, 12e-3f, 50, 1, ItemList.Circuit_Wafer_NAND.get(1), + ItemList.Circuit_Silicon_Wafer), // NAND uses only Ender Pearl lens, don't ask me why + NOR("nor", "NOR", 100, "", BLANK2, Dyes._NULL, 8e-3f, 10e-3f, 50, 1, ItemList.Circuit_Wafer_NOR.get(1), + ItemList.Circuit_Silicon_Wafer, ItemList.Circuit_Silicon_Wafer2), // Same as above, but with ender eye + CPU("cpu", "Central Processing Unit", 10, "", BLANK2, Dyes.dyeWhite, 6e-3f, 12e-3f, 50, 2, + ItemList.Circuit_Wafer_CPU.get(1)), + SOC("soc", "SoC", 150, "", BLANK2, Dyes.dyeYellow, 3e-3f, 10e-3f, 50, 2, ItemList.Circuit_Wafer_SoC.get(1), + ItemList.Circuit_Silicon_Wafer, ItemList.Circuit_Silicon_Wafer2), + ASOC("asoc", "Advanced SoC", 120, "", BLANK2, Dyes.dyeGreen, 100e-3f, 200e-3f, 50, 2, + ItemList.Circuit_Wafer_SoC2.get(1), ItemList.Circuit_Silicon_Wafer, ItemList.Circuit_Silicon_Wafer2), + PIC("pic", "Power IC", 100, "", BLANK2, Dyes.dyeBlue, 5e-3f, 10e-3f, 50, 4, ItemList.Circuit_Wafer_PIC.get(1), + ItemList.Circuit_Silicon_Wafer), + HPIC("hpic", "High Power IC", 80, "", BLANK3, null, 100e-3f, 200e-3f, 50, 6, ItemList.Circuit_Wafer_HPIC.get(1), + ItemList.Circuit_Silicon_Wafer), // Different, made in chemical reactor. Figure out something for + // this later? + NCPU("ncpu", "NanoCPU", 60, "", BLANK2, null, 5e-3f, 10e-3f, 50, 4, ItemList.Circuit_Wafer_NanoCPU.get(1), + ItemList.Circuit_Silicon_Wafer), // Same as above + QBIT("qbit", "QBit", 50, "", BLANK2, null, 3e-3f, 10e-3f, 50, 4, ItemList.Circuit_Wafer_QuantumCPU.get(1), + ItemList.Circuit_Silicon_Wafer), // ^ + UHPIC("uhpic", "Ultra High Power IC", 60, "", BLANK3, null, 200e-3f, 400e-3f, 50, 8, + ItemList.Circuit_Wafer_UHPIC.get(1), ItemList.Circuit_Silicon_Wafer, ItemList.Circuit_Silicon_Wafer2), // You + // get + // the + // gist + SSOC("ssoc", "Simple SoC", 150, "", BLANK1, Dyes.dyeOrange, 2e-3f, 4e-3f, 50, 1, + ItemList.Circuit_Wafer_Simple_SoC.get(1)), + ULPIC("ulpic", "Ultra Low Power IC", 200, "", BLANK1, Dyes.dyeGreen, 2e-3f, 4e-3f, 50, 1, + ItemList.Circuit_Wafer_ULPIC.get(1)), // Can use green for this as well as asoc, given + // the latter uses a different base mask + LPIC("lpic", "Low Power IC", 150, "", BLANK1, Dyes.dyeYellow, 2e-3f, 4e-3f, 50, 2, + ItemList.Circuit_Wafer_LPIC.get(1)), // Same as above, except for yellow + NPIC("npic", "Nano Power IC", 70, "", BLANK3, Dyes.dyeRed, 1, 100000, 50, 4, ItemList.Circuit_Wafer_NPIC.get(1), + ItemList.Circuit_Silicon_Wafer, ItemList.Circuit_Silicon_Wafer2, ItemList.Circuit_Silicon_Wafer3), // Same + PPIC("ppic", "PPIC", 50, "", BLANK3, null, 10, 15, 50, 6, ItemList.Circuit_Wafer_PPIC.get(1), + ItemList.Circuit_Silicon_Wafer, ItemList.Circuit_Silicon_Wafer2, ItemList.Circuit_Silicon_Wafer3), // CR + // recipe + QPIC("qpic", "QPIC", 50, "", BLANK3, Dyes.dyeBlue, 5, 9, 50, 6, ItemList.Circuit_Wafer_QPIC.get(1), + ItemList.Circuit_Silicon_Wafer, ItemList.Circuit_Silicon_Wafer2, ItemList.Circuit_Silicon_Wafer3, + ItemList.Circuit_Silicon_Wafer4); // Different base mask to PIC + + String name; + String englishName; + String spectrum; + + int maxDamage; + + MaskList precursor; + Dyes lensColour; + + float minEnergy; + float maxEnergy; + + float minFocus; + int baselineAmount; + + ItemStack producedItem; + + ItemList[] forbiddenWafers; + + MaskList(String name, String englishName, int maxDamage, String spectrum, MaskList precursor, Dyes lensColour, + float minEnergy, float maxEnergy, float minFocus, int baselineAmount, ItemStack producedItem, + ItemList... forbiddenWafers) { + this.name = name; + this.englishName = englishName; + this.spectrum = spectrum; + this.maxDamage = maxDamage; + this.precursor = precursor; + this.lensColour = lensColour; + this.minFocus = minFocus; + this.minEnergy = minEnergy; + this.maxEnergy = maxEnergy; + this.baselineAmount = baselineAmount; + this.producedItem = producedItem; + this.forbiddenWafers = forbiddenWafers; + } + + public String getName() { + return this.name; + } + + public String getEnglishName() { + return this.englishName; + } + + public String getSpectrum() { + return this.spectrum; + } + + public int getDamage() { + return this.maxDamage; + } + + public MaskList getPrecursor() { + return this.precursor; + } + + public Dyes getLensColour() { + return this.lensColour; + } + + public float getMinEnergy() { + return this.minEnergy; + } + + public float getMaxEnergy() { + return this.maxEnergy; + } + + public float getMinFocus() { + return this.minFocus; + } + + public int getBaselineAmount() { + return this.baselineAmount; + } + + public ItemStack getProducedItem() { + return this.producedItem; + } + + public ItemList[] getForbiddenWafers() { + return this.forbiddenWafers; + } + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/item/ParticleItem.java b/src/main/java/com/elisis/gtnhlanth/common/item/ParticleItem.java new file mode 100644 index 0000000000..b6484b93a5 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/item/ParticleItem.java @@ -0,0 +1,124 @@ +package com.elisis.gtnhlanth.common.item; + +import java.util.List; + +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IIcon; +import net.minecraft.util.MathHelper; + +import com.elisis.gtnhlanth.Tags; +import com.elisis.gtnhlanth.common.beamline.Particle; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +public class ParticleItem extends Item { + + public static final int NUMBER_OF_SUBTYPES = Particle.values().length; + + private static String[] names = new String[NUMBER_OF_SUBTYPES]; + + static { + populateNamesArray(); + } + + @SideOnly(Side.CLIENT) + private IIcon[] iconArray; + + public ParticleItem() { + + this.setHasSubtypes(true); + this.setMaxDamage(0); + + } + + @SideOnly(Side.CLIENT) + @Override + public IIcon getIconFromDamage(int damage) { + int j = MathHelper.clamp_int(damage, 0, NUMBER_OF_SUBTYPES - 1); + return this.iconArray[j]; + } + + public String getUnlocalizedName(ItemStack stack) { + int i = MathHelper.clamp_int(stack.getItemDamage(), 0, NUMBER_OF_SUBTYPES - 1); + return super.getUnlocalizedName() + "." + names[i]; + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + @SideOnly(Side.CLIENT) + @Override + public void getSubItems(Item item, CreativeTabs tab, List list) { + for (int i = 0; i < NUMBER_OF_SUBTYPES; ++i) { + list.add(new ItemStack(item, 1, i)); + } + } + + @SideOnly(Side.CLIENT) + @Override + public void registerIcons(IIconRegister register) { + this.iconArray = new IIcon[NUMBER_OF_SUBTYPES]; + + for (int i = 0; i < NUMBER_OF_SUBTYPES; ++i) { + this.iconArray[i] = register.registerIcon(Tags.MODID + ":" + "particle/" + names[i]); + } + } + + @SideOnly(Side.CLIENT) + @Override + public String getItemStackDisplayName(ItemStack stack) { + + int i = MathHelper.clamp_int(stack.getItemDamage(), 0, NUMBER_OF_SUBTYPES - 1); + + Particle particle = Particle.values()[i]; + + return particle.getLocalisedName(); + + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean bool) { + + int i = MathHelper.clamp_int(stack.getItemDamage(), 0, NUMBER_OF_SUBTYPES - 1); + + Particle particle = Particle.values()[i]; + + float restMass = particle.getMass(); + + float charge = particle.getCharge(); + + String chargeSpecial = particle.getChargeSpecial(); + + String chargeStringToAppend; + if (chargeSpecial != null) { + + chargeStringToAppend = chargeSpecial; + + } else { + + if (charge > 0) chargeStringToAppend = "+" + charge; + else chargeStringToAppend = "" + charge; + } + + list.add("Rest Mass: " + restMass + " MeV"); + list.add("Charge: " + chargeStringToAppend + "e"); + + } + + private static void populateNamesArray() { + + for (int i = 0; i < NUMBER_OF_SUBTYPES; i++) { + + Particle particle = Particle.values()[i]; + + names[i] = particle.getName(); + + } + + } + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/item/PhotolithographicMask.java b/src/main/java/com/elisis/gtnhlanth/common/item/PhotolithographicMask.java new file mode 100644 index 0000000000..a6b34660f0 --- /dev/null +++ b/src/main/java/com/elisis/gtnhlanth/common/item/PhotolithographicMask.java @@ -0,0 +1,38 @@ +package com.elisis.gtnhlanth.common.item; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +import com.elisis.gtnhlanth.Tags; + +public class PhotolithographicMask extends Item implements ICanFocus { + + private String name; + private String descSpectrum; + + public PhotolithographicMask(String name, int maxDamage, String descSpectrum) { + super(); + this.name = name; + this.descSpectrum = descSpectrum; + this.setUnlocalizedName("photomask." + name); + this.setMaxStackSize(1); + this.setMaxDamage(maxDamage); + this.setTextureName(Tags.MODID + ":photomask/" + name); + } + + /* + * @Override public String getUnlocalizedName() { return "item.photomask." + this.name; } + */ + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List list, boolean bool) { + + if (!this.descSpectrum.isEmpty()) + list.add("Suitable for the " + this.descSpectrum + " segment of the electromagnetic spectrum and lower"); + + } + +} diff --git a/src/main/java/com/elisis/gtnhlanth/common/register/LanthItemList.java b/src/main/java/com/elisis/gtnhlanth/common/register/LanthItemList.java index 69aa026e47..1b799ac84a 100644 --- a/src/main/java/com/e