The Great Renaming (#3014)

* move kekztech to a single root dir

* move detrav to a single root dir

* move gtnh-lanthanides to a single root dir

* move tectech and delete some gross reflection in gt++

* remove more reflection inside gt5u

* delete more reflection in gt++

* fix imports

* move bartworks and bwcrossmod

* fix proxies

* move galactigreg and ggfab

* move gtneioreplugin

* try to fix gt++ bee loader

* apply the rename rules to BW

* apply rename rules to bwcrossmod

* apply rename rules to detrav scanner mod

* apply rename rules to galacticgreg

* apply rename rules to ggfab

* apply rename rules to goodgenerator

* apply rename rules to gtnh-lanthanides

* apply rename rules to gt++

* apply rename rules to kekztech

* apply rename rules to kubatech

* apply rename rules to tectech

* apply rename rules to gt

apply the rename rules to gt

* fix tt import

* fix mui hopefully

* fix coremod except intergalactic

* rename assline recipe class

* fix a class name i stumbled on

* rename StructureUtility to GTStructureUtility to prevent conflict with structurelib

* temporary rename of GTTooltipDataCache to old name

* fix gt client/server proxy names

1 files changed, 605 insertions, 0 deletions

diff --git a/src/main/java/gregtech/common/tileentities/machines/multi/MTEIndustrialLaserEngraver.java b/src/main/java/gregtech/common/tileentities/machines/multi/MTEIndustrialLaserEngraver.java
new file mode 100644
index 0000000000..e79244f881
--- /dev/null
+++ b/src/main/java/gregtech/common/tileentities/machines/multi/MTEIndustrialLaserEngraver.java
@@ -0,0 +1,605 @@
+package gregtech.common.tileentities.machines.multi;
+
+import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
+import static gregtech.api.enums.GTValues.AuthorFourIsTheNumber;
+import static gregtech.api.enums.HatchElement.*;
+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.GTStructureUtility.buildHatchAdder;
+import static gregtech.api.util.GTStructureUtility.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.gtnewhorizon.structurelib.alignment.constructable.ISurvivalConstructable;
+import com.gtnewhorizon.structurelib.structure.IStructureDefinition;
+import com.gtnewhorizon.structurelib.structure.ISurvivalBuildEnvironment;
+import com.gtnewhorizon.structurelib.structure.StructureDefinition;
+
+import bartworks.API.BorosilicateGlass;
+import gregtech.api.GregTechAPI;
+import gregtech.api.enums.GTValues;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.enums.Textures;
+import gregtech.api.enums.VoltageIndex;
+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.MTEExtendedPowerMultiBlockBase;
+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.GTOreDictUnificator;
+import gregtech.api.util.GTRecipe;
+import gregtech.api.util.GTUtility;
+import gregtech.api.util.LaserRenderingUtil;
+import gregtech.api.util.MultiblockTooltipBuilder;
+import gregtech.common.blocks.BlockCasings10;
+import gregtech.common.tileentities.render.TileEntityLaser;
+import gtPlusPlus.core.util.minecraft.PlayerUtils;
+import mcp.mobius.waila.api.IWailaConfigHandler;
+import mcp.mobius.waila.api.IWailaDataAccessor;
+import tectech.thing.metaTileEntity.hatch.MTEHatchDynamoTunnel;
+
+public class MTEIndustrialLaserEngraver extends MTEExtendedPowerMultiBlockBase<MTEIndustrialLaserEngraver>
+    implements ISurvivalConstructable {
+
+    private static final String STRUCTURE_PIECE_MAIN = "main";
+    private static final IStructureDefinition<MTEIndustrialLaserEngraver> STRUCTURE_DEFINITION = StructureDefinition
+        .<MTEIndustrialLaserEngraver>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(MTEIndustrialLaserEngraver.class)
+                .atLeast(InputBus, OutputBus, InputHatch, OutputHatch, Maintenance, Energy)
+                .casingIndex(((BlockCasings10) GregTechAPI.sBlockCasings10).getTextureIndex(1))
+                .dot(1)
+                .buildAndChain(
+                    onElementPass(MTEIndustrialLaserEngraver::onCasingAdded, ofBlock(GregTechAPI.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(MTEIndustrialLaserEngraver::laserRendererAdder, GregTechAPI.sLaserRender, 0))
+        .addElement(
+            's',
+            buildHatchAdder(MTEIndustrialLaserEngraver.class).adder(MTEIndustrialLaserEngraver::addLaserSource)
+                .hatchClass(MTEHatchDynamoTunnel.class)
+                .casingIndex(((BlockCasings10) GregTechAPI.sBlockCasings10).getTextureIndex(1))
+                .dot(3)
+                .build())
+        .build();
+
+    protected TileEntityLaser renderer;
+    private byte glassTier = 0;
+    private MTEHatchDynamoTunnel 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 MTEHatchDynamoTunnel) {
+                laserSource = (MTEHatchDynamoTunnel) 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 = GTValues.VN[laserTier];
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean laserRendererAdder(Block block, int meta, World world, int x, int y, int z) {
+        if (block != GregTechAPI.sLaserRender || world == null) {
+            return false;
+        }
+        TileEntity te = world.getTileEntity(x, y, z);
+        if (te instanceof TileEntityLaser) {
+            renderer = (TileEntityLaser) te;
+            renderer.setRotationFields(getDirection(), getRotation(), getFlip());
+            return true;
+        }
+        return false;
+    }
+
+    public MTEIndustrialLaserEngraver(final int aID, final String aName, final String aNameRegional) {
+        super(aID, aName, aNameRegional);
+    }
+
+    public MTEIndustrialLaserEngraver(String aName) {
+        super(aName);
+    }
+
+    @Override
+    public IStructureDefinition<MTEIndustrialLaserEngraver> getStructureDefinition() {
+        return STRUCTURE_DEFINITION;
+    }
+
+    @Override
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    @Override
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new MTEIndustrialLaserEngraver(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(GTUtility.getCasingTextureIndex(GregTechAPI.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(GTUtility.getCasingTextureIndex(GregTechAPI.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(GTUtility.getCasingTextureIndex(GregTechAPI.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 (aPlayer.isSneaking()) {
+            batchMode = !batchMode;
+            if (batchMode) {
+                GTUtility.sendChatToPlayer(aPlayer, StatCollector.translateToLocal("misc.BatchModeTextOn"));
+            } else {
+                GTUtility.sendChatToPlayer(aPlayer, StatCollector.translateToLocal("misc.BatchModeTextOff"));
+            }
+            return true;
+        } else {
+            if (renderer != null) {
+                renderer.realism = !renderer.realism;
+                PlayerUtils.messagePlayer(aPlayer, "Toggling realism!");
+                return true;
+            }
+        }
+        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 MultiblockTooltipBuilder createTooltip() {
+        MultiblockTooltipBuilder tt = new MultiblockTooltipBuilder();
+        tt.addMachineType("Laser Engraver")
+            .addInfo("Controller Block for the Hyper-Intensity Laser Engraver")
+            .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 recipe 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 Casing", 1)
+            .toolTipFinisher("GregTech");
+        return tt;
+    }
+
+    @Override
+    public void construct(ItemStack stackSize, boolean hintsOnly) {
+        buildPiece(STRUCTURE_PIECE_MAIN, stackSize, hintsOnly, 2, 4, 0);
+    }
+
+    @Override
+    public int survivalConstruct(ItemStack stackSize, int elementBudget, ISurvivalBuildEnvironment env) {
+        if (mMachine) return -1;
+        return survivialBuildPiece(STRUCTURE_PIECE_MAIN, stackSize, 2, 4, 0, elementBudget, env, false, true);
+    }
+
+    private int mCasingAmount;
+
+    private void onCasingAdded() {
+        mCasingAmount++;
+    }
+
+    @Override
+    public boolean checkMachine(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+        mCasingAmount = 0;
+        mEnergyHatches.clear();
+
+        if (!checkPiece(STRUCTURE_PIECE_MAIN, 2, 4, 0)) return false;
+        if (mCasingAmount < 45) return false;
+        if (laserSource == null) return false;
+        if (renderer == null) return false;
+        if (glassTier < VoltageIndex.UMV && laserSource.mTier > glassTier) return false;
+
+        return true;
+    }
+
+    private static String getUniqueIdentifier(ItemStack is) {
+        return is.getItem()
+            .getUnlocalizedName() + is.getItemDamage();
+    }
+
+    @Override
+    protected ProcessingLogic createProcessingLogic() {
+        return new ProcessingLogic() {
+
+            @NotNull
+            @Override
+            protected CheckRecipeResult validateRecipe(@Nonnull GTRecipe recipe) {
+                if (laserTier < VoltageIndex.UXV && recipe.mEUt > GTValues.V[laserTier]) {
+                    return SimpleCheckRecipeResult.ofFailure("laser_insufficient");
+                }
+                return CheckRecipeResultRegistry.SUCCESSFUL;
+            }
+
+            @NotNull
+            @Override
+            protected CheckRecipeResult onRecipeStart(@NotNull GTRecipe recipe) {
+                Colors c = Colors.Red;
+                for (int i = 0; i < recipe.mInputs.length; i++) {
+                    String uid = getUniqueIdentifier(recipe.mInputs[i]);
+                    if (lensColors.containsKey(uid)) {
+                        c = lensColors.get(uid);
+                    }
+                }
+                if (renderer != null) {
+                    renderer.setColors(c.r, c.g, c.b);
+                    if (!stopAllRendering) {
+                        renderer.setShouldRender(true);
+                    }
+                }
+                return super.onRecipeStart(recipe);
+            }
+
+            @Override
+            public ProcessingLogic clear() {
+                if (renderer != null) renderer.setShouldRender(false);
+                return super.clear();
+            }
+        }.setSpeedBonus(1F / 3F)
+            .setEuModifier(0.8F)
+            .setMaxParallelSupplier(this::getMaxParallelRecipes);
+    }
+
+    @Override
+    public boolean isRotationChangeAllowed() {
+        return true;
+    }
+
+    private int getMaxParallelRecipes() {
+        return laserAmps;
+    }
+
+    @Override
+    public RecipeMap<?> getRecipeMap() {
+        return RecipeMaps.laserEngraverRecipes;
+    }
+
+    @Override
+    public int getMaxEfficiency(ItemStack aStack) {
+        return 10000;
+    }
+
+    @Override
+    public int getDamageToComponent(ItemStack aStack) {
+        return 0;
+    }
+
+    @Override
+    public boolean explodesOnComponentBreak(ItemStack aStack) {
+        return false;
+    }
+
+    @Override
+    public int getRecipeCatalystPriority() {
+        return -10;
+    }
+
+    @Override
+    public boolean supportsVoidProtection() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsBatchMode() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsInputSeparation() {
+        return true;
+    }
+
+    @Override
+    public boolean supportsSingleRecipeLocking() {
+        return true;
+    }
+
+    @Override
+    protected void setProcessingLogicPower(ProcessingLogic logic) {
+        logic.setAvailableVoltage(GTUtility.roundUpVoltage(this.getMaxInputVoltage()));
+        logic.setAvailableAmperage(1L);
+    }
+
+    @Override
+    public void saveNBTData(NBTTagCompound aNBT) {
+        aNBT.setBoolean("stopAllRendering", stopAllRendering);
+        super.saveNBTData(aNBT);
+    }
+
+    @Override
+    public void loadNBTData(NBTTagCompound aNBT) {
+        if (aNBT.hasKey("stopAllRendering")) {
+            stopAllRendering = aNBT.getBoolean("stopAllRendering");
+        }
+        super.loadNBTData(aNBT);
+    }
+
+    @Override
+    public void getWailaNBTData(EntityPlayerMP player, TileEntity tile, NBTTagCompound tag, World world, int x, int y,
+        int z) {
+        super.getWailaNBTData(player, tile, tag, world, x, y, z);
+        tag.setInteger("laserAmps", laserAmps);
+        tag.setString("tierName", tierName);
+    }
+
+    @Override
+    public void getWailaBody(ItemStack itemStack, List<String> currentTip, IWailaDataAccessor accessor,
+        IWailaConfigHandler config) {
+        super.getWailaBody(itemStack, currentTip, accessor, config);
+        final NBTTagCompound tag = accessor.getNBTData();
+        currentTip.add(
+            StatCollector.translateToLocal("GT5U.multiblock.parallelism") + ": "
+                + EnumChatFormatting.WHITE
+                + tag.getInteger("laserAmps")
+                + EnumChatFormatting.RESET);
+        currentTip.add(
+            StatCollector.translateToLocal("GT5U.multiblock.maxtier") + ": "
+                + EnumChatFormatting.WHITE
+                + tag.getString("tierName")
+                + EnumChatFormatting.RESET);
+    }
+
+    private enum Colors {
+
+        White(1, 1, 1),
+        Red(1, 0, 0),
+        Green(0, 1, 0),
+        Blue(0, 0, 1),
+        Yellow(1, 1, 0),
+        Purple(1, 0, 1),
+        Cyan(0, 1, 1),
+        Orange(1, 0.5F, 0),
+        Black(0, 0, 0),
+        Brown(0.647F, 0.164F, 0.164F);
+
+        final float r, g, b;
+
+        Colors(float r, float g, float b) {
+            this.r = r;
+            this.g = g;
+            this.b = b;
+        }
+    }
+
+    private static final Map<String, Colors> lensColors;
+    static {
+        lensColors = new HashMap<>();
+
+        // Black lenses
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Forcicium, 1)), Colors.Black);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Forcillium, 1)), Colors.Black);
+        lensColors.put(
+            getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.InfusedEntropy, 1)),
+            Colors.Black);
+
+        // White lenses
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.NetherStar, 1)), Colors.White);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Dilithium, 1)), Colors.White);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Glass, 1)), Colors.White);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Diamond, 1)), Colors.Cyan);
+        lensColors.put(
+            getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.InfusedOrder, 1)),
+            Colors.White);
+
+        // Green lenses
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Emerald, 1)), Colors.Green);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Olivine, 1)), Colors.Green);
+        lensColors.put(
+            getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.GreenSapphire, 1)),
+            Colors.Green);
+        lensColors.put(
+            getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.InfusedEarth, 1)),
+            Colors.Green);
+
+        // Red lenses
+        lensColors.put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Ruby, 1)), Colors.Red);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Firestone, 1)), Colors.Red);
+        lensColors.put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Jasper, 1)), Colors.Red);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.FoolsRuby, 1)), Colors.Red);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.GarnetRed, 1)), Colors.Red);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.InfusedFire, 1)), Colors.Red);
+
+        // Blue lenses
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.BlueTopaz, 1)), Colors.Blue);
+        lensColors.put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Opal, 1)), Colors.Blue);
+        lensColors.put(
+            getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.InfusedWater, 1)),
+            Colors.Blue);
+
+        // Yellow lenses
+        lensColors.put(
+            getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.GarnetYellow, 1)),
+            Colors.Yellow);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Force, 1)), Colors.Yellow);
+        lensColors.put(
+            getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.InfusedAir, 1)),
+            Colors.Yellow);
+
+        // Purple lenses
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Amethyst, 1)), Colors.Purple);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Tanzanite, 1)), Colors.Purple);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Sapphire, 1)), Colors.Purple);
+
+        // Cyan lenses
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.EnderEye, 1)), Colors.Cyan);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.EnderPearl, 1)), Colors.Cyan);
+
+        // Orange lenses
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Topaz, 1)), Colors.Orange);
+        lensColors
+            .put(getUniqueIdentifier(GTOreDictUnificator.get(OrePrefixes.lens, Materials.Amber, 1)), Colors.Orange);
+
+        // Time to manually define a bunch of lenses based on id
+        lensColors.put("gt.bwMetaGeneratedlens1", Colors.Yellow);
+        lensColors.put("gt.bwMetaGeneratedlens4", Colors.White);
+        lensColors.put("gt.bwMetaGeneratedlens5", Colors.Black);
+        lensColors.put("gt.bwMetaGeneratedlens7", Colors.Green);
+        lensColors.put("gt.bwMetaGeneratedlens8", Colors.Green);
+        lensColors.put("gt.bwMetaGeneratedlens9", Colors.White);
+        lensColors.put("gt.bwMetaGeneratedlens19", Colors.Red);
+        lensColors.put("gt.bwMetaGeneratedlens20", Colors.White);
+        lensColors.put("gt.bwMetaGeneratedlens21", Colors.Brown);
+        lensColors.put("gt.bwMetaGeneratedlens22", Colors.Orange);
+        lensColors.put("gt.bwMetaGeneratedlens23", Colors.Black);
+        lensColors.put("gt.bwMetaGeneratedlens24", Colors.White);
+        lensColors.put("gt.bwMetaGeneratedlens25", Colors.Green);
+        lensColors.put("gt.bwMetaGeneratedlens35", Colors.Yellow);
+        lensColors.put("gt.bwMetaGeneratedlens36", Colors.Purple);
+        lensColors.put("gt.bwMetaGeneratedlens43", Colors.Green);
+        lensColors.put("gt.bwMetaGeneratedlens89", Colors.Green);
+        lensColors.put("gt.bwMetaGeneratedlens91", Colors.Purple);
+        lensColors.put("gt.bwMetaGeneratedlens10023", Colors.Red);
+        lensColors.put("gt.bwMetaGeneratedlens11499", Colors.Green);
+        lensColors.put("gt.bwMetaGeneratedlens11358", Colors.Red);
+        lensColors.put("MU-metaitem.0132140", Colors.Purple);
+        lensColors.put("MU-metaitem.0132140", Colors.Purple);
+
+        //
+    }
+}