diff options
Diffstat (limited to 'src/main/java/gregtech')
16 files changed, 1085 insertions, 2 deletions
diff --git a/src/main/java/gregtech/api/GregTech_API.java b/src/main/java/gregtech/api/GregTech_API.java index 9190d03bab..f252a12965 100644 --- a/src/main/java/gregtech/api/GregTech_API.java +++ b/src/main/java/gregtech/api/GregTech_API.java @@ -297,6 +297,7 @@ public class GregTech_API { sBlockCasings8, sBlockCasings9, sBlockCasings10, sBlockCasings11, sSolenoidCoilCasings; public static Block sBlockLongDistancePipes; public static Block sDroneRender; + public static Block sLaserRender; /** * Getting assigned by the Config */ diff --git a/src/main/java/gregtech/api/enums/GT_Values.java b/src/main/java/gregtech/api/enums/GT_Values.java index bda681dc75..74c392ce67 100644 --- a/src/main/java/gregtech/api/enums/GT_Values.java +++ b/src/main/java/gregtech/api/enums/GT_Values.java @@ -650,7 +650,18 @@ public class GT_Values { public static final String AuthorQuerns = "Author: " + EnumChatFormatting.RED + "Querns"; public static final String AuthorSilverMoon = "Author: " + EnumChatFormatting.AQUA + "SilverMoon"; public static final String AuthorTheEpicGamer274 = "Author: " + "TheEpicGamer274"; - public static final String AuthorFourIsTheNumber = "Author: " + EnumChatFormatting.LIGHT_PURPLE + "FourIsTheNumber"; + public static final String AuthorFourIsTheNumber = "Author: " + EnumChatFormatting.LIGHT_PURPLE + + EnumChatFormatting.ITALIC + + "Four" + + EnumChatFormatting.WHITE + + EnumChatFormatting.ITALIC + + "Is" + + EnumChatFormatting.LIGHT_PURPLE + + EnumChatFormatting.ITALIC + + "The" + + EnumChatFormatting.WHITE + + EnumChatFormatting.ITALIC + + "Number"; public static final String authorBaps = "Author: " + EnumChatFormatting.GOLD + "Ba" + EnumChatFormatting.LIGHT_PURPLE diff --git a/src/main/java/gregtech/api/enums/ItemList.java b/src/main/java/gregtech/api/enums/ItemList.java index f024361c19..d1c30a0935 100644 --- a/src/main/java/gregtech/api/enums/ItemList.java +++ b/src/main/java/gregtech/api/enums/ItemList.java @@ -1462,6 +1462,9 @@ public enum ItemList implements IItemContainer { Electromagnet_Tengam, Machine_Multi_Canner, + Machine_Multi_IndustrialLaserEngraver, + Laser_Plate, + Casing_Laser, Machine_Multi_Lathe, diff --git a/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java b/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java index 8abf07e1b1..b34c5d79f0 100644 --- a/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java +++ b/src/main/java/gregtech/api/enums/MetaTileEntityIDs.java @@ -610,6 +610,7 @@ public enum MetaTileEntityIDs { CRAFTING_INPUT_SLAVE(2716), INPUT_HATCH_ME(2717), INPUT_BUS_ME(2718), + INDUSTRIAL_LASER_ENGRAVER_CONTROLLER(3004), CHEST_BUFFER_ULV(9230), CHEST_BUFFER_LV(9231), CHEST_BUFFER_MV(9232), diff --git a/src/main/java/gregtech/api/enums/Textures.java b/src/main/java/gregtech/api/enums/Textures.java index ba13de2552..b190d60d00 100644 --- a/src/main/java/gregtech/api/enums/Textures.java +++ b/src/main/java/gregtech/api/enums/Textures.java @@ -336,6 +336,12 @@ public class Textures { OVERLAY_FRONT_MULTI_CANNER_ACTIVE_GLOW, OVERLAY_FRONT_MULTI_CANNER_GLOW, + LASER_PLATE, + MACHINE_CASING_LASER, + OVERLAY_FRONT_ENGRAVER, + OVERLAY_FRONT_ENGRAVER_ACTIVE, + OVERLAY_FRONT_ENGRAVER_ACTIVE_GLOW, + OVERLAY_FRONT_ENGRAVER_GLOW, OVERLAY_FRONT_MULTI_LATHE, OVERLAY_FRONT_MULTI_LATHE_ACTIVE, OVERLAY_FRONT_MULTI_LATHE_ACTIVE_GLOW, diff --git a/src/main/java/gregtech/api/util/LaserRenderingUtil.java b/src/main/java/gregtech/api/util/LaserRenderingUtil.java new file mode 100644 index 0000000000..e42d23bc85 --- /dev/null +++ b/src/main/java/gregtech/api/util/LaserRenderingUtil.java @@ -0,0 +1,102 @@ +package gregtech.api.util; + +import java.util.function.Consumer; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.util.IChatComponent; +import net.minecraft.world.World; + +import com.gtnewhorizon.structurelib.StructureLibAPI; +import com.gtnewhorizon.structurelib.structure.ICustomBlockSetting; +import com.gtnewhorizon.structurelib.structure.IItemSource; +import com.gtnewhorizon.structurelib.structure.IStructureElement; +import com.gtnewhorizon.structurelib.structure.StructureUtility; + +public class LaserRenderingUtil { + // This code is shamelessly ripped from GTNH-Intergalactic + + public interface IBlockAdder<T> { + + /** + * Callback on block added, needs to check if block is valid (and add it) + * + * @param block block attempted to add + * @param meta meta of block attempted to add + * @param world World of the block + * @param x X coordinate of the block + * @param y Y coordinate of the block + * @param z Z coordinate of the block + * @return is structure still valid + */ + boolean apply(T t, Block block, int meta, World world, int x, int y, int z); + } + + public static <T> IStructureElement<T> ofBlockAdder(IBlockAdder<T> iBlockAdder, Block defaultBlock, + int defaultMeta) { + if (iBlockAdder == null || defaultBlock == null) { + throw new IllegalArgumentException(); + } + if (defaultBlock instanceof ICustomBlockSetting) { + return new IStructureElement<T>() { + + @Override + public boolean check(T t, World world, int x, int y, int z) { + Block worldBlock = world.getBlock(x, y, z); + return iBlockAdder.apply(t, worldBlock, worldBlock.getDamageValue(world, x, y, z), world, x, y, z); + } + + @Override + public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) { + ((ICustomBlockSetting) defaultBlock).setBlock(world, x, y, z, defaultMeta); + return true; + } + + @Override + public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) { + StructureLibAPI.hintParticle(world, x, y, z, defaultBlock, defaultMeta); + return true; + } + + @Override + public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger, + IItemSource s, EntityPlayerMP actor, Consumer<IChatComponent> chatter) { + if (check(t, world, x, y, z)) return PlaceResult.SKIP; + return StructureUtility + .survivalPlaceBlock(defaultBlock, defaultMeta, world, x, y, z, s, actor, chatter); + } + }; + } else { + return new IStructureElement<T>() { + + @Override + public boolean check(T t, World world, int x, int y, int z) { + Block worldBlock = world.getBlock(x, y, z); + return iBlockAdder + .apply(t, worldBlock, ((Block) worldBlock).getDamageValue(world, x, y, z), world, x, y, z); + } + + @Override + public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) { + world.setBlock(x, y, z, defaultBlock, defaultMeta, 2); + return true; + } + + @Override + public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) { + StructureLibAPI.hintParticle(world, x, y, z, defaultBlock, defaultMeta); + return true; + } + + @Override + public PlaceResult survivalPlaceBlock(T t, World world, int x, int y, int z, ItemStack trigger, + IItemSource s, EntityPlayerMP actor, Consumer<IChatComponent> chatter) { + if (check(t, world, x, y, z)) return IStructureElement.PlaceResult.SKIP; + return StructureUtility + .survivalPlaceBlock(defaultBlock, defaultMeta, world, x, y, z, s, actor, chatter); + } + }; + } + } +} diff --git a/src/main/java/gregtech/common/GT_Client.java b/src/main/java/gregtech/common/GT_Client.java index d7bd2ad53f..69fc98212f 100644 --- a/src/main/java/gregtech/common/GT_Client.java +++ b/src/main/java/gregtech/common/GT_Client.java @@ -91,6 +91,7 @@ import gregtech.common.blocks.GT_Item_Machines; import gregtech.common.render.GT_CapeRenderer; import gregtech.common.render.GT_FlaskRenderer; import gregtech.common.render.GT_FluidDisplayStackRenderer; +import gregtech.common.render.GT_LaserRenderer; import gregtech.common.render.GT_MetaGenerated_Tool_Renderer; import gregtech.common.render.GT_MultiTile_Renderer; import gregtech.common.render.GT_PollutionRenderer; @@ -622,6 +623,7 @@ public class GT_Client extends GT_Proxy implements Runnable { GT_Renderer_Block.register(); new GT_MultiTile_Renderer(); new GT_RenderDrone(); + new GT_LaserRenderer(); metaGeneratedItemRenderer = new GT_MetaGenerated_Item_Renderer(); for (GT_MetaGenerated_Item item : GT_MetaGenerated_Item.sInstances.values()) { metaGeneratedItemRenderer.registerItem(item); diff --git a/src/main/java/gregtech/common/blocks/GT_Block_Casings10.java b/src/main/java/gregtech/common/blocks/GT_Block_Casings10.java index 8f5ee9de5b..660c709886 100644 --- a/src/main/java/gregtech/common/blocks/GT_Block_Casings10.java +++ b/src/main/java/gregtech/common/blocks/GT_Block_Casings10.java @@ -18,8 +18,10 @@ public class GT_Block_Casings10 extends GT_Block_Casings_Abstract { public GT_Block_Casings10() { super(GT_Item_Casings10.class, "gt.blockcasings10", GT_Material_Casings.INSTANCE, 16); GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".0.name", "MagTech Casing"); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".1.name", "Laser Containment Casing"); ItemList.Casing_Electromagnetic_Separator.set(new ItemStack(this, 1, 0)); + ItemList.Casing_Laser.set(new ItemStack(this, 1, 1)); } @Override @@ -32,6 +34,7 @@ public class GT_Block_Casings10 extends GT_Block_Casings_Abstract { public IIcon getIcon(int ordinalSide, int aMeta) { return switch (aMeta) { case 0 -> Textures.BlockIcons.MACHINE_CASING_EMS.getIcon(); + case 1 -> Textures.BlockIcons.MACHINE_CASING_LASER.getIcon(); default -> Textures.BlockIcons.MACHINE_CASING_ROBUST_TUNGSTENSTEEL.getIcon(); }; } diff --git a/src/main/java/gregtech/common/blocks/GT_Block_Laser.java b/src/main/java/gregtech/common/blocks/GT_Block_Laser.java new file mode 100644 index 0000000000..7ec03ce781 --- /dev/null +++ b/src/main/java/gregtech/common/blocks/GT_Block_Laser.java @@ -0,0 +1,104 @@ +package gregtech.common.blocks; + +import net.minecraft.block.Block; +import net.minecraft.block.ITileEntityProvider; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IIconRegister; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import gregtech.api.GregTech_API; +import gregtech.api.enums.ItemList; +import gregtech.api.enums.Textures; +import gregtech.api.util.GT_LanguageManager; +import gregtech.common.tileentities.render.TileLaser; + +public class GT_Block_Laser extends Block implements ITileEntityProvider { + + public static IIcon[] textures; + + public GT_Block_Laser() { + super(Material.iron); + setBlockName("LaserPlate"); + this.setCreativeTab(GregTech_API.TAB_GREGTECH); + GT_LanguageManager.addStringLocalization(getUnlocalizedName() + ".name", "Laser Resistant Plate"); + GregTech_API.registerMachineBlock(this, -1); + GameRegistry.registerBlock(this, GT_Item_Block_Laser.class, getUnlocalizedName()); + ItemList.Laser_Plate.set(new ItemStack(this, 1)); + } + + @Override + public void onBlockAdded(World aWorld, int aX, int aY, int aZ) { + if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } + + @Override + public void breakBlock(World aWorld, int aX, int aY, int aZ, Block aBlock, int aMetaData) { + if (GregTech_API.isMachineBlock(this, aWorld.getBlockMetadata(aX, aY, aZ))) { + GregTech_API.causeMachineUpdate(aWorld, aX, aY, aZ); + } + } + + @Override + public String getHarvestTool(int aMeta) { + return "wrench"; + } + + @Override + public int getHarvestLevel(int aMeta) { + return 2; + } + + @Override + public String getUnlocalizedName() { + return "gt.laserplate"; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerBlockIcons(IIconRegister iconRegister) { + blockIcon = Textures.BlockIcons.LASER_PLATE.getIcon(); + } + + @Override + public IIcon getIcon(int side, int meta) { + return blockIcon; + } + + @Override + public boolean renderAsNormalBlock() { + return false; + } + + @Override + public float getBlockHardness(World world, int x, int y, int z) { + return 1.0f; + } + + @Override + public int damageDropped(int meta) { + return meta; + } + + @Override + public boolean isOpaqueCube() { + return false; + } + + @Override + public boolean hasTileEntity(int metadata) { + return true; + } + + @Override + public TileEntity createNewTileEntity(World world, int meta) { + return new TileLaser(); + } +} diff --git a/src/main/java/gregtech/common/blocks/GT_Item_Block_Laser.java b/src/main/java/gregtech/common/blocks/GT_Item_Block_Laser.java new file mode 100644 index 0000000000..db4f6ddddc --- /dev/null +++ b/src/main/java/gregtech/common/blocks/GT_Item_Block_Laser.java @@ -0,0 +1,24 @@ +package gregtech.common.blocks; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; + +import gregtech.api.util.GT_LanguageManager; + +public class GT_Item_Block_Laser extends ItemBlock { + + public GT_Item_Block_Laser(Block block) { + super(block); + } + + @Override + public void addInformation(ItemStack stack, EntityPlayer player, List<String> tooltip, boolean f3_h) { + tooltip.add( + GT_LanguageManager + .addStringLocalization("gt.laserplatingtooltip", "Engineered to withstand extreme temperatures")); + } +} diff --git a/src/main/java/gregtech/common/render/GT_LaserRenderer.java b/src/main/java/gregtech/common/render/GT_LaserRenderer.java new file mode 100644 index 0000000000..1c54a5d58b --- /dev/null +++ b/src/main/java/gregtech/common/render/GT_LaserRenderer.java @@ -0,0 +1,90 @@ +package gregtech.common.render; + +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; + +import org.lwjgl.opengl.GL11; + +import cpw.mods.fml.client.registry.ClientRegistry; +import gregtech.common.tileentities.render.TileLaser; + +public class GT_LaserRenderer extends TileEntitySpecialRenderer { + + private double zOffset = 0.0; + private double xOffset = 0.0; + + // Relative to block size + final private double lineRadius = 0.03; + + final private float lineOpacity = 0.7F; + + final private float laserSpeed = 0.8F; + + public GT_LaserRenderer() { + ClientRegistry.bindTileEntitySpecialRenderer(TileLaser.class, this); + } + + private void maths(float counter) { + float tc = (0.05F * counter); + zOffset = 0.5 + 0.45 * Math.sin(2 * Math.PI * tc); + xOffset = 0.5 + 0.45 * Math.sin(0.5 * Math.PI * tc); + } + + private void renderFakeLine(TileLaser laser, double x1, double y1, double z1, double x2, double y2, double z2) { + Tessellator tessellator = Tessellator.instance; + tessellator.startDrawingQuads(); + tessellator.setColorRGBA_F(laser.getRed(), laser.getGreen(), laser.getBlue(), lineOpacity); + tessellator.addVertex(x1 - lineRadius, y1, z1); + tessellator.addVertex(x1 + lineRadius, y1, z1); + tessellator.addVertex(x2 + lineRadius, y2, z2); + tessellator.addVertex(x2 - lineRadius, y2, z2); + + tessellator.addVertex(x1, y1, z1 - lineRadius); + tessellator.addVertex(x1, y1, z1 + lineRadius); + tessellator.addVertex(x2, y2, z2 + lineRadius); + tessellator.addVertex(x2, y2, z2 - lineRadius); + tessellator.draw(); + } + + @Override + public void renderTileEntityAt(TileEntity tile, double x, double y, double z, float timeSinceLastTick) { + final TileLaser ltile = (TileLaser) tile; + + if (ltile.getShouldRender()) { + // Push GL state + GL11.glPushMatrix(); + GL11.glPushAttrib(GL11.GL_ENABLE_BIT); + + GL11.glDisable(GL11.GL_LIGHTING); + GL11.glDisable(GL11.GL_CULL_FACE); + GL11.glDisable(GL11.GL_TEXTURE_2D); + GL11.glEnable(GL11.GL_BLEND); + + // Full brightness on this thing (Emits glow with shaders) + OpenGlHelper.setLightmapTextureCoords(OpenGlHelper.lightmapTexUnit, 240.f, 240.f); + + GL11.glTranslated(x + 0.5, y + 0.5, z + 0.5); + GL11.glRotated(ltile.rotationAngle, ltile.rotAxisX, ltile.rotAxisY, ltile.rotAxisZ); + GL11.glTranslated(-x - 0.5, -y - 0.5, -z - 0.5); + + if (ltile.realism) { + renderFakeLine(ltile, x + xOffset, y + 4.0, z + zOffset, x + xOffset, y + 0.5, z + zOffset); + } else { + renderFakeLine(ltile, x + 0.5, y + 4.0, z + 0.5, x + xOffset, y + 0.5, z + zOffset); + } + + // Pop GL state + GL11.glPopAttrib(); + GL11.glPopMatrix(); + + // Movement calculations + maths(ltile.counter); + ltile.counter += laserSpeed; + if (ltile.counter >= 80) { + ltile.counter = 0; + } + } + } +} diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_IndustrialLaserEngraver.java b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_IndustrialLaserEngraver.java new file mode 100644 index 0000000000..3da4d18f80 --- /dev/null +++ b/src/main/java/gregtech/common/tileentities/machines/multi/GT_MetaTileEntity_IndustrialLaserEngraver.java @@ -0,0 +1,599 @@ +package gregtech.common.tileentities.machines.multi; + +import static com.gtnewhorizon.structurelib.structure.StructureUtility.*; +import static gregtech.api.enums.GT_HatchElement.*; +import static gregtech.api.enums.GT_Values.AuthorFourIsTheNumber; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ENGRAVER; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ENGRAVER_ACTIVE; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ENGRAVER_ACTIVE_GLOW; +import static gregtech.api.enums.Textures.BlockIcons.OVERLAY_FRONT_ENGRAVER_GLOW; +import static gregtech.api.util.GT_StructureUtility.buildHatchAdder; +import static gregtech.api.util.GT_StructureUtility.ofFrame; + +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import javax.annotation.Nonnull; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.entity.player.EntityPlayerMP; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumChatFormatting; +import net.minecraft.util.StatCollector; +import net.minecraft.world.World; +import net.minecraftforge.common.util.ForgeDirection; + +import org.jetbrains.annotations.NotNull; + +import com.github.bartimaeusnek.bartworks.API.BorosilicateGlass; +import com.github.technus.tectech.thing.metaTileEntity.hatch.GT_MetaTileEntity_Hatch_DynamoTunnel; +import com.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable; +import com.gtnewhorizon.structurelib.structure.IStructureDefinition; +import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment; +import com.gtnewhorizon.structurelib.structure.StructureDefinition; + +import gregtech.api.GregTech_API; +import gregtech.api.enums.GTVoltageIndex; +import gregtech.api.enums.GT_Values; +import gregtech.api.enums.Materials; +import gregtech.api.enums.OrePrefixes; +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.logic.ProcessingLogic; +import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_ExtendedPowerMultiBlockBase; +import gregtech.api.recipe.RecipeMap; +import gregtech.api.recipe.RecipeMaps; +import gregtech.api.recipe.check.CheckRecipeResult; +import gregtech.api.recipe.check.CheckRecipeResultRegistry; +import gregtech.api.recipe.check.SimpleCheckRecipeResult; +import gregtech.api.render.TextureFactory; +import gregtech.api.util.GT_Multiblock_Tooltip_Builder; +import gregtech.api.util.GT_OreDictUnificator; +import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; +import gregtech.api.util.LaserRenderingUtil; +import gregtech.common.blocks.GT_Block_Casings10; +import gregtech.common.tileentities.render.TileLaser; +import gtPlusPlus.core.util.minecraft.PlayerUtils; +import mcp.mobius.waila.api.IWailaConfigHandler; +import mcp.mobius.waila.api.IWailaDataAccessor; + +public class GT_MetaTileEntity_IndustrialLaserEngraver + extends GT_MetaTileEntity_ExtendedPowerMultiBlockBase<GT_MetaTileEntity_IndustrialLaserEngraver> + implements ISurvivalConstructable { + + private static final String STRUCTURE_PIECE_MAIN = "main"; + private static final IStructureDefinition<GT_MetaTileEntity_IndustrialLaserEngraver> STRUCTURE_DEFINITION = StructureDefinition + .<GT_MetaTileEntity_IndustrialLaserEngraver>builder() + .addShape( + STRUCTURE_PIECE_MAIN, + (new String[][] { { " f ", " ", " ", " ", " a~a " }, + { " fsf ", " g ", " g ", "a g a", "aaraa" }, { "faaaf", "f f", "f f", "a a", "aaaaa" }, + { "aaaaa", "a a a", "a a a", "a a a", "aaaaa" }, { "aaaaa", "aaaaa", "aaaaa", "aaaaa", "aaaaa" } })) + .addElement( + 'a', + buildHatchAdder(GT_MetaTileEntity_IndustrialLaserEngraver.class) + .atLeast(InputBus, OutputBus, InputHatch, OutputHatch, Maintenance, Energy) + .casingIndex(((GT_Block_Casings10) GregTech_API.sBlockCasings10).getTextureIndex(1)) + .dot(1) + .buildAndChain( + onElementPass( + GT_MetaTileEntity_IndustrialLaserEngraver::onCasingAdded, + ofBlock(GregTech_API.sBlockCasings10, 1)))) + .addElement('f', ofFrame(Materials.TungstenSteel)) + .addElement( + 'g', + BorosilicateGlass + .ofBoroGlass((byte) 0, (byte) 1, Byte.MAX_VALUE, (te, t) -> te.glassTier = t, te -> te.glassTier)) + .addElement( + 'r', + LaserRenderingUtil.ofBlockAdder( + GT_MetaTileEntity_IndustrialLaserEngraver::laserRendererAdder, + GregTech_API.sLaserRender, + 0)) + .addElement( + 's', + buildHatchAdder(GT_MetaTileEntity_IndustrialLaserEngraver.class) + .adder(GT_MetaTileEntity_IndustrialLaserEngraver::addLaserSource) + .hatchClass(GT_MetaTileEntity_Hatch_DynamoTunnel.class) + .casingIndex(((GT_Block_Casings10) GregTech_API.sBlockCasings10).getTextureIndex(1)) + .dot(3) + .build()) + .build(); + + protected TileLaser renderer; + private byte glassTier = 0; + private GT_MetaTileEntity_Hatch_DynamoTunnel laserSource = null; + private int laserAmps = 0; + private int laserTier = 0; + private String tierName = "LV"; + + private boolean addLaserSource(IGregTechTileEntity aTileEntity, int aBaseCasingIndex) { + if (aTileEntity != null) { + final IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity(); + if (aMetaTileEntity instanceof GT_MetaTileEntity_Hatch_DynamoTunnel) { + laserSource = (GT_MetaTileEntity_Hatch_DynamoTunnel) aMetaTileEntity; + laserSource.updateTexture(aBaseCasingIndex); + // Snap the laser source toward the plate. Player can rotate it if they want after but this will look + // nicer + switch (getRotation()) { + case NORMAL -> laserSource.getBaseMetaTileEntity() + .setFrontFacing(ForgeDirection.DOWN); + case UPSIDE_DOWN -> laserSource.getBaseMetaTileEntity() + .setFrontFacing(ForgeDirection.UP); + case CLOCKWISE -> laserSource.getBaseMetaTileEntity() + .setFrontFacing(getDirection().getRotation(ForgeDirection.UP)); + default -> laserSource.getBaseMetaTileEntity() + .setFrontFacing(getDirection().getRotation(ForgeDirection.DOWN)); + } + // Cube root the amperage to get the parallels + laserAmps = (int) Math.cbrt(laserSource.maxAmperesOut()); + laserTier = (int) laserSource.getOutputTier(); + tierName = GT_Values.VN[laserTier]; + return true; + } + } + return false; + } + + private boolean laserRendererAdder(Block block, int meta, World world, int x, int y, int z) { + if (block != GregTech_API.sLaserRender || world == null) { + return false; + } + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof TileLaser) { + renderer = (TileLaser) te; + renderer.setRotationFields(getDirection(), getRotation(), getFlip()); + return true; + } + return false; + } + + public GT_MetaTileEntity_IndustrialLaserEngraver(final int aID, final String aName, final String aNameRegional) { + super(aID, aName, aNameRegional); + } + + public GT_MetaTileEntity_IndustrialLaserEngraver(String aName) { + super(aName); + } + + @Override + public IStructureDefinition<GT_MetaTileEntity_IndustrialLaserEngraver> getStructureDefinition() { + return STRUCTURE_DEFINITION; + } + + @Override + public boolean isCorrectMachinePart(ItemStack aStack) { + return true; + } + + @Override + public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) { + return new GT_MetaTileEntity_IndustrialLaserEngraver(this.mName); + } + + @Override + public ITexture[] getTexture(IGregTechTileEntity baseMetaTileEntity, ForgeDirection side, ForgeDirection aFacing, + int colorIndex, boolean aActive, boolean redstoneLevel) { + ITexture[] rTexture; + if (side == aFacing) { + if (aActive) { + rTexture = new ITexture[] { + Textures.BlockIcons + .getCasingTextureForId(GT_Utility.getCasingTextureIndex(GregTech_API.sBlockCasings10, 1)), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_ENGRAVER_ACTIVE) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_ENGRAVER_ACTIVE_GLOW) + .extFacing() + .glow() + .build() }; + } else { + rTexture = new ITexture[] { + Textures.BlockIcons + .getCasingTextureForId(GT_Utility.getCasingTextureIndex(GregTech_API.sBlockCasings10, 1)), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_ENGRAVER) + .extFacing() + .build(), + TextureFactory.builder() + .addIcon(OVERLAY_FRONT_ENGRAVER_GLOW) + .extFacing() + .glow() + .build() }; + } + } else { + rTexture = new ITexture[] { Textures.BlockIcons + .getCasingTextureForId(GT_Utility.getCasingTextureIndex(GregTech_API.sBlockCasings10, 1)) }; + } + return rTexture; + } + + private boolean stopAllRendering = false; + + @Override + public void onScrewdriverRightClick(ForgeDirection side, EntityPlayer aPlayer, float aX, float aY, float aZ) { + stopAllRendering = !stopAllRendering; + if (stopAllRendering) { + PlayerUtils.messagePlayer(aPlayer, "Rendering off"); + if (renderer != null) renderer.setShouldRender(false); + } else PlayerUtils.messagePlayer(aPlayer, "Rendering on"); + } + + @Override + public boolean onWireCutterRightClick(ForgeDirection side, ForgeDirection wrenchingSide, EntityPlayer aPlayer, + float aX, float aY, float aZ, ItemStack aTool) { + if (renderer != null) { + renderer.realism = !renderer.realism; + PlayerUtils.messagePlayer(aPlayer, "Toggling realism!"); + } + return false; + } + + @Override + public void onDisableWorking() { + if (renderer != null) renderer.setShouldRender(false); + super.onDisableWorking(); + } + + @Override + public void onBlockDestroyed() { + if (renderer != null) renderer.setShouldRender(false); + super.onBlockDestroyed(); + } + + @Override + protected GT_Multiblock_Tooltip_Builder createTooltip() { + GT_Multiblock_Tooltip_Builder tt = new GT_Multiblock_Tooltip_Builder(); + tt.addMachineType("Laser Engraver") + .addInfo("Controller Block for the High Energy Laser Emitter") + .addInfo("200% faster than single block machines of the same voltage") + .addInfo("Uses 80% of the EU normally required") + .addInfo("Laser source hatch determines maximum power tier and parallels") + .addInfo("Parallels equal to the cube root of laser source amperage input") + .addInfo("Glass tier determines maximum laser source tier") + .addInfo("Only accepts borosilicate glass (no, really)") + .addInfo("UMV glass accepts all laser source hatches") + .addInfo("Use screwdriver to disable laser rendering") + .addInfo("Use wire cutter to toggle realism mode if you hate angled lasers") + .addInfo(AuthorFourIsTheNumber) + .addSeparator() + .beginStructureBlock(5, 5, 5, false) + .addController("Front Center") + .addCasingInfoMin("Laser Containment Casing", 45, false) + .addCasingInfoExactly("Tungstensteel Frame Box", 9, false) + .addOtherStructurePart("Laser Resistant Plate", "x1") + .addOtherStructurePart("Borosilicate Glass", "x3") + .addOtherStructurePart("Laser Source Hatch", "x1", 3) + .addInputBus("Any Casing", 1) + .addInputHatch("Any Casing", 1) + .addOutputBus("Any Casing", 1) + .addOutputHatch("Any Casing", 1) + .addEnergyHatch("Any Casing", 1) + .addMaintenanceHatch("Any Casi |