diff --git a/Explicit.java b/Explicit.java new file mode 100644 index 0000000..e49cc58 --- /dev/null +++ b/Explicit.java @@ -0,0 +1,337 @@ +package me.explicit; + +import java.io.File; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.color.ColorManager; +import me.explicit.command.commands.BindCommand; +import me.explicit.command.commands.ConfigCommand; +import me.explicit.command.commands.FriendCommand; +import me.explicit.command.commands.HelpCommand; +import me.explicit.command.commands.SettingsCommand; +import me.explicit.command.commands.ToggleCommand; +import me.explicit.config.ConfigManager; +import me.explicit.consolegui.ConsoleGUI; +import me.explicit.friends.FriendManager; +import me.explicit.module.Module; +import me.explicit.module.ModuleManager; +import me.explicit.net.NetHandler; +import me.explicit.settings.SettingsManager; +import me.explicit.ui.clickgui.ClickGUI; +import me.explicit.ui.hud.HUDRenderer; +import me.explicit.utils.Game; +import me.explicit.utils.VersionCheck; +import net.minecraft.client.Minecraft; +import net.minecraft.client.network.NetHandlerPlayClient; +import net.minecraft.network.INetHandler; +import net.minecraftforge.client.ClientCommandHandler; +import net.minecraftforge.client.event.RenderGameOverlayEvent; +import net.minecraftforge.client.event.RenderWorldLastEvent; +import net.minecraftforge.client.event.RenderGameOverlayEvent.ElementType; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.InputEvent.KeyInputEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.ClientTickEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.PlayerTickEvent; +import org.lwjgl.input.Keyboard; + +public class Explicit { + + public static final String MODID; + public static final String NAME; + public static final String VERSION; + public static Explicit instance; + public ModuleManager mm; + public SettingsManager sm; + public ClickGUI clickGui; + public ColorManager cm; + public ConsoleGUI cg; + public HUDRenderer uiRenderer; + public ConfigManager configManager; + public FriendManager friendManager; + public static boolean destructed; + public static boolean consolegui; + private static final String[] lIIIIIIl; + private static String[] lIIIIIll; + + public void onInit() { + VersionCheck versioncheck = new VersionCheck(); + + versioncheck.setName(Explicit.lIIIIIIl[0]); + versioncheck.start(); + MinecraftForge.EVENT_BUS.register(this); + this.configManager = new ConfigManager(); + this.sm = new SettingsManager(); + this.mm = new ModuleManager(); + this.clickGui = new ClickGUI(); + this.cm = new ColorManager(); + this.uiRenderer = new HUDRenderer(); + ConfigManager.init(); + this.friendManager = new FriendManager(); + if (!Explicit.destructed) { + this.registerCommands(); + } + + this.cg = new ConsoleGUI(); + this.cg.setName(Explicit.lIIIIIIl[1]); + this.cg.start(); + } + + public void registerCommands() { + ClientCommandHandler.instance.registerCommand(new FriendCommand()); + ClientCommandHandler.instance.registerCommand(new ToggleCommand()); + ClientCommandHandler.instance.registerCommand(new BindCommand()); + ClientCommandHandler.instance.registerCommand(new ConfigCommand()); + ClientCommandHandler.instance.registerCommand(new SettingsCommand()); + ClientCommandHandler.instance.registerCommand(new HelpCommand()); + } + + public void onSelfDestruct() { + Minecraft.getMinecraft().currentScreen = null; + Iterator iterator = this.mm.modules.iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + MinecraftForge.EVENT_BUS.unregister(module); + module.setToggledNoSave(false); + module.setName(Explicit.lIIIIIIl[2]); + module = null; + this.mm.modules.remove(module); + } + + MinecraftForge.EVENT_BUS.unregister(this); + Explicit.consolegui = false; + Explicit.destructed = true; + this.configManager = null; + this.uiRenderer = null; + this.clickGui = null; + this.mm = null; + this.sm = null; + File file = Minecraft.getMinecraft().mcDataDir; + File file1 = new File(file, Explicit.lIIIIIIl[3]); + File file2 = new File(file, Explicit.lIIIIIIl[4]); + String[] astring = file1.list(); + + for (int i = 0; i < astring.length; ++i) { + String s = astring[i]; + File file3 = new File(file1.getPath(), s); + + file3.delete(); + } + + file1.delete(); + if (file2.exists()) { + String[] astring1 = file2.list(); + + for (int j = 0; j < astring1.length; ++j) { + String s1 = astring1[j]; + File file4 = new File(file2.getPath(), s1); + + file4.delete(); + } + + file2.delete(); + } + + } + + @SubscribeEvent + public void ClientTick(ClientTickEvent clienttickevent) { + if (Game.World() != null) { + INetHandler inethandler = Game.Player().sendQueue.getNetworkManager().getNetHandler(); + + if (!(inethandler instanceof NetHandler)) { + Game.Player().sendQueue.getNetworkManager().setNetHandler(new NetHandler((NetHandlerPlayClient) inethandler)); + } + } + + if (!Explicit.destructed) { + Iterator iterator = this.mm.getModules().iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + if (Game.World() != null && Game.Player() != null) { + module.onUpdateNoToggle(); + if (module.isToggled()) { + module.onUpdate(); + } + } + } + + } + } + + @SubscribeEvent + public void onLivingUpdate(LivingUpdateEvent livingupdateevent) { + if (livingupdateevent.entityLiving != null && livingupdateevent.entityLiving == Game.Player()) { + Iterator iterator = this.mm.getModules().iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + if (module.isToggled() && Game.World() != null && Game.Player() != null) { + module.onMove(); + } + } + } + + } + + @SubscribeEvent + public void PlayerTick(PlayerTickEvent playertickevent) { + if (!Explicit.destructed) { + Iterator iterator = this.mm.getModules().iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + if (module.isToggled() && Game.World() != null && Game.Player() != null) { + module.onTick(); + } + } + + } + } + + @SubscribeEvent + public void key(KeyInputEvent keyinputevent) { + if (!Explicit.destructed && Game.World() != null && Game.Player() != null) { + try { + if (Keyboard.isCreated() && Keyboard.getEventKeyState()) { + int i = Keyboard.getEventKey(); + + if (i <= 0) { + return; + } + + Iterator iterator = this.mm.modules.iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + if (module.getKey() == i && i > 0) { + module.toggle(); + } + } + } + } catch (Exception exception) { + exception.printStackTrace(); + } + + } + } + + @SubscribeEvent + public void render(RenderGameOverlayEvent rendergameoverlayevent) { + if (rendergameoverlayevent.type.equals(ElementType.TEXT) && !Explicit.destructed) { + this.uiRenderer.draw(); + Iterator iterator = this.mm.getModules().iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + if (module.isToggled() && Game.World() != null && Game.Player() != null) { + module.onRender2D(); + } + } + + } + } + + @SubscribeEvent + public void render3d(RenderWorldLastEvent renderworldlastevent) { + if (!Explicit.destructed) { + Iterator iterator = this.mm.getModules().iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + if (module.isToggled() && Game.World() != null && Game.Player() != null) { + module.onRender3D(); + } + } + + } + } + + static { + lllIIIIIl(); + lllIIIIII(); + NAME = Explicit.lIIIIIIl[5]; + MODID = Explicit.lIIIIIIl[6]; + VERSION = Explicit.lIIIIIIl[7]; + Explicit.destructed = false; + Explicit.consolegui = false; + } + + private static void lllIIIIII() { + lIIIIIIl = new String[8]; + Explicit.lIIIIIIl[0] = llIlllIlI(Explicit.lIIIIIll[0], Explicit.lIIIIIll[1]); + Explicit.lIIIIIIl[1] = llIlllIll(Explicit.lIIIIIll[2], Explicit.lIIIIIll[3]); + Explicit.lIIIIIIl[2] = llIlllIll(Explicit.lIIIIIll[4], Explicit.lIIIIIll[5]); + Explicit.lIIIIIIl[3] = llIllllII(Explicit.lIIIIIll[6], Explicit.lIIIIIll[7]); + Explicit.lIIIIIIl[4] = llIlllIll(Explicit.lIIIIIll[8], Explicit.lIIIIIll[9]); + Explicit.lIIIIIIl[5] = llIllllII(Explicit.lIIIIIll[10], Explicit.lIIIIIll[11]); + Explicit.lIIIIIIl[6] = llIlllIlI(Explicit.lIIIIIll[12], Explicit.lIIIIIll[13]); + Explicit.lIIIIIIl[7] = llIlllIll(Explicit.lIIIIIll[14], Explicit.lIIIIIll[15]); + Explicit.lIIIIIll = null; + } + + private static void lllIIIIIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Explicit.lIIIIIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIlllIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIlllIll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIllllII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/color/Chroma.java b/color/Chroma.java new file mode 100644 index 0000000..54fb9e5 --- /dev/null +++ b/color/Chroma.java @@ -0,0 +1,40 @@ +package me.explicit.color; + +import java.awt.Color; +import me.explicit.utils.TimerUtils; +import net.minecraftforge.client.event.RenderGameOverlayEvent; +import net.minecraftforge.client.event.RenderGameOverlayEvent.ElementType; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class Chroma { + + private TimerUtils timer = new TimerUtils(); + private int lastHue; + + @SubscribeEvent + public void render(RenderGameOverlayEvent rendergameoverlayevent) { + if (rendergameoverlayevent.type.equals(ElementType.TEXT) && this.timer.hasReached(33.3333333333D)) { + this.changeColor(); + this.timer.reset(); + } + + } + + public Color getColor(int i) { + int j; + + for (j = this.lastHue + i * 2; j > 1000; j -= 1000) { + ; + } + + return Color.getHSBColor((float) j / 1000.0F, 1.0F, 1.0F); + } + + private void changeColor() { + this.lastHue += 5; + if (this.lastHue > 1000) { + this.lastHue = 0; + } + + } +} diff --git a/color/ColorManager.java b/color/ColorManager.java new file mode 100644 index 0000000..a272c4c --- /dev/null +++ b/color/ColorManager.java @@ -0,0 +1,12 @@ +package me.explicit.color; + +import net.minecraftforge.common.MinecraftForge; + +public class ColorManager { + + public Chroma cc = new Chroma(); + + public ColorManager() { + MinecraftForge.EVENT_BUS.register(this.cc); + } +} diff --git a/command/CommandUtils.java b/command/CommandUtils.java new file mode 100644 index 0000000..f7a2a79 --- /dev/null +++ b/command/CommandUtils.java @@ -0,0 +1,140 @@ +package me.explicit.command; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.command.commands.BindCommand; +import me.explicit.command.commands.ConfigCommand; +import me.explicit.command.commands.FriendCommand; +import me.explicit.command.commands.HelpCommand; +import me.explicit.command.commands.SettingsCommand; +import me.explicit.command.commands.ToggleCommand; +import org.apache.commons.lang3.ArrayUtils; + +public class CommandUtils { + + private static final String[] llIIlllI; + private static String[] llIlIIll; + + public static List sendCommand(String s) { + Object object; + + ((List) (object = new ArrayList())).clear(); + ((List) object).add(CommandUtils.llIIlllI[0]); + s = s.replaceFirst(CommandUtils.llIIlllI[1], CommandUtils.llIIlllI[2]); + s = s.replaceFirst(CommandUtils.llIIlllI[3], CommandUtils.llIIlllI[4]); + if (s.startsWith(CommandUtils.llIIlllI[5])) { + object = (new BindCommand()).executeCommand((String[]) ArrayUtils.remove(s.split(CommandUtils.llIIlllI[6]), 0)); + } else if (!s.startsWith(CommandUtils.llIIlllI[7]) && !s.startsWith(CommandUtils.llIIlllI[8])) { + if (!s.startsWith(CommandUtils.llIIlllI[10]) && !s.startsWith(CommandUtils.llIIlllI[11]) && !s.startsWith(CommandUtils.llIIlllI[12])) { + if (s.startsWith(CommandUtils.llIIlllI[14])) { + object = (new ConfigCommand()).executeCommand((String[]) ArrayUtils.remove(s.split(CommandUtils.llIIlllI[15]), 0), false); + } else if (!s.startsWith(CommandUtils.llIIlllI[16]) && !s.startsWith(CommandUtils.llIIlllI[17]) && !s.startsWith(CommandUtils.llIIlllI[18])) { + if (s.startsWith(CommandUtils.llIIlllI[20])) { + object = (new HelpCommand()).executeCommand((String[]) ArrayUtils.remove(s.split(CommandUtils.llIIlllI[21]), 0)); + } else { + ((List) object).clear(); + ((List) object).add(String.valueOf((new StringBuilder()).append(CommandUtils.llIIlllI[22]).append(s).append(CommandUtils.llIIlllI[23]))); + } + } else { + object = (new SettingsCommand()).executeCommand((String[]) ArrayUtils.remove(s.split(CommandUtils.llIIlllI[19]), 0)); + } + } else { + object = (new FriendCommand()).executeCommand((String[]) ArrayUtils.remove(s.split(CommandUtils.llIIlllI[13]), 0)); + } + } else { + object = (new ToggleCommand()).executeCommand((String[]) ArrayUtils.remove(s.split(CommandUtils.llIIlllI[9]), 0)); + } + + return (List) object; + } + + static { + llIIIlIlII(); + llIIIlIIlI(); + } + + private static void llIIIlIIlI() { + llIIlllI = new String[24]; + CommandUtils.llIIlllI[0] = llIIIIIlII(CommandUtils.llIlIIll[0], CommandUtils.llIlIIll[1]); + CommandUtils.llIIlllI[1] = llIIIIlIlI(CommandUtils.llIlIIll[2], CommandUtils.llIlIIll[3]); + CommandUtils.llIIlllI[2] = llIIIIIlII(CommandUtils.llIlIIll[4], CommandUtils.llIlIIll[5]); + CommandUtils.llIIlllI[3] = llIIIIlIlI(CommandUtils.llIlIIll[6], CommandUtils.llIlIIll[7]); + CommandUtils.llIIlllI[4] = llIIIIlIll(CommandUtils.llIlIIll[8], CommandUtils.llIlIIll[9]); + CommandUtils.llIIlllI[5] = llIIIIlIll(CommandUtils.llIlIIll[10], CommandUtils.llIlIIll[11]); + CommandUtils.llIIlllI[6] = llIIIIlIlI(CommandUtils.llIlIIll[12], CommandUtils.llIlIIll[13]); + CommandUtils.llIIlllI[7] = llIIIIlIll(CommandUtils.llIlIIll[14], CommandUtils.llIlIIll[15]); + CommandUtils.llIIlllI[8] = llIIIIlIll(CommandUtils.llIlIIll[16], CommandUtils.llIlIIll[17]); + CommandUtils.llIIlllI[9] = llIIIIlIlI(CommandUtils.llIlIIll[18], CommandUtils.llIlIIll[19]); + CommandUtils.llIIlllI[10] = llIIIIIlII(CommandUtils.llIlIIll[20], CommandUtils.llIlIIll[21]); + CommandUtils.llIIlllI[11] = llIIIIlIll(CommandUtils.llIlIIll[22], CommandUtils.llIlIIll[23]); + CommandUtils.llIIlllI[12] = llIIIIlIlI(CommandUtils.llIlIIll[24], CommandUtils.llIlIIll[25]); + CommandUtils.llIIlllI[13] = llIIIIlIll(CommandUtils.llIlIIll[26], CommandUtils.llIlIIll[27]); + CommandUtils.llIIlllI[14] = llIIIIlIlI(CommandUtils.llIlIIll[28], CommandUtils.llIlIIll[29]); + CommandUtils.llIIlllI[15] = llIIIIIlII(CommandUtils.llIlIIll[30], CommandUtils.llIlIIll[31]); + CommandUtils.llIIlllI[16] = llIIIIlIlI(CommandUtils.llIlIIll[32], CommandUtils.llIlIIll[33]); + CommandUtils.llIIlllI[17] = llIIIIIlII(CommandUtils.llIlIIll[34], CommandUtils.llIlIIll[35]); + CommandUtils.llIIlllI[18] = llIIIIIlII(CommandUtils.llIlIIll[36], CommandUtils.llIlIIll[37]); + CommandUtils.llIIlllI[19] = llIIIIlIll(CommandUtils.llIlIIll[38], CommandUtils.llIlIIll[39]); + CommandUtils.llIIlllI[20] = llIIIIIlII(CommandUtils.llIlIIll[40], CommandUtils.llIlIIll[41]); + CommandUtils.llIIlllI[21] = llIIIIlIlI(CommandUtils.llIlIIll[42], CommandUtils.llIlIIll[43]); + CommandUtils.llIIlllI[22] = llIIIIlIll(CommandUtils.llIlIIll[44], CommandUtils.llIlIIll[45]); + CommandUtils.llIIlllI[23] = llIIIIlIlI(CommandUtils.llIlIIll[46], CommandUtils.llIlIIll[47]); + CommandUtils.llIlIIll = null; + } + + private static void llIIIlIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + CommandUtils.llIlIIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIIIIlII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIIIlIlI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIIIIlIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/command/commands/BindCommand.java b/command/commands/BindCommand.java new file mode 100644 index 0000000..ae43851 --- /dev/null +++ b/command/commands/BindCommand.java @@ -0,0 +1,282 @@ +package me.explicit.command.commands; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Module; +import me.explicit.utils.ChatUtils; +import me.explicit.utils.Game; +import net.minecraft.command.CommandException; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.util.BlockPos; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; +import org.lwjgl.input.Keyboard; + +public class BindCommand implements ICommand { + + private static final String[] lIIllIllI; + private static String[] lIlIIIlII; + + public int compareTo(ICommand icommand) { + return 0; + } + + public String getCommandName() { + return BindCommand.lIIllIllI[0]; + } + + public String getCommandUsage(ICommandSender icommandsender) { + return BindCommand.lIIllIllI[1]; + } + + public List getCommandAliases() { + ArrayList arraylist = new ArrayList(); + + arraylist.add(BindCommand.lIIllIllI[2]); + return arraylist; + } + + public void processCommand(ICommandSender icommandsender, String[] astring) throws CommandException { + this.executeCommand(astring); + } + + public List executeCommand(String[] astring) { + ArrayList arraylist; + + (arraylist = new ArrayList()).clear(); + if (Explicit.destructed) { + Game.Player().addChatMessage(new ChatComponentText(String.valueOf((new StringBuilder()).append(EnumChatFormatting.RED).append(BindCommand.lIIllIllI[3])))); + return arraylist; + } else { + if (astring.length == 0) { + if (Explicit.consolegui) { + arraylist.add(BindCommand.lIIllIllI[4]); + arraylist.add(BindCommand.lIIllIllI[5]); + arraylist.add(BindCommand.lIIllIllI[6]); + arraylist.add(BindCommand.lIIllIllI[7]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[8]))); + ChatUtils.sendMessage(BindCommand.lIIllIllI[9]); + ChatUtils.sendMessage(BindCommand.lIIllIllI[10]); + ChatUtils.sendMessage(BindCommand.lIIllIllI[11]); + } + } else if (astring[0].equalsIgnoreCase(BindCommand.lIIllIllI[12])) { + if (astring.length >= 2 && Explicit.instance.mm.getModuleByName(astring[1]) != null) { + if (astring.length == 3 && Keyboard.getKeyIndex(astring[2].toUpperCase()) != 0) { + Explicit.instance.mm.getModuleByName(astring[1]).setKey(Keyboard.getKeyIndex(astring[2].toUpperCase())); + if (Explicit.consolegui) { + arraylist.add(String.valueOf((new StringBuilder()).append(BindCommand.lIIllIllI[13]).append(astring[1]).append(BindCommand.lIIllIllI[14]).append(astring[2].toUpperCase()).append(BindCommand.lIIllIllI[15]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[16]).append(astring[1]).append(BindCommand.lIIllIllI[17]).append(astring[2].toUpperCase()).append(BindCommand.lIIllIllI[18]))); + } + } else if (Keyboard.getKeyIndex(astring[2].toUpperCase()) == 0) { + if (Explicit.consolegui) { + arraylist.add(String.valueOf((new StringBuilder()).append(BindCommand.lIIllIllI[19]).append(astring[2].toUpperCase()).append(BindCommand.lIIllIllI[20]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[21]).append(astring[2].toUpperCase()).append(BindCommand.lIIllIllI[22]))); + } + } else if (Explicit.consolegui) { + arraylist.add(BindCommand.lIIllIllI[23]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[24]))); + } + } else if (astring.length >= 2 && Explicit.instance.mm.getModuleByName(astring[1]) == null) { + if (Explicit.consolegui) { + arraylist.add(String.valueOf((new StringBuilder()).append(BindCommand.lIIllIllI[25]).append(astring[1].toUpperCase()).append(BindCommand.lIIllIllI[26]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[27]).append(astring[1].toUpperCase()).append(BindCommand.lIIllIllI[28]))); + } + } else if (astring.length == 1) { + if (Explicit.consolegui) { + arraylist.add(BindCommand.lIIllIllI[29]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[30]))); + } + } + } else if (astring[0].equalsIgnoreCase(BindCommand.lIIllIllI[31])) { + Iterator iterator = Explicit.instance.mm.getModules().iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + module.setKey(0); + } + + if (Explicit.consolegui) { + arraylist.add(BindCommand.lIIllIllI[32]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[33]))); + } + } else if (astring[0].equalsIgnoreCase(BindCommand.lIIllIllI[34])) { + if (astring.length >= 2 && Explicit.instance.mm.getModuleByName(astring[1]) != null) { + Explicit.instance.mm.getModuleByName(astring[1]).setKey(0); + if (Explicit.consolegui) { + arraylist.add(String.valueOf((new StringBuilder()).append(BindCommand.lIIllIllI[35]).append(astring[1]).append(BindCommand.lIIllIllI[36]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[37]).append(astring[1]).append(BindCommand.lIIllIllI[38]))); + } + } else if (astring.length >= 2) { + if (Explicit.consolegui) { + arraylist.add(String.valueOf((new StringBuilder()).append(BindCommand.lIIllIllI[39]).append(astring[1]).append(BindCommand.lIIllIllI[40]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[41]).append(astring[1]).append(BindCommand.lIIllIllI[42]))); + } + } else if (Explicit.consolegui) { + arraylist.add(BindCommand.lIIllIllI[43]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[44]))); + } + } else if (Explicit.consolegui) { + arraylist.add(BindCommand.lIIllIllI[45]); + arraylist.add(BindCommand.lIIllIllI[46]); + arraylist.add(BindCommand.lIIllIllI[47]); + arraylist.add(BindCommand.lIIllIllI[48]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(BindCommand.lIIllIllI[49]))); + ChatUtils.sendMessage(BindCommand.lIIllIllI[50]); + ChatUtils.sendMessage(BindCommand.lIIllIllI[51]); + ChatUtils.sendMessage(BindCommand.lIIllIllI[52]); + } + + return arraylist; + } + } + + public boolean canCommandSenderUseCommand(ICommandSender icommandsender) { + return true; + } + + public List addTabCompletionOptions(ICommandSender icommandsender, String[] astring, BlockPos blockpos) { + return null; + } + + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int compareTo(Object object) { + return this.compareTo((ICommand) object); + } + + static { + lIIIlllIlll(); + lIIIlllIllI(); + } + + private static void lIIIlllIllI() { + lIIllIllI = new String[53]; + BindCommand.lIIllIllI[0] = lIIIIllllII(BindCommand.lIlIIIlII[0], BindCommand.lIlIIIlII[1]); + BindCommand.lIIllIllI[1] = lIIIIllllII(BindCommand.lIlIIIlII[2], BindCommand.lIlIIIlII[3]); + BindCommand.lIIllIllI[2] = lIIIIllllII(BindCommand.lIlIIIlII[4], BindCommand.lIlIIIlII[5]); + BindCommand.lIIllIllI[3] = lIIIIllllII(BindCommand.lIlIIIlII[6], BindCommand.lIlIIIlII[7]); + BindCommand.lIIllIllI[4] = lIIIIllllII(BindCommand.lIlIIIlII[8], BindCommand.lIlIIIlII[9]); + BindCommand.lIIllIllI[5] = lIIIIllllIl(BindCommand.lIlIIIlII[10], BindCommand.lIlIIIlII[11]); + BindCommand.lIIllIllI[6] = lIIIIllllll(BindCommand.lIlIIIlII[12], BindCommand.lIlIIIlII[13]); + BindCommand.lIIllIllI[7] = lIIIIllllII(BindCommand.lIlIIIlII[14], BindCommand.lIlIIIlII[15]); + BindCommand.lIIllIllI[8] = lIIIIllllII(BindCommand.lIlIIIlII[16], BindCommand.lIlIIIlII[17]); + BindCommand.lIIllIllI[9] = lIIIIllllII(BindCommand.lIlIIIlII[18], BindCommand.lIlIIIlII[19]); + BindCommand.lIIllIllI[10] = lIIIIllllII(BindCommand.lIlIIIlII[20], BindCommand.lIlIIIlII[21]); + BindCommand.lIIllIllI[11] = lIIIIllllll(BindCommand.lIlIIIlII[22], BindCommand.lIlIIIlII[23]); + BindCommand.lIIllIllI[12] = lIIIIllllIl(BindCommand.lIlIIIlII[24], BindCommand.lIlIIIlII[25]); + BindCommand.lIIllIllI[13] = lIIIIllllll(BindCommand.lIlIIIlII[26], BindCommand.lIlIIIlII[27]); + BindCommand.lIIllIllI[14] = lIIIIllllII(BindCommand.lIlIIIlII[28], BindCommand.lIlIIIlII[29]); + BindCommand.lIIllIllI[15] = lIIIIllllll(BindCommand.lIlIIIlII[30], BindCommand.lIlIIIlII[31]); + BindCommand.lIIllIllI[16] = lIIIIllllIl(BindCommand.lIlIIIlII[32], BindCommand.lIlIIIlII[33]); + BindCommand.lIIllIllI[17] = lIIIIllllII(BindCommand.lIlIIIlII[34], BindCommand.lIlIIIlII[35]); + BindCommand.lIIllIllI[18] = lIIIIllllIl(BindCommand.lIlIIIlII[36], BindCommand.lIlIIIlII[37]); + BindCommand.lIIllIllI[19] = lIIIIllllIl(BindCommand.lIlIIIlII[38], BindCommand.lIlIIIlII[39]); + BindCommand.lIIllIllI[20] = lIIIIllllIl("laeKFUSipqpA2qjU5uuz3+oBiX6PXcqo", "PcVBG"); + BindCommand.lIIllIllI[21] = lIIIIllllII("NigKKy5JZwwxMkUsHSB3Qg==", "eGxYW"); + BindCommand.lIIllIllI[22] = lIIIIllllll("0N5JHvJzy2wnVnwOZwaEE6NNfWXmV1ea", "Hhquu"); + BindCommand.lIIllIllI[23] = lIIIIllllII("DQAgCxViU24OGTYXYR8VLFN9IR88Bi0JTnhPCgkJZg==", "XsAlp"); + BindCommand.lIIllIllI[24] = lIIIIllllII("BBwtFA9rT2MRAz8LbAAPJU9wPgU1GiAWVHFTBxYTbw==", "QoLsj"); + BindCommand.lIIllIllI[25] = lIIIIllllII("MAIHOgBPTQEgHEMAGiwMDwhVbw==", "cmuHy"); + BindCommand.lIIllIllI[26] = lIIIIllllII("cFYxPAIkVjs8E3cTLToUIw==", "WvUSg"); + BindCommand.lIIllIllI[27] = lIIIIllllIl("dnMuvjvGZm62GLI7AI53Mt4tInriJ4Gg", "jhWIj"); + BindCommand.lIIllIllI[28] = lIIIIllllll("xTQhZhJsyzDCXayS8CcreU+GZPNvICNf", "Yupfi"); + BindCommand.lIIllIllI[29] = lIIIIllllIl("v27ztdw7eCBud9rm1T+OjD1sxuuG1UbYU/mTtDsKZKs=", "ImpgB"); + BindCommand.lIIllIllI[30] = lIIIIllllII("AjEMBgRtYkIDCDkmTRIEI2JRLA4zNwEEX3d+JgQYaQ==", "WBmaa"); + BindCommand.lIIllIllI[31] = lIIIIllllII("NxAXGRUANBYa", "euzvc"); + BindCommand.lIIllIllI[32] = lIIIIllllll("G8dT3qog5pPlBKObMnLeW0Ck8onEGcBoYzUF+Nle5uXzLs9T1SoOpg==", "SOvaM"); + BindCommand.lIIllIllI[33] = lIIIIllllll("O58K0EbpPWLrQKP+T/lTZmOtvf4oIjQsHZZkUdf1QzwBXE6nWH8fQg==", "HgeXr"); + BindCommand.lIIllIllI[34] = lIIIIllllIl("60DSLA/3WB4=", "kBGLh"); + BindCommand.lIIllIllI[35] = lIIIIllllII("IS8XMSwBKRInJR4jVCcnEDUBPC1SfQ==", "rZtRI"); + BindCommand.lIIllIllI[36] = lIIIIllllIl("E4qO5fibs48=", "ozqZU"); + BindCommand.lIIllIllI[37] = lIIIIllllII("CxsPLRcrHQo7HjQXTDscOgEZIBZ4SQ==", "XnlNr"); + BindCommand.lIIllIllI[38] = lIIIIllllIl("4Lmi+ophXx0=", "XOWZI"); + BindCommand.lIIllIllI[39] = lIIIIllllII("FTkEBjVqdgIcKWY7GRA5KjNWUw==", "FVvtL"); + BindCommand.lIIllIllI[40] = lIIIIllllll("AhGYxmvcaLQUa76lzQswQObXv2l1MdiT", "WqdKD"); + BindCommand.lIIllIllI[41] = lIIIIllllll("ojNpEFvdFfcBPiuSfNmHV56OdJCUVdPE", "MWVuM"); + BindCommand.lIIllIllI[42] = lIIIIllllIl("LsbxW7idyGbMCjzQHrCI2V/lvd7DCprK", "JgDWB"); + BindCommand.lIIllIllI[43] = lIIIIllllII("BTAGEBVqY0gVGT4nRwUVPSwRElBsDggTBTwmWQ==", "PCgwp"); + BindCommand.lIIllIllI[44] = lIIIIllllll("r8TgN+SLxK6Q3NM0EPno9gs6xkVpCaIRGrnR1Ydcc6U=", "hFfli"); + BindCommand.lIIllIllI[45] = lIIIIllllII("OTAwISIdLCMndVg=", "xBWTO"); + BindCommand.lIIllIllI[46] = lIIIIllllll("mTcbmHDKyIk=", "aBkqL"); + BindCommand.lIIllIllI[47] = lIIIIllllII("CgAVDgY9", "Xexap"); + BindCommand.lIIllIllI[48] = lIIIIllllII("HhAOBDApNA8H", "LuckF"); + BindCommand.lIIllIllI[49] = lIIIIllllIl("2mt3Lx8C/IbCtjVTJpcSng==", "hGRoB"); + BindCommand.lIIllIllI[50] = lIIIIllllll("48DW8MxRx+A=", "iHbGm"); + BindCommand.lIIllIllI[51] = lIIIIllllIl("VoSCxdZ3Fl0=", "RuyUJ"); + BindCommand.lIIllIllI[52] = lIIIIllllll("izmXiENsuhl4W3Bi2MOy2w==", "mFnEL"); + BindCommand.lIlIIIlII = null; + } + + private static void lIIIlllIlll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + BindCommand.lIlIIIlII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIllllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIIllllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIIllllII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/command/commands/ConfigCommand.java b/command/commands/ConfigCommand.java new file mode 100644 index 0000000..e80c083 --- /dev/null +++ b/command/commands/ConfigCommand.java @@ -0,0 +1,364 @@ +package me.explicit.command.commands; + +import java.io.File; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.config.ConfigManager; +import me.explicit.utils.ChatUtils; +import me.explicit.utils.Game; +import net.minecraft.command.CommandException; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.util.BlockPos; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; + +public class ConfigCommand implements ICommand { + + private static final String[] lIIlIIIl; + private static String[] lIIlIllI; + + public int compareTo(ICommand icommand) { + return 0; + } + + public String getCommandName() { + return ConfigCommand.lIIlIIIl[0]; + } + + public String getCommandUsage(ICommandSender icommandsender) { + return ConfigCommand.lIIlIIIl[1]; + } + + public List getCommandAliases() { + ArrayList arraylist = new ArrayList(); + + arraylist.add(ConfigCommand.lIIlIIIl[2]); + arraylist.add(ConfigCommand.lIIlIIIl[3]); + return arraylist; + } + + public void processCommand(ICommandSender icommandsender, String[] astring) throws CommandException { + this.executeCommand(astring, true); + } + + public List executeCommand(String[] astring, boolean flag) { + ArrayList arraylist; + + (arraylist = new ArrayList()).clear(); + if (Explicit.destructed) { + Game.Player().addChatMessage(new ChatComponentText(String.valueOf((new StringBuilder()).append(EnumChatFormatting.RED).append(ConfigCommand.lIIlIIIl[4])))); + return arraylist; + } else { + boolean flag1 = Explicit.consolegui || !flag; + + if (astring.length == 0) { + if (flag1) { + arraylist.add(ConfigCommand.lIIlIIIl[5]); + arraylist.add(ConfigCommand.lIIlIIIl[6]); + arraylist.add(ConfigCommand.lIIlIIIl[7]); + arraylist.add(ConfigCommand.lIIlIIIl[8]); + arraylist.add(ConfigCommand.lIIlIIIl[9]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[10]))); + ChatUtils.sendMessage(ConfigCommand.lIIlIIIl[11]); + ChatUtils.sendMessage(ConfigCommand.lIIlIIIl[12]); + ChatUtils.sendMessage(ConfigCommand.lIIlIIIl[13]); + ChatUtils.sendMessage(ConfigCommand.lIIlIIIl[14]); + } + + return arraylist; + } else if (astring.length >= 2 && astring[1].equalsIgnoreCase(ConfigCommand.lIIlIIIl[15])) { + if (flag1) { + arraylist.add(String.valueOf((new StringBuilder()).append(ConfigCommand.lIIlIIIl[16]).append(astring[1]).append(ConfigCommand.lIIlIIIl[17]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[18]).append(astring[1]).append(ConfigCommand.lIIlIIIl[19]))); + } + + return arraylist; + } else { + if (astring.length >= 1) { + if (astring[0].equalsIgnoreCase(ConfigCommand.lIIlIIIl[20])) { + if (ConfigManager.GetConfigs().size() == 0) { + if (flag1) { + arraylist.add(ConfigCommand.lIIlIIIl[21]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[22]))); + } + } else { + if (flag1) { + arraylist.add(ConfigCommand.lIIlIIIl[23]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[24]))); + } + + Iterator iterator = ConfigManager.GetConfigs().iterator(); + + while (iterator.hasNext()) { + String s = (String) iterator.next(); + + if (flag1) { + arraylist.add(s); + } else { + ChatUtils.sendMessage(s); + } + } + } + } else if (astring[0].equalsIgnoreCase(ConfigCommand.lIIlIIIl[25])) { + if (astring.length >= 2) { + ConfigManager.getConfigFile(astring[1], true); + ConfigManager.SaveConfigFile(astring[1]); + if (flag1) { + arraylist.add(String.valueOf((new StringBuilder()).append(ConfigCommand.lIIlIIIl[26]).append(astring[1]).append(ConfigCommand.lIIlIIIl[27]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[28]).append(astring[1]).append(ConfigCommand.lIIlIIIl[29]))); + } + } else if (flag1) { + arraylist.add(ConfigCommand.lIIlIIIl[30]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[31]))); + } + } else { + boolean flag2; + File file; + + if (astring[0].equalsIgnoreCase(ConfigCommand.lIIlIIIl[32])) { + astring[1].replaceAll(ConfigCommand.lIIlIIIl[33], ConfigCommand.lIIlIIIl[34]); + if (astring.length >= 2) { + flag2 = true; + file = new File(ConfigManager.dir, String.format(ConfigCommand.lIIlIIIl[35], new Object[] { astring[1]})); + if (!file.exists()) { + flag2 = false; + + try { + file.createNewFile(); + } catch (IOException ioexception) { + ; + } + } + + if (flag2) { + ConfigManager.LoadConfig(astring[1]); + if (flag1) { + arraylist.add(String.valueOf((new StringBuilder()).append(ConfigCommand.lIIlIIIl[36]).append(astring[1]).append(ConfigCommand.lIIlIIIl[37]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[38]).append(astring[1]).append(ConfigCommand.lIIlIIIl[39]))); + } + } else if (flag1) { + arraylist.add(String.valueOf((new StringBuilder()).append(ConfigCommand.lIIlIIIl[40]).append(astring[1]).append(ConfigCommand.lIIlIIIl[41]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[42]).append(astring[1]).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[43]))); + } + } else if (flag1) { + arraylist.add(ConfigCommand.lIIlIIIl[44]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[45]))); + } + } else if (astring[0].equalsIgnoreCase(ConfigCommand.lIIlIIIl[46])) { + if (astring.length >= 2) { + flag2 = true; + file = new File(ConfigManager.dir, String.format(ConfigCommand.lIIlIIIl[47], new Object[] { astring[1]})); + if (!file.exists()) { + flag2 = false; + } + + if (flag2) { + if (file.delete()) { + if (flag1) { + arraylist.add(String.valueOf((new StringBuilder()).append(ConfigCommand.lIIlIIIl[48]).append(astring[1]).append(ConfigCommand.lIIlIIIl[49]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[50]).append(astring[1]).append(ConfigCommand.lIIlIIIl[51]))); + } + } else if (flag1) { + arraylist.add(String.valueOf((new StringBuilder()).append(ConfigCommand.lIIlIIIl[52]).append(astring[1]).append(ConfigCommand.lIIlIIIl[53]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[54]).append(astring[1]).append(ConfigCommand.lIIlIIIl[55]))); + } + } else if (flag1) { + arraylist.add(String.valueOf((new StringBuilder()).append(ConfigCommand.lIIlIIIl[56]).append(astring[1]).append(ConfigCommand.lIIlIIIl[57]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[58]).append(astring[1]).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[59]))); + } + } else if (flag1) { + arraylist.add(ConfigCommand.lIIlIIIl[60]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[61]))); + } + } else if (flag1) { + arraylist.add(ConfigCommand.lIIlIIIl[62]); + arraylist.add(ConfigCommand.lIIlIIIl[63]); + arraylist.add(ConfigCommand.lIIlIIIl[64]); + arraylist.add(ConfigCommand.lIIlIIIl[65]); + arraylist.add(ConfigCommand.lIIlIIIl[66]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ConfigCommand.lIIlIIIl[67]))); + ChatUtils.sendMessage(ConfigCommand.lIIlIIIl[68]); + ChatUtils.sendMessage(ConfigCommand.lIIlIIIl[69]); + ChatUtils.sendMessage(ConfigCommand.lIIlIIIl[70]); + ChatUtils.sendMessage(ConfigCommand.lIIlIIIl[71]); + } + } + } + + return arraylist; + } + } + } + + public boolean canCommandSenderUseCommand(ICommandSender icommandsender) { + return true; + } + + public List addTabCompletionOptions(ICommandSender icommandsender, String[] astring, BlockPos blockpos) { + return null; + } + + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int compareTo(Object object) { + return this.compareTo((ICommand) object); + } + + static { + lIIIIlIIlI(); + lIIIIlIIIl(); + } + + private static void lIIIIlIIIl() { + lIIlIIIl = new String[72]; + ConfigCommand.lIIlIIIl[0] = lllllllII(ConfigCommand.lIIlIllI[0], ConfigCommand.lIIlIllI[1]); + ConfigCommand.lIIlIIIl[1] = lllllllIl(ConfigCommand.lIIlIllI[2], ConfigCommand.lIIlIllI[3]); + ConfigCommand.lIIlIIIl[2] = lllllllII(ConfigCommand.lIIlIllI[4], ConfigCommand.lIIlIllI[5]); + ConfigCommand.lIIlIIIl[3] = lllllllIl(ConfigCommand.lIIlIllI[6], ConfigCommand.lIIlIllI[7]); + ConfigCommand.lIIlIIIl[4] = lllllllIl(ConfigCommand.lIIlIllI[8], ConfigCommand.lIIlIllI[9]); + ConfigCommand.lIIlIIIl[5] = lllllllII(ConfigCommand.lIIlIllI[10], ConfigCommand.lIIlIllI[11]); + ConfigCommand.lIIlIIIl[6] = lllllllll(ConfigCommand.lIIlIllI[12], ConfigCommand.lIIlIllI[13]); + ConfigCommand.lIIlIIIl[7] = lllllllII(ConfigCommand.lIIlIllI[14], ConfigCommand.lIIlIllI[15]); + ConfigCommand.lIIlIIIl[8] = lllllllIl(ConfigCommand.lIIlIllI[16], ConfigCommand.lIIlIllI[17]); + ConfigCommand.lIIlIIIl[9] = lllllllll(ConfigCommand.lIIlIllI[18], ConfigCommand.lIIlIllI[19]); + ConfigCommand.lIIlIIIl[10] = lllllllIl(ConfigCommand.lIIlIllI[20], ConfigCommand.lIIlIllI[21]); + ConfigCommand.lIIlIIIl[11] = lllllllII(ConfigCommand.lIIlIllI[22], ConfigCommand.lIIlIllI[23]); + ConfigCommand.lIIlIIIl[12] = lllllllIl(ConfigCommand.lIIlIllI[24], ConfigCommand.lIIlIllI[25]); + ConfigCommand.lIIlIIIl[13] = lllllllII(ConfigCommand.lIIlIllI[26], ConfigCommand.lIIlIllI[27]); + ConfigCommand.lIIlIIIl[14] = lllllllIl(ConfigCommand.lIIlIllI[28], ConfigCommand.lIIlIllI[29]); + ConfigCommand.lIIlIIIl[15] = lllllllIl(ConfigCommand.lIIlIllI[30], ConfigCommand.lIIlIllI[31]); + ConfigCommand.lIIlIIIl[16] = lllllllll(ConfigCommand.lIIlIllI[32], ConfigCommand.lIIlIllI[33]); + ConfigCommand.lIIlIIIl[17] = lllllllIl(ConfigCommand.lIIlIllI[34], ConfigCommand.lIIlIllI[35]); + ConfigCommand.lIIlIIIl[18] = lllllllII("Nh0aIw9FBgA0VgYdBjcfAlIfOAINUhw5E0UcCTwTRVU=", "erhQv"); + ConfigCommand.lIIlIIIl[19] = lllllllll("2KyZ3G1WqhDQLyTSrGCpI0r5u7t1wDte", "liBbi"); + ConfigCommand.lIIlIIIl[20] = lllllllIl("T1q17aVoDt8=", "MXTgB"); + ConfigCommand.lIIlIIIl[21] = lllllllII("MD8eWg8IJg5aCQZwCBUJDzkMCQ==", "iPkzg"); + ConfigCommand.lIIlIIIl[22] = lllllllll("ZDVFFtAdWfumrpBOvgkc4Dxh+yTcXGC1", "nBCbk"); + ConfigCommand.lIIlIIIl[23] = lllllllIl("Jlh8ol/VEZyF3jJcWif5lg==", "IZnoq"); + ConfigCommand.lIIlIIIl[24] = lllllllII("IAsmIDkEF3Jm", "cdHFP"); + ConfigCommand.lIIlIIIl[25] = lllllllII("Axg3Bw==", "PyAbg"); + ConfigCommand.lIIlIIIl[26] = lllllllll("lskS6j2vAd5EL9E5a8fLeTB0jtQ0o3Ick8RkhfbA4STOOLVenR53apXI5CUyQwxh", "Fqxyh"); + ConfigCommand.lIIlIIIl[27] = lllllllll("cqIi6va/Iqg=", "GjILs"); + ConfigCommand.lIIlIIIl[28] = lllllllll("848f3orYgLXOoTWYWk2EMvvNFTBGpIItJwyXGONETik7rmdMhOl8j2IQu/bqUaxH", "IisRa"); + ConfigCommand.lIIlIIIl[29] = lllllllII("VQ==", "rrihw"); + ConfigCommand.lIIlIIIl[30] = lllllllII("PhImKBFRQWgsGwUHLihUGAAxKlRXIighEgIGZwEVBgR5", "kaGOt"); + ConfigCommand.lIIlIIIl[31] = lllllllIl("1O6IUd+2oo6BtKCVlBNw24Kn8J8cGdFqhB4d4Rbxw+qrIT1Ix4sVqQ==", "bjPce"); + ConfigCommand.lIIlIIIl[32] = lllllllII("JTUOKQ==", "iZoMl"); + ConfigCommand.lIIlIIIl[33] = lllllllll("1FWzYUEm800=", "oNHdH"); + ConfigCommand.lIIlIIIl[34] = lllllllII("", "LVgzf"); + ConfigCommand.lIIlIIIl[35] = lllllllll("PyAVH6WOF8s=", "HZIkR"); + ConfigCommand.lIIlIIIl[36] = lllllllIl("SM7Qzv3r2YAX0+9YxIhYgz2zS/jW/yKU/TR6TdBjci/oOh0UDVgMASmsdzRJnDad", "qBBuY"); + ConfigCommand.lIIlIIIl[37] = lllllllll("kvUKCJb79Is=", "nwkcl"); + ConfigCommand.lIIlIIIl[38] = lllllllIl("ySQhINb2DcGMN0p+ftkmRIqSY26/2NRa6U9MQRoHNJkZ4Gm5rd1I9s5BWe5qfvX7", "IOnzM"); + ConfigCommand.lIIlIIIl[39] = lllllllll("9J+axgLHW84=", "mgxPC"); + ConfigCommand.lIIlIIIl[40] = lllllllII("IDkBVQ0bPwIcCVQmDQEGVCUMEE4aMAkQTlM=", "tQdun"); + ConfigCommand.lIIlIIIl[41] = lllllllIl("lcRVq/V+KUeSJ7QZGFFESmzvMpvZ3CIU", "NgtcV"); + ConfigCommand.lIIlIIIl[42] = lllllllII("Ag0gVzk5CyMePXYSLAMydhEtEno4BCgSenE=", "VeEwZ"); + ConfigCommand.lIIlIIIl[43] = lllllllll("tIcL1EcOdHbztqknGV2DwAeMAJIjuPDS", "GIpDn"); + ConfigCommand.lIIlIIIl[44] = lllllllll("dry1pGJG8YlG3J4s1MhyaXghGG0KKrAhC34+B7ZPoJC4Fy1nMKva+A==", "ergbh"); + ConfigCommand.lIIlIIIl[45] = lllllllll("NL8tgyz5r+/BPqYFQQ3iXu3coBxWei6czim+9pxYngUTzPq0BT++zg==", "fSHyD"); + ConfigCommand.lIIlIIIl[46] = lllllllll("6aFp2LulEeQ=", "LIlzm"); + ConfigCommand.lIIlIIIl[47] = lllllllIl("NUqUvH5fRFI=", "NeLgS"); + ConfigCommand.lIIlIIIl[48] = lllllllll("q+/hRddLGg3YU57qoyS289E1c8qgAi676IQ6L4YRn/A2dAx3YFlBJgVyrpQ6zUvM", "nZcJG"); + ConfigCommand.lIIlIIIl[49] = lllllllll("bUD6Z3kpbp8=", "NOOxX"); + ConfigCommand.lIIlIIIl[50] = lllllllIl("agIHm5SZusZBIimN6yimn5b6yI8+xlctH6a8Sod8HMsc1W/E5sd1OwiZyB/2nyPl", "KpGTF"); + ConfigCommand.lIIlIIIl[51] = lllllllIl("x5pVmut6hjU=", "NekFE"); + ConfigCommand.lIIlIIIl[52] = lllllllll("UlD6uGcPRWRpCPrkI931jk4e1+Bkal1Nr4FtieD7dQGV81u/uox4cg==", "KMJXE"); + ConfigCommand.lIIlIIIl[53] = lllllllII("bW03ID0mKDU=", "JMQAT"); + ConfigCommand.lIIlIIIl[54] = lllllllIl("YzEWs3T7sPgy7izyHyRPhpmm/zyvEcUOU1kJYE1WW7jht98b64sbdA==", "fHWIr"); + ConfigCommand.lIIlIIIl[55] = lllllllll("CThCnVqeZChR/D4BNxpdYg==", "NVgKy"); + ConfigCommand.lIIlIIIl[56] = lllllllIl("XpVadfTzVcnsWWRUGYDLSuqV3tfjQMAoJgQjDx/vTzY=", "PVxSn"); + ConfigCommand.lIIlIIIl[57] = lllllllII("QUUyCzEVRTgLIEYALg0nEg==", "feVdT"); + ConfigCommand.lIIlIIIl[58] = lllllllll("2q50+h9hUN1SSwdcs1J5egwUT+m3tmu4+AuZqzkSdsQ=", "FdAKg"); + ConfigCommand.lIIlIIIl[59] = lllllllll("3olkJTBcKZ8VZJfQSogvQAZOA3vhAgF1", "ZaJNP"); + ConfigCommand.lIIlIIIl[60] = lllllllII("Fh0kChR5TmoOHi0ILApRJwspCAUmTnkuHi0ILApRDQ8oCE8=", "CnEmq"); + ConfigCommand.lIIlIIIl[61] = lllllllII("NxsPCBZYSEEMHAwOBwhTBg0CCgcHSFIsHAwOBwhTLAkDCk0=", "bhnos"); + ConfigCommand.lIIlIIIl[62] = lllllllII("AhMeNAEmDw0yVmM=", "CayAl"); + ConfigCommand.lIIlIIIl[63] = lllllllll("qJKr7DKtzR0=", "ejFlx"); + ConfigCommand.lIIlIIIl[64] = lllllllIl("zogaveo+J/U=", "xvWhZ"); + ConfigCommand.lIIlIIIl[65] = lllllllII("ADY6HwMh", "DSVzw"); + ConfigCommand.lIIlIIIl[66] = lllllllII("AhorEw==", "NsXgN"); + ConfigCommand.lIIlIIIl[67] = lllllllIl("NLXHrIs6M/1NPjpDYDvPbg==", "dVCDG"); + ConfigCommand.lIIlIIIl[68] = lllllllII("PBsdNw==", "ozkRh"); + ConfigCommand.lIIlIIIl[69] = lllllllII("GhsgMg==", "VtAVP"); + ConfigCommand.lIIlIIIl[70] = lllllllII("AB0/NyEh", "DxSRU"); + ConfigCommand.lIIlIIIl[71] = lllllllIl("ix52CjG+qvM=", "GwCUP"); + ConfigCommand.lIIlIllI = null; + } + + private static void lIIIIlIIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ConfigCommand.lIIlIllI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllllllII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lllllllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllllllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/command/commands/FriendCommand.java b/command/commands/FriendCommand.java new file mode 100644 index 0000000..16be66c --- /dev/null +++ b/command/commands/FriendCommand.java @@ -0,0 +1,293 @@ +package me.explicit.command.commands; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.config.ConfigManager; +import me.explicit.utils.ChatUtils; +import me.explicit.utils.Game; +import net.minecraft.command.CommandException; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.util.BlockPos; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; + +public class FriendCommand implements ICommand { + + private static final String[] lIIIIllII; + private static String[] lIIIlIIll; + + public int compareTo(ICommand icommand) { + return 0; + } + + public String getCommandName() { + return FriendCommand.lIIIIllII[0]; + } + + public String getCommandUsage(ICommandSender icommandsender) { + return FriendCommand.lIIIIllII[1]; + } + + public List getCommandAliases() { + ArrayList arraylist = new ArrayList(); + + arraylist.add(FriendCommand.lIIIIllII[2]); + arraylist.add(FriendCommand.lIIIIllII[3]); + return arraylist; + } + + public void processCommand(ICommandSender icommandsender, String[] astring) throws CommandException {} + + public List executeCommand(String[] astring) { + ArrayList arraylist; + + (arraylist = new ArrayList()).clear(); + if (Explicit.destructed) { + Game.Player().addChatMessage(new ChatComponentText(String.valueOf((new StringBuilder()).append(EnumChatFormatting.RED).append(FriendCommand.lIIIIllII[4])))); + return arraylist; + } else if (astring.length == 0) { + if (Explicit.consolegui) { + arraylist.add(FriendCommand.lIIIIllII[5]); + arraylist.add(FriendCommand.lIIIIllII[6]); + arraylist.add(FriendCommand.lIIIIllII[7]); + arraylist.add(FriendCommand.lIIIIllII[8]); + arraylist.add(FriendCommand.lIIIIllII[9]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[10]))); + ChatUtils.sendMessage(FriendCommand.lIIIIllII[11]); + ChatUtils.sendMessage(FriendCommand.lIIIIllII[12]); + ChatUtils.sendMessage(FriendCommand.lIIIIllII[13]); + ChatUtils.sendMessage(FriendCommand.lIIIIllII[14]); + } + + return arraylist; + } else { + if (astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[15])) { + Explicit.instance.friendManager.getFriends().clear(); + ConfigManager.SaveFriendsFile(); + if (Explicit.consolegui) { + arraylist.add(FriendCommand.lIIIIllII[16]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[17]))); + } + } else if (astring.length > 0 && !astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[18]) && !astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[19]) && !astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[20]) && !astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[21])) { + if (Explicit.consolegui) { + arraylist.add(FriendCommand.lIIIIllII[22]); + arraylist.add(FriendCommand.lIIIIllII[23]); + arraylist.add(FriendCommand.lIIIIllII[24]); + arraylist.add(FriendCommand.lIIIIllII[25]); + arraylist.add(FriendCommand.lIIIIllII[26]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[27]))); + ChatUtils.sendMessage(FriendCommand.lIIIIllII[28]); + ChatUtils.sendMessage(FriendCommand.lIIIIllII[29]); + ChatUtils.sendMessage(FriendCommand.lIIIIllII[30]); + ChatUtils.sendMessage(FriendCommand.lIIIIllII[31]); + } + } else if (astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[32]) && astring.length > 1) { + Explicit.instance.friendManager.addFriend(astring[1]); + if (Explicit.consolegui) { + arraylist.add(String.valueOf((new StringBuilder()).append(FriendCommand.lIIIIllII[33]).append(astring[1]).append(FriendCommand.lIIIIllII[34]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[35]).append(astring[1]).append(FriendCommand.lIIIIllII[36]))); + } + } else if (astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[37])) { + if (Explicit.consolegui) { + arraylist.add(FriendCommand.lIIIIllII[38]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[39]))); + } + } else if (astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[40]) && astring.length > 1) { + if (Explicit.instance.friendManager.getFriends().contains(astring[1])) { + Explicit.instance.friendManager.getFriends().remove(astring[1]); + ConfigManager.SaveFriendsFile(); + if (Explicit.consolegui) { + arraylist.add(String.valueOf((new StringBuilder()).append(FriendCommand.lIIIIllII[41]).append(astring[1]).append(FriendCommand.lIIIIllII[42]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[43]).append(astring[1]).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[44]))); + } + } else if (Explicit.consolegui) { + arraylist.add(String.valueOf((new StringBuilder()).append(FriendCommand.lIIIIllII[45]).append(astring[1]).append(FriendCommand.lIIIIllII[46]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(FriendCommand.lIIIIllII[47]).append(astring[1]).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[48]))); + } + } else if (astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[49])) { + if (Explicit.instance.friendManager.getFriends().size() == 0) { + if (Explicit.consolegui) { + arraylist.add(FriendCommand.lIIIIllII[50]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[51]))); + } + } else { + if (Explicit.consolegui) { + arraylist.add(FriendCommand.lIIIIllII[52]); + } + + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[53]))); + } + + Iterator iterator = Explicit.instance.friendManager.getFriends().iterator(); + + while (iterator.hasNext()) { + String s = (String) iterator.next(); + + if (Explicit.consolegui) { + arraylist.add(s); + } else { + ChatUtils.sendMessage(s); + } + } + } else if (astring[0].equalsIgnoreCase(FriendCommand.lIIIIllII[54])) { + if (Explicit.consolegui) { + arraylist.add(FriendCommand.lIIIIllII[55]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(FriendCommand.lIIIIllII[56]))); + } + } + + return arraylist; + } + } + + public boolean canCommandSenderUseCommand(ICommandSender icommandsender) { + return true; + } + + public List addTabCompletionOptions(ICommandSender icommandsender, String[] astring, BlockPos blockpos) { + return null; + } + + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int compareTo(Object object) { + return this.compareTo((ICommand) object); + } + + static { + llllIIllIl(); + llllIIllII(); + } + + private static void llllIIllII() { + lIIIIllII = new String[57]; + FriendCommand.lIIIIllII[0] = lllIllIllI(FriendCommand.lIIIlIIll[0], FriendCommand.lIIIlIIll[1]); + FriendCommand.lIIIIllII[1] = lllIllIlll(FriendCommand.lIIIlIIll[2], FriendCommand.lIIIlIIll[3]); + FriendCommand.lIIIIllII[2] = lllIllIllI(FriendCommand.lIIIlIIll[4], FriendCommand.lIIIlIIll[5]); + FriendCommand.lIIIIllII[3] = lllIllIlll(FriendCommand.lIIIlIIll[6], FriendCommand.lIIIlIIll[7]); + FriendCommand.lIIIIllII[4] = lllIlllIII(FriendCommand.lIIIlIIll[8], FriendCommand.lIIIlIIll[9]); + FriendCommand.lIIIIllII[5] = lllIlllIII(FriendCommand.lIIIlIIll[10], FriendCommand.lIIIlIIll[11]); + FriendCommand.lIIIIllII[6] = lllIllIllI(FriendCommand.lIIIlIIll[12], FriendCommand.lIIIlIIll[13]); + FriendCommand.lIIIIllII[7] = lllIllIlll(FriendCommand.lIIIlIIll[14], FriendCommand.lIIIlIIll[15]); + FriendCommand.lIIIIllII[8] = lllIllIlll(FriendCommand.lIIIlIIll[16], FriendCommand.lIIIlIIll[17]); + FriendCommand.lIIIIllII[9] = lllIlllIII(FriendCommand.lIIIlIIll[18], FriendCommand.lIIIlIIll[19]); + FriendCommand.lIIIIllII[10] = lllIllIlll(FriendCommand.lIIIlIIll[20], FriendCommand.lIIIlIIll[21]); + FriendCommand.lIIIIllII[11] = lllIllIlll(FriendCommand.lIIIlIIll[22], FriendCommand.lIIIlIIll[23]); + FriendCommand.lIIIIllII[12] = lllIllIllI(FriendCommand.lIIIlIIll[24], FriendCommand.lIIIlIIll[25]); + FriendCommand.lIIIIllII[13] = lllIllIlll(FriendCommand.lIIIlIIll[26], FriendCommand.lIIIlIIll[27]); + FriendCommand.lIIIIllII[14] = lllIlllIII(FriendCommand.lIIIlIIll[28], FriendCommand.lIIIlIIll[29]); + FriendCommand.lIIIIllII[15] = lllIllIllI(FriendCommand.lIIIlIIll[30], FriendCommand.lIIIlIIll[31]); + FriendCommand.lIIIIllII[16] = lllIlllIII(FriendCommand.lIIIlIIll[32], FriendCommand.lIIIlIIll[33]); + FriendCommand.lIIIIllII[17] = lllIlllIII("tpmzinw1mIdBKy8+DhKUrXlDgOtJGqyh2RJV7NV1yimu2sau7Q7Okw==", "gAMlY"); + FriendCommand.lIIIIllII[18] = lllIllIlll("uCydWNPLK30=", "SWZLK"); + FriendCommand.lIIIIllII[19] = lllIlllIII("JPJeuxIbHK0=", "vStka"); + FriendCommand.lIIIIllII[20] = lllIlllIII("1rKFbJgshLM=", "pBAry"); + FriendCommand.lIIIIllII[21] = lllIlllIII("OqJ9fpYjs5Q=", "FNBoz"); + FriendCommand.lIIIIllII[22] = lllIlllIII("qVxqneI9XtmEyf8tunEKNQ==", "otyRo"); + FriendCommand.lIIIIllII[23] = lllIllIllI("ADIn", "AVCay"); + FriendCommand.lIIIIllII[24] = lllIllIllI("KyIpGyMc", "yGDtU"); + FriendCommand.lIIIIllII[25] = lllIllIlll("d/7AAy7Tl4c=", "NriPf"); + FriendCommand.lIIIIllII[26] = lllIllIllI("LgsmDA==", "bbUxY"); + FriendCommand.lIIIIllII[27] = lllIllIllI("JAYAEQgAGhMXX0U=", "etgde"); + FriendCommand.lIIIIllII[28] = lllIlllIII("cU6K5EzsohA=", "hmicp"); + FriendCommand.lIIIIllII[29] = lllIllIllI("NAQ3OAYD", "faZWp"); + FriendCommand.lIIIIllII[30] = lllIlllIII("qNeZ5XgPHik=", "IPUUA"); + FriendCommand.lIIIIllII[31] = lllIlllIII("uddOiQy9RUI=", "ZwhwR"); + FriendCommand.lIIIIllII[32] = lllIllIlll("DFhDRzkDWxg=", "nOpZm"); + FriendCommand.lIIIIllII[33] = lllIllIlll("ALLzc0XkxY0LhRCvjTnkp0vZ9wbqoYRO", "VDUHu"); + FriendCommand.lIIIIllII[34] = lllIllIlll("CtZWEGg+GYz77dnz08EP+v+bS0nri/IP", "JouKL"); + FriendCommand.lIIIIllII[35] = lllIllIllI("KgEEGwsKBwENAhUNRxkKHREDWEk=", "ytgxn"); + FriendCommand.lIIIIllII[36] = lllIllIllI("XVkVAUoDFhQcShwLCAsEHgpBAgMJDQ==", "zyanj"); + FriendCommand.lIIIIllII[37] = lllIllIllI("Iw8y", "BkVQo"); + FriendCommand.lIIIIllII[38] = lllIlllIII("5vdd78mtZaHkeaT8YlsXmOvVowaOta05", "ltTPy"); + FriendCommand.lIIIIllII[39] = lllIllIllI("WxEQKCgaExFhLBATQn0DFRoHfw==", "twbAM"); + FriendCommand.lIIIIllII[40] = lllIllIlll("++67LY9g/KQ=", "LxhQL"); + FriendCommand.lIIIIllII[41] = lllIllIlll("vZYWzmebtkgEtffmd+aaTs5q5uJWp/+P", "FIDyF"); + FriendCommand.lIIIIllII[42] = lllIllIlll("mihsyNaGPKVxG3ZhonvqXgAnm7bdvPSLcpafobwwvQQ=", "EauGB"); + FriendCommand.lIIIIllII[43] = lllIllIlll("gO4Wtc8Rj2fKH9ENuIZIKQ25T+cuDV6j", "FAWDc"); + FriendCommand.lIIIIllII[44] = lllIllIllI("ZFoJOx0uWhYmBzFaCTsbJhQLOlIvExw9", "CzoIr"); + FriendCommand.lIIIIllII[45] = lllIlllIII("hyOC56yDTfI=", "LzFKb"); + FriendCommand.lIIIIllII[46] = lllIllIlll("a+QKo+kycnJ4Lk7PLTJ3VZr3yjlB72fG35eqaIEh4p9EeXk0YrjZ0g==", "dSvTx"); + FriendCommand.lIIIIllII[47] = lllIllIllI("Vw==", "pRLca"); + FriendCommand.lIIIIllII[48] = lllIllIllI("fWQRDiV6KgkbdjwrEwEyeisITy81MRRPMCgtAwEyKWQKBiUu", "ZDfoV"); + FriendCommand.lIIIIllII[49] = lllIlllIII("FGyD1J6lNQw=", "bOUvZ"); + FriendCommand.lIIIIllII[50] = lllIlllIII("w1bPe3+nw3LwkppR7HqjI6sMGF6vCgNy", "hfVFK"); + FriendCommand.lIIIIllII[51] = lllIllIllI("GiEhWQwiODFZCixuMgsNJiAwCkR5Zg==", "CNTyd"); + FriendCommand.lIIIIllII[52] = lllIllIlll("0vqPDSwLPDEHCbvd9fm3jQ==", "lMXRc"); + FriendCommand.lIIIIllII[53] = lllIlllIII("JHr9fQgQztS/uq9oDQLeuw==", "HcvNv"); + FriendCommand.lIIIIllII[54] = lllIlllIII("ivuA3Xop6Uw=", "jnSTX"); + FriendCommand.lIIIIllII[55] = lllIllIlll("MIVYkvNuyOUpBkjRQ3h0n2Z8o7beUJvw", "ySNRQ"); + FriendCommand.lIIIIllII[56] = lllIllIllI("QVo0ICYLGTYhbxwSPz05C1duHC4DEmw=", "nwRRO"); + FriendCommand.lIIIlIIll = null; + } + + private static void llllIIllIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + FriendCommand.lIIIlIIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllIllIlll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllIllIllI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lllIlllIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/command/commands/HelpCommand.java b/command/commands/HelpCommand.java new file mode 100644 index 0000000..22fc73d --- /dev/null +++ b/command/commands/HelpCommand.java @@ -0,0 +1,167 @@ +package me.explicit.command.commands; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.utils.ChatUtils; +import me.explicit.utils.Game; +import net.minecraft.command.CommandException; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.util.BlockPos; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; + +public class HelpCommand implements ICommand { + + private static final String[] lIIlll; + private static String[] lIllII; + + public int compareTo(ICommand icommand) { + return 0; + } + + public String getCommandName() { + return HelpCommand.lIIlll[0]; + } + + public String getCommandUsage(ICommandSender icommandsender) { + return HelpCommand.lIIlll[1]; + } + + public List getCommandAliases() { + ArrayList arraylist = new ArrayList(); + + return arraylist; + } + + public void processCommand(ICommandSender icommandsender, String[] astring) throws CommandException { + this.executeCommand(astring); + } + + public List executeCommand(String[] astring) { + boolean flag = Explicit.consolegui; + ArrayList arraylist; + + (arraylist = new ArrayList()).clear(); + if (Explicit.destructed) { + Game.Player().addChatMessage(new ChatComponentText(String.valueOf((new StringBuilder()).append(EnumChatFormatting.RED).append(HelpCommand.lIIlll[2])))); + return arraylist; + } else { + if (flag) { + arraylist.add(HelpCommand.lIIlll[3]); + arraylist.add(HelpCommand.lIIlll[4]); + arraylist.add(HelpCommand.lIIlll[5]); + arraylist.add(HelpCommand.lIIlll[6]); + arraylist.add(HelpCommand.lIIlll[7]); + arraylist.add(HelpCommand.lIIlll[8]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(HelpCommand.lIIlll[9]))); + ChatUtils.sendMessage(HelpCommand.lIIlll[10]); + ChatUtils.sendMessage(HelpCommand.lIIlll[11]); + ChatUtils.sendMessage(HelpCommand.lIIlll[12]); + ChatUtils.sendMessage(HelpCommand.lIIlll[13]); + ChatUtils.sendMessage(HelpCommand.lIIlll[14]); + } + + return arraylist; + } + } + + public boolean canCommandSenderUseCommand(ICommandSender icommandsender) { + return true; + } + + public List addTabCompletionOptions(ICommandSender icommandsender, String[] astring, BlockPos blockpos) { + return null; + } + + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int compareTo(Object object) { + return this.compareTo((ICommand) object); + } + + static { + lIIllIII(); + lIIlIlll(); + } + + private static void lIIlIlll() { + lIIlll = new String[15]; + HelpCommand.lIIlll[0] = lIIIllII(HelpCommand.lIllII[0], HelpCommand.lIllII[1]); + HelpCommand.lIIlll[1] = lIIIllIl(HelpCommand.lIllII[2], HelpCommand.lIllII[3]); + HelpCommand.lIIlll[2] = lIIIllIl(HelpCommand.lIllII[4], HelpCommand.lIllII[5]); + HelpCommand.lIIlll[3] = lIIIlllI(HelpCommand.lIllII[6], HelpCommand.lIllII[7]); + HelpCommand.lIIlll[4] = lIIIllIl(HelpCommand.lIllII[8], HelpCommand.lIllII[9]); + HelpCommand.lIIlll[5] = lIIIlllI(HelpCommand.lIllII[10], HelpCommand.lIllII[11]); + HelpCommand.lIIlll[6] = lIIIllII(HelpCommand.lIllII[12], HelpCommand.lIllII[13]); + HelpCommand.lIIlll[7] = lIIIllIl(HelpCommand.lIllII[14], HelpCommand.lIllII[15]); + HelpCommand.lIIlll[8] = lIIIlllI(HelpCommand.lIllII[16], HelpCommand.lIllII[17]); + HelpCommand.lIIlll[9] = lIIIlllI("nKkDOzYB0/3CVOHGPp1zr8ocCbJcxyjH", "CYkvc"); + HelpCommand.lIIlll[10] = lIIIlllI("gEFUMS/2tR8nf5AaNgBGAzjcSAdrvx/c/NxCu52XAY8=", "rBXyU"); + HelpCommand.lIIlll[11] = lIIIllII("bkEbLCQlTENlGSQYWTEiJEwSIDMjBRchajUDWSRqLAMdMCYk", "AlyEJ"); + HelpCommand.lIIlll[12] = lIIIlllI("C60W4exsk2dylYLvySgwt0FngbySEGRdy0qQqhskUaMXE075ykrcrvvO905Z+JcaZVSSnJO75ixyabJKLqxMSwYzb0xcrjjy", "aLvHv"); + HelpCommand.lIIlll[13] = lIIIllII("TGg6Py8FLD5we0MIOD4gBCB5KS4WN3kzLg0jMDcy", "cEYPA"); + HelpCommand.lIIlll[14] = lIIIllIl("CTgn1oHM9X2dtjh1lojb5IDoaSoQGTChloS3jAPQVtFEqEMGDk4483whvokUo4AY", "TNSVd"); + HelpCommand.lIllII = null; + } + + private static void lIIllIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + HelpCommand.lIllII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIllII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIlllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/command/commands/SettingsCommand.java b/command/commands/SettingsCommand.java new file mode 100644 index 0000000..9522792 --- /dev/null +++ b/command/commands/SettingsCommand.java @@ -0,0 +1,303 @@ +package me.explicit.command.commands; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.ChatUtils; +import me.explicit.utils.Game; +import net.minecraft.command.CommandException; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.util.BlockPos; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; + +public class SettingsCommand implements ICommand { + + private static final String[] lllIlllI; + private static String[] lllllIll; + + public int compareTo(ICommand icommand) { + return 0; + } + + public String getCommandName() { + return SettingsCommand.lllIlllI[0]; + } + + public String getCommandUsage(ICommandSender icommandsender) { + return SettingsCommand.lllIlllI[1]; + } + + public List getCommandAliases() { + ArrayList arraylist = new ArrayList(); + + arraylist.add(SettingsCommand.lllIlllI[2]); + arraylist.add(SettingsCommand.lllIlllI[3]); + return arraylist; + } + + public void processCommand(ICommandSender icommandsender, String[] astring) throws CommandException { + this.executeCommand(astring); + } + + public List executeCommand(String[] astring) { + boolean flag = Explicit.consolegui; + ArrayList arraylist; + + (arraylist = new ArrayList()).clear(); + if (Explicit.destructed) { + Game.Player().addChatMessage(new ChatComponentText(String.valueOf((new StringBuilder()).append(EnumChatFormatting.RED).append(SettingsCommand.lllIlllI[4])))); + return arraylist; + } else { + if (astring.length < 3) { + if (flag) { + arraylist.add(SettingsCommand.lllIlllI[5]); + } else { + ChatUtils.sendMessage(SettingsCommand.lllIlllI[6]); + } + } else if (Explicit.instance.mm.getModuleByName(astring[0]) != null) { + Module module = Explicit.instance.mm.getModuleByName(astring[0]); + Setting setting = Explicit.instance.sm.getSettingByName(module, astring[1]); + + if (setting == null) { + if (flag) { + arraylist.add(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[7]).append(astring[1]).append(SettingsCommand.lllIlllI[8]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(SettingsCommand.lllIlllI[9]).append(astring[1]).append(SettingsCommand.lllIlllI[10]))); + } + } else { + String s = astring[2]; + + if (s != null) { + try { + if (setting.isCheck()) { + if (!s.equalsIgnoreCase(SettingsCommand.lllIlllI[11]) && !s.equalsIgnoreCase(SettingsCommand.lllIlllI[12])) { + if (flag) { + arraylist.add(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[15]).append(astring[1]).append(SettingsCommand.lllIlllI[16]).append(s).append(SettingsCommand.lllIlllI[17]))); + arraylist.add(SettingsCommand.lllIlllI[18]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[19]).append(astring[1]).append(SettingsCommand.lllIlllI[20]).append(s).append(SettingsCommand.lllIlllI[21]))); + ChatUtils.sendMessage(SettingsCommand.lllIlllI[22]); + } + } else { + setting.setValBoolean(Boolean.parseBoolean(s)); + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(SettingsCommand.lllIlllI[13]).append(setting.getName()).append(SettingsCommand.lllIlllI[14]).append(s))); + } + } else if (setting.isCombo()) { + boolean flag1 = false; + Iterator iterator = setting.getOptions().iterator(); + + while (iterator.hasNext()) { + String s1 = (String) iterator.next(); + + if (s1.equalsIgnoreCase(s)) { + setting.setValString(s); + flag1 = true; + } + } + + if (!flag1) { + if (flag) { + arraylist.add(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[23]).append(astring[1]).append(SettingsCommand.lllIlllI[24]).append(s).append(SettingsCommand.lllIlllI[25]))); + arraylist.add(SettingsCommand.lllIlllI[26]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[27]).append(astring[1]).append(SettingsCommand.lllIlllI[28]).append(s).append(SettingsCommand.lllIlllI[29]))); + String s2 = SettingsCommand.lllIlllI[30]; + Iterator iterator1 = setting.getOptions().iterator(); + + while (iterator1.hasNext()) { + String s3 = (String) iterator1.next(); + + if (s3 == setting.getOptions().get(setting.getOptions().size() - 2)) { + s2 = String.valueOf((new StringBuilder()).append(s2).append(s3).append(SettingsCommand.lllIlllI[31])); + } else if (s3 == setting.getOptions().get(setting.getOptions().size() - 1)) { + s2 = String.valueOf((new StringBuilder()).append(s2).append(s3)); + } else { + s2 = String.valueOf((new StringBuilder()).append(s2).append(s3).append(SettingsCommand.lllIlllI[32])); + } + } + + ChatUtils.sendMessage(s2); + } + } else { + setting.setValString(s); + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(SettingsCommand.lllIlllI[33]).append(setting.getName()).append(SettingsCommand.lllIlllI[34]).append(s))); + } + } else if (setting.isSlider()) { + if (Double.parseDouble(s) >= setting.getMin() && Double.parseDouble(s) <= setting.getMax()) { + setting.setValDouble(Double.parseDouble(s)); + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(SettingsCommand.lllIlllI[44]).append(setting.getName()).append(SettingsCommand.lllIlllI[45]).append(s))); + } else if (flag) { + arraylist.add(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[35]).append(astring[1]).append(SettingsCommand.lllIlllI[36]).append(s).append(SettingsCommand.lllIlllI[37]))); + arraylist.add(SettingsCommand.lllIlllI[38]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[39]).append(astring[1]).append(SettingsCommand.lllIlllI[40]).append(s).append(SettingsCommand.lllIlllI[41]))); + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[42]).append(setting.getMin()).append(SettingsCommand.lllIlllI[43]).append(setting.getMax()))); + } + } + } catch (NumberFormatException numberformatexception) { + if (flag) { + arraylist.add(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[46]).append(astring[1]).append(SettingsCommand.lllIlllI[47]).append(s).append(SettingsCommand.lllIlllI[48]))); + arraylist.add(SettingsCommand.lllIlllI[49]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[50]).append(astring[1]).append(SettingsCommand.lllIlllI[51]).append(s).append(SettingsCommand.lllIlllI[52]))); + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[53]).append(setting.getMin()).append(SettingsCommand.lllIlllI[54]).append(setting.getMax()))); + } + } + } + } + } else if (flag) { + arraylist.add(String.valueOf((new StringBuilder()).append(SettingsCommand.lllIlllI[55]).append(astring[0]).append(SettingsCommand.lllIlllI[56]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(SettingsCommand.lllIlllI[57]).append(astring[0]).append(SettingsCommand.lllIlllI[58]))); + } + + return arraylist; + } + } + + public boolean canCommandSenderUseCommand(ICommandSender icommandsender) { + return true; + } + + public List addTabCompletionOptions(ICommandSender icommandsender, String[] astring, BlockPos blockpos) { + return null; + } + + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int compareTo(Object object) { + return this.compareTo((ICommand) object); + } + + static { + llIllllllI(); + llIlllllII(); + } + + private static void llIlllllII() { + lllIlllI = new String[59]; + SettingsCommand.lllIlllI[0] = llIllIIlIl(SettingsCommand.lllllIll[0], SettingsCommand.lllllIll[1]); + SettingsCommand.lllIlllI[1] = llIllIIlll(SettingsCommand.lllllIll[2], SettingsCommand.lllllIll[3]); + SettingsCommand.lllIlllI[2] = llIllIIlIl(SettingsCommand.lllllIll[4], SettingsCommand.lllllIll[5]); + SettingsCommand.lllIlllI[3] = llIllIIlll(SettingsCommand.lllllIll[6], SettingsCommand.lllllIll[7]); + SettingsCommand.lllIlllI[4] = llIllIlIII(SettingsCommand.lllllIll[8], SettingsCommand.lllllIll[9]); + SettingsCommand.lllIlllI[5] = llIllIlIII(SettingsCommand.lllllIll[10], SettingsCommand.lllllIll[11]); + SettingsCommand.lllIlllI[6] = llIllIlIII(SettingsCommand.lllllIll[12], SettingsCommand.lllllIll[13]); + SettingsCommand.lllIlllI[7] = llIllIlIII(SettingsCommand.lllllIll[14], SettingsCommand.lllllIll[15]); + SettingsCommand.lllIlllI[8] = llIllIlIII(SettingsCommand.lllllIll[16], SettingsCommand.lllllIll[17]); + SettingsCommand.lllIlllI[9] = llIllIIlll(SettingsCommand.lllllIll[18], SettingsCommand.lllllIll[19]); + SettingsCommand.lllIlllI[10] = llIllIIlll(SettingsCommand.lllllIll[20], SettingsCommand.lllllIll[21]); + SettingsCommand.lllIlllI[11] = llIllIIlIl(SettingsCommand.lllllIll[22], SettingsCommand.lllllIll[23]); + SettingsCommand.lllIlllI[12] = llIllIlIII(SettingsCommand.lllllIll[24], SettingsCommand.lllllIll[25]); + SettingsCommand.lllIlllI[13] = llIllIlIII(SettingsCommand.lllllIll[26], SettingsCommand.lllllIll[27]); + SettingsCommand.lllIlllI[14] = llIllIlIII("QiY7Tg==", "bRTnx"); + SettingsCommand.lllIlllI[15] = llIllIlIII("ECo1OgtvZQ==", "CEGHr"); + SettingsCommand.lllIlllI[16] = llIllIlIII("UBJzHzgbFDZJOhYPPQYtVwM2SX4=", "waSiY"); + SettingsCommand.lllIlllI[17] = llIllIIlll("w1HHdppc3CQ=", "vaKBV"); + SettingsCommand.lllIlllI[18] = llIllIIlll("BBTVPZNlta/ZGXWMF2kuqaXSp6PDeaVGu+UBkKBMdi8=", "IVPru"); + SettingsCommand.lllIlllI[19] = llIllIIlIl("SdeTjuqOUB8=", "SBjsX"); + SettingsCommand.lllIlllI[20] = llIllIlIII("didWIzE9IRN1MzA6GDokcTYTdXc=", "QTvUP"); + SettingsCommand.lllIlllI[21] = llIllIIlll("6lfLXIRzLb4=", "KdGwN"); + SettingsCommand.lllIlllI[22] = llIllIIlll("ERo9/Ewjey3AkVTgk09SAFQgiwSRq13xown134bqHZU=", "YfhgD"); + SettingsCommand.lllIlllI[23] = llIllIIlll("vxbhbreplMw=", "NLhHK"); + SettingsCommand.lllIlllI[24] = llIllIIlIl("uqbKv0jkSkqu9lxIoRbVauZkfbEQVfWn", "IUEYo"); + SettingsCommand.lllIlllI[25] = llIllIIlll("sBEk592zorU=", "yUWRY"); + SettingsCommand.lllIlllI[26] = llIllIIlll("FzYZyQ7H9huokXHxnIcV2fVe9U8/UhOKCHdxYasTZYw=", "NEDaW"); + SettingsCommand.lllIlllI[27] = llIllIIlIl("KjNCDBfZtPM=", "klNwH"); + SettingsCommand.lllIlllI[28] = llIllIIlll("zo9y7o1cOGc7gNLOsiIHyA1PLKBoP2Yc", "oVEaQ"); + SettingsCommand.lllIlllI[29] = llIllIlIII("bg==", "Iqtfa"); + SettingsCommand.lllIlllI[30] = llIllIlIII("MwB1DRUUVDoAGANUNwtU", "ztUnt"); + SettingsCommand.lllIlllI[31] = llIllIIlll("3dHtoMhR3IQ=", "lzHNr"); + SettingsCommand.lllIlllI[32] = llIllIIlIl("koICllPqhB8=", "CrqhC"); + SettingsCommand.lllIlllI[33] = llIllIlIII("AT4gKxAhOCU9GT4yYzsQJms=", "RKCHu"); + SettingsCommand.lllIlllI[34] = llIllIIlIl("57ijTaAnfyg=", "XUxKe"); + SettingsCommand.lllIlllI[35] = llIllIIlll("fLv3T7a3eTY=", "jCANs"); + SettingsCommand.lllIlllI[36] = llIllIlIII("fRViJS02EydzLzsILDw4egQnc2s=", "ZfBSL"); + SettingsCommand.lllIlllI[37] = llIllIlIII("VA==", "sBjgH"); + SettingsCommand.lllIlllI[38] = llIllIlIII("BjpLKhshbgQnFjZuCSxaOzweLFogPEsvGyM9Dg==", "ONkIz"); + SettingsCommand.lllIlllI[39] = llIllIIlll("RCWMcSmRFmM=", "XVPpI"); + SettingsCommand.lllIlllI[40] = llIllIIlll("4IwYAmUsRHq8pYCQlWerad1CN9+OGZPN", "XybuT"); + SettingsCommand.lllIlllI[41] = llIllIIlIl("abaisLt8K6Q=", "EFAhw"); + SettingsCommand.lllIlllI[42] = llIllIIlIl("IidsRqhYIapKhb7VD/nd/0oSxpoRGJOOAK4fzDnManT/tD9LizFv2g==", "WHUfg"); + SettingsCommand.lllIlllI[43] = llIllIlIII("Rg48Fmc=", "foRrG"); + SettingsCommand.lllIlllI[44] = llIllIIlll("PzY2r6639iPVfiVxOvkQdSFy9l9ytLEq", "drTOK"); + SettingsCommand.lllIlllI[45] = llIllIIlll("0HmXnCoypx0=", "ndQRj"); + SettingsCommand.lllIlllI[46] = llIllIIlll("Ed7DLTnsAuI=", "gWWPl"); + SettingsCommand.lllIlllI[47] = llIllIlIII("fiNuPxc1JStpFTg+ICYCeTIraVE=", "YPNIv"); + SettingsCommand.lllIlllI[48] = llIllIIlIl("SNFgJbrXIV4=", "LqezW"); + SettingsCommand.lllIlllI[49] = llIllIlIII("ATlDNi0mbQw7IDFtATBsPD8WMGwnP0MzLSQ+Bg==", "HMcUL"); + SettingsCommand.lllIlllI[50] = llIllIlIII("NQ49ERJKQQ==", "faOck"); + SettingsCommand.lllIlllI[51] = llIllIIlll("OWvzsYaVMOSj7+b5158v98RA81eKX/8u", "KDYAX"); + SettingsCommand.lllIlllI[52] = llIllIlIII("Qw==", "dKtlB"); + SettingsCommand.lllIlllI[53] = llIllIIlIl("1BVrKDaQkX5PJCAoRoGbzbBn3yUY+gnpT8X3iqrtru0FVswFoAfITA==", "BaPEl"); + SettingsCommand.lllIlllI[54] = llIllIlIII("YwUDAFg=", "Cdmdx"); + SettingsCommand.lllIlllI[55] = llIllIlIII("Ogg9FBtFRzsOB0kKIAIXBQJvQQ==", "igOfb"); + SettingsCommand.lllIlllI[56] = llIllIlIII("U0YLGBIHCEgDVxEeBgQD", "tfoww"); + SettingsCommand.lllIlllI[57] = llIllIIlIl("HAy9LyBDRAUnHQbKQYjqjEQgZ9/7yYzI", "CnwJL"); + SettingsCommand.lllIlllI[58] = llIllIIlll("iD/7qNBwzyhZtA/fsUppDw==", "ntgoU"); + SettingsCommand.lllllIll = null; + } + + private static void llIllllllI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + SettingsCommand.lllllIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIllIIlll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIllIIlIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIllIlIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/command/commands/ToggleCommand.java b/command/commands/ToggleCommand.java new file mode 100644 index 0000000..fa1e6e1 --- /dev/null +++ b/command/commands/ToggleCommand.java @@ -0,0 +1,168 @@ +package me.explicit.command.commands; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.utils.ChatUtils; +import me.explicit.utils.Game; +import net.minecraft.command.CommandException; +import net.minecraft.command.ICommand; +import net.minecraft.command.ICommandSender; +import net.minecraft.util.BlockPos; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; + +public class ToggleCommand implements ICommand { + + private static final String[] lIIIIlIll; + private static String[] lIIIIllll; + + public int compareTo(ICommand icommand) { + return 0; + } + + public String getCommandName() { + return ToggleCommand.lIIIIlIll[0]; + } + + public String getCommandUsage(ICommandSender icommandsender) { + return ToggleCommand.lIIIIlIll[1]; + } + + public List getCommandAliases() { + ArrayList arraylist = new ArrayList(); + + arraylist.add(ToggleCommand.lIIIIlIll[2]); + return arraylist; + } + + public void processCommand(ICommandSender icommandsender, String[] astring) throws CommandException { + this.executeCommand(astring); + } + + public List executeCommand(String[] astring) { + boolean flag = Explicit.consolegui; + ArrayList arraylist; + + (arraylist = new ArrayList()).clear(); + if (Explicit.destructed) { + Game.Player().addChatMessage(new ChatComponentText(String.valueOf((new StringBuilder()).append(EnumChatFormatting.RED).append(ToggleCommand.lIIIIlIll[3])))); + return arraylist; + } else { + if (astring.length == 0) { + if (flag) { + arraylist.add(ToggleCommand.lIIIIlIll[4]); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ToggleCommand.lIIIIlIll[5]))); + } + } else if (Explicit.instance.mm.getModuleByName(astring[0]) != null) { + Explicit.instance.mm.getModuleByName(astring[0]).toggle(); + if (flag) { + arraylist.add(String.valueOf((new StringBuilder()).append(ToggleCommand.lIIIIlIll[6]).append(astring[0]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ToggleCommand.lIIIIlIll[7]).append(astring[0]))); + } + } else if (flag) { + arraylist.add(String.valueOf((new StringBuilder()).append(ToggleCommand.lIIIIlIll[8]).append(astring[0]).append(ToggleCommand.lIIIIlIll[9]))); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(ToggleCommand.lIIIIlIll[10]).append(astring[0]).append(ToggleCommand.lIIIIlIll[11]))); + } + + return arraylist; + } + } + + public boolean canCommandSenderUseCommand(ICommandSender icommandsender) { + return true; + } + + public List addTabCompletionOptions(ICommandSender icommandsender, String[] astring, BlockPos blockpos) { + return null; + } + + public boolean isUsernameIndex(String[] astring, int i) { + return false; + } + + public int compareTo(Object object) { + return this.compareTo((ICommand) object); + } + + static { + llllIIIIIl(); + llllIIIIII(); + } + + private static void llllIIIIII() { + lIIIIlIll = new String[12]; + ToggleCommand.lIIIIlIll[0] = lllIllIlIl(ToggleCommand.lIIIIllll[0], ToggleCommand.lIIIIllll[1]); + ToggleCommand.lIIIIlIll[1] = lllIllIlIl(ToggleCommand.lIIIIllll[2], ToggleCommand.lIIIIllll[3]); + ToggleCommand.lIIIIlIll[2] = lllIlllIll(ToggleCommand.lIIIIllll[4], ToggleCommand.lIIIIllll[5]); + ToggleCommand.lIIIIlIll[3] = lllIlllIll(ToggleCommand.lIIIIllll[6], ToggleCommand.lIIIIllll[7]); + ToggleCommand.lIIIIlIll[4] = lllIllIlIl(ToggleCommand.lIIIIllll[8], ToggleCommand.lIIIIllll[9]); + ToggleCommand.lIIIIlIll[5] = lllIllIlIl(ToggleCommand.lIIIIllll[10], ToggleCommand.lIIIIllll[11]); + ToggleCommand.lIIIIlIll[6] = lllIlllIll(ToggleCommand.lIIIIllll[12], ToggleCommand.lIIIIllll[13]); + ToggleCommand.lIIIIlIll[7] = lllIlllIll(ToggleCommand.lIIIIllll[14], ToggleCommand.lIIIIllll[15]); + ToggleCommand.lIIIIlIll[8] = lllIlllllI(ToggleCommand.lIIIIllll[16], ToggleCommand.lIIIIllll[17]); + ToggleCommand.lIIIIlIll[9] = lllIllIlIl(ToggleCommand.lIIIIllll[18], ToggleCommand.lIIIIllll[19]); + ToggleCommand.lIIIIlIll[10] = lllIlllIll(ToggleCommand.lIIIIllll[20], ToggleCommand.lIIIIllll[21]); + ToggleCommand.lIIIIlIll[11] = lllIlllIll(ToggleCommand.lIIIIllll[22], ToggleCommand.lIIIIllll[23]); + ToggleCommand.lIIIIllll = null; + } + + private static void llllIIIIIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ToggleCommand.lIIIIllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllIlllIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllIlllllI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lllIllIlIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/config/ConfigGUI.java b/config/ConfigGUI.java new file mode 100644 index 0000000..a0ba1bf --- /dev/null +++ b/config/ConfigGUI.java @@ -0,0 +1,296 @@ +package me.explicit.config; + +import java.awt.Color; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.command.commands.ConfigCommand; +import net.minecraft.client.gui.FontRenderer; +import net.minecraft.client.gui.Gui; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.gui.ScaledResolution; +import net.minecraft.client.renderer.OpenGlHelper; +import net.minecraft.client.renderer.Tessellator; +import org.lwjgl.input.Keyboard; +import org.lwjgl.input.Mouse; +import org.lwjgl.opengl.GL11; + +public class ConfigGUI extends GuiScreen { + + private final GuiScreen previousScreen; + private int selected; + private int offset; + private static final String[] lIIlIllII; + private static String[] lIIlIlllI; + + public ConfigGUI(GuiScreen guiscreen) { + this.previousScreen = guiscreen; + } + + public void actionPerformed(GuiButton guibutton) throws IOException { + if (this.mc.currentScreen instanceof ConfigGUI) { + ConfigCommand configcommand; + + switch (guibutton.id) { + case 0: + this.mc.displayGuiScreen((GuiScreen) null); + break; + + case 1: + configcommand = new ConfigCommand(); + if (this.selected != -1) { + configcommand.executeCommand(new String[] { ConfigGUI.lIIlIllII[0], ((String) ConfigManager.GetConfigs().get(this.selected)).replace(ConfigGUI.lIIlIllII[1], ConfigGUI.lIIlIllII[2])}, true); + } + break; + + case 2: + configcommand = new ConfigCommand(); + if (this.selected != -1) { + configcommand.executeCommand(new String[] { ConfigGUI.lIIlIllII[3], ((String) ConfigManager.GetConfigs().get(this.selected)).replace(ConfigGUI.lIIlIllII[4], ConfigGUI.lIIlIllII[5])}, true); + } + + this.selected = -1; + break; + + case 3: + configcommand = new ConfigCommand(); + if (this.selected == -1) { + configcommand.executeCommand(new String[] { ConfigGUI.lIIlIllII[6], String.valueOf((new StringBuilder()).append(ConfigGUI.lIIlIllII[7]).append(ConfigManager.GetConfigs().size() + 1))}, true); + } else { + configcommand.executeCommand(new String[] { ConfigGUI.lIIlIllII[8], ((String) ConfigManager.GetConfigs().get(this.selected)).replace(ConfigGUI.lIIlIllII[9], ConfigGUI.lIIlIllII[10])}, true); + } + } + + } + } + + public void drawScreen(int i, int j, float f) { + if (this.mc.currentScreen instanceof ConfigGUI) { + this.drawDefaultBackground(); + if (Mouse.hasWheel()) { + int k = Mouse.getDWheel(); + + if (k < 0) { + this.offset += 26; + if (this.offset < 0) { + this.offset = 0; + } + } else if (k > 0) { + this.offset -= 26; + if (this.offset < 0) { + this.offset = 0; + } + } + } + + this.drawDefaultBackground(); + FontRenderer fontrenderer = this.mc.fontRendererObj; + + fontrenderer.drawString(ConfigGUI.lIIlIllII[11], this.width / 2 - fontrenderer.getStringWidth(ConfigGUI.lIIlIllII[12]) / 2, 10, -1); + GL11.glPushMatrix(); + this.prepareScissorBox(0.0F, 33.0F, (float) this.width, (float) (this.height - 50)); + GL11.glEnable(3089); + int l = 38; + List list = ConfigManager.GetConfigs(); + + if (list.isEmpty()) { + this.selected = -1; + } + + for (int i1 = 0; i1 < list.size(); ++i1) { + if (this.isAltInArea(l) && !((String) list.get(i1)).equalsIgnoreCase(ConfigGUI.lIIlIllII[13])) { + if (i1 == this.selected) { + if (this.isMouseOverAlt(i, j, l - this.offset) && Mouse.isButtonDown(0)) { + Gui.drawRect(52, l - this.offset - 4, this.width - 52, l - this.offset + 20, (new Color(50, 50, 50)).getRGB()); + } else if (this.isMouseOverAlt(i, j, l - this.offset)) { + Gui.drawRect(52, l - this.offset - 4, this.width - 52, l - this.offset + 20, (new Color(150, 150, 150)).getRGB()); + } else { + Gui.drawRect(52, l - this.offset - 4, this.width - 52, l - this.offset + 20, (new Color(50, 50, 50)).getRGB()); + } + } else if (this.isMouseOverAlt(i, j, l - this.offset) && Mouse.isButtonDown(0)) { + Gui.drawRect(52, l - this.offset - 4, this.width - 52, l - this.offset + 20, (new Color(150, 150, 150)).getRGB()); + } else if (this.isMouseOverAlt(i, j, l - this.offset)) { + Gui.drawRect(52, l - this.offset - 4, this.width - 52, l - this.offset + 20, (new Color(150, 150, 150)).getRGB()); + } + + this.mc.fontRendererObj.drawString((String) list.get(i1), 54, l + 3, -1); + l += 26; + } + } + + GL11.glDisable(3089); + GL11.glPopMatrix(); + super.drawScreen(i, j, f); + if (Keyboard.isKeyDown(200)) { + this.offset -= 26; + if (this.offset < 0) { + this.offset = 0; + } + } else if (Keyboard.isKeyDown(208)) { + this.offset += 26; + if (this.offset < 0) { + this.offset = 0; + } + } + + } + } + + public void initGui() { + this.buttonList.add(new GuiButton(0, this.width / 2 + 4, this.height - 24, 75, 20, ConfigGUI.lIIlIllII[14])); + this.buttonList.add(new GuiButton(1, this.width / 2 - 70, this.height - 48, 70, 20, ConfigGUI.lIIlIllII[15])); + this.buttonList.add(new GuiButton(2, this.width / 2 - 70, this.height - 24, 70, 20, ConfigGUI.lIIlIllII[16])); + this.buttonList.add(new GuiButton(3, this.width / 2 + 4, this.height - 48, 75, 20, ConfigGUI.lIIlIllII[17])); + } + + private boolean isAltInArea(int i) { + return i - this.offset <= this.height - 50; + } + + private boolean isMouseOverAlt(int i, int j, int k) { + return i >= 52 && j >= k - 4 && i <= this.width - 52 && j <= k + 20 && i >= 0 && j >= 33 && i <= this.width && j <= this.height - 50; + } + + protected void mouseClicked(int i, int j, int k) throws IOException { + if (this.mc.currentScreen instanceof ConfigGUI) { + if (this.offset < 0) { + this.offset = 0; + } + + int l = 38 - this.offset; + List list = ConfigManager.GetConfigs(); + boolean flag = false; + + for (int i1 = 0; i1 < list.size(); ++i1) { + if (this.isMouseOverAlt(i, j, l)) { + if (i1 == this.selected) { + this.actionPerformed((GuiButton) this.buttonList.get(1)); + return; + } + + this.selected = i1; + flag = true; + } + + l += 26; + } + + try { + super.mouseClicked(i, j, k); + } catch (IOException ioexception) { + ioexception.printStackTrace(); + } + + if (!flag) { + this.selected = -1; + } + + } + } + + public void prepareScissorBox(float f, float f1, float f2, float f3) { + int i = (new ScaledResolution(this.mc)).getScaleFactor(); + + GL11.glScissor((int) (f * (float) i), (int) (((float) (new ScaledResolution(this.mc)).getScaledHeight() - f3) * (float) i), (int) ((f2 - f) * (float) i), (int) ((f3 - f1) * (float) i)); + } + + public void renderBackground(int i, int j) { + GL11.glDisable(2929); + GL11.glDepthMask(false); + OpenGlHelper.glBlendFunc(770, 771, 1, 0); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + GL11.glDisable(3008); + this.drawDefaultBackground(); + Tessellator tessellator = Tessellator.getInstance(); + + tessellator.draw(); + GL11.glDepthMask(true); + GL11.glEnable(2929); + GL11.glEnable(3008); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + } + + static { + lIIIIlIIlIl(); + lIIIIlIIlII(); + } + + private static void lIIIIlIIlII() { + lIIlIllII = new String[18]; + ConfigGUI.lIIlIllII[0] = lIIIIIlllll(ConfigGUI.lIIlIlllI[0], ConfigGUI.lIIlIlllI[1]); + ConfigGUI.lIIlIllII[1] = lIIIIlIIIII(ConfigGUI.lIIlIlllI[2], ConfigGUI.lIIlIlllI[3]); + ConfigGUI.lIIlIllII[2] = lIIIIIlllll(ConfigGUI.lIIlIlllI[4], ConfigGUI.lIIlIlllI[5]); + ConfigGUI.lIIlIllII[3] = lIIIIIlllll(ConfigGUI.lIIlIlllI[6], ConfigGUI.lIIlIlllI[7]); + ConfigGUI.lIIlIllII[4] = lIIIIlIIIII(ConfigGUI.lIIlIlllI[8], ConfigGUI.lIIlIlllI[9]); + ConfigGUI.lIIlIllII[5] = lIIIIlIIIIl(ConfigGUI.lIIlIlllI[10], ConfigGUI.lIIlIlllI[11]); + ConfigGUI.lIIlIllII[6] = lIIIIlIIIIl(ConfigGUI.lIIlIlllI[12], ConfigGUI.lIIlIlllI[13]); + ConfigGUI.lIIlIllII[7] = lIIIIIlllll(ConfigGUI.lIIlIlllI[14], ConfigGUI.lIIlIlllI[15]); + ConfigGUI.lIIlIllII[8] = lIIIIIlllll(ConfigGUI.lIIlIlllI[16], ConfigGUI.lIIlIlllI[17]); + ConfigGUI.lIIlIllII[9] = lIIIIIlllll(ConfigGUI.lIIlIlllI[18], ConfigGUI.lIIlIlllI[19]); + ConfigGUI.lIIlIllII[10] = lIIIIIlllll(ConfigGUI.lIIlIlllI[20], ConfigGUI.lIIlIlllI[21]); + ConfigGUI.lIIlIllII[11] = lIIIIIlllll(ConfigGUI.lIIlIlllI[22], ConfigGUI.lIIlIlllI[23]); + ConfigGUI.lIIlIllII[12] = lIIIIlIIIII(ConfigGUI.lIIlIlllI[24], ConfigGUI.lIIlIlllI[25]); + ConfigGUI.lIIlIllII[13] = lIIIIlIIIII(ConfigGUI.lIIlIlllI[26], ConfigGUI.lIIlIlllI[27]); + ConfigGUI.lIIlIllII[14] = lIIIIIlllll(ConfigGUI.lIIlIlllI[28], ConfigGUI.lIIlIlllI[29]); + ConfigGUI.lIIlIllII[15] = lIIIIlIIIIl(ConfigGUI.lIIlIlllI[30], ConfigGUI.lIIlIlllI[31]); + ConfigGUI.lIIlIllII[16] = lIIIIlIIIII(ConfigGUI.lIIlIlllI[32], ConfigGUI.lIIlIlllI[33]); + ConfigGUI.lIIlIllII[17] = lIIIIIlllll(ConfigGUI.lIIlIlllI[34], ConfigGUI.lIIlIlllI[35]); + ConfigGUI.lIIlIlllI = null; + } + + private static void lIIIIlIIlIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ConfigGUI.lIIlIlllI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIlIIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIIlIIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIIIlllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/config/ConfigManager.java b/config/ConfigManager.java new file mode 100644 index 0000000..2b3ce46 --- /dev/null +++ b/config/ConfigManager.java @@ -0,0 +1,384 @@ +package me.explicit.config; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.io.PrintWriter; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.ui.clickgui.ClickGUI; +import me.explicit.ui.clickgui.Panel; +import net.minecraft.client.Minecraft; + +public class ConfigManager { + + public static File dir; + private static final File DEFAULT; + private static final File FRIENDS; + public static final File KILLSULTS; + public static final File CLICKGUI; + private static final String[] llIIIlll; + private static String[] llIIlIII; + + public static File getConfigFile(String s, boolean flag) { + File file; + + if (!flag) { + file = new File(ConfigManager.dir, String.format(ConfigManager.llIIIlll[0], new Object[] { s})); + } else { + file = new File(ConfigManager.dir, String.format(ConfigManager.llIIIlll[1], new Object[] { s})); + } + + if (!file.exists()) { + try { + file.createNewFile(); + } catch (IOException ioexception) { + ; + } + } + + return file; + } + + public static void init() { + if (!ConfigManager.dir.exists()) { + ConfigManager.dir.mkdir(); + } + + LoadConfig(ConfigManager.llIIIlll[2]); + LoadFriends(); + loadGUISettings(); + } + + public static void SaveConfigFile(String s) { + try { + if (Explicit.instance.sm == null || Explicit.instance.sm.getSettings() == null) { + return; + } + + PrintWriter printwriter = new PrintWriter(getConfigFile(s, true)); + + for (Iterator iterator = Explicit.instance.sm.getSettings().iterator(); iterator.hasNext(); printwriter.println()) { + Setting setting = (Setting) iterator.next(); + + if (setting.isCheck()) { + printwriter.write(String.valueOf((new StringBuilder()).append(ConfigManager.llIIIlll[3]).append(setting.getParentMod().getName()).append(ConfigManager.llIIIlll[4]).append(setting.getName()).append(ConfigManager.llIIIlll[5]).append(setting.getValBoolean()))); + } else if (setting.isCombo()) { + printwriter.write(String.valueOf((new StringBuilder()).append(ConfigManager.llIIIlll[6]).append(setting.getParentMod().getName()).append(ConfigManager.llIIIlll[7]).append(setting.getName()).append(ConfigManager.llIIIlll[8]).append(setting.getValString()))); + } else if (setting.isSlider()) { + printwriter.write(String.valueOf((new StringBuilder()).append(ConfigManager.llIIIlll[9]).append(setting.getParentMod().getName()).append(ConfigManager.llIIIlll[10]).append(setting.getName()).append(ConfigManager.llIIIlll[11]).append(setting.getValDouble()))); + } else { + printwriter.write(String.valueOf((new StringBuilder()).append(ConfigManager.llIIIlll[12]).append(setting.getParentMod().getName()).append(ConfigManager.llIIIlll[13]).append(setting.getName()))); + } + } + + for (int i = 0; i < Explicit.instance.mm.getModules().size(); ++i) { + Module module = (Module) Explicit.instance.mm.getModules().get(i); + + printwriter.write(String.valueOf((new StringBuilder()).append(ConfigManager.llIIIlll[14]).append(module.getName()).append(ConfigManager.llIIIlll[15]).append(module.isToggled()).append(ConfigManager.llIIIlll[16]).append(module.getKey()))); + if (Explicit.instance.mm.getModules().size() != i) { + printwriter.println(); + } + } + + printwriter.close(); + } catch (FileNotFoundException filenotfoundexception) { + filenotfoundexception.printStackTrace(); + } + + } + + public static void SaveFriendsFile() { + try { + PrintWriter printwriter = new PrintWriter(ConfigManager.FRIENDS); + + for (int i = 0; i < Explicit.instance.friendManager.getFriends().size(); ++i) { + printwriter.println((String) Explicit.instance.friendManager.getFriends().get(i)); + } + + printwriter.close(); + } catch (FileNotFoundException filenotfoundexception) { + filenotfoundexception.printStackTrace(); + } + + } + + public static void LoadFriends() { + try { + BufferedReader bufferedreader = new BufferedReader(new FileReader(ConfigManager.FRIENDS)); + String s; + + if (ConfigManager.FRIENDS.exists()) { + while ((s = bufferedreader.readLine()) != null) { + Explicit.instance.friendManager.addFriendNoSave(s); + } + } + + bufferedreader.close(); + } catch (Exception exception) { + ; + } + + } + + public static List GetConfigs() { + ArrayList arraylist = new ArrayList(); + File file = ConfigManager.dir; + + if (file.isDirectory()) { + File[] afile = file.listFiles(); + File[] afile1 = afile; + int i = afile.length; + + for (int j = 0; j < i; ++j) { + File file1 = afile1[j]; + + if (file1.getName().contains(ConfigManager.llIIIlll[17]) && !file1.getName().equalsIgnoreCase(ConfigManager.llIIIlll[18])) { + String s = file1.getName(); + + arraylist.add(s); + } + } + } + + return arraylist; + } + + public static void saveGUISettings() { + try { + PrintWriter printwriter = new PrintWriter(ConfigManager.CLICKGUI); + Iterator iterator = ClickGUI.panels.iterator(); + + while (iterator.hasNext()) { + Panel panel = (Panel) iterator.next(); + + printwriter.println(String.valueOf((new StringBuilder()).append(panel.title).append(ConfigManager.llIIIlll[19]).append(panel.x).append(ConfigManager.llIIIlll[20]).append(panel.y).append(ConfigManager.llIIIlll[21]).append(panel.extended))); + } + + printwriter.close(); + } catch (FileNotFoundException filenotfoundexception) { + filenotfoundexception.printStackTrace(); + } + + } + + public static void loadGUISettings() { + ArrayList arraylist = new ArrayList(); + + String s; + + try { + BufferedReader bufferedreader = new BufferedReader(new FileReader(ConfigManager.CLICKGUI)); + + while ((s = bufferedreader.readLine()) != null) { + arraylist.add(s); + } + + bufferedreader.close(); + } catch (IOException ioexception) { + ioexception.printStackTrace(); + } + + if (!arraylist.isEmpty()) { + Iterator iterator = arraylist.iterator(); + + while (iterator.hasNext()) { + s = (String) iterator.next(); + String[] astring = s.split(ConfigManager.llIIIlll[22]); + + if (astring.length > 3) { + Iterator iterator1 = ClickGUI.panels.iterator(); + + while (iterator1.hasNext()) { + Panel panel = (Panel) iterator1.next(); + + if (panel.title.equalsIgnoreCase(astring[0])) { + panel.x = Double.parseDouble(astring[1]); + panel.y = Double.parseDouble(astring[2]); + panel.extended = Boolean.parseBoolean(astring[3]); + } + } + } + } + } + + } + + public static void LoadConfig(String s) { + try { + BufferedReader bufferedreader = new BufferedReader(new FileReader(getConfigFile(s, true))); + String s1; + + if (getConfigFile(s, true).exists()) { + while ((s1 = bufferedreader.readLine()) != null) { + String[] astring = s1.split(ConfigManager.llIIIlll[23]); + Module module = Explicit.instance.mm.getModuleByName(astring[1]); + + if (module != null) { + if (astring[0].equalsIgnoreCase(ConfigManager.llIIIlll[24])) { + Setting setting = Explicit.instance.sm.getSettingByName(module, astring[2]); + + if (setting != null) { + if (setting.isCheck()) { + setting.setValBooleanNoSave(Boolean.parseBoolean(astring[3])); + } else if (setting.isCombo()) { + setting.setValStringNoSave(astring[3]); + } else if (setting.isSlider()) { + setting.setValDoubleNoSave(Double.parseDouble(astring[3])); + } + } + } else if (astring[0].equalsIgnoreCase(ConfigManager.llIIIlll[25])) { + if (Boolean.parseBoolean(astring[2])) { + module.setToggledNoSave(true); + } + + int i = Integer.parseInt(astring[3]); + + if (i != 0) { + module.setKey(i); + } + } + } + } + } + + bufferedreader.close(); + } catch (Exception exception) { + ; + } + + } + + static { + lIlllIlIIl(); + lIlllIlIII(); + File file = Minecraft.getMinecraft().mcDataDir; + + ConfigManager.dir = new File(file, ConfigManager.llIIIlll[26]); + if (!ConfigManager.dir.exists()) { + ConfigManager.dir.mkdirs(); + } + + DEFAULT = getConfigFile(ConfigManager.llIIIlll[27], true); + FRIENDS = getConfigFile(ConfigManager.llIIIlll[28], false); + CLICKGUI = getConfigFile(ConfigManager.llIIIlll[29], false); + File file1 = new File(ConfigManager.dir, ConfigManager.llIIIlll[30]); + + if (!file1.exists()) { + try { + file1.createNewFile(); + PrintWriter printwriter = new PrintWriter(file1); + + printwriter.println(ConfigManager.llIIIlll[31]); + printwriter.println(ConfigManager.llIIIlll[32]); + printwriter.println(ConfigManager.llIIIlll[33]); + printwriter.close(); + } catch (IOException ioexception) { + ; + } + } + + KILLSULTS = file1; + } + + private static void lIlllIlIII() { + llIIIlll = new String[34]; + ConfigManager.llIIIlll[0] = lIlllIIlIl(ConfigManager.llIIlIII[0], ConfigManager.llIIlIII[1]); + ConfigManager.llIIIlll[1] = lIlllIIlIl(ConfigManager.llIIlIII[2], ConfigManager.llIIlIII[3]); + ConfigManager.llIIIlll[2] = lIlllIIlIl(ConfigManager.llIIlIII[4], ConfigManager.llIIlIII[5]); + ConfigManager.llIIIlll[3] = lIlllIIllI(ConfigManager.llIIlIII[6], ConfigManager.llIIlIII[7]); + ConfigManager.llIIIlll[4] = lIlllIIlIl(ConfigManager.llIIlIII[8], ConfigManager.llIIlIII[9]); + ConfigManager.llIIIlll[5] = lIlllIIlIl(ConfigManager.llIIlIII[10], ConfigManager.llIIlIII[11]); + ConfigManager.llIIIlll[6] = lIlllIIllI(ConfigManager.llIIlIII[12], ConfigManager.llIIlIII[13]); + ConfigManager.llIIIlll[7] = lIlllIIllI(ConfigManager.llIIlIII[14], ConfigManager.llIIlIII[15]); + ConfigManager.llIIIlll[8] = lIlllIIlIl(ConfigManager.llIIlIII[16], ConfigManager.llIIlIII[17]); + ConfigManager.llIIIlll[9] = lIlllIIlll(ConfigManager.llIIlIII[18], ConfigManager.llIIlIII[19]); + ConfigManager.llIIIlll[10] = lIlllIIlll(ConfigManager.llIIlIII[20], ConfigManager.llIIlIII[21]); + ConfigManager.llIIIlll[11] = lIlllIIlIl(ConfigManager.llIIlIII[22], ConfigManager.llIIlIII[23]); + ConfigManager.llIIIlll[12] = lIlllIIlIl(ConfigManager.llIIlIII[24], ConfigManager.llIIlIII[25]); + ConfigManager.llIIIlll[13] = lIlllIIllI(ConfigManager.llIIlIII[26], ConfigManager.llIIlIII[27]); + ConfigManager.llIIIlll[14] = lIlllIIllI(ConfigManager.llIIlIII[28], ConfigManager.llIIlIII[29]); + ConfigManager.llIIIlll[15] = lIlllIIlIl(ConfigManager.llIIlIII[30], ConfigManager.llIIlIII[31]); + ConfigManager.llIIIlll[16] = lIlllIIlIl(ConfigManager.llIIlIII[32], ConfigManager.llIIlIII[33]); + ConfigManager.llIIIlll[17] = lIlllIIlIl(ConfigManager.llIIlIII[34], ConfigManager.llIIlIII[35]); + ConfigManager.llIIIlll[18] = lIlllIIllI(ConfigManager.llIIlIII[36], ConfigManager.llIIlIII[37]); + ConfigManager.llIIIlll[19] = lIlllIIllI(ConfigManager.llIIlIII[38], ConfigManager.llIIlIII[39]); + ConfigManager.llIIIlll[20] = lIlllIIlll(ConfigManager.llIIlIII[40], ConfigManager.llIIlIII[41]); + ConfigManager.llIIIlll[21] = lIlllIIlll(ConfigManager.llIIlIII[42], ConfigManager.llIIlIII[43]); + ConfigManager.llIIIlll[22] = lIlllIIlIl(ConfigManager.llIIlIII[44], ConfigManager.llIIlIII[45]); + ConfigManager.llIIIlll[23] = lIlllIIlll(ConfigManager.llIIlIII[46], ConfigManager.llIIlIII[47]); + ConfigManager.llIIIlll[24] = lIlllIIlIl(ConfigManager.llIIlIII[48], ConfigManager.llIIlIII[49]); + ConfigManager.llIIIlll[25] = lIlllIIlIl(ConfigManager.llIIlIII[50], ConfigManager.llIIlIII[51]); + ConfigManager.llIIIlll[26] = lIlllIIlll(ConfigManager.llIIlIII[52], ConfigManager.llIIlIII[53]); + ConfigManager.llIIIlll[27] = lIlllIIlIl("vRQT+g5Hwd0=", "pMhKw"); + ConfigManager.llIIIlll[28] = lIlllIIlIl("+p0f4h+WRDc=", "beqrU"); + ConfigManager.llIIIlll[29] = lIlllIIllI("sc1t+nn6iLHd6vNb3DkFuQ==", "QSdTq"); + ConfigManager.llIIIlll[30] = lIlllIIlIl("qsQv058qXWS3yWTy7tlbXg==", "NvlHD"); + ConfigManager.llIIIlll[31] = lIlllIIllI("GtLRtWuImW+UmnnSZZTX/gZhOYi8bc9lJzJBB3tHDnJJjZFAsjraO7nYLzyRNgBgZwokjYl6O+ZrPK1vd1iC9g==", "EATkz"); + ConfigManager.llIIIlll[32] = lIlllIIlll("DBY4STYKAzwMJksGPkkgChdsTCwKHilM", "ksLiB"); + ConfigManager.llIIIlll[33] = lIlllIIlll("dho0AgB2VDwCBDQdOwpFPRshTxAgHTsIRRYMJQMMMB0h", "StUoe"); + ConfigManager.llIIlIII = null; + } + + private static void lIlllIlIIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ConfigManager.llIIlIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlllIIlll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIlllIIllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlllIIlIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/config/ConfigModule.java b/config/ConfigModule.java new file mode 100644 index 0000000..64a3fd9 --- /dev/null +++ b/config/ConfigModule.java @@ -0,0 +1,74 @@ +package me.explicit.config; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ConfigModule extends Module { + + private static final String[] lIIlIIIlI; + private static String[] lIIlIIlII; + + public ConfigModule() { + super(ConfigModule.lIIlIIIlI[0], ConfigModule.lIIlIIIlI[1], Category.CONFIGS); + } + + public void onEnable() { + super.onEnable(); + ConfigModule.mc.displayGuiScreen(new ConfigGUI(ConfigModule.mc.currentScreen)); + this.setToggled(false); + } + + static { + llllllIlII(); + llllllIIll(); + } + + private static void llllllIIll() { + lIIlIIIlI = new String[2]; + ConfigModule.lIIlIIIlI[0] = llllllIIIl(ConfigModule.lIIlIIlII[0], ConfigModule.lIIlIIlII[1]); + ConfigModule.lIIlIIIlI[1] = llllllIIlI(ConfigModule.lIIlIIlII[2], ConfigModule.lIIlIIlII[3]); + ConfigModule.lIIlIIlII = null; + } + + private static void llllllIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ConfigModule.lIIlIIlII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llllllIIIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llllllIIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/consolegui/ConsoleGUI.java b/consolegui/ConsoleGUI.java new file mode 100644 index 0000000..45af2d7 --- /dev/null +++ b/consolegui/ConsoleGUI.java @@ -0,0 +1,440 @@ +package me.explicit.consolegui; + +import io.netty.util.internal.ThreadLocalRandom; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.PrintWriter; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import java.util.List; +import java.util.Scanner; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.command.CommandUtils; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.Minecraft; + +public class ConsoleGUI extends Thread { + + private String fileName; + private String fileLocation; + private TimerUtils fileChecker = new TimerUtils(); + private TimerUtils processChecker = new TimerUtils(); + private boolean hasOpened = false; + private static final String[] llIIIIl; + private static String[] llIIIlI; + + public void run() { + Explicit.consolegui = true; + if (!System.getProperty(ConsoleGUI.llIIIIl[0]).toLowerCase().contains(ConsoleGUI.llIIIIl[1])) { + Explicit.consolegui = false; + System.out.println(ConsoleGUI.llIIIIl[2]); + } else { + File file = Minecraft.getMinecraft().mcDataDir; + File file1 = new File(file, ConsoleGUI.llIIIIl[3]); + + if (!file1.exists()) { + System.out.println(ConsoleGUI.llIIIIl[4]); + Explicit.consolegui = false; + } else { + File[] afile = file1.listFiles(); + + for (int i = 0; i < afile.length; ++i) { + if (afile[i].isFile() && afile[i].getName().endsWith(ConsoleGUI.llIIIIl[5])) { + this.fileName = afile[i].getName(); + this.fileLocation = afile[i].getAbsolutePath(); + } + } + + if (this.fileName != null && this.fileLocation != null) { + try { + File file2 = new File(file1, ConsoleGUI.llIIIIl[7]); + File file3; + + if (file2.exists()) { + String[] astring = file2.list(); + + for (int j = 0; j < astring.length; ++j) { + String s = astring[j]; + + file3 = new File(file2.getPath(), s); + file3.delete(); + } + + file2.delete(); + } + + File file4 = new File(file1, ConsoleGUI.llIIIIl[8]); + + if (file4.exists()) { + String[] astring1 = file4.list(); + + for (int k = 0; k < astring1.length; ++k) { + String s1 = astring1[k]; + File file5 = new File(file4.getPath(), s1); + + file5.delete(); + } + + file4.delete(); + } + + File file6 = new File(file1, ConsoleGUI.llIIIIl[9]); + + if (!file6.exists()) { + file6.createNewFile(); + } + + File file7 = new File(file1, ConsoleGUI.llIIIIl[10]); + + if (!file7.exists()) { + file7.createNewFile(); + } + + file3 = new File(file1, ConsoleGUI.llIIIIl[11]); + if (!file3.exists()) { + file3.createNewFile(); + } + + PrintWriter printwriter = new PrintWriter(file6); + Iterator iterator = Explicit.instance.mm.getModules().iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + printwriter.println(module.getName().toLowerCase()); + } + + printwriter.close(); + PrintWriter printwriter1 = new PrintWriter(file7); + + for (Iterator iterator1 = Explicit.instance.sm.getSettings().iterator(); iterator1.hasNext(); printwriter1.println()) { + Setting setting = (Setting) iterator1.next(); + + printwriter1.print(String.valueOf((new StringBuilder()).append(setting.getParentMod().getName().toLowerCase()).append(ConsoleGUI.llIIIIl[12]).append(setting.getName().toLowerCase()).append(ConsoleGUI.llIIIIl[13]))); + if (setting.isCheck()) { + printwriter1.print(ConsoleGUI.llIIIIl[14]); + } else if (setting.isCombo()) { + printwriter1.print(ConsoleGUI.llIIIIl[15]); + Iterator iterator2 = setting.getOptions().iterator(); + + while (iterator2.hasNext()) { + String s2 = (String) iterator2.next(); + + printwriter1.print(s2); + if (s2 != setting.getOptions().get(setting.getOptions().size() - 1)) { + printwriter1.print(ConsoleGUI.llIIIIl[16]); + } + } + } else if (setting.isSlider()) { + printwriter1.print(String.valueOf((new StringBuilder()).append(setting.getMin()).append(ConsoleGUI.llIIIIl[17]).append(setting.getMax()))); + } + } + + printwriter1.close(); + PrintWriter printwriter2 = new PrintWriter(file3); + + printwriter2.print(this.fileName); + printwriter2.close(); + Runtime.getRuntime().exec(String.valueOf((new StringBuilder()).append(ConsoleGUI.llIIIIl[18]).append(file3.getAbsolutePath()))); + } catch (IOException ioexception) { + ioexception.printStackTrace(); + System.out.println(ConsoleGUI.llIIIIl[19]); + Explicit.consolegui = false; + } + + if (Explicit.consolegui) { + this.fileChecker.reset(); + this.processChecker.reset(); + this.runChecks(); + } else { + if (Explicit.instance.mm.getModuleByName(ConsoleGUI.llIIIIl[20]).getKey() == 0) { + Explicit.instance.mm.getModuleByName(ConsoleGUI.llIIIIl[21]).setKey(54); + } + + System.out.println(ConsoleGUI.llIIIIl[22]); + } + + } else { + System.out.println(ConsoleGUI.llIIIIl[6]); + Explicit.consolegui = false; + } + } + } + } + + private void runChecks() { + int i = 0; + ArrayList arraylist; + + (arraylist = new ArrayList()).clear(); + + while (Explicit.consolegui) { + if (this.fileChecker.hasReached(2000.0D)) { + File file = Minecraft.getMinecraft().mcDataDir; + File file1 = new File(file, ConsoleGUI.llIIIIl[23]); + File file2 = new File(file1, ConsoleGUI.llIIIIl[24]); + + if (file2.isDirectory()) { + File[] afile = file2.listFiles(); + + if (afile.length > 0) { + File[] afile1 = afile; + int j = afile.length; + + for (int k = 0; k < j; ++k) { + File file3 = afile1[k]; + + if (!arraylist.contains(file3.getName())) { + try { + BufferedReader bufferedreader = new BufferedReader(new FileReader(file3)); + + String s; + + while ((s = bufferedreader.readLine()) != null) { + if (s == ConsoleGUI.llIIIIl[25] && !this.isProcessOpen()) { + Explicit.instance.cg = null; + } else { + this.sendMessage(CommandUtils.sendCommand(s)); + } + } + + arraylist.add(file3.getName()); + } catch (FileNotFoundException filenotfoundexception) { + filenotfoundexception.printStackTrace(); + } catch (IOException ioexception) { + ioexception.printStackTrace(); + } + } + + file3.delete(); + } + } + } + + this.fileChecker.reset(); + } + + if (this.processChecker.hasReached(8000.0D)) { + if (!this.hasOpened && i < 4 && this.isProcessOpen()) { + this.hasOpened = true; + ++i; + } + + if (!this.isProcessOpen() && i >= 4 && !this.hasOpened) { + System.out.println(ConsoleGUI.llIIIIl[26]); + Explicit.consolegui = false; + } + + if (this.hasOpened && !this.isProcessOpen()) { + ++i; + if (i > 1) { + if (Explicit.instance.mm.getModuleByName(ConsoleGUI.llIIIIl[27]).getKey() == 0) { + Explicit.instance.mm.getModuleByName(ConsoleGUI.llIIIIl[28]).setKey(54); + } + + System.out.println(ConsoleGUI.llIIIIl[29]); + Explicit.consolegui = false; + } + } else if (this.hasOpened) { + i = 0; + } + + this.processChecker.reset(); + } + + if (!Explicit.consolegui) { + Explicit.instance.cg = null; + if (!Explicit.destructed && Explicit.instance.mm.getModuleByName(ConsoleGUI.llIIIIl[30]).getKey() == 0) { + Explicit.instance.mm.getModuleByName(ConsoleGUI.llIIIIl[31]).setKey(54); + } + } + } + + } + + private void sendMessage(List list) { + File file = Minecraft.getMinecraft().mcDataDir; + File file1 = new File(file, ConsoleGUI.llIIIIl[32]); + File file2 = new File(file1, ConsoleGUI.llIIIIl[33]); + + if (!file2.isDirectory()) { + file2.mkdir(); + } + + File file3 = new File(file2, String.valueOf((new StringBuilder()).append(ConsoleGUI.llIIIIl[34]).append(this.randomString(5)).append(ConsoleGUI.llIIIIl[35]))); + + try { + if (file3.createNewFile()) { + PrintWriter printwriter = new PrintWriter(file3); + Iterator iterator = list.iterator(); + + while (iterator.hasNext()) { + String s = (String) iterator.next(); + + printwriter.println(s); + } + + printwriter.close(); + } + } catch (IOException ioexception) { + ioexception.printStackTrace(); + } + + } + + private boolean isProcessOpen() { + ProcessBuilder processbuilder = new ProcessBuilder(new String[] { ConsoleGUI.llIIIIl[36]}); + Process process = null; + + try { + process = processbuilder.start(); + } catch (IOException ioexception) { + ioexception.printStackTrace(); + return false; + } + + String s; + + try { + s = this.toString(process.getInputStream()); + } catch (IOException ioexception1) { + ioexception1.printStackTrace(); + return false; + } + + return s.contains(this.fileName); + } + + private String toString(InputStream inputstream) throws IOException { + Scanner scanner = (new Scanner(inputstream, ConsoleGUI.llIIIIl[37])).useDelimiter(ConsoleGUI.llIIIIl[38]); + String s = scanner.hasNext() ? scanner.next() : ConsoleGUI.llIIIIl[39]; + + scanner.close(); + return s; + } + + public String randomString(int i) { + String s = ConsoleGUI.llIIIIl[40]; + String s1 = ConsoleGUI.llIIIIl[41]; + + for (int j = 0; j < i; ++j) { + s1 = String.valueOf((new StringBuilder()).append(s1).append(s.charAt(ThreadLocalRandom.current().nextInt(s.toCharArray().length)))); + } + + return s1; + } + + static { + lIlIlIlII(); + lIlIlIIll(); + } + + private static void lIlIlIIll() { + llIIIIl = new String[42]; + ConsoleGUI.llIIIIl[0] = lIlIIllll(ConsoleGUI.llIIIlI[0], ConsoleGUI.llIIIlI[1]); + ConsoleGUI.llIIIIl[1] = lIlIlIIIl(ConsoleGUI.llIIIlI[2], ConsoleGUI.llIIIlI[3]); + ConsoleGUI.llIIIIl[2] = lIlIlIIIl(ConsoleGUI.llIIIlI[4], ConsoleGUI.llIIIlI[5]); + ConsoleGUI.llIIIIl[3] = lIlIlIIlI(ConsoleGUI.llIIIlI[6], ConsoleGUI.llIIIlI[7]); + ConsoleGUI.llIIIIl[4] = lIlIIllll(ConsoleGUI.llIIIlI[8], ConsoleGUI.llIIIlI[9]); + ConsoleGUI.llIIIIl[5] = lIlIlIIIl(ConsoleGUI.llIIIlI[10], ConsoleGUI.llIIIlI[11]); + ConsoleGUI.llIIIIl[6] = lIlIlIIIl(ConsoleGUI.llIIIlI[12], ConsoleGUI.llIIIlI[13]); + ConsoleGUI.llIIIIl[7] = lIlIlIIlI(ConsoleGUI.llIIIlI[14], ConsoleGUI.llIIIlI[15]); + ConsoleGUI.llIIIIl[8] = lIlIlIIIl(ConsoleGUI.llIIIlI[16], ConsoleGUI.llIIIlI[17]); + ConsoleGUI.llIIIIl[9] = lIlIlIIIl(ConsoleGUI.llIIIlI[18], ConsoleGUI.llIIIlI[19]); + ConsoleGUI.llIIIIl[10] = lIlIlIIIl(ConsoleGUI.llIIIlI[20], ConsoleGUI.llIIIlI[21]); + ConsoleGUI.llIIIIl[11] = lIlIlIIlI(ConsoleGUI.llIIIlI[22], ConsoleGUI.llIIIlI[23]); + ConsoleGUI.llIIIIl[12] = lIlIIllll(ConsoleGUI.llIIIlI[24], ConsoleGUI.llIIIlI[25]); + ConsoleGUI.llIIIIl[13] = lIlIIllll(ConsoleGUI.llIIIlI[26], ConsoleGUI.llIIIlI[27]); + ConsoleGUI.llIIIIl[14] = lIlIIllll(ConsoleGUI.llIIIlI[28], ConsoleGUI.llIIIlI[29]); + ConsoleGUI.llIIIIl[15] = lIlIlIIlI(ConsoleGUI.llIIIlI[30], ConsoleGUI.llIIIlI[31]); + ConsoleGUI.llIIIIl[16] = lIlIIllll(ConsoleGUI.llIIIlI[32], ConsoleGUI.llIIIlI[33]); + ConsoleGUI.llIIIIl[17] = lIlIlIIlI(ConsoleGUI.llIIIlI[34], ConsoleGUI.llIIIlI[35]); + ConsoleGUI.llIIIIl[18] = lIlIlIIIl(ConsoleGUI.llIIIlI[36], ConsoleGUI.llIIIlI[37]); + ConsoleGUI.llIIIIl[19] = lIlIIllll(ConsoleGUI.llIIIlI[38], ConsoleGUI.llIIIlI[39]); + ConsoleGUI.llIIIIl[20] = lIlIlIIIl("GFQG8iKxfZbaBGnj4RIc+A==", "npJHd"); + ConsoleGUI.llIIIIl[21] = lIlIlIIlI("GzURLTofDDE=", "XYxNQ"); + ConsoleGUI.llIIIIl[22] = lIlIlIIIl("1KgeELJLp8NHhZ9rdITcDg==", "ghUii"); + ConsoleGUI.llIIIIl[23] = lIlIlIIlI("ACM+", "gVWKP"); + ConsoleGUI.llIIIIl[24] = lIlIlIIlI("NzEWAQ==", "dTxee"); + ConsoleGUI.llIIIIl[25] = lIlIlIIIl("NpSuZjK/+Sb1Uio1iY4ZMQ==", "YPjWk"); + ConsoleGUI.llIIIIl[26] = lIlIlIIIl("H/RICsD4q9/90nQNStOTagC48H4HqenBpaxSlvuzXnE=", "zlHKO"); + ConsoleGUI.llIIIIl[27] = lIlIIllll("jLc/UIMAr9SMtD46FNYmJw==", "JNTNL"); + ConsoleGUI.llIIIIl[28] = lIlIlIIlI("Jw8aJBojNjo=", "dcsGq"); + ConsoleGUI.llIIIIl[29] = lIlIlIIIl("88rtIC6jsgEw2f8a1TyV8I7irmwjAc1P", "KMvJs"); + ConsoleGUI.llIIIIl[30] = lIlIIllll("P+B6yXzt00R5mgOG8XCXZw==", "sUlSZ"); + ConsoleGUI.llIIIIl[31] = lIlIlIIIl("zIuKm8Mn2iukQNp4RLx52w==", "chQzH"); + ConsoleGUI.llIIIIl[32] = lIlIIllll("BcDEwx/HcNY=", "OXckK"); + ConsoleGUI.llIIIIl[33] = lIlIIllll("8xrB+iwGcus=", "WDzjS"); + ConsoleGUI.llIIIIl[34] = lIlIIllll("LF17abkYAVw=", "VlsKO"); + ConsoleGUI.llIIIIl[35] = lIlIlIIlI("WDYQFg==", "vBhbD"); + ConsoleGUI.llIIIIl[36] = lIlIlIIIl("ge6lXW/QkdiEvyzQuVNSVg==", "jGNnp"); + ConsoleGUI.llIIIIl[37] = lIlIIllll("WORqAJ5WL/A=", "CmQFW"); + ConsoleGUI.llIIIIl[38] = lIlIIllll("2UvxRhcQyz4=", "DOuce"); + ConsoleGUI.llIIIIl[39] = lIlIlIIIl("wAmavX9lwyI=", "SiAhU"); + ConsoleGUI.llIIIIl[40] = lIlIIllll("w3g3QDWt75EqMUT9RXeR4D1sXyKJda+A1EAYwWYwDine9ZaEAHu5nQ==", "lwMsP"); + ConsoleGUI.llIIIIl[41] = lIlIlIIIl("MBqKrBXtZwc=", "ENRvt"); + ConsoleGUI.llIIIlI = null; + } + + private static void lIlIlIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ConsoleGUI.llIIIlI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlIlIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIlIIlI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIlIIllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/friends/FriendManager.java b/friends/FriendManager.java new file mode 100644 index 0000000..d01398f --- /dev/null +++ b/friends/FriendManager.java @@ -0,0 +1,31 @@ +package me.explicit.friends; + +import java.util.ArrayList; +import java.util.List; +import me.explicit.config.ConfigManager; + +public class FriendManager { + + private List friends; + + public void addFriend(String s) { + if (this.friends == null) { + (this.friends = new ArrayList()).clear(); + } + + this.friends.add(s); + ConfigManager.SaveFriendsFile(); + } + + public void addFriendNoSave(String s) { + this.friends.add(s); + } + + public List getFriends() { + if (this.friends == null) { + (this.friends = new ArrayList()).clear(); + } + + return this.friends; + } +} diff --git a/module/Category.java b/module/Category.java new file mode 100644 index 0000000..696137e --- /dev/null +++ b/module/Category.java @@ -0,0 +1,94 @@ +package me.explicit.module; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; + +public enum Category { + + COMBAT, BLATANT, MOVEMENT, RENDER, PLAYER, MISC, VALUES, CONFIGS; + + private static final Category[] $VALUES; + private static final String[] lIIIIllI; + private static String[] lIIIIlll; + + static { + lllIlIIlI(); + lllIlIIIl(); + COMBAT = new Category(Category.lIIIIllI[0], 0); + BLATANT = new Category(Category.lIIIIllI[1], 1); + MOVEMENT = new Category(Category.lIIIIllI[2], 2); + RENDER = new Category(Category.lIIIIllI[3], 3); + PLAYER = new Category(Category.lIIIIllI[4], 4); + MISC = new Category(Category.lIIIIllI[5], 5); + VALUES = new Category(Category.lIIIIllI[6], 6); + CONFIGS = new Category(Category.lIIIIllI[7], 7); + $VALUES = new Category[] { Category.COMBAT, Category.BLATANT, Category.MOVEMENT, Category.RENDER, Category.PLAYER, Category.MISC, Category.VALUES, Category.CONFIGS}; + } + + private static void lllIlIIIl() { + lIIIIllI = new String[8]; + Category.lIIIIllI[0] = lllIIlllI(Category.lIIIIlll[0], Category.lIIIIlll[1]); + Category.lIIIIllI[1] = lllIIllll(Category.lIIIIlll[2], Category.lIIIIlll[3]); + Category.lIIIIllI[2] = lllIIlllI(Category.lIIIIlll[4], Category.lIIIIlll[5]); + Category.lIIIIllI[3] = lllIlIIII(Category.lIIIIlll[6], Category.lIIIIlll[7]); + Category.lIIIIllI[4] = lllIIllll(Category.lIIIIlll[8], Category.lIIIIlll[9]); + Category.lIIIIllI[5] = lllIIlllI(Category.lIIIIlll[10], Category.lIIIIlll[11]); + Category.lIIIIllI[6] = lllIIllll(Category.lIIIIlll[12], Category.lIIIIlll[13]); + Category.lIIIIllI[7] = lllIIlllI(Category.lIIIIlll[14], Category.lIIIIlll[15]); + Category.lIIIIlll = null; + } + + private static void lllIlIIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Category.lIIIIlll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllIIlllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllIlIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lllIIllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/Module.java b/module/Module.java new file mode 100644 index 0000000..0964151 --- /dev/null +++ b/module/Module.java @@ -0,0 +1,208 @@ +package me.explicit.module; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.config.ConfigManager; +import me.explicit.utils.Game; +import net.minecraft.client.Minecraft; +import net.minecraftforge.common.MinecraftForge; + +public class Module { + + protected static Minecraft mc; + private String name; + private String displayName; + private String description; + private int key; + private Category category; + private boolean toggled; + private static final String[] lIIllIIlI; + private static String[] lIIllIlll; + + public Module(String s, int i, Category category, String s1) { + this.name = s; + this.key = i; + this.category = category; + this.toggled = false; + this.description = s1; + this.setup(); + } + + public Module(String s, String s1, Category category) { + this.name = s; + this.key = 0; + this.category = category; + this.toggled = false; + this.description = s1; + this.setup(); + } + + public void onUpdate() {} + + public void onUpdateNoToggle() {} + + public void onTick() {} + + public void onMove() {} + + public void onEnable() { + MinecraftForge.EVENT_BUS.register(this); + } + + public void onDisable() { + MinecraftForge.EVENT_BUS.unregister(this); + } + + public void onToggle() {} + + public void setToggled(boolean flag) { + this.toggled = flag; + this.onToggle(); + ConfigManager.SaveConfigFile(Module.lIIllIIlI[0]); + MinecraftForge.EVENT_BUS.register(this); + if (this.toggled) { + this.onEnable(); + } else { + MinecraftForge.EVENT_BUS.unregister(this); + this.onDisable(); + } + + } + + public void setToggledNoSave(boolean flag) { + this.toggled = flag; + this.onToggle(); + MinecraftForge.EVENT_BUS.register(this); + if (this.toggled) { + this.onEnable(); + } else { + MinecraftForge.EVENT_BUS.unregister(this); + this.onDisable(); + } + + } + + public void toggle() { + this.toggled = !this.toggled; + this.onToggle(); + ConfigManager.SaveConfigFile(Module.lIIllIIlI[1]); + if (this.toggled) { + this.onEnable(); + } else { + this.onDisable(); + } + + } + + public void toggleNoSave() { + this.toggled = !this.toggled; + this.onToggle(); + if (this.toggled) { + this.onEnable(); + } else { + this.onDisable(); + } + + } + + public String getName() { + return this.name; + } + + public String getDescription() { + return this.description; + } + + public void setName(String s) { + this.name = s; + } + + public int getKey() { + return this.key; + } + + public void setKey(int i) { + ConfigManager.SaveConfigFile(Module.lIIllIIlI[2]); + this.key = i; + } + + public void setKeyNoSave(int i) { + this.key = i; + } + + public Category getCategory() { + return this.category; + } + + public void setCategory(Category category) { + this.category = category; + } + + public boolean isToggled() { + return this.toggled; + } + + public String getDisplayName() { + return this.displayName == null ? this.name : this.displayName; + } + + public void setDisplayName(String s) { + this.displayName = s; + } + + public void setup() {} + + public void onRender2D() {} + + public void onRender3D() {} + + static { + lIIIIlllllI(); + lIIIIlllIll(); + Module.mc = Game.Minecraft(); + } + + private static void lIIIIlllIll() { + lIIllIIlI = new String[3]; + Module.lIIllIIlI[0] = lIIIIlllIIl(Module.lIIllIlll[0], Module.lIIllIlll[1]); + Module.lIIllIIlI[1] = lIIIIlllIlI(Module.lIIllIlll[2], Module.lIIllIlll[3]); + Module.lIIllIIlI[2] = lIIIIlllIlI(Module.lIIllIlll[4], Module.lIIllIlll[5]); + Module.lIIllIlll = null; + } + + private static void lIIIIlllllI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Module.lIIllIlll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIlllIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIIlllIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/ModuleManager.java b/module/ModuleManager.java new file mode 100644 index 0000000..94065fe --- /dev/null +++ b/module/ModuleManager.java @@ -0,0 +1,160 @@ +package me.explicit.module; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import me.explicit.config.ConfigModule; +import me.explicit.module.blatant.AntiVoid; +import me.explicit.module.blatant.BowAimbot; +import me.explicit.module.blatant.Criticals; +import me.explicit.module.blatant.Fall; +import me.explicit.module.blatant.Fly; +import me.explicit.module.blatant.KillSults; +import me.explicit.module.blatant.Killaura; +import me.explicit.module.blatant.LongJump; +import me.explicit.module.blatant.Speed; +import me.explicit.module.blatant.TriggerBot; +import me.explicit.module.combat.AimAssist; +import me.explicit.module.combat.AntiBot; +import me.explicit.module.combat.AutoClicker; +import me.explicit.module.combat.ClickAssist; +import me.explicit.module.combat.HitBoxes; +import me.explicit.module.combat.Reach; +import me.explicit.module.combat.RodAimbot; +import me.explicit.module.combat.STap; +import me.explicit.module.combat.ThrowPot; +import me.explicit.module.combat.Velocity; +import me.explicit.module.combat.WTap; +import me.explicit.module.misc.MCF; +import me.explicit.module.misc.NameProtect; +import me.explicit.module.misc.PingSpoof; +import me.explicit.module.misc.SelfDestruct; +import me.explicit.module.misc.Timer; +import me.explicit.module.movement.Eagle; +import me.explicit.module.movement.InvMove; +import me.explicit.module.movement.Parkour; +import me.explicit.module.movement.Sprint; +import me.explicit.module.movement.Step; +import me.explicit.module.movement.Strafe; +import me.explicit.module.player.AutoArmor; +import me.explicit.module.player.AutoHotbar; +import me.explicit.module.player.AutoMLG; +import me.explicit.module.player.AutoMine; +import me.explicit.module.player.AutoTool; +import me.explicit.module.player.ChestStealer; +import me.explicit.module.player.FastBreak; +import me.explicit.module.player.FastPlace; +import me.explicit.module.render.Chams; +import me.explicit.module.render.ClickGUI; +import me.explicit.module.render.ESP; +import me.explicit.module.render.HUD; +import me.explicit.module.render.NameTags; +import me.explicit.module.render.Projectiles; +import me.explicit.module.render.Search; +import me.explicit.module.render.StorageESP; +import me.explicit.module.render.TimeChanger; +import me.explicit.module.values.ValueAnimals; +import me.explicit.module.values.ValueFriends; +import me.explicit.module.values.ValueInvisibles; +import me.explicit.module.values.ValueMobs; +import me.explicit.module.values.ValueNaked; +import me.explicit.module.values.ValueOthers; +import me.explicit.module.values.ValuePlayers; +import me.explicit.module.values.ValueTeams; + +public class ModuleManager { + + public List modules; + + public ModuleManager() { + (this.modules = new ArrayList()).add(new ValuePlayers()); + this.modules.add(new ValueTeams()); + this.modules.add(new ValueInvisibles()); + this.modules.add(new ValueFriends()); + this.modules.add(new ValueAnimals()); + this.modules.add(new ValueMobs()); + this.modules.add(new ValueOthers()); + this.modules.add(new ValueNaked()); + this.modules.add(new FastPlace()); + this.modules.add(new Sprint()); + this.modules.add(new Strafe()); + this.modules.add(new ClickGUI()); + this.modules.add(new AimAssist()); + this.modules.add(new AutoClicker()); + this.modules.add(new Velocity()); + this.modules.add(new Reach()); + this.modules.add(new AntiBot()); + this.modules.add(new Fly()); + this.modules.add(new HUD()); + this.modules.add(new SelfDestruct()); + this.modules.add(new AutoArmor()); + this.modules.add(new Speed()); + this.modules.add(new Timer()); + this.modules.add(new ESP()); + this.modules.add(new Chams()); + this.modules.add(new HitBoxes()); + this.modules.add(new AutoMLG()); + this.modules.add(new ChestStealer()); + this.modules.add(new Step()); + this.modules.add(new Eagle()); + this.modules.add(new Fall()); + this.modules.add(new MCF()); + this.modules.add(new NameTags()); + this.modules.add(new RodAimbot()); + this.modules.add(new AutoMine()); + this.modules.add(new StorageESP()); + this.modules.add(new WTap()); + this.modules.add(new STap()); + this.modules.add(new LongJump()); + this.modules.add(new AutoHotbar()); + this.modules.add(new Search()); + this.modules.add(new TimeChanger()); + this.modules.add(new Projectiles()); + this.modules.add(new BowAimbot()); + this.modules.add(new KillSults()); + this.modules.add(new Killaura()); + this.modules.add(new NameProtect()); + this.modules.add(new Criticals()); + this.modules.add(new ConfigModule()); + this.modules.add(new AntiVoid()); + this.modules.add(new AutoTool()); + this.modules.add(new InvMove()); + this.modules.add(new Parkour()); + this.modules.add(new FastBreak()); + this.modules.add(new TriggerBot()); + this.modules.add(new ThrowPot()); + this.modules.add(new PingSpoof()); + this.modules.add(new ClickAssist()); + } + + public List getEnabledModules() { + ArrayList arraylist = new ArrayList(); + + for (int i = 0; i < this.modules.size(); ++i) { + if (((Module) this.modules.get(i)).isToggled()) { + arraylist.add(this.modules.get(i)); + } + } + + return arraylist; + } + + public List getModules() { + return this.modules; + } + + public Module getModuleByName(String s) { + Module module = null; + Iterator iterator = this.modules.iterator(); + + while (iterator.hasNext()) { + Module module1 = (Module) iterator.next(); + + if (module1.getName().equalsIgnoreCase(s)) { + module = module1; + } + } + + return module; + } +} diff --git a/module/blatant/AntiVoid.java b/module/blatant/AntiVoid.java new file mode 100644 index 0000000..0fce9d4 --- /dev/null +++ b/module/blatant/AntiVoid.java @@ -0,0 +1,86 @@ +package me.explicit.module.blatant; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import net.minecraft.block.material.Material; +import net.minecraft.network.play.client.C03PacketPlayer.C04PacketPlayerPosition; +import net.minecraft.util.BlockPos; + +public class AntiVoid extends Module { + + private static final String[] lIIIllI; + private static String[] lIIlIII; + + public AntiVoid() { + super(AntiVoid.lIIIllI[0], AntiVoid.lIIIllI[1], Category.BLATANT); + } + + public void onUpdate() { + if (Game.Player() != null && Game.Player().fallDistance > 4.0F && !this.isBlockUnderneath()) { + Game.Player().sendQueue.addToSendQueue(new C04PacketPlayerPosition(Game.Player().posX, Game.Player().posY + ThreadLocalRandom.current().nextDouble(8.0D, 12.0D), Game.Player().posZ, false)); + } + + } + + public boolean isBlockUnderneath() { + for (int i = 0; (double) i < AntiVoid.mc.thePlayer.posY + 1.0D; ++i) { + if (AntiVoid.mc.theWorld.getBlockState(new BlockPos(AntiVoid.mc.thePlayer.posX, (double) i, AntiVoid.mc.thePlayer.posZ)).getBlock().getMaterial() != Material.air) { + return true; + } + } + + return false; + } + + static { + llllIlll(); + llllIlIl(); + } + + private static void llllIlIl() { + lIIIllI = new String[2]; + AntiVoid.lIIIllI[0] = llllIIll(AntiVoid.lIIlIII[0], AntiVoid.lIIlIII[1]); + AntiVoid.lIIIllI[1] = llllIlII(AntiVoid.lIIlIII[2], AntiVoid.lIIlIII[3]); + AntiVoid.lIIlIII = null; + } + + private static void llllIlll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AntiVoid.lIIlIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llllIlII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llllIIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/blatant/BowAimbot.java b/module/blatant/BowAimbot.java new file mode 100644 index 0000000..4eec16c --- /dev/null +++ b/module/blatant/BowAimbot.java @@ -0,0 +1,189 @@ +package me.explicit.module.blatant; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import me.explicit.utils.RotationUtils; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.entity.Entity; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemFishingRod; +import net.minecraft.item.ItemStack; +import net.minecraft.util.Vec3; + +public class BowAimbot extends Module { + + private Entity target; + private static final String[] lIIIlIlI; + private static String[] lIIIllII; + + public BowAimbot() { + super(BowAimbot.lIIIlIlI[0], 0, Category.BLATANT, BowAimbot.lIIIlIlI[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(BowAimbot.lIIIlIlI[2], this, 10.0D, 0.1D, 20.0D, false)); + } + + public void onTick() { + if (!BowAimbot.mc.gameSettings.keyBindUseItem.isKeyDown()) { + this.target = null; + } else { + ItemStack itemstack = Game.Player().inventory.getCurrentItem(); + + if (itemstack != null && itemstack.getItem() instanceof ItemBow) { + if (this.target == null || !CombatUtils.canTarget(this.target, true) || !RotationUtils.canEntityBeSeen(this.target) || !this.target.isEntityAlive()) { + this.target = this.getBestEntity(); + } + + if (this.target != null) { + try { + float[] afloat = faceBow(this.target, false, true, (float) Explicit.instance.sm.getSettingByName(this, BowAimbot.lIIIlIlI[3]).getValDouble()); + + if (afloat.length < 2 || afloat[0] == Float.POSITIVE_INFINITY || afloat[0] == Float.NEGATIVE_INFINITY || afloat[1] == Float.POSITIVE_INFINITY || afloat[1] == Float.NEGATIVE_INFINITY) { + return; + } + + float f; + + for (f = afloat[0]; f > 360.0F; f -= 360.0F) { + ; + } + + BowAimbot.mc.thePlayer.rotationYaw = f; + float f1 = afloat[1]; + + if (!Double.isNaN((double) f1)) { + BowAimbot.mc.thePlayer.rotationPitch = afloat[1]; + } + } catch (Exception exception) { + exception.printStackTrace(); + BowAimbot.mc.thePlayer.rotationYaw = 0.0F; + BowAimbot.mc.thePlayer.rotationPitch = 0.0F; + } + + } + } else { + this.target = null; + } + } + } + + public Entity getBestEntity() { + Entity entity = null; + float f = Float.POSITIVE_INFINITY; + Iterator iterator = Game.World().loadedEntityList.iterator(); + + while (iterator.hasNext()) { + Entity entity1 = (Entity) iterator.next(); + + if (entity1 != null && (!(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemFishingRod) || Game.Player().getDistanceToEntity(entity1) <= 30.0F) && CombatUtils.canTarget(entity1, true) && BowAimbot.mc.thePlayer.canEntityBeSeen(entity1) && BowAimbot.mc.thePlayer.canEntityBeSeen(entity1) && Game.Player().getDistanceToEntity(entity1) <= 75.0F) { + new Vec3(0.5D, 1.0D, 0.5D); + float[] afloat = RotationUtils.getRotations(entity1); + float f1 = BowAimbot.mc.thePlayer.rotationYaw - afloat[0]; + float f2 = BowAimbot.mc.thePlayer.rotationPitch - afloat[1]; + float f3 = (float) Math.sqrt((double) (f1 * f1 + f2 * f2)); + + if (f3 < f) { + entity = entity1; + f = f3; + } + } + } + + return entity; + } + + public static float[] faceBow(Entity entity, boolean flag, boolean flag1, float f) { + EntityPlayerSP entityplayersp = BowAimbot.mc.thePlayer; + double d0 = entity.posX + (flag1 ? (entity.posX - entity.prevPosX) * (double) f : 0.0D) - (entityplayersp.posX + (flag1 ? entityplayersp.posX - entityplayersp.prevPosX : 0.0D)); + double d1 = entity.getEntityBoundingBox().minY + (flag1 ? (entity.getEntityBoundingBox().minY - entity.prevPosY) * (double) f : 0.0D) + (double) entity.getEyeHeight() - 0.15D - (entityplayersp.getEntityBoundingBox().minY + (flag1 ? entityplayersp.posY - entityplayersp.prevPosY : 0.0D)) - (double) entityplayersp.getEyeHeight(); + double d2 = entity.posZ + (flag1 ? (entity.posZ - entity.prevPosZ) * (double) f : 0.0D) - (entityplayersp.posZ + (flag1 ? entityplayersp.posZ - entityplayersp.prevPosZ : 0.0D)); + double d3 = Math.sqrt(d0 * d0 + d2 * d2); + float f1 = (float) entityplayersp.getItemInUseDuration() / 20.0F; + + f1 = (f1 * f1 + f1 * 2.0F) / 3.0F; + if (f1 > 1.0F) { + f1 = 1.0F; + } + + float f2 = (float) (Math.atan2(d2, d0) * 180.0D / 3.141592653589793D) - 90.0F; + float f3 = (float) (-Math.toDegrees(Math.atan(((double) (f1 * f1) - Math.sqrt((double) (f1 * f1 * f1 * f1) - 0.006000000052154064D * (0.006000000052154064D * d3 * d3 + 2.0D * d1 * (double) (f1 * f1)))) / (0.006000000052154064D * d3)))); + + return new float[] { f2, f3}; + } + + static { + llllIIlll(); + llllIIllI(); + } + + private static void llllIIllI() { + lIIIlIlI = new String[4]; + BowAimbot.lIIIlIlI[0] = lllIlllll(BowAimbot.lIIIllII[0], BowAimbot.lIIIllII[1]); + BowAimbot.lIIIlIlI[1] = llllIIIII(BowAimbot.lIIIllII[2], BowAimbot.lIIIllII[3]); + BowAimbot.lIIIlIlI[2] = llllIIIIl(BowAimbot.lIIIllII[4], BowAimbot.lIIIllII[5]); + BowAimbot.lIIIlIlI[3] = lllIlllll(BowAimbot.lIIIllII[6], BowAimbot.lIIIllII[7]); + BowAimbot.lIIIllII = null; + } + + private static void llllIIlll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + BowAimbot.lIIIllII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llllIIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lllIlllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llllIIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/blatant/Criticals.java b/module/blatant/Criticals.java new file mode 100644 index 0000000..03c9da6 --- /dev/null +++ b/module/blatant/Criticals.java @@ -0,0 +1,88 @@ +package me.explicit.module.blatant; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.concurrent.ThreadLocalRandom; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import net.minecraft.network.play.client.C03PacketPlayer.C04PacketPlayerPosition; +import net.minecraftforge.client.event.MouseEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class Criticals extends Module { + + private static final String[] llIlIIII; + private static String[] llIlIIIl; + + public Criticals() { + super(Criticals.llIlIIII[0], Criticals.llIlIIII[1], Category.BLATANT); + } + + @SubscribeEvent + public void mous(MouseEvent mouseevent) { + if (Game.Player() != null && Game.World() != null && ThreadLocalRandom.current().nextInt(100) < 85 && Criticals.mc.thePlayer.onGround && Criticals.mc.objectMouseOver != null && Criticals.mc.objectMouseOver.entityHit != null && CombatUtils.canTarget(Criticals.mc.objectMouseOver.entityHit, true) && mouseevent.button == 0) { + for (int i = 0; i < 2; ++i) { + double d0 = ThreadLocalRandom.current().nextDouble(4.0E-6D, 6.0E-6D); + + Criticals.mc.thePlayer.sendQueue.addToSendQueue(new C04PacketPlayerPosition(Criticals.mc.thePlayer.posX, Criticals.mc.thePlayer.posY + d0, Criticals.mc.thePlayer.posZ, false)); + Criticals.mc.thePlayer.sendQueue.addToSendQueue(new C04PacketPlayerPosition(Criticals.mc.thePlayer.posX, Criticals.mc.thePlayer.posY, Criticals.mc.thePlayer.posZ, false)); + } + } + + } + + static { + llIIIlIIII(); + llIIIIllll(); + } + + private static void llIIIIllll() { + llIlIIII = new String[2]; + Criticals.llIlIIII[0] = llIIIIllIl(Criticals.llIlIIIl[0], Criticals.llIlIIIl[1]); + Criticals.llIlIIII[1] = llIIIIlllI(Criticals.llIlIIIl[2], Criticals.llIlIIIl[3]); + Criticals.llIlIIIl = null; + } + + private static void llIIIlIIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Criticals.llIlIIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIIIllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIIIlllI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/blatant/Fall.java b/module/blatant/Fall.java new file mode 100644 index 0000000..af4f5be --- /dev/null +++ b/module/blatant/Fall.java @@ -0,0 +1,90 @@ +package me.explicit.module.blatant; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import net.minecraft.block.BlockAir; +import net.minecraft.network.play.client.C03PacketPlayer.C06PacketPlayerPosLook; +import net.minecraft.util.BlockPos; + +public class Fall extends Module { + + private static final String[] lIIllllIl; + private static String[] lIIlllllI; + + public Fall() { + super(Fall.lIIllllIl[0], 0, Category.BLATANT, Fall.lIIllllIl[1]); + } + + public void onTick() { + if (Game.Player().fallDistance > 3.0F && this.isBlockUnderneath()) { + Fall.mc.getNetHandler().addToSendQueue(new C06PacketPlayerPosLook(Game.Player().posX, Game.Player().posY, Game.Player().posZ, Game.Player().rotationYaw, Game.Player().rotationPitch, true)); + Game.Player().fallDistance = 0.0F; + } + + } + + private boolean isBlockUnderneath() { + boolean flag = false; + + for (int i = 0; (double) i < Game.Player().posY + 2.0D; ++i) { + BlockPos blockpos = new BlockPos(Game.Player().posX, (double) i, Game.Player().posZ); + + if (!(Module.mc.theWorld.getBlockState(blockpos).getBlock() instanceof BlockAir)) { + flag = true; + } + } + + return flag; + } + + public double getDistanceToGround() { + int i = 0; + + for (int j = 0; (double) j < Game.Player().posY; ++j) { + BlockPos blockpos = new BlockPos(Game.Player().posX, Game.Player().posY - (double) j, Game.Player().posZ); + + if (Game.World().isAirBlock(blockpos)) { + ++i; + } + } + + return (double) i; + } + + static { + lIIIlIlIIll(); + lIIIlIlIIlI(); + } + + private static void lIIIlIlIIlI() { + lIIllllIl = new String[2]; + Fall.lIIllllIl[0] = lIIIlIlIIIl(Fall.lIIlllllI[0], Fall.lIIlllllI[1]); + Fall.lIIllllIl[1] = lIIIlIlIIIl(Fall.lIIlllllI[2], Fall.lIIlllllI[3]); + Fall.lIIlllllI = null; + } + + private static void lIIIlIlIIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Fall.lIIlllllI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIlIlIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/blatant/Fly.java b/module/blatant/Fly.java new file mode 100644 index 0000000..d38e1a2 --- /dev/null +++ b/module/blatant/Fly.java @@ -0,0 +1,98 @@ +package me.explicit.module.blatant; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.MoveUtils; + +public class Fly extends Module { + + private static final String[] llIllllI; + private static String[] llIlllll; + + public Fly() { + super(Fly.llIllllI[0], 0, Category.BLATANT, Fly.llIllllI[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(Fly.llIllllI[2], this, 1.0D, 0.05D, 5.0D, false)); + } + + public void onTick() { + boolean flag = Fly.mc.gameSettings.keyBindJump.isKeyDown(); + boolean flag1 = Fly.mc.gameSettings.keyBindSneak.isKeyDown(); + double d0 = Explicit.instance.sm.getSettingByName(this, Fly.llIllllI[3]).getValDouble(); + + if (!flag && !flag1) { + Game.Player().motionY = 0.0D; + } else if (flag) { + Game.Player().motionY = d0; + } else if (flag1) { + Game.Player().motionY = -d0; + } + + MoveUtils.setMoveSpeed(d0); + } + + public void onDisable() { + super.onDisable(); + } + + static { + llIIlllIlI(); + llIIlllIIl(); + } + + private static void llIIlllIIl() { + llIllllI = new String[4]; + Fly.llIllllI[0] = llIIllIlll(Fly.llIlllll[0], Fly.llIlllll[1]); + Fly.llIllllI[1] = llIIlllIII(Fly.llIlllll[2], Fly.llIlllll[3]); + Fly.llIllllI[2] = llIIlllIII(Fly.llIlllll[4], Fly.llIlllll[5]); + Fly.llIllllI[3] = llIIllIlll(Fly.llIlllll[6], Fly.llIlllll[7]); + Fly.llIlllll = null; + } + + private static void llIIlllIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Fly.llIlllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIlllIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIllIlll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/blatant/KillSults.java b/module/blatant/KillSults.java new file mode 100644 index 0000000..374d892 --- /dev/null +++ b/module/blatant/KillSults.java @@ -0,0 +1,204 @@ +package me.explicit.module.blatant; + +import io.netty.util.internal.ThreadLocalRandom; +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.config.ConfigManager; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.ChatUtils; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import net.minecraft.entity.EntityLivingBase; +import net.minecraftforge.client.event.ClientChatReceivedEvent; +import net.minecraftforge.event.entity.living.LivingDeathEvent; +import net.minecraftforge.event.entity.player.AttackEntityEvent; +import net.minecraftforge.fml.common.eventhandler.EventPriority; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class KillSults extends Module { + + private List killsults = new ArrayList(); + private String mode; + private EntityLivingBase lastHit; + private static final String[] lIIllllI; + private static String[] lIIlllll; + + public KillSults() { + super(KillSults.lIIllllI[0], 0, Category.BLATANT, KillSults.lIIllllI[1]); + this.mode = KillSults.lIIllllI[2]; + this.lastHit = null; + } + + public void setup() { + ArrayList arraylist = new ArrayList(); + + arraylist.add(KillSults.lIIllllI[3]); + arraylist.add(KillSults.lIIllllI[4]); + Explicit.instance.sm.rSetting(new Setting(KillSults.lIIllllI[5], this, KillSults.lIIllllI[6], arraylist)); + Explicit.instance.sm.rSetting(new Setting(KillSults.lIIllllI[7], this, false)); + } + + public void onEnable() { + super.onEnable(); + this.setKillsults(); + } + + public void onUpdateNoToggle() { + this.mode = Explicit.instance.sm.getSettingByName(this, KillSults.lIIllllI[8]).getValString(); + if (Explicit.instance.sm.getSettingByName(this, KillSults.lIIllllI[9]).getValBoolean()) { + this.setKillsults(); + Explicit.instance.sm.getSettingByName(this, KillSults.lIIllllI[10]).setValBoolean(false); + } + + } + + @SubscribeEvent + public void chat(ClientChatReceivedEvent clientchatreceivedevent) { + if (this.mode.equalsIgnoreCase(KillSults.lIIllllI[11]) && this.lastHit != null) { + String s = clientchatreceivedevent.message.getUnformattedText(); + + if (s.startsWith(this.lastHit.getName()) && (s.endsWith(Game.Player().getName()) || s.endsWith(String.valueOf((new StringBuilder()).append(Game.Player().getName()).append(KillSults.lIIllllI[12]))))) { + this.insult(); + } + } + + } + + @SubscribeEvent + public void kill(LivingDeathEvent livingdeathevent) { + if (livingdeathevent.source.getEntity() != null && livingdeathevent.source.getEntity().getName() == Game.Player().getName() && CombatUtils.canTarget(livingdeathevent.entityLiving, true) && this.mode.equalsIgnoreCase(KillSults.lIIllllI[13])) { + this.insult(); + } + + } + + @SubscribeEvent( + priority = EventPriority.LOWEST + ) + public void onAttack(AttackEntityEvent attackentityevent) { + if (attackentityevent.entityLiving != null && attackentityevent.entityLiving.getName() == Game.Player().getName() && attackentityevent.target != null && CombatUtils.canTarget(attackentityevent.target, true)) { + this.lastHit = (EntityLivingBase) attackentityevent.target; + } + + } + + public void insult() { + if (!this.killsults.isEmpty()) { + String s = (String) this.killsults.get(ThreadLocalRandom.current().nextInt(this.killsults.size())); + + Game.Player().sendChatMessage(s.replaceAll(KillSults.lIIllllI[14], this.lastHit.getName())); + } + } + + public void setKillsults() { + ConfigManager.getConfigFile(KillSults.lIIllllI[15], false); + File file = ConfigManager.KILLSULTS; + + try { + BufferedReader bufferedreader = new BufferedReader(new FileReader(file)); + + this.killsults.clear(); + + String s; + + while ((s = bufferedreader.readLine()) != null) { + this.killsults.add(s); + } + + ChatUtils.sendMessage(KillSults.lIIllllI[16]); + } catch (IOException ioexception) { + ioexception.printStackTrace(); + } + + } + + static { + lIIIlIllll(); + lIIIlIlllI(); + } + + private static void lIIIlIlllI() { + lIIllllI = new String[17]; + KillSults.lIIllllI[0] = lIIIlIlIll(KillSults.lIIlllll[0], KillSults.lIIlllll[1]); + KillSults.lIIllllI[1] = lIIIlIlIll(KillSults.lIIlllll[2], KillSults.lIIlllll[3]); + KillSults.lIIllllI[2] = lIIIlIlIll(KillSults.lIIlllll[4], KillSults.lIIlllll[5]); + KillSults.lIIllllI[3] = lIIIlIllII(KillSults.lIIlllll[6], KillSults.lIIlllll[7]); + KillSults.lIIllllI[4] = lIIIlIlIll(KillSults.lIIlllll[8], KillSults.lIIlllll[9]); + KillSults.lIIllllI[5] = lIIIlIllII(KillSults.lIIlllll[10], KillSults.lIIlllll[11]); + KillSults.lIIllllI[6] = lIIIlIllIl(KillSults.lIIlllll[12], KillSults.lIIlllll[13]); + KillSults.lIIllllI[7] = lIIIlIlIll(KillSults.lIIlllll[14], KillSults.lIIlllll[15]); + KillSults.lIIllllI[8] = lIIIlIllII(KillSults.lIIlllll[16], KillSults.lIIlllll[17]); + KillSults.lIIllllI[9] = lIIIlIllIl(KillSults.lIIlllll[18], KillSults.lIIlllll[19]); + KillSults.lIIllllI[10] = lIIIlIllIl(KillSults.lIIlllll[20], KillSults.lIIlllll[21]); + KillSults.lIIllllI[11] = lIIIlIllIl(KillSults.lIIlllll[22], KillSults.lIIlllll[23]); + KillSults.lIIllllI[12] = lIIIlIllIl(KillSults.lIIlllll[24], KillSults.lIIlllll[25]); + KillSults.lIIllllI[13] = lIIIlIllIl(KillSults.lIIlllll[26], KillSults.lIIlllll[27]); + KillSults.lIIllllI[14] = lIIIlIlIll(KillSults.lIIlllll[28], KillSults.lIIlllll[29]); + KillSults.lIIllllI[15] = lIIIlIlIll(KillSults.lIIlllll[30], KillSults.lIIlllll[31]); + KillSults.lIIllllI[16] = lIIIlIllII(KillSults.lIIlllll[32], KillSults.lIIlllll[33]); + KillSults.lIIlllll = null; + } + + private static void lIIIlIllll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + KillSults.lIIlllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIlIlIll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIlIllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIlIllII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/blatant/Killaura.java b/module/blatant/Killaura.java new file mode 100644 index 0000000..c7087cb --- /dev/null +++ b/module/blatant/Killaura.java @@ -0,0 +1,443 @@ +package me.explicit.module.blatant; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import me.explicit.utils.RotationUtils; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityArmorStand; +import net.minecraft.item.ItemAxe; +import net.minecraft.item.ItemSword; +import net.minecraft.network.play.client.C02PacketUseEntity; +import net.minecraft.network.play.client.C02PacketUseEntity.Action; + +public class Killaura extends Module { + + private TimerUtils switchTimer = new TimerUtils(); + private TimerUtils attackTimer = new TimerUtils(); + public EntityLivingBase target; + private List targets = new ArrayList(); + private boolean isBlocking; + private boolean canBlock; + private int currentIndex; + public static boolean isAttackTick; + public static boolean isRotationTick; + private String mode; + private String rotationsmode; + private double range; + private double blockrange; + private int hitchance; + private int switchdelay; + private double aps; + public boolean autoblock; + private boolean raytrace; + private static final String[] llIlllI; + private static String[] lllIIII; + + public Killaura() { + super(Killaura.llIlllI[0], 0, Category.BLATANT, Killaura.llIlllI[1]); + } + + public void setup() { + ArrayList arraylist = new ArrayList(); + + arraylist.add(Killaura.llIlllI[2]); + arraylist.add(Killaura.llIlllI[3]); + arraylist.add(Killaura.llIlllI[4]); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[5], this, Killaura.llIlllI[6], arraylist)); + ArrayList arraylist1 = new ArrayList(); + + arraylist1.add(Killaura.llIlllI[7]); + arraylist1.add(Killaura.llIlllI[8]); + arraylist1.add(Killaura.llIlllI[9]); + arraylist1.add(Killaura.llIlllI[10]); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[11], this, Killaura.llIlllI[12], arraylist1)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[13], this, 4.2D, 1.0D, 6.0D, false)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[14], this, 5.0D, 1.0D, 10.0D, false)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[15], this, 100.0D, 1.0D, 100.0D, true)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[16], this, 200.0D, 1.0D, 1000.0D, true)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[17], this, 10.0D, 2.0D, 20.0D, false)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[18], this, true)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[19], this, false)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[20], this, false)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[21], this, false)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[22], this, false)); + Explicit.instance.sm.rSetting(new Setting(Killaura.llIlllI[23], this, false)); + } + + public void onTick() { + Killaura.isRotationTick = false; + this.updateSettings(); + this.setTargets(); + if (Game.Player() != null && Game.World() != null) { + if (!Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[24]).getValBoolean() || Killaura.mc.gameSettings.keyBindAttack.isKeyDown()) { + this.isBlocking = Game.Player().isUsingItem() && Killaura.mc.thePlayer.getCurrentEquippedItem() != null && Killaura.mc.thePlayer.getCurrentEquippedItem().getItem() instanceof ItemSword; + if (this.target != null) { + this.rotate(); + double d0 = (double) Killaura.mc.thePlayer.getDistanceToEntity(this.target); + + if (d0 <= this.blockrange && d0 <= this.range && this.autoblock && Killaura.mc.thePlayer.getCurrentEquippedItem() != null && Killaura.mc.thePlayer.getCurrentEquippedItem().getItem() instanceof ItemSword) { + this.canBlock = true; + } else { + this.canBlock = false; + } + + if (this.canBlock && !this.isBlocking) { + this.block(); + } + + if (d0 <= this.range && this.attackTimer.hasReached(1000.0D / this.aps)) { + Killaura.mc.thePlayer.swingItem(); + if (ThreadLocalRandom.current().nextInt(0, 100) <= this.hitchance && (Killaura.mc.objectMouseOver.entityHit != null && (Killaura.mc.objectMouseOver.entityHit == this.target || this.mode.equalsIgnoreCase(Killaura.llIlllI[25])) || !this.raytrace) && this.canHit()) { + if (this.isBlocking) { + this.unBlock(); + } + + Killaura.isAttackTick = true; + this.attack(); + if (this.canBlock) { + this.block(); + } + } + + this.attackTimer.reset(); + } else { + Killaura.isAttackTick = false; + } + } else if (this.isBlocking) { + this.unBlock(); + } + + } + } + } + + private boolean canHit() { + boolean flag = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[26]).getValBoolean(); + boolean flag1 = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[27]).getValBoolean(); + + if (flag || flag1) { + if (Game.Player().getCurrentEquippedItem() == null) { + return false; + } + + if (flag && !flag1 && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemSword)) { + return false; + } + + if (!flag && flag1 && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemAxe)) { + return false; + } + + if (flag && flag1 && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemAxe) && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemSword)) { + return false; + } + } + + return true; + } + + private void rotate() { + if (this.canHit()) { + float[] afloat = RotationUtils.getRotations(this.target); + + if (this.rotationsmode.equalsIgnoreCase(Killaura.llIlllI[28])) { + Game.Player().rotationYaw = afloat[0]; + Game.Player().rotationPitch = afloat[1]; + Killaura.isRotationTick = true; + } else { + double d0; + float f; + float f1; + double d1; + + if (this.rotationsmode.equalsIgnoreCase(Killaura.llIlllI[29])) { + d0 = ThreadLocalRandom.current().nextDouble(7.5D, 10.0D); + f = RotationUtils.getYawChange(Game.Player().prevRotationYaw, this.target.posX + ThreadLocalRandom.current().nextDouble(-1.0D, 1.0D) * 0.05D, this.target.posZ + ThreadLocalRandom.current().nextDouble(-1.0D, 1.0D) * 0.05D); + f1 = (float) ((double) f / d0); + Game.Player().rotationYaw = Game.Player().prevRotationYaw + f1; + d1 = (double) (afloat[1] - Game.Player().rotationPitch); + Game.Player().rotationPitch = (float) ((double) Game.Player().rotationPitch + d1 / d0); + Killaura.isRotationTick = true; + } else if (this.rotationsmode.equalsIgnoreCase(Killaura.llIlllI[30])) { + d0 = ThreadLocalRandom.current().nextDouble(15.0D, 20.0D); + f = RotationUtils.getYawChange(Game.Player().prevRotationYaw, this.target.posX + ThreadLocalRandom.current().nextDouble(-1.0D, 1.0D) * 0.05D, this.target.posZ + ThreadLocalRandom.current().nextDouble(-1.0D, 1.0D) * 0.05D); + f1 = (float) ((double) f / d0); + Game.Player().rotationYaw = Game.Player().prevRotationYaw + f1; + d1 = (double) (afloat[1] - Game.Player().rotationPitch); + Game.Player().rotationPitch = (float) ((double) Game.Player().rotationPitch + d1 / d0); + Killaura.isRotationTick = true; + } + } + } + + if (Killaura.mc.thePlayer.rotationPitch > 90.0F) { + Killaura.mc.thePlayer.rotationPitch = 90.0F; + } else if (Killaura.mc.thePlayer.rotationPitch < -90.0F) { + Killaura.mc.thePlayer.rotationPitch = -90.0F; + } + + } + + public void onEnable() { + this.targets.clear(); + super.onEnable(); + } + + public void onDisable() { + if (this.isBlocking) { + this.unBlock(); + } + + Killaura.isAttackTick = false; + Killaura.isRotationTick = false; + super.onDisable(); + } + + private void setTargets() { + this.targets = this.getTargets(); + if (!this.targets.isEmpty() && (this.target == null || this.targets.contains(this.target))) { + if (!this.mode.equalsIgnoreCase(Killaura.llIlllI[31]) && this.switchTimer.hasReached((double) this.switchdelay) && (!this.mode.equalsIgnoreCase(Killaura.llIlllI[32]) || this.targets.size() != 1)) { + if (this.mode.equalsIgnoreCase(Killaura.llIlllI[33])) { + if (this.target != null && this.isValid(this.target) && this.targets.size() == 1) { + return; + } + + if (this.target == null) { + this.target = (EntityLivingBase) this.targets.get(0); + } else if (this.targets.size() > 1) { + int i = this.targets.size() - 1; + + if (this.currentIndex >= i) { + this.currentIndex = 0; + } else { + ++this.currentIndex; + } + + if (this.targets.get(this.currentIndex) != null && this.targets.get(this.currentIndex) != this.target) { + this.target = (EntityLivingBase) this.targets.get(this.currentIndex); + this.switchTimer.reset(); + } + } else { + this.target = null; + } + } else if (this.mode.equalsIgnoreCase(Killaura.llIlllI[34])) { + if (this.targets.isEmpty()) { + this.target = null; + } else if (this.target != null && !this.targets.contains(this.target) || this.target == null) { + this.target = (EntityLivingBase) this.targets.get(ThreadLocalRandom.current().nextInt(this.targets.size() - 1)); + } + } + } else { + if (this.target != null && this.isValid(this.target)) { + return; + } + + this.target = (EntityLivingBase) this.targets.get(0); + } + + } else { + this.target = null; + } + } + + private int getTargetInt() { + for (int i = 0; i < this.targets.size(); ++i) { + if (this.targets.get(i) == this.target) { + return i; + } + } + + return -1; + } + + private List getTargets() { + ArrayList arraylist = new ArrayList(); + Iterator iterator = Killaura.mc.theWorld.loadedEntityList.iterator(); + + while (iterator.hasNext()) { + Entity entity = (Entity) iterator.next(); + + if (this.isValid(entity)) { + arraylist.add((EntityLivingBase) entity); + } + } + + return arraylist; + } + + private boolean isValid(Entity entity) { + return entity instanceof EntityLivingBase && entity != Killaura.mc.thePlayer && entity.isEntityAlive() && !(entity instanceof EntityArmorStand) && CombatUtils.canTarget(entity, true) ? (double) Killaura.mc.thePlayer.getDistanceToEntity(entity) <= Math.max(this.range, this.blockrange) : false; + } + + private boolean attack() { + if (this.target == null) { + return false; + } else { + if (this.mode.equalsIgnoreCase(Killaura.llIlllI[35])) { + Iterator iterator = this.targets.iterator(); + + while (iterator.hasNext()) { + EntityLivingBase entitylivingbase = (EntityLivingBase) iterator.next(); + + Killaura.mc.thePlayer.sendQueue.addToSendQueue(new C02PacketUseEntity(entitylivingbase, Action.ATTACK)); + } + } else { + Killaura.mc.thePlayer.sendQueue.addToSendQueue(new C02PacketUseEntity(this.target, Action.ATTACK)); + } + + return true; + } + } + + private void unBlock() { + KeyBinding.setKeyBindState(Killaura.mc.gameSettings.keyBindUseItem.getKeyCode(), false); + Module.mc.playerController.onStoppedUsingItem(Module.mc.thePlayer); + } + + private void block() { + KeyBinding.setKeyBindState(Killaura.mc.gameSettings.keyBindUseItem.getKeyCode(), true); + if (Module.mc.playerController.sendUseItem(Module.mc.thePlayer, Module.mc.theWorld, Module.mc.thePlayer.inventory.getCurrentItem())) { + Module.mc.getItemRenderer().resetEquippedProgress2(); + } + + } + + private void updateSettings() { + this.mode = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[36]).getValString(); + this.rotationsmode = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[37]).getValString(); + this.range = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[38]).getValDouble(); + this.blockrange = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[39]).getValDouble(); + this.hitchance = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[40]).getValInt(); + this.switchdelay = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[41]).getValInt(); + boolean flag = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[42]).getValBoolean(); + + this.aps = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[43]).getValDouble() + (flag ? ThreadLocalRandom.current().nextDouble(-1.0D, 1.0D) : 0.0D); + this.autoblock = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[44]).getValBoolean(); + this.raytrace = Explicit.instance.sm.getSettingByName(this, Killaura.llIlllI[45]).getValBoolean(); + } + + static { + llIIIlllI(); + llIIIllIl(); + Killaura.isAttackTick = false; + Killaura.isRotationTick = false; + } + + private static void llIIIllIl() { + llIlllI = new String[46]; + Killaura.llIlllI[0] = llIIIlIlI(Killaura.lllIIII[0], Killaura.lllIIII[1]); + Killaura.llIlllI[1] = llIIIlIlI(Killaura.lllIIII[2], Killaura.lllIIII[3]); + Killaura.llIlllI[2] = llIIIlIlI(Killaura.lllIIII[4], Killaura.lllIIII[5]); + Killaura.llIlllI[3] = llIIIlIll(Killaura.lllIIII[6], Killaura.lllIIII[7]); + Killaura.llIlllI[4] = llIIIlIlI(Killaura.lllIIII[8], Killaura.lllIIII[9]); + Killaura.llIlllI[5] = llIIIlIll(Killaura.lllIIII[10], Killaura.lllIIII[11]); + Killaura.llIlllI[6] = llIIIlIlI(Killaura.lllIIII[12], Killaura.lllIIII[13]); + Killaura.llIlllI[7] = llIIIlIll(Killaura.lllIIII[14], Killaura.lllIIII[15]); + Killaura.llIlllI[8] = llIIIlIll(Killaura.lllIIII[16], Killaura.lllIIII[17]); + Killaura.llIlllI[9] = llIIIllII(Killaura.lllIIII[18], Killaura.lllIIII[19]); + Killaura.llIlllI[10] = llIIIlIll(Killaura.lllIIII[20], Killaura.lllIIII[21]); + Killaura.llIlllI[11] = llIIIlIll(Killaura.lllIIII[22], Killaura.lllIIII[23]); + Killaura.llIlllI[12] = llIIIllII(Killaura.lllIIII[24], Killaura.lllIIII[25]); + Killaura.llIlllI[13] = llIIIlIll(Killaura.lllIIII[26], Killaura.lllIIII[27]); + Killaura.llIlllI[14] = llIIIlIlI(Killaura.lllIIII[28], Killaura.lllIIII[29]); + Killaura.llIlllI[15] = llIIIlIll(Killaura.lllIIII[30], Killaura.lllIIII[31]); + Killaura.llIlllI[16] = llIIIlIlI(Killaura.lllIIII[32], Killaura.lllIIII[33]); + Killaura.llIlllI[17] = llIIIlIlI(Killaura.lllIIII[34], Killaura.lllIIII[35]); + Killaura.llIlllI[18] = llIIIlIlI(Killaura.lllIIII[36], Killaura.lllIIII[37]); + Killaura.llIlllI[19] = llIIIlIll(Killaura.lllIIII[38], Killaura.lllIIII[39]); + Killaura.llIlllI[20] = llIIIlIll(Killaura.lllIIII[40], Killaura.lllIIII[41]); + Killaura.llIlllI[21] = llIIIlIll(Killaura.lllIIII[42], Killaura.lllIIII[43]); + Killaura.llIlllI[22] = llIIIlIlI("Oj0+PT4mJD02", "iJQOZ"); + Killaura.llIlllI[23] = llIIIlIlI("GRExJzc0EA==", "XiThY"); + Killaura.llIlllI[24] = llIIIlIlI("JAgCOCUIDQ==", "kfATL"); + Killaura.llIlllI[25] = llIIIllII("o0yTud7hBes=", "prWuJ"); + Killaura.llIlllI[26] = llIIIlIll("69CO0mwqQgUoWcSDtO8Q0Q==", "ypioN"); + Killaura.llIlllI[27] = llIIIlIll("Zf2YTt+REdc=", "wdCJJ"); + Killaura.llIlllI[28] = llIIIllII("6ZrrHCPMLHM=", "ZRTuG"); + Killaura.llIlllI[29] = llIIIlIlI("Gzo7PTEg", "HWTRE"); + Killaura.llIlllI[30] = llIIIlIll("CBOreD9l5Uk=", "dhExr"); + Killaura.llIlllI[31] = llIIIlIlI("NgssEjQg", "EbBuX"); + Killaura.llIlllI[32] = llIIIlIlI("LhA8Ji0=", "CePRD"); + Killaura.llIlllI[33] = llIIIllII("Ca/3t1tejHc=", "wPyjv"); + Killaura.llIlllI[34] = llIIIlIll("SSNtNNRACy4=", "UlMCU"); + Killaura.llIlllI[35] = llIIIlIll("6qncfI4F6Hg=", "ztFYC"); + Killaura.llIlllI[36] = llIIIlIll("sMjFbq6Rcpo=", "VfBfq"); + Killaura.llIlllI[37] = llIIIllII("WazPsQAZKOiX5Dge0LuYSg==", "NHYKw"); + Killaura.llIlllI[38] = llIIIllII("uZV+QGAB8EE=", "KtaWl"); + Killaura.llIlllI[39] = llIIIlIlI("MCgMLgggJQ0qBg==", "rDcMc"); + Killaura.llIlllI[40] = llIIIlIlI("BzkzGzguPiQ9", "OPGXP"); + Killaura.llIlllI[41] = llIIIlIll("vRPvvPv8CgCmT9jLSddO5Q==", "FZcNn"); + Killaura.llIlllI[42] = llIIIlIlI("FBspCSsrEz0IBRYp", "FzGmD"); + Killaura.llIlllI[43] = llIIIlIll("qbZX1j+xnxk=", "CieMk"); + Killaura.llIlllI[44] = llIIIlIll("j492mJHCP+moi0F1BKqR0g==", "jjopE"); + Killaura.llIlllI[45] = llIIIlIlI("ODkaFTkLOwY=", "jXcaK"); + Killaura.lllIIII = null; + } + + private static void llIIIlllI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Killaura.lllIIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIIlIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIIllII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIIlIlI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/blatant/LongJump.java b/module/blatant/LongJump.java new file mode 100644 index 0000000..98857c1 --- /dev/null +++ b/module/blatant/LongJump.java @@ -0,0 +1,75 @@ +package me.explicit.module.blatant; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import me.explicit.utils.MoveUtils; + +public class LongJump extends Module { + + public long enabled; + private static final String[] lIIIIIllI; + private static String[] lIIIIlIII; + + public LongJump() { + super(LongJump.lIIIIIllI[0], 0, Category.BLATANT, LongJump.lIIIIIllI[1]); + } + + public void onMove() { + if (Game.Player().onGround && System.currentTimeMillis() - this.enabled > 500L) { + this.setToggled(false); + } else { + if (!Game.Player().onGround) { + MoveUtils.setMoveSpeed(2.0D); + } + + } + } + + public void onEnable() { + super.onEnable(); + if (Game.Player().onGround) { + LongJump.mc.thePlayer.jump(); + } else { + this.setToggled(false); + } + + this.enabled = System.currentTimeMillis(); + } + + static { + lllIlIlIII(); + lllIlIIlll(); + } + + private static void lllIlIIlll() { + lIIIIIllI = new String[2]; + LongJump.lIIIIIllI[0] = lllIIlIlIl(LongJump.lIIIIlIII[0], LongJump.lIIIIlIII[1]); + LongJump.lIIIIIllI[1] = lllIIlIlIl(LongJump.lIIIIlIII[2], LongJump.lIIIIlIII[3]); + LongJump.lIIIIlIII = null; + } + + private static void lllIlIlIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + LongJump.lIIIIlIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllIIlIlIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/blatant/Speed.java b/module/blatant/Speed.java new file mode 100644 index 0000000..6813f3e --- /dev/null +++ b/module/blatant/Speed.java @@ -0,0 +1,225 @@ +package me.explicit.module.blatant; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import me.explicit.utils.MoveUtils; +import me.explicit.utils.PrivateUtils; +import me.explicit.utils.TimerUtils; + +public class Speed extends Module { + + boolean collided = false; + double stair; + double less; + boolean lessSlow; + public TimerUtils timer = new TimerUtils(); + private TimerUtils lastCheck = new TimerUtils(); + public boolean shouldslow = false; + private double movementSpeed; + private int stage; + private static final String[] lIIlII; + private static String[] lIIlIl; + + public Speed() { + super(Speed.lIIlII[0], 0, Category.BLATANT, Speed.lIIlII[1]); + } + + public void onDisable() { + super.onDisable(); + PrivateUtils.timer().timerSpeed = 1.0F; + } + + public void onEnable() { + super.onEnable(); + boolean flag = Game.Player() == null; + + this.collided = !flag && Game.Player().isCollidedHorizontally; + this.less = 0.0D; + this.lessSlow = false; + if (Game.Player() != null) { + this.movementSpeed = MoveUtils.getBaseMovementSpeed(); + } + + this.shouldslow = false; + } + + private boolean canZoom() { + return MoveUtils.PlayerMoving() && Game.Player().onGround; + } + + public void onUpdate() {} + + public void onMove() { + this.run(); + } + + public void run() { + if (Game.Player().isCollidedHorizontally) { + this.collided = true; + } + + if (this.collided) { + PrivateUtils.timer().timerSpeed = 1.0F; + this.stage = -1; + } + + if (this.stair > 0.0D) { + this.stair -= 0.25D; + } + + this.less -= this.less > 1.0D ? 0.12D : 0.11D; + if (this.less < 0.0D) { + this.less = 0.0D; + } + + if (MoveUtils.isOnGround(0.01D) && MoveUtils.PlayerMoving()) { + this.collided = Game.Player().isCollidedHorizontally; + if (this.stage >= 0 || this.collided) { + this.stage = 0; + double d0 = 0.407D + (double) MoveUtils.getJumpEffect() * 0.1D; + + if (this.stair == 0.0D) { + Game.Player().jump(); + Game.Player().motionY = d0; + } + + ++this.less; + if (this.less > 1.0D && !this.lessSlow) { + this.lessSlow = true; + } else { + this.lessSlow = false; + } + + if (this.less > 1.12D) { + this.less = 1.12D; + } + } + } + + this.movementSpeed = this.getHypixelSpeed(this.stage) + 0.0331D; + this.movementSpeed *= 0.91D; + if (this.stair > 0.0D) { + this.movementSpeed *= 0.7D - (double) MoveUtils.getSpeedEffect() * 0.1D; + } + + if (this.stage < 0) { + this.movementSpeed = MoveUtils.getBaseMovementSpeed(); + } + + if (this.lessSlow) { + this.movementSpeed *= 0.95D; + } + + if (Game.Player().moveForward != 0.0F || Game.Player().moveStrafing != 0.0F) { + MoveUtils.setMoveSpeed(this.movementSpeed); + ++this.stage; + } + + } + + public void onTick() {} + + private double getHypixelSpeed(int i) { + double d0 = MoveUtils.getBaseMovementSpeed() + 0.028D * (double) MoveUtils.getSpeedEffect() + (double) MoveUtils.getSpeedEffect() / 15.0D; + double d1 = 0.4145D + (double) MoveUtils.getSpeedEffect() / 12.5D; + double d2 = (double) i / 500.0D * 2.0D; + + if (i == 0) { + if (this.timer.delay(300.0F)) { + this.timer.reset(); + } + + if (!this.lastCheck.delay(500.0F)) { + if (!this.shouldslow) { + this.shouldslow = true; + } + } else if (this.shouldslow) { + this.shouldslow = false; + } + + d0 = 0.64D + ((double) MoveUtils.getSpeedEffect() + 0.028D * (double) MoveUtils.getSpeedEffect()) * 0.134D; + } else if (i == 1) { + if (PrivateUtils.timer().timerSpeed == 1.354F) { + ; + } + + d0 = d1; + } else if (i >= 2) { + if (PrivateUtils.timer().timerSpeed == 1.254F) { + ; + } + + d0 = d1 - d2; + } + + if (this.shouldslow || !this.lastCheck.delay(500.0F) || this.collided) { + d0 = 0.2D; + if (i == 0) { + d0 = 0.0D; + } + } + + return Math.max(d0, this.shouldslow ? d0 : MoveUtils.getBaseMovementSpeed() + 0.028D * (double) MoveUtils.getSpeedEffect()); + } + + public void setSpeed(double d0) { + Game.Player().motionX = -Math.sin((double) MoveUtils.getDirection()) * d0; + Game.Player().motionZ = Math.cos((double) MoveUtils.getDirection()) * d0; + } + + static { + lllllIl(); + lllllII(); + } + + private static void lllllII() { + lIIlII = new String[2]; + Speed.lIIlII[0] = llllIlI(Speed.lIIlIl[0], Speed.lIIlIl[1]); + Speed.lIIlII[1] = llllIll(Speed.lIIlIl[2], Speed.lIIlIl[3]); + Speed.lIIlIl = null; + } + + private static void lllllIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Speed.lIIlIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llllIll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llllIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/blatant/TriggerBot.java b/module/blatant/TriggerBot.java new file mode 100644 index 0000000..ce327d5 --- /dev/null +++ b/module/blatant/TriggerBot.java @@ -0,0 +1,315 @@ +package me.explicit.module.blatant; + +import java.lang.reflect.Field; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.Random; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.item.ItemAxe; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemFood; +import net.minecraft.item.ItemPotion; +import net.minecraft.item.ItemSword; +import net.minecraftforge.client.event.MouseEvent; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent; +import org.lwjgl.input.Mouse; + +public class TriggerBot extends Module { + + public double minLeft; + public double maxLeft; + public double jitterLeft; + public boolean sword; + public boolean axe; + private long time1Left; + private long timeLeft; + private long time2Left; + private long time3Left; + private double time4Left; + private boolean shouldLeft; + private static Field buttonstate; + private static Field button; + private static Field buttons; + private Random rando = new Random(); + private static final String[] lIlIllIl; + private static String[] lIlIllll; + + public TriggerBot() { + super(TriggerBot.lIlIllIl[0], TriggerBot.lIlIllIl[1], Category.BLATANT); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(TriggerBot.lIlIllIl[2], this, 8.0D, 1.0D, 20.0D, false)); + Explicit.instance.sm.rSetting(new Setting(TriggerBot.lIlIllIl[3], this, 12.0D, 1.0D, 20.0D, false)); + Explicit.instance.sm.rSetting(new Setting(TriggerBot.lIlIllIl[4], this, 0.0D, 0.0D, 4.0D, false)); + Explicit.instance.sm.rSetting(new Setting(TriggerBot.lIlIllIl[5], this, false)); + Explicit.instance.sm.rSetting(new Setting(TriggerBot.lIlIllIl[6], this, false)); + } + + public void onUpdateNoToggle() { + this.minLeft = Explicit.instance.sm.getSettingByName(this, TriggerBot.lIlIllIl[7]).getValDouble(); + this.maxLeft = Explicit.instance.sm.getSettingByName(this, TriggerBot.lIlIllIl[8]).getValDouble(); + this.jitterLeft = Explicit.instance.sm.getSettingByName(this, TriggerBot.lIlIllIl[9]).getValDouble(); + this.sword = Explicit.instance.sm.getSettingByName(this, TriggerBot.lIlIllIl[10]).getValBoolean(); + this.axe = Explicit.instance.sm.getSettingByName(this, TriggerBot.lIlIllIl[11]).getValBoolean(); + } + + @SubscribeEvent + public void tick(RenderTickEvent rendertickevent) { + if (Game.World() != null && Game.Player() != null) { + boolean flag = false; + + if (Game.Player().getCurrentEquippedItem() != null && (Game.Player().getCurrentEquippedItem().getItem() instanceof ItemBow || Game.Player().getCurrentEquippedItem().getItem() instanceof ItemFood || Game.Player().getCurrentEquippedItem().getItem() instanceof ItemPotion)) { + flag = true; + } + + if (!flag && TriggerBot.mc.currentScreen == null && TriggerBot.mc.objectMouseOver != null && TriggerBot.mc.objectMouseOver.entityHit != null && CombatUtils.canTarget(TriggerBot.mc.objectMouseOver.entityHit, true)) { + Mouse.poll(); + this.clickLeft(); + } else { + this.time1Left = 0L; + this.timeLeft = 0L; + KeyBinding.setKeyBindState(TriggerBot.mc.gameSettings.keyBindAttack.getKeyCode(), Mouse.isButtonDown(0)); + } + } else { + this.time1Left = 0L; + this.timeLeft = 0L; + } + } + + public void clickLeft() { + if (TriggerBot.mc.inGameHasFocus) { + if (this.sword || this.axe) { + if (Game.Player().getCurrentEquippedItem() == null) { + return; + } + + if (this.sword && !this.axe && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemSword)) { + return; + } + + if (!this.sword && this.axe && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemAxe)) { + return; + } + + if (this.sword && this.axe && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemAxe) && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemSword)) { + return; + } + } + + if (this.jitterLeft > 0.0D) { + double d0 = this.jitterLeft * 0.5D; + EntityPlayerSP entityplayersp; + + if (this.rando.nextBoolean()) { + entityplayersp = Game.Player(); + entityplayersp.rotationYaw += (float) ((double) this.rando.nextFloat() * d0); + } else { + entityplayersp = Game.Player(); + entityplayersp.rotationYaw -= (float) ((double) this.rando.nextFloat() * d0); + } + + if (this.rando.nextBoolean()) { + entityplayersp = Game.Player(); + entityplayersp.rotationPitch += (float) ((double) this.rando.nextFloat() * d0 * 0.45D); + } else { + entityplayersp = Game.Player(); + entityplayersp.rotationPitch -= (float) ((double) this.rando.nextFloat() * d0 * 0.45D); + } + } + + if (this.timeLeft > 0L && this.time1Left > 0L) { + int i; + + if (System.currentTimeMillis() > this.timeLeft) { + i = TriggerBot.mc.gameSettings.keyBindAttack.getKeyCode(); + KeyBinding.setKeyBindState(i, true); + KeyBinding.onTick(i); + pushEvent(0, true); + this.getELeft(); + } else if (System.currentTimeMillis() > this.time1Left) { + i = TriggerBot.mc.gameSettings.keyBindAttack.getKeyCode(); + KeyBinding.setKeyBindState(i, false); + pushEvent(0, false); + } + } else { + this.getELeft(); + } + + } + } + + public void getELeft() { + double d0 = this.minLeft + this.rando.nextDouble() * (this.maxLeft - this.minLeft); + long i = (long) ((int) Math.round(1000.0D / d0) - (int) (Math.round(1000.0D / d0) / 1000L)); + + if (System.currentTimeMillis() > this.time2Left) { + if (!this.shouldLeft && this.rando.nextInt(100) >= 85) { + this.shouldLeft = true; + this.time4Left = 1.1D + this.rando.nextDouble() * 0.15D; + } else { + this.shouldLeft = false; + } + + this.time2Left = System.currentTimeMillis() + 400L + (long) this.rando.nextInt(1500); + } + + if (this.shouldLeft) { + i *= (long) this.time4Left; + } + + if (System.currentTimeMillis() > this.time3Left) { + if (this.rando.nextInt(100) >= 80) { + i += 50L + (long) this.rando.nextInt(100); + } + + this.time3Left = System.currentTimeMillis() + 450L + (long) this.rando.nextInt(100); + } + + this.timeLeft = System.currentTimeMillis() + i; + this.time1Left = System.currentTimeMillis() + i / 2L - (long) this.rando.nextInt(8); + } + + public static void pushEvent(int i, boolean flag) { + MouseEvent mouseevent = new MouseEvent(); + + TriggerBot.button.setAccessible(true); + + try { + TriggerBot.button.set(mouseevent, Integer.valueOf(i)); + } catch (IllegalAccessException illegalaccessexception) { + illegalaccessexception.printStackTrace(); + } + + TriggerBot.button.setAccessible(false); + TriggerBot.buttonstate.setAccessible(true); + + try { + TriggerBot.buttonstate.set(mouseevent, Boolean.valueOf(flag)); + } catch (IllegalAccessException illegalaccessexception1) { + illegalaccessexception1.printStackTrace(); + } + + TriggerBot.buttonstate.setAccessible(false); + MinecraftForge.EVENT_BUS.post(mouseevent); + + try { + TriggerBot.buttons.setAccessible(true); + ByteBuffer bytebuffer = (ByteBuffer) TriggerBot.buttons.get((Object) null); + + TriggerBot.buttons.setAccessible(false); + bytebuffer.put(i, (byte) (flag ? 1 : 0)); + } catch (IllegalAccessException illegalaccessexception2) { + illegalaccessexception2.printStackTrace(); + } + + } + + static { + lIIlllIIIl(); + lIIlllIIII(); + + try { + TriggerBot.button = MouseEvent.class.getDeclaredField(TriggerBot.lIlIllIl[12]); + } catch (NoSuchFieldException nosuchfieldexception) { + nosuchfieldexception.printStackTrace(); + } + + try { + TriggerBot.buttonstate = MouseEvent.class.getDeclaredField(TriggerBot.lIlIllIl[13]); + } catch (NoSuchFieldException nosuchfieldexception1) { + nosuchfieldexception1.printStackTrace(); + } + + try { + TriggerBot.buttons = Mouse.class.getDeclaredField(TriggerBot.lIlIllIl[14]); + } catch (NoSuchFieldException nosuchfieldexception2) { + nosuchfieldexception2.printStackTrace(); + } + + } + + private static void lIIlllIIII() { + lIlIllIl = new String[15]; + TriggerBot.lIlIllIl[0] = lIIllIllII(TriggerBot.lIlIllll[0], TriggerBot.lIlIllll[1]); + TriggerBot.lIlIllIl[1] = lIIllIllIl(TriggerBot.lIlIllll[2], TriggerBot.lIlIllll[3]); + TriggerBot.lIlIllIl[2] = lIIllIllII(TriggerBot.lIlIllll[4], TriggerBot.lIlIllll[5]); + TriggerBot.lIlIllIl[3] = lIIllIllII(TriggerBot.lIlIllll[6], TriggerBot.lIlIllll[7]); + TriggerBot.lIlIllIl[4] = lIIllIllIl(TriggerBot.lIlIllll[8], TriggerBot.lIlIllll[9]); + TriggerBot.lIlIllIl[5] = lIIllIllII(TriggerBot.lIlIllll[10], TriggerBot.lIlIllll[11]); + TriggerBot.lIlIllIl[6] = lIIllIllIl(TriggerBot.lIlIllll[12], TriggerBot.lIlIllll[13]); + TriggerBot.lIlIllIl[7] = lIIllIlllI(TriggerBot.lIlIllll[14], TriggerBot.lIlIllll[15]); + TriggerBot.lIlIllIl[8] = lIIllIlllI(TriggerBot.lIlIllll[16], TriggerBot.lIlIllll[17]); + TriggerBot.lIlIllIl[9] = lIIllIllII(TriggerBot.lIlIllll[18], TriggerBot.lIlIllll[19]); + TriggerBot.lIlIllIl[10] = lIIllIllII(TriggerBot.lIlIllll[20], TriggerBot.lIlIllll[21]); + TriggerBot.lIlIllIl[11] = lIIllIllII(TriggerBot.lIlIllll[22], TriggerBot.lIlIllll[23]); + TriggerBot.lIlIllIl[12] = lIIllIlllI(TriggerBot.lIlIllll[24], TriggerBot.lIlIllll[25]); + TriggerBot.lIlIllIl[13] = lIIllIllIl(TriggerBot.lIlIllll[26], TriggerBot.lIlIllll[27]); + TriggerBot.lIlIllIl[14] = lIIllIllIl(TriggerBot.lIlIllll[28], TriggerBot.lIlIllll[29]); + TriggerBot.lIlIllll = null; + } + + private static void lIIlllIIIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + TriggerBot.lIlIllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIllIlllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIllIllII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIllIllIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/combat/AimAssist.java b/module/combat/AimAssist.java new file mode 100644 index 0000000..f0c8a8a --- /dev/null +++ b/module/combat/AimAssist.java @@ -0,0 +1,288 @@ +package me.explicit.module.combat; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import me.explicit.utils.RotationUtils; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemAxe; +import net.minecraft.item.ItemSword; +import net.minecraft.util.MathHelper; +import org.lwjgl.input.Keyboard; +import org.lwjgl.input.Mouse; + +public class AimAssist extends Module { + + private float a; + private float b; + private float c; + private float h; + private boolean d; + private boolean e; + private boolean f; + private boolean g; + private boolean i; + private boolean j; + private boolean k; + private static final String[] lIlIIIIII; + private static String[] lIlIIIIIl; + + public AimAssist() { + super(AimAssist.lIlIIIIII[0], 0, Category.COMBAT, AimAssist.lIlIIIIII[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[2], this, 50.0D, 10.0D, 250.0D, true)); + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[3], this, 50.0D, 10.0D, 250.0D, true)); + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[4], this, 90.0D, 15.0D, 360.0D, true)); + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[5], this, 4.2D, 1.0D, 10.0D, false)); + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[6], this, true)); + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[7], this, true)); + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[8], this, true)); + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[9], this, false)); + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[10], this, false)); + Explicit.instance.sm.rSetting(new Setting(AimAssist.lIlIIIIII[11], this, false)); + } + + public void onUpdateNoToggle() { + this.a = (float) Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[12]).getValDouble(); + this.h = (float) Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[13]).getValDouble(); + this.b = (float) Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[14]).getValDouble(); + this.c = (float) Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[15]).getValDouble(); + this.d = Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[16]).getValBoolean(); + this.e = Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[17]).getValBoolean(); + this.g = Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[18]).getValBoolean(); + this.i = Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[19]).getValBoolean(); + this.j = Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[20]).getValBoolean(); + this.k = Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[21]).getValBoolean(); + Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[22]).setVisible(this.i && !this.g); + Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[23]).setVisible(!this.g); + Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[24]).setVisible(!this.g); + Explicit.instance.sm.getSettingByName(this, AimAssist.lIlIIIIII[25]).setVisible(!this.g); + } + + private boolean isKeyDown(int i) { + return i < 0 ? Mouse.isButtonDown(i + 100) : Keyboard.isKeyDown(i); + } + + public void onUpdate() { + if (AimAssist.mc.currentScreen == null && (!this.j || !this.isKeyDown(AimAssist.mc.gameSettings.keyBindAttack.getKeyCode()) || AimAssist.mc.objectMouseOver == null || AimAssist.mc.objectMouseOver.getBlockPos() == null || AimAssist.mc.theWorld.isAirBlock(AimAssist.mc.objectMouseOver.getBlockPos()))) { + if (Game.Player() != null && (!this.k || Game.Player().isSprinting())) { + if (this.e) { + if (Game.Player().getCurrentEquippedItem() == null) { + return; + } + + if (!(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemSword) && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemAxe)) { + return; + } + } + + if (!this.d || Mouse.isButtonDown(0)) { + Entity entity = this.ent(); + + if (!this.g) { + if (entity != null && (getY(entity) > 1.0D || getY(entity) < -1.0D)) { + boolean flag = getY(entity) > 0.0D; + EntityPlayerSP entityplayersp = Game.Player(); + + entityplayersp.rotationYaw += (float) (flag ? -(Math.abs(getY(entity)) / (double) this.a) : Math.abs(getY(entity)) / (double) this.a); + float[] afloat = RotationUtils.getRotations(entity); + + if (afloat[1] < -2.0F || afloat[1] > 2.0F && this.i) { + float f = afloat[1] - entityplayersp.rotationPitch; + + entityplayersp.rotationPitch = (float) ((double) entityplayersp.rotationPitch + (double) f / ((double) this.h + ThreadLocalRandom.current().nextDouble())); + } + } + } else { + blatant(entity); + } + + } + } + } + } + + public Entity ent() { + Entity entity = null; + int i = (int) this.b; + Iterator iterator = Game.World().loadedEntityList.iterator(); + + while (iterator.hasNext()) { + Object object = iterator.next(); + Entity entity1 = (Entity) object; + + if (entity1.isEntityAlive() && entity1 != Game.Player() && Game.Player().getDistanceToEntity(entity1) <= this.c && CombatUtils.canTarget(entity1, true)) { + if (!this.g) { + if (can(entity1, (float) i)) { + entity = entity1; + i = (int) getY(entity1); + } + } else { + entity = entity1; + i = (int) getY(entity1); + } + } + } + + return entity; + } + + public static float yaw(Entity entity) { + double d0 = entity.posX - Game.Player().posX; + double d1 = entity.posY - Game.Player().posY; + double d2 = entity.posZ - Game.Player().posZ; + double d3 = Math.atan2(d0, d2) * 57.2957795D; + + d3 = -d3; + double d4 = Math.asin(d1 / Math.sqrt(d0 * d0 + d1 * d1 + d2 * d2)) * 57.2957795D; + + d4 = -d4; + return (float) d3; + } + + public static double getY(Entity entity) { + return ((double) (Game.Player().rotationYaw - yaw(entity)) % 360.0D + 540.0D) % 360.0D - 180.0D; + } + + public static boolean can(Entity entity, float f) { + f = (float) ((double) f * 0.5D); + double d0 = ((double) (Game.Player().rotationYaw - yaw(entity)) % 360.0D + 540.0D) % 360.0D - 180.0D; + + return d0 > 0.0D && d0 < (double) f || (double) (-f) < d0 && d0 < 0.0D; + } + + public static float[] rots(Entity entity) { + if (entity == null) { + return null; + } else { + double d0 = entity.posX - Game.Player().posX; + double d1; + + if (entity instanceof EntityLivingBase) { + EntityLivingBase entitylivingbase = (EntityLivingBase) entity; + + d1 = entitylivingbase.posY + (double) entitylivingbase.getEyeHeight() * 0.9D - (Game.Player().posY + (double) Game.Player().getEyeHeight()); + } else { + d1 = (entity.getEntityBoundingBox().minY + entity.getEntityBoundingBox().minY) / 2.0D - (Game.Player().posY + (double) Game.Player().getEyeHeight()); + } + + double d2 = entity.posZ - Game.Player().posZ; + double d3 = (double) MathHelper.sqrt_double(d0 * d0 + d2 * d2); + float f = (float) (Math.atan2(d2, d0) * 180.0D / 3.141592653589793D) - 90.0F; + float f1 = (float) (-(Math.atan2(d1, d3) * 180.0D / 3.141592653589793D)); + + return new float[] { Game.Player().rotationYaw + MathHelper.wrapAngleTo180_float(f - Game.Player().rotationYaw), Game.Player().rotationPitch + MathHelper.wrapAngleTo180_float(f1 - Game.Player().rotationPitch)}; + } + } + + public static void blatant(Entity entity) { + float[] afloat = rots(entity); + + if (afloat != null) { + Game.Player().rotationYaw = afloat[0]; + Game.Player().rotationPitch = afloat[1] + 4.0F; + } + + } + + static { + lIIIllIIIII(); + lIIIlIlllll(); + } + + private static void lIIIlIlllll() { + lIlIIIIII = new String[26]; + AimAssist.lIlIIIIII[0] = lIIIlIlllII(AimAssist.lIlIIIIIl[0], AimAssist.lIlIIIIIl[1]); + AimAssist.lIlIIIIII[1] = lIIIlIlllII(AimAssist.lIlIIIIIl[2], AimAssist.lIlIIIIIl[3]); + AimAssist.lIlIIIIII[2] = lIIIlIlllIl(AimAssist.lIlIIIIIl[4], AimAssist.lIlIIIIIl[5]); + AimAssist.lIlIIIIII[3] = lIIIlIlllII(AimAssist.lIlIIIIIl[6], AimAssist.lIlIIIIIl[7]); + AimAssist.lIlIIIIII[4] = lIIIlIlllIl(AimAssist.lIlIIIIIl[8], AimAssist.lIlIIIIIl[9]); + AimAssist.lIlIIIIII[5] = lIIIlIlllIl(AimAssist.lIlIIIIIl[10], AimAssist.lIlIIIIIl[11]); + AimAssist.lIlIIIIII[6] = lIIIlIllllI(AimAssist.lIlIIIIIl[12], AimAssist.lIlIIIIIl[13]); + AimAssist.lIlIIIIII[7] = lIIIlIllllI(AimAssist.lIlIIIIIl[14], AimAssist.lIlIIIIIl[15]); + AimAssist.lIlIIIIII[8] = lIIIlIlllII(AimAssist.lIlIIIIIl[16], AimAssist.lIlIIIIIl[17]); + AimAssist.lIlIIIIII[9] = lIIIlIllllI(AimAssist.lIlIIIIIl[18], AimAssist.lIlIIIIIl[19]); + AimAssist.lIlIIIIII[10] = lIIIlIlllII(AimAssist.lIlIIIIIl[20], AimAssist.lIlIIIIIl[21]); + AimAssist.lIlIIIIII[11] = lIIIlIllllI(AimAssist.lIlIIIIIl[22], AimAssist.lIlIIIIIl[23]); + AimAssist.lIlIIIIII[12] = lIIIlIlllIl(AimAssist.lIlIIIIIl[24], AimAssist.lIlIIIIIl[25]); + AimAssist.lIlIIIIII[13] = lIIIlIlllII(AimAssist.lIlIIIIIl[26], AimAssist.lIlIIIIIl[27]); + AimAssist.lIlIIIIII[14] = lIIIlIllllI(AimAssist.lIlIIIIIl[28], AimAssist.lIlIIIIIl[29]); + AimAssist.lIlIIIIII[15] = lIIIlIlllIl(AimAssist.lIlIIIIIl[30], AimAssist.lIlIIIIIl[31]); + AimAssist.lIlIIIIII[16] = lIIIlIlllIl(AimAssist.lIlIIIIIl[32], AimAssist.lIlIIIIIl[33]); + AimAssist.lIlIIIIII[17] = lIIIlIlllII(AimAssist.lIlIIIIIl[34], AimAssist.lIlIIIIIl[35]); + AimAssist.lIlIIIIII[18] = lIIIlIllllI(AimAssist.lIlIIIIIl[36], AimAssist.lIlIIIIIl[37]); + AimAssist.lIlIIIIII[19] = lIIIlIllllI(AimAssist.lIlIIIIIl[38], AimAssist.lIlIIIIIl[39]); + AimAssist.lIlIIIIII[20] = lIIIlIlllII(AimAssist.lIlIIIIIl[40], AimAssist.lIlIIIIIl[41]); + AimAssist.lIlIIIIII[21] = lIIIlIllllI("GBMwKio/LCwvPQ==", "KcBCD"); + AimAssist.lIlIIIIII[22] = lIIIlIllllI("GjQpKT8o", "LgYLZ"); + AimAssist.lIlIIIIII[23] = lIIIlIlllII("XhjAnpGkac8=", "hHcnw"); + AimAssist.lIlIIIIII[24] = lIIIlIllllI("KSsV", "odCsH"); + AimAssist.lIlIIIIII[25] = lIIIlIlllII("WoY8A1eGVrCoa9715TqsDA==", "UvvtG"); + AimAssist.lIlIIIIIl = null; + } + + private static void lIIIllIIIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AimAssist.lIlIIIIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIlIlllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIlIllllI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIlIlllII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/combat/AntiBot.java b/module/combat/AntiBot.java new file mode 100644 index 0000000..ba408e9 --- /dev/null +++ b/module/combat/AntiBot.java @@ -0,0 +1,246 @@ +package me.explicit.module.combat; + +import com.google.common.collect.Ordering; +import java.lang.reflect.Field; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.gui.GuiPlayerTabOverlay; +import net.minecraft.client.network.NetHandlerPlayClient; +import net.minecraft.client.network.NetworkPlayerInfo; +import net.minecraft.entity.player.EntityPlayer; + +public class AntiBot extends Module { + + private TimerUtils notificationTimer = new TimerUtils(); + private TimerUtils resetTimer = new TimerUtils(); + private int botsFound; + private static List bots; + String mode; + private static final String[] llIIIlII; + private static String[] llIIIlIl; + + public AntiBot() { + super(AntiBot.llIIIlII[0], 0, Category.COMBAT, AntiBot.llIIIlII[1]); + } + + public void setup() { + ArrayList arraylist; + + (arraylist = new ArrayList()).add(AntiBot.llIIIlII[2]); + arraylist.add(AntiBot.llIIIlII[3]); + Explicit.instance.sm.rSetting(new Setting(AntiBot.llIIIlII[4], this, AntiBot.llIIIlII[5], arraylist)); + } + + public void onUpdate() { + if (this.resetTimer.hasReached(20000.0D)) { + AntiBot.bots.clear(); + this.resetTimer.reset(); + } + + this.mode = Explicit.instance.sm.getSettingByName(this, AntiBot.llIIIlII[6]).getValString(); + if (this.botsFound > 0 && this.notificationTimer.hasReached(1000.0D)) { + this.notificationTimer.reset(); + this.botsFound = 0; + } + + if (AntiBot.mc.thePlayer.ticksExisted <= 0) { + this.notificationTimer.reset(); + this.botsFound = 0; + AntiBot.bots.clear(); + } + + Iterator iterator; + Object object; + EntityPlayer entityplayer; + + if (this.mode.equalsIgnoreCase(AntiBot.llIIIlII[7])) { + iterator = Module.mc.theWorld.playerEntities.iterator(); + + while (iterator.hasNext()) { + object = iterator.next(); + if (object instanceof EntityPlayer) { + entityplayer = (EntityPlayer) object; + if (entityplayer.ticksExisted < 2 && entityplayer.getHealth() < 20.0F && entityplayer.getHealth() > 0.0F && entityplayer != Module.mc.thePlayer) { + this.add(entityplayer, false); + ++this.botsFound; + } + } + } + } else if (this.mode.equalsIgnoreCase(AntiBot.llIIIlII[8])) { + iterator = AntiBot.mc.theWorld.getLoadedEntityList().iterator(); + + while (iterator.hasNext()) { + object = iterator.next(); + if (object instanceof EntityPlayer && object != AntiBot.mc.thePlayer && !AntiBot.bots.contains(object)) { + entityplayer = (EntityPlayer) object; + String s = entityplayer.getDisplayName().getFormattedText(); + String s1 = entityplayer.getCustomNameTag(); + String s2 = entityplayer.getName(); + boolean flag = false; + + if (this.getTabPlayerList() != null && !this.getTabPlayerList().contains(entityplayer)) { + this.add(entityplayer, false); + flag = true; + } + + if (s.contains(AntiBot.llIIIlII[9]) && entityplayer != AntiBot.mc.thePlayer) { + this.add(entityplayer, false); + flag = true; + } + + if (s1.equalsIgnoreCase(s2) && entityplayer.getMaxHealth() == 20.0F && (this.getTabPlayerList() == null || !this.getTabPlayerList().contains(entityplayer)) && s.contains(AntiBot.llIIIlII[10]) && s.contains(AntiBot.llIIIlII[11])) { + this.add(entityplayer, true); + flag = true; + } + } + } + } + + } + + public void add(EntityPlayer entityplayer, boolean flag) { + if (!AntiBot.bots.contains(entityplayer)) { + ++this.botsFound; + AntiBot.bots.add(entityplayer); + } + + } + + public List getTabPlayerList() { + NetHandlerPlayClient nethandlerplayclient = AntiBot.mc.thePlayer.sendQueue; + ArrayList arraylist; + + (arraylist = new ArrayList()).clear(); + Ordering ordering = this.field_175252_a(); + + if (ordering == null) { + return null; + } else { + List list = ordering.sortedCopy(nethandlerplayclient.getPlayerInfoMap()); + Iterator iterator = list.iterator(); + + while (iterator.hasNext()) { + Object object = iterator.next(); + NetworkPlayerInfo networkplayerinfo = (NetworkPlayerInfo) object; + + if (networkplayerinfo != null) { + arraylist.add(AntiBot.mc.theWorld.getPlayerEntityByName(networkplayerinfo.getGameProfile().getName())); + } + } + + return arraylist; + } + } + + public Ordering field_175252_a() { + try { + Class oclass = GuiPlayerTabOverlay.class; + Field field = oclass.getDeclaredField(AntiBot.llIIIlII[12]); + + field.setAccessible(true); + return (Ordering) field.get(GuiPlayerTabOverlay.class); + } catch (Exception exception) { + return null; + } + } + + public void onEnable() { + super.onEnable(); + AntiBot.bots.clear(); + } + + public void onDisable() { + super.onDisable(); + AntiBot.bots.clear(); + } + + public static List getBots() { + return AntiBot.bots; + } + + static { + lIllIlIIlI(); + lIllIlIIIl(); + AntiBot.bots = new ArrayList(); + } + + private static void lIllIlIIIl() { + llIIIlII = new String[13]; + AntiBot.llIIIlII[0] = lIllIIlllI(AntiBot.llIIIlIl[0], AntiBot.llIIIlIl[1]); + AntiBot.llIIIlII[1] = lIllIIllll(AntiBot.llIIIlIl[2], AntiBot.llIIIlIl[3]); + AntiBot.llIIIlII[2] = lIllIlIIII(AntiBot.llIIIlIl[4], AntiBot.llIIIlIl[5]); + AntiBot.llIIIlII[3] = lIllIlIIII(AntiBot.llIIIlIl[6], AntiBot.llIIIlIl[7]); + AntiBot.llIIIlII[4] = lIllIIllll(AntiBot.llIIIlIl[8], AntiBot.llIIIlIl[9]); + AntiBot.llIIIlII[5] = lIllIIlllI(AntiBot.llIIIlIl[10], AntiBot.llIIIlIl[11]); + AntiBot.llIIIlII[6] = lIllIlIIII(AntiBot.llIIIlIl[12], AntiBot.llIIIlIl[13]); + AntiBot.llIIIlII[7] = lIllIIllll(AntiBot.llIIIlIl[14], AntiBot.llIIIlIl[15]); + AntiBot.llIIIlII[8] = lIllIIlllI(AntiBot.llIIIlIl[16], AntiBot.llIIIlIl[17]); + AntiBot.llIIIlII[9] = lIllIlIIII(AntiBot.llIIIlIl[18], AntiBot.llIIIlIl[19]); + AntiBot.llIIIlII[10] = lIllIIlllI(AntiBot.llIIIlIl[20], AntiBot.llIIIlIl[21]); + AntiBot.llIIIlII[11] = lIllIIlllI(AntiBot.llIIIlIl[22], AntiBot.llIIIlIl[23]); + AntiBot.llIIIlII[12] = lIllIlIIII(AntiBot.llIIIlIl[24], AntiBot.llIIIlIl[25]); + AntiBot.llIIIlIl = null; + } + + private static void lIllIlIIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AntiBot.llIIIlIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIllIIlllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIllIIllll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIllIlIIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/combat/AutoClicker.java b/module/combat/AutoClicker.java new file mode 100644 index 0000000..d2e8c9a --- /dev/null +++ b/module/combat/AutoClicker.java @@ -0,0 +1,488 @@ +package me.explicit.module.combat; + +import io.netty.util.internal.ThreadLocalRandom; +import java.lang.reflect.Field; +import java.nio.ByteBuffer; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.Random; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemAxe; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemFood; +import net.minecraft.item.ItemPotion; +import net.minecraft.item.ItemSword; +import net.minecraft.util.BlockPos; +import net.minecraftforge.client.event.MouseEvent; +import net.minecraftforge.common.MinecraftForge; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent; +import org.lwjgl.input.Mouse; + +public class AutoClicker extends Module { + + public double minLeft; + public double maxLeft; + public double minBlock; + public double maxBlock; + public double jitterLeft; + public double jitterRight; + public double breakDelay; + public boolean sword; + public boolean axe; + public boolean blocks; + public boolean rightClick; + public boolean blockHit; + public boolean noShift; + private long time1Left; + private long timeLeft; + private long time2Left; + private long time3Left; + private double time4Left; + private boolean shouldLeft; + private long time1Right; + private long timeRight; + private long time2Right; + private long time3Right; + private double time4Right; + private boolean shouldRight; + private static Field buttonstate; + private static Field button; + private static Field buttons; + private Random rando = new Random(); + private TimerUtils breaktimer = new TimerUtils(); + private TimerUtils unbreaktimer = new TimerUtils(); + private boolean isBreaking = false; + private boolean wasBreaking = false; + private static final String[] lllllIlI; + private static String[] lIIIIIIlI; + + public AutoClicker() { + super(AutoClicker.lllllIlI[0], 0, Category.COMBAT, AutoClicker.lllllIlI[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[2], this, 8.0D, 1.0D, 20.0D, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[3], this, 12.0D, 1.0D, 20.0D, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[4], this, 3.0D, 1.0D, 10.0D, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[5], this, 5.0D, 1.0D, 10.0D, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[6], this, 0.0D, 0.0D, 4.0D, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[7], this, 0.0D, 0.0D, 4.0D, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[8], this, 25.0D, 0.0D, 500.0D, true)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[9], this, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[10], this, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[11], this, true)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[12], this, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[13], this, false)); + Explicit.instance.sm.rSetting(new Setting(AutoClicker.lllllIlI[14], this, false)); + } + + public void onEnable() { + super.onEnable(); + } + + public void onTick() {} + + public void onUpdateNoToggle() { + this.minLeft = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[15]).getValDouble(); + this.maxLeft = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[16]).getValDouble(); + this.jitterLeft = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[17]).getValDouble(); + this.jitterRight = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[18]).getValDouble(); + this.sword = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[19]).getValBoolean(); + this.axe = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[20]).getValBoolean(); + this.blocks = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[21]).getValBoolean(); + this.rightClick = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[22]).getValBoolean(); + this.blockHit = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[23]).getValBoolean(); + this.noShift = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[24]).getValBoolean(); + this.minBlock = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[25]).getValDouble(); + this.maxBlock = Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[26]).getValDouble(); + this.breakDelay = (double) ((int) Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[27]).getValDouble()); + Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[28]).setVisible(this.blocks); + Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[29]).setVisible(this.rightClick); + Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[30]).setVisible(this.rightClick); + Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[31]).setVisible(this.blockHit && this.rightClick); + Explicit.instance.sm.getSettingByName(this, AutoClicker.lllllIlI[32]).setVisible(this.blockHit && this.rightClick); + } + + @SubscribeEvent + public void tick(RenderTickEvent rendertickevent) { + boolean flag = false; + + if (Game.World() != null && Game.Player() != null) { + if (Game.Player().getCurrentEquippedItem() != null && (Game.Player().getCurrentEquippedItem().getItem() instanceof ItemBow || Game.Player().getCurrentEquippedItem().getItem() instanceof ItemFood || Game.Player().getCurrentEquippedItem().getItem() instanceof ItemPotion)) { + flag = true; + } + + if (AutoClicker.mc.currentScreen == null && (!AutoClicker.mc.gameSettings.keyBindSneak.isKeyDown() || !this.noShift)) { + Mouse.poll(); + if (Mouse.isButtonDown(0)) { + this.clickLeft(); + } else { + this.time1Left = 0L; + this.timeLeft = 0L; + } + + Mouse.poll(); + if (Mouse.isButtonDown(1) && this.rightClick && !flag && (this.blockHit || !Mouse.isButtonDown(0))) { + this.clickRight(); + } else { + this.time1Right = 0L; + this.timeRight = 0L; + } + + this.wasBreaking = this.isBreaking; + } + } + } + + public void clickLeft() { + if (AutoClicker.mc.inGameHasFocus) { + if (this.sword || this.axe) { + if (Game.Player().getCurrentEquippedItem() == null) { + return; + } + + if (this.sword && !this.axe && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemSword)) { + return; + } + + if (!this.sword && this.axe && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemAxe)) { + return; + } + + if (this.sword && this.axe && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemAxe) && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemSword)) { + return; + } + } + + this.isBreaking = false; + if (this.blocks && AutoClicker.mc.objectMouseOver != null) { + BlockPos blockpos = AutoClicker.mc.objectMouseOver.getBlockPos(); + + if (blockpos != null && Game.World().getBlockState(blockpos).getBlock() != Blocks.air) { + if (this.breaktimer.hasReached(this.breakDelay + ThreadLocalRandom.current().nextDouble(-5.0D, 5.0D))) { + int i = AutoClicker.mc.gameSettings.keyBindAttack.getKeyCode(); + + KeyBinding.setKeyBindState(i, true); + KeyBinding.onTick(i); + } + + this.isBreaking = true; + this.wasBreaking = true; + return; + } + } + + this.breaktimer.reset(); + if (this.jitterLeft > 0.0D) { + double d0 = this.jitterLeft * 0.5D; + EntityPlayerSP entityplayersp; + + if (this.rando.nextBoolean()) { + entityplayersp = Game.Player(); + entityplayersp.rotationYaw += (float) ((double) this.rando.nextFloat() * d0); + } else { + entityplayersp = Game.Player(); + entityplayersp.rotationYaw -= (float) ((double) this.rando.nextFloat() * d0); + } + + if (this.rando.nextBoolean()) { + entityplayersp = Game.Player(); + entityplayersp.rotationPitch += (float) ((double) this.rando.nextFloat() * d0 * 0.45D); + } else { + entityplayersp = Game.Player(); + entityplayersp.rotationPitch -= (float) ((double) this.rando.nextFloat() * d0 * 0.45D); + } + } + + if (this.timeLeft > 0L && this.time1Left > 0L) { + int j; + + if (System.currentTimeMillis() > this.timeLeft) { + j = AutoClicker.mc.gameSettings.keyBindAttack.getKeyCode(); + KeyBinding.setKeyBindState(j, true); + KeyBinding.onTick(j); + pushEvent(0, true); + this.getELeft(); + } else if (System.currentTimeMillis() > this.time1Left) { + j = AutoClicker.mc.gameSettings.keyBindAttack.getKeyCode(); + KeyBinding.setKeyBindState(j, false); + pushEvent(0, false); + } + } else { + this.getELeft(); + } + + } + } + + public void clickRight() { + if (AutoClicker.mc.inGameHasFocus) { + if (this.jitterRight > 0.0D) { + double d0 = this.jitterRight * 0.5D; + EntityPlayerSP entityplayersp; + + if (this.rando.nextBoolean()) { + entityplayersp = Game.Player(); + entityplayersp.rotationYaw += (float) ((double) this.rando.nextFloat() * d0); + } else { + entityplayersp = Game.Player(); + entityplayersp.rotationYaw -= (float) ((double) this.rando.nextFloat() * d0); + } + + if (this.rando.nextBoolean()) { + entityplayersp = Game.Player(); + entityplayersp.rotationPitch += (float) ((double) this.rando.nextFloat() * d0 * 0.45D); + } else { + entityplayersp = Game.Player(); + entityplayersp.rotationPitch -= (float) ((double) this.rando.nextFloat() * d0 * 0.45D); + } + } + + if (this.timeRight > 0L && this.time1Right > 0L) { + int i; + + if (System.currentTimeMillis() > this.timeRight && !AutoClicker.mc.gameSettings.keyBindAttack.isKeyDown()) { + i = AutoClicker.mc.gameSettings.keyBindUseItem.getKeyCode(); + KeyBinding.setKeyBindState(i, true); + KeyBinding.onTick(i); + pushEvent(1, true); + this.getERight(); + } else if (System.currentTimeMillis() > this.time1Right || AutoClicker.mc.gameSettings.keyBindAttack.isKeyDown()) { + i = AutoClicker.mc.gameSettings.keyBindUseItem.getKeyCode(); + KeyBinding.setKeyBindState(i, false); + pushEvent(1, false); + } + } else { + this.getERight(); + } + + } + } + + public void getELeft() { + double d0 = this.minLeft + this.rando.nextDouble() * (this.maxLeft - this.minLeft); + long i = (long) ((int) Math.round(1000.0D / d0) - (int) (Math.round(1000.0D / d0) / 1000L)); + + if (System.currentTimeMillis() > this.time2Left) { + if (!this.shouldLeft && this.rando.nextInt(100) >= 85) { + this.shouldLeft = true; + this.time4Left = 1.1D + this.rando.nextDouble() * 0.15D; + } else { + this.shouldLeft = false; + } + + this.time2Left = System.currentTimeMillis() + 400L + (long) this.rando.nextInt(1500); + } + + if (this.shouldLeft) { + i *= (long) this.time4Left; + } + + if (System.currentTimeMillis() > this.time3Left) { + if (this.rando.nextInt(100) >= 80) { + i += 50L + (long) this.rando.nextInt(100); + } + + this.time3Left = System.currentTimeMillis() + 450L + (long) this.rando.nextInt(100); + } + + this.timeLeft = System.currentTimeMillis() + i; + this.time1Left = System.currentTimeMillis() + i / 2L - (long) this.rando.nextInt(8); + } + + public void getERight() { + double d0 = this.blockHit ? this.minBlock : this.minLeft; + double d1 = this.blockHit ? this.maxBlock : this.maxLeft; + double d2 = d0 + this.rando.nextDouble() * (d1 - d0); + long i = (long) ((int) Math.round(1000.0D / d2) - (int) (Math.round(1000.0D / d2) / 1000L)); + + if (System.currentTimeMillis() > this.time2Right) { + if (!this.shouldRight && this.rando.nextInt(100) >= 85) { + this.shouldRight = true; + this.time4Right = 1.1D + this.rando.nextDouble() * 0.15D; + } else { + this.shouldRight = false; + } + + this.time2Right = System.currentTimeMillis() + 400L + (long) this.rando.nextInt(1500); + } + + if (this.shouldRight) { + i *= (long) this.time4Right; + } + + if (System.currentTimeMillis() > this.time3Right) { + if (this.rando.nextInt(100) >= 80) { + i += 50L + (long) this.rando.nextInt(100); + } + + this.time3Right = System.currentTimeMillis() + 450L + (long) this.rando.nextInt(100); + } + + this.timeRight = System.currentTimeMillis() + i; + this.time1Right = System.currentTimeMillis() + i / 2L - (long) this.rando.nextInt(8); + } + + public static void pushEvent(int i, boolean flag) { + MouseEvent mouseevent = new MouseEvent(); + + AutoClicker.button.setAccessible(true); + + try { + AutoClicker.button.set(mouseevent, Integer.valueOf(i)); + } catch (IllegalAccessException illegalaccessexception) { + illegalaccessexception.printStackTrace(); + } + + AutoClicker.button.setAccessible(false); + AutoClicker.buttonstate.setAccessible(true); + + try { + AutoClicker.buttonstate.set(mouseevent, Boolean.valueOf(flag)); + } catch (IllegalAccessException illegalaccessexception1) { + illegalaccessexception1.printStackTrace(); + } + + AutoClicker.buttonstate.setAccessible(false); + MinecraftForge.EVENT_BUS.post(mouseevent); + + try { + AutoClicker.buttons.setAccessible(true); + ByteBuffer bytebuffer = (ByteBuffer) AutoClicker.buttons.get((Object) null); + + AutoClicker.buttons.setAccessible(false); + bytebuffer.put(i, (byte) (flag ? 1 : 0)); + } catch (IllegalAccessException illegalaccessexception2) { + illegalaccessexception2.printStackTrace(); + } + + } + + static { + lllIIlIIlI(); + lllIIlIIIl(); + + try { + AutoClicker.button = MouseEvent.class.getDeclaredField(AutoClicker.lllllIlI[33]); + } catch (NoSuchFieldException nosuchfieldexception) { + nosuchfieldexception.printStackTrace(); + } + + try { + AutoClicker.buttonstate = MouseEvent.class.getDeclaredField(AutoClicker.lllllIlI[34]); + } catch (NoSuchFieldException nosuchfieldexception1) { + nosuchfieldexception1.printStackTrace(); + } + + try { + AutoClicker.buttons = Mouse.class.getDeclaredField(AutoClicker.lllllIlI[35]); + } catch (NoSuchFieldException nosuchfieldexception2) { + nosuchfieldexception2.printStackTrace(); + } + + } + + private static void lllIIlIIIl() { + lllllIlI = new String[36]; + AutoClicker.lllllIlI[0] = llIlllllIl(AutoClicker.lIIIIIIlI[0], AutoClicker.lIIIIIIlI[1]); + AutoClicker.lllllIlI[1] = llIlllllll(AutoClicker.lIIIIIIlI[2], AutoClicker.lIIIIIIlI[3]); + AutoClicker.lllllIlI[2] = llIlllllIl(AutoClicker.lIIIIIIlI[4], AutoClicker.lIIIIIIlI[5]); + AutoClicker.lllllIlI[3] = lllIIIIIII(AutoClicker.lIIIIIIlI[6], AutoClicker.lIIIIIIlI[7]); + AutoClicker.lllllIlI[4] = lllIIIIIII(AutoClicker.lIIIIIIlI[8], AutoClicker.lIIIIIIlI[9]); + AutoClicker.lllllIlI[5] = lllIIIIIII(AutoClicker.lIIIIIIlI[10], AutoClicker.lIIIIIIlI[11]); + AutoClicker.lllllIlI[6] = llIlllllIl(AutoClicker.lIIIIIIlI[12], AutoClicker.lIIIIIIlI[13]); + AutoClicker.lllllIlI[7] = llIlllllIl(AutoClicker.lIIIIIIlI[14], AutoClicker.lIIIIIIlI[15]); + AutoClicker.lllllIlI[8] = llIlllllIl(AutoClicker.lIIIIIIlI[16], AutoClicker.lIIIIIIlI[17]); + AutoClicker.lllllIlI[9] = lllIIIIIII(AutoClicker.lIIIIIIlI[18], AutoClicker.lIIIIIIlI[19]); + AutoClicker.lllllIlI[10] = lllIIIIIII(AutoClicker.lIIIIIIlI[20], AutoClicker.lIIIIIIlI[21]); + AutoClicker.lllllIlI[11] = lllIIIIIII(AutoClicker.lIIIIIIlI[22], AutoClicker.lIIIIIIlI[23]); + AutoClicker.lllllIlI[12] = llIlllllIl(AutoClicker.lIIIIIIlI[24], AutoClicker.lIIIIIIlI[25]); + AutoClicker.lllllIlI[13] = lllIIIIIII(AutoClicker.lIIIIIIlI[26], AutoClicker.lIIIIIIlI[27]); + AutoClicker.lllllIlI[14] = lllIIIIIII(AutoClicker.lIIIIIIlI[28], AutoClicker.lIIIIIIlI[29]); + AutoClicker.lllllIlI[15] = llIlllllll(AutoClicker.lIIIIIIlI[30], AutoClicker.lIIIIIIlI[31]); + AutoClicker.lllllIlI[16] = llIlllllIl(AutoClicker.lIIIIIIlI[32], AutoClicker.lIIIIIIlI[33]); + AutoClicker.lllllIlI[17] = llIlllllll(AutoClicker.lIIIIIIlI[34], AutoClicker.lIIIIIIlI[35]); + AutoClicker.lllllIlI[18] = lllIIIIIII(AutoClicker.lIIIIIIlI[36], AutoClicker.lIIIIIIlI[37]); + AutoClicker.lllllIlI[19] = lllIIIIIII("hQlRQHe2RE5/6DYHBUJWYQ==", "GddRK"); + AutoClicker.lllllIlI[20] = llIlllllll("EhAqAjo/EQ==", "ShOMT"); + AutoClicker.lllllIlI[21] = llIlllllll("CTQDLD0JKgkuPTg=", "KFfMV"); + AutoClicker.lllllIlI[22] = llIlllllll("EBAXAzsBFRkIJA==", "BypkO"); + AutoClicker.lllllIlI[23] = llIlllllll("DB4BKy0GGxo=", "NrnHF"); + AutoClicker.lllllIlI[24] = llIlllllIl("0Ff7aulEK3w=", "HFzcE"); + AutoClicker.lllllIlI[25] = llIlllllIl("wimwy/rQQzc=", "vzsst"); + AutoClicker.lllllIlI[26] = lllIIIIIII("n+IYivp8jbw=", "AVGUi"); + AutoClicker.lllllIlI[27] = llIlllllll("DiMMIjEINAUiIw==", "LQiCZ"); + AutoClicker.lllllIlI[28] = llIlllllIl("7ik5Bytyb9tcGIOVc9OlBA==", "gqGwY"); + AutoClicker.lllllIlI[29] = llIlllllIl("Oqf+0aU7mWWG69hcI5YIdQ==", "GcpvA"); + AutoClicker.lllllIlI[30] = llIlllllll("PzsFIBAnOxY8AR8=", "mRbHd"); + AutoClicker.lllllIlI[31] = llIlllllll("DwUKKwIR", "BldiR"); + AutoClicker.lllllIlI[32] = llIlllllll("PigXFBwg", "sIoVL"); + AutoClicker.lllllIlI[33] = llIlllllIl("Jx1i7Yd1BNc=", "KPkkV"); + AutoClicker.lllllIlI[34] = lllIIIIIII("mvFNUxLO+GKAHAWnXP/eLg==", "vRqWs"); + AutoClicker.lllllIlI[35] = llIlllllll("FBY/HQgYEA==", "vcKig"); + AutoClicker.lIIIIIIlI = null; + } + + private static void lllIIlIIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AutoClicker.lIIIIIIlI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllIIIIIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIlllllll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIlllllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/combat/ClickAssist.java b/module/combat/ClickAssist.java new file mode 100644 index 0000000..1ed5c33 --- /dev/null +++ b/module/combat/ClickAssist.java @@ -0,0 +1,166 @@ +package me.explicit.module.combat; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.concurrent.ThreadLocalRandom; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import net.minecraft.client.settings.KeyBinding; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent; +import org.lwjgl.input.Mouse; + +public class ClickAssist extends Module { + + public double minLeft; + public double maxLeft; + private long lastClick; + private long hold; + private double speed; + private double holdLength; + private int averageCPS = 0; + private ArrayList cps = new ArrayList(); + private boolean wasClick = false; + private static final String[] lllIIIII; + private static String[] lllIIIll; + + public ClickAssist() { + super(ClickAssist.lllIIIII[0], ClickAssist.lllIIIII[1], Category.COMBAT); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(ClickAssist.lllIIIII[2], this, 8.0D, 4.0D, 20.0D, false)); + Explicit.instance.sm.rSetting(new Setting(ClickAssist.lllIIIII[3], this, 12.0D, 5.0D, 20.0D, false)); + } + + @SubscribeEvent + public void tick(RenderTickEvent rendertickevent) { + if (ClickAssist.mc.thePlayer != null) { + Mouse.poll(); + this.updateVals(); + if (this.cps.size() > Math.max(4, this.averageCPS) && ThreadLocalRandom.current().nextDouble(this.minLeft - 0.2D, this.maxLeft) > (double) this.cps.size()) { + if ((double) (System.currentTimeMillis() - this.lastClick) > this.speed * 1000.0D) { + this.lastClick = System.currentTimeMillis(); + if (this.hold < this.lastClick) { + this.hold = this.lastClick; + } + + int i = ClickAssist.mc.gameSettings.keyBindAttack.getKeyCode(); + + KeyBinding.setKeyBindState(i, true); + KeyBinding.onTick(i); + this.updateVals(); + } else if ((double) (System.currentTimeMillis() - this.hold) > this.holdLength * 1000.0D) { + KeyBinding.setKeyBindState(ClickAssist.mc.gameSettings.keyBindAttack.getKeyCode(), false); + this.updateVals(); + } + } + + } + } + + public void onEnable() { + super.onEnable(); + this.wasClick = false; + this.averageCPS = 0; + } + + private void updateVals() { + this.minLeft = Explicit.instance.sm.getSettingByName(this, ClickAssist.lllIIIII[4]).getValDouble(); + this.maxLeft = Explicit.instance.sm.getSettingByName(this, ClickAssist.lllIIIII[5]).getValDouble(); + + for (int i = 0; i < this.cps.size(); ++i) { + if (System.currentTimeMillis() - ((Long) this.cps.get(i)).longValue() > 1000L) { + this.cps.remove(i); + } + } + + if (!this.wasClick && Mouse.isButtonDown(0)) { + this.cps.add(Long.valueOf(System.currentTimeMillis())); + this.averageCPS = (int) ((double) this.cps.size() / 1.3D); + this.wasClick = true; + } else if (!Mouse.isButtonDown(0)) { + this.wasClick = false; + } + + if (this.minLeft >= this.maxLeft) { + this.maxLeft = this.minLeft + 1.0D; + } + + this.speed = 1.0D / ThreadLocalRandom.current().nextDouble(this.minLeft - 0.2D, this.maxLeft); + this.holdLength = this.speed / ThreadLocalRandom.current().nextDouble(this.minLeft, this.maxLeft); + } + + static { + llIlIIIlIl(); + llIlIIIIlI(); + } + + private static void llIlIIIIlI() { + lllIIIII = new String[6]; + ClickAssist.lllIIIII[0] = llIIlllIll(ClickAssist.lllIIIll[0], ClickAssist.lllIIIll[1]); + ClickAssist.lllIIIII[1] = llIIllllII(ClickAssist.lllIIIll[2], ClickAssist.lllIIIll[3]); + ClickAssist.lllIIIII[2] = llIIlllIll(ClickAssist.lllIIIll[4], ClickAssist.lllIIIll[5]); + ClickAssist.lllIIIII[3] = llIIllllIl(ClickAssist.lllIIIll[6], ClickAssist.lllIIIll[7]); + ClickAssist.lllIIIII[4] = llIIllllIl(ClickAssist.lllIIIll[8], ClickAssist.lllIIIll[9]); + ClickAssist.lllIIIII[5] = llIIllllII(ClickAssist.lllIIIll[10], ClickAssist.lllIIIll[11]); + ClickAssist.lllIIIll = null; + } + + private static void llIlIIIlIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ClickAssist.lllIIIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIllllIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIIllllII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIlllIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/combat/HitBoxes.java b/module/combat/HitBoxes.java new file mode 100644 index 0000000..653b475 --- /dev/null +++ b/module/combat/HitBoxes.java @@ -0,0 +1,217 @@ +package me.explicit.module.combat; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import java.util.concurrent.ThreadLocalRandom; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import me.explicit.utils.RotationUtils; +import net.minecraft.entity.Entity; +import net.minecraft.entity.item.EntityItemFrame; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.util.Vec3; +import net.minecraftforge.client.event.MouseEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent; + +public class HitBoxes extends Module { + + private Entity pointedEntity; + private MovingObjectPosition moving; + public static float hitBoxMultiplier; + private static final String[] llIIllI; + private static String[] llIIlll; + + public HitBoxes() { + super(HitBoxes.llIIllI[0], 0, Category.COMBAT, HitBoxes.llIIllI[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(HitBoxes.llIIllI[2], this, 30.0D, 1.0D, 180.0D, true)); + } + + @SubscribeEvent + public void mouse(MouseEvent mouseevent) { + if (this.moving != null && mouseevent.button == 0 && (HitBoxes.mc.objectMouseOver.getBlockPos() == null || Game.World().isAirBlock(HitBoxes.mc.objectMouseOver.getBlockPos()))) { + Module.mc.objectMouseOver = this.moving; + } + + } + + public void onClick() {} + + @SubscribeEvent + public void tick(RenderTickEvent rendertickevent) { + if (Game.World() != null) { + HitBoxes.hitBoxMultiplier = (float) Explicit.instance.sm.getSettingByName(this, HitBoxes.llIIllI[3]).getValDouble(); + } + + this.getMouseOver(1.0F); + } + + public void onUpdate() { + if (Game.World() != null) { + HitBoxes.hitBoxMultiplier = (float) Explicit.instance.sm.getSettingByName(this, HitBoxes.llIIllI[4]).getValDouble(); + } + + this.getMouseOver(1.0F); + } + + private void getMouseOver(float f) { + if (HitBoxes.mc.getRenderViewEntity() != null && Game.World() != null) { + HitBoxes.mc.pointedEntity = null; + double d0 = 3.0D; + double d1; + + if (Explicit.instance.mm.getModuleByName(HitBoxes.llIIllI[5]).isToggled()) { + d1 = Explicit.instance.sm.getSettingByName(Explicit.instance.mm.getModuleByName(HitBoxes.llIIllI[6]), HitBoxes.llIIllI[7]).getValDouble(); + double d2 = Explicit.instance.sm.getSettingByName(Explicit.instance.mm.getModuleByName(HitBoxes.llIIllI[8]), HitBoxes.llIIllI[9]).getValDouble(); + + if (d1 <= d2 && d1 != d2) { + d0 = ThreadLocalRandom.current().nextDouble(d1, d2); + } else { + d0 = d1; + } + } + + this.moving = HitBoxes.mc.getRenderViewEntity().rayTrace(d0, f); + d1 = d0; + Vec3 vec3 = HitBoxes.mc.getRenderViewEntity().getPositionEyes(f); + + if (this.moving != null) { + d1 = this.moving.hitVec.distanceTo(vec3); + } + + Vec3 vec31 = HitBoxes.mc.getRenderViewEntity().getLook(f); + Vec3 vec32 = vec3.addVector(vec31.xCoord * d0, vec31.yCoord * d0, vec31.zCoord * d0); + + this.pointedEntity = null; + Vec3 vec33 = null; + float f1 = 1.0F; + List list = Game.World().getEntitiesWithinAABBExcludingEntity(HitBoxes.mc.getRenderViewEntity(), HitBoxes.mc.getRenderViewEntity().getEntityBoundingBox().addCoord(vec31.xCoord * d0, vec31.yCoord * d0, vec31.zCoord * d0).expand((double) f1, (double) f1, (double) f1)); + double d3 = d1; + + for (int i = 0; i < list.size(); ++i) { + Entity entity = (Entity) list.get(i); + + if (entity.canBeCollidedWith() && CombatUtils.canTarget(entity, true) && RotationUtils.canEntityBeSeen(entity)) { + float f2 = 0.13F * HitBoxes.hitBoxMultiplier; + AxisAlignedBB axisalignedbb = entity.getEntityBoundingBox().expand((double) f2, (double) f2, (double) f2); + MovingObjectPosition movingobjectposition = axisalignedbb.calculateIntercept(vec3, vec32); + + if (axisalignedbb.isVecInside(vec3)) { + if (0.0D < d3 || d3 == 0.0D) { + this.pointedEntity = entity; + vec33 = movingobjectposition == null ? vec3 : movingobjectposition.hitVec; + d3 = 0.0D; + } + } else if (movingobjectposition != null) { + double d4 = vec3.distanceTo(movingobjectposition.hitVec); + + if (d4 < d3 || d3 == 0.0D) { + if (entity == HitBoxes.mc.getRenderViewEntity().ridingEntity && !entity.canRiderInteract()) { + if (d3 == 0.0D) { + this.pointedEntity = entity; + vec33 = movingobjectposition.hitVec; + } + } else { + this.pointedEntity = entity; + vec33 = movingobjectposition.hitVec; + d3 = d4; + } + } + } + } + } + + if (this.pointedEntity != null && (d3 < d1 || this.moving == null)) { + this.moving = new MovingObjectPosition(this.pointedEntity, vec33); + if (CombatUtils.canTarget(this.pointedEntity, true) || this.pointedEntity instanceof EntityItemFrame) { + HitBoxes.mc.pointedEntity = this.pointedEntity; + } + } + } + + } + + static { + lIllIIlll(); + lIllIIllI(); + HitBoxes.hitBoxMultiplier = 1.0F; + } + + private static void lIllIIllI() { + llIIllI = new String[10]; + HitBoxes.llIIllI[0] = lIllIIIII(HitBoxes.llIIlll[0], HitBoxes.llIIlll[1]); + HitBoxes.llIIllI[1] = lIllIIlII(HitBoxes.llIIlll[2], HitBoxes.llIIlll[3]); + HitBoxes.llIIllI[2] = lIllIIlII(HitBoxes.llIIlll[4], HitBoxes.llIIlll[5]); + HitBoxes.llIIllI[3] = lIllIIlIl(HitBoxes.llIIlll[6], HitBoxes.llIIlll[7]); + HitBoxes.llIIllI[4] = lIllIIlII(HitBoxes.llIIlll[8], HitBoxes.llIIlll[9]); + HitBoxes.llIIllI[5] = lIllIIlII(HitBoxes.llIIlll[10], HitBoxes.llIIlll[11]); + HitBoxes.llIIllI[6] = lIllIIlII(HitBoxes.llIIlll[12], HitBoxes.llIIlll[13]); + HitBoxes.llIIllI[7] = lIllIIlII(HitBoxes.llIIlll[14], HitBoxes.llIIlll[15]); + HitBoxes.llIIllI[8] = lIllIIlIl(HitBoxes.llIIlll[16], HitBoxes.llIIlll[17]); + HitBoxes.llIIllI[9] = lIllIIlIl(HitBoxes.llIIlll[18], HitBoxes.llIIlll[19]); + HitBoxes.llIIlll = null; + } + + private static void lIllIIlll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + HitBoxes.llIIlll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIllIIlIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIllIIIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIllIIlII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/combat/Reach.java b/module/combat/Reach.java new file mode 100644 index 0000000..7617556 --- /dev/null +++ b/module/combat/Reach.java @@ -0,0 +1,319 @@ +package me.explicit.module.combat; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import java.util.Random; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import net.minecraft.entity.Entity; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemAxe; +import net.minecraft.item.ItemSword; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.BlockPos; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.util.Vec3; +import net.minecraftforge.client.event.MouseEvent; +import net.minecraftforge.event.entity.living.LivingAttackEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class Reach extends Module { + + float ab; + float bb; + boolean cb; + boolean d; + int timeout; + int hits; + boolean misplace; + public Random e = new Random(); + private List Players; + private List oldPos; + private List currentPos; + private static final String[] I; + private static String[] llI; + + public Reach() { + super(Reach.I[0], 0, Category.COMBAT, Reach.I[1]); + } + + public void onEnable() { + super.onEnable(); + if (this.Players == null) { + (this.Players = new ArrayList()).clear(); + } else { + this.Players.clear(); + } + + if (this.oldPos == null) { + (this.oldPos = new ArrayList()).clear(); + } else { + this.oldPos.clear(); + } + + if (this.currentPos == null) { + (this.currentPos = new ArrayList()).clear(); + } else { + this.currentPos.clear(); + } + + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(Reach.I[2], this, 3.0D, 3.0D, 6.0D, false)); + Explicit.instance.sm.rSetting(new Setting(Reach.I[3], this, 3.8D, 3.0D, 6.0D, false)); + Explicit.instance.sm.rSetting(new Setting(Reach.I[4], this, 0.0D, 0.0D, 20.0D, true)); + Explicit.instance.sm.rSetting(new Setting(Reach.I[5], this, false)); + Explicit.instance.sm.rSetting(new Setting(Reach.I[6], this, false)); + Explicit.instance.sm.rSetting(new Setting(Reach.I[7], this, true)); + Explicit.instance.sm.rSetting(new Setting(Reach.I[8], this, false)); + } + + public void onUpdateNoToggle() { + this.misplace = Explicit.instance.sm.getSettingByName(this, Reach.I[9]).getValBoolean(); + if (this.misplace) { + Explicit.instance.sm.getSettingByName(this, Reach.I[10]).setVisible(false); + Explicit.instance.sm.getSettingByName(this, Reach.I[11]).setVisible(false); + Explicit.instance.sm.getSettingByName(this, Reach.I[12]).setVisible(false); + Explicit.instance.sm.getSettingByName(this, Reach.I[13]).setVisible(false); + } else { + Explicit.instance.sm.getSettingByName(this, Reach.I[14]).setVisible(true); + Explicit.instance.sm.getSettingByName(this, Reach.I[15]).setVisible(true); + Explicit.instance.sm.getSettingByName(this, Reach.I[16]).setVisible(true); + Explicit.instance.sm.getSettingByName(this, Reach.I[17]).setVisible(true); + } + + } + + @SubscribeEvent + public void mous(MouseEvent mouseevent) { + if (!Explicit.destructed) { + this.ab = (float) Explicit.instance.sm.getSettingByName(this, Reach.I[18]).getValDouble(); + this.bb = (float) Explicit.instance.sm.getSettingByName(this, Reach.I[19]).getValDouble(); + this.cb = Explicit.instance.sm.getSettingByName(this, Reach.I[20]).getValBoolean(); + this.timeout = (int) Explicit.instance.sm.getSettingByName(this, Reach.I[21]).getValDouble(); + this.misplace = Explicit.instance.sm.getSettingByName(this, Reach.I[22]).getValBoolean(); + this.d = false; + if (this.canReach()) { + if (Reach.mc.objectMouseOver != null) { + BlockPos blockpos = Reach.mc.objectMouseOver.getBlockPos(); + + if (blockpos != null && Game.World().getBlockState(blockpos).getBlock() != Blocks.air) { + return; + } + } + + double d0 = (double) this.ab + this.e.nextDouble() * (double) (this.bb - this.ab); + Object[] aobject = add(d0, 0.0D, 0.0F); + + if (aobject != null) { + Reach.mc.objectMouseOver = new MovingObjectPosition((Entity) aobject[0], (Vec3) aobject[1]); + Reach.mc.pointedEntity = (Entity) aobject[0]; + } + } + } + } + + public boolean canReach() { + boolean flag = Explicit.instance.sm.getSettingByName(this, Reach.I[23]).getValBoolean(); + boolean flag1 = Explicit.instance.sm.getSettingByName(this, Reach.I[24]).getValBoolean(); + + if (flag1 && !Game.Player().onGround) { + return false; + } else if (flag && !Game.Player().isSprinting()) { + return false; + } else if (this.misplace) { + return false; + } else { + if (this.cb) { + if (Game.Player().getCurrentEquippedItem() == null) { + return false; + } + + if (!(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemSword) && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemAxe)) { + return false; + } + } + + return this.hits >= this.timeout; + } + } + + @SubscribeEvent + public void onAttack(LivingAttackEvent livingattackevent) { + if (livingattackevent.entityLiving != null && livingattackevent.source.getEntity() != null && livingattackevent.source.getEntity() == Reach.mc.thePlayer && livingattackevent.ammount > 0.0F && CombatUtils.canTarget(livingattackevent.entityLiving, true)) { + if (Reach.mc.thePlayer.getDistanceToEntity(livingattackevent.entityLiving) >= Math.min(this.ab, this.bb)) { + if (this.hits < this.timeout) { + ++this.hits; + } else if (this.hits >= this.timeout) { + this.hits = 0; + } + } else { + ++this.hits; + } + } + + } + + public static Object[] add(double d0, double d1, float f) { + Entity entity = Reach.mc.getRenderViewEntity(); + Entity entity1 = null; + + if (entity != null && Game.World() != null) { + Reach.mc.mcProfiler.startSection(Reach.I[25]); + Vec3 vec3 = entity.getPositionEyes(0.0F); + Vec3 vec31 = entity.getLook(0.0F); + Vec3 vec32 = vec3.addVector(vec31.xCoord * d0, vec31.yCoord * d0, vec31.zCoord * d0); + Vec3 vec33 = null; + float f1 = 1.0F; + List list = Game.World().getEntitiesWithinAABBExcludingEntity(entity, entity.getEntityBoundingBox().addCoord(vec31.xCoord * d0, vec31.yCoord * d0, vec31.zCoord * d0).expand(1.0D, 1.0D, 1.0D)); + double d2 = d0; + + for (int i = 0; i < list.size(); ++i) { + Entity entity2 = (Entity) list.get(i); + + if (entity2.canBeCollidedWith()) { + float f2 = entity2.getCollisionBorderSize(); + AxisAlignedBB axisalignedbb = entity2.getEntityBoundingBox().expand((double) f2, (double) f2, (double) f2); + + axisalignedbb = axisalignedbb.expand(d1, d1, d1); + MovingObjectPosition movingobjectposition = axisalignedbb.calculateIntercept(vec3, vec32); + + if (axisalignedbb.isVecInside(vec3)) { + if (0.0D < d2 || d2 == 0.0D) { + entity1 = entity2; + vec33 = movingobjectposition == null ? vec3 : movingobjectposition.hitVec; + d2 = 0.0D; + } + } else if (movingobjectposition != null) { + double d3 = vec3.distanceTo(movingobjectposition.hitVec); + + if (d3 < d2 || d2 == 0.0D) { + boolean flag = false; + + if (entity2 == entity.ridingEntity) { + if (d2 == 0.0D) { + entity1 = entity2; + vec33 = movingobjectposition.hitVec; + } + } else { + entity1 = entity2; + vec33 = movingobjectposition.hitVec; + d2 = d3; + } + } + } + } + } + + if (d2 < d0 && !CombatUtils.canTarget(entity1, true)) { + entity1 = null; + } + + Reach.mc.mcProfiler.endSection(); + if (entity1 != null && vec33 != null) { + return new Object[] { entity1, vec33}; + } else { + return null; + } + } else { + return null; + } + } + + static { + llIl(); + llII(); + } + + private static void llII() { + I = new String[26]; + Reach.I[0] = I(Reach.llI[0], Reach.llI[1]); + Reach.I[1] = llI(Reach.llI[2], Reach.llI[3]); + Reach.I[2] = llI(Reach.llI[4], Reach.llI[5]); + Reach.I[3] = llI(Reach.llI[6], Reach.llI[7]); + Reach.I[4] = lIIl(Reach.llI[8], Reach.llI[9]); + Reach.I[5] = llI(Reach.llI[10], Reach.llI[11]); + Reach.I[6] = I(Reach.llI[12], Reach.llI[13]); + Reach.I[7] = lIIl(Reach.llI[14], Reach.llI[15]); + Reach.I[8] = I(Reach.llI[16], Reach.llI[17]); + Reach.I[9] = lIIl(Reach.llI[18], Reach.llI[19]); + Reach.I[10] = llI(Reach.llI[20], Reach.llI[21]); + Reach.I[11] = I(Reach.llI[22], Reach.llI[23]); + Reach.I[12] = lIIl(Reach.llI[24], Reach.llI[25]); + Reach.I[13] = lIIl(Reach.llI[26], Reach.llI[27]); + Reach.I[14] = lIIl(Reach.llI[28], Reach.llI[29]); + Reach.I[15] = llI(Reach.llI[30], Reach.llI[31]); + Reach.I[16] = lIIl("7CKcMYlNmS2KtQI/rEz6sg==", "Uquao"); + Reach.I[17] = lIIl("GX767rndmuidhTU84C/S8Q==", "Tzmdv"); + Reach.I[18] = lIIl("k3tjs2kCTMrdIZowHtF0WA==", "jyITs"); + Reach.I[19] = lIIl("m2MXLwEdzkpUjN6e4CjE1g==", "ykzKL"); + Reach.I[20] = I("EAo0ICUpIDs8Mw==", "GoUPJ"); + Reach.I[21] = lIIl("Rb+99LXJzHf2iq+8K47RUA==", "XwHQR"); + Reach.I[22] = lIIl("0N+dOi4p2EEuNZ2iZhbwdA==", "ehVVV"); + Reach.I[23] = I("HiUwGwM5GiweFA==", "MUBrm"); + Reach.I[24] = I("ITc2BCgCCjcdPw==", "fEYqF"); + Reach.I[25] = I("FxMCDw==", "gzadP"); + Reach.llI = null; + } + + private static void llIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Reach.llI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String I(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/combat/RodAimbot.java b/module/combat/RodAimbot.java new file mode 100644 index 0000000..aba6472 --- /dev/null +++ b/module/combat/RodAimbot.java @@ -0,0 +1,196 @@ +package me.explicit.module.combat; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import me.explicit.utils.RotationUtils; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.entity.Entity; + +public class RodAimbot extends Module { + + private Entity target; + private static final String[] lIIIlllIl; + private static String[] lIIIlllll; + + public RodAimbot() { + super(RodAimbot.lIIIlllIl[0], 0, Category.COMBAT, RodAimbot.lIIIlllIl[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(RodAimbot.lIIIlllIl[2], this, 30.0D, 3.0D, 250.0D, true)); + Explicit.instance.sm.rSetting(new Setting(RodAimbot.lIIIlllIl[3], this, 30.0D, 3.0D, 250.0D, true)); + Explicit.instance.sm.rSetting(new Setting(RodAimbot.lIIIlllIl[4], this, 8.0D, 1.0D, 17.5D, false)); + Explicit.instance.sm.rSetting(new Setting(RodAimbot.lIIIlllIl[5], this, 100.0D, 1.0D, 360.0D, true)); + } + + public void onUpdate() { + if (Game.Player() != null && Game.World() != null) { + if (this.target == null || this.target != null && !this.isValid(this.target)) { + this.target = this.getTarget(); + } + + if (this.target != null) { + this.Aim(); + } + } + + } + + private void Aim() { + if (this.target != null) { + int i = Explicit.instance.sm.getSettingByName(this, RodAimbot.lIIIlllIl[6]).getValInt(); + int j = Explicit.instance.sm.getSettingByName(this, RodAimbot.lIIIlllIl[7]).getValInt(); + Entity entity = this.getTarget(); + + if (entity != null && (this.getY(entity) > 1.0D || this.getY(entity) < -1.0D)) { + boolean flag = this.getY(entity) > 0.0D; + EntityPlayerSP entityplayersp = Game.Player(); + + entityplayersp.rotationYaw += (float) (flag ? -(Math.abs(this.getY(entity)) / (double) i) : Math.abs(this.getY(entity)) / (double) i); + float[] afloat = RotationUtils.getRotations(entity); + + if (this.target == null) { + return; + } + + float f = afloat[1] - Game.Player().getDistanceToEntity(this.target) + Game.Player().getDistanceToEntity(this.target) / 4.0F - Game.Player().rotationPitch; + + entityplayersp.rotationPitch = (float) ((double) entityplayersp.rotationPitch + (double) f / ((double) j + ThreadLocalRandom.current().nextDouble())); + } + + } + } + + public Entity getTarget() { + Entity entity = null; + int i = (int) Explicit.instance.sm.getSettingByName(this, RodAimbot.lIIIlllIl[8]).getValDouble(); + + if (Game.World().loadedEntityList != null && Game.Player().getCurrentEquippedItem() != null && Game.Player().getCurrentEquippedItem().getItem().getUnlocalizedName().toLowerCase().contains(RodAimbot.lIIIlllIl[9])) { + List list = Game.World().loadedEntityList; + + for (int j = 0; j < list.size(); ++j) { + Entity entity1 = (Entity) list.get(j); + + if (this.isValid(entity1) && this.can(entity1, (float) i)) { + entity = entity1; + i = (int) this.getY(entity1); + } + } + + return entity; + } else { + return null; + } + } + + private boolean isValid(Entity entity) { + return RotationUtils.canEntityBeSeen(entity) && entity.isEntityAlive() && entity != Game.Player() && (double) Game.Player().getDistanceToEntity(entity) <= Explicit.instance.sm.getSettingByName(this, RodAimbot.lIIIlllIl[10]).getValDouble() && CombatUtils.canTarget(entity, true); + } + + public boolean can(Entity entity, float f) { + f = (float) ((double) f * 0.5D); + double d0 = ((double) (Game.Player().rotationYaw - this.yaw(entity)) % 360.0D + 540.0D) % 360.0D - 180.0D; + + return d0 > 0.0D && d0 < (double) f || (double) (-f) < d0 && d0 < 0.0D; + } + + public float yaw(Entity entity) { + double d0 = entity.posX - Game.Player().posX; + double d1 = entity.posY - Game.Player().posY; + double d2 = entity.posZ - Game.Player().posZ; + double d3 = Math.atan2(d0, d2) * 57.2957795D; + + d3 = -d3; + double d4 = Math.asin(d1 / Math.sqrt(d0 * d0 + d1 * d1 + d2 * d2)) * 57.2957795D; + + d4 = -d4; + return (float) d3; + } + + public double getY(Entity entity) { + return ((double) (Game.Player().rotationYaw - this.yaw(entity)) % 360.0D + 540.0D) % 360.0D - 180.0D; + } + + static { + llllllIIII(); + lllllIllll(); + } + + private static void lllllIllll() { + lIIIlllIl = new String[11]; + RodAimbot.lIIIlllIl[0] = lllllIllII(RodAimbot.lIIIlllll[0], RodAimbot.lIIIlllll[1]); + RodAimbot.lIIIlllIl[1] = lllllIllIl(RodAimbot.lIIIlllll[2], RodAimbot.lIIIlllll[3]); + RodAimbot.lIIIlllIl[2] = lllllIllII(RodAimbot.lIIIlllll[4], RodAimbot.lIIIlllll[5]); + RodAimbot.lIIIlllIl[3] = lllllIlllI(RodAimbot.lIIIlllll[6], RodAimbot.lIIIlllll[7]); + RodAimbot.lIIIlllIl[4] = lllllIllII(RodAimbot.lIIIlllll[8], RodAimbot.lIIIlllll[9]); + RodAimbot.lIIIlllIl[5] = lllllIllII(RodAimbot.lIIIlllll[10], RodAimbot.lIIIlllll[11]); + RodAimbot.lIIIlllIl[6] = lllllIllIl(RodAimbot.lIIIlllll[12], RodAimbot.lIIIlllll[13]); + RodAimbot.lIIIlllIl[7] = lllllIllIl(RodAimbot.lIIIlllll[14], RodAimbot.lIIIlllll[15]); + RodAimbot.lIIIlllIl[8] = lllllIllII(RodAimbot.lIIIlllll[16], RodAimbot.lIIIlllll[17]); + RodAimbot.lIIIlllIl[9] = lllllIllIl(RodAimbot.lIIIlllll[18], RodAimbot.lIIIlllll[19]); + RodAimbot.lIIIlllIl[10] = lllllIllIl(RodAimbot.lIIIlllll[20], RodAimbot.lIIIlllll[21]); + RodAimbot.lIIIlllll = null; + } + + private static void llllllIIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + RodAimbot.lIIIlllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllllIlllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllllIllII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllllIllIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/combat/STap.java b/module/combat/STap.java new file mode 100644 index 0000000..ed42680 --- /dev/null +++ b/module/combat/STap.java @@ -0,0 +1,178 @@ +package me.explicit.module.combat; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.util.MovingObjectPosition.MovingObjectType; +import net.minecraftforge.event.entity.player.AttackEntityEvent; +import net.minecraftforge.fml.common.eventhandler.EventPriority; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent; +import org.lwjgl.input.Keyboard; + +public class STap extends Module { + + boolean shouldTap = false; + private TimerUtils tDelay = new TimerUtils(); + private TimerUtils tHold = new TimerUtils(); + private TimerUtils updateData = new TimerUtils(); + private double delay; + private double hold; + boolean hasReached = false; + private static final String[] lIIlIIlI; + private static String[] lIIlIIll; + + public STap() { + super(STap.lIIlIIlI[0], 0, Category.MOVEMENT, STap.lIIlIIlI[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(STap.lIIlIIlI[2], this, 100.0D, 1.0D, 500.0D, true)); + Explicit.instance.sm.rSetting(new Setting(STap.lIIlIIlI[3], this, 150.0D, 1.0D, 500.0D, true)); + Explicit.instance.sm.rSetting(new Setting(STap.lIIlIIlI[4], this, 10.0D, 1.0D, 250.0D, true)); + Explicit.instance.sm.rSetting(new Setting(STap.lIIlIIlI[5], this, 11.0D, 1.0D, 250.0D, true)); + } + + public void onEnable() { + this.shouldTap = false; + this.hasReached = false; + super.onEnable(); + } + + public void setData() { + double d0 = Explicit.instance.sm.getSettingByName(this, STap.lIIlIIlI[6]).getValDouble(); + double d1 = Explicit.instance.sm.getSettingByName(this, STap.lIIlIIlI[7]).getValDouble(); + double d2 = Explicit.instance.sm.getSettingByName(this, STap.lIIlIIlI[8]).getValDouble(); + double d3 = Explicit.instance.sm.getSettingByName(this, STap.lIIlIIlI[9]).getValDouble(); + + if (d0 == d1 || d0 > d1) { + d1 = d0 * 1.1D; + } + + if (d2 == d3 || d2 > d3) { + d3 = d2 * 1.1D; + } + + this.delay = ThreadLocalRandom.current().nextDouble(Math.min(d0, d1), Math.max(d0, d1)); + this.hold = ThreadLocalRandom.current().nextDouble(Math.min(d2, d3), Math.max(d2, d3)); + } + + @SubscribeEvent + public void t34ff(RenderTickEvent rendertickevent) { + double d0 = Explicit.instance.sm.getSettingByName(this, STap.lIIlIIlI[10]).getValDouble(); + double d1 = Explicit.instance.sm.getSettingByName(this, STap.lIIlIIlI[11]).getValDouble(); + + if (this.updateData.hasReached(Math.max(d0, d1) * (ThreadLocalRandom.current().nextDouble() + ThreadLocalRandom.current().nextDouble()) * 2.0D)) { + this.setData(); + this.hasReached = true; + this.updateData.reset(); + } + + if (this.hasReached) { + if (this.tHold.hasReached(this.hold) && this.shouldTap && Keyboard.isKeyDown(STap.mc.gameSettings.keyBindBack.getKeyCode())) { + KeyBinding.setKeyBindState(STap.mc.gameSettings.keyBindBack.getKeyCode(), true); + this.shouldTap = false; + } else if (!Keyboard.isKeyDown(STap.mc.gameSettings.keyBindBack.getKeyCode())) { + KeyBinding.setKeyBindState(STap.mc.gameSettings.keyBindBack.getKeyCode(), false); + } + + } + } + + @SubscribeEvent( + priority = EventPriority.LOWEST + ) + public void asdfgbnv(AttackEntityEvent attackentityevent) { + if (this.tDelay.hasReached(this.delay) && !this.shouldTap && Module.mc.objectMouseOver != null && Module.mc.objectMouseOver.typeOfHit == MovingObjectType.ENTITY && Module.mc.objectMouseOver.entityHit.getEntityId() == attackentityevent.target.getEntityId() && CombatUtils.canTarget(Game.World().getEntityByID(attackentityevent.target.getEntityId()), true)) { + this.shouldTap = true; + this.tHold.reset(); + this.tDelay.reset(); + KeyBinding.setKeyBindState(STap.mc.gameSettings.keyBindBack.getKeyCode(), false); + } + + } + + static { + lIIIIIIlII(); + lIIIIIIIll(); + } + + private static void lIIIIIIIll() { + lIIlIIlI = new String[12]; + STap.lIIlIIlI[0] = lIIIIIIIII(STap.lIIlIIll[0], STap.lIIlIIll[1]); + STap.lIIlIIlI[1] = lIIIIIIIIl(STap.lIIlIIll[2], STap.lIIlIIll[3]); + STap.lIIlIIlI[2] = lIIIIIIIII(STap.lIIlIIll[4], STap.lIIlIIll[5]); + STap.lIIlIIlI[3] = lIIIIIIIlI(STap.lIIlIIll[6], STap.lIIlIIll[7]); + STap.lIIlIIlI[4] = lIIIIIIIlI(STap.lIIlIIll[8], STap.lIIlIIll[9]); + STap.lIIlIIlI[5] = lIIIIIIIII(STap.lIIlIIll[10], STap.lIIlIIll[11]); + STap.lIIlIIlI[6] = lIIIIIIIlI(STap.lIIlIIll[12], STap.lIIlIIll[13]); + STap.lIIlIIlI[7] = lIIIIIIIII(STap.lIIlIIll[14], STap.lIIlIIll[15]); + STap.lIIlIIlI[8] = lIIIIIIIIl(STap.lIIlIIll[16], STap.lIIlIIll[17]); + STap.lIIlIIlI[9] = lIIIIIIIlI(STap.lIIlIIll[18], STap.lIIlIIll[19]); + STap.lIIlIIlI[10] = lIIIIIIIlI(STap.lIIlIIll[20], STap.lIIlIIll[21]); + STap.lIIlIIlI[11] = lIIIIIIIII(STap.lIIlIIll[22], STap.lIIlIIll[23]); + STap.lIIlIIll = null; + } + + private static void lIIIIIIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + STap.lIIlIIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIIIIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIIIIIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIIIIIIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/combat/ThrowPot.java b/module/combat/ThrowPot.java new file mode 100644 index 0000000..100818c --- /dev/null +++ b/module/combat/ThrowPot.java @@ -0,0 +1,186 @@ +package me.explicit.module.combat; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.item.Item; +import net.minecraft.item.ItemPotion; +import net.minecraft.item.ItemStack; + +public class ThrowPot extends Module { + + private int stage = 0; + private TimerUtils timer = new TimerUtils(); + private int oldSlot; + private int potSlot; + private static final String[] lIlIlllI; + private static String[] lIllIIII; + + public ThrowPot() { + super(ThrowPot.lIlIlllI[0], ThrowPot.lIlIlllI[1], Category.COMBAT); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(ThrowPot.lIlIlllI[2], this, 100.0D, 10.0D, 1000.0D, true)); + Explicit.instance.sm.rSetting(new Setting(ThrowPot.lIlIlllI[3], this, 150.0D, 10.0D, 1000.0D, true)); + Explicit.instance.sm.rSetting(new Setting(ThrowPot.lIlIlllI[4], this, 8.0D, 1.0D, 20.0D, true)); + } + + public void onEnable() { + super.onEnable(); + this.stage = 0; + this.timer.reset(); + if (Game.Player() == null) { + this.setToggled(false); + } else { + this.oldSlot = ThrowPot.mc.thePlayer.inventory.currentItem; + this.potSlot = this.getPotionSlot(); + if (this.potSlot == -1) { + this.setToggled(false); + } + } + } + + public void onTick() { + if (this.stage == 0) { + this.stage = 1; + } else if (this.stage == 1) { + float f = (float) Explicit.instance.sm.getSettingByName(this, ThrowPot.lIlIlllI[5]).getValDouble(); + + if (ThrowPot.mc.thePlayer.getHealth() <= ThrowPot.mc.thePlayer.getMaxHealth() - f) { + ThrowPot.mc.thePlayer.inventory.currentItem = this.potSlot; + this.stage = 2; + this.timer.reset(); + } else { + ThrowPot.mc.thePlayer.inventory.currentItem = this.oldSlot; + this.setToggled(false); + } + } else if (this.stage == 2) { + if (this.timer.hasReached(this.getDelay() / 3.0D)) { + KeyBinding.setKeyBindState(ThrowPot.mc.gameSettings.keyBindUseItem.getKeyCode(), true); + this.timer.reset(); + this.stage = 3; + } + } else if (this.stage == 3) { + if (this.timer.hasReached(this.getDelay() / 3.0D)) { + KeyBinding.setKeyBindState(ThrowPot.mc.gameSettings.keyBindUseItem.getKeyCode(), false); + this.stage = 4; + } + } else if (this.stage == 4) { + ThrowPot.mc.thePlayer.inventory.currentItem = this.oldSlot; + this.setToggled(false); + this.stage = 0; + } + + } + + public int getPotionSlot() { + for (int i = 0; i < 8; ++i) { + ItemStack itemstack = ThrowPot.mc.thePlayer.inventory.getStackInSlot(i); + + if (itemstack != null && !itemstack.isStackable()) { + Item item = itemstack.getItem(); + + if (item instanceof ItemPotion) { + ItemPotion itempotion = (ItemPotion) item; + + if (ItemPotion.isSplash(itemstack.getMetadata())) { + return i; + } + } + } + } + + return -1; + } + + public double getDelay() { + int i = Explicit.instance.sm.getSettingByName(this, ThrowPot.lIlIlllI[6]).getValInt() * 4; + int j = Explicit.instance.sm.getSettingByName(this, ThrowPot.lIlIlllI[7]).getValInt() * 4; + + if (i == j) { + j = i + 1; + } + + return ThreadLocalRandom.current().nextDouble((double) Math.min(j, i), (double) Math.max(j, i)); + } + + static { + lIIlllIlIl(); + lIIlllIlII(); + } + + private static void lIIlllIlII() { + lIlIlllI = new String[8]; + ThrowPot.lIlIlllI[0] = lIIllIllll(ThrowPot.lIllIIII[0], ThrowPot.lIllIIII[1]); + ThrowPot.lIlIlllI[1] = lIIllIllll(ThrowPot.lIllIIII[2], ThrowPot.lIllIIII[3]); + ThrowPot.lIlIlllI[2] = lIIlllIIlI(ThrowPot.lIllIIII[4], ThrowPot.lIllIIII[5]); + ThrowPot.lIlIlllI[3] = lIIllIllll(ThrowPot.lIllIIII[6], ThrowPot.lIllIIII[7]); + ThrowPot.lIlIlllI[4] = lIIlllIIll(ThrowPot.lIllIIII[8], ThrowPot.lIllIIII[9]); + ThrowPot.lIlIlllI[5] = lIIlllIIll(ThrowPot.lIllIIII[10], ThrowPot.lIllIIII[11]); + ThrowPot.lIlIlllI[6] = lIIlllIIlI(ThrowPot.lIllIIII[12], ThrowPot.lIllIIII[13]); + ThrowPot.lIlIlllI[7] = lIIllIllll(ThrowPot.lIllIIII[14], ThrowPot.lIllIIII[15]); + ThrowPot.lIllIIII = null; + } + + private static void lIIlllIlIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ThrowPot.lIllIIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIlllIIlI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIllIllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIlllIIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/combat/Velocity.java b/module/combat/Velocity.java new file mode 100644 index 0000000..48bcd2e --- /dev/null +++ b/module/combat/Velocity.java @@ -0,0 +1,162 @@ +package me.explicit.module.combat; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.item.ItemAxe; +import net.minecraft.item.ItemSword; +import net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class Velocity extends Module { + + private static final String[] llIlIl; + private static String[] llIlll; + + public Velocity() { + super(Velocity.llIlIl[0], 0, Category.COMBAT, Velocity.llIlIl[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(Velocity.llIlIl[2], this, 90.0D, 0.0D, 100.0D, true, true)); + Explicit.instance.sm.rSetting(new Setting(Velocity.llIlIl[3], this, 100.0D, 0.0D, 100.0D, true, true)); + Explicit.instance.sm.rSetting(new Setting(Velocity.llIlIl[4], this, 60.0D, 0.0D, 100.0D, true, true)); + Explicit.instance.sm.rSetting(new Setting(Velocity.llIlIl[5], this, true)); + Explicit.instance.sm.rSetting(new Setting(Velocity.llIlIl[6], this, true)); + Explicit.instance.sm.rSetting(new Setting(Velocity.llIlIl[7], this, false)); + Explicit.instance.sm.rSetting(new Setting(Velocity.llIlIl[8], this, false)); + } + + @SubscribeEvent + public void onEv(LivingUpdateEvent livingupdateevent) { + float f = (float) Explicit.instance.sm.getSettingByName(this, Velocity.llIlIl[9]).getValDouble(); + float f1 = (float) Explicit.instance.sm.getSettingByName(this, Velocity.llIlIl[10]).getValDouble(); + + if (this.canVelocity() && Game.Player().hurtTime == Game.Player().maxHurtTime && Game.Player().maxHurtTime > 0) { + EntityPlayerSP entityplayersp = Game.Player(); + + entityplayersp.motionX *= (double) f / 100.0D; + EntityPlayerSP entityplayersp1 = Game.Player(); + + entityplayersp1.motionY *= (double) f1 / 100.0D; + EntityPlayerSP entityplayersp2 = Game.Player(); + + entityplayersp2.motionZ *= (double) f / 100.0D; + } + + } + + public boolean canVelocity() { + int i = 100 - (int) Explicit.instance.sm.getSettingByName(this, Velocity.llIlIl[11]).getValDouble(); + boolean flag = Explicit.instance.sm.getSettingByName(this, Velocity.llIlIl[12]).getValBoolean(); + boolean flag1 = Explicit.instance.sm.getSettingByName(this, Velocity.llIlIl[13]).getValBoolean(); + boolean flag2 = Explicit.instance.sm.getSettingByName(this, Velocity.llIlIl[14]).getValBoolean(); + boolean flag3 = Explicit.instance.sm.getSettingByName(this, Velocity.llIlIl[15]).getValBoolean(); + + if (Game.World() != null && Game.Player() != null && (!flag || Game.Player().isSprinting()) && i < ThreadLocalRandom.current().nextInt(0, 101)) { + if (flag1 && Velocity.mc.objectMouseOver != null && Velocity.mc.objectMouseOver.entityHit == null) { + return false; + } else { + if (flag2) { + if (Game.Player().getCurrentEquippedItem() == null) { + return false; + } + + if (!(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemSword) && !(Game.Player().getCurrentEquippedItem().getItem() instanceof ItemAxe)) { + return false; + } + } + + return !Game.Player().isInWater() && !Game.Player().isInLava() || !flag3; + } + } else { + return false; + } + } + + static { + llIIIIII(); + lIllllll(); + } + + private static void lIllllll() { + llIlIl = new String[16]; + Velocity.llIlIl[0] = lIlIlIII(Velocity.llIlll[0], Velocity.llIlll[1]); + Velocity.llIlIl[1] = lIlIlIII(Velocity.llIlll[2], Velocity.llIlll[3]); + Velocity.llIlIl[2] = lIllIlIl(Velocity.llIlll[4], Velocity.llIlll[5]); + Velocity.llIlIl[3] = lIlIlIII(Velocity.llIlll[6], Velocity.llIlll[7]); + Velocity.llIlIl[4] = lIllIlll(Velocity.llIlll[8], Velocity.llIlll[9]); + Velocity.llIlIl[5] = lIlIlIII(Velocity.llIlll[10], Velocity.llIlll[11]); + Velocity.llIlIl[6] = lIllIlll(Velocity.llIlll[12], Velocity.llIlll[13]); + Velocity.llIlIl[7] = lIlIlIII(Velocity.llIlll[14], Velocity.llIlll[15]); + Velocity.llIlIl[8] = lIllIlIl(Velocity.llIlll[16], Velocity.llIlll[17]); + Velocity.llIlIl[9] = lIlIlIII(Velocity.llIlll[18], Velocity.llIlll[19]); + Velocity.llIlIl[10] = lIllIlll(Velocity.llIlll[20], Velocity.llIlll[21]); + Velocity.llIlIl[11] = lIllIlll(Velocity.llIlll[22], Velocity.llIlll[23]); + Velocity.llIlIl[12] = lIllIlIl(Velocity.llIlll[24], Velocity.llIlll[25]); + Velocity.llIlIl[13] = lIllIlll(Velocity.llIlll[26], Velocity.llIlll[27]); + Velocity.llIlIl[14] = lIllIlIl(Velocity.llIlll[28], Velocity.llIlll[29]); + Velocity.llIlIl[15] = lIllIlIl(Velocity.llIlll[30], Velocity.llIlll[31]); + Velocity.llIlll = null; + } + + private static void llIIIIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Velocity.llIlll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIllIlll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIllIlIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIlIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/combat/WTap.java b/module/combat/WTap.java new file mode 100644 index 0000000..064610b --- /dev/null +++ b/module/combat/WTap.java @@ -0,0 +1,173 @@ +package me.explicit.module.combat; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.util.MovingObjectPosition.MovingObjectType; +import net.minecraftforge.event.entity.player.AttackEntityEvent; +import net.minecraftforge.fml.common.eventhandler.EventPriority; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent; +import org.lwjgl.input.Keyboard; + +public class WTap extends Module { + + boolean shouldTap = false; + private TimerUtils tDelay = new TimerUtils(); + private TimerUtils tHold = new TimerUtils(); + private TimerUtils updateData = new TimerUtils(); + private double delay; + private double hold; + boolean hasReached = false; + private static final String[] lIIIlIIIl; + private static String[] lIIIlIIlI; + + public WTap() { + super(WTap.lIIIlIIIl[0], 0, Category.MOVEMENT, WTap.lIIIlIIIl[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(WTap.lIIIlIIIl[2], this, 100.0D, 1.0D, 500.0D, true)); + Explicit.instance.sm.rSetting(new Setting(WTap.lIIIlIIIl[3], this, 150.0D, 1.0D, 500.0D, true)); + Explicit.instance.sm.rSetting(new Setting(WTap.lIIIlIIIl[4], this, 10.0D, 1.0D, 250.0D, true)); + Explicit.instance.sm.rSetting(new Setting(WTap.lIIIlIIIl[5], this, 11.0D, 1.0D, 250.0D, true)); + } + + public void onEnable() { + this.shouldTap = false; + this.hasReached = false; + super.onEnable(); + } + + public void setData() { + double d0 = Explicit.instance.sm.getSettingByName(this, WTap.lIIIlIIIl[6]).getValDouble(); + double d1 = Explicit.instance.sm.getSettingByName(this, WTap.lIIIlIIIl[7]).getValDouble(); + double d2 = Explicit.instance.sm.getSettingByName(this, WTap.lIIIlIIIl[8]).getValDouble(); + double d3 = Explicit.instance.sm.getSettingByName(this, WTap.lIIIlIIIl[9]).getValDouble(); + + if (d0 == d1 || d0 > d1) { + d1 = d0 * 1.1D; + } + + if (d2 == d3 || d2 > d3) { + d3 = d2 * 1.1D; + } + + this.delay = ThreadLocalRandom.current().nextDouble(Math.min(d0, d1), Math.max(d0, d1)); + this.hold = ThreadLocalRandom.current().nextDouble(Math.min(d2, d3), Math.max(d2, d3)); + } + + @SubscribeEvent + public void t3s4f(RenderTickEvent rendertickevent) { + if (this.updateData.hasReached(1000.0D)) { + this.setData(); + this.hasReached = true; + this.updateData.reset(); + } + + if (this.hasReached) { + if (this.tHold.hasReached(this.hold) && this.shouldTap && Keyboard.isKeyDown(WTap.mc.gameSettings.keyBindForward.getKeyCode())) { + KeyBinding.setKeyBindState(WTap.mc.gameSettings.keyBindForward.getKeyCode(), true); + this.shouldTap = false; + } else if (!Keyboard.isKeyDown(WTap.mc.gameSettings.keyBindForward.getKeyCode())) { + KeyBinding.setKeyBindState(WTap.mc.gameSettings.keyBindForward.getKeyCode(), false); + } + + } + } + + @SubscribeEvent( + priority = EventPriority.LOWEST + ) + public void asdfgbnv(AttackEntityEvent attackentityevent) { + if (this.tDelay.hasReached(this.delay) && !this.shouldTap && Module.mc.objectMouseOver != null && Module.mc.objectMouseOver.typeOfHit == MovingObjectType.ENTITY && Module.mc.objectMouseOver.entityHit.getEntityId() == attackentityevent.target.getEntityId() && CombatUtils.canTarget(Game.World().getEntityByID(attackentityevent.target.getEntityId()), true)) { + this.shouldTap = true; + this.tHold.reset(); + this.tDelay.reset(); + KeyBinding.setKeyBindState(WTap.mc.gameSettings.keyBindForward.getKeyCode(), false); + } + + } + + static { + llllIIlIll(); + llllIIlIlI(); + } + + private static void llllIIlIlI() { + lIIIlIIIl = new String[10]; + WTap.lIIIlIIIl[0] = llllIIIlll(WTap.lIIIlIIlI[0], WTap.lIIIlIIlI[1]); + WTap.lIIIlIIIl[1] = llllIIlIII(WTap.lIIIlIIlI[2], WTap.lIIIlIIlI[3]); + WTap.lIIIlIIIl[2] = llllIIIlll(WTap.lIIIlIIlI[4], WTap.lIIIlIIlI[5]); + WTap.lIIIlIIIl[3] = llllIIIlll(WTap.lIIIlIIlI[6], WTap.lIIIlIIlI[7]); + WTap.lIIIlIIIl[4] = llllIIlIII(WTap.lIIIlIIlI[8], WTap.lIIIlIIlI[9]); + WTap.lIIIlIIIl[5] = llllIIlIII(WTap.lIIIlIIlI[10], WTap.lIIIlIIlI[11]); + WTap.lIIIlIIIl[6] = llllIIlIIl(WTap.lIIIlIIlI[12], WTap.lIIIlIIlI[13]); + WTap.lIIIlIIIl[7] = llllIIlIIl(WTap.lIIIlIIlI[14], WTap.lIIIlIIlI[15]); + WTap.lIIIlIIIl[8] = llllIIlIII(WTap.lIIIlIIlI[16], WTap.lIIIlIIlI[17]); + WTap.lIIIlIIIl[9] = llllIIIlll(WTap.lIIIlIIlI[18], WTap.lIIIlIIlI[19]); + WTap.lIIIlIIlI = null; + } + + private static void llllIIlIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + WTap.lIIIlIIlI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llllIIlIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llllIIIlll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llllIIlIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/misc/MCF.java b/module/misc/MCF.java new file mode 100644 index 0000000..51807eb --- /dev/null +++ b/module/misc/MCF.java @@ -0,0 +1,130 @@ +package me.explicit.module.misc; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.ChatUtils; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.util.EnumChatFormatting; +import org.lwjgl.input.Mouse; + +public class MCF extends Module { + + boolean waitingForRelease = false; + private static final String[] lIIl; + private static String[] lIlI; + + public MCF() { + super(MCF.lIIl[0], 0, Category.MISC, MCF.lIIl[1]); + } + + public void onTick() { + if (Mouse.isButtonDown(2) && !this.waitingForRelease) { + if (MCF.mc.objectMouseOver != null && MCF.mc.objectMouseOver.entityHit != null && MCF.mc.objectMouseOver.entityHit instanceof EntityPlayer) { + boolean flag = false; + Iterator iterator = Explicit.instance.friendManager.getFriends().iterator(); + + while (iterator.hasNext()) { + String s = (String) iterator.next(); + + if (s.equalsIgnoreCase(MCF.mc.objectMouseOver.entityHit.getName())) { + flag = true; + } + } + + if (!flag) { + Explicit.instance.friendManager.addFriend(MCF.mc.objectMouseOver.entityHit.getName()); + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(MCF.lIIl[2]).append(getTeamColor((EntityPlayer) MCF.mc.objectMouseOver.entityHit)).append(MCF.mc.objectMouseOver.entityHit.getName()).append(EnumChatFormatting.GOLD).append(MCF.lIIl[3]))); + } else { + Explicit.instance.friendManager.getFriends().remove(MCF.mc.objectMouseOver.entityHit.getName()); + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(EnumChatFormatting.GOLD).append(MCF.lIIl[4]).append(getTeamColor((EntityPlayer) MCF.mc.objectMouseOver.entityHit)).append(MCF.mc.objectMouseOver.entityHit.getName()).append(EnumChatFormatting.GOLD).append(MCF.lIIl[5]))); + } + } + + this.waitingForRelease = true; + } else if (!Mouse.isButtonDown(2)) { + this.waitingForRelease = false; + } + + } + + public static String getTeamColor(EntityPlayer entityplayer) { + Character character = Character.valueOf(entityplayer.getDisplayName().getFormattedText().charAt(1)); + + return String.valueOf((new StringBuilder()).append(MCF.lIIl[6]).append(character)); + } + + static { + lIIlII(); + lIIIll(); + } + + private static void lIIIll() { + lIIl = new String[7]; + MCF.lIIl[0] = lIIIII(MCF.lIlI[0], MCF.lIlI[1]); + MCF.lIIl[1] = lIIIII(MCF.lIlI[2], MCF.lIlI[3]); + MCF.lIIl[2] = lIIIIl(MCF.lIlI[4], MCF.lIlI[5]); + MCF.lIIl[3] = lIIIIl(MCF.lIlI[6], MCF.lIlI[7]); + MCF.lIIl[4] = lIIIlI(MCF.lIlI[8], MCF.lIlI[9]); + MCF.lIIl[5] = lIIIII(MCF.lIlI[10], MCF.lIlI[11]); + MCF.lIIl[6] = lIIIII(MCF.lIlI[12], MCF.lIlI[13]); + MCF.lIlI = null; + } + + private static void lIIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + MCF.lIlI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/misc/NameProtect.java b/module/misc/NameProtect.java new file mode 100644 index 0000000..93e39e3 --- /dev/null +++ b/module/misc/NameProtect.java @@ -0,0 +1,69 @@ +package me.explicit.module.misc; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class NameProtect extends Module { + + private static final String[] lIIIlIllI; + private static String[] lIIIlIlll; + + public NameProtect() { + super(NameProtect.lIIIlIllI[0], 0, Category.MISC, NameProtect.lIIIlIllI[1]); + } + + static { + lllllIIIII(); + llllIlllll(); + } + + private static void llllIlllll() { + lIIIlIllI = new String[2]; + NameProtect.lIIIlIllI[0] = llllIlllII(NameProtect.lIIIlIlll[0], NameProtect.lIIIlIlll[1]); + NameProtect.lIIIlIllI[1] = llllIllllI(NameProtect.lIIIlIlll[2], NameProtect.lIIIlIlll[3]); + NameProtect.lIIIlIlll = null; + } + + private static void lllllIIIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + NameProtect.lIIIlIlll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llllIllllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llllIlllII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/misc/NoRotate.java b/module/misc/NoRotate.java new file mode 100644 index 0000000..ecffcd7 --- /dev/null +++ b/module/misc/NoRotate.java @@ -0,0 +1,50 @@ +package me.explicit.module.misc; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class NoRotate extends Module { + + private static final String[] lIIIIIlIl; + private static String[] lIIIIIlll; + + public NoRotate() { + super(NoRotate.lIIIIIlIl[0], 0, Category.MISC, NoRotate.lIIIIIlIl[1]); + } + + static { + lllIIllIIl(); + lllIIlIlll(); + } + + private static void lllIIlIlll() { + lIIIIIlIl = new String[2]; + NoRotate.lIIIIIlIl[0] = lllIIlIlII(NoRotate.lIIIIIlll[0], NoRotate.lIIIIIlll[1]); + NoRotate.lIIIIIlIl[1] = lllIIlIlII(NoRotate.lIIIIIlll[2], NoRotate.lIIIIIlll[3]); + NoRotate.lIIIIIlll = null; + } + + private static void lllIIllIIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + NoRotate.lIIIIIlll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllIIlIlII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/misc/PingSpoof.java b/module/misc/PingSpoof.java new file mode 100644 index 0000000..f2caee4 --- /dev/null +++ b/module/misc/PingSpoof.java @@ -0,0 +1,84 @@ +package me.explicit.module.misc; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; + +public class PingSpoof extends Module { + + public static boolean toggled; + public static int ping; + private static final String[] lllIlIIl; + private static String[] lllIlIll; + + public PingSpoof() { + super(PingSpoof.lllIlIIl[0], PingSpoof.lllIlIIl[1], Category.MISC); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(PingSpoof.lllIlIIl[2], this, 150.0D, 1.0D, 6000.0D, true)); + } + + public void onUpdateNoToggle() { + PingSpoof.toggled = this.isToggled(); + } + + public void onUpdate() { + PingSpoof.ping = Explicit.instance.sm.getSettingByName(this, PingSpoof.lllIlIIl[3]).getValInt(); + } + + static { + llIllIIlII(); + llIllIIIll(); + PingSpoof.toggled = false; + PingSpoof.ping = 0; + } + + private static void llIllIIIll() { + lllIlIIl = new String[4]; + PingSpoof.lllIlIIl[0] = llIlIllIlI(PingSpoof.lllIlIll[0], PingSpoof.lllIlIll[1]); + PingSpoof.lllIlIIl[1] = llIlIllIll(PingSpoof.lllIlIll[2], PingSpoof.lllIlIll[3]); + PingSpoof.lllIlIIl[2] = llIlIllIlI(PingSpoof.lllIlIll[4], PingSpoof.lllIlIll[5]); + PingSpoof.lllIlIIl[3] = llIlIllIll(PingSpoof.lllIlIll[6], PingSpoof.lllIlIll[7]); + PingSpoof.lllIlIll = null; + } + + private static void llIllIIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + PingSpoof.lllIlIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIlIllIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIlIllIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/misc/SelfDestruct.java b/module/misc/SelfDestruct.java new file mode 100644 index 0000000..6d59d40 --- /dev/null +++ b/module/misc/SelfDestruct.java @@ -0,0 +1,80 @@ +package me.explicit.module.misc; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class SelfDestruct extends Module { + + private static final String[] llllIll; + private static String[] lllllII; + + public SelfDestruct() { + super(SelfDestruct.llllIll[0], 0, Category.MISC, SelfDestruct.llllIll[1]); + } + + public void onEnable() { + super.onEnable(); + Explicit.instance.onSelfDestruct(); + this.setToggled(false); + } + + public void onTick() { + Explicit.instance.onSelfDestruct(); + this.setToggled(false); + } + + static { + llIIlllIl(); + llIIlllII(); + } + + private static void llIIlllII() { + llllIll = new String[2]; + SelfDestruct.llllIll[0] = llIIllIlI(SelfDestruct.lllllII[0], SelfDestruct.lllllII[1]); + SelfDestruct.llllIll[1] = llIIllIll(SelfDestruct.lllllII[2], SelfDestruct.lllllII[3]); + SelfDestruct.lllllII = null; + } + + private static void llIIlllIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + SelfDestruct.lllllII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIllIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIllIlI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/misc/Timer.java b/module/misc/Timer.java new file mode 100644 index 0000000..b48f45e --- /dev/null +++ b/module/misc/Timer.java @@ -0,0 +1,82 @@ +package me.explicit.module.misc; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.PrivateUtils; + +public class Timer extends Module { + + private static final String[] lllllIII; + private static String[] lllllIIl; + + public Timer() { + super(Timer.lllllIII[0], 0, Category.MISC, Timer.lllllIII[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(Timer.lllllIII[2], this, 1.25D, 0.1D, 10.0D, false)); + } + + public void onUpdate() { + PrivateUtils.timer().timerSpeed = (float) Explicit.instance.sm.getSettingByName(this, Timer.lllllIII[3]).getValDouble(); + } + + public void onDisable() { + super.onDisable(); + PrivateUtils.timer().timerSpeed = 1.0F; + } + + static { + llIllllIll(); + llIllllIlI(); + } + + private static void llIllllIlI() { + lllllIII = new String[4]; + Timer.lllllIII[0] = llIllllIII(Timer.lllllIIl[0], Timer.lllllIIl[1]); + Timer.lllllIII[1] = llIllllIII(Timer.lllllIIl[2], Timer.lllllIIl[3]); + Timer.lllllIII[2] = llIllllIII(Timer.lllllIIl[4], Timer.lllllIIl[5]); + Timer.lllllIII[3] = llIllllIIl(Timer.lllllIIl[6], Timer.lllllIIl[7]); + Timer.lllllIIl = null; + } + + private static void llIllllIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Timer.lllllIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIllllIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIllllIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/movement/Eagle.java b/module/movement/Eagle.java new file mode 100644 index 0000000..af11a74 --- /dev/null +++ b/module/movement/Eagle.java @@ -0,0 +1,129 @@ +package me.explicit.module.movement; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.init.Blocks; +import net.minecraft.util.BlockPos; +import org.lwjgl.input.Keyboard; + +public class Eagle extends Module { + + private TimerUtils sneakTimer = new TimerUtils(); + private static final String[] llIIllII; + private static String[] llIIllIl; + + public Eagle() { + super(Eagle.llIIllII[0], 0, Category.MOVEMENT, Eagle.llIIllII[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(Eagle.llIIllII[2], this, true)); + Explicit.instance.sm.rSetting(new Setting(Eagle.llIIllII[3], this, false)); + Explicit.instance.sm.rSetting(new Setting(Eagle.llIIllII[4], this, 500.0D, 50.0D, 1500.0D, true)); + } + + public void onTick() { + if (Game.Player() != null && Game.World() != null) { + if (!Explicit.instance.sm.getSettingByName(this, Eagle.llIIllII[5]).getValBoolean() && Eagle.mc.currentScreen != null) { + KeyBinding.setKeyBindState(Eagle.mc.gameSettings.keyBindSneak.getKeyCode(), false); + } else if (Explicit.instance.sm.getSettingByName(this, Eagle.llIIllII[6]).getValBoolean() && !Keyboard.isKeyDown(Eagle.mc.gameSettings.keyBindSneak.getKeyCode())) { + KeyBinding.setKeyBindState(Eagle.mc.gameSettings.keyBindSneak.getKeyCode(), false); + } else { + if (Game.World().getBlockState((new BlockPos(Game.Player())).add(0, -1, 0)).getBlock() == Blocks.air && Eagle.mc.thePlayer.onGround) { + KeyBinding.setKeyBindState(Eagle.mc.gameSettings.keyBindSneak.getKeyCode(), true); + this.sneakTimer.reset(); + } else if (this.sneakTimer.hasReached((double) Explicit.instance.sm.getSettingByName(this, Eagle.llIIllII[7]).getValInt())) { + KeyBinding.setKeyBindState(Eagle.mc.gameSettings.keyBindSneak.getKeyCode(), Keyboard.isKeyDown(Eagle.mc.gameSettings.keyBindSneak.getKeyCode())); + } else { + KeyBinding.setKeyBindState(Eagle.mc.gameSettings.keyBindSneak.getKeyCode(), false); + } + + } + } else { + KeyBinding.setKeyBindState(Eagle.mc.gameSettings.keyBindSneak.getKeyCode(), false); + } + } + + public void onDisable() { + KeyBinding.setKeyBindState(Eagle.mc.gameSettings.keyBindSneak.getKeyCode(), false); + } + + static { + llIIIIIIlI(); + llIIIIIIIl(); + } + + private static void llIIIIIIIl() { + llIIllII = new String[8]; + Eagle.llIIllII[0] = lIllllllIl(Eagle.llIIllIl[0], Eagle.llIIllIl[1]); + Eagle.llIIllII[1] = lIllllllIl(Eagle.llIIllIl[2], Eagle.llIIllIl[3]); + Eagle.llIIllII[2] = lIllllllIl(Eagle.llIIllIl[4], Eagle.llIIllIl[5]); + Eagle.llIIllII[3] = lIllllllll(Eagle.llIIllIl[6], Eagle.llIIllIl[7]); + Eagle.llIIllII[4] = lIllllllll(Eagle.llIIllIl[8], Eagle.llIIllIl[9]); + Eagle.llIIllII[5] = lIllllllll(Eagle.llIIllIl[10], Eagle.llIIllIl[11]); + Eagle.llIIllII[6] = llIIIIIIII(Eagle.llIIllIl[12], Eagle.llIIllIl[13]); + Eagle.llIIllII[7] = llIIIIIIII(Eagle.llIIllIl[14], Eagle.llIIllIl[15]); + Eagle.llIIllIl = null; + } + + private static void llIIIIIIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Eagle.llIIllIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIIIIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIllllllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIllllllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/movement/InvMove.java b/module/movement/InvMove.java new file mode 100644 index 0000000..cf43055 --- /dev/null +++ b/module/movement/InvMove.java @@ -0,0 +1,106 @@ +package me.explicit.module.movement; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import net.minecraft.client.gui.inventory.GuiChest; +import net.minecraft.client.gui.inventory.GuiInventory; +import net.minecraft.client.settings.KeyBinding; +import org.lwjgl.input.Keyboard; + +public class InvMove extends Module { + + private static final String[] llIlIlI; + private static String[] llIlIll; + + public InvMove() { + super(InvMove.llIlIlI[0], InvMove.llIlIlI[1], Category.MOVEMENT); + } + + public void onTick() { + if (InvMove.mc.currentScreen instanceof GuiInventory || InvMove.mc.currentScreen instanceof GuiChest) { + this.setKeys(); + } + + } + + public void onDisable() { + this.setKeys(); + } + + private void setKeys() { + if (Game.Player() != null && Game.World() != null) { + int i = InvMove.mc.gameSettings.keyBindForward.getKeyCode(); + int j = InvMove.mc.gameSettings.keyBindBack.getKeyCode(); + int k = InvMove.mc.gameSettings.keyBindRight.getKeyCode(); + int l = InvMove.mc.gameSettings.keyBindLeft.getKeyCode(); + int i1 = InvMove.mc.gameSettings.keyBindJump.getKeyCode(); + int j1 = InvMove.mc.gameSettings.keyBindSneak.getKeyCode(); + int k1 = InvMove.mc.gameSettings.keyBindSprint.getKeyCode(); + + KeyBinding.setKeyBindState(i, Keyboard.isKeyDown(i)); + KeyBinding.setKeyBindState(j, Keyboard.isKeyDown(j)); + KeyBinding.setKeyBindState(k, Keyboard.isKeyDown(k)); + KeyBinding.setKeyBindState(l, Keyboard.isKeyDown(l)); + KeyBinding.setKeyBindState(i1, Keyboard.isKeyDown(i1)); + KeyBinding.setKeyBindState(j1, Keyboard.isKeyDown(j1)); + KeyBinding.setKeyBindState(k1, Keyboard.isKeyDown(k1)); + } + + } + + static { + lIllllIII(); + lIlllIlll(); + } + + private static void lIlllIlll() { + llIlIlI = new String[2]; + InvMove.llIlIlI[0] = lIlllIlIl(InvMove.llIlIll[0], InvMove.llIlIll[1]); + InvMove.llIlIlI[1] = lIlllIllI(InvMove.llIlIll[2], InvMove.llIlIll[3]); + InvMove.llIlIll = null; + } + + private static void lIllllIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + InvMove.llIlIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlllIlIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlllIllI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/movement/NoSlow.java b/module/movement/NoSlow.java new file mode 100644 index 0000000..60091f3 --- /dev/null +++ b/module/movement/NoSlow.java @@ -0,0 +1,77 @@ +package me.explicit.module.movement; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.util.MovementInput; +import net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class NoSlow extends Module { + + private static final String[] lIIllIlI; + private static String[] lIIllIll; + + public NoSlow() { + super(NoSlow.lIIllIlI[0], 0, Category.MOVEMENT, NoSlow.lIIllIlI[1]); + } + + @SubscribeEvent + public void onLivingUpdate(LivingUpdateEvent livingupdateevent) { + if (Game.Player() != null && Game.Player().isUsingItem() && !Game.Player().isRiding()) { + EntityPlayerSP entityplayersp = Game.Player(); + + entityplayersp.moveForward *= 5.0F; + entityplayersp = Game.Player(); + entityplayersp.moveStrafing *= 5.0F; + MovementInput movementinput = Game.Player().movementInput; + + movementinput.moveForward *= 5.0F; + movementinput = Game.Player().movementInput; + movementinput.moveStrafe *= 5.0F; + entityplayersp = Game.Player(); + entityplayersp.motionX *= 1.1D; + entityplayersp = Game.Player(); + entityplayersp.motionY *= 1.1D; + } + + } + + static { + lIIIlIIlII(); + lIIIlIIIll(); + } + + private static void lIIIlIIIll() { + lIIllIlI = new String[2]; + NoSlow.lIIllIlI[0] = lIIIlIIIlI(NoSlow.lIIllIll[0], NoSlow.lIIllIll[1]); + NoSlow.lIIllIlI[1] = lIIIlIIIlI(NoSlow.lIIllIll[2], NoSlow.lIIllIll[3]); + NoSlow.lIIllIll = null; + } + + private static void lIIIlIIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + NoSlow.lIIllIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIlIIIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/movement/Parkour.java b/module/movement/Parkour.java new file mode 100644 index 0000000..2b48bfe --- /dev/null +++ b/module/movement/Parkour.java @@ -0,0 +1,82 @@ +package me.explicit.module.movement; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.init.Blocks; +import net.minecraft.util.BlockPos; +import org.lwjgl.input.Keyboard; + +public class Parkour extends Module { + + private static final String[] llIlII; + private static String[] llIllI; + + public Parkour() { + super(Parkour.llIlII[0], Parkour.llIlII[1], Category.MOVEMENT); + } + + public void onTick() { + if (Game.Player() != null && Game.World() != null && Parkour.mc.gameSettings.keyBindForward.isKeyDown()) { + if (Game.World().getBlockState((new BlockPos(Game.Player())).add(0, -1, 0)).getBlock() == Blocks.air && Parkour.mc.thePlayer.onGround) { + KeyBinding.setKeyBindState(Parkour.mc.gameSettings.keyBindJump.getKeyCode(), true); + } else { + KeyBinding.setKeyBindState(Parkour.mc.gameSettings.keyBindJump.getKeyCode(), Keyboard.isKeyDown(Parkour.mc.gameSettings.keyBindJump.getKeyCode())); + } + + } else { + KeyBinding.setKeyBindState(Parkour.mc.gameSettings.keyBindJump.getKeyCode(), Keyboard.isKeyDown(Parkour.mc.gameSettings.keyBindJump.getKeyCode())); + } + } + + static { + lIlllIIl(); + lIlIlIIl(); + } + + private static void lIlIlIIl() { + llIlII = new String[2]; + Parkour.llIlII[0] = lIlIIllI(Parkour.llIllI[0], Parkour.llIllI[1]); + Parkour.llIlII[1] = lIlIIlll(Parkour.llIllI[2], Parkour.llIllI[3]); + Parkour.llIllI = null; + } + + private static void lIlllIIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Parkour.llIllI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlIIllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIIlll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/movement/Sprint.java b/module/movement/Sprint.java new file mode 100644 index 0000000..108f4d5 --- /dev/null +++ b/module/movement/Sprint.java @@ -0,0 +1,95 @@ +package me.explicit.module.movement; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.MoveUtils; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.client.settings.KeyBinding; + +public class Sprint extends Module { + + private static final String[] llll; + private static String[] lIIII; + + public Sprint() { + super(Sprint.llll[0], 0, Category.MOVEMENT, Sprint.llll[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(Sprint.llll[2], this, false)); + } + + public void onTick() { + if (Sprint.mc.inGameHasFocus && !Game.Player().isSneaking()) { + EntityPlayerSP entityplayersp = Game.Player(); + + if (Explicit.instance.sm.getSettingByName(this, Sprint.llll[3]).getValBoolean()) { + if (MoveUtils.PlayerMoving() && entityplayersp.getFoodStats().getFoodLevel() > 6) { + entityplayersp.setSprinting(true); + } + } else { + KeyBinding.setKeyBindState(Sprint.mc.gameSettings.keyBindSprint.getKeyCode(), true); + } + } + + } + + static { + llIlIl(); + llIlII(); + } + + private static void llIlII() { + llll = new String[4]; + Sprint.llll[0] = llIIlI(Sprint.lIIII[0], Sprint.lIIII[1]); + Sprint.llll[1] = llIIll(Sprint.lIIII[2], Sprint.lIIII[3]); + Sprint.llll[2] = llIIll(Sprint.lIIII[4], Sprint.lIIII[5]); + Sprint.llll[3] = llIIll(Sprint.lIIII[6], Sprint.lIIII[7]); + Sprint.lIIII = null; + } + + private static void llIlIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Sprint.lIIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/movement/Step.java b/module/movement/Step.java new file mode 100644 index 0000000..b9b3c17 --- /dev/null +++ b/module/movement/Step.java @@ -0,0 +1,93 @@ +package me.explicit.module.movement; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; + +public class Step extends Module { + + private float oldStep; + private static final String[] llllll; + private static String[] lIIIIII; + + public Step() { + super(Step.llllll[0], 0, Category.MOVEMENT, Step.llllll[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(Step.llllll[2], this, 3.0D, 1.0D, 10.0D, false)); + } + + public void onEnable() { + super.onEnable(); + this.oldStep = Game.Player().stepHeight; + } + + public void onDisable() { + super.onDisable(); + Game.Player().stepHeight = this.oldStep; + } + + public void onTick() { + Game.Player().stepHeight = (float) Explicit.instance.sm.getSettingByName(this, Step.llllll[3]).getValInt(); + } + + static { + llIlllll(); + llIllllI(); + } + + private static void llIllllI() { + llllll = new String[4]; + Step.llllll[0] = llIlllII(Step.lIIIIII[0], Step.lIIIIII[1]); + Step.llllll[1] = llIlllIl(Step.lIIIIII[2], Step.lIIIIII[3]); + Step.llllll[2] = llIlllIl(Step.lIIIIII[4], Step.lIIIIII[5]); + Step.llllll[3] = llIlllIl(Step.lIIIIII[6], Step.lIIIIII[7]); + Step.lIIIIII = null; + } + + private static void llIlllll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Step.lIIIIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIlllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIlllII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/movement/Strafe.java b/module/movement/Strafe.java new file mode 100644 index 0000000..c710a4b --- /dev/null +++ b/module/movement/Strafe.java @@ -0,0 +1,130 @@ +package me.explicit.module.movement; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.MoveUtils; +import me.explicit.utils.PrivateUtils; +import net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class Strafe extends Module { + + private static final String[] lIIIIllIl; + private static String[] lIIIIlllI; + + public Strafe() { + super(Strafe.lIIIIllIl[0], 0, Category.MOVEMENT, Strafe.lIIIIllIl[1]); + } + + public void setup() { + ArrayList arraylist; + + (arraylist = new ArrayList()).add(Strafe.lIIIIllIl[2]); + arraylist.add(Strafe.lIIIIllIl[3]); + Explicit.instance.sm.rSetting(new Setting(Strafe.lIIIIllIl[4], this, Strafe.lIIIIllIl[5], arraylist)); + Explicit.instance.sm.rSetting(new Setting(Strafe.lIIIIllIl[6], this, 1.08D, 0.1D, 3.0D, false)); + } + + @SubscribeEvent + public void onLivingUpdate(LivingUpdateEvent livingupdateevent) { + double d0 = Explicit.instance.sm.getSettingByName(this, Strafe.lIIIIllIl[7]).getValDouble(); + String s = Explicit.instance.sm.getSettingByName(this, Strafe.lIIIIllIl[8]).getValString(); + + if (livingupdateevent.entityLiving != null && livingupdateevent.entityLiving == Game.Player()) { + if (s.equalsIgnoreCase(Strafe.lIIIIllIl[9])) { + if (Game.Player().moveStrafing != 0.0F && Game.Player().onGround && Game.Player().ticksExisted % 2 == 0) { + MoveUtils.setMoveSpeed(d0 / 3.0D); + } + } else if (s.equalsIgnoreCase(Strafe.lIIIIllIl[10])) { + if (Game.Player().moveStrafing != 0.0F && Game.Player().onGround) { + PrivateUtils.timer().timerSpeed = (float) d0; + } else if (!Explicit.instance.mm.getModuleByName(Strafe.lIIIIllIl[11]).isToggled()) { + PrivateUtils.timer().timerSpeed = 1.0F; + } + } + } + + } + + static { + lllIllllll(); + lllIllllIl(); + } + + private static void lllIllllIl() { + lIIIIllIl = new String[12]; + Strafe.lIIIIllIl[0] = lllIlllIIl(Strafe.lIIIIlllI[0], Strafe.lIIIIlllI[1]); + Strafe.lIIIIllIl[1] = lllIlllIIl(Strafe.lIIIIlllI[2], Strafe.lIIIIlllI[3]); + Strafe.lIIIIllIl[2] = lllIlllIlI(Strafe.lIIIIlllI[4], Strafe.lIIIIlllI[5]); + Strafe.lIIIIllIl[3] = lllIlllIlI(Strafe.lIIIIlllI[6], Strafe.lIIIIlllI[7]); + Strafe.lIIIIllIl[4] = lllIlllIlI(Strafe.lIIIIlllI[8], Strafe.lIIIIlllI[9]); + Strafe.lIIIIllIl[5] = lllIlllIIl(Strafe.lIIIIlllI[10], Strafe.lIIIIlllI[11]); + Strafe.lIIIIllIl[6] = lllIlllIIl(Strafe.lIIIIlllI[12], Strafe.lIIIIlllI[13]); + Strafe.lIIIIllIl[7] = lllIlllIIl(Strafe.lIIIIlllI[14], Strafe.lIIIIlllI[15]); + Strafe.lIIIIllIl[8] = lllIllllII(Strafe.lIIIIlllI[16], Strafe.lIIIIlllI[17]); + Strafe.lIIIIllIl[9] = lllIllllII(Strafe.lIIIIlllI[18], Strafe.lIIIIlllI[19]); + Strafe.lIIIIllIl[10] = lllIlllIIl(Strafe.lIIIIlllI[20], Strafe.lIIIIlllI[21]); + Strafe.lIIIIllIl[11] = lllIlllIlI(Strafe.lIIIIlllI[22], Strafe.lIIIIlllI[23]); + Strafe.lIIIIlllI = null; + } + + private static void lllIllllll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Strafe.lIIIIlllI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllIlllIlI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lllIllllII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllIlllIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/player/AutoArmor.java b/module/player/AutoArmor.java new file mode 100644 index 0000000..88321f3 --- /dev/null +++ b/module/player/AutoArmor.java @@ -0,0 +1,281 @@ +package me.explicit.module.player; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.concurrent.ThreadLocalRandom; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.gui.GuiChat; +import net.minecraft.client.gui.inventory.GuiInventory; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.enchantment.EnchantmentHelper; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemPotion; +import net.minecraft.item.ItemStack; + +public class AutoArmor extends Module { + + private TimerUtils timer = new TimerUtils(); + private TimerUtils dropTimer = new TimerUtils(); + private boolean dropping; + private double delay; + private static final String[] lIIlI; + private static String[] lIIll; + + public AutoArmor() { + super(AutoArmor.lIIlI[0], 0, Category.PLAYER, AutoArmor.lIIlI[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(AutoArmor.lIIlI[2], this, 100.0D, 0.0D, 1000.0D, true)); + Explicit.instance.sm.rSetting(new Setting(AutoArmor.lIIlI[3], this, 150.0D, 0.0D, 1000.0D, true)); + Explicit.instance.sm.rSetting(new Setting(AutoArmor.lIIlI[4], this, true)); + Explicit.instance.sm.rSetting(new Setting(AutoArmor.lIIlI[5], this, false)); + } + + public void onTick() { + if (this.isToggled()) { + String s; + + if (Explicit.instance.sm.getSettingByName(this, AutoArmor.lIIlI[6]).getValBoolean()) { + s = AutoArmor.lIIlI[7]; + } else { + s = AutoArmor.lIIlI[8]; + } + + double d0 = Explicit.instance.sm.getSettingByName(this, AutoArmor.lIIlI[9]).getValDouble(); + double d1 = Explicit.instance.sm.getSettingByName(this, AutoArmor.lIIlI[10]).getValDouble(); + + if (d0 == d1) { + d1 = d0 * 1.1D; + } + + this.delay = ThreadLocalRandom.current().nextDouble(Math.min(d0, d1), Math.max(d0, d1)); + if (!s.equalsIgnoreCase(AutoArmor.lIIlI[11]) || AutoArmor.mc.currentScreen instanceof GuiInventory) { + if ((AutoArmor.mc.currentScreen == null || AutoArmor.mc.currentScreen instanceof GuiInventory || AutoArmor.mc.currentScreen instanceof GuiChat) && this.timer.hasReached(this.delay)) { + this.getBestArmor(); + } + + if (!this.dropping) { + if ((AutoArmor.mc.currentScreen == null || AutoArmor.mc.currentScreen instanceof GuiInventory || AutoArmor.mc.currentScreen instanceof GuiChat) && this.timer.hasReached(this.delay)) { + this.getBestArmor(); + } + } else if (this.dropTimer.hasReached(this.delay)) { + Module.mc.playerController.windowClick(Module.mc.thePlayer.inventoryContainer.windowId, -999, 0, 0, Module.mc.thePlayer); + this.dropTimer.reset(); + this.dropping = false; + } + + } + } + } + + public void getBestArmor() { + int i; + ItemStack itemstack; + + for (i = 1; i < 5; ++i) { + if (AutoArmor.mc.thePlayer.inventoryContainer.getSlot(4 + i).getHasStack()) { + itemstack = AutoArmor.mc.thePlayer.inventoryContainer.getSlot(4 + i).getStack(); + if (isBestArmor(itemstack, i)) { + continue; + } + + if (Explicit.instance.sm.getSettingByName(this, AutoArmor.lIIlI[12]).getValBoolean()) { + this.drop(4 + i); + } else { + this.shiftClick(4 + i); + } + } + + for (int j = 9; j < 45; ++j) { + if (AutoArmor.mc.thePlayer.inventoryContainer.getSlot(j).getHasStack()) { + ItemStack itemstack1 = AutoArmor.mc.thePlayer.inventoryContainer.getSlot(j).getStack(); + + if (isBestArmor(itemstack1, i) && getProtection(itemstack1) > 0.0F) { + this.shiftClick(j); + this.timer.reset(); + if (this.delay > 0.0D) { + return; + } + } + } + } + } + + if (Explicit.instance.sm.getSettingByName(this, AutoArmor.lIIlI[13]).getValBoolean()) { + for (i = 9; i < 45; ++i) { + if (AutoArmor.mc.thePlayer.inventoryContainer.getSlot(i).getHasStack()) { + itemstack = AutoArmor.mc.thePlayer.inventoryContainer.getSlot(i).getStack(); + if ((getProtection(itemstack) > 0.0F || this.isDuplicate(itemstack, i)) && !this.dropping && itemstack.getItem() instanceof ItemArmor) { + this.drop(i); + } + } + } + } + + } + + public boolean isDuplicate(ItemStack itemstack, int i) { + for (int j = 0; j < 45; ++j) { + if (Module.mc.thePlayer.inventoryContainer.getSlot(j).getHasStack()) { + ItemStack itemstack1 = Module.mc.thePlayer.inventoryContainer.getSlot(j).getStack(); + + if (itemstack1 != itemstack && i != j && getProtection(itemstack) == getProtection(itemstack1) && itemstack1.getItem() instanceof ItemArmor && !(itemstack1.getItem() instanceof ItemPotion) && !(itemstack1.getItem() instanceof ItemBlock)) { + return true; + } + } + } + + return false; + } + + public static boolean isBestArmor(ItemStack itemstack, int i) { + float f = getProtection(itemstack); + String s = AutoArmor.lIIlI[14]; + + if (i == 1) { + s = AutoArmor.lIIlI[15]; + } else if (i == 2) { + s = AutoArmor.lIIlI[16]; + } else if (i == 3) { + s = AutoArmor.lIIlI[17]; + } else if (i == 4) { + s = AutoArmor.lIIlI[18]; + } + + if (!itemstack.getUnlocalizedName().contains(s)) { + return false; + } else { + for (int j = 5; j < 45; ++j) { + if (AutoArmor.mc.thePlayer.inventoryContainer.getSlot(j).getHasStack()) { + ItemStack itemstack1 = AutoArmor.mc.thePlayer.inventoryContainer.getSlot(j).getStack(); + + if (getProtection(itemstack1) > f && itemstack1.getUnlocalizedName().contains(s)) { + return false; + } + } + } + + return true; + } + } + + public void shiftClick(int i) { + AutoArmor.mc.playerController.windowClick(AutoArmor.mc.thePlayer.inventoryContainer.windowId, i, 0, 1, AutoArmor.mc.thePlayer); + } + + public void drop(int i) { + if (Explicit.instance.sm.getSettingByName(this, AutoArmor.lIIlI[19]).getValBoolean() && this.dropTimer.hasReached(this.delay) && !this.dropping) { + Module.mc.playerController.windowClick(Module.mc.thePlayer.inventoryContainer.windowId, i, 0, 0, Module.mc.thePlayer); + this.dropping = true; + this.dropTimer.reset(); + } + + } + + public static float getProtection(ItemStack itemstack) { + float f = 0.0F; + + if (itemstack.getItem() instanceof ItemArmor) { + ItemArmor itemarmor = (ItemArmor) itemstack.getItem(); + + f = (float) ((double) f + (double) itemarmor.damageReduceAmount + (double) ((100 - itemarmor.damageReduceAmount) * EnchantmentHelper.getEnchantmentLevel(Enchantment.protection.effectId, itemstack)) * 0.0075D); + f = (float) ((double) f + (double) EnchantmentHelper.getEnchantmentLevel(Enchantment.blastProtection.effectId, itemstack) / 100.0D); + f = (float) ((double) f + (double) EnchantmentHelper.getEnchantmentLevel(Enchantment.fireProtection.effectId, itemstack) / 100.0D); + f = (float) ((double) f + (double) EnchantmentHelper.getEnchantmentLevel(Enchantment.thorns.effectId, itemstack) / 100.0D); + f = (float) ((double) f + (double) EnchantmentHelper.getEnchantmentLevel(Enchantment.unbreaking.effectId, itemstack) / 50.0D); + f = (float) ((double) f + (double) EnchantmentHelper.getEnchantmentLevel(Enchantment.projectileProtection.effectId, itemstack) / 100.0D); + } + + return f; + } + + static { + llllll(); + lllIIl(); + } + + private static void lllIIl() { + lIIlI = new String[20]; + AutoArmor.lIIlI[0] = llIllI(AutoArmor.lIIll[0], AutoArmor.lIIll[1]); + AutoArmor.lIIlI[1] = llIlll(AutoArmor.lIIll[2], AutoArmor.lIIll[3]); + AutoArmor.lIIlI[2] = lllIII(AutoArmor.lIIll[4], AutoArmor.lIIll[5]); + AutoArmor.lIIlI[3] = llIllI(AutoArmor.lIIll[6], AutoArmor.lIIll[7]); + AutoArmor.lIIlI[4] = lllIII(AutoArmor.lIIll[8], AutoArmor.lIIll[9]); + AutoArmor.lIIlI[5] = llIllI(AutoArmor.lIIll[10], AutoArmor.lIIll[11]); + AutoArmor.lIIlI[6] = lllIII(AutoArmor.lIIll[12], AutoArmor.lIIll[13]); + AutoArmor.lIIlI[7] = llIllI(AutoArmor.lIIll[14], AutoArmor.lIIll[15]); + AutoArmor.lIIlI[8] = llIlll(AutoArmor.lIIll[16], AutoArmor.lIIll[17]); + AutoArmor.lIIlI[9] = lllIII(AutoArmor.lIIll[18], AutoArmor.lIIll[19]); + AutoArmor.lIIlI[10] = llIllI(AutoArmor.lIIll[20], AutoArmor.lIIll[21]); + AutoArmor.lIIlI[11] = llIlll(AutoArmor.lIIll[22], AutoArmor.lIIll[23]); + AutoArmor.lIIlI[12] = llIllI(AutoArmor.lIIll[24], AutoArmor.lIIll[25]); + AutoArmor.lIIlI[13] = lllIII(AutoArmor.lIIll[26], AutoArmor.lIIll[27]); + AutoArmor.lIIlI[14] = llIlll(AutoArmor.lIIll[28], AutoArmor.lIIll[29]); + AutoArmor.lIIlI[15] = llIlll(AutoArmor.lIIll[30], AutoArmor.lIIll[31]); + AutoArmor.lIIlI[16] = llIlll(AutoArmor.lIIll[32], AutoArmor.lIIll[33]); + AutoArmor.lIIlI[17] = llIlll(AutoArmor.lIIll[34], AutoArmor.lIIll[35]); + AutoArmor.lIIlI[18] = llIllI(AutoArmor.lIIll[36], AutoArmor.lIIll[37]); + AutoArmor.lIIlI[19] = llIllI(AutoArmor.lIIll[38], AutoArmor.lIIll[39]); + AutoArmor.lIIll = null; + } + + private static void llllll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AutoArmor.lIIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIllI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIlll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/player/AutoClutch.java b/module/player/AutoClutch.java new file mode 100644 index 0000000..746be43 --- /dev/null +++ b/module/player/AutoClutch.java @@ -0,0 +1,174 @@ +package me.explicit.module.player; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.PrivateUtils; +import me.explicit.utils.RotationUtils; +import me.explicit.utils.TimerUtils; +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.network.play.client.C09PacketHeldItemChange; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.Vec3; + +public class AutoClutch extends Module { + + public static List badBlocks; + private int distanceToTheGround = 5; + private TimerUtils timer = new TimerUtils(); + private BlockData blockBelowData; + private BlockPos lastBlockPos; + private double fallStartY = 0.0D; + private static final String[] lIlllIII; + private static String[] lIlllIIl; + + public AutoClutch() { + super(AutoClutch.lIlllIII[0], 0, Category.PLAYER, AutoClutch.lIlllIII[1]); + } + + public void onTick() { + if (!Module.mc.thePlayer.onGround && Module.mc.thePlayer.motionY > 0.0D && Module.mc.gameSettings.keyBindJump.isKeyDown() && this.lastBlockPos != null && (double) this.lastBlockPos.getX() == Math.floor(Module.mc.thePlayer.posX) && (double) this.lastBlockPos.getZ() == Math.floor(Module.mc.thePlayer.posZ)) { + BlockPos blockpos = new BlockPos(Module.mc.thePlayer.posX, Module.mc.thePlayer.posY - 1.0D, Module.mc.thePlayer.posZ); + IBlockState iblockstate = Module.mc.theWorld.getBlockState(blockpos); + + if (iblockstate.getBlock() == Blocks.air && this.timer.delay(100.0F)) { + this.blockBelowData = this.getBlockData(blockpos); + if (this.blockBelowData != null) { + float[] afloat = RotationUtils.getRotationsBlock(this.blockBelowData.position, this.blockBelowData.face); + + AutoClutch.mc.thePlayer.rotationYaw = afloat[0]; + AutoClutch.mc.thePlayer.rotationPitch = afloat[1]; + } + } + } else if (!Module.mc.thePlayer.onGround && Module.mc.thePlayer.motionY < 0.0D) { + if (this.fallStartY < Module.mc.thePlayer.posY) { + this.fallStartY = Module.mc.thePlayer.posY; + } + + if (this.fallStartY - Module.mc.thePlayer.posY > 2.0D) { + double d0 = Module.mc.thePlayer.posX; + double d1 = Module.mc.thePlayer.posY - 1.5D; + double d2 = Module.mc.thePlayer.posZ; + BlockPos blockpos1 = new BlockPos(d0, d1, d2); + IBlockState iblockstate1 = Module.mc.theWorld.getBlockState(blockpos1); + IBlockState iblockstate2 = Module.mc.theWorld.getBlockState(new BlockPos(d0, d1 - 1.0D, d2)); + + if (!iblockstate2.getBlock().isFullCube() && !Module.mc.thePlayer.isSneaking() && (iblockstate1.getBlock() == Blocks.air || iblockstate1.getBlock() == Blocks.snow_layer || iblockstate1.getBlock() == Blocks.tallgrass) && this.timer.delay(100.0F)) { + this.timer.reset(); + this.lastBlockPos = blockpos1; + this.blockBelowData = this.getBlockData(blockpos1); + if (this.blockBelowData != null) { + float[] afloat1 = RotationUtils.getRotationsBlock(this.blockBelowData.position, this.blockBelowData.face); + + AutoClutch.mc.thePlayer.rotationYaw = afloat1[0]; + AutoClutch.mc.thePlayer.rotationPitch = afloat1[1]; + } + } + } else { + this.blockBelowData = null; + } + } else { + this.fallStartY = 0.0D; + } + + this.blockBelowData = null; + if (this.blockBelowData != null) { + for (int i = 36; i < 45; ++i) { + if (Module.mc.thePlayer.inventoryContainer.getSlot(i).getHasStack()) { + ItemStack itemstack = Module.mc.thePlayer.inventoryContainer.getSlot(i).getStack(); + Item item = itemstack.getItem(); + + if (item instanceof ItemBlock && !AutoClutch.badBlocks.contains(((ItemBlock) item).getBlock()) && !((ItemBlock) item).getBlock().getLocalizedName().toLowerCase().contains(AutoClutch.lIlllIII[2])) { + PrivateUtils.setRightClickDelayTimer(0); + int j = Module.mc.thePlayer.inventory.currentItem; + + Module.mc.thePlayer.sendQueue.addToSendQueue(new C09PacketHeldItemChange(i - 36)); + Module.mc.thePlayer.inventory.currentItem = i - 36; + Module.mc.playerController.updateController(); + + try { + if (Module.mc.playerController.onPlayerRightClick(Module.mc.thePlayer, Module.mc.theWorld, Module.mc.thePlayer.inventory.getCurrentItem(), this.blockBelowData.position, this.blockBelowData.face, new Vec3((double) this.blockBelowData.position.getX(), (double) this.blockBelowData.position.getY(), (double) this.blockBelowData.position.getZ()))) { + Module.mc.thePlayer.swingItem(); + } + } catch (Exception exception) { + ; + } + + this.blockBelowData = null; + Module.mc.thePlayer.inventory.currentItem = j; + Module.mc.playerController.updateController(); + return; + } + } + } + } + + } + + private BlockData getBlockData(BlockPos blockpos) { + return !AutoClutch.badBlocks.contains(Module.mc.theWorld.getBlockState(blockpos.add(-1, 0, 0)).getBlock()) ? new BlockData(blockpos.add(-1, 0, 0), EnumFacing.EAST) : (!AutoClutch.badBlocks.contains(Module.mc.theWorld.getBlockState(blockpos.add(1, 0, 0)).getBlock()) ? new BlockData(blockpos.add(1, 0, 0), EnumFacing.WEST) : (!AutoClutch.badBlocks.contains(Module.mc.theWorld.getBlockState(blockpos.add(0, 0, -1)).getBlock()) ? new BlockData(blockpos.add(0, 0, -1), EnumFacing.SOUTH) : (!AutoClutch.badBlocks.contains(Module.mc.theWorld.getBlockState(blockpos.add(0, 0, 1)).getBlock()) ? new BlockData(blockpos.add(0, 0, 1), EnumFacing.NORTH) : null))); + } + + static { + lIlIlIIIlI(); + lIlIlIIIIl(); + AutoClutch.badBlocks = Arrays.asList(new Block[] { Blocks.air, Blocks.water, Blocks.flowing_water, Blocks.lava, Blocks.flowing_lava, Blocks.enchanting_table, Blocks.carpet, Blocks.glass_pane, Blocks.stained_glass_pane, Blocks.iron_bars, Blocks.snow_layer, Blocks.ice, Blocks.packed_ice, Blocks.coal_ore, Blocks.diamond_ore, Blocks.emerald_ore, Blocks.chest, Blocks.torch, Blocks.anvil, Blocks.trapped_chest, Blocks.noteblock, Blocks.jukebox, Blocks.tnt, Blocks.gold_ore, Blocks.iron_ore, Blocks.lapis_ore, Blocks.lit_redstone_ore, Blocks.quartz_ore, Blocks.redstone_ore, Blocks.wooden_pressure_plate, Blocks.stone_pressure_plate, Blocks.light_weighted_pressure_plate, Blocks.heavy_weighted_pressure_plate, Blocks.stone_button, Blocks.wooden_button, Blocks.lever}); + } + + private static void lIlIlIIIIl() { + lIlllIII = new String[3]; + AutoClutch.lIlllIII[0] = lIlIIlllll(AutoClutch.lIlllIIl[0], AutoClutch.lIlllIIl[1]); + AutoClutch.lIlllIII[1] = lIlIIlllll(AutoClutch.lIlllIIl[2], AutoClutch.lIlllIIl[3]); + AutoClutch.lIlllIII[2] = lIlIlIIIII(AutoClutch.lIlllIIl[4], AutoClutch.lIlllIIl[5]); + AutoClutch.lIlllIIl = null; + } + + private static void lIlIlIIIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AutoClutch.lIlllIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlIlIIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIlIIlllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/player/AutoHotbar.java b/module/player/AutoHotbar.java new file mode 100644 index 0000000..2d0affb --- /dev/null +++ b/module/player/AutoHotbar.java @@ -0,0 +1,180 @@ +package me.explicit.module.player; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.gui.inventory.GuiInventory; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class AutoHotbar extends Module { + + private TimerUtils timer = new TimerUtils(); + private double speed; + private static final String[] lIIlIlIl; + private static String[] lIIllIII; + + public AutoHotbar() { + super(AutoHotbar.lIIlIlIl[0], 0, Category.PLAYER, AutoHotbar.lIIlIlIl[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(AutoHotbar.lIIlIlIl[2], this, false)); + Explicit.instance.sm.rSetting(new Setting(AutoHotbar.lIIlIlIl[3], this, true)); + Explicit.instance.sm.rSetting(new Setting(AutoHotbar.lIIlIlIl[4], this, false)); + Explicit.instance.sm.rSetting(new Setting(AutoHotbar.lIIlIlIl[5], this, true)); + Explicit.instance.sm.rSetting(new Setting(AutoHotbar.lIIlIlIl[6], this, 0.2D, 0.0D, 1.0D, false)); + Explicit.instance.sm.rSetting(new Setting(AutoHotbar.lIIlIlIl[7], this, 0.4D, 0.0D, 1.001D, false)); + } + + public void onEnable() { + this.updateSpeed(); + } + + private void updateSpeed() { + double d0 = Explicit.instance.sm.getSettingByName(this, AutoHotbar.lIIlIlIl[8]).getValDouble(); + double d1 = Explicit.instance.sm.getSettingByName(this, AutoHotbar.lIIlIlIl[9]).getValDouble(); + + if (d0 == d1) { + d1 = d0 + 1.0D; + } + + this.speed = ThreadLocalRandom.current().nextDouble(Math.min(d0, d1), Math.max(d0, d1)); + } + + public void onUpdate() { + if (AutoHotbar.mc.currentScreen instanceof GuiInventory && this.timer.hasReached(this.speed * 1000.0D)) { + if (!this.isHotbarFull() && this.getItem() != -1) { + this.shiftClick(this.getItem()); + this.updateSpeed(); + } + + this.timer.reset(); + this.updateSpeed(); + } + + } + + private int getItem() { + for (int i = 9; i < 36; ++i) { + if (this.isValidItem(Game.Player().inventory.mainInventory[i])) { + return i; + } + } + + return -1; + } + + private boolean isHotbarFull() { + for (int i = 0; i < 9; ++i) { + if (Game.Player().inventory.mainInventory[i] == null) { + return false; + } + } + + return true; + } + + private void shiftClick(int i) { + Module.mc.playerController.windowClick(AutoHotbar.mc.thePlayer.inventoryContainer.windowId, i, 0, 1, Module.mc.thePlayer); + } + + private boolean isValidItem(ItemStack itemstack) { + if (itemstack == null) { + return false; + } else { + boolean flag = Explicit.instance.sm.getSettingByName(this, AutoHotbar.lIIlIlIl[10]).getValBoolean(); + boolean flag1 = Explicit.instance.sm.getSettingByName(this, AutoHotbar.lIIlIlIl[11]).getValBoolean(); + boolean flag2 = Explicit.instance.sm.getSettingByName(this, AutoHotbar.lIIlIlIl[12]).getValBoolean(); + boolean flag3 = Explicit.instance.sm.getSettingByName(this, AutoHotbar.lIIlIlIl[13]).getValBoolean(); + + return Item.getIdFromItem(itemstack.getItem()) == 373 && flag && itemstack.getItem().getItemStackDisplayName(itemstack).toLowerCase().contains(AutoHotbar.lIIlIlIl[14]) ? true : (Item.getIdFromItem(itemstack.getItem()) == 373 && flag1 && !itemstack.getItem().getItemStackDisplayName(itemstack).toLowerCase().contains(AutoHotbar.lIIlIlIl[15]) ? true : ((Item.getIdFromItem(itemstack.getItem()) == 332 || Item.getIdFromItem(itemstack.getItem()) == 344) && flag2 ? true : Item.getIdFromItem(itemstack.getItem()) == 436 && flag3)); + } + } + + static { + lIIIIlIlII(); + lIIIIlIIll(); + } + + private static void lIIIIlIIll() { + lIIlIlIl = new String[16]; + AutoHotbar.lIIlIlIl[0] = lIIIIIlllI(AutoHotbar.lIIllIII[0], AutoHotbar.lIIllIII[1]); + AutoHotbar.lIIlIlIl[1] = lIIIIIllll(AutoHotbar.lIIllIII[2], AutoHotbar.lIIllIII[3]); + AutoHotbar.lIIlIlIl[2] = lIIIIlIIII(AutoHotbar.lIIllIII[4], AutoHotbar.lIIllIII[5]); + AutoHotbar.lIIlIlIl[3] = lIIIIIlllI(AutoHotbar.lIIllIII[6], AutoHotbar.lIIllIII[7]); + AutoHotbar.lIIlIlIl[4] = lIIIIIllll(AutoHotbar.lIIllIII[8], AutoHotbar.lIIllIII[9]); + AutoHotbar.lIIlIlIl[5] = lIIIIIllll(AutoHotbar.lIIllIII[10], AutoHotbar.lIIllIII[11]); + AutoHotbar.lIIlIlIl[6] = lIIIIlIIII(AutoHotbar.lIIllIII[12], AutoHotbar.lIIllIII[13]); + AutoHotbar.lIIlIlIl[7] = lIIIIIlllI(AutoHotbar.lIIllIII[14], AutoHotbar.lIIllIII[15]); + AutoHotbar.lIIlIlIl[8] = lIIIIIlllI(AutoHotbar.lIIllIII[16], AutoHotbar.lIIllIII[17]); + AutoHotbar.lIIlIlIl[9] = lIIIIIlllI(AutoHotbar.lIIllIII[18], AutoHotbar.lIIllIII[19]); + AutoHotbar.lIIlIlIl[10] = lIIIIIllll(AutoHotbar.lIIllIII[20], AutoHotbar.lIIllIII[21]); + AutoHotbar.lIIlIlIl[11] = lIIIIlIIII(AutoHotbar.lIIllIII[22], AutoHotbar.lIIllIII[23]); + AutoHotbar.lIIlIlIl[12] = lIIIIIllll(AutoHotbar.lIIllIII[24], AutoHotbar.lIIllIII[25]); + AutoHotbar.lIIlIlIl[13] = lIIIIlIIII(AutoHotbar.lIIllIII[26], AutoHotbar.lIIllIII[27]); + AutoHotbar.lIIlIlIl[14] = lIIIIlIIII(AutoHotbar.lIIllIII[28], AutoHotbar.lIIllIII[29]); + AutoHotbar.lIIlIlIl[15] = lIIIIlIIII(AutoHotbar.lIIllIII[30], AutoHotbar.lIIllIII[31]); + AutoHotbar.lIIllIII = null; + } + + private static void lIIIIlIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AutoHotbar.lIIllIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIIllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIIIlllI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIIlIIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/player/AutoMLG.java b/module/player/AutoMLG.java new file mode 100644 index 0000000..760d5f8 --- /dev/null +++ b/module/player/AutoMLG.java @@ -0,0 +1,258 @@ +package me.explicit.module.player; + +import io.netty.util.internal.ThreadLocalRandom; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.PrivateUtils; +import net.minecraft.block.BlockAir; +import net.minecraft.client.Minecraft; +import net.minecraft.client.settings.KeyBinding; +import net.minecraft.item.ItemBucket; +import net.minecraft.util.BlockPos; +import org.lwjgl.input.Keyboard; +import org.lwjgl.input.Mouse; + +public class AutoMLG extends Module { + + private int oldSlot; + private boolean lastFell; + private static final String[] lIIIIIlI; + private static String[] lIIIIlII; + + public AutoMLG() { + super(AutoMLG.lIIIIIlI[0], 0, Category.PLAYER, AutoMLG.lIIIIIlI[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(AutoMLG.lIIIIIlI[2], this, 4.0D, 3.0D, 10.0D, false)); + Explicit.instance.sm.rSetting(new Setting(AutoMLG.lIIIIIlI[3], this, false)); + Explicit.instance.sm.rSetting(new Setting(AutoMLG.lIIIIIlI[4], this, true)); + Explicit.instance.sm.rSetting(new Setting(AutoMLG.lIIIIIlI[5], this, false)); + } + + public void onUpdate() { + final boolean flag = Explicit.instance.sm.getSettingByName(this, AutoMLG.lIIIIIlI[6]).getValBoolean(); + boolean flag1 = Explicit.instance.sm.getSettingByName(this, AutoMLG.lIIIIIlI[7]).getValBoolean(); + boolean flag2 = Explicit.instance.sm.getSettingByName(this, AutoMLG.lIIIIIlI[8]).getValBoolean(); + double d0 = Explicit.instance.sm.getSettingByName(this, AutoMLG.lIIIIIlI[9]).getValDouble(); + + if ((double) Game.Player().fallDistance > d0 && this.isBlockUnderneath() && !AutoMLG.mc.thePlayer.onGround && this.getWaterBucketSlot() != -1) { + if (flag1) { + AutoMLG.mc.thePlayer.inventory.currentItem = this.getWaterBucketSlot(); + } + + if (this.isHoldingWaterBucket()) { + if (flag) { + Game.Player().rotationPitch = 90.0F; + } + + PrivateUtils.setRightClickDelayTimer(0); + KeyBinding.setKeyBindState(AutoMLG.mc.gameSettings.keyBindUseItem.getKeyCode(), true); + this.lastFell = true; + if (flag2) { + Thread thread = new Thread(new Runnable() { + final boolean val$autoaim = flag; + final AutoMLG this$0 = AutoMLG.this; + + public void run() { + try { + Thread.sleep(100L); + } catch (InterruptedException interruptedexception) { + interruptedexception.printStackTrace(); + } + + if (this.this$0.isHoldingEmptyBucket()) { + if (this.val$autoaim) { + Game.Player().rotationPitch = 90.0F; + } + + if (!AutoMLG.mc.gameSettings.keyBindUseItem.isKeyDown()) { + KeyBinding.setKeyBindState(AutoMLG.mc.gameSettings.keyBindUseItem.getKeyCode(), true); + } + + try { + Thread.sleep(ThreadLocalRandom.current().nextLong(200L, 500L)); + } catch (InterruptedException interruptedexception1) { + interruptedexception1.printStackTrace(); + } + + KeyBinding.setKeyBindState(AutoMLG.mc.gameSettings.keyBindUseItem.getKeyCode(), false); + } + + } + }); + + thread.start(); + } + } else { + this.StopMLG(); + } + } else { + this.StopMLG(); + } + + } + + private void StopMLG() { + if (!this.lastFell) { + this.oldSlot = AutoMLG.mc.thePlayer.inventory.currentItem; + } else { + AutoMLG.mc.thePlayer.inventory.currentItem = this.oldSlot; + KeyBinding.setKeyBindState(AutoMLG.mc.gameSettings.keyBindUseItem.getKeyCode(), this.isKeyDown(AutoMLG.mc.gameSettings.keyBindUseItem.getKeyCode())); + PrivateUtils.setRightClickDelayTimer(4); + } + + this.lastFell = false; + } + + private boolean isBlockUnderneath() { + boolean flag = false; + + for (int i = 0; (double) i < Module.mc.thePlayer.posY + 2.0D; ++i) { + BlockPos blockpos = new BlockPos(Module.mc.thePlayer.posX, (double) i, Module.mc.thePlayer.posZ); + + if (!(Module.mc.theWorld.getBlockState(blockpos).getBlock() instanceof BlockAir)) { + flag = true; + } + } + + return flag; + } + + private boolean isHoldingWaterBucket() { + return Game.Player().getCurrentEquippedItem() != null && Game.Player().getCurrentEquippedItem().getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[10]); + } + + private boolean isHoldingEmptyBucket() { + return Game.Player().getCurrentEquippedItem() != null && Game.Player().getCurrentEquippedItem().getItem() instanceof ItemBucket && !Game.Player().getCurrentEquippedItem().getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[11]) && !Game.Player().getCurrentEquippedItem().getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[12]) && !Game.Player().getCurrentEquippedItem().getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[13]); + } + + private int getWaterBucketSlot() { + for (int i = 0; i < 9; ++i) { + if (Game.Player().inventory.getStackInSlot(i) != null && (Game.Player().inventory.getStackInSlot(i).getItem() instanceof ItemBucket && !Game.Player().inventory.getStackInSlot(i).getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[14]) && Game.Player().inventory.getStackInSlot(i).getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[15]) || Game.Player().inventory.getStackInSlot(i).getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[16]))) { + return i; + } + } + + return -1; + } + + private int getEmptyBucketSlot() { + for (int i = 0; i < 9; ++i) { + if (Game.Player().inventory.getStackInSlot(i) != null && Game.Player().inventory.getStackInSlot(i).getItem() instanceof ItemBucket && !Game.Player().inventory.getStackInSlot(i).getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[17]) && !Game.Player().inventory.getStackInSlot(i).getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[18]) && !Game.Player().inventory.getStackInSlot(i).getItem().getUnlocalizedName().toLowerCase().contains(AutoMLG.lIIIIIlI[19])) { + return i; + } + } + + return -1; + } + + private boolean isKeyDown(int i) { + return i < 0 ? Mouse.isButtonDown(i + 100) : Keyboard.isKeyDown(i); + } + + static boolean access$000(AutoMLG automlg) { + return automlg.isHoldingEmptyBucket(); + } + + static Minecraft access$100() { + return AutoMLG.mc; + } + + static Minecraft access$200() { + return AutoMLG.mc; + } + + static Minecraft access$300() { + return AutoMLG.mc; + } + + static { + lllIIIIll(); + lllIIIIlI(); + } + + private static void lllIIIIlI() { + lIIIIIlI = new String[20]; + AutoMLG.lIIIIIlI[0] = llIllllIl(AutoMLG.lIIIIlII[0], AutoMLG.lIIIIlII[1]); + AutoMLG.lIIIIIlI[1] = llIlllllI(AutoMLG.lIIIIlII[2], AutoMLG.lIIIIlII[3]); + AutoMLG.lIIIIIlI[2] = llIlllllI(AutoMLG.lIIIIlII[4], AutoMLG.lIIIIlII[5]); + AutoMLG.lIIIIIlI[3] = llIllllIl(AutoMLG.lIIIIlII[6], AutoMLG.lIIIIlII[7]); + AutoMLG.lIIIIIlI[4] = llIllllll(AutoMLG.lIIIIlII[8], AutoMLG.lIIIIlII[9]); + AutoMLG.lIIIIIlI[5] = llIllllIl(AutoMLG.lIIIIlII[10], AutoMLG.lIIIIlII[11]); + AutoMLG.lIIIIIlI[6] = llIlllllI(AutoMLG.lIIIIlII[12], AutoMLG.lIIIIlII[13]); + AutoMLG.lIIIIIlI[7] = llIlllllI(AutoMLG.lIIIIlII[14], AutoMLG.lIIIIlII[15]); + AutoMLG.lIIIIIlI[8] = llIllllll(AutoMLG.lIIIIlII[16], AutoMLG.lIIIIlII[17]); + AutoMLG.lIIIIIlI[9] = llIlllllI(AutoMLG.lIIIIlII[18], AutoMLG.lIIIIlII[19]); + AutoMLG.lIIIIIlI[10] = llIllllll(AutoMLG.lIIIIlII[20], AutoMLG.lIIIIlII[21]); + AutoMLG.lIIIIIlI[11] = llIlllllI(AutoMLG.lIIIIlII[22], AutoMLG.lIIIIlII[23]); + AutoMLG.lIIIIIlI[12] = llIllllIl(AutoMLG.lIIIIlII[24], AutoMLG.lIIIIlII[25]); + AutoMLG.lIIIIIlI[13] = llIllllll(AutoMLG.lIIIIlII[26], AutoMLG.lIIIIlII[27]); + AutoMLG.lIIIIIlI[14] = llIllllIl(AutoMLG.lIIIIlII[28], AutoMLG.lIIIIlII[29]); + AutoMLG.lIIIIIlI[15] = llIllllIl(AutoMLG.lIIIIlII[30], AutoMLG.lIIIIlII[31]); + AutoMLG.lIIIIIlI[16] = llIllllll(AutoMLG.lIIIIlII[32], AutoMLG.lIIIIlII[33]); + AutoMLG.lIIIIIlI[17] = llIllllll(AutoMLG.lIIIIlII[34], AutoMLG.lIIIIlII[35]); + AutoMLG.lIIIIIlI[18] = llIllllIl(AutoMLG.lIIIIlII[36], AutoMLG.lIIIIlII[37]); + AutoMLG.lIIIIIlI[19] = llIllllIl(AutoMLG.lIIIIlII[38], AutoMLG.lIIIIlII[39]); + AutoMLG.lIIIIlII = null; + } + + private static void lllIIIIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AutoMLG.lIIIIlII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIllllIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIlllllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIllllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/player/AutoMine.java b/module/player/AutoMine.java new file mode 100644 index 0000000..0f1f7b9 --- /dev/null +++ b/module/player/AutoMine.java @@ -0,0 +1,98 @@ +package me.explicit.module.player; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.settings.KeyBinding; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent; +import org.lwjgl.input.Mouse; + +public class AutoMine extends Module { + + private TimerUtils timer = new TimerUtils(); + private static final String[] lIlIII; + private static String[] lIlIIl; + + public AutoMine() { + super(AutoMine.lIlIII[0], 0, Category.PLAYER, AutoMine.lIlIII[1]); + } + + public void onEnable() { + super.onEnable(); + this.timer.reset(); + System.out.println(); + } + + @SubscribeEvent + public void rty(RenderTickEvent rendertickevent) { + int i; + + if (AutoMine.mc.objectMouseOver != null && AutoMine.mc.objectMouseOver.getBlockPos() != null && !Game.World().isAirBlock(AutoMine.mc.objectMouseOver.getBlockPos()) && !Mouse.isButtonDown(0)) { + i = AutoMine.mc.gameSettings.keyBindAttack.getKeyCode(); + KeyBinding.setKeyBindState(i, true); + KeyBinding.onTick(i); + this.timer.reset(); + } else if (this.timer.hasReached(30.0D)) { + i = AutoMine.mc.gameSettings.keyBindAttack.getKeyCode(); + KeyBinding.setKeyBindState(i, false); + } + + } + + static { + lIIlIIlI(); + lIIlIIIl(); + } + + private static void lIIlIIIl() { + lIlIII = new String[2]; + AutoMine.lIlIII[0] = lIIIllll(AutoMine.lIlIIl[0], AutoMine.lIlIIl[1]); + AutoMine.lIlIII[1] = lIIlIIII(AutoMine.lIlIIl[2], AutoMine.lIlIIl[3]); + AutoMine.lIlIIl = null; + } + + private static void lIIlIIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AutoMine.lIlIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIlIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/player/AutoTool.java b/module/player/AutoTool.java new file mode 100644 index 0000000..5c88e3d --- /dev/null +++ b/module/player/AutoTool.java @@ -0,0 +1,110 @@ +package me.explicit.module.player; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import net.minecraftforge.fml.common.gameevent.TickEvent.RenderTickEvent; +import org.lwjgl.input.Mouse; + +public class AutoTool extends Module { + + private int oldSlot = -1; + private boolean wasBreaking = false; + private static final String[] lIlIIIll; + private static String[] lIlIIlII; + + public AutoTool() { + super(AutoTool.lIlIIIll[0], AutoTool.lIlIIIll[1], Category.PLAYER); + } + + public void onEnable() { + super.onEnable(); + this.oldSlot = AutoTool.mc.thePlayer.inventory.currentItem; + this.wasBreaking = false; + } + + @SubscribeEvent + public void tick(RenderTickEvent rendertickevent) { + if (AutoTool.mc.currentScreen == null && Mouse.isButtonDown(0) && Game.Player() != null && Game.World() != null && AutoTool.mc.objectMouseOver != null && AutoTool.mc.objectMouseOver.getBlockPos() != null && AutoTool.mc.objectMouseOver.entityHit == null) { + try { + float f = 1.0F; + int i = -1; + Block block = AutoTool.mc.theWorld.getBlockState(AutoTool.mc.objectMouseOver.getBlockPos()).getBlock(); + + for (int j = 0; j < 8; ++j) { + ItemStack itemstack = Game.Player().inventory.getStackInSlot(j); + + if (itemstack != null) { + float f1 = itemstack.getStrVsBlock(block); + + if (f1 > f) { + f = f1; + i = j; + } + } + } + + if (i != -1 && AutoTool.mc.thePlayer.inventory.currentItem != i) { + AutoTool.mc.thePlayer.inventory.currentItem = i; + this.wasBreaking = true; + } else if (i == -1) { + if (this.wasBreaking) { + AutoTool.mc.thePlayer.inventory.currentItem = this.oldSlot; + this.wasBreaking = false; + } + + this.oldSlot = AutoTool.mc.thePlayer.inventory.currentItem; + } + } catch (Exception exception) { + exception.printStackTrace(); + } + } else if (Game.Player() != null && Game.World() != null) { + if (this.wasBreaking) { + AutoTool.mc.thePlayer.inventory.currentItem = this.oldSlot; + this.wasBreaking = false; + } + + this.oldSlot = AutoTool.mc.thePlayer.inventory.currentItem; + } + + } + + static { + lIIlIIIIll(); + lIIlIIIIlI(); + } + + private static void lIIlIIIIlI() { + lIlIIIll = new String[2]; + AutoTool.lIlIIIll[0] = lIIlIIIIIl(AutoTool.lIlIIlII[0], AutoTool.lIlIIlII[1]); + AutoTool.lIlIIIll[1] = lIIlIIIIIl(AutoTool.lIlIIlII[2], AutoTool.lIlIIlII[3]); + AutoTool.lIlIIlII = null; + } + + private static void lIIlIIIIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + AutoTool.lIlIIlII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIlIIIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/player/BlockData.java b/module/player/BlockData.java new file mode 100644 index 0000000..a6b338c --- /dev/null +++ b/module/player/BlockData.java @@ -0,0 +1,15 @@ +package me.explicit.module.player; + +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; + +class BlockData { + + public BlockPos position; + public EnumFacing face; + + public BlockData(BlockPos blockpos, EnumFacing enumfacing) { + this.position = blockpos; + this.face = enumfacing; + } +} diff --git a/module/player/ChestStealer.java b/module/player/ChestStealer.java new file mode 100644 index 0000000..9456ba7 --- /dev/null +++ b/module/player/ChestStealer.java @@ -0,0 +1,199 @@ +package me.explicit.module.player; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.concurrent.ThreadLocalRandom; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.ItemUtils; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.gui.inventory.GuiChest; +import net.minecraft.inventory.ContainerChest; +import net.minecraft.item.ItemAppleGold; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemFood; +import net.minecraft.item.ItemPotion; +import net.minecraft.item.ItemStack; + +public class ChestStealer extends Module { + + TimerUtils timer = new TimerUtils(); + double delay; + private boolean checkName; + private static final String[] llIlIIl; + private static String[] llIllIl; + + public ChestStealer() { + super(ChestStealer.llIlIIl[0], 0, Category.PLAYER, ChestStealer.llIlIIl[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(ChestStealer.llIlIIl[2], this, 100.0D, 0.0D, 500.0D, true)); + Explicit.instance.sm.rSetting(new Setting(ChestStealer.llIlIIl[3], this, 150.0D, 0.0D, 500.0D, true)); + Explicit.instance.sm.rSetting(new Setting(ChestStealer.llIlIIl[4], this, true)); + Explicit.instance.sm.rSetting(new Setting(ChestStealer.llIlIIl[5], this, false)); + } + + public void onEnable() { + this.setDelay(); + super.onEnable(); + } + + public void onUpdate() { + this.checkName = Explicit.instance.sm.getSettingByName(this, ChestStealer.llIlIIl[6]).getValBoolean(); + int i = Explicit.instance.sm.getSettingByName(this, ChestStealer.llIlIIl[7]).getValInt(); + int j = Explicit.instance.sm.getSettingByName(this, ChestStealer.llIlIIl[8]).getValInt(); + + if (Module.mc.currentScreen instanceof GuiChest) { + GuiChest guichest = (GuiChest) Module.mc.currentScreen; + ContainerChest containerchest = (ContainerChest) Game.Player().openContainer; + + if ((containerchest.getLowerChestInventory().getName().toLowerCase().contains(ChestStealer.llIlIIl[9]) || containerchest.getLowerChestInventory().getName().toLowerCase().contains(ChestStealer.llIlIIl[10]) || containerchest.getLowerChestInventory().getName().toLowerCase().contains(ChestStealer.llIlIIl[11]) || containerchest.getLowerChestInventory().getName().toLowerCase().contains(ChestStealer.llIlIIl[12])) && this.checkName) { + return; + } + + if (this.isChestEmpty(guichest) || this.isInventoryFull()) { + Module.mc.thePlayer.closeScreen(); + return; + } + + for (int k = 0; k < containerchest.getLowerChestInventory().getSizeInventory(); ++k) { + ItemStack itemstack = containerchest.getLowerChestInventory().getStackInSlot(k); + + if (itemstack != null && this.timer.hasReached(this.delay) && (this.isValidItem(itemstack) || !Explicit.instance.sm.getSettingByName(this, ChestStealer.llIlIIl[13]).getValBoolean())) { + Module.mc.playerController.windowClick(guichest.inventorySlots.windowId, k, 0, 1, Module.mc.thePlayer); + this.setDelay(); + this.timer.reset(); + break; + } + } + } + + } + + private boolean isValidItem(ItemStack itemstack) { + return itemstack != null && (ItemUtils.compareDamage(itemstack, ItemUtils.bestSword()) != null && ItemUtils.compareDamage(itemstack, ItemUtils.bestSword()) == itemstack || itemstack.getItem() instanceof ItemBlock || itemstack.getItem() instanceof ItemPotion && !ItemUtils.isBadPotion(itemstack) || itemstack.getItem() instanceof ItemArmor || itemstack.getItem() instanceof ItemAppleGold || itemstack.getItem() instanceof ItemFood); + } + + public void setDelay() { + double d0 = Explicit.instance.sm.getSettingByName(this, ChestStealer.llIlIIl[14]).getValDouble(); + double d1 = Explicit.instance.sm.getSettingByName(this, ChestStealer.llIlIIl[15]).getValDouble(); + + if (d0 == d1) { + d1 = d0 * 1.1D; + } + + this.delay = ThreadLocalRandom.current().nextDouble(Math.min(d0, d1), Math.max(d0, d1)); + } + + private boolean isChestEmpty(GuiChest guichest) { + ContainerChest containerchest = (ContainerChest) Game.Player().openContainer; + + for (int i = 0; i < containerchest.getLowerChestInventory().getSizeInventory(); ++i) { + ItemStack itemstack = containerchest.getLowerChestInventory().getStackInSlot(i); + + if (itemstack != null && (this.isValidItem(itemstack) || !Explicit.instance.sm.getSettingByName(this, ChestStealer.llIlIIl[16]).getValBoolean())) { + return false; + } + } + + return true; + } + + private boolean isInventoryFull() { + for (int i = 9; i <= 44; ++i) { + ItemStack itemstack = Module.mc.thePlayer.inventoryContainer.getSlot(i).getStack(); + + if (itemstack == null) { + return false; + } + } + + return true; + } + + static { + llIIIIIII(); + lIlllllll(); + } + + private static void lIlllllll() { + llIlIIl = new String[17]; + ChestStealer.llIlIIl[0] = lIlllIIll(ChestStealer.llIllIl[0], ChestStealer.llIllIl[1]); + ChestStealer.llIlIIl[1] = lIlllIlII(ChestStealer.llIllIl[2], ChestStealer.llIllIl[3]); + ChestStealer.llIlIIl[2] = lIlllIIll(ChestStealer.llIllIl[4], ChestStealer.llIllIl[5]); + ChestStealer.llIlIIl[3] = lIlllIlII(ChestStealer.llIllIl[6], ChestStealer.llIllIl[7]); + ChestStealer.llIlIIl[4] = lIlllIIll(ChestStealer.llIllIl[8], ChestStealer.llIllIl[9]); + ChestStealer.llIlIIl[5] = lIlllIIll(ChestStealer.llIllIl[10], ChestStealer.llIllIl[11]); + ChestStealer.llIlIIl[6] = lIllllIIl(ChestStealer.llIllIl[12], ChestStealer.llIllIl[13]); + ChestStealer.llIlIIl[7] = lIlllIlII(ChestStealer.llIllIl[14], ChestStealer.llIllIl[15]); + ChestStealer.llIlIIl[8] = lIllllIIl(ChestStealer.llIllIl[16], ChestStealer.llIllIl[17]); + ChestStealer.llIlIIl[9] = lIlllIlII(ChestStealer.llIllIl[18], ChestStealer.llIllIl[19]); + ChestStealer.llIlIIl[10] = lIlllIlII(ChestStealer.llIllIl[20], ChestStealer.llIllIl[21]); + ChestStealer.llIlIIl[11] = lIllllIIl(ChestStealer.llIllIl[22], ChestStealer.llIllIl[23]); + ChestStealer.llIlIIl[12] = lIllllIIl(ChestStealer.llIllIl[24], ChestStealer.llIllIl[25]); + ChestStealer.llIlIIl[13] = lIlllIIll(ChestStealer.llIllIl[26], ChestStealer.llIllIl[27]); + ChestStealer.llIlIIl[14] = lIllllIIl(ChestStealer.llIllIl[28], ChestStealer.llIllIl[29]); + ChestStealer.llIlIIl[15] = lIlllIlII(ChestStealer.llIllIl[30], ChestStealer.llIllIl[31]); + ChestStealer.llIlIIl[16] = lIlllIIll(ChestStealer.llIllIl[32], ChestStealer.llIllIl[33]); + ChestStealer.llIllIl = null; + } + + private static void llIIIIIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ChestStealer.llIllIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlllIIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlllIlII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIllllIIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/player/FastBreak.java b/module/player/FastBreak.java new file mode 100644 index 0000000..843fee8 --- /dev/null +++ b/module/player/FastBreak.java @@ -0,0 +1,89 @@ +package me.explicit.module.player; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.PrivateUtils; + +public class FastBreak extends Module { + + private static final String[] lIlIIllI; + private static String[] lIlIlIII; + + public FastBreak() { + super(FastBreak.lIlIIllI[0], FastBreak.lIlIIllI[1], Category.PLAYER); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(FastBreak.lIlIIllI[2], this, 0.2D, 0.0D, 1.0D, false)); + } + + public void onTick() { + if (FastBreak.mc.currentScreen == null && FastBreak.mc.thePlayer != null && FastBreak.mc.objectMouseOver != null && FastBreak.mc.objectMouseOver.getBlockPos() != null && FastBreak.mc.gameSettings.keyBindAttack.isKeyDown()) { + PrivateUtils.setBlockHitDelay(0); + float f = PrivateUtils.getBlockDamage(); + + if (f == -1.0F) { + return; + } + + if ((double) f > Explicit.instance.sm.getSettingByName(this, FastBreak.lIlIIllI[3]).getValDouble()) { + PrivateUtils.setBlockDamage(1.0F); + } + } + + } + + static { + lIIlIlIIlI(); + lIIlIlIIIl(); + } + + private static void lIIlIlIIIl() { + lIlIIllI = new String[4]; + FastBreak.lIlIIllI[0] = lIIlIIllIl(FastBreak.lIlIlIII[0], FastBreak.lIlIlIII[1]); + FastBreak.lIlIIllI[1] = lIIlIIllll(FastBreak.lIlIlIII[2], FastBreak.lIlIlIII[3]); + FastBreak.lIlIIllI[2] = lIIlIIllIl(FastBreak.lIlIlIII[4], FastBreak.lIlIlIII[5]); + FastBreak.lIlIIllI[3] = lIIlIIllIl(FastBreak.lIlIlIII[6], FastBreak.lIlIlIII[7]); + FastBreak.lIlIlIII = null; + } + + private static void lIIlIlIIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + FastBreak.lIlIlIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIlIIllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIlIIllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/player/FastPlace.java b/module/player/FastPlace.java new file mode 100644 index 0000000..31511d1 --- /dev/null +++ b/module/player/FastPlace.java @@ -0,0 +1,126 @@ +package me.explicit.module.player; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.PrivateUtils; +import net.minecraft.item.Item; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemEgg; +import net.minecraft.item.ItemFireball; +import net.minecraft.item.ItemSnowball; + +public class FastPlace extends Module { + + public static int placeDelay; + private static final String[] lIIIlII; + private static String[] lIIIlIl; + + public FastPlace() { + super(FastPlace.lIIIlII[0], 0, Category.PLAYER, FastPlace.lIIIlII[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(FastPlace.lIIIlII[2], this, true)); + Explicit.instance.sm.rSetting(new Setting(FastPlace.lIIIlII[3], this, false)); + Explicit.instance.sm.rSetting(new Setting(FastPlace.lIIIlII[4], this, false)); + } + + public void onTick() { + boolean flag = Explicit.instance.sm.getSettingByName(this, FastPlace.lIIIlII[5]).getValBoolean(); + boolean flag1 = Explicit.instance.sm.getSettingByName(this, FastPlace.lIIIlII[6]).getValBoolean(); + boolean flag2 = Explicit.instance.sm.getSettingByName(this, FastPlace.lIIIlII[7]).getValBoolean(); + byte b0 = 0; + + if (Game.Player().inventory.getCurrentItem() != null) { + Item item = Game.Player().inventory.getCurrentItem().getItem(); + + if ((!(item instanceof ItemBlock) || !flag) && (!(item instanceof ItemSnowball) && !(item instanceof ItemEgg) && !(item instanceof ItemFireball) || !flag1)) { + if (flag2 && (!(item instanceof ItemBlock) || !flag) && (item instanceof ItemSnowball || item instanceof ItemEgg || item instanceof ItemFireball) && flag1) { + this.setFastPlace(b0); + } else if ((!(item instanceof ItemBlock) || !flag) && (item instanceof ItemSnowball || item instanceof ItemEgg || item instanceof ItemFireball) && flag1) { + this.setFastPlace(4); + } + } else { + this.setFastPlace(b0); + } + } else if (Game.Player().inventory.getCurrentItem() == null) { + this.setFastPlace(4); + } + + } + + public void onDisable() { + this.setFastPlace(4); + FastPlace.placeDelay = 4; + super.onDisable(); + } + + public void setFastPlace(int i) { + PrivateUtils.setRightClickDelayTimer(i); + } + + static { + llllIIlI(); + llllIIIl(); + FastPlace.placeDelay = 4; + } + + private static void llllIIIl() { + lIIIlII = new String[8]; + FastPlace.lIIIlII[0] = lllIllll(FastPlace.lIIIlIl[0], FastPlace.lIIIlIl[1]); + FastPlace.lIIIlII[1] = llllIIII(FastPlace.lIIIlIl[2], FastPlace.lIIIlIl[3]); + FastPlace.lIIIlII[2] = llllIIII(FastPlace.lIIIlIl[4], FastPlace.lIIIlIl[5]); + FastPlace.lIIIlII[3] = llllIIII(FastPlace.lIIIlIl[6], FastPlace.lIIIlIl[7]); + FastPlace.lIIIlII[4] = lllIllll(FastPlace.lIIIlIl[8], FastPlace.lIIIlIl[9]); + FastPlace.lIIIlII[5] = lllIllll(FastPlace.lIIIlIl[10], FastPlace.lIIIlIl[11]); + FastPlace.lIIIlII[6] = llllIIII(FastPlace.lIIIlIl[12], FastPlace.lIIIlIl[13]); + FastPlace.lIIIlII[7] = llllIIII(FastPlace.lIIIlIl[14], FastPlace.lIIIlIl[15]); + FastPlace.lIIIlIl = null; + } + + private static void llllIIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + FastPlace.lIIIlIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llllIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lllIllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/player/Safewalk.java b/module/player/Safewalk.java new file mode 100644 index 0000000..af2a481 --- /dev/null +++ b/module/player/Safewalk.java @@ -0,0 +1,93 @@ +package me.explicit.module.player; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.utils.Game; +import net.minecraft.init.Blocks; +import net.minecraft.util.BlockPos; +import net.minecraftforge.event.entity.living.LivingEvent.LivingUpdateEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class Safewalk extends Module { + + private static final String[] llII; + private static String[] llIl; + + public Safewalk() { + super(Safewalk.llII[0], 0, Category.PLAYER, Safewalk.llII[1]); + } + + public void onTick() { + if (Safewalk.mc.thePlayer != null && Game.World() != null && Game.Player().onGround) { + double d0 = (double) ((int) Game.Player().posX) - Game.Player().posX; + double d1 = Game.Player().posZ - (double) ((int) Game.Player().posZ); + + System.out.println(String.valueOf((new StringBuilder()).append(d0).append(Safewalk.llII[2]).append(d1))); + if (Game.World().getBlockState((new BlockPos(Game.Player())).add(0, -1, 0)).getBlock() == Blocks.air) { + Safewalk.mc.thePlayer.motionX = 0.0D; + Safewalk.mc.thePlayer.motionY = 0.0D; + Safewalk.mc.thePlayer.motionZ = 0.0D; + Safewalk.mc.thePlayer.jumpMovementFactor = 0.0F; + Safewalk.mc.thePlayer.noClip = true; + Safewalk.mc.thePlayer.onGround = false; + } + + } + } + + @SubscribeEvent + public void onLivingUpdate(LivingUpdateEvent livingupdateevent) {} + + public void onDisable() {} + + static { + lIllIl(); + lIllII(); + } + + private static void lIllII() { + llII = new String[3]; + Safewalk.llII[0] = lIlIlI(Safewalk.llIl[0], Safewalk.llIl[1]); + Safewalk.llII[1] = lIlIlI(Safewalk.llIl[2], Safewalk.llIl[3]); + Safewalk.llII[2] = lIlIll(Safewalk.llIl[4], Safewalk.llIl[5]); + Safewalk.llIl = null; + } + + private static void lIllIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Safewalk.llIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/render/BlockFound.java b/module/render/BlockFound.java new file mode 100644 index 0000000..cddb933 --- /dev/null +++ b/module/render/BlockFound.java @@ -0,0 +1,18 @@ +package me.explicit.module.render; + +import java.awt.Color; +import net.minecraft.block.Block; +import net.minecraft.util.BlockPos; + +class BlockFound { + + public BlockPos pos; + public Block block; + public Color color; + + public BlockFound(BlockPos blockpos, Block block, Color color) { + this.pos = blockpos; + this.block = block; + this.color = color; + } +} diff --git a/module/render/Chams.java b/module/render/Chams.java new file mode 100644 index 0000000..5a28e2f --- /dev/null +++ b/module/render/Chams.java @@ -0,0 +1,87 @@ +package me.explicit.module.render; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; +import net.minecraft.client.Minecraft; +import net.minecraftforge.client.event.RenderPlayerEvent.Post; +import net.minecraftforge.client.event.RenderPlayerEvent.Pre; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import org.lwjgl.opengl.GL11; + +public class Chams extends Module { + + private static final String[] llIIIIIl; + private static String[] llIIIIlI; + + public Chams() { + super(Chams.llIIIIIl[0], Chams.llIIIIIl[1], Category.RENDER); + } + + @SubscribeEvent + public void onRenderLiving(Pre pre) { + GL11.glEnable('耷'); + GL11.glPolygonOffset(1.0F, -1100000.0F); + } + + @SubscribeEvent + public void onRenderLiving(Post post) { + GL11.glDisable('耷'); + GL11.glPolygonOffset(1.0F, 1100000.0F); + Minecraft.getMinecraft().getRenderManager().setRenderOutlines(false); + } + + static { + lIllIIlIll(); + lIllIIlIlI(); + } + + private static void lIllIIlIlI() { + llIIIIIl = new String[2]; + Chams.llIIIIIl[0] = lIllIIlIII(Chams.llIIIIlI[0], Chams.llIIIIlI[1]); + Chams.llIIIIIl[1] = lIllIIlIIl(Chams.llIIIIlI[2], Chams.llIIIIlI[3]); + Chams.llIIIIlI = null; + } + + private static void lIllIIlIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Chams.llIIIIlI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIllIIlIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIllIIlIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/render/ClickGUI.java b/module/render/ClickGUI.java new file mode 100644 index 0000000..21cba90 --- /dev/null +++ b/module/render/ClickGUI.java @@ -0,0 +1,119 @@ +package me.explicit.module.render; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; + +public class ClickGUI extends Module { + + public static String mode; + private static final String[] lIIIlllI; + private static String[] lIIIllll; + + public ClickGUI() { + super(ClickGUI.lIIIlllI[0], 54, Category.RENDER, ClickGUI.lIIIlllI[1]); + } + + public void setup() { + ArrayList arraylist = new ArrayList(); + + arraylist.add(ClickGUI.lIIIlllI[2]); + arraylist.add(ClickGUI.lIIIlllI[3]); + arraylist.add(ClickGUI.lIIIlllI[4]); + arraylist.add(ClickGUI.lIIIlllI[5]); + arraylist.add(ClickGUI.lIIIlllI[6]); + arraylist.add(ClickGUI.lIIIlllI[7]); + Explicit.instance.sm.rSetting(new Setting(ClickGUI.lIIIlllI[8], this, ClickGUI.lIIIlllI[9], arraylist)); + } + + public void onUpdateNoToggle() { + ClickGUI.mode = Explicit.instance.sm.getSettingByName(this, ClickGUI.lIIIlllI[10]).getValString(); + } + + public void onEnable() { + super.onEnable(); + ClickGUI.mc.displayGuiScreen(Explicit.instance.clickGui); + this.toggle(); + } + + static { + llllllIlI(); + llllllIIl(); + ClickGUI.mode = ClickGUI.lIIIlllI[11]; + } + + private static void llllllIIl() { + lIIIlllI = new String[12]; + ClickGUI.lIIIlllI[0] = lllllIlII(ClickGUI.lIIIllll[0], ClickGUI.lIIIllll[1]); + ClickGUI.lIIIlllI[1] = lllllIllI(ClickGUI.lIIIllll[2], ClickGUI.lIIIllll[3]); + ClickGUI.lIIIlllI[2] = lllllIllI(ClickGUI.lIIIllll[4], ClickGUI.lIIIllll[5]); + ClickGUI.lIIIlllI[3] = llllllIII(ClickGUI.lIIIllll[6], ClickGUI.lIIIllll[7]); + ClickGUI.lIIIlllI[4] = lllllIllI(ClickGUI.lIIIllll[8], ClickGUI.lIIIllll[9]); + ClickGUI.lIIIlllI[5] = lllllIlII(ClickGUI.lIIIllll[10], ClickGUI.lIIIllll[11]); + ClickGUI.lIIIlllI[6] = llllllIII(ClickGUI.lIIIllll[12], ClickGUI.lIIIllll[13]); + ClickGUI.lIIIlllI[7] = lllllIlII(ClickGUI.lIIIllll[14], ClickGUI.lIIIllll[15]); + ClickGUI.lIIIlllI[8] = lllllIlII(ClickGUI.lIIIllll[16], ClickGUI.lIIIllll[17]); + ClickGUI.lIIIlllI[9] = llllllIII(ClickGUI.lIIIllll[18], ClickGUI.lIIIllll[19]); + ClickGUI.lIIIlllI[10] = lllllIllI(ClickGUI.lIIIllll[20], ClickGUI.lIIIllll[21]); + ClickGUI.lIIIlllI[11] = lllllIlII(ClickGUI.lIIIllll[22], ClickGUI.lIIIllll[23]); + ClickGUI.lIIIllll = null; + } + + private static void llllllIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ClickGUI.lIIIllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllllIllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllllIlII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llllllIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/render/ESP.java b/module/render/ESP.java new file mode 100644 index 0000000..24488a8 --- /dev/null +++ b/module/render/ESP.java @@ -0,0 +1,206 @@ +package me.explicit.module.render; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.module.combat.AntiBot; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import me.explicit.utils.RenderUtils; +import net.minecraft.entity.Entity; +import net.minecraft.entity.monster.EntityMob; +import net.minecraft.entity.passive.EntityAnimal; +import net.minecraft.entity.player.EntityPlayer; + +public class ESP extends Module { + + private String color; + private int red; + private int green; + private int blue; + private static final String[] lIIIIll; + private static String[] lIIlIll; + + public ESP() { + super(ESP.lIIIIll[0], 0, Category.RENDER, ESP.lIIIIll[1]); + } + + public void setup() { + ArrayList arraylist; + ArrayList arraylist1; + + (arraylist = new ArrayList()).add(ESP.lIIIIll[2]); + arraylist.add(ESP.lIIIIll[3]); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[4], this, ESP.lIIIIll[5], arraylist)); + (arraylist1 = new ArrayList()).add(ESP.lIIIIll[6]); + arraylist1.add(ESP.lIIIIll[7]); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[8], this, ESP.lIIIIll[9], arraylist1)); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[10], this, true)); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[11], this, false)); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[12], this, false)); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[13], this, false)); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[14], this, false)); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[15], this, 150.0D, 0.0D, 255.0D, true)); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[16], this, 0.0D, 0.0D, 255.0D, true)); + Explicit.instance.sm.rSetting(new Setting(ESP.lIIIIll[17], this, 0.0D, 0.0D, 255.0D, true)); + } + + public void onRender3D() { + this.color = Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[18]).getValString(); + this.red = (int) Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[19]).getValDouble(); + this.green = (int) Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[20]).getValDouble(); + this.blue = (int) Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[21]).getValDouble(); + if (this.color.equalsIgnoreCase(ESP.lIIIIll[22])) { + Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[23]).setVisible(false); + Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[24]).setVisible(false); + Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[25]).setVisible(false); + } else { + Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[26]).setVisible(true); + Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[27]).setVisible(true); + Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[28]).setVisible(true); + } + + Iterator iterator = Game.World().loadedEntityList.iterator(); + + while (iterator.hasNext()) { + Entity entity = (Entity) iterator.next(); + + if (!AntiBot.getBots().contains(entity)) { + boolean flag = true; + boolean flag1 = Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[29]).getValBoolean(); + boolean flag2 = Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[30]).getValBoolean(); + boolean flag3 = Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[31]).getValBoolean(); + + if (!CombatUtils.isTeam(Game.Player(), entity) && flag1 && flag2 && entity instanceof EntityPlayer) { + flag = false; + } else if (entity.isInvisible() && !flag3 && flag2 && entity instanceof EntityPlayer) { + flag = false; + } else if (!flag2 || !(entity instanceof EntityPlayer)) { + flag = false; + } + + if (entity != Game.Player() && !AntiBot.getBots().contains(entity) && (flag || entity instanceof EntityMob && Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[32]).getValBoolean() || entity instanceof EntityAnimal && Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[33]).getValBoolean())) { + if (Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[34]).getValString().equalsIgnoreCase(ESP.lIIIIll[35])) { + RenderUtils.renderEntity(entity, this.getColor().getRGB(), 2); + } else if (Explicit.instance.sm.getSettingByName(this, ESP.lIIIIll[36]).getValString().equalsIgnoreCase(ESP.lIIIIll[37])) { + RenderUtils.renderEntity(entity, this.getColor().getRGB(), 3); + } + } + } + } + + } + + private Color getColor() { + return this.color.equalsIgnoreCase(ESP.lIIIIll[38]) ? Explicit.instance.cm.cc.getColor(0) : new Color(this.red, this.green, this.blue, 255); + } + + static { + lIIIIlIlI(); + lIIIIIllI(); + } + + private static void lIIIIIllI() { + lIIIIll = new String[39]; + ESP.lIIIIll[0] = lllIIllI(ESP.lIIlIll[0], ESP.lIIlIll[1]); + ESP.lIIIIll[1] = lllIllIl(ESP.lIIlIll[2], ESP.lIIlIll[3]); + ESP.lIIIIll[2] = lllIlllI(ESP.lIIlIll[4], ESP.lIIlIll[5]); + ESP.lIIIIll[3] = lllIIllI(ESP.lIIlIll[6], ESP.lIIlIll[7]); + ESP.lIIIIll[4] = lllIIllI(ESP.lIIlIll[8], ESP.lIIlIll[9]); + ESP.lIIIIll[5] = lllIlllI(ESP.lIIlIll[10], ESP.lIIlIll[11]); + ESP.lIIIIll[6] = lllIIllI(ESP.lIIlIll[12], ESP.lIIlIll[13]); + ESP.lIIIIll[7] = lllIIllI(ESP.lIIlIll[14], ESP.lIIlIll[15]); + ESP.lIIIIll[8] = lllIlllI(ESP.lIIlIll[16], ESP.lIIlIll[17]); + ESP.lIIIIll[9] = lllIllIl(ESP.lIIlIll[18], ESP.lIIlIll[19]); + ESP.lIIIIll[10] = lllIlllI(ESP.lIIlIll[20], ESP.lIIlIll[21]); + ESP.lIIIIll[11] = lllIllIl(ESP.lIIlIll[22], ESP.lIIlIll[23]); + ESP.lIIIIll[12] = lllIllIl(ESP.lIIlIll[24], ESP.lIIlIll[25]); + ESP.lIIIIll[13] = lllIlllI(ESP.lIIlIll[26], ESP.lIIlIll[27]); + ESP.lIIIIll[14] = lllIIllI(ESP.lIIlIll[28], ESP.lIIlIll[29]); + ESP.lIIIIll[15] = lllIllIl(ESP.lIIlIll[30], ESP.lIIlIll[31]); + ESP.lIIIIll[16] = lllIlllI(ESP.lIIlIll[32], ESP.lIIlIll[33]); + ESP.lIIIIll[17] = lllIlllI(ESP.lIIlIll[34], ESP.lIIlIll[35]); + ESP.lIIIIll[18] = lllIllIl(ESP.lIIlIll[36], ESP.lIIlIll[37]); + ESP.lIIIIll[19] = lllIlllI(ESP.lIIlIll[38], ESP.lIIlIll[39]); + ESP.lIIIIll[20] = lllIIllI(ESP.lIIlIll[40], ESP.lIIlIll[41]); + ESP.lIIIIll[21] = lllIIllI(ESP.lIIlIll[42], ESP.lIIlIll[43]); + ESP.lIIIIll[22] = lllIllIl(ESP.lIIlIll[44], ESP.lIIlIll[45]); + ESP.lIIIIll[23] = lllIlllI(ESP.lIIlIll[46], ESP.lIIlIll[47]); + ESP.lIIIIll[24] = lllIllIl(ESP.lIIlIll[48], ESP.lIIlIll[49]); + ESP.lIIIIll[25] = lllIlllI("X5H8JFbaBMs=", "ZdSPQ"); + ESP.lIIIIll[26] = lllIIllI("HXEDOAdq7+Y=", "JpZjP"); + ESP.lIIIIll[27] = lllIllIl("AxgyACk=", "DjWeG"); + ESP.lIIIIll[28] = lllIlllI("rJx/dY09R9s=", "DcAXd"); + ESP.lIIIIll[29] = lllIlllI("7O7kZmwihl4=", "IejaQ"); + ESP.lIIIIll[30] = lllIllIl("PDosHioeJQ==", "lVMgO"); + ESP.lIIIIll[31] = lllIlllI("7tyKNnLr903Kt3W1w31SJQ==", "wDNgs"); + ESP.lIIIIll[32] = lllIIllI("4zZsl0gdym0=", "krfHL"); + ESP.lIIIIll[33] = lllIIllI("QI3+l1NB6HA=", "AliAk"); + ESP.lIIIIll[34] = lllIllIl("ITwBBw==", "lSebm"); + ESP.lIIIIll[35] = lllIllIl("LgUy", "ljJhi"); + ESP.lIIIIll[36] = lllIlllI("VvFStmxJkLs=", "xiLGX"); + ESP.lIIIIll[37] = lllIIllI("u4EdPlPRmKI=", "dmcoP"); + ESP.lIIIIll[38] = lllIIllI("6uXD08aqnUI=", "dsALw"); + ESP.lIIlIll = null; + } + + private static void lIIIIlIlI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ESP.lIIlIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllIlllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllIllIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lllIIllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/render/HUD.java b/module/render/HUD.java new file mode 100644 index 0000000..43db6ba --- /dev/null +++ b/module/render/HUD.java @@ -0,0 +1,82 @@ +package me.explicit.module.render; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; + +public class HUD extends Module { + + private static final String[] ll; + private static String[] lIl; + + public HUD() { + super(HUD.ll[0], 0, Category.RENDER, HUD.ll[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(HUD.ll[2], this, true)); + Explicit.instance.sm.rSetting(new Setting(HUD.ll[3], this, 170.0D, 0.0D, 255.0D, true)); + Explicit.instance.sm.rSetting(new Setting(HUD.ll[4], this, 0.0D, 0.0D, 255.0D, true)); + Explicit.instance.sm.rSetting(new Setting(HUD.ll[5], this, 0.0D, 0.0D, 255.0D, true)); + } + + static { + lllI(); + lIll(); + } + + private static void lIll() { + ll = new String[6]; + HUD.ll[0] = lI(HUD.lIl[0], HUD.lIl[1]); + HUD.ll[1] = lI(HUD.lIl[2], HUD.lIl[3]); + HUD.ll[2] = lIlI(HUD.lIl[4], HUD.lIl[5]); + HUD.ll[3] = lI(HUD.lIl[6], HUD.lIl[7]); + HUD.ll[4] = lI(HUD.lIl[8], HUD.lIl[9]); + HUD.ll[5] = lIlI(HUD.lIl[10], HUD.lIl[11]); + HUD.lIl = null; + } + + private static void lllI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + HUD.lIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/render/NameTags.java b/module/render/NameTags.java new file mode 100644 index 0000000..647fe03 --- /dev/null +++ b/module/render/NameTags.java @@ -0,0 +1,574 @@ +package me.explicit.module.render; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import me.explicit.utils.PrivateUtils; +import me.explicit.utils.RenderUtils; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.client.renderer.RenderHelper; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.enchantment.EnchantmentHelper; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Items; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemSword; +import net.minecraft.item.ItemTool; +import net.minecraftforge.client.event.RenderWorldLastEvent; +import net.minecraftforge.client.event.RenderLivingEvent.Specials.Pre; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; +import org.lwjgl.opengl.GL11; + +public class NameTags extends Module { + + private float scale; + private String mode; + boolean armor; + boolean dura; + boolean players = true; + boolean invis; + boolean mobs = false; + boolean animals = false; + private ArrayList entities; + float _x; + float _y; + float _z; + private static final String[] lIIIll; + private static String[] llIIII; + + public NameTags() { + super(NameTags.lIIIll[0], 0, Category.RENDER, NameTags.lIIIll[1]); + } + + public void setup() { + ArrayList arraylist; + + (arraylist = new ArrayList()).add(NameTags.lIIIll[2]); + arraylist.add(NameTags.lIIIll[3]); + Explicit.instance.sm.rSetting(new Setting(NameTags.lIIIll[4], this, NameTags.lIIIll[5], arraylist)); + Explicit.instance.sm.rSetting(new Setting(NameTags.lIIIll[6], this, 5.0D, 0.1D, 10.0D, false)); + Explicit.instance.sm.rSetting(new Setting(NameTags.lIIIll[7], this, 0.0D, 0.0D, 512.0D, true)); + Explicit.instance.sm.rSetting(new Setting(NameTags.lIIIll[8], this, true)); + Explicit.instance.sm.rSetting(new Setting(NameTags.lIIIll[9], this, false)); + Explicit.instance.sm.rSetting(new Setting(NameTags.lIIIll[10], this, true)); + } + + public void onUpdate() { + this.scale = (float) Explicit.instance.sm.getSettingByName(this, NameTags.lIIIll[11]).getValDouble(); + this.mode = Explicit.instance.sm.getSettingByName(this, NameTags.lIIIll[12]).getValString(); + this.armor = Explicit.instance.sm.getSettingByName(this, NameTags.lIIIll[13]).getValBoolean(); + this.dura = Explicit.instance.sm.getSettingByName(this, NameTags.lIIIll[14]).getValBoolean(); + } + + @SubscribeEvent + public void nameTag(Pre pre) { + if (pre.entity.getDisplayName().getFormattedText() != null && pre.entity.getDisplayName().getFormattedText() != NameTags.lIIIll[15] && pre.entity instanceof EntityPlayer && CombatUtils.canTarget(pre.entity, false) && ((double) Game.Player().getDistanceToEntity(pre.entity) <= Explicit.instance.sm.getSettingByName(this, NameTags.lIIIll[16]).getValDouble() || Explicit.instance.sm.getSettingByName(this, NameTags.lIIIll[17]).getValDouble() == 0.0D)) { + pre.setCanceled(true); + } + + } + + @SubscribeEvent + public void render3d(RenderWorldLastEvent renderworldlastevent) { + ArrayList arraylist = new ArrayList(); + + if (arraylist.size() > 100) { + arraylist.clear(); + } + + Iterator iterator = Module.mc.theWorld.playerEntities.iterator(); + + while (iterator.hasNext()) { + EntityLivingBase entitylivingbase = (EntityLivingBase) iterator.next(); + + if ((double) Game.Player().getDistanceToEntity(entitylivingbase) > Explicit.instance.sm.getSettingByName(this, NameTags.lIIIll[18]).getValDouble() && Explicit.instance.sm.getSettingByName(this, NameTags.lIIIll[19]).getValDouble() != 0.0D) { + if (arraylist.contains(entitylivingbase)) { + arraylist.remove(entitylivingbase); + } + } else if (entitylivingbase.getName().contains(NameTags.lIIIll[20])) { + if (arraylist.contains(entitylivingbase)) { + arraylist.remove(entitylivingbase); + } + } else if (entitylivingbase.isEntityAlive()) { + if (entitylivingbase.isInvisible()) { + if (arraylist.contains(entitylivingbase)) { + arraylist.remove(entitylivingbase); + } + } else if (entitylivingbase == Module.mc.thePlayer) { + if (arraylist.contains(entitylivingbase)) { + arraylist.remove(entitylivingbase); + } + } else { + if (arraylist.size() > 100) { + break; + } + + if (!arraylist.contains(entitylivingbase)) { + arraylist.add((EntityPlayer) entitylivingbase); + } + } + } else if (arraylist.contains(entitylivingbase)) { + arraylist.remove(entitylivingbase); + } + } + + this._x = 0.0F; + this._y = 0.0F; + this._z = 0.0F; + iterator = arraylist.iterator(); + + while (iterator.hasNext()) { + EntityPlayer entityplayer = (EntityPlayer) iterator.next(); + + if (CombatUtils.canTarget(entityplayer, false)) { + entityplayer.setAlwaysRenderNameTag(false); + this._x = (float) (entityplayer.lastTickPosX + (entityplayer.posX - entityplayer.lastTickPosX) * (double) PrivateUtils.timer().renderPartialTicks - Game.Minecraft().getRenderManager().viewerPosX); + this._y = (float) (entityplayer.lastTickPosY + (entityplayer.posY - entityplayer.lastTickPosY) * (double) PrivateUtils.timer().renderPartialTicks - Game.Minecraft().getRenderManager().viewerPosY); + this._z = (float) (entityplayer.lastTickPosZ + (entityplayer.posZ - entityplayer.lastTickPosZ) * (double) PrivateUtils.timer().renderPartialTicks - Game.Minecraft().getRenderManager().viewerPosZ); + this.renderNametag(entityplayer, this._x, this._y, this._z); + } + } + + } + + private String getHealth(EntityPlayer entityplayer) { + DecimalFormat decimalformat = new DecimalFormat(NameTags.lIIIll[21]); + + return this.mode.equalsIgnoreCase(NameTags.lIIIll[22]) ? decimalformat.format((double) (entityplayer.getHealth() * 5.0F + entityplayer.getAbsorptionAmount() * 5.0F)) : decimalformat.format((double) (entityplayer.getHealth() / 2.0F + entityplayer.getAbsorptionAmount() / 2.0F)); + } + + private void drawNames(EntityPlayer entityplayer) { + float f = 2.2F; + float f1 = (float) this.getWidth(this.getPlayerName(entityplayer)) / 2.0F + 2.2F; + float f2; + + f1 = f2 = (float) ((double) f1 + (double) (this.getWidth(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[23]).append(this.getHealth(entityplayer)))) / 2) + 2.5D); + float f3 = -f1 - 2.2F; + float f4 = (float) (this.getWidth(this.getPlayerName(entityplayer)) + 4); + + if (this.mode.equalsIgnoreCase(NameTags.lIIIll[24])) { + RenderUtils.drawBorderedRect(f3, -3.0F, f1, 10.0F, 1.0F, (new Color(20, 20, 20, 180)).getRGB(), (new Color(10, 10, 10, 200)).getRGB()); + } else { + RenderUtils.drawBorderedRect(f3 + 5.0F, -3.0F, f1, 10.0F, 1.0F, (new Color(20, 20, 20, 180)).getRGB(), (new Color(10, 10, 10, 200)).getRGB()); + } + + GlStateManager.disableDepth(); + if (this.mode.equalsIgnoreCase(NameTags.lIIIll[25])) { + f4 += (float) (this.getWidth(this.getHealth(entityplayer)) + this.getWidth(NameTags.lIIIll[26]) - 1); + } else { + f4 += (float) (this.getWidth(this.getHealth(entityplayer)) + this.getWidth(NameTags.lIIIll[27]) - 1); + } + + this.drawString(this.getPlayerName(entityplayer), f2 - f4, 0.0F, 16777215); + if (entityplayer.getHealth() == 10.0F) { + ; + } + + int i; + + if (entityplayer.getHealth() > 10.0F) { + i = RenderUtils.blend(new Color(-16711936), new Color(-256), (double) (1.0F / entityplayer.getHealth() / 2.0F * (entityplayer.getHealth() - 10.0F))).getRGB(); + } else { + i = RenderUtils.blend(new Color(-256), new Color(-65536), (double) (0.1F * entityplayer.getHealth())).getRGB(); + } + + if (this.mode.equalsIgnoreCase(NameTags.lIIIll[28])) { + this.drawString(String.valueOf((new StringBuilder()).append(String.valueOf(this.getHealth(entityplayer))).append(NameTags.lIIIll[29])), f2 - (float) this.getWidth(String.valueOf((new StringBuilder()).append(String.valueOf(this.getHealth(entityplayer))).append(NameTags.lIIIll[30]))), 0.0F, i); + } else { + this.drawString(this.getHealth(entityplayer), f2 - (float) this.getWidth(String.valueOf((new StringBuilder()).append(String.valueOf(this.getHealth(entityplayer))).append(NameTags.lIIIll[31]))), 0.0F, i); + } + + GlStateManager.enableDepth(); + } + + private void drawString(String s, float f, float f1, int i) { + Module.mc.fontRendererObj.drawStringWithShadow(s, f, f1, i); + } + + private int getWidth(String s) { + return Module.mc.fontRendererObj.getStringWidth(s); + } + + private void startDrawing(float f, float f1, float f2, EntityPlayer entityplayer) { + float f3 = Module.mc.gameSettings.thirdPersonView == 2 ? -1.0F : 1.0F; + double d0 = (double) (this.getSize(entityplayer) / 10.0F * this.scale) * 1.5D; + + GL11.glPushMatrix(); + RenderUtils.startDrawing(); + GL11.glTranslatef(f, f1, f2); + GL11.glNormal3f(0.0F, 1.0F, 0.0F); + GL11.glRotatef(-Module.mc.getRenderManager().playerViewY, 0.0F, 1.0F, 0.0F); + GL11.glRotatef(Module.mc.getRenderManager().playerViewX, f3, 0.0F, 0.0F); + GL11.glScaled(-0.01666666753590107D * d0, -0.01666666753590107D * d0, 0.01666666753590107D * d0); + } + + private void stopDrawing() { + RenderUtils.stopDrawing(); + GlStateManager.color(1.0F, 1.0F, 1.0F); + GlStateManager.popMatrix(); + } + + private void renderNametag(EntityPlayer entityplayer, float f, float f1, float f2) { + f1 += (float) (1.55D + (entityplayer.isSneaking() ? 0.5D : 0.7D)); + this.startDrawing(f, f1, f2, entityplayer); + this.drawNames(entityplayer); + GL11.glColor4d(1.0D, 1.0D, 1.0D, 1.0D); + if (this.armor) { + this.renderArmor(entityplayer); + } + + this.stopDrawing(); + } + + private void renderArmor(EntityPlayer entityplayer) { + ItemStack[] aitemstack = entityplayer.inventory.armorInventory; + int i = aitemstack.length; + int j = 0; + ItemStack[] aitemstack1 = aitemstack; + int k = aitemstack.length; + + for (int l = 0; l < k; ++l) { + ItemStack itemstack = aitemstack1[l]; + + if (itemstack != null) { + j -= 8; + } + } + + if (entityplayer.getHeldItem() != null) { + j -= 8; + ItemStack itemstack1 = entityplayer.getHeldItem().copy(); + + if (itemstack1.hasEffect() && (itemstack1.getItem() instanceof ItemTool || itemstack1.getItem() instanceof ItemArmor)) { + itemstack1.stackSize = 1; + } + + this.renderItemStack(itemstack1, j, -20); + j += 16; + } + + aitemstack = entityplayer.inventory.armorInventory; + + for (k = 3; k >= 0; --k) { + ItemStack itemstack2 = aitemstack[k]; + + if (itemstack2 != null) { + this.renderItemStack(itemstack2, j, -20); + j += 16; + } + } + + GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F); + } + + private String getPlayerName(EntityPlayer entityplayer) { + boolean flag = Explicit.instance.sm.getSettingByName(this, NameTags.lIIIll[32]).getValBoolean(); + + return String.valueOf((new StringBuilder()).append(flag ? String.valueOf((new StringBuilder()).append((new DecimalFormat(NameTags.lIIIll[33])).format((double) Game.Player().getDistanceToEntity(entityplayer))).append(NameTags.lIIIll[34])) : NameTags.lIIIll[35]).append(entityplayer.getDisplayName().getFormattedText())); + } + + private float getSize(EntityPlayer entityplayer) { + return Module.mc.thePlayer.getDistanceToEntity(entityplayer) / 4.0F <= 2.0F ? 2.0F : Module.mc.thePlayer.getDistanceToEntity(entityplayer) / 4.0F; + } + + private void renderItemStack(ItemStack itemstack, int i, int j) { + GlStateManager.pushMatrix(); + GlStateManager.depthMask(true); + GlStateManager.clear(256); + RenderHelper.enableStandardItemLighting(); + Module.mc.getRenderItem().zLevel = -150.0F; + GlStateManager.disableDepth(); + GlStateManager.disableTexture2D(); + GlStateManager.enableBlend(); + GlStateManager.enableAlpha(); + GlStateManager.enableTexture2D(); + GlStateManager.enableLighting(); + GlStateManager.enableDepth(); + Module.mc.getRenderItem().renderItemAndEffectIntoGUI(itemstack, i, j); + Module.mc.getRenderItem().renderItemOverlays(Module.mc.fontRendererObj, itemstack, i, j); + Module.mc.getRenderItem().zLevel = 0.0F; + RenderHelper.disableStandardItemLighting(); + GlStateManager.disableCull(); + GlStateManager.enableAlpha(); + GlStateManager.disableBlend(); + GlStateManager.disableLighting(); + double d0 = 0.5D; + + GlStateManager.scale(0.5D, 0.5D, 0.5D); + GlStateManager.disableDepth(); + this.renderEnchantText(itemstack, i, j); + GlStateManager.enableDepth(); + GlStateManager.scale(2.0F, 2.0F, 2.0F); + GlStateManager.popMatrix(); + } + + private void renderEnchantText(ItemStack itemstack, int i, int j) { + int k = j - 24; + + if (itemstack.getEnchantmentTagList() != null && itemstack.getEnchantmentTagList().tagCount() >= 6) { + Module.mc.fontRendererObj.drawStringWithShadow(NameTags.lIIIll[36], (float) (i * 2), (float) k, 16711680); + } else { + int l; + int i1; + int j1; + int k1; + + if (itemstack.getItem() instanceof ItemArmor) { + l = EnchantmentHelper.getEnchantmentLevel(Enchantment.protection.effectId, itemstack); + i1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.projectileProtection.effectId, itemstack); + j1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.blastProtection.effectId, itemstack); + k1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.fireProtection.effectId, itemstack); + int l1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.thorns.effectId, itemstack); + int i2 = EnchantmentHelper.getEnchantmentLevel(Enchantment.unbreaking.effectId, itemstack); + int j2 = itemstack.getMaxDamage() - itemstack.getItemDamage(); + + if (this.dura) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(j2)), (float) (i * 2), (float) j, 16777215); + } + + if (l > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[37]).append(l)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (i1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[38]).append(i1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (j1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[39]).append(j1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (k1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[40]).append(k1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (l1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[41]).append(l1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (i2 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[42]).append(i2)), (float) (i * 2), (float) k, -1); + k += 8; + } + } + + if (itemstack.getItem() instanceof ItemBow) { + l = EnchantmentHelper.getEnchantmentLevel(Enchantment.power.effectId, itemstack); + i1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.punch.effectId, itemstack); + j1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.flame.effectId, itemstack); + k1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.unbreaking.effectId, itemstack); + if (l > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[43]).append(l)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (i1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[44]).append(i1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (j1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[45]).append(j1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (k1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[46]).append(k1)), (float) (i * 2), (float) k, -1); + k += 8; + } + } + + if (itemstack.getItem() instanceof ItemSword) { + l = EnchantmentHelper.getEnchantmentLevel(Enchantment.sharpness.effectId, itemstack); + i1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.knockback.effectId, itemstack); + j1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.fireAspect.effectId, itemstack); + k1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.unbreaking.effectId, itemstack); + if (l > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[47]).append(l)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (i1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[48]).append(i1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (j1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[49]).append(j1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (k1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[50]).append(k1)), (float) (i * 2), (float) k, -1); + } + } + + if (itemstack.getItem() instanceof ItemTool) { + l = EnchantmentHelper.getEnchantmentLevel(Enchantment.unbreaking.effectId, itemstack); + i1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.efficiency.effectId, itemstack); + j1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.fortune.effectId, itemstack); + k1 = EnchantmentHelper.getEnchantmentLevel(Enchantment.silkTouch.effectId, itemstack); + if (i1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[51]).append(i1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (j1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[52]).append(j1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (k1 > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[53]).append(k1)), (float) (i * 2), (float) k, -1); + k += 8; + } + + if (l > 0) { + Module.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(NameTags.lIIIll[54]).append(l)), (float) (i * 2), (float) k, -1); + } + } + + if (itemstack.getItem() == Items.golden_apple && itemstack.hasEffect()) { + Module.mc.fontRendererObj.drawStringWithShadow(NameTags.lIIIll[55], (float) (i * 2), (float) k, -1); + } + + } + } + + static { + lIIlllll(); + lIIllllI(); + } + + private static void lIIllllI() { + lIIIll = new String[56]; + NameTags.lIIIll[0] = lllIlll(NameTags.llIIII[0], NameTags.llIIII[1]); + NameTags.lIIIll[1] = llllIII(NameTags.llIIII[2], NameTags.llIIII[3]); + NameTags.lIIIll[2] = llllIIl(NameTags.llIIII[4], NameTags.llIIII[5]); + NameTags.lIIIll[3] = lllIlll(NameTags.llIIII[6], NameTags.llIIII[7]); + NameTags.lIIIll[4] = lllIlll(NameTags.llIIII[8], NameTags.llIIII[9]); + NameTags.lIIIll[5] = llllIIl(NameTags.llIIII[10], NameTags.llIIII[11]); + NameTags.lIIIll[6] = lllIlll(NameTags.llIIII[12], NameTags.llIIII[13]); + NameTags.lIIIll[7] = llllIIl(NameTags.llIIII[14], NameTags.llIIII[15]); + NameTags.lIIIll[8] = llllIIl(NameTags.llIIII[16], NameTags.llIIII[17]); + NameTags.lIIIll[9] = llllIII(NameTags.llIIII[18], NameTags.llIIII[19]); + NameTags.lIIIll[10] = llllIII(NameTags.llIIII[20], NameTags.llIIII[21]); + NameTags.lIIIll[11] = lllIlll(NameTags.llIIII[22], NameTags.llIIII[23]); + NameTags.lIIIll[12] = llllIII(NameTags.llIIII[24], NameTags.llIIII[25]); + NameTags.lIIIll[13] = lllIlll(NameTags.llIIII[26], NameTags.llIIII[27]); + NameTags.lIIIll[14] = llllIIl(NameTags.llIIII[28], NameTags.llIIII[29]); + NameTags.lIIIll[15] = llllIIl(NameTags.llIIII[30], NameTags.llIIII[31]); + NameTags.lIIIll[16] = llllIII(NameTags.llIIII[32], NameTags.llIIII[33]); + NameTags.lIIIll[17] = llllIII(NameTags.llIIII[34], NameTags.llIIII[35]); + NameTags.lIIIll[18] = llllIII(NameTags.llIIII[36], NameTags.llIIII[37]); + NameTags.lIIIll[19] = llllIIl(NameTags.llIIII[38], NameTags.llIIII[39]); + NameTags.lIIIll[20] = llllIIl(NameTags.llIIII[40], NameTags.llIIII[41]); + NameTags.lIIIll[21] = lllIlll(NameTags.llIIII[42], NameTags.llIIII[43]); + NameTags.lIIIll[22] = lllIlll("0m/j2qzj2UHWr+0QgLBmMQ==", "QTjrb"); + NameTags.lIIIll[23] = lllIlll("pwMWrm7iV3w=", "bBReU"); + NameTags.lIIIll[24] = llllIIl("Ki40Nx8UPyczHw==", "zKFTz"); + NameTags.lIIIll[25] = lllIlll("gbNdu7I+vp9nWTBPQQ3ukw==", "vRiby"); + NameTags.lIIIll[26] = llllIIl("RUg=", "emcBX"); + NameTags.lIIIll[27] = llllIII("f1oHmprZRTI=", "RJetQ"); + NameTags.lIIIll[28] = lllIlll("mxXn7CvpCXM9xELb+zJjcA==", "HtcQG"); + NameTags.lIIIll[29] = llllIIl("dw==", "RZMYa"); + NameTags.lIIIll[30] = llllIII("QvNkO/3GLMg=", "IKKET"); + NameTags.lIIIll[31] = llllIIl("Zg==", "FCBRY"); + NameTags.lIIIll[32] = llllIIl("JSwCEQgPJhQ=", "aEqei"); + NameTags.lIIIll[33] = llllIIl("REtzcg==", "gePQo"); + NameTags.lIIIll[34] = llllIII("oJwXYkhSoss=", "xrUvL"); + NameTags.lIIIll[35] = llllIII("CNgfzcWX3jo=", "twlut"); + NameTags.lIIIll[36] = llllIII("X/5eJyd8XoM=", "RdhND"); + NameTags.lIIIll[37] = llllIIl("KBgLIA==", "XjdTb"); + NameTags.lIIIll[38] = llllIII("6lstHFRfH1M=", "YzgkT"); + NameTags.lIIIll[39] = llllIIl("LQI=", "OrSIk"); + NameTags.lIIIll[40] = lllIlll("G3weh1kleo8=", "YBJnG"); + NameTags.lIIIll[41] = llllIII("souQZGHK43k=", "KEcbJ"); + NameTags.lIIIll[42] = llllIII("EmFZq2eq1R8=", "EqeRx"); + NameTags.lIIIll[43] = lllIlll("ioplyssfSFc=", "juZNa"); + NameTags.lIIIll[44] = llllIII("qjL6HOtQTpk=", "YQCgU"); + NameTags.lIIIll[45] = lllIlll("3eOnQWuCIes=", "QCBhB"); + NameTags.lIIIll[46] = llllIII("OO6GPuM/h9k=", "uTDoH"); + NameTags.lIIIll[47] = llllIII("EDeomb/PFlQ=", "ObnnQ"); + NameTags.lIIIll[48] = llllIIl("Bxg=", "lzouX"); + NameTags.lIIIll[49] = lllIlll("ybhgneIw9eg=", "kUhyW"); + NameTags.lIIIll[50] = llllIIl("AwgL", "vfiJy"); + NameTags.lIIIll[51] = llllIIl("DjEJ", "kWowy"); + NameTags.lIIIll[52] = lllIlll("nkrlJ3pM3ik=", "Ovagk"); + NameTags.lIIIll[53] = llllIIl("OTo1Ag==", "JSYiX"); + NameTags.lIIIll[54] = llllIIl("Myw=", "FNOTf"); + NameTags.lIIIll[55] = lllIlll("lBQQu/JKCBg=", "RpfhY"); + NameTags.llIIII = null; + } + + private static void lIIlllll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + NameTags.llIIII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llllIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllIlll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llllIIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/render/Projectiles.java b/module/render/Projectiles.java new file mode 100644 index 0000000..5695969 --- /dev/null +++ b/module/render/Projectiles.java @@ -0,0 +1,203 @@ +package me.explicit.module.render; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.ItemUtils; +import me.explicit.utils.PrivateUtils; +import me.explicit.utils.RenderUtils; +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.Minecraft; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.client.renderer.entity.RenderManager; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemFishingRod; +import net.minecraft.item.ItemFood; +import net.minecraft.item.ItemPotion; +import net.minecraft.item.ItemStack; +import net.minecraft.util.BlockPos; +import net.minecraft.util.Vec3; +import org.lwjgl.opengl.GL11; + +public class Projectiles extends Module { + + private static final String[] lIIlllII; + private static String[] lIlIIIIl; + + public Projectiles() { + super(Projectiles.lIIlllII[0], 0, Category.RENDER, Projectiles.lIIlllII[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(Projectiles.lIIlllII[2], this, true)); + } + + public void onRender3D() { + if (Game.World() != null && Game.Player() != null) { + EntityPlayerSP entityplayersp = Game.Player(); + ItemStack itemstack = entityplayersp.inventory.getCurrentItem(); + + if (itemstack != null) { + if (ItemUtils.isThrowable(itemstack)) { + boolean flag = false; + + if (Game.Player().getCurrentEquippedItem() != null && (Game.Player().getCurrentEquippedItem().getItem() instanceof ItemBow || Game.Player().getCurrentEquippedItem().getItem() instanceof ItemFood || Game.Player().getCurrentEquippedItem().getItem() instanceof ItemPotion)) { + flag = true; + } + + if (!flag || Projectiles.mc.gameSettings.keyBindUseItem.isKeyDown()) { + boolean flag1 = itemstack.getItem() instanceof ItemBow; + double d0 = entityplayersp.lastTickPosX + (entityplayersp.posX - entityplayersp.lastTickPosX) * (double) PrivateUtils.timer().renderPartialTicks - Math.cos((double) ((float) Math.toRadians((double) entityplayersp.rotationYaw))) * 0.1599999964237213D; + double d1 = entityplayersp.lastTickPosY + (entityplayersp.posY - entityplayersp.lastTickPosY) * (double) PrivateUtils.timer().renderPartialTicks + (double) entityplayersp.getEyeHeight(); + double d2 = entityplayersp.lastTickPosZ + (entityplayersp.posZ - entityplayersp.lastTickPosZ) * (double) PrivateUtils.timer().renderPartialTicks - Math.sin((double) ((float) Math.toRadians((double) entityplayersp.rotationYaw))) * 0.1599999964237213D; + float f = flag1 ? 1.0F : 0.4F; + float f1 = (float) Math.toRadians((double) entityplayersp.rotationYaw); + float f2 = (float) Math.toRadians((double) entityplayersp.rotationPitch); + float f3 = (float) (-Math.sin((double) f1) * Math.cos((double) f2) * (double) f); + float f4 = (float) (-Math.sin((double) f2) * (double) f); + float f5 = (float) (Math.cos((double) f1) * Math.cos((double) f2) * (double) f); + double d3 = Math.sqrt((double) (f3 * f3 + f4 * f4 + f5 * f5)); + + f3 /= (float) d3; + f4 /= (float) d3; + f5 /= (float) d3; + if (flag1) { + float f6 = (float) (72000 - entityplayersp.getItemInUseCount()) / 20.0F; + + f6 = (f6 * f6 + f6 * 2.0F) / 3.0F; + if (f6 > 1.0F || f6 <= 0.1F) { + f6 = 1.0F; + } + + f6 *= 3.0F; + f3 *= f6; + f4 *= f6; + f5 *= f6; + } else { + f3 = (float) ((double) f3 * 1.5D); + f4 = (float) ((double) f4 * 1.5D); + f5 = (float) ((double) f5 * 1.5D); + } + + double d4 = (double) PrivateUtils.timer().renderPartialTicks - Minecraft.getMinecraft().getRenderManager().viewerPosX; + double d5 = (double) PrivateUtils.timer().renderPartialTicks - Minecraft.getMinecraft().getRenderManager().viewerPosY; + double d6 = (double) PrivateUtils.timer().renderPartialTicks - Minecraft.getMinecraft().getRenderManager().viewerPosZ; + + GL11.glPushMatrix(); + GL11.glDisable(3553); + GL11.glEnable(3042); + GL11.glBlendFunc(770, 771); + GL11.glDisable(2929); + GL11.glDepthMask(false); + GL11.glEnable(2848); + GL11.glLineWidth(2.0F); + RenderManager rendermanager = Projectiles.mc.getRenderManager(); + double d7 = flag1 ? 0.05D : (itemstack.getItem() instanceof ItemPotion ? 0.4D : (itemstack.getItem() instanceof ItemFishingRod ? 0.15D : 0.03D)); + + new Vec3(entityplayersp.posX, entityplayersp.posY + (double) entityplayersp.getEyeHeight(), entityplayersp.posZ); + GL11.glColor4f(0.0F, 1.0F, 0.0F, 0.75F); + GL11.glBegin(3); + + for (int i = 0; i < 1000; ++i) { + GL11.glVertex3d(d0 - Minecraft.getMinecraft().getRenderManager().viewerPosX, d1 - Minecraft.getMinecraft().getRenderManager().viewerPosY, d2 - Minecraft.getMinecraft().getRenderManager().viewerPosZ); + d0 += (double) f3 * 0.1D; + d1 += (double) f4 * 0.1D; + d2 += (double) f5 * 0.1D; + f3 *= 0.999F; + f4 *= 0.999F; + f5 *= 0.999F; + f4 -= (float) (d7 * 0.1D); + IBlockState iblockstate = Game.World().getBlockState(new BlockPos(d0, d1, d2)); + + if (!Game.World().isAirBlock(new BlockPos(d0, d1, d2)) && !iblockstate.getBlock().getUnlocalizedName().toLowerCase().contains(Projectiles.lIIlllII[3])) { + break; + } + } + + GL11.glEnd(); + double d8 = d0 - Minecraft.getMinecraft().getRenderManager().viewerPosX; + double d9 = d1 - Minecraft.getMinecraft().getRenderManager().viewerPosY; + double d10 = d2 - Minecraft.getMinecraft().getRenderManager().viewerPosZ; + + GL11.glPushMatrix(); + GL11.glTranslated(d8 - 0.5D, d9 - 0.5D, d10 - 0.5D); + if (Explicit.instance.sm.getSettingByName(this, Projectiles.lIIlllII[4]).getValBoolean()) { + GL11.glColor4f(0.0F, 1.0F, 0.0F, 0.25F); + RenderUtils.drawSolidBox(); + GL11.glColor4f(0.0F, 1.0F, 0.0F, 0.75F); + RenderUtils.drawOutlinedBox(); + } + + GL11.glPopMatrix(); + GL11.glDisable(3042); + GL11.glEnable(3553); + GL11.glEnable(2929); + GL11.glDepthMask(true); + GL11.glDisable(2848); + GL11.glPopMatrix(); + } + } + } + } + } + + static { + lIIIllIlll(); + lIIIllIllI(); + } + + private static void lIIIllIllI() { + lIIlllII = new String[5]; + Projectiles.lIIlllII[0] = lIIIlIIlIl(Projectiles.lIlIIIIl[0], Projectiles.lIlIIIIl[1]); + Projectiles.lIIlllII[1] = lIIIlIIlIl(Projectiles.lIlIIIIl[2], Projectiles.lIlIIIIl[3]); + Projectiles.lIIlllII[2] = lIIIlIIllI(Projectiles.lIlIIIIl[4], Projectiles.lIlIIIIl[5]); + Projectiles.lIIlllII[3] = lIIIlIIllI(Projectiles.lIlIIIIl[6], Projectiles.lIlIIIIl[7]); + Projectiles.lIIlllII[4] = lIIIlIIllI(Projectiles.lIlIIIIl[8], Projectiles.lIlIIIIl[9]); + Projectiles.lIlIIIIl = null; + } + + private static void lIIIllIlll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Projectiles.lIlIIIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIlIIlIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIlIIllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/render/Search.java b/module/render/Search.java new file mode 100644 index 0000000..9fa50ff --- /dev/null +++ b/module/render/Search.java @@ -0,0 +1,230 @@ +package me.explicit.module.render; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.Game; +import me.explicit.utils.RenderUtils; +import me.explicit.utils.TimerUtils; +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.util.BlockPos; +import net.minecraftforge.client.event.RenderWorldLastEvent; +import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; + +public class Search extends Module { + + public int r; + public boolean iron; + public boolean gold; + public boolean diamond; + public boolean emerald; + public boolean lapis; + public boolean redstone; + public boolean coal; + public boolean spawner; + public List ores; + public List blocksFound; + private TimerUtils updateTimer = new TimerUtils(); + private static final String[] lIIlIllIl; + private static String[] lIIlIllll; + + public Search() { + super(Search.lIIlIllIl[0], 0, Category.RENDER, Search.lIIlIllIl[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[2], this, 50.0D, 2.0D, 256.0D, true)); + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[3], this, 4000.0D, 1000.0D, 9999.0D, true)); + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[4], this, true)); + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[5], this, false)); + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[6], this, false)); + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[7], this, true)); + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[8], this, false)); + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[9], this, false)); + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[10], this, false)); + Explicit.instance.sm.rSetting(new Setting(Search.lIIlIllIl[11], this, false)); + (this.blocksFound = new ArrayList()).clear(); + (this.ores = new ArrayList()).add(Blocks.iron_ore); + this.ores.add(Blocks.gold_ore); + this.ores.add(Blocks.diamond_ore); + this.ores.add(Blocks.emerald_ore); + this.ores.add(Blocks.lapis_ore); + this.ores.add(Blocks.redstone_ore); + this.ores.add(Blocks.coal_ore); + this.ores.add(Blocks.mob_spawner); + } + + public void onUpdateNoToggle() { + this.r = Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[12]).getValInt(); + this.iron = Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[13]).getValBoolean(); + this.gold = Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[14]).getValBoolean(); + this.diamond = Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[15]).getValBoolean(); + this.redstone = Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[16]).getValBoolean(); + this.coal = Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[17]).getValBoolean(); + this.emerald = Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[18]).getValBoolean(); + this.lapis = Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[19]).getValBoolean(); + this.spawner = Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[20]).getValBoolean(); + } + + @SubscribeEvent + public void orl(RenderWorldLastEvent renderworldlastevent) { + if (this.updateTimer.hasReached(Explicit.instance.sm.getSettingByName(this, Search.lIIlIllIl[21]).getValDouble())) { + this.updateBlocks(); + this.updateTimer.reset(); + } + + if (this.iron || this.gold || this.coal || this.diamond || this.redstone || this.emerald || this.lapis || this.spawner) { + for (int i = 0; i < this.blocksFound.size(); ++i) { + this.draw((BlockFound) this.blocksFound.get(i)); + } + + } + } + + private void updateBlocks() { + this.blocksFound.clear(); + BlockPos blockpos = Game.Player().getPosition(); + int i = this.r; + + for (int j = blockpos.getX() - i; j <= blockpos.getX() + i; ++j) { + for (int k = blockpos.getZ() - i; k < blockpos.getZ() + i; ++k) { + for (int l = blockpos.getY() - i; l < blockpos.getY() + i; ++l) { + Block block = Game.World().getBlockState(new BlockPos(j, l, k)).getBlock(); + + if (this.ores.contains(block) && (this.iron || !block.equals(Blocks.iron_ore)) && (this.gold || !block.equals(Blocks.gold_ore)) && (this.diamond || !block.equals(Blocks.diamond_ore)) && (this.emerald || !block.equals(Blocks.emerald_ore)) && (this.lapis || !block.equals(Blocks.lapis_ore)) && (this.redstone || !block.equals(Blocks.redstone_ore)) && (this.coal || !block.equals(Blocks.coal_ore)) && (this.spawner || !block.equals(Blocks.mob_spawner))) { + this.blocksFound.add(new BlockFound(new BlockPos(j, l, k), block, this.color(block))); + } + } + } + } + + } + + private void draw(BlockFound blockfound) { + RenderUtils.blockESPBox(blockfound.pos, (float) blockfound.color.getRed(), (float) blockfound.color.getGreen(), (float) blockfound.color.getBlue(), 1.0F); + } + + private Color color(Block block) { + short short0 = 0; + short short1 = 0; + short short2 = 0; + + if (block.equals(Blocks.iron_ore)) { + short0 = 255; + short1 = 255; + short2 = 255; + } else if (block.equals(Blocks.gold_ore)) { + short0 = 255; + short1 = 255; + } else if (block.equals(Blocks.diamond_ore)) { + short1 = 220; + short2 = 255; + } else if (block.equals(Blocks.emerald_ore)) { + short0 = 35; + short1 = 255; + } else if (block.equals(Blocks.lapis_ore)) { + short1 = 50; + short2 = 255; + } else if (block.equals(Blocks.redstone_ore)) { + short0 = 255; + } else if (block.equals(Blocks.mob_spawner)) { + short0 = 30; + short2 = 135; + } + + return new Color(short0, short1, short2); + } + + static { + lIIIIlIlIII(); + lIIIIlIIlll(); + } + + private static void lIIIIlIIlll() { + lIIlIllIl = new String[22]; + Search.lIIlIllIl[0] = lIIIIlIIIlI(Search.lIIlIllll[0], Search.lIIlIllll[1]); + Search.lIIlIllIl[1] = lIIIIlIIIlI(Search.lIIlIllll[2], Search.lIIlIllll[3]); + Search.lIIlIllIl[2] = lIIIIlIIIll(Search.lIIlIllll[4], Search.lIIlIllll[5]); + Search.lIIlIllIl[3] = lIIIIlIIIlI(Search.lIIlIllll[6], Search.lIIlIllll[7]); + Search.lIIlIllIl[4] = lIIIIlIIIll(Search.lIIlIllll[8], Search.lIIlIllll[9]); + Search.lIIlIllIl[5] = lIIIIlIIIlI(Search.lIIlIllll[10], Search.lIIlIllll[11]); + Search.lIIlIllIl[6] = lIIIIlIIllI(Search.lIIlIllll[12], Search.lIIlIllll[13]); + Search.lIIlIllIl[7] = lIIIIlIIIlI(Search.lIIlIllll[14], Search.lIIlIllll[15]); + Search.lIIlIllIl[8] = lIIIIlIIIll(Search.lIIlIllll[16], Search.lIIlIllll[17]); + Search.lIIlIllIl[9] = lIIIIlIIIll(Search.lIIlIllll[18], Search.lIIlIllll[19]); + Search.lIIlIllIl[10] = lIIIIlIIIlI(Search.lIIlIllll[20], Search.lIIlIllll[21]); + Search.lIIlIllIl[11] = lIIIIlIIllI(Search.lIIlIllll[22], Search.lIIlIllll[23]); + Search.lIIlIllIl[12] = lIIIIlIIIll(Search.lIIlIllll[24], Search.lIIlIllll[25]); + Search.lIIlIllIl[13] = lIIIIlIIIlI(Search.lIIlIllll[26], Search.lIIlIllll[27]); + Search.lIIlIllIl[14] = lIIIIlIIIll(Search.lIIlIllll[28], Search.lIIlIllll[29]); + Search.lIIlIllIl[15] = lIIIIlIIllI(Search.lIIlIllll[30], Search.lIIlIllll[31]); + Search.lIIlIllIl[16] = lIIIIlIIllI(Search.lIIlIllll[32], Search.lIIlIllll[33]); + Search.lIIlIllIl[17] = lIIIIlIIIlI(Search.lIIlIllll[34], Search.lIIlIllll[35]); + Search.lIIlIllIl[18] = lIIIIlIIIlI(Search.lIIlIllll[36], Search.lIIlIllll[37]); + Search.lIIlIllIl[19] = lIIIIlIIIlI(Search.lIIlIllll[38], Search.lIIlIllll[39]); + Search.lIIlIllIl[20] = lIIIIlIIllI(Search.lIIlIllll[40], Search.lIIlIllll[41]); + Search.lIIlIllIl[21] = lIIIIlIIllI(Search.lIIlIllll[42], Search.lIIlIllll[43]); + Search.lIIlIllll = null; + } + + private static void lIIIIlIlIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Search.lIIlIllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIlIIIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIIlIIIlI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIIlIIllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/render/StorageESP.java b/module/render/StorageESP.java new file mode 100644 index 0000000..56fb416 --- /dev/null +++ b/module/render/StorageESP.java @@ -0,0 +1,205 @@ +package me.explicit.module.render; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; +import me.explicit.utils.RenderUtils; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.tileentity.TileEntityChest; +import net.minecraft.tileentity.TileEntityDispenser; +import net.minecraft.tileentity.TileEntityDropper; +import net.minecraft.tileentity.TileEntityEnderChest; +import net.minecraft.tileentity.TileEntityFurnace; +import net.minecraft.tileentity.TileEntityHopper; + +public class StorageESP extends Module { + + private boolean rainbow; + private int red; + private int green; + private int blue; + private static final String[] lIlIIlI; + private static String[] lIllIll; + + public StorageESP() { + super(StorageESP.lIlIIlI[0], 0, Category.RENDER, StorageESP.lIlIIlI[1]); + } + + public void setup() { + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[2], this, true)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[3], this, 2.0D, 0.1D, 5.0D, false)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[4], this, 150.0D, 0.0D, 255.0D, true)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[5], this, 0.0D, 0.0D, 255.0D, true)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[6], this, 0.0D, 0.0D, 255.0D, true)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[7], this, false)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[8], this, 20.0D, 1.0D, 512.0D, true)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[9], this, true)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[10], this, true)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[11], this, false)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[12], this, false)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[13], this, false)); + Explicit.instance.sm.rSetting(new Setting(StorageESP.lIlIIlI[14], this, false)); + } + + public void onUpdateNoToggle() { + this.rainbow = Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[15]).getValBoolean(); + Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[16]).setVisible(!this.rainbow); + Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[17]).setVisible(!this.rainbow); + Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[18]).setVisible(!this.rainbow); + } + + public void onRender3D() { + int i = (int) Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[19]).getValDouble(); + boolean flag = Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[20]).getValBoolean(); + Iterator iterator = StorageESP.mc.theWorld.loadedTileEntityList.iterator(); + + while (iterator.hasNext()) { + Object object = iterator.next(); + + if (flag) { + if (((TileEntity) object).getPos().getX() - StorageESP.mc.thePlayer.getPosition().getX() > -(i + 1) && ((TileEntity) object).getPos().getX() - StorageESP.mc.thePlayer.getPosition().getX() < i + 1 && ((TileEntity) object).getPos().getY() - StorageESP.mc.thePlayer.getPosition().getY() > -(i + 1) && ((TileEntity) object).getPos().getY() - StorageESP.mc.thePlayer.getPosition().getY() < i + 1 && ((TileEntity) object).getPos().getZ() - StorageESP.mc.thePlayer.getPosition().getZ() > -(i + 1) && ((TileEntity) object).getPos().getZ() - StorageESP.mc.thePlayer.getPosition().getZ() < i + 1) { + this.checkCorrectBlock((TileEntity) object); + } + } else { + this.checkCorrectBlock((TileEntity) object); + } + } + + } + + private void checkCorrectBlock(TileEntity tileentity) { + boolean flag = Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[21]).getValBoolean(); + boolean flag1 = Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[22]).getValBoolean(); + boolean flag2 = Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[23]).getValBoolean(); + boolean flag3 = Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[24]).getValBoolean(); + boolean flag4 = Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[25]).getValBoolean(); + boolean flag5 = Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[26]).getValBoolean(); + float f = (float) Explicit.instance.sm.getSettingByName(this, StorageESP.lIlIIlI[27]).getValDouble(); + + if (tileentity instanceof TileEntityChest && flag) { + RenderUtils.blockESPBox(((TileEntityChest) tileentity).getPos(), (float) this.getColor().getRed() / 255.0F, (float) this.getColor().getGreen() / 255.0F, (float) this.getColor().getBlue() / 255.0F, f); + } + + if (tileentity instanceof TileEntityEnderChest && flag1) { + RenderUtils.blockESPBox(((TileEntityEnderChest) tileentity).getPos(), (float) this.getColor().getRed() / 255.0F, (float) this.getColor().getGreen() / 255.0F, (float) this.getColor().getBlue() / 255.0F, f); + } + + if (tileentity instanceof TileEntityDropper && flag2) { + RenderUtils.blockESPBox(((TileEntityDropper) tileentity).getPos(), (float) this.getColor().getRed() / 255.0F, (float) this.getColor().getGreen() / 255.0F, (float) this.getColor().getBlue() / 255.0F, f); + } + + if (tileentity instanceof TileEntityDispenser && flag3) { + RenderUtils.blockESPBox(((TileEntityDispenser) tileentity).getPos(), (float) this.getColor().getRed() / 255.0F, (float) this.getColor().getGreen() / 255.0F, (float) this.getColor().getBlue() / 255.0F, f); + } + + if (tileentity instanceof TileEntityFurnace && flag4) { + RenderUtils.blockESPBox(((TileEntityFurnace) tileentity).getPos(), (float) this.getColor().getRed() / 255.0F, (float) this.getColor().getGreen() / 255.0F, (float) this.getColor().getBlue() / 255.0F, f); + } + + if (tileentity instanceof TileEntityHopper && flag5) { + RenderUtils.blockESPBox(((TileEntityHopper) tileentity).getPos(), (float) this.getColor().getRed() / 255.0F, (float) this.getColor().getGreen() / 255.0F, (float) this.getColor().getBlue() / 255.0F, f); + } + + } + + private Color getColor() { + return new Color(this.red, this.green, this.blue, 255); + } + + static { + lIIllIIll(); + lIIllIIlI(); + } + + private static void lIIllIIlI() { + lIlIIlI = new String[28]; + StorageESP.lIlIIlI[0] = lIIIlIllI(StorageESP.lIllIll[0], StorageESP.lIllIll[1]); + StorageESP.lIlIIlI[1] = lIIIllIIl(StorageESP.lIllIll[2], StorageESP.lIllIll[3]); + StorageESP.lIlIIlI[2] = lIIIllIIl(StorageESP.lIllIll[4], StorageESP.lIllIll[5]); + StorageESP.lIlIIlI[3] = lIIIllIIl(StorageESP.lIllIll[6], StorageESP.lIllIll[7]); + StorageESP.lIlIIlI[4] = lIIIlIllI(StorageESP.lIllIll[8], StorageESP.lIllIll[9]); + StorageESP.lIlIIlI[5] = lIIIllIIl(StorageESP.lIllIll[10], StorageESP.lIllIll[11]); + StorageESP.lIlIIlI[6] = lIIIllIIl(StorageESP.lIllIll[12], StorageESP.lIllIll[13]); + StorageESP.lIlIIlI[7] = lIIIllIIl(StorageESP.lIllIll[14], StorageESP.lIllIll[15]); + StorageESP.lIlIIlI[8] = lIIIlllIl(StorageESP.lIllIll[16], StorageESP.lIllIll[17]); + StorageESP.lIlIIlI[9] = lIIIlIllI(StorageESP.lIllIll[18], StorageESP.lIllIll[19]); + StorageESP.lIlIIlI[10] = lIIIlllIl(StorageESP.lIllIll[20], StorageESP.lIllIll[21]); + StorageESP.lIlIIlI[11] = lIIIllIIl(StorageESP.lIllIll[22], StorageESP.lIllIll[23]); + StorageESP.lIlIIlI[12] = lIIIlllIl(StorageESP.lIllIll[24], StorageESP.lIllIll[25]); + StorageESP.lIlIIlI[13] = lIIIlIllI(StorageESP.lIllIll[26], StorageESP.lIllIll[27]); + StorageESP.lIlIIlI[14] = lIIIllIIl(StorageESP.lIllIll[28], StorageESP.lIllIll[29]); + StorageESP.lIlIIlI[15] = lIIIllIIl(StorageESP.lIllIll[30], StorageESP.lIllIll[31]); + StorageESP.lIlIIlI[16] = lIIIlllIl(StorageESP.lIllIll[32], StorageESP.lIllIll[33]); + StorageESP.lIlIIlI[17] = lIIIlllIl(StorageESP.lIllIll[34], StorageESP.lIllIll[35]); + StorageESP.lIlIIlI[18] = lIIIllIIl(StorageESP.lIllIll[36], StorageESP.lIllIll[37]); + StorageESP.lIlIIlI[19] = lIIIllIIl(StorageESP.lIllIll[38], StorageESP.lIllIll[39]); + StorageESP.lIlIIlI[20] = lIIIlIllI(StorageESP.lIllIll[40], StorageESP.lIllIll[41]); + StorageESP.lIlIIlI[21] = lIIIllIIl(StorageESP.lIllIll[42], StorageESP.lIllIll[43]); + StorageESP.lIlIIlI[22] = lIIIllIIl("iXw57Tkipi/uXUcN4CdisQ==", "sPfVt"); + StorageESP.lIlIIlI[23] = lIIIlllIl("CRwlBjgoHA==", "MnJvH"); + StorageESP.lIlIIlI[24] = lIIIllIIl("EvoID8/FE+V3IryAuLVL7Q==", "unufH"); + StorageESP.lIlIIlI[25] = lIIIllIIl("maktT7XAm4I=", "sHAHn"); + StorageESP.lIlIIlI[26] = lIIIllIIl("eVAL6AlFbMw=", "iWMlu"); + StorageESP.lIlIIlI[27] = lIIIlllIl("Pg8ALh4bHAs=", "rfnKM"); + StorageESP.lIllIll = null; + } + + private static void lIIllIIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + StorageESP.lIllIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIllIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIlllIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIlIllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/render/TimeChanger.java b/module/render/TimeChanger.java new file mode 100644 index 0000000..fa9ea8d --- /dev/null +++ b/module/render/TimeChanger.java @@ -0,0 +1,99 @@ +package me.explicit.module.render; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.Setting; + +public class TimeChanger extends Module { + + private static final String[] lllIlIlI; + private static String[] llllIIll; + + public TimeChanger() { + super(TimeChanger.lllIlIlI[0], 0, Category.RENDER, TimeChanger.lllIlIlI[1]); + } + + public void setup() { + ArrayList arraylist; + + (arraylist = new ArrayList()).add(TimeChanger.lllIlIlI[2]); + arraylist.add(TimeChanger.lllIlIlI[3]); + arraylist.add(TimeChanger.lllIlIlI[4]); + Explicit.instance.sm.rSetting(new Setting(TimeChanger.lllIlIlI[5], this, TimeChanger.lllIlIlI[6], arraylist)); + } + + static { + llIlllIIII(); + llIllIllll(); + } + + private static void llIllIllll() { + lllIlIlI = new String[7]; + TimeChanger.lllIlIlI[0] = llIlIlllIl(TimeChanger.llllIIll[0], TimeChanger.llllIIll[1]); + TimeChanger.lllIlIlI[1] = llIllIIIIl(TimeChanger.llllIIll[2], TimeChanger.llllIIll[3]); + TimeChanger.lllIlIlI[2] = llIlIlllIl(TimeChanger.llllIIll[4], TimeChanger.llllIIll[5]); + TimeChanger.lllIlIlI[3] = llIllIIIlI(TimeChanger.llllIIll[6], TimeChanger.llllIIll[7]); + TimeChanger.lllIlIlI[4] = llIlIlllIl(TimeChanger.llllIIll[8], TimeChanger.llllIIll[9]); + TimeChanger.lllIlIlI[5] = llIlIlllIl(TimeChanger.llllIIll[10], TimeChanger.llllIIll[11]); + TimeChanger.lllIlIlI[6] = llIllIIIIl(TimeChanger.llllIIll[12], TimeChanger.llllIIll[13]); + TimeChanger.llllIIll = null; + } + + private static void llIlllIIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + TimeChanger.llllIIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIlIlllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIllIIIIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIllIIIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/values/ValueAnimals.java b/module/values/ValueAnimals.java new file mode 100644 index 0000000..13e7f46 --- /dev/null +++ b/module/values/ValueAnimals.java @@ -0,0 +1,50 @@ +package me.explicit.module.values; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ValueAnimals extends Module { + + private static final String[] llIlIlIl; + private static String[] llIlIllI; + + public ValueAnimals() { + super(ValueAnimals.llIlIlIl[0], 0, Category.VALUES, ValueAnimals.llIlIlIl[1]); + } + + static { + llIIIllllI(); + llIIIlllIl(); + } + + private static void llIIIlllIl() { + llIlIlIl = new String[2]; + ValueAnimals.llIlIlIl[0] = llIIIllIlI(ValueAnimals.llIlIllI[0], ValueAnimals.llIlIllI[1]); + ValueAnimals.llIlIlIl[1] = llIIIllIlI(ValueAnimals.llIlIllI[2], ValueAnimals.llIlIllI[3]); + ValueAnimals.llIlIllI = null; + } + + private static void llIIIllllI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ValueAnimals.llIlIllI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIIllIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/values/ValueFriends.java b/module/values/ValueFriends.java new file mode 100644 index 0000000..8b04119 --- /dev/null +++ b/module/values/ValueFriends.java @@ -0,0 +1,51 @@ +package me.explicit.module.values; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ValueFriends extends Module { + + private static final String[] lIIllIl; + private static String[] lIIllll; + + public ValueFriends() { + super(ValueFriends.lIIllIl[0], 0, Category.VALUES, ValueFriends.lIIllIl[1]); + this.setToggled(true); + } + + static { + lIIIIlllI(); + lIIIIllIl(); + } + + private static void lIIIIllIl() { + lIIllIl = new String[2]; + ValueFriends.lIIllIl[0] = lIIIIlIll(ValueFriends.lIIllll[0], ValueFriends.lIIllll[1]); + ValueFriends.lIIllIl[1] = lIIIIlIll(ValueFriends.lIIllll[2], ValueFriends.lIIllll[3]); + ValueFriends.lIIllll = null; + } + + private static void lIIIIlllI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ValueFriends.lIIllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIlIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/values/ValueInvisibles.java b/module/values/ValueInvisibles.java new file mode 100644 index 0000000..fd56eb8 --- /dev/null +++ b/module/values/ValueInvisibles.java @@ -0,0 +1,64 @@ +package me.explicit.module.values; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ValueInvisibles extends Module { + + private static final String[] lIIIIIIII; + private static String[] lIIIIIIIl; + + public ValueInvisibles() { + super(ValueInvisibles.lIIIIIIII[0], 0, Category.VALUES, ValueInvisibles.lIIIIIIII[1]); + } + + static { + lllIIlIIII(); + lllIIIllll(); + } + + private static void lllIIIllll() { + lIIIIIIII = new String[2]; + ValueInvisibles.lIIIIIIII[0] = lllIIIllIl(ValueInvisibles.lIIIIIIIl[0], ValueInvisibles.lIIIIIIIl[1]); + ValueInvisibles.lIIIIIIII[1] = lllIIIlllI(ValueInvisibles.lIIIIIIIl[2], ValueInvisibles.lIIIIIIIl[3]); + ValueInvisibles.lIIIIIIIl = null; + } + + private static void lllIIlIIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ValueInvisibles.lIIIIIIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lllIIIlllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lllIIIllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/values/ValueMobs.java b/module/values/ValueMobs.java new file mode 100644 index 0000000..35b129b --- /dev/null +++ b/module/values/ValueMobs.java @@ -0,0 +1,64 @@ +package me.explicit.module.values; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ValueMobs extends Module { + + private static final String[] lllIlIl; + private static String[] lllIlll; + + public ValueMobs() { + super(ValueMobs.lllIlIl[0], 0, Category.VALUES, ValueMobs.lllIlIl[1]); + } + + static { + llIIlIlII(); + llIIlIIll(); + } + + private static void llIIlIIll() { + lllIlIl = new String[2]; + ValueMobs.lllIlIl[0] = llIIlIIIl(ValueMobs.lllIlll[0], ValueMobs.lllIlll[1]); + ValueMobs.lllIlIl[1] = llIIlIIlI(ValueMobs.lllIlll[2], ValueMobs.lllIlll[3]); + ValueMobs.lllIlll = null; + } + + private static void llIIlIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ValueMobs.lllIlll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIlIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIlIIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/values/ValueNaked.java b/module/values/ValueNaked.java new file mode 100644 index 0000000..9c2eeba --- /dev/null +++ b/module/values/ValueNaked.java @@ -0,0 +1,69 @@ +package me.explicit.module.values; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ValueNaked extends Module { + + private static final String[] lIlII; + private static String[] lIlIl; + + public ValueNaked() { + super(ValueNaked.lIlII[0], 0, Category.VALUES, ValueNaked.lIlII[1]); + } + + static { + lIIIIll(); + lIIIIlI(); + } + + private static void lIIIIlI() { + lIlII = new String[2]; + ValueNaked.lIlII[0] = lIIIIII(ValueNaked.lIlIl[0], ValueNaked.lIlIl[1]); + ValueNaked.lIlII[1] = lIIIIIl(ValueNaked.lIlIl[2], ValueNaked.lIlIl[3]); + ValueNaked.lIlIl = null; + } + + private static void lIIIIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ValueNaked.lIlIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/values/ValueOthers.java b/module/values/ValueOthers.java new file mode 100644 index 0000000..76c36d8 --- /dev/null +++ b/module/values/ValueOthers.java @@ -0,0 +1,68 @@ +package me.explicit.module.values; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ValueOthers extends Module { + + private static final String[] lIlIlI; + private static String[] lIlIll; + + public ValueOthers() { + super(ValueOthers.lIlIlI[0], 0, Category.VALUES, ValueOthers.lIlIlI[1]); + } + + static { + lIIlIllI(); + lIIlIlIl(); + } + + private static void lIIlIlIl() { + lIlIlI = new String[2]; + ValueOthers.lIlIlI[0] = lIIlIIll(ValueOthers.lIlIll[0], ValueOthers.lIlIll[1]); + ValueOthers.lIlIlI[1] = lIIlIlII(ValueOthers.lIlIll[2], ValueOthers.lIlIll[3]); + ValueOthers.lIlIll = null; + } + + private static void lIIlIllI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ValueOthers.lIlIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIlIIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIlIlII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/module/values/ValuePlayers.java b/module/values/ValuePlayers.java new file mode 100644 index 0000000..c06d94f --- /dev/null +++ b/module/values/ValuePlayers.java @@ -0,0 +1,51 @@ +package me.explicit.module.values; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ValuePlayers extends Module { + + private static final String[] lIlllI; + private static String[] lIllll; + + public ValuePlayers() { + super(ValuePlayers.lIlllI[0], 0, Category.VALUES, ValuePlayers.lIlllI[1]); + this.setToggled(true); + } + + static { + lIIlllIl(); + lIIlllII(); + } + + private static void lIIlllII() { + lIlllI = new String[2]; + ValuePlayers.lIlllI[0] = lIIllIll(ValuePlayers.lIllll[0], ValuePlayers.lIllll[1]); + ValuePlayers.lIlllI[1] = lIIllIll(ValuePlayers.lIllll[2], ValuePlayers.lIllll[3]); + ValuePlayers.lIllll = null; + } + + private static void lIIlllIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ValuePlayers.lIllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIllIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/module/values/ValueTeams.java b/module/values/ValueTeams.java new file mode 100644 index 0000000..7f93da4 --- /dev/null +++ b/module/values/ValueTeams.java @@ -0,0 +1,69 @@ +package me.explicit.module.values; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ValueTeams extends Module { + + private static final String[] llllIIII; + private static String[] llllIIIl; + + public ValueTeams() { + super(ValueTeams.llllIIII[0], 0, Category.VALUES, ValueTeams.llllIIII[1]); + } + + static { + llIllIllII(); + llIllIlIll(); + } + + private static void llIllIlIll() { + llllIIII = new String[2]; + ValueTeams.llllIIII[0] = llIllIlIIl(ValueTeams.llllIIIl[0], ValueTeams.llllIIIl[1]); + ValueTeams.llllIIII[1] = llIllIlIlI(ValueTeams.llllIIIl[2], ValueTeams.llllIIIl[3]); + ValueTeams.llllIIIl = null; + } + + private static void llIllIllII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ValueTeams.llllIIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIllIlIIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIllIlIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/net/NetHandler.java b/net/NetHandler.java new file mode 100644 index 0000000..5b16910 --- /dev/null +++ b/net/NetHandler.java @@ -0,0 +1,589 @@ +package me.explicit.net; + +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.lang.reflect.Field; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.concurrent.ThreadLocalRandom; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import javax.swing.Timer; +import me.explicit.Explicit; +import me.explicit.module.combat.Reach; +import me.explicit.module.misc.PingSpoof; +import me.explicit.utils.CombatUtils; +import me.explicit.utils.Game; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.network.NetHandlerPlayClient; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.network.play.server.S00PacketKeepAlive; +import net.minecraft.network.play.server.S01PacketJoinGame; +import net.minecraft.network.play.server.S02PacketChat; +import net.minecraft.network.play.server.S03PacketTimeUpdate; +import net.minecraft.network.play.server.S04PacketEntityEquipment; +import net.minecraft.network.play.server.S05PacketSpawnPosition; +import net.minecraft.network.play.server.S06PacketUpdateHealth; +import net.minecraft.network.play.server.S07PacketRespawn; +import net.minecraft.network.play.server.S08PacketPlayerPosLook; +import net.minecraft.network.play.server.S09PacketHeldItemChange; +import net.minecraft.network.play.server.S0APacketUseBed; +import net.minecraft.network.play.server.S0BPacketAnimation; +import net.minecraft.network.play.server.S0CPacketSpawnPlayer; +import net.minecraft.network.play.server.S0DPacketCollectItem; +import net.minecraft.network.play.server.S0EPacketSpawnObject; +import net.minecraft.network.play.server.S0FPacketSpawnMob; +import net.minecraft.network.play.server.S10PacketSpawnPainting; +import net.minecraft.network.play.server.S11PacketSpawnExperienceOrb; +import net.minecraft.network.play.server.S12PacketEntityVelocity; +import net.minecraft.network.play.server.S13PacketDestroyEntities; +import net.minecraft.network.play.server.S14PacketEntity; +import net.minecraft.network.play.server.S18PacketEntityTeleport; +import net.minecraft.network.play.server.S19PacketEntityHeadLook; +import net.minecraft.network.play.server.S19PacketEntityStatus; +import net.minecraft.network.play.server.S1BPacketEntityAttach; +import net.minecraft.network.play.server.S1CPacketEntityMetadata; +import net.minecraft.network.play.server.S1DPacketEntityEffect; +import net.minecraft.network.play.server.S1EPacketRemoveEntityEffect; +import net.minecraft.network.play.server.S1FPacketSetExperience; +import net.minecraft.network.play.server.S20PacketEntityProperties; +import net.minecraft.network.play.server.S21PacketChunkData; +import net.minecraft.network.play.server.S22PacketMultiBlockChange; +import net.minecraft.network.play.server.S23PacketBlockChange; +import net.minecraft.network.play.server.S24PacketBlockAction; +import net.minecraft.network.play.server.S25PacketBlockBreakAnim; +import net.minecraft.network.play.server.S26PacketMapChunkBulk; +import net.minecraft.network.play.server.S27PacketExplosion; +import net.minecraft.network.play.server.S28PacketEffect; +import net.minecraft.network.play.server.S29PacketSoundEffect; +import net.minecraft.network.play.server.S2APacketParticles; +import net.minecraft.network.play.server.S2BPacketChangeGameState; +import net.minecraft.network.play.server.S2CPacketSpawnGlobalEntity; +import net.minecraft.network.play.server.S2DPacketOpenWindow; +import net.minecraft.network.play.server.S2EPacketCloseWindow; +import net.minecraft.network.play.server.S2FPacketSetSlot; +import net.minecraft.network.play.server.S30PacketWindowItems; +import net.minecraft.network.play.server.S31PacketWindowProperty; +import net.minecraft.network.play.server.S32PacketConfirmTransaction; +import net.minecraft.network.play.server.S33PacketUpdateSign; +import net.minecraft.network.play.server.S34PacketMaps; +import net.minecraft.network.play.server.S35PacketUpdateTileEntity; +import net.minecraft.network.play.server.S36PacketSignEditorOpen; +import net.minecraft.network.play.server.S37PacketStatistics; +import net.minecraft.network.play.server.S38PacketPlayerListItem; +import net.minecraft.network.play.server.S39PacketPlayerAbilities; +import net.minecraft.network.play.server.S3APacketTabComplete; +import net.minecraft.network.play.server.S3BPacketScoreboardObjective; +import net.minecraft.network.play.server.S3CPacketUpdateScore; +import net.minecraft.network.play.server.S3DPacketDisplayScoreboard; +import net.minecraft.network.play.server.S3EPacketTeams; +import net.minecraft.network.play.server.S3FPacketCustomPayload; +import net.minecraft.network.play.server.S40PacketDisconnect; +import net.minecraft.network.play.server.S44PacketWorldBorder; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.IChatComponent; +import net.minecraft.util.MathHelper; + +public class NetHandler extends NetHandlerPlayClient { + + private NetHandlerPlayClient parent; + private static final String[] lIlllIll; + private static String[] lIllllIl; + + public NetHandler(NetHandlerPlayClient nethandlerplayclient) { + super(Minecraft.getMinecraft(), getGuiScreen(nethandlerplayclient), nethandlerplayclient.getNetworkManager(), Game.Player().getGameProfile()); + this.parent = nethandlerplayclient; + } + + private static GuiScreen getGuiScreen(NetHandlerPlayClient nethandlerplayclient) { + Field[] afield = nethandlerplayclient.getClass().getDeclaredFields(); + int i = afield.length; + + for (int j = 0; j < i; ++j) { + Field field = afield[j]; + + if (field.getType().equals(GuiScreen.class)) { + field.setAccessible(true); + + try { + return (GuiScreen) field.get(nethandlerplayclient); + } catch (Exception exception) { + return null; + } + } + } + + return null; + } + + private double a(float f, float f1) { + float f2 = Math.abs(f - f1) % 360.0F; + + if (f2 > 180.0F) { + f2 = 360.0F - f2; + } + + return (double) f2; + } + + private float a(double d0, double d1) { + double d2 = d0 - Minecraft.getMinecraft().thePlayer.posX; + double d3 = d1 - Minecraft.getMinecraft().thePlayer.posZ; + float f = (float) Math.toDegrees(-Math.atan(d2 / d3)); + + if (d3 < 0.0D && d2 < 0.0D) { + f = (float) (90.0D + Math.toDegrees(Math.atan(d3 / d2))); + } else if (d3 < 0.0D && d2 > 0.0D) { + f = (float) (-90.0D + Math.toDegrees(Math.atan(d3 / d2))); + } + + return f; + } + + public void handleJoinGame(S01PacketJoinGame s01packetjoingame) { + this.parent.handleJoinGame(s01packetjoingame); + } + + public void handleSpawnObject(S0EPacketSpawnObject s0epacketspawnobject) { + this.parent.handleSpawnObject(s0epacketspawnobject); + } + + public void handleSpawnExperienceOrb(S11PacketSpawnExperienceOrb s11packetspawnexperienceorb) { + this.parent.handleSpawnExperienceOrb(s11packetspawnexperienceorb); + } + + public void handleSpawnGlobalEntity(S2CPacketSpawnGlobalEntity s2cpacketspawnglobalentity) { + this.parent.handleSpawnGlobalEntity(s2cpacketspawnglobalentity); + } + + public void handleSpawnPainting(S10PacketSpawnPainting s10packetspawnpainting) { + this.parent.handleSpawnPainting(s10packetspawnpainting); + } + + public void handleEntityVelocity(S12PacketEntityVelocity s12packetentityvelocity) { + this.parent.handleEntityVelocity(s12packetentityvelocity); + } + + public void handleEntityMetadata(S1CPacketEntityMetadata s1cpacketentitymetadata) { + this.parent.handleEntityMetadata(s1cpacketentitymetadata); + } + + public void handleSpawnPlayer(S0CPacketSpawnPlayer s0cpacketspawnplayer) { + this.parent.handleSpawnPlayer(s0cpacketspawnplayer); + } + + public void handleEntityTeleport(S18PacketEntityTeleport s18packetentityteleport) { + Entity entity = Minecraft.getMinecraft().theWorld.getEntityByID(s18packetentityteleport.getEntityId()); + + if (Explicit.destructed) { + this.parent.handleEntityTeleport(s18packetentityteleport); + } else { + Reach reach = (Reach) Explicit.instance.mm.getModuleByName(NetHandler.lIlllIll[0]); + + if (entity instanceof EntityPlayer && CombatUtils.canTarget(entity, true) && reach.isToggled() && Explicit.instance.sm.getSettingByName(reach, NetHandler.lIlllIll[1]).getValBoolean()) { + double d0 = (double) s18packetentityteleport.getX() / 32.0D; + double d1 = (double) s18packetentityteleport.getZ() / 32.0D; + double d2 = Explicit.instance.sm.getSettingByName(reach, NetHandler.lIlllIll[2]).getValDouble() - 3.0D; + double d3 = Explicit.instance.sm.getSettingByName(reach, NetHandler.lIlllIll[3]).getValDouble() - 3.0D; + double d4 = ThreadLocalRandom.current().nextDouble(Math.min(d2, d3), Math.max(d2, d3)); + + if (d4 == 0.0D) { + this.parent.handleEntityTeleport(s18packetentityteleport); + return; + } + + double d5 = Math.hypot(Minecraft.getMinecraft().thePlayer.posX - d0, Minecraft.getMinecraft().thePlayer.posZ - d1); + + if (d4 > d5) { + d4 -= d5; + } + + float f = this.a(d0, d1); + + if (this.a(Minecraft.getMinecraft().thePlayer.rotationYaw, f) > 180.0D) { + this.parent.handleEntityTeleport(s18packetentityteleport); + return; + } + + double d6 = Math.cos(Math.toRadians((double) (f + 90.0F))); + double d7 = Math.sin(Math.toRadians((double) (f + 90.0F))); + + d0 -= d6 * d4; + d1 -= d7 * d4; + Class oclass = s18packetentityteleport.getClass(); + + Field field; + + try { + field = oclass.getDeclaredField(NetHandler.lIlllIll[4]); + field.setAccessible(true); + field.set(s18packetentityteleport, Integer.valueOf(MathHelper.floor_double(d0 * 32.0D))); + field = oclass.getDeclaredField(NetHandler.lIlllIll[5]); + field.setAccessible(true); + field.set(s18packetentityteleport, Integer.valueOf(MathHelper.floor_double(d1 * 32.0D))); + } catch (Exception exception) { + ; + } + + try { + field = oclass.getDeclaredField(NetHandler.lIlllIll[6]); + field.setAccessible(true); + field.set(s18packetentityteleport, Integer.valueOf(MathHelper.floor_double(d0 * 32.0D))); + field = oclass.getDeclaredField(NetHandler.lIlllIll[7]); + field.setAccessible(true); + field.set(s18packetentityteleport, Integer.valueOf(MathHelper.floor_double(d1 * 32.0D))); + } catch (Exception exception1) { + ; + } + } + + this.parent.handleEntityTeleport(s18packetentityteleport); + } + } + + public void handleHeldItemChange(S09PacketHeldItemChange s09packethelditemchange) { + this.parent.handleHeldItemChange(s09packethelditemchange); + } + + public void handleEntityMovement(S14PacketEntity s14packetentity) { + this.parent.handleEntityMovement(s14packetentity); + } + + public void handleEntityHeadLook(S19PacketEntityHeadLook s19packetentityheadlook) { + this.parent.handleEntityHeadLook(s19packetentityheadlook); + } + + public void handleDestroyEntities(S13PacketDestroyEntities s13packetdestroyentities) { + this.parent.handleDestroyEntities(s13packetdestroyentities); + } + + public void handlePlayerPosLook(S08PacketPlayerPosLook s08packetplayerposlook) { + this.parent.handlePlayerPosLook(s08packetplayerposlook); + } + + public void handleMultiBlockChange(S22PacketMultiBlockChange s22packetmultiblockchange) { + this.parent.handleMultiBlockChange(s22packetmultiblockchange); + } + + public void handleChunkData(S21PacketChunkData s21packetchunkdata) { + this.parent.handleChunkData(s21packetchunkdata); + } + + public void handleBlockChange(S23PacketBlockChange s23packetblockchange) { + this.parent.handleBlockChange(s23packetblockchange); + } + + public void handleDisconnect(S40PacketDisconnect s40packetdisconnect) { + this.parent.handleDisconnect(s40packetdisconnect); + } + + public void onDisconnect(IChatComponent ichatcomponent) { + this.parent.onDisconnect(ichatcomponent); + } + + public void handleCollectItem(S0DPacketCollectItem s0dpacketcollectitem) { + this.parent.handleCollectItem(s0dpacketcollectitem); + } + + public void handleChat(S02PacketChat s02packetchat) { + IChatComponent ichatcomponent = s02packetchat.getChatComponent(); + + if (!Explicit.destructed && Explicit.instance.mm.getModuleByName(NetHandler.lIlllIll[8]).isToggled()) { + String s = s02packetchat.getChatComponent().getFormattedText(); + String s1 = s.replaceAll(Minecraft.getMinecraft().thePlayer.getName(), NetHandler.lIlllIll[9]); + String s2 = s1.replaceAll(Minecraft.getMinecraft().thePlayer.getDisplayName().getFormattedText(), NetHandler.lIlllIll[10]); + + if (s02packetchat.getChatComponent() instanceof ChatComponentText && !s02packetchat.isChat()) { + this.parent.handleChat(new S02PacketChat(new ChatComponentText(s2))); + return; + } + } + + this.parent.handleChat(s02packetchat); + } + + public void handleAnimation(S0BPacketAnimation s0bpacketanimation) { + this.parent.handleAnimation(s0bpacketanimation); + } + + public void handleUseBed(S0APacketUseBed s0apacketusebed) { + this.parent.handleUseBed(s0apacketusebed); + } + + public void handleSpawnMob(S0FPacketSpawnMob s0fpacketspawnmob) { + this.parent.handleSpawnMob(s0fpacketspawnmob); + } + + public void handleTimeUpdate(S03PacketTimeUpdate s03packettimeupdate) { + String s = Explicit.destructed ? NetHandler.lIlllIll[11] : (Explicit.instance.mm.getModuleByName(NetHandler.lIlllIll[12]).isToggled() ? Explicit.instance.sm.getSettingByName(Explicit.instance.mm.getModuleByName(NetHandler.lIlllIll[13]), NetHandler.lIlllIll[14]).getValString().toUpperCase() : NetHandler.lIlllIll[15]); + + if (s.equalsIgnoreCase(NetHandler.lIlllIll[16])) { + this.parent.handleTimeUpdate(new S03PacketTimeUpdate(s03packettimeupdate.getTotalWorldTime(), -6000L, true)); + } else if (s.equalsIgnoreCase(NetHandler.lIlllIll[17])) { + this.parent.handleTimeUpdate(new S03PacketTimeUpdate(s03packettimeupdate.getTotalWorldTime(), -22880L, true)); + } else if (s.equalsIgnoreCase(NetHandler.lIlllIll[18])) { + this.parent.handleTimeUpdate(new S03PacketTimeUpdate(s03packettimeupdate.getTotalWorldTime(), -18000L, true)); + } else { + this.parent.handleTimeUpdate(s03packettimeupdate); + } + + } + + public void handleSpawnPosition(S05PacketSpawnPosition s05packetspawnposition) { + this.parent.handleSpawnPosition(s05packetspawnposition); + } + + public void handleEntityAttach(S1BPacketEntityAttach s1bpacketentityattach) { + this.parent.handleEntityAttach(s1bpacketentityattach); + } + + public void handleEntityStatus(S19PacketEntityStatus s19packetentitystatus) { + this.parent.handleEntityStatus(s19packetentitystatus); + } + + public void handleUpdateHealth(S06PacketUpdateHealth s06packetupdatehealth) { + this.parent.handleUpdateHealth(s06packetupdatehealth); + } + + public void handleSetExperience(S1FPacketSetExperience s1fpacketsetexperience) { + this.parent.handleSetExperience(s1fpacketsetexperience); + } + + public void handleRespawn(S07PacketRespawn s07packetrespawn) { + this.parent.handleRespawn(s07packetrespawn); + } + + public void handleExplosion(S27PacketExplosion s27packetexplosion) { + this.parent.handleExplosion(s27packetexplosion); + } + + public void handleOpenWindow(S2DPacketOpenWindow s2dpacketopenwindow) { + this.parent.handleOpenWindow(s2dpacketopenwindow); + } + + public void handleSetSlot(S2FPacketSetSlot s2fpacketsetslot) { + this.parent.handleSetSlot(s2fpacketsetslot); + } + + public void handleConfirmTransaction(S32PacketConfirmTransaction s32packetconfirmtransaction) { + this.parent.handleConfirmTransaction(s32packetconfirmtransaction); + } + + public void handleWindowItems(S30PacketWindowItems s30packetwindowitems) { + this.parent.handleWindowItems(s30packetwindowitems); + } + + public void handleSignEditorOpen(S36PacketSignEditorOpen s36packetsigneditoropen) { + this.parent.handleSignEditorOpen(s36packetsigneditoropen); + } + + public void handleUpdateSign(S33PacketUpdateSign s33packetupdatesign) { + this.parent.handleUpdateSign(s33packetupdatesign); + } + + public void handleUpdateTileEntity(S35PacketUpdateTileEntity s35packetupdatetileentity) { + this.parent.handleUpdateTileEntity(s35packetupdatetileentity); + } + + public void handleWindowProperty(S31PacketWindowProperty s31packetwindowproperty) { + this.parent.handleWindowProperty(s31packetwindowproperty); + } + + public void handleEntityEquipment(S04PacketEntityEquipment s04packetentityequipment) { + this.parent.handleEntityEquipment(s04packetentityequipment); + } + + public void handleCloseWindow(S2EPacketCloseWindow s2epacketclosewindow) { + this.parent.handleCloseWindow(s2epacketclosewindow); + } + + public void handleBlockAction(S24PacketBlockAction s24packetblockaction) { + this.parent.handleBlockAction(s24packetblockaction); + } + + public void handleBlockBreakAnim(S25PacketBlockBreakAnim s25packetblockbreakanim) { + this.parent.handleBlockBreakAnim(s25packetblockbreakanim); + } + + public void handleMapChunkBulk(S26PacketMapChunkBulk s26packetmapchunkbulk) { + this.parent.handleMapChunkBulk(s26packetmapchunkbulk); + } + + public void handleChangeGameState(S2BPacketChangeGameState s2bpacketchangegamestate) { + this.parent.handleChangeGameState(s2bpacketchangegamestate); + } + + public void handleMaps(S34PacketMaps s34packetmaps) { + this.parent.handleMaps(s34packetmaps); + } + + public void handleEffect(S28PacketEffect s28packeteffect) { + this.parent.handleEffect(s28packeteffect); + } + + public void handleStatistics(S37PacketStatistics s37packetstatistics) { + this.parent.handleStatistics(s37packetstatistics); + } + + public void handleEntityEffect(S1DPacketEntityEffect s1dpacketentityeffect) { + this.parent.handleEntityEffect(s1dpacketentityeffect); + } + + public void handleRemoveEntityEffect(S1EPacketRemoveEntityEffect s1epacketremoveentityeffect) { + this.parent.handleRemoveEntityEffect(s1epacketremoveentityeffect); + } + + public void handlePlayerListItem(S38PacketPlayerListItem s38packetplayerlistitem) { + this.parent.handlePlayerListItem(s38packetplayerlistitem); + } + + public void handleKeepAlive(final S00PacketKeepAlive s00packetkeepalive) { + if (PingSpoof.toggled) { + Timer timer = new Timer(PingSpoof.ping, new ActionListener() { + final S00PacketKeepAlive val$packetIn = s00packetkeepalive; + final NetHandler this$0 = NetHandler.this; + + public void actionPerformed(ActionEvent actionevent) { + this.this$0.parent.handleKeepAlive(this.val$packetIn); + } + }); + + timer.setRepeats(false); + timer.start(); + } else { + this.parent.handleKeepAlive(s00packetkeepalive); + } + + } + + public void handlePlayerAbilities(S39PacketPlayerAbilities s39packetplayerabilities) { + this.parent.handlePlayerAbilities(s39packetplayerabilities); + } + + public void handleTabComplete(S3APacketTabComplete s3apackettabcomplete) { + this.parent.handleTabComplete(s3apackettabcomplete); + } + + public void handleSoundEffect(S29PacketSoundEffect s29packetsoundeffect) { + this.parent.handleSoundEffect(s29packetsoundeffect); + } + + public void handleCustomPayload(S3FPacketCustomPayload s3fpacketcustompayload) { + this.parent.handleCustomPayload(s3fpacketcustompayload); + } + + public void handleScoreboardObjective(S3BPacketScoreboardObjective s3bpacketscoreboardobjective) { + this.parent.handleScoreboardObjective(s3bpacketscoreboardobjective); + } + + public void handleUpdateScore(S3CPacketUpdateScore s3cpacketupdatescore) { + this.parent.handleUpdateScore(s3cpacketupdatescore); + } + + public void handleDisplayScoreboard(S3DPacketDisplayScoreboard s3dpacketdisplayscoreboard) { + this.parent.handleDisplayScoreboard(s3dpacketdisplayscoreboard); + } + + public void handleWorldBorder(S44PacketWorldBorder s44packetworldborder) { + this.parent.handleWorldBorder(s44packetworldborder); + } + + public void handleTeams(S3EPacketTeams s3epacketteams) { + this.parent.handleTeams(s3epacketteams); + } + + public void handleParticles(S2APacketParticles s2apacketparticles) { + this.parent.handleParticles(s2apacketparticles); + } + + public void handleEntityProperties(S20PacketEntityProperties s20packetentityproperties) { + this.parent.handleEntityProperties(s20packetentityproperties); + } + + static NetHandlerPlayClient access$000(NetHandler nethandler) { + return nethandler.parent; + } + + static { + lIlIllIlII(); + lIlIllIIlI(); + } + + private static void lIlIllIIlI() { + lIlllIll = new String[19]; + NetHandler.lIlllIll[0] = lIlIlIlllI(NetHandler.lIllllIl[0], NetHandler.lIllllIl[1]); + NetHandler.lIlllIll[1] = lIlIlIlllI(NetHandler.lIllllIl[2], NetHandler.lIllllIl[3]); + NetHandler.lIlllIll[2] = lIlIlIllll(NetHandler.lIllllIl[4], NetHandler.lIllllIl[5]); + NetHandler.lIlllIll[3] = lIlIlIllll(NetHandler.lIllllIl[6], NetHandler.lIllllIl[7]); + NetHandler.lIlllIll[4] = lIlIlIlllI(NetHandler.lIllllIl[8], NetHandler.lIllllIl[9]); + NetHandler.lIlllIll[5] = lIlIlIlllI(NetHandler.lIllllIl[10], NetHandler.lIllllIl[11]); + NetHandler.lIlllIll[6] = lIlIlIlllI(NetHandler.lIllllIl[12], NetHandler.lIllllIl[13]); + NetHandler.lIlllIll[7] = lIlIllIIII(NetHandler.lIllllIl[14], NetHandler.lIllllIl[15]); + NetHandler.lIlllIll[8] = lIlIllIIII(NetHandler.lIllllIl[16], NetHandler.lIllllIl[17]); + NetHandler.lIlllIll[9] = lIlIlIlllI(NetHandler.lIllllIl[18], NetHandler.lIllllIl[19]); + NetHandler.lIlllIll[10] = lIlIlIllll(NetHandler.lIllllIl[20], NetHandler.lIllllIl[21]); + NetHandler.lIlllIll[11] = lIlIlIlllI(NetHandler.lIllllIl[22], NetHandler.lIllllIl[23]); + NetHandler.lIlllIll[12] = lIlIlIllll(NetHandler.lIllllIl[24], NetHandler.lIllllIl[25]); + NetHandler.lIlllIll[13] = lIlIlIllll(NetHandler.lIllllIl[26], NetHandler.lIllllIl[27]); + NetHandler.lIlllIll[14] = lIlIlIllll(NetHandler.lIllllIl[28], NetHandler.lIllllIl[29]); + NetHandler.lIlllIll[15] = lIlIlIllll(NetHandler.lIllllIl[30], NetHandler.lIllllIl[31]); + NetHandler.lIlllIll[16] = lIlIlIllll(NetHandler.lIllllIl[32], NetHandler.lIllllIl[33]); + NetHandler.lIlllIll[17] = lIlIlIlllI(NetHandler.lIllllIl[34], NetHandler.lIllllIl[35]); + NetHandler.lIlllIll[18] = lIlIlIllll(NetHandler.lIllllIl[36], NetHandler.lIllllIl[37]); + NetHandler.lIllllIl = null; + } + + private static void lIlIllIlII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + NetHandler.lIllllIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlIlIllll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIllIIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIlIlllI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/settings/Setting.java b/settings/Setting.java new file mode 100644 index 0000000..68a6c23 --- /dev/null +++ b/settings/Setting.java @@ -0,0 +1,244 @@ +package me.explicit.settings; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.config.ConfigManager; +import me.explicit.module.Module; + +public class Setting { + + private String name; + private Module parent; + private String mode; + private String sval; + private List options; + private boolean bval; + private double dval; + private double min; + private double max; + private boolean onlyint = false; + public boolean percentage = false; + boolean visible = false; + private static final String[] lIlIIll; + private static String[] lIlIlII; + + public Setting(String s, Module module, String s1, ArrayList arraylist) { + this.name = s; + this.parent = module; + this.sval = s1; + this.options = arraylist; + this.mode = Setting.lIlIIll[0]; + this.visible = false; + } + + public Setting(String s, Module module, boolean flag) { + this.name = s; + this.parent = module; + this.bval = flag; + this.mode = Setting.lIlIIll[1]; + this.visible = false; + } + + public Setting(String s, Module module, double d0, double d1, double d2, boolean flag) { + this.name = s; + this.parent = module; + this.dval = d0; + this.min = d1; + this.max = d2; + this.onlyint = flag; + this.mode = Setting.lIlIIll[2]; + this.visible = false; + } + + public Setting(String s, Module module, double d0, double d1, double d2, boolean flag, boolean flag1) { + this.name = s; + this.parent = module; + this.dval = d0; + this.min = d1; + this.max = d2; + this.onlyint = flag; + this.percentage = flag1; + this.mode = Setting.lIlIIll[3]; + this.visible = false; + } + + public void setVisible(boolean flag) { + this.visible = !flag; + } + + public boolean isVisible() { + return this.visible; + } + + public String getName() { + return this.name; + } + + public Module getParentMod() { + return this.parent; + } + + public String getValString() { + return this.sval; + } + + public void setValString(String s) { + if (this.sval != s) { + this.sval = s; + ConfigManager.SaveConfigFile(Setting.lIlIIll[4]); + } + + } + + public void setValStringNoSave(String s) { + this.sval = s; + } + + public List getOptions() { + return this.options; + } + + public boolean getValBoolean() { + return this.bval; + } + + public void setValBoolean(boolean flag) { + if (this.bval != flag) { + this.bval = flag; + ConfigManager.SaveConfigFile(Setting.lIlIIll[5]); + } + + } + + public void setValBooleanNoSave(boolean flag) { + this.bval = flag; + } + + public double getValDouble() { + if (this.onlyint) { + this.dval = (double) ((int) this.dval); + } + + return this.dval; + } + + public int getValInt() { + if (this.onlyint) { + this.dval = (double) ((int) this.dval); + } + + return (int) this.dval; + } + + public void setValDouble(double d0) { + if (this.dval != d0) { + this.dval = d0; + ConfigManager.SaveConfigFile(Setting.lIlIIll[6]); + } + + } + + public void setValDoubleNoSave(double d0) { + this.dval = d0; + } + + public double getMin() { + return this.min; + } + + public double getMax() { + return this.max; + } + + public boolean isCombo() { + return this.mode.equalsIgnoreCase(Setting.lIlIIll[7]); + } + + public boolean isCheck() { + return this.mode.equalsIgnoreCase(Setting.lIlIIll[8]); + } + + public boolean isSlider() { + return this.mode.equalsIgnoreCase(Setting.lIlIIll[9]); + } + + public boolean onlyInt() { + return this.onlyint; + } + + static { + lIIIlllII(); + lIIIllIll(); + } + + private static void lIIIllIll() { + lIlIIll = new String[10]; + Setting.lIlIIll[0] = lIIIlIlll(Setting.lIlIlII[0], Setting.lIlIlII[1]); + Setting.lIlIIll[1] = lIIIllIII(Setting.lIlIlII[2], Setting.lIlIlII[3]); + Setting.lIlIIll[2] = lIIIlIlll(Setting.lIlIlII[4], Setting.lIlIlII[5]); + Setting.lIlIIll[3] = lIIIlIlll(Setting.lIlIlII[6], Setting.lIlIlII[7]); + Setting.lIlIIll[4] = lIIIllIII(Setting.lIlIlII[8], Setting.lIlIlII[9]); + Setting.lIlIIll[5] = lIIIlIlll(Setting.lIlIlII[10], Setting.lIlIlII[11]); + Setting.lIlIIll[6] = lIIIlIlll(Setting.lIlIlII[12], Setting.lIlIlII[13]); + Setting.lIlIIll[7] = lIIIllIlI(Setting.lIlIlII[14], Setting.lIlIlII[15]); + Setting.lIlIIll[8] = lIIIllIII(Setting.lIlIlII[16], Setting.lIlIlII[17]); + Setting.lIlIIll[9] = lIIIllIII(Setting.lIlIlII[18], Setting.lIlIlII[19]); + Setting.lIlIlII = null; + } + + private static void lIIIlllII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Setting.lIlIlII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIllIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIlIlll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIllIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/settings/SettingsManager.java b/settings/SettingsManager.java new file mode 100644 index 0000000..506b6a9 --- /dev/null +++ b/settings/SettingsManager.java @@ -0,0 +1,90 @@ +package me.explicit.settings; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import me.explicit.module.Module; + +public class SettingsManager { + + private List settings; + ArrayList out; + ArrayList outSetting; + + public void rSetting(Setting setting) { + if (this.settings == null) { + (this.settings = new ArrayList()).add(setting); + } else { + this.settings.add(setting); + } + + } + + public List getSettings() { + return this.settings; + } + + public List getSettingsByMod(Module module) { + if (this.outSetting == null) { + (this.outSetting = new ArrayList()).clear(); + } else { + this.outSetting.clear(); + } + + Iterator iterator = this.getSettings().iterator(); + + while (iterator.hasNext()) { + Setting setting = (Setting) iterator.next(); + + if (setting.getParentMod().equals(module)) { + this.outSetting.add(setting); + } + } + + if (this.outSetting.isEmpty()) { + return null; + } else { + return this.outSetting; + } + } + + public List getSettingsNameByMod(Module module) { + if (this.out == null) { + (this.out = new ArrayList()).clear(); + } else { + this.out.clear(); + } + + Iterator iterator = this.getSettings().iterator(); + + while (iterator.hasNext()) { + Setting setting = (Setting) iterator.next(); + + if (setting.getParentMod().equals(module)) { + this.out.add(setting.getName()); + } + } + + if (this.out.isEmpty()) { + return null; + } else { + return this.out; + } + } + + public Setting getSettingByName(Module module, String s) { + Iterator iterator = this.getSettings().iterator(); + + Setting setting; + + do { + if (!iterator.hasNext()) { + return null; + } + + setting = (Setting) iterator.next(); + } while (!setting.getName().equalsIgnoreCase(s) || !setting.getParentMod().equals(module)); + + return setting; + } +} diff --git a/ui/clickgui/ClickGUI.java b/ui/clickgui/ClickGUI.java new file mode 100644 index 0000000..aab653a --- /dev/null +++ b/ui/clickgui/ClickGUI.java @@ -0,0 +1,440 @@ +package me.explicit.ui.clickgui; + +import java.awt.Color; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Collections; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.config.ConfigManager; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.SettingsManager; +import me.explicit.ui.clickgui.elements.Element; +import me.explicit.ui.clickgui.elements.ModuleButton; +import me.explicit.ui.clickgui.elements.menu.ElementSlider; +import me.explicit.ui.clickgui.util.ColorUtil; +import me.explicit.ui.clickgui.util.FontUtil; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiScreen; +import net.minecraft.client.gui.ScaledResolution; +import org.lwjgl.input.Keyboard; +import org.lwjgl.opengl.GL11; + +public class ClickGUI extends GuiScreen { + + public static ArrayList panels; + public static ArrayList rpanels; + private ModuleButton mb = null; + public SettingsManager setmgr; + boolean wasFastRenderOn; + public static boolean enabled; + private TimerUtils timer = new TimerUtils(); + private static final String[] lIllllI; + private static String[] lIlllll; + + public ClickGUI() { + this.setmgr = Explicit.instance.sm; + FontUtil.setupFontUtils(); + (ClickGUI.panels = new ArrayList()).clear(); + final double d0 = 80.0D; + final double d1 = 20.0D; + final double d2 = 10.0D; + final double d3 = 10.0D; + double d4 = d1; + Category[] acategory = Category.values(); + int i = acategory.length; + + for (int j = 0; j < i; ++j) { + final Category category = acategory[j]; + final String s = String.valueOf((new StringBuilder()).append(Character.toUpperCase(category.name().toLowerCase().charAt(0))).append(category.name().toLowerCase().substring(1))); + + ClickGUI.panels.add(new Panel(s, d2, d0, (double) false, (double) category, flag, clickgui) { + final Category val$c = category; + final ClickGUI this$0 = ClickGUI.this; + + public void setup() { + Iterator iterator = Explicit.instance.mm.modules.iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + if (module.getCategory().equals(this.val$c)) { + this.Elements.add(new ModuleButton(module, this)); + } + } + + } + }); + d3 += d4 + 2.0D; + } + + ClickGUI.rpanels = new ArrayList(); + Iterator iterator = ClickGUI.panels.iterator(); + + while (iterator.hasNext()) { + Panel panel = (Panel) iterator.next(); + + ClickGUI.rpanels.add(panel); + } + + Collections.reverse(ClickGUI.rpanels); + } + + public void drawScreen(int i, int j, float f) { + Iterator iterator = ClickGUI.panels.iterator(); + + while (iterator.hasNext()) { + Panel panel = (Panel) iterator.next(); + + panel.drawScreen(i, j, f); + } + + ScaledResolution scaledresolution = new ScaledResolution(this.mc); + + GL11.glPushMatrix(); + GL11.glTranslated((double) scaledresolution.getScaledWidth(), (double) scaledresolution.getScaledHeight(), 0.0D); + GL11.glScaled(0.5D, 0.5D, 0.5D); + GL11.glPopMatrix(); + this.mb = null; + Iterator iterator1 = ClickGUI.panels.iterator(); + + Panel panel1; + Iterator iterator2; + ModuleButton modulebutton; + + label109: + while (iterator1.hasNext()) { + panel1 = (Panel) iterator1.next(); + if (panel1 != null && panel1.visible && panel1.extended && panel1.Elements != null && panel1.Elements.size() > 0) { + iterator2 = panel1.Elements.iterator(); + + while (iterator2.hasNext()) { + modulebutton = (ModuleButton) iterator2.next(); + if (modulebutton.listening) { + this.mb = modulebutton; + break label109; + } + } + } + } + + iterator1 = ClickGUI.panels.iterator(); + + while (iterator1.hasNext()) { + panel1 = (Panel) iterator1.next(); + if (panel1.extended && panel1.visible && panel1.Elements != null) { + iterator2 = panel1.Elements.iterator(); + + while (iterator2.hasNext()) { + modulebutton = (ModuleButton) iterator2.next(); + if (modulebutton.extended && modulebutton.menuelements != null && !modulebutton.menuelements.isEmpty()) { + double d0 = -1.0D; + Color color = ColorUtil.getClickGUIColor().darker(); + int k = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 255)).getRGB(); + Iterator iterator3 = modulebutton.menuelements.iterator(); + + while (iterator3.hasNext()) { + Element element = (Element) iterator3.next(); + + if (!element.set.isVisible()) { + element.offset = d0; + element.update(); + element.drawScreen(i, j, f); + d0 += element.height; + } + } + } + } + } + } + + if (this.mb != null) { + drawRect(0, 0, this.width, this.height, -2012213232); + GL11.glPushMatrix(); + GL11.glTranslatef((float) (scaledresolution.getScaledWidth() / 2), (float) (scaledresolution.getScaledHeight() / 2), 0.0F); + FontUtil.drawBigTotalCenteredStringWithShadow(ClickGUI.lIllllI[0], 0.0F, -20.0F, -1); + FontUtil.drawBigTotalCenteredStringWithShadow(String.valueOf((new StringBuilder()).append(ClickGUI.lIllllI[1]).append(this.mb.mod.getName()).append(this.mb.mod.getKey() > -1 ? String.valueOf((new StringBuilder()).append(ClickGUI.lIllllI[2]).append(Keyboard.getKeyName(this.mb.mod.getKey())).append(ClickGUI.lIllllI[3])) : ClickGUI.lIllllI[4])), 0.0F, 0.0F, -1); + GL11.glPopMatrix(); + } + + String s = String.valueOf((new StringBuilder()).append(ClickGUI.lIllllI[5]).append(ClickGUI.lIllllI[6].toLowerCase())); + char[] achar = s.toCharArray(); + double d1 = 5.0D; + ScaledResolution scaledresolution1 = new ScaledResolution(this.mc); + + for (int l = 0; l < achar.length; ++l) { + this.mc.fontRendererObj.drawString(String.valueOf((new StringBuilder()).append(achar[l]).append(ClickGUI.lIllllI[7])), scaledresolution1.getScaledWidth() - 10 - this.mc.fontRendererObj.getStringWidth(s) + (int) d1, 5, Explicit.instance.uiRenderer.getColor(l).getRGB()); + d1 += (double) this.mc.fontRendererObj.getStringWidth(String.valueOf((new StringBuilder()).append(achar[l]).append(ClickGUI.lIllllI[8]))); + } + + super.drawScreen(i, j, f); + } + + public void mouseClicked(int i, int j, int k) { + ConfigManager.saveGUISettings(); + if (this.mb == null) { + Iterator iterator = ClickGUI.rpanels.iterator(); + + Panel panel; + + while (iterator.hasNext()) { + panel = (Panel) iterator.next(); + if (panel.extended && panel.visible && panel.Elements != null) { + Iterator iterator1 = panel.Elements.iterator(); + + while (iterator1.hasNext()) { + ModuleButton modulebutton = (ModuleButton) iterator1.next(); + + if (modulebutton.extended) { + Iterator iterator2 = modulebutton.menuelements.iterator(); + + while (iterator2.hasNext()) { + Element element = (Element) iterator2.next(); + + if (!element.set.isVisible() && element.mouseClicked(i, j, k)) { + return; + } + } + } + } + } + } + + iterator = ClickGUI.rpanels.iterator(); + + do { + if (!iterator.hasNext()) { + try { + super.mouseClicked(i, j, k); + } catch (IOException ioexception) { + ioexception.printStackTrace(); + } + + return; + } + + panel = (Panel) iterator.next(); + } while (!panel.mouseClicked(i, j, k)); + + } + } + + public void mouseReleased(int i, int j, int k) { + if (this.mb == null) { + Iterator iterator = ClickGUI.rpanels.iterator(); + + Panel panel; + + while (iterator.hasNext()) { + panel = (Panel) iterator.next(); + if (panel.extended && panel.visible && panel.Elements != null) { + Iterator iterator1 = panel.Elements.iterator(); + + while (iterator1.hasNext()) { + ModuleButton modulebutton = (ModuleButton) iterator1.next(); + + if (modulebutton.extended) { + Iterator iterator2 = modulebutton.menuelements.iterator(); + + while (iterator2.hasNext()) { + Element element = (Element) iterator2.next(); + + element.mouseReleased(i, j, k); + } + } + } + } + } + + iterator = ClickGUI.rpanels.iterator(); + + while (iterator.hasNext()) { + panel = (Panel) iterator.next(); + panel.mouseReleased(i, j, k); + } + + super.mouseReleased(i, j, k); + } + } + + protected void keyTyped(char c0, int i) { + Iterator iterator = ClickGUI.rpanels.iterator(); + + while (iterator.hasNext()) { + Panel panel = (Panel) iterator.next(); + + if (panel != null && panel.visible && panel.extended && panel.Elements != null && panel.Elements.size() > 0) { + Iterator iterator1 = panel.Elements.iterator(); + + while (iterator1.hasNext()) { + ModuleButton modulebutton = (ModuleButton) iterator1.next(); + + try { + if (modulebutton.keyTyped(c0, i)) { + return; + } + } catch (IOException ioexception) { + ioexception.printStackTrace(); + } + } + } + } + + try { + super.keyTyped(c0, i); + } catch (IOException ioexception1) { + ioexception1.printStackTrace(); + } + + } + + public void initGui() { + ScaledResolution scaledresolution = new ScaledResolution(this.mc); + + this.buttonList.add(new GuiButton(1, 5, scaledresolution.getScaledHeight() - 25, 100, 20, ClickGUI.lIllllI[9])); + } + + protected void actionPerformed(GuiButton guibutton) throws IOException { + if (guibutton.id == 1) { + this.closeAllSettings(); + double d0 = 22.0D; + double d1 = 10.0D; + double d2 = 10.0D; + double d3 = d0; + + for (Iterator iterator = ClickGUI.panels.iterator(); iterator.hasNext(); d2 += d3) { + Panel panel = (Panel) iterator.next(); + + panel.dragging = false; + panel.extended = false; + panel.x = d1; + panel.y = d2; + } + } + + } + + public void onGuiClosed() { + Iterator iterator = ClickGUI.rpanels.iterator(); + + while (iterator.hasNext()) { + Panel panel = (Panel) iterator.next(); + + if (panel.extended && panel.visible && panel.Elements != null) { + Iterator iterator1 = panel.Elements.iterator(); + + while (iterator1.hasNext()) { + ModuleButton modulebutton = (ModuleButton) iterator1.next(); + + if (modulebutton.extended) { + Iterator iterator2 = modulebutton.menuelements.iterator(); + + while (iterator2.hasNext()) { + Element element = (Element) iterator2.next(); + + if (element instanceof ElementSlider) { + ((ElementSlider) element).dragging = false; + } + } + } + } + } + } + + } + + public void closeAllSettings() { + Iterator iterator = ClickGUI.rpanels.iterator(); + + while (iterator.hasNext()) { + Panel panel = (Panel) iterator.next(); + ModuleButton modulebutton; + + if (panel != null && panel.visible && panel.extended && panel.Elements != null && panel.Elements.size() > 0) { + for (Iterator iterator1 = panel.Elements.iterator(); iterator1.hasNext(); modulebutton.extended = false) { + modulebutton = (ModuleButton) iterator1.next(); + } + } + } + + } + + static { + lIlIIIlll(); + lIlIIIllI(); + ClickGUI.enabled = false; + } + + private static void lIlIIIllI() { + lIllllI = new String[10]; + ClickGUI.lIllllI[0] = lIlIIIIll(ClickGUI.lIlllll[0], ClickGUI.lIlllll[1]); + ClickGUI.lIllllI[1] = lIlIIIIll(ClickGUI.lIlllll[2], ClickGUI.lIlllll[3]); + ClickGUI.lIllllI[2] = lIlIIIIll(ClickGUI.lIlllll[4], ClickGUI.lIlllll[5]); + ClickGUI.lIllllI[3] = lIlIIIlII(ClickGUI.lIlllll[6], ClickGUI.lIlllll[7]); + ClickGUI.lIllllI[4] = lIlIIIlIl(ClickGUI.lIlllll[8], ClickGUI.lIlllll[9]); + ClickGUI.lIllllI[5] = lIlIIIlII(ClickGUI.lIlllll[10], ClickGUI.lIlllll[11]); + ClickGUI.lIllllI[6] = lIlIIIlIl(ClickGUI.lIlllll[12], ClickGUI.lIlllll[13]); + ClickGUI.lIllllI[7] = lIlIIIlIl(ClickGUI.lIlllll[14], ClickGUI.lIlllll[15]); + ClickGUI.lIllllI[8] = lIlIIIIll(ClickGUI.lIlllll[16], ClickGUI.lIlllll[17]); + ClickGUI.lIllllI[9] = lIlIIIlII(ClickGUI.lIlllll[18], ClickGUI.lIlllll[19]); + ClickGUI.lIlllll = null; + } + + private static void lIlIIIlll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ClickGUI.lIlllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlIIIlIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIlIIIIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIIIlII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/ui/clickgui/Panel.java b/ui/clickgui/Panel.java new file mode 100644 index 0000000..48feb99 --- /dev/null +++ b/ui/clickgui/Panel.java @@ -0,0 +1,157 @@ +package me.explicit.ui.clickgui; + +import java.awt.Color; +import java.util.ArrayList; +import java.util.Iterator; +import me.explicit.ui.clickgui.elements.Element; +import me.explicit.ui.clickgui.elements.ModuleButton; +import me.explicit.ui.clickgui.util.ColorUtil; +import me.explicit.ui.clickgui.util.FontUtil; +import net.minecraft.client.gui.Gui; + +public class Panel { + + public String title; + public double x; + public double y; + private double x2; + private double y2; + public double width; + public double height; + public boolean dragging; + public boolean extended; + public boolean visible; + public ArrayList Elements; + public ClickGUI clickgui; + + public Panel(String s, double d0, double d1, double d2, double d3, boolean flag, ClickGUI clickgui) { + this.title = s; + this.x = d0; + this.y = d1; + this.width = d2; + this.height = d3; + this.extended = flag; + this.dragging = false; + this.visible = true; + this.clickgui = clickgui; + (this.Elements = new ArrayList()).clear(); + this.setup(); + } + + public void setup() {} + + public void drawScreen(int i, int j, float f) { + if (this.visible) { + if (this.dragging) { + this.x = this.x2 + (double) i; + this.y = this.y2 + (double) j; + } + + Color color = (new Color(ColorUtil.getClickGUIColor().getRed(), ColorUtil.getClickGUIColor().getGreen(), ColorUtil.getClickGUIColor().getBlue(), 0)).darker(); + int k = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 200)).getRGB(); + + Gui.drawRect((int) this.x, (int) this.y, (int) this.x + (int) this.width, (int) this.y + (int) this.height, -15592942); + Gui.drawRect((int) this.x, (int) this.y, (int) this.x + 80, (int) this.y + (int) this.height, k); + if (this.extended && !this.Elements.isEmpty()) { + double d0 = this.y + this.height; + int l = (new Color(ColorUtil.getClickGUIColor().getRed(), ColorUtil.getClickGUIColor().getGreen(), ColorUtil.getClickGUIColor().getBlue(), 100)).darker().darker().getRGB(); + Iterator iterator = this.Elements.iterator(); + + ModuleButton modulebutton; + + while (iterator.hasNext()) { + modulebutton = (ModuleButton) iterator.next(); + Element element = null; + + Gui.drawRect((int) this.x, (int) d0, (int) this.x + (int) this.width, (int) d0 + (int) modulebutton.height + 1, l); + modulebutton.x = this.x + 2.0D; + modulebutton.y = d0 + 1.0D; + modulebutton.width = this.width - 4.0D; + modulebutton.drawScreen(i, j, f); + if (modulebutton.extended) { + int i1 = 1; + Iterator iterator1 = modulebutton.menuelements.iterator(); + + while (iterator1.hasNext()) { + Element element1 = (Element) iterator1.next(); + + if (!element1.set.isVisible()) { + i1 = (int) ((double) i1 + element1.height); + element = element1; + } + } + + d0 += modulebutton.height + (double) i1; + } else { + d0 += modulebutton.height + 1.0D; + } + + if (element != null) { + element.setEndEl(true); + Iterator iterator2 = modulebutton.menuelements.iterator(); + + while (iterator2.hasNext()) { + Element element2 = (Element) iterator2.next(); + + if (element2 != element) { + element2.setEndEl(false); + } + } + } + } + + FontUtil.drawStringWithShadow(this.title, (float) (this.x + 5.0D), (float) (this.y + this.height / 2.0D - (double) (FontUtil.getFontHeight() / 2)), -1052689); + iterator = this.Elements.iterator(); + + while (iterator.hasNext()) { + modulebutton = (ModuleButton) iterator.next(); + modulebutton.onUpdate(); + } + } else { + FontUtil.drawStringWithShadow(this.title, (float) (this.x + 5.0D), (float) (this.y + this.height / 2.0D - (double) (FontUtil.getFontHeight() / 2)), -1052689); + } + + } + } + + public boolean mouseClicked(int i, int j, int k) { + if (!this.visible) { + return false; + } else if (k == 0 && this.isHovered(i, j)) { + this.x2 = this.x - (double) i; + this.y2 = this.y - (double) j; + this.dragging = true; + return true; + } else if (k == 1 && this.isHovered(i, j)) { + this.extended = !this.extended; + return true; + } else { + if (this.extended) { + Iterator iterator = this.Elements.iterator(); + + while (iterator.hasNext()) { + ModuleButton modulebutton = (ModuleButton) iterator.next(); + + if (modulebutton.mouseClicked(i, j, k)) { + return true; + } + } + } + + return false; + } + } + + public void mouseReleased(int i, int j, int k) { + if (this.visible) { + if (k == 0) { + this.dragging = false; + } + + } + } + + public boolean isHovered(int i, int j) { + return (double) i >= this.x && (double) i <= this.x + this.width && (double) j >= this.y && (double) j <= this.y + this.height; + } +} diff --git a/ui/clickgui/elements/Element.java b/ui/clickgui/elements/Element.java new file mode 100644 index 0000000..889a58b --- /dev/null +++ b/ui/clickgui/elements/Element.java @@ -0,0 +1,150 @@ +package me.explicit.ui.clickgui.elements; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.settings.Setting; +import me.explicit.ui.clickgui.ClickGUI; +import me.explicit.ui.clickgui.util.FontUtil; +import net.minecraft.client.gui.Gui; + +public class Element { + + public ClickGUI clickgui; + public ModuleButton parent; + public Setting set; + public double offset; + public double x; + public double y; + public double width; + public double height; + private boolean isEnd; + public String setstrg; + public boolean comboextended; + private static final String[] llIllIIl; + private static String[] llIllIll; + + public void setup() { + this.clickgui = this.parent.parent.clickgui; + } + + public void update() { + this.x = this.parent.x - 2.0D; + this.y = this.parent.y + this.offset + this.parent.height + 1.0D; + this.width = this.parent.width + 4.0D; + this.height = 15.0D; + String s = this.set.getName(); + + if (this.set.isCheck()) { + this.setstrg = String.valueOf((new StringBuilder()).append(s.substring(0, 1).toUpperCase()).append(s.substring(1, s.length()))); + double d0 = this.x + this.width - (double) FontUtil.getStringWidth(this.setstrg); + + if (d0 < this.x + 13.0D) { + this.width += this.x + 13.0D - d0 + 1.0D; + } + } else if (this.set.isCombo()) { + this.height = this.comboextended ? (double) (this.set.getOptions().size() * (FontUtil.getFontHeight() + 2) + 15) : 15.0D; + this.setstrg = String.valueOf((new StringBuilder()).append(s.substring(0, 1).toUpperCase()).append(s.substring(1, s.length()))); + float f = FontUtil.getStringWidth(this.setstrg); + Iterator iterator = this.set.getOptions().iterator(); + + while (iterator.hasNext()) { + String s1 = (String) iterator.next(); + float f1 = FontUtil.getStringWidth(s1); + + if (f1 > f) { + f = f1; + } + } + + double d1 = this.x + this.width - (double) f; + + if (d1 < this.x) { + this.width += this.x - d1 + 1.0D; + } + } else if (this.set.isSlider()) { + this.setstrg = String.valueOf((new StringBuilder()).append(s.substring(0, 1).toUpperCase()).append(s.substring(1, s.length()))); + String s2 = String.valueOf((new StringBuilder()).append(Element.llIllIIl[0]).append((double) Math.round(this.set.getValDouble() * 100.0D) / 100.0D)); + String s3 = String.valueOf((new StringBuilder()).append(Element.llIllIIl[1]).append((double) Math.round(this.set.getMax() * 100.0D) / 100.0D)); + double d2 = this.x + this.width - (double) FontUtil.getStringWidth(this.setstrg) - (double) FontUtil.getStringWidth(s3) - 4.0D; + + if (d2 < this.x - 13.0D) { + this.width += this.x - d2 + 13.0D; + } + } + + if (this.isEnd) { + Gui.drawRect((int) this.x, (int) this.y + 14, (int) this.x + (int) this.width, (int) this.y + 16, (new Color(0, 0, 0, 175)).getRGB()); + } + + } + + public void setEndEl(boolean flag) { + this.isEnd = flag; + } + + public void drawScreen(int i, int j, float f) {} + + public boolean mouseClicked(int i, int j, int k) { + return this.isHovered(i, j); + } + + public void mouseReleased(int i, int j, int k) {} + + public boolean isHovered(int i, int j) { + return (double) i >= this.x && (double) i <= this.x + this.width && (double) j >= this.y && (double) j <= this.y + this.height; + } + + static { + llIIlIlIII(); + llIIlIIlll(); + } + + private static void llIIlIIlll() { + llIllIIl = new String[2]; + Element.llIllIIl[0] = llIIlIIlII(Element.llIllIll[0], Element.llIllIll[1]); + Element.llIllIIl[1] = llIIlIIllI(Element.llIllIll[2], Element.llIllIll[3]); + Element.llIllIll = null; + } + + private static void llIIlIlIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + Element.llIllIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIlIIlII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIlIIllI(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/ui/clickgui/elements/ModuleButton.java b/ui/clickgui/elements/ModuleButton.java new file mode 100644 index 0000000..7958d06 --- /dev/null +++ b/ui/clickgui/elements/ModuleButton.java @@ -0,0 +1,215 @@ +package me.explicit.ui.clickgui.elements; + +import java.awt.Color; +import java.io.IOException; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Module; +import me.explicit.module.render.ClickGUI; +import me.explicit.settings.Setting; +import me.explicit.ui.clickgui.Panel; +import me.explicit.ui.clickgui.elements.menu.ElementCheckBox; +import me.explicit.ui.clickgui.elements.menu.ElementComboBox; +import me.explicit.ui.clickgui.elements.menu.ElementSlider; +import me.explicit.ui.clickgui.util.ColorUtil; +import me.explicit.ui.clickgui.util.FontUtil; +import me.explicit.utils.ChatUtils; +import me.explicit.utils.TimerUtils; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.Gui; +import org.lwjgl.input.Keyboard; + +public class ModuleButton { + + public Module mod; + public ArrayList menuelements; + public Panel parent; + public double x; + public double y; + public double width; + public double height; + public boolean extended = false; + public boolean listening = false; + private TimerUtils timer; + private static final String[] lIllllII; + private static String[] lIlllllI; + + public ModuleButton(Module module, Panel panel) { + this.mod = module; + this.height = (double) (Minecraft.getMinecraft().fontRendererObj.FONT_HEIGHT + 6); + this.parent = panel; + (this.menuelements = new ArrayList()).clear(); + if (Explicit.instance.sm.getSettingsByMod(module) != null) { + Iterator iterator = Explicit.instance.sm.getSettingsByMod(module).iterator(); + + while (iterator.hasNext()) { + Setting setting = (Setting) iterator.next(); + + if (setting.isCheck()) { + this.menuelements.add(new ElementCheckBox(this, setting)); + } else if (setting.isSlider()) { + this.menuelements.add(new ElementSlider(this, setting)); + } else if (setting.isCombo()) { + this.menuelements.add(new ElementComboBox(this, setting)); + } + } + } + + this.timer = new TimerUtils(); + } + + public void drawScreen(int i, int j, float f) { + Color color = ColorUtil.getClickGUIColor(); + int k = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 150)).getRGB(); + int l = ColorUtil.getClickGUIColor().getRGB(); + + if (this.mod.isToggled() || this.mod.getName().equalsIgnoreCase(ModuleButton.lIllllII[0])) { + Gui.drawRect((int) this.x - 2, (int) this.y, (int) this.x + (int) this.width + 2, (int) this.y + (int) this.height, k); + l = ColorUtil.getClickGUIColor().brighter().getRGB(); + if (ClickGUI.mode.equalsIgnoreCase(ModuleButton.lIllllII[1])) { + (new Color(240, 240, 240, 200)).getRGB(); + } else { + ColorUtil.getClickGUIColor().brighter().getRGB(); + } + } + + if (this.isHovered(i, j)) { + Gui.drawRect((int) this.x - 2, (int) this.y, (int) this.x + (int) this.width + 2, (int) this.y + (int) this.height + 1, 1427181841); + if (this.timer.hasReached(1000.0D)) { + Gui.drawRect(i - 1, j, (int) ((float) (i + 1) + FontUtil.getStringWidth(this.mod.getDescription())), (int) ((double) (j - FontUtil.getFontHeight()) - 2.5D), ColorUtil.getClickGUIColor().darker().darker().getRGB()); + FontUtil.drawString(this.mod.getDescription(), (float) (i + 1), (float) ((double) j - (double) FontUtil.getFontHeight() * 1.25D), ColorUtil.getClickGUIColor().brighter().brighter().getRGB()); + } + } else { + this.timer.reset(); + } + + } + + public void onUpdate() { + int i = ClickGUI.mode.equalsIgnoreCase(ModuleButton.lIllllII[2]) ? (new Color(240, 240, 240)).getRGB() : ColorUtil.getClickGUIColor().brighter().getRGB(); + + FontUtil.drawTotalCenteredStringWithShadow(this.mod.getName(), (float) (this.x + (double) (FontUtil.getStringWidth(this.mod.getName()) / 2.0F)), (float) (this.y + 1.0D + this.height / 2.0D), i); + if (!this.menuelements.isEmpty()) { + FontUtil.drawTotalCenteredStringWithShadow(this.extended ? ModuleButton.lIllllII[3] : ModuleButton.lIllllII[4], (float) this.x + 72.0F, (float) (this.y + 1.0D + this.height / 2.0D), i); + } + + } + + public boolean mouseClicked(int i, int j, int k) { + if (!this.isHovered(i, j)) { + return false; + } else { + if (k == 0) { + this.mod.toggle(); + } else if (k == 1) { + if (this.menuelements != null && this.menuelements.size() > 0) { + boolean flag = !this.extended; + + this.extended = flag; + } + } else if (k == 2) { + this.listening = true; + } + + return true; + } + } + + public boolean keyTyped(char c0, int i) throws IOException { + if (this.listening) { + if (i != 1) { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(ModuleButton.lIllllII[5]).append(this.mod.getName()).append(ModuleButton.lIllllII[6]).append(Keyboard.getKeyName(i)).append(ModuleButton.lIllllII[7]))); + this.mod.setKey(i); + } else { + ChatUtils.sendMessage(String.valueOf((new StringBuilder()).append(ModuleButton.lIllllII[8]).append(this.mod.getName()).append(ModuleButton.lIllllII[9]))); + this.mod.setKey(0); + } + + this.listening = false; + return true; + } else { + return false; + } + } + + public boolean isHovered(int i, int j) { + return (double) i >= this.x && (double) i <= this.x + this.width && (double) j >= this.y && (double) j <= this.y + this.height; + } + + static { + lIlIllIlll(); + lIlIllIllI(); + } + + private static void lIlIllIllI() { + lIllllII = new String[10]; + ModuleButton.lIllllII[0] = lIlIllIIIl(ModuleButton.lIlllllI[0], ModuleButton.lIlllllI[1]); + ModuleButton.lIllllII[1] = lIlIllIIll(ModuleButton.lIlllllI[2], ModuleButton.lIlllllI[3]); + ModuleButton.lIllllII[2] = lIlIllIlIl(ModuleButton.lIlllllI[4], ModuleButton.lIlllllI[5]); + ModuleButton.lIllllII[3] = lIlIllIIll(ModuleButton.lIlllllI[6], ModuleButton.lIlllllI[7]); + ModuleButton.lIllllII[4] = lIlIllIIll(ModuleButton.lIlllllI[8], ModuleButton.lIlllllI[9]); + ModuleButton.lIllllII[5] = lIlIllIIll(ModuleButton.lIlllllI[10], ModuleButton.lIlllllI[11]); + ModuleButton.lIllllII[6] = lIlIllIIIl(ModuleButton.lIlllllI[12], ModuleButton.lIlllllI[13]); + ModuleButton.lIllllII[7] = lIlIllIIll(ModuleButton.lIlllllI[14], ModuleButton.lIlllllI[15]); + ModuleButton.lIllllII[8] = lIlIllIIll(ModuleButton.lIlllllI[16], ModuleButton.lIlllllI[17]); + ModuleButton.lIllllII[9] = lIlIllIIll(ModuleButton.lIlllllI[18], ModuleButton.lIlllllI[19]); + ModuleButton.lIlllllI = null; + } + + private static void lIlIllIlll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ModuleButton.lIlllllI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlIllIlIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIlIllIIll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIllIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/ui/clickgui/elements/menu/ElementCheckBox.java b/ui/clickgui/elements/menu/ElementCheckBox.java new file mode 100644 index 0000000..2d7c8f4 --- /dev/null +++ b/ui/clickgui/elements/menu/ElementCheckBox.java @@ -0,0 +1,135 @@ +package me.explicit.ui.clickgui.elements.menu; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.settings.Setting; +import me.explicit.ui.clickgui.elements.Element; +import me.explicit.ui.clickgui.elements.ModuleButton; +import me.explicit.ui.clickgui.util.ColorUtil; +import me.explicit.ui.clickgui.util.FontUtil; +import net.minecraft.client.gui.Gui; + +public class ElementCheckBox extends Element { + + private long prevTime = System.currentTimeMillis(); + private long prevTimeHover = System.currentTimeMillis(); + private boolean wasChecked = false; + private static final String[] llllIlII; + private static String[] llllIlIl; + + public ElementCheckBox(ModuleButton modulebutton, Setting setting) { + this.parent = modulebutton; + this.set = setting; + super.setup(); + } + + public void drawScreen(int i, int j, float f) { + Color color = ColorUtil.getClickGUIColor(); + int k = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 200)).getRGB(); + int l = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 100)).darker().getRGB(); + int i1 = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 200)).darker().darker().darker().darker().getRGB(); + int j1 = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 200)).darker().darker().darker().darker().darker().darker().darker().darker().getRGB(); + int k1 = (new Color(ColorUtil.getClickGUIColor().getRed(), ColorUtil.getClickGUIColor().getGreen(), ColorUtil.getClickGUIColor().getBlue(), 100)).darker().getRGB(); + + Gui.drawRect((int) this.x, (int) this.y, (int) (this.x + this.width), (int) (this.y + this.height), k1); + FontUtil.drawString(this.setstrg, (float) (this.x + this.width - (double) FontUtil.getStringWidth(this.setstrg)), (float) (this.y + (double) (FontUtil.getFontHeight() / 2) - 0.5D), -1); + Gui.drawRect((int) this.x + 1, (int) this.y + 2, (int) this.x + 12, (int) this.y + 13, j1); + long l1 = System.currentTimeMillis() - this.prevTime; + + if (this.set.getValBoolean()) { + if (l1 > 250L) { + Gui.drawRect((int) this.x + 2, (int) this.y + 3, (int) this.x + 11, (int) this.y + 12, k); + } else { + Gui.drawRect((int) this.x + 2, (int) this.y + 3, (int) this.x + 11, (int) (this.y + 3.0D + (double) (l1 / 25L)), k); + } + } else if (l1 <= 250L) { + if (l1 > 250L) { + Gui.drawRect((int) this.x + 2, (int) this.y + 3, (int) this.x + 11, (int) this.y + 12, k); + } else { + Gui.drawRect((int) this.x + 2, (int) this.y + 3, (int) this.x + 11, (int) (this.y + 12.0D - (double) (l1 / 25L)), k); + } + } + + if (this.isCheckHovered(i, j)) { + if (!this.wasChecked) { + this.prevTimeHover = System.currentTimeMillis(); + } + + long i2 = System.currentTimeMillis() - this.prevTimeHover; + + if (i2 <= 100L && !this.set.getValBoolean()) { + Gui.drawRect((int) this.x + 2, (int) this.y + 3, (int) this.x + 11, (int) (this.y + 3.0D + (double) i2 / 10.7777778D), l); + } else if (l1 > 250L) { + Gui.drawRect((int) this.x + 2, (int) this.y + 3, (int) this.x + 11, (int) this.y + 12, l); + } + + this.wasChecked = true; + } else { + this.wasChecked = false; + } + + if (this.set.getValBoolean()) { + this.prevTimeHover = System.currentTimeMillis(); + } + + } + + public boolean mouseClicked(int i, int j, int k) { + if (k == 0 && this.isCheckHovered(i, j)) { + long l = System.currentTimeMillis() - this.prevTime; + long i1 = System.currentTimeMillis() - this.prevTimeHover; + + if (l > 250L) { + this.set.setValBoolean(!this.set.getValBoolean()); + this.prevTime = System.currentTimeMillis(); + return super.mouseClicked(i, j, k); + } + } + + return super.mouseClicked(i, j, k); + } + + public boolean isCheckHovered(int i, int j) { + boolean flag = (double) i >= this.x + 1.0D && (double) i <= this.x + 12.0D && (double) j >= this.y + 2.0D && (double) j <= this.y + 13.0D; + + if (this.set.getName().equalsIgnoreCase(ElementCheckBox.llllIlII[0])) { + ; + } + + return flag; + } + + static { + llIlllIIll(); + llIlllIIlI(); + } + + private static void llIlllIIlI() { + llllIlII = new String[1]; + ElementCheckBox.llllIlII[0] = llIlllIIIl(ElementCheckBox.llllIlIl[0], ElementCheckBox.llllIlIl[1]); + ElementCheckBox.llllIlIl = null; + } + + private static void llIlllIIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ElementCheckBox.llllIlIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIlllIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/ui/clickgui/elements/menu/ElementComboBox.java b/ui/clickgui/elements/menu/ElementComboBox.java new file mode 100644 index 0000000..bf08b78 --- /dev/null +++ b/ui/clickgui/elements/menu/ElementComboBox.java @@ -0,0 +1,130 @@ +package me.explicit.ui.clickgui.elements.menu; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.util.Base64; +import java.util.Iterator; +import me.explicit.settings.Setting; +import me.explicit.ui.clickgui.elements.Element; +import me.explicit.ui.clickgui.elements.ModuleButton; +import me.explicit.ui.clickgui.util.ColorUtil; +import me.explicit.ui.clickgui.util.FontUtil; +import net.minecraft.client.gui.Gui; + +public class ElementComboBox extends Element { + + private static final String[] lIIlIIllI; + private static String[] lIIlIIlll; + + public ElementComboBox(ModuleButton modulebutton, Setting setting) { + this.parent = modulebutton; + this.set = setting; + super.setup(); + } + + public void drawScreen(int i, int j, float f) { + Color color = ColorUtil.getClickGUIColor(); + int k = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 200)).getRGB(); + int l = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 200)).darker().getRGB(); + int i1 = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 200)).darker().darker().darker().darker().getRGB(); + int j1 = (new Color(ColorUtil.getClickGUIColor().getRed(), ColorUtil.getClickGUIColor().getGreen(), ColorUtil.getClickGUIColor().getBlue(), 100)).darker().getRGB(); + + Gui.drawRect((int) this.x, (int) this.y, (int) this.x + (int) this.width, (int) this.y + (int) this.height, j1); + FontUtil.drawTotalCenteredString(this.setstrg, (float) (this.x + this.width / 2.0D), (float) (this.y + 7.0D), -1); + int k1 = color.getRGB(); + int l1 = l; + int i2 = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 50)).getRGB(); + + Gui.drawRect((int) this.x, (int) this.y + 14, (int) this.x + (int) this.width, (int) this.y + 15, 1996488704); + if (this.comboextended) { + Gui.drawRect((int) this.x, (int) this.y + 15, (int) this.x + (int) this.width, (int) this.y + (int) this.height, -1441656302); + double d0 = this.y + 15.0D; + + for (Iterator iterator = this.set.getOptions().iterator(); iterator.hasNext(); d0 += (double) (FontUtil.getFontHeight() + 2)) { + String s = (String) iterator.next(); + String s1 = String.valueOf((new StringBuilder()).append(s.substring(0, 1).toUpperCase()).append(s.substring(1, s.length()))); + + if (s.equalsIgnoreCase(this.set.getValString())) { + Gui.drawRect((int) this.x + (int) this.width, (int) d0, (int) this.x, (int) (d0 + (double) FontUtil.getFontHeight() + 2.0D), l1); + } + + if ((double) i >= this.x && (double) i <= this.x + this.width && (double) j >= d0 && (double) j < d0 + (double) FontUtil.getFontHeight() + 2.0D) { + Gui.drawRect((int) this.x, (int) d0, (int) this.x + (int) this.width, (int) (d0 + (double) FontUtil.getFontHeight() + 2.0D), i2); + } + + FontUtil.drawCenteredString(s1, (float) (this.x + this.width / 2.0D), (float) (d0 + 1.0D), -1); + } + } + + FontUtil.drawTotalCenteredStringWithShadow(this.comboextended ? ElementComboBox.lIIlIIllI[0] : ElementComboBox.lIIlIIllI[1], (float) this.x + 74.0F, (float) this.y + 8.0F, k); + } + + public boolean mouseClicked(int i, int j, int k) { + if (k == 0 || k == 1) { + if (this.isButtonHovered(i, j)) { + this.comboextended = !this.comboextended; + return true; + } + + if (!this.comboextended) { + return false; + } + + double d0 = this.y + 15.0D; + + for (Iterator iterator = this.set.getOptions().iterator(); iterator.hasNext(); d0 += (double) (FontUtil.getFontHeight() + 2)) { + String s = (String) iterator.next(); + + if ((double) i >= this.x && (double) i <= this.x + this.width && (double) j >= d0 && (double) j <= d0 + (double) FontUtil.getFontHeight() + 2.0D) { + if (this.clickgui != null && this.clickgui.setmgr != null) { + this.clickgui.setmgr.getSettingByName(this.parent.mod, this.set.getName()).setValString(s.toLowerCase()); + } + + return true; + } + } + } + + return super.mouseClicked(i, j, k); + } + + public boolean isButtonHovered(int i, int j) { + return (double) i >= this.x && (double) i <= this.x + this.width && (double) j >= this.y && (double) j <= this.y + 15.0D; + } + + static { + lIIIIIIlIIl(); + lIIIIIIlIII(); + } + + private static void lIIIIIIlIII() { + lIIlIIllI = new String[2]; + ElementComboBox.lIIlIIllI[0] = lIIIIIIIlll(ElementComboBox.lIIlIIlll[0], ElementComboBox.lIIlIIlll[1]); + ElementComboBox.lIIlIIllI[1] = lIIIIIIIlll(ElementComboBox.lIIlIIlll[2], ElementComboBox.lIIlIIlll[3]); + ElementComboBox.lIIlIIlll = null; + } + + private static void lIIIIIIlIIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ElementComboBox.lIIlIIlll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIIIIlll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/ui/clickgui/elements/menu/ElementSlider.java b/ui/clickgui/elements/menu/ElementSlider.java new file mode 100644 index 0000000..017afea --- /dev/null +++ b/ui/clickgui/elements/menu/ElementSlider.java @@ -0,0 +1,149 @@ +package me.explicit.ui.clickgui.elements.menu; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.settings.Setting; +import me.explicit.ui.clickgui.elements.Element; +import me.explicit.ui.clickgui.elements.ModuleButton; +import me.explicit.ui.clickgui.util.ColorUtil; +import me.explicit.ui.clickgui.util.FontUtil; +import net.minecraft.client.gui.Gui; +import net.minecraft.util.MathHelper; + +public class ElementSlider extends Element { + + public boolean dragging; + private static final String[] lllIlI; + private static String[] lllIll; + + public ElementSlider(ModuleButton modulebutton, Setting setting) { + this.parent = modulebutton; + this.set = setting; + this.dragging = false; + super.setup(); + } + + public void drawScreen(int i, int j, float f) { + String s = String.valueOf((new StringBuilder()).append(ElementSlider.lllIlI[0]).append((double) Math.round(this.set.getValDouble() * 100.0D) / 100.0D)); + boolean flag = this.isSliderHovered(i, j) || this.dragging; + Color color = ColorUtil.getClickGUIColor(); + int k = (new Color(color.getRed(), color.getGreen(), color.getBlue(), flag ? 250 : 200)).getRGB(); + int l = (new Color(color.getRed(), color.getGreen(), color.getBlue(), flag ? 255 : 230)).getRGB(); + int i1 = (new Color(color.getRed(), color.getGreen(), color.getBlue(), 200)).darker().darker().darker().darker().getRGB(); + int j1 = (new Color(ColorUtil.getClickGUIColor().getRed(), ColorUtil.getClickGUIColor().getGreen(), ColorUtil.getClickGUIColor().getBlue(), 100)).darker().getRGB(); + double d0 = (this.set.getValDouble() - this.set.getMin()) / (this.set.getMax() - this.set.getMin()); + + Gui.drawRect((int) this.x, (int) this.y, (int) this.x + (int) this.width, (int) this.y + (int) this.height, j1); + Gui.drawRect((int) this.x, (int) this.y + 12, (int) this.x + (int) this.width, (int) this.y + 2, -15724528); + Gui.drawRect((int) this.x, (int) this.y + 12, (int) this.x + (int) (d0 * this.width), (int) this.y + 2, k); + FontUtil.drawString(this.setstrg, (float) (this.x + 1.0D), (float) (this.y + 3.0D), -1); + String s1 = ElementSlider.lllIlI[1]; + + if (s.endsWith(ElementSlider.lllIlI[2])) { + for (int k1 = 0; (long) k1 < s.chars().count() - 2L; ++k1) { + s1 = String.valueOf((new StringBuilder()).append(s1).append(s.charAt(k1))); + } + } else { + s1 = s; + } + + if (this.set.percentage) { + s1 = String.valueOf((new StringBuilder()).append(s1).append(ElementSlider.lllIlI[3])); + } + + FontUtil.drawString(s1, (float) (this.x + this.width - (double) FontUtil.getStringWidth(s1)), (float) (this.y + 3.0D), -1); + if (this.dragging) { + double d1 = this.set.getMax() - this.set.getMin(); + double d2 = this.set.getMin() + MathHelper.clamp_double(((double) i - this.x) / this.width, 0.0D, 1.0D) * d1; + + this.set.setValDouble(d2); + } + + } + + public boolean mouseClicked(int i, int j, int k) { + if (k == 0 && this.isSliderHovered(i, j)) { + this.dragging = true; + return true; + } else { + return super.mouseClicked(i, j, k); + } + } + + public void mouseReleased(int i, int j, int k) { + this.dragging = false; + } + + public boolean isSliderHovered(int i, int j) { + return (double) i >= this.x && (double) i <= this.x + this.width && (double) j >= this.y + 2.0D && (double) j <= this.y + 14.0D; + } + + static { + llIlIIll(); + llIlIIlI(); + } + + private static void llIlIIlI() { + lllIlI = new String[4]; + ElementSlider.lllIlI[0] = llIIllll(ElementSlider.lllIll[0], ElementSlider.lllIll[1]); + ElementSlider.lllIlI[1] = llIlIIII(ElementSlider.lllIll[2], ElementSlider.lllIll[3]); + ElementSlider.lllIlI[2] = llIlIIIl(ElementSlider.lllIll[4], ElementSlider.lllIll[5]); + ElementSlider.lllIlI[3] = llIIllll(ElementSlider.lllIll[6], ElementSlider.lllIll[7]); + ElementSlider.lllIll = null; + } + + private static void llIlIIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ElementSlider.lllIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIlIIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIlIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIllll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/ui/clickgui/util/ColorUtil.java b/ui/clickgui/util/ColorUtil.java new file mode 100644 index 0000000..26fbb45 --- /dev/null +++ b/ui/clickgui/util/ColorUtil.java @@ -0,0 +1,87 @@ +package me.explicit.ui.clickgui.util; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.render.ClickGUI; + +public class ColorUtil { + + private static final String[] lIlIIlll; + private static String[] lIlIlIIl; + + public static Color getClickGUIColor() { + return ClickGUI.mode.equalsIgnoreCase(ColorUtil.lIlIIlll[0]) ? new Color(Explicit.instance.cm.cc.getColor(0).getRed(), Explicit.instance.cm.cc.getColor(0).getGreen(), Explicit.instance.cm.cc.getColor(0).getBlue(), 255) : (ClickGUI.mode.equalsIgnoreCase(ColorUtil.lIlIIlll[1]) ? Color.getHSBColor(0.62F, 1.0F, 1.0F) : (ClickGUI.mode.equalsIgnoreCase(ColorUtil.lIlIIlll[2]) ? new Color(0, 255, 0) : (ClickGUI.mode.equalsIgnoreCase(ColorUtil.lIlIIlll[3]) ? new Color(255, 0, 0) : (ClickGUI.mode.equalsIgnoreCase(ColorUtil.lIlIIlll[4]) ? new Color(128, 0, 128) : (ClickGUI.mode.equalsIgnoreCase(ColorUtil.lIlIIlll[5]) ? new Color(20, 20, 20, 255) : new Color(1, 1, 1, 255)))))); + } + + static { + lIIlIlIlIl(); + lIIlIlIlII(); + } + + private static void lIIlIlIlII() { + lIlIIlll = new String[6]; + ColorUtil.lIlIIlll[0] = lIIlIIlllI(ColorUtil.lIlIlIIl[0], ColorUtil.lIlIlIIl[1]); + ColorUtil.lIlIIlll[1] = lIIlIlIIII(ColorUtil.lIlIlIIl[2], ColorUtil.lIlIlIIl[3]); + ColorUtil.lIlIIlll[2] = lIIlIIlllI(ColorUtil.lIlIlIIl[4], ColorUtil.lIlIlIIl[5]); + ColorUtil.lIlIIlll[3] = lIIlIIlllI(ColorUtil.lIlIlIIl[6], ColorUtil.lIlIlIIl[7]); + ColorUtil.lIlIIlll[4] = lIIlIlIIII(ColorUtil.lIlIlIIl[8], ColorUtil.lIlIlIIl[9]); + ColorUtil.lIlIIlll[5] = lIIlIlIIll(ColorUtil.lIlIlIIl[10], ColorUtil.lIlIlIIl[11]); + ColorUtil.lIlIlIIl = null; + } + + private static void lIIlIlIlIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ColorUtil.lIlIlIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIlIlIIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIlIlIIll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIlIIlllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/ui/clickgui/util/FontUtil.java b/ui/clickgui/util/FontUtil.java new file mode 100644 index 0000000..bdb62bd --- /dev/null +++ b/ui/clickgui/util/FontUtil.java @@ -0,0 +1,46 @@ +package me.explicit.ui.clickgui.util; + +import me.explicit.utils.Game; +import net.minecraft.client.Minecraft; +import net.minecraft.util.StringUtils; + +public class FontUtil { + + public static void setupFontUtils() {} + + public static float getStringWidth(String s) { + return (float) Game.Minecraft().fontRendererObj.getStringWidth(StringUtils.stripControlCodes(s)); + } + + public static int getFontHeight() { + return Minecraft.getMinecraft().fontRendererObj.FONT_HEIGHT; + } + + public static void drawString(String s, float f, float f1, int i) { + Game.Minecraft().fontRendererObj.drawStringWithShadow(s, f, f1, i); + } + + public static void drawStringWithShadow(String s, float f, float f1, int i) { + Game.Minecraft().fontRendererObj.drawStringWithShadow(s, f, f1, i); + } + + public static void drawCenteredString(String s, float f, float f1, int i) { + Game.Minecraft().fontRendererObj.drawStringWithShadow(s, f - getStringWidth(s) / 2.0F, f1, i); + } + + public static void drawCenteredStringWithShadow(String s, float f, float f1, int i) { + drawStringWithShadow(s, f - getStringWidth(s) / 2.0F, f1, i); + } + + public static void drawTotalCenteredString(String s, float f, float f1, int i) { + Game.Minecraft().fontRendererObj.drawString(s, (int) (f - getStringWidth(s) / 2.0F), (int) (f1 - (float) (getFontHeight() / 2)), i); + } + + public static void drawTotalCenteredStringWithShadow(String s, float f, float f1, int i) { + drawStringWithShadow(s, f - getStringWidth(s) / 2.0F, f1 - (float) getFontHeight() / 2.0F, i); + } + + public static void drawBigTotalCenteredStringWithShadow(String s, float f, float f1, int i) { + Game.Minecraft().fontRendererObj.drawStringWithShadow(s, f - getStringWidth(s) / 2.0F, f1 - (float) Game.Minecraft().fontRendererObj.FONT_HEIGHT / 2.0F, i); + } +} diff --git a/ui/hud/HUDRenderer.java b/ui/hud/HUDRenderer.java new file mode 100644 index 0000000..8addbf5 --- /dev/null +++ b/ui/hud/HUDRenderer.java @@ -0,0 +1,204 @@ +package me.explicit.ui.hud; + +import java.awt.Color; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Collections; +import java.util.Comparator; +import java.util.Iterator; +import java.util.List; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; +import me.explicit.settings.SettingsManager; +import me.explicit.ui.clickgui.ClickGUI; +import me.explicit.utils.Game; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.Gui; +import net.minecraft.client.gui.ScaledResolution; + +public class HUDRenderer extends Gui { + + protected Minecraft mc = Game.Minecraft(); + private static final String[] lIllIlIl; + private static String[] lIllIllI; + + public void draw() { + if (Explicit.instance.mm.getModuleByName(HUDRenderer.lIllIlIl[0]).isToggled()) { + this.renderModules(); + } + } + + public void renderModules() { + if (!(this.mc.currentScreen instanceof ClickGUI) && Game.World() != null && Game.Player() != null) { + ScaledResolution scaledresolution = new ScaledResolution(this.mc); + List list = this.getOrder(); + int i = 1; + + for (int j = 0; j < this.getOrder().size(); ++j) { + String s = (String) this.getOrder().get(j); + + if (!s.equalsIgnoreCase(HUDRenderer.lIllIlIl[1]) && !((Module) this.getOrderModule().get(j)).getCategory().equals(Category.VALUES)) { + int k = 10 * i - this.mc.fontRendererObj.FONT_HEIGHT + 2; + + this.renderText(s, scaledresolution.getScaledWidth() - this.mc.fontRendererObj.getStringWidth(s) - 2, k, 0); + ++i; + } + } + + String s1 = String.valueOf((new StringBuilder()).append(HUDRenderer.lIllIlIl[2]).append(HUDRenderer.lIllIlIl[3].toLowerCase())); + + this.renderText(String.valueOf((new StringBuilder()).append(HUDRenderer.lIllIlIl[4]).append(HUDRenderer.lIllIlIl[5].toLowerCase())), 5, 5, 0); + } + } + + private void renderText(String s, int i, int j, int k) { + String s1 = HUDRenderer.lIllIlIl[6]; + + for (int l = 0; l < s.toCharArray().length; ++l) { + char c0 = s.toCharArray()[l]; + float f = (float) (i + this.mc.fontRendererObj.getStringWidth(s1)); + + this.mc.fontRendererObj.drawStringWithShadow(String.valueOf((new StringBuilder()).append(c0).append(HUDRenderer.lIllIlIl[7])), f, (float) j, this.getColor((int) (-f) + j + k).getRGB()); + s1 = String.valueOf((new StringBuilder()).append(s1).append(c0)); + } + + } + + public Color getColor(int i) { + Module module = Explicit.instance.mm.getModuleByName(HUDRenderer.lIllIlIl[8]); + SettingsManager settingsmanager = Explicit.instance.sm; + + if (settingsmanager.getSettingByName(module, HUDRenderer.lIllIlIl[9]).getValBoolean()) { + return Explicit.instance.cm.cc.getColor(i); + } else { + int j = (int) settingsmanager.getSettingByName(module, HUDRenderer.lIllIlIl[10]).getValDouble(); + int k = (int) settingsmanager.getSettingByName(module, HUDRenderer.lIllIlIl[11]).getValDouble(); + int l = (int) settingsmanager.getSettingByName(module, HUDRenderer.lIllIlIl[12]).getValDouble(); + + return new Color(j, k, l, 255); + } + } + + private List getOrder() { + List list = Explicit.instance.mm.getEnabledModules(); + ArrayList arraylist = null; + Comparator comparator = new Comparator() { + final HUDRenderer this$0 = HUDRenderer.this; + + public int compare(String s, String s1) { + return Float.compare((float) this.this$0.mc.fontRendererObj.getStringWidth(s1), (float) this.this$0.mc.fontRendererObj.getStringWidth(s)); + } + + public int compare(Object object, Object object1) { + return this.compare((String) object, (String) object1); + } + }; + + if (arraylist == null) { + (arraylist = new ArrayList()).clear(); + } + + for (int i = 0; i < list.size(); ++i) { + arraylist.add(((Module) list.get(i)).getDisplayName()); + } + + Collections.sort(arraylist, comparator); + return arraylist; + } + + private List getOrderModule() { + ArrayList arraylist; + + (arraylist = new ArrayList()).clear(); + Iterator iterator = this.getOrder().iterator(); + + while (iterator.hasNext()) { + String s = (String) iterator.next(); + + if (Explicit.instance.mm.getModuleByName(s) != null) { + arraylist.add(Explicit.instance.mm.getModuleByName(s)); + } + } + + return arraylist; + } + + static { + lIlIIllIII(); + lIlIIlIlll(); + } + + private static void lIlIIlIlll() { + lIllIlIl = new String[13]; + HUDRenderer.lIllIlIl[0] = lIlIIlIlII(HUDRenderer.lIllIllI[0], HUDRenderer.lIllIllI[1]); + HUDRenderer.lIllIlIl[1] = lIlIIlIlII(HUDRenderer.lIllIllI[2], HUDRenderer.lIllIllI[3]); + HUDRenderer.lIllIlIl[2] = lIlIIlIlII(HUDRenderer.lIllIllI[4], HUDRenderer.lIllIllI[5]); + HUDRenderer.lIllIlIl[3] = lIlIIlIlIl(HUDRenderer.lIllIllI[6], HUDRenderer.lIllIllI[7]); + HUDRenderer.lIllIlIl[4] = lIlIIlIlIl(HUDRenderer.lIllIllI[8], HUDRenderer.lIllIllI[9]); + HUDRenderer.lIllIlIl[5] = lIlIIlIlII(HUDRenderer.lIllIllI[10], HUDRenderer.lIllIllI[11]); + HUDRenderer.lIllIlIl[6] = lIlIIlIlII(HUDRenderer.lIllIllI[12], HUDRenderer.lIllIllI[13]); + HUDRenderer.lIllIlIl[7] = lIlIIlIllI(HUDRenderer.lIllIllI[14], HUDRenderer.lIllIllI[15]); + HUDRenderer.lIllIlIl[8] = lIlIIlIlII(HUDRenderer.lIllIllI[16], HUDRenderer.lIllIllI[17]); + HUDRenderer.lIllIlIl[9] = lIlIIlIllI(HUDRenderer.lIllIllI[18], HUDRenderer.lIllIllI[19]); + HUDRenderer.lIllIlIl[10] = lIlIIlIlIl(HUDRenderer.lIllIllI[20], HUDRenderer.lIllIllI[21]); + HUDRenderer.lIllIlIl[11] = lIlIIlIlIl(HUDRenderer.lIllIllI[22], HUDRenderer.lIllIllI[23]); + HUDRenderer.lIllIlIl[12] = lIlIIlIlIl(HUDRenderer.lIllIllI[24], HUDRenderer.lIllIllI[25]); + HUDRenderer.lIllIllI = null; + } + + private static void lIlIIllIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + HUDRenderer.lIllIllI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlIIlIlII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIlIIlIlIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIIlIllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/utils/ChatUtils.java b/utils/ChatUtils.java new file mode 100644 index 0000000..79d25da --- /dev/null +++ b/utils/ChatUtils.java @@ -0,0 +1,84 @@ +package me.explicit.utils; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.util.ChatComponentText; +import net.minecraft.util.EnumChatFormatting; + +public class ChatUtils { + + private static final String[] llllllI; + private static String[] lllllll; + + public static void sendMessage(String s) { + if (s != null) { + EntityPlayerSP entityplayersp = Game.Player(); + String s1 = ChatUtils.llllllI[0]; + Object[] aobject = new Object[2]; + boolean flag = false; + StringBuilder stringbuilder = (new StringBuilder()).append(EnumChatFormatting.DARK_AQUA); + + aobject[0] = String.valueOf(stringbuilder.append(ChatUtils.llllllI[1]).append(EnumChatFormatting.GRAY).append(ChatUtils.llllllI[2])); + aobject[1] = s; + entityplayersp.addChatMessage(new ChatComponentText(String.valueOf((new StringBuilder()).append(EnumChatFormatting.DARK_GREEN).append(ChatUtils.llllllI[3]).append(EnumChatFormatting.AQUA).append(ChatUtils.llllllI[4]).append(EnumChatFormatting.DARK_GREEN).append(ChatUtils.llllllI[5]).append(EnumChatFormatting.GRAY).append(s)))); + } + } + + static { + llIlIIIll(); + llIlIIIlI(); + } + + private static void llIlIIIlI() { + llllllI = new String[6]; + ChatUtils.llllllI[0] = llIlIIIII(ChatUtils.lllllll[0], ChatUtils.lllllll[1]); + ChatUtils.llllllI[1] = llIlIIIII(ChatUtils.lllllll[2], ChatUtils.lllllll[3]); + ChatUtils.llllllI[2] = llIlIIIII(ChatUtils.lllllll[4], ChatUtils.lllllll[5]); + ChatUtils.llllllI[3] = llIlIIIIl(ChatUtils.lllllll[6], ChatUtils.lllllll[7]); + ChatUtils.llllllI[4] = llIlIIIIl(ChatUtils.lllllll[8], ChatUtils.lllllll[9]); + ChatUtils.llllllI[5] = llIlIIIIl(ChatUtils.lllllll[10], ChatUtils.lllllll[11]); + ChatUtils.lllllll = null; + } + + private static void llIlIIIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ChatUtils.lllllll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIlIIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIlIIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/utils/CombatUtils.java b/utils/CombatUtils.java new file mode 100644 index 0000000..d2b8e2e --- /dev/null +++ b/utils/CombatUtils.java @@ -0,0 +1,165 @@ +package me.explicit.utils; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.combat.AntiBot; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityArmorStand; +import net.minecraft.entity.monster.EntityMob; +import net.minecraft.entity.passive.EntityAnimal; +import net.minecraft.entity.player.EntityPlayer; + +public class CombatUtils { + + private static final String[] lIIllIIll; + private static String[] lIIllllII; + + public static boolean canTarget(Entity entity, boolean flag) { + if (entity != null && entity != Game.Player()) { + EntityPlayer entityplayer = null; + EntityLivingBase entitylivingbase = null; + + if (entity instanceof EntityPlayer) { + entityplayer = (EntityPlayer) entity; + } + + if (entity instanceof EntityLivingBase) { + entitylivingbase = (EntityLivingBase) entity; + } + + boolean flag1 = Explicit.instance.mm.getModuleByName(CombatUtils.lIIllIIll[0]).isToggled(); + boolean flag2 = Explicit.instance.mm.getModuleByName(CombatUtils.lIIllIIll[1]).isToggled(); + boolean flag3 = Explicit.instance.mm.getModuleByName(CombatUtils.lIIllIIll[2]).isToggled(); + boolean flag4 = Explicit.instance.mm.getModuleByName(CombatUtils.lIIllIIll[3]).isToggled(); + boolean flag5 = Explicit.instance.mm.getModuleByName(CombatUtils.lIIllIIll[4]).isToggled(); + boolean flag6 = Explicit.instance.mm.getModuleByName(CombatUtils.lIIllIIll[5]).isToggled(); + boolean flag7 = Explicit.instance.mm.getModuleByName(CombatUtils.lIIllIIll[6]).isToggled() && flag; + boolean flag8 = false; + + if (flag7 && isTeam(Game.Player(), entity)) { + flag8 = true; + } + + boolean flag9 = true; + + if (entity.isInvisible() && !flag4) { + flag9 = false; + } + + boolean flag10 = false; + + if (Explicit.instance.mm.getModuleByName(CombatUtils.lIIllIIll[7]).isToggled() && Explicit.instance.friendManager.getFriends().contains(entity.getName())) { + flag10 = true; + } + + return !AntiBot.getBots().contains(entity) && !(entity instanceof EntityArmorStand) && !flag10 && flag9 && (entity instanceof EntityPlayer && flag1 && !flag8 && (!flag || !isNaked(entitylivingbase) || !flag6) || entity instanceof EntityAnimal && flag2 || entity instanceof EntityMob && flag3 || entity instanceof EntityLivingBase && flag5 && !(entity instanceof EntityMob) && !(entity instanceof EntityAnimal) && !(entity instanceof EntityPlayer) && entity instanceof EntityLivingBase && entitylivingbase.isEntityAlive()); + } else { + return false; + } + } + + public static boolean isTeam(EntityPlayer entityplayer, Entity entity) { + if (entity instanceof EntityPlayer && ((EntityPlayer) entity).getTeam() != null && entityplayer.getTeam() != null) { + Character character = Character.valueOf(entity.getDisplayName().getFormattedText().charAt(3)); + Character character1 = Character.valueOf(entityplayer.getDisplayName().getFormattedText().charAt(3)); + Character character2 = Character.valueOf(entity.getDisplayName().getFormattedText().charAt(2)); + Character character3 = Character.valueOf(entityplayer.getDisplayName().getFormattedText().charAt(2)); + boolean flag = false; + + if (character.equals(character1) && character2.equals(character3)) { + flag = true; + } else { + Character character4 = Character.valueOf(entity.getDisplayName().getFormattedText().charAt(1)); + Character character5 = Character.valueOf(entityplayer.getDisplayName().getFormattedText().charAt(1)); + Character character6 = Character.valueOf(entity.getDisplayName().getFormattedText().charAt(0)); + Character character7 = Character.valueOf(entityplayer.getDisplayName().getFormattedText().charAt(0)); + + if (character4.equals(character5) && Character.isDigit(0) && character6.equals(character7)) { + flag = true; + } + } + + return flag; + } else { + return true; + } + } + + private static boolean isNaked(EntityLivingBase entitylivingbase) { + return entitylivingbase.getTotalArmorValue() == 0; + } + + static { + lIIIlIIllIl(); + lIIIlIIlIll(); + } + + private static void lIIIlIIlIll() { + lIIllIIll = new String[8]; + CombatUtils.lIIllIIll[0] = lIIIlIIIlll(CombatUtils.lIIllllII[0], CombatUtils.lIIllllII[1]); + CombatUtils.lIIllIIll[1] = lIIIlIIlIII(CombatUtils.lIIllllII[2], CombatUtils.lIIllllII[3]); + CombatUtils.lIIllIIll[2] = lIIIlIIlIIl(CombatUtils.lIIllllII[4], CombatUtils.lIIllllII[5]); + CombatUtils.lIIllIIll[3] = lIIIlIIlIIl(CombatUtils.lIIllllII[6], CombatUtils.lIIllllII[7]); + CombatUtils.lIIllIIll[4] = lIIIlIIlIII(CombatUtils.lIIllllII[8], CombatUtils.lIIllllII[9]); + CombatUtils.lIIllIIll[5] = lIIIlIIlIII(CombatUtils.lIIllllII[10], CombatUtils.lIIllllII[11]); + CombatUtils.lIIllIIll[6] = lIIIlIIIlll(CombatUtils.lIIllllII[12], CombatUtils.lIIllllII[13]); + CombatUtils.lIIllIIll[7] = lIIIlIIlIII(CombatUtils.lIIllllII[14], CombatUtils.lIIllllII[15]); + CombatUtils.lIIllllII = null; + } + + private static void lIIIlIIllIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + CombatUtils.lIIllllII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIlIIIlll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIIIlIIlIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIIIlIIlIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/utils/Game.java b/utils/Game.java new file mode 100644 index 0000000..620cea7 --- /dev/null +++ b/utils/Game.java @@ -0,0 +1,20 @@ +package me.explicit.utils; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.entity.EntityPlayerSP; +import net.minecraft.client.multiplayer.WorldClient; + +public class Game { + + public static EntityPlayerSP Player() { + return Minecraft().thePlayer; + } + + public static WorldClient World() { + return Minecraft().theWorld; + } + + public static Minecraft Minecraft() { + return Minecraft.getMinecraft(); + } +} diff --git a/utils/ItemUtils.java b/utils/ItemUtils.java new file mode 100644 index 0000000..527261c --- /dev/null +++ b/utils/ItemUtils.java @@ -0,0 +1,281 @@ +package me.explicit.utils; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import net.minecraft.client.Minecraft; +import net.minecraft.enchantment.Enchantment; +import net.minecraft.enchantment.EnchantmentHelper; +import net.minecraft.item.Item; +import net.minecraft.item.ItemArmor; +import net.minecraft.item.ItemBow; +import net.minecraft.item.ItemEgg; +import net.minecraft.item.ItemEnderPearl; +import net.minecraft.item.ItemGlassBottle; +import net.minecraft.item.ItemPotion; +import net.minecraft.item.ItemSnowball; +import net.minecraft.item.ItemStack; +import net.minecraft.item.ItemSword; +import net.minecraft.potion.Potion; +import net.minecraft.potion.PotionEffect; +import net.minecraft.util.DamageSource; + +public class ItemUtils { + + private static final Minecraft mc; + private static final String[] lIllIIlI; + private static String[] lIllIIll; + + public static ItemStack bestSword() { + ItemStack itemstack = null; + float f = 0.0F; + + for (int i = 9; i < 45; ++i) { + if (ItemUtils.mc.thePlayer.inventoryContainer.getSlot(i).getHasStack()) { + ItemStack itemstack1 = ItemUtils.mc.thePlayer.inventoryContainer.getSlot(i).getStack(); + + if (itemstack1.getItem() instanceof ItemSword) { + float f1 = getItemDamage(itemstack1); + + if (f1 > f) { + f = f1; + itemstack = itemstack1; + } + } + } + } + + return itemstack; + } + + public static boolean isThrowable(ItemStack itemstack) { + Item item = itemstack.getItem(); + + return item instanceof ItemBow || item instanceof ItemSnowball || item instanceof ItemEgg || item instanceof ItemEnderPearl || item instanceof ItemPotion && ItemPotion.isSplash(itemstack.getItemDamage()); + } + + public static ItemStack compareDamage(ItemStack itemstack, ItemStack itemstack1) { + try { + return itemstack != null && itemstack1 != null ? (!(itemstack.getItem() instanceof ItemSword) && itemstack1.getItem() instanceof ItemSword ? null : (getItemDamage(itemstack) > getItemDamage(itemstack1) ? itemstack : (getItemDamage(itemstack1) > getItemDamage(itemstack) ? itemstack1 : itemstack))) : null; + } catch (NullPointerException nullpointerexception) { + nullpointerexception.printStackTrace(); + return itemstack; + } + } + + public static boolean isBad(ItemStack itemstack) { + return itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[0]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[1]) || itemstack.getItem().getUnlocalizedName().equalsIgnoreCase(ItemUtils.lIllIIlI[2]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[3]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[4]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[5]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[6]) || itemstack.getItem().getUnlocalizedName().equalsIgnoreCase(ItemUtils.lIllIIlI[7]) && !itemstack.getDisplayName().toLowerCase().contains(ItemUtils.lIllIIlI[8]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[9]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[10]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[11]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[12]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[13]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[14]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[15]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[16]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[17]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[18]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[19]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[20]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[21]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[22]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[23]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[24]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[25]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[26]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[27]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[28]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[29]) || itemstack.getItem() instanceof ItemGlassBottle || itemstack.getItem() instanceof ItemArmor && !getBest().contains(itemstack) || itemstack.getItem() instanceof ItemSword && itemstack != bestSword() || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[30]) || itemstack.getItem().getUnlocalizedName().contains(ItemUtils.lIllIIlI[31]) && isBadPotion(itemstack); + } + + public static List getBest() { + ArrayList arraylist = new ArrayList(); + + for (int i = 0; i < 4; ++i) { + ItemStack itemstack = null; + ItemStack[] aitemstack = ItemUtils.mc.thePlayer.inventory.armorInventory; + int j = ItemUtils.mc.thePlayer.inventory.armorInventory.length; + + ItemStack itemstack1; + + for (int k = 0; k < j; ++k) { + itemstack1 = aitemstack[k]; + if (itemstack1 != null && itemstack1.getItem() instanceof ItemArmor) { + ItemArmor itemarmor = (ItemArmor) itemstack1.getItem(); + + if (itemarmor.armorType == i) { + itemstack = itemstack1; + } + } + } + + double d0 = itemstack == null ? -1.0D : getArmorStrength(itemstack); + + itemstack1 = findBestArmor(i); + if (itemstack1 != null && getArmorStrength(itemstack1) <= d0) { + itemstack1 = itemstack; + } + + if (itemstack1 != null) { + arraylist.add(itemstack1); + } + } + + return arraylist; + } + + public static ItemStack findBestArmor(int i) { + ItemStack itemstack = null; + double d0 = 0.0D; + + for (int j = 0; j < 36; ++j) { + ItemStack itemstack1 = ItemUtils.mc.thePlayer.inventory.mainInventory[j]; + + if (itemstack1 != null) { + double d1 = getArmorStrength(itemstack1); + + if (d1 != -1.0D) { + ItemArmor itemarmor = (ItemArmor) itemstack1.getItem(); + + if (itemarmor.armorType == i && d1 >= d0) { + d0 = d1; + itemstack = itemstack1; + } + } + } + } + + return itemstack; + } + + public static double getArmorStrength(ItemStack itemstack) { + if (!(itemstack.getItem() instanceof ItemArmor)) { + return -1.0D; + } else { + float f = (float) ((ItemArmor) itemstack.getItem()).damageReduceAmount; + Map map = EnchantmentHelper.getEnchantments(itemstack); + + if (map.containsKey(Integer.valueOf(Enchantment.protection.effectId))) { + int i = ((Integer) map.get(Integer.valueOf(Enchantment.protection.effectId))).intValue(); + + f += (float) Enchantment.protection.calcModifierDamage(i, DamageSource.generic); + } + + return (double) f; + } + } + + public static boolean isBadPotion(ItemStack itemstack) { + if (itemstack != null && itemstack.getItem() instanceof ItemPotion) { + ItemPotion itempotion = (ItemPotion) itemstack.getItem(); + + if (ItemPotion.isSplash(itemstack.getItemDamage())) { + Iterator iterator = itempotion.getEffects(itemstack).iterator(); + + while (iterator.hasNext()) { + Object object = iterator.next(); + PotionEffect potioneffect = (PotionEffect) object; + + if (potioneffect.getPotionID() == Potion.poison.getId() || potioneffect.getPotionID() == Potion.harm.getId() || potioneffect.getPotionID() == Potion.moveSlowdown.getId() || potioneffect.getPotionID() == Potion.weakness.getId()) { + return true; + } + } + } + } + + return false; + } + + public static float getItemDamage(ItemStack itemstack) { + if (itemstack == null) { + return 0.0F; + } else if (!(itemstack.getItem() instanceof ItemSword)) { + return 0.0F; + } else { + float f = ((ItemSword) itemstack.getItem()).getDamageVsEntity(); + + f += (float) EnchantmentHelper.getEnchantmentLevel(Enchantment.sharpness.effectId, itemstack) * 1.25F; + f += (float) EnchantmentHelper.getEnchantmentLevel(Enchantment.fireAspect.effectId, itemstack) * 0.01F; + return f; + } + } + + static { + lIlIIIIIll(); + lIlIIIIIlI(); + mc = Minecraft.getMinecraft(); + } + + private static void lIlIIIIIlI() { + lIllIIlI = new String[32]; + ItemUtils.lIllIIlI[0] = lIIlllllll(ItemUtils.lIllIIll[0], ItemUtils.lIllIIll[1]); + ItemUtils.lIllIIlI[1] = lIlIIIIIII(ItemUtils.lIllIIll[2], ItemUtils.lIllIIll[3]); + ItemUtils.lIllIIlI[2] = lIlIIIIIII(ItemUtils.lIllIIll[4], ItemUtils.lIllIIll[5]); + ItemUtils.lIllIIlI[3] = lIlIIIIIIl(ItemUtils.lIllIIll[6], ItemUtils.lIllIIll[7]); + ItemUtils.lIllIIlI[4] = lIIlllllll(ItemUtils.lIllIIll[8], ItemUtils.lIllIIll[9]); + ItemUtils.lIllIIlI[5] = lIlIIIIIII(ItemUtils.lIllIIll[10], ItemUtils.lIllIIll[11]); + ItemUtils.lIllIIlI[6] = lIIlllllll(ItemUtils.lIllIIll[12], ItemUtils.lIllIIll[13]); + ItemUtils.lIllIIlI[7] = lIlIIIIIIl(ItemUtils.lIllIIll[14], ItemUtils.lIllIIll[15]); + ItemUtils.lIllIIlI[8] = lIIlllllll(ItemUtils.lIllIIll[16], ItemUtils.lIllIIll[17]); + ItemUtils.lIllIIlI[9] = lIlIIIIIII(ItemUtils.lIllIIll[18], ItemUtils.lIllIIll[19]); + ItemUtils.lIllIIlI[10] = lIlIIIIIIl(ItemUtils.lIllIIll[20], ItemUtils.lIllIIll[21]); + ItemUtils.lIllIIlI[11] = lIlIIIIIIl(ItemUtils.lIllIIll[22], ItemUtils.lIllIIll[23]); + ItemUtils.lIllIIlI[12] = lIlIIIIIIl(ItemUtils.lIllIIll[24], ItemUtils.lIllIIll[25]); + ItemUtils.lIllIIlI[13] = lIlIIIIIII(ItemUtils.lIllIIll[26], ItemUtils.lIllIIll[27]); + ItemUtils.lIllIIlI[14] = lIlIIIIIIl(ItemUtils.lIllIIll[28], ItemUtils.lIllIIll[29]); + ItemUtils.lIllIIlI[15] = lIIlllllll(ItemUtils.lIllIIll[30], ItemUtils.lIllIIll[31]); + ItemUtils.lIllIIlI[16] = lIlIIIIIII(ItemUtils.lIllIIll[32], ItemUtils.lIllIIll[33]); + ItemUtils.lIllIIlI[17] = lIlIIIIIII(ItemUtils.lIllIIll[34], ItemUtils.lIllIIll[35]); + ItemUtils.lIllIIlI[18] = lIlIIIIIII(ItemUtils.lIllIIll[36], ItemUtils.lIllIIll[37]); + ItemUtils.lIllIIlI[19] = lIIlllllll(ItemUtils.lIllIIll[38], ItemUtils.lIllIIll[39]); + ItemUtils.lIllIIlI[20] = lIlIIIIIIl(ItemUtils.lIllIIll[40], ItemUtils.lIllIIll[41]); + ItemUtils.lIllIIlI[21] = lIlIIIIIII(ItemUtils.lIllIIll[42], ItemUtils.lIllIIll[43]); + ItemUtils.lIllIIlI[22] = lIlIIIIIII(ItemUtils.lIllIIll[44], ItemUtils.lIllIIll[45]); + ItemUtils.lIllIIlI[23] = lIlIIIIIIl(ItemUtils.lIllIIll[46], ItemUtils.lIllIIll[47]); + ItemUtils.lIllIIlI[24] = lIIlllllll(ItemUtils.lIllIIll[48], ItemUtils.lIllIIll[49]); + ItemUtils.lIllIIlI[25] = lIlIIIIIII(ItemUtils.lIllIIll[50], ItemUtils.lIllIIll[51]); + ItemUtils.lIllIIlI[26] = lIIlllllll(ItemUtils.lIllIIll[52], ItemUtils.lIllIIll[53]); + ItemUtils.lIllIIlI[27] = lIIlllllll(ItemUtils.lIllIIll[54], ItemUtils.lIllIIll[55]); + ItemUtils.lIllIIlI[28] = lIIlllllll("CjYCNz0=", "yZkZX"); + ItemUtils.lIllIIlI[29] = lIIlllllll("ByYm", "pCDlm"); + ItemUtils.lIllIIlI[30] = lIlIIIIIIl("EP15kV8anRc=", "XDvZl"); + ItemUtils.lIllIIlI[31] = lIlIIIIIII("rCFTWL8Ygjo=", "TbXso"); + ItemUtils.lIllIIll = null; + } + + private static void lIlIIIIIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ItemUtils.lIllIIll = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIlllllll(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String lIlIIIIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIlIIIIIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/utils/ModuleUtils.java b/utils/ModuleUtils.java new file mode 100644 index 0000000..339ebac --- /dev/null +++ b/utils/ModuleUtils.java @@ -0,0 +1,61 @@ +package me.explicit.utils; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import java.util.Iterator; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import me.explicit.module.Category; +import me.explicit.module.Module; + +public class ModuleUtils { + + private static final String[] lIIlIlIII; + private static String[] lIIlIlIlI; + + public static void setAllModulesToggled(boolean flag) { + Iterator iterator = Explicit.instance.mm.getModules().iterator(); + + while (iterator.hasNext()) { + Module module = (Module) iterator.next(); + + if (!module.getName().equalsIgnoreCase(ModuleUtils.lIIlIlIII[0]) && !module.getCategory().equals(Category.VALUES)) { + module.setToggled(flag); + } + } + + } + + static { + lIIIIIIllII(); + lIIIIIIlIll(); + } + + private static void lIIIIIIlIll() { + lIIlIlIII = new String[1]; + ModuleUtils.lIIlIlIII[0] = lIIIIIIlIlI(ModuleUtils.lIIlIlIlI[0], ModuleUtils.lIIlIlIlI[1]); + ModuleUtils.lIIlIlIlI = null; + } + + private static void lIIIIIIllII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + ModuleUtils.lIIlIlIlI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIIIIIlIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/utils/MoveUtils.java b/utils/MoveUtils.java new file mode 100644 index 0000000..3f0315e --- /dev/null +++ b/utils/MoveUtils.java @@ -0,0 +1,143 @@ +package me.explicit.utils; + +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.Explicit; +import net.minecraft.potion.Potion; + +public class MoveUtils { + + private static final String[] lIllIII; + private static String[] lIllIIl; + + public static boolean PlayerMoving() { + return Game.Player().movementInput.moveForward != 0.0F || Game.Player().movementInput.moveStrafe != 0.0F; + } + + public static void setMoveSpeed(double d0) { + double d1 = (double) Game.Player().movementInput.moveForward; + double d2 = (double) Game.Player().movementInput.moveStrafe; + double d3 = (double) Game.Player().rotationYaw; + + if (d1 != 0.0D || d2 != 0.0D) { + if (d1 != 0.0D) { + if (d2 > 0.0D) { + d3 += d1 > 0.0D ? -45.0D : 45.0D; + } else if (d2 < 0.0D) { + d3 += d1 > 0.0D ? 45.0D : -45.0D; + } + + d2 = 0.0D; + if (d1 > 0.0D) { + d1 = 1.0D; + } else if (d1 < 0.0D) { + d1 = -1.0D; + } + } + + double d4 = d1 * d0 * Math.cos(Math.toRadians(d3 + 88.0D)) + d2 * d0 * Math.sin(Math.toRadians(d3 + 87.9000015258789D)); + double d5 = d1 * d0 * Math.sin(Math.toRadians(d3 + 88.0D)) - d2 * d0 * Math.cos(Math.toRadians(d3 + 87.9000015258789D)); + + if (Explicit.instance.mm.getModuleByName(MoveUtils.lIllIII[0]).isToggled()) { + Game.Player().motionX = d4 / 1.5D; + Game.Player().motionZ = d5 / 1.5D; + } else { + Game.Player().motionX = d4 / 1.25D; + Game.Player().motionZ = d5 / 1.25D; + } + } + + } + + public static double getBaseMovementSpeed() { + double d0 = 0.2873D; + + if (Game.Player().isPotionActive(Potion.moveSpeed)) { + int i = Game.Player().getActivePotionEffect(Potion.moveSpeed).getAmplifier(); + + d0 *= 1.0D + 0.2D * (double) (i + 1); + } + + return d0; + } + + public static float getSpeed() { + float f = (float) Math.sqrt(Game.Player().motionX * Game.Player().motionX + Game.Player().motionZ * Game.Player().motionZ); + + return f; + } + + public static boolean isOnGround(double d0) { + return !Game.World().getCollidingBoundingBoxes(Game.Player(), Game.Player().getEntityBoundingBox().offset(0.0D, -d0, 0.0D)).isEmpty(); + } + + public static int getJumpEffect() { + return Game.Player().isPotionActive(Potion.jump) ? Game.Player().getActivePotionEffect(Potion.jump).getAmplifier() + 1 : 0; + } + + public static int getSpeedEffect() { + return Game.Player().isPotionActive(Potion.moveSpeed) ? Game.Player().getActivePotionEffect(Potion.moveSpeed).getAmplifier() + 1 : 0; + } + + public static float getDirection() { + float f = Game.Player().rotationYaw; + + if (Game.Player().moveForward < 0.0F) { + f += 180.0F; + } + + float f1 = 1.0F; + + if (Game.Player().moveForward < 0.0F) { + f1 = -0.5F; + } else if (Game.Player().moveForward > 0.0F) { + f1 = 0.5F; + } else { + f1 = 1.0F; + } + + if (Game.Player().moveStrafing > 0.0F) { + f -= 90.0F * f1; + } + + if (Game.Player().moveStrafing < 0.0F) { + f += 90.0F * f1; + } + + f *= 0.017453292F; + return f; + } + + static { + lIIlIlllI(); + lIIlIllIl(); + } + + private static void lIIlIllIl() { + lIllIII = new String[1]; + MoveUtils.lIllIII[0] = lIIlIllII(MoveUtils.lIllIIl[0], MoveUtils.lIllIIl[1]); + MoveUtils.lIllIIl = null; + } + + private static void lIIlIlllI() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + MoveUtils.lIllIIl = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIIlIllII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/utils/PlayerUtils.java b/utils/PlayerUtils.java new file mode 100644 index 0000000..8d355ee --- /dev/null +++ b/utils/PlayerUtils.java @@ -0,0 +1,5 @@ +package me.explicit.utils; + +public class PlayerUtils { + +} diff --git a/utils/PrivateUtils.java b/utils/PrivateUtils.java new file mode 100644 index 0000000..e933d48 --- /dev/null +++ b/utils/PrivateUtils.java @@ -0,0 +1,186 @@ +package me.explicit.utils; + +import java.lang.reflect.Field; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import me.explicit.module.player.FastPlace; +import net.minecraft.client.Minecraft; +import net.minecraft.client.multiplayer.PlayerControllerMP; +import net.minecraft.util.Timer; + +public class PrivateUtils { + + private static final String[] llIllIII; + private static String[] llIllIlI; + + public static Timer timer() { + try { + Class oclass = Minecraft.class; + Field field = oclass.getDeclaredField(new String(new char[] { 't', 'i', 'm', 'e', 'r'})); + + field.setAccessible(true); + return (Timer) field.get(Game.Minecraft()); + } catch (Exception exception) { + try { + Class oclass1 = Minecraft.class; + Field field1 = oclass1.getDeclaredField(new String(new char[] { 'f', 'i', 'e', 'l', 'd', '_', '7', '1', '4', '2', '8', '_', 'T'})); + + field1.setAccessible(true); + return (Timer) field1.get(Game.Minecraft()); + } catch (Exception exception1) { + return null; + } + } + } + + public static void setRightClickDelayTimer(int i) { + FastPlace.placeDelay = i; + + try { + Field field = Minecraft.class.getDeclaredField(PrivateUtils.llIllIII[0]); + + field.setAccessible(true); + field.set(Game.Minecraft(), Integer.valueOf(i)); + } catch (Exception exception) { + try { + Field field1 = Minecraft.class.getDeclaredField(PrivateUtils.llIllIII[1]); + + field1.setAccessible(true); + field1.set(Game.Minecraft(), Integer.valueOf(i)); + } catch (Exception exception1) { + ; + } + } + + } + + public static void setBlockDamage(float f) { + try { + Field field = PlayerControllerMP.class.getDeclaredField(PrivateUtils.llIllIII[2]); + + field.setAccessible(true); + field.set(Game.Minecraft().playerController, Float.valueOf(f)); + } catch (Exception exception) { + try { + Field field1 = PlayerControllerMP.class.getDeclaredField(PrivateUtils.llIllIII[3]); + + field1.setAccessible(true); + field1.set(Game.Minecraft().playerController, Float.valueOf(f)); + } catch (Exception exception1) { + ; + } + } + + } + + public static void setBlockHitDelay(int i) { + try { + Field field = PlayerControllerMP.class.getDeclaredField(PrivateUtils.llIllIII[4]); + + field.setAccessible(true); + field.set(Game.Minecraft().playerController, Integer.valueOf(i)); + } catch (Exception exception) { + try { + Field field1 = PlayerControllerMP.class.getDeclaredField(PrivateUtils.llIllIII[5]); + + field1.setAccessible(true); + field1.set(Game.Minecraft().playerController, Integer.valueOf(i)); + } catch (Exception exception1) { + ; + } + } + + } + + public static float getBlockDamage() { + try { + Class oclass = PlayerControllerMP.class; + Field field = oclass.getDeclaredField(PrivateUtils.llIllIII[6]); + + field.setAccessible(true); + return ((Float) field.get(Game.Minecraft().playerController)).floatValue(); + } catch (Exception exception) { + try { + Class oclass1 = PlayerControllerMP.class; + Field field1 = oclass1.getDeclaredField(PrivateUtils.llIllIII[7]); + + field1.setAccessible(true); + return ((Float) field1.get(Game.Minecraft().playerController)).floatValue(); + } catch (Exception exception1) { + return -1.0F; + } + } + } + + static { + llIIlIIlIl(); + llIIlIIIll(); + } + + private static void llIIlIIIll() { + llIllIII = new String[8]; + PrivateUtils.llIllIII[0] = llIIlIIIII(PrivateUtils.llIllIlI[0], PrivateUtils.llIllIlI[1]); + PrivateUtils.llIllIII[1] = llIIlIIIIl(PrivateUtils.llIllIlI[2], PrivateUtils.llIllIlI[3]); + PrivateUtils.llIllIII[2] = llIIlIIIIl(PrivateUtils.llIllIlI[4], PrivateUtils.llIllIlI[5]); + PrivateUtils.llIllIII[3] = llIIlIIIII(PrivateUtils.llIllIlI[6], PrivateUtils.llIllIlI[7]); + PrivateUtils.llIllIII[4] = llIIlIIIII(PrivateUtils.llIllIlI[8], PrivateUtils.llIllIlI[9]); + PrivateUtils.llIllIII[5] = llIIlIIIII(PrivateUtils.llIllIlI[10], PrivateUtils.llIllIlI[11]); + PrivateUtils.llIllIII[6] = llIIlIIIIl(PrivateUtils.llIllIlI[12], PrivateUtils.llIllIlI[13]); + PrivateUtils.llIllIII[7] = llIIlIIIlI(PrivateUtils.llIllIlI[14], PrivateUtils.llIllIlI[15]); + PrivateUtils.llIllIlI = null; + } + + private static void llIIlIIlIl() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + PrivateUtils.llIllIlI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIIlIIIlI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIlIIIIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIIlIIIII(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } +} diff --git a/utils/RenderUtils.java b/utils/RenderUtils.java new file mode 100644 index 0000000..b6c5334 --- /dev/null +++ b/utils/RenderUtils.java @@ -0,0 +1,449 @@ +package me.explicit.utils; + +import java.awt.Color; +import java.lang.reflect.Method; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.Gui; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.client.renderer.RenderGlobal; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.WorldRenderer; +import net.minecraft.client.renderer.vertex.DefaultVertexFormats; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.BlockPos; +import org.lwjgl.opengl.GL11; + +public class RenderUtils { + + private static final String[] llIll; + private static String[] lllII; + + public static void renderBlockPos(BlockPos blockpos, int i) { + if (blockpos != null) { + double d0 = (double) blockpos.getX() - Game.Minecraft().getRenderManager().viewerPosX; + double d1 = (double) blockpos.getY() - Game.Minecraft().getRenderManager().viewerPosY; + double d2 = (double) blockpos.getZ() - Game.Minecraft().getRenderManager().viewerPosZ; + + GL11.glBlendFunc(770, 771); + GL11.glEnable(3042); + GL11.glLineWidth(2.0F); + GL11.glDisable(3553); + GL11.glDisable(2929); + GL11.glDepthMask(false); + float f = (float) (i >> 24 & 255) / 255.0F; + float f1 = (float) (i >> 16 & 255) / 255.0F; + float f2 = (float) (i >> 8 & 255) / 255.0F; + float f3 = (float) (i & 255) / 255.0F; + + GL11.glColor4d((double) f1, (double) f2, (double) f3, (double) f); + RenderGlobal.drawSelectionBoundingBox(new AxisAlignedBB(d0, d1, d2, d0 + 1.0D, d1 + 1.0D, d2 + 1.0D)); + dbb(new AxisAlignedBB(d0, d1, d2, d0 + 1.0D, d1 + 1.0D, d2 + 1.0D), f1, f2, f3); + GL11.glEnable(3553); + GL11.glEnable(2929); + GL11.glDepthMask(true); + GL11.glDisable(3042); + } + } + + public static void renderEntity(Entity entity, int i, int j) { + if (entity != null) { + double d0 = entity.lastTickPosX + (entity.posX - entity.lastTickPosX) * (double) PrivateUtils.timer().renderPartialTicks - Minecraft.getMinecraft().getRenderManager().viewerPosX; + double d1 = entity.lastTickPosY + (entity.posY - entity.lastTickPosY) * (double) PrivateUtils.timer().renderPartialTicks - Minecraft.getMinecraft().getRenderManager().viewerPosY; + double d2 = entity.lastTickPosZ + (entity.posZ - entity.lastTickPosZ) * (double) PrivateUtils.timer().renderPartialTicks - Minecraft.getMinecraft().getRenderManager().viewerPosZ; + + if (entity instanceof EntityPlayer && ((EntityPlayer) entity).hurtTime != 0) { + i = Color.RED.getRGB(); + } + + float f; + float f1; + float f2; + float f3; + + if (j == 1) { + GlStateManager.pushMatrix(); + GL11.glBlendFunc(770, 771); + GL11.glEnable(3042); + GL11.glDisable(3553); + GL11.glDisable(2929); + GL11.glDepthMask(false); + GL11.glLineWidth(2.0F); + f = (float) (i >> 24 & 255) / 255.0F; + f1 = (float) (i >> 16 & 255) / 255.0F; + f2 = (float) (i >> 8 & 255) / 255.0F; + f3 = (float) (i & 255) / 255.0F; + GL11.glColor4f(f1, f2, f3, f); + RenderGlobal.drawSelectionBoundingBox(new AxisAlignedBB(entity.getEntityBoundingBox().minX - 0.05D - entity.posX + (entity.posX - Minecraft.getMinecraft().getRenderManager().viewerPosX), entity.getEntityBoundingBox().minY - entity.posY + (entity.posY - Minecraft.getMinecraft().getRenderManager().viewerPosY), entity.getEntityBoundingBox().minZ - 0.05D - entity.posZ + (entity.posZ - Minecraft.getMinecraft().getRenderManager().viewerPosZ), entity.getEntityBoundingBox().maxX + 0.05D - entity.posX + (entity.posX - Minecraft.getMinecraft().getRenderManager().viewerPosX), entity.getEntityBoundingBox().maxY + 0.1D - entity.posY + (entity.posY - Minecraft.getMinecraft().getRenderManager().viewerPosY), entity.getEntityBoundingBox().maxZ + 0.05D - entity.posZ + (entity.posZ - Minecraft.getMinecraft().getRenderManager().viewerPosZ))); + dbb(new AxisAlignedBB(entity.getEntityBoundingBox().minX - 0.05D - entity.posX + (entity.posX - Minecraft.getMinecraft().getRenderManager().viewerPosX), entity.getEntityBoundingBox().minY - entity.posY + (entity.posY - Minecraft.getMinecraft().getRenderManager().viewerPosY), entity.getEntityBoundingBox().minZ - 0.05D - entity.posZ + (entity.posZ - Minecraft.getMinecraft().getRenderManager().viewerPosZ), entity.getEntityBoundingBox().maxX + 0.05D - entity.posX + (entity.posX - Minecraft.getMinecraft().getRenderManager().viewerPosX), entity.getEntityBoundingBox().maxY + 0.1D - entity.posY + (entity.posY - Minecraft.getMinecraft().getRenderManager().viewerPosY), entity.getEntityBoundingBox().maxZ + 0.05D - entity.posZ + (entity.posZ - Minecraft.getMinecraft().getRenderManager().viewerPosZ)), f1, f2, f3); + GL11.glEnable(3553); + GL11.glEnable(2929); + GL11.glDepthMask(true); + GL11.glDisable(3042); + GlStateManager.popMatrix(); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + } else if (j == 2) { + GL11.glBlendFunc(770, 771); + GL11.glEnable(3042); + GL11.glLineWidth(2.0F); + GL11.glDisable(3553); + GL11.glDisable(2929); + GL11.glDepthMask(false); + f = (float) (i >> 24 & 255) / 255.0F; + f1 = (float) (i >> 16 & 255) / 255.0F; + f2 = (float) (i >> 8 & 255) / 255.0F; + f3 = (float) (i & 255) / 255.0F; + GL11.glColor4d((double) f1, (double) f2, (double) f3, (double) f); + RenderGlobal.drawSelectionBoundingBox(new AxisAlignedBB(entity.getEntityBoundingBox().minX - 0.05D - entity.posX + (entity.posX - Minecraft.getMinecraft().getRenderManager().viewerPosX), entity.getEntityBoundingBox().minY - entity.posY + (entity.posY - Minecraft.getMinecraft().getRenderManager().viewerPosY), entity.getEntityBoundingBox().minZ - 0.05D - entity.posZ + (entity.posZ - Minecraft.getMinecraft().getRenderManager().viewerPosZ), entity.getEntityBoundingBox().maxX + 0.05D - entity.posX + (entity.posX - Minecraft.getMinecraft().getRenderManager().viewerPosX), entity.getEntityBoundingBox().maxY + 0.1D - entity.posY + (entity.posY - Minecraft.getMinecraft().getRenderManager().viewerPosY), entity.getEntityBoundingBox().maxZ + 0.05D - entity.posZ + (entity.posZ - Minecraft.getMinecraft().getRenderManager().viewerPosZ))); + GL11.glEnable(3553); + GL11.glEnable(2929); + GL11.glDepthMask(true); + GL11.glDisable(3042); + } else if (j == 3) { + GL11.glPushMatrix(); + GL11.glTranslated(d0, d1 - 0.2D, d2); + GL11.glScalef(0.03F, 0.03F, 0.03F); + GL11.glRotated((double) (-Minecraft.getMinecraft().getRenderManager().playerViewY), 0.0D, 1.0D, 0.0D); + GlStateManager.disableDepth(); + Gui.drawRect(-20, -1, -26, 15, Color.black.getRGB()); + Gui.drawRect(-21, 0, -25, 14, i); + Gui.drawRect(-20, 61, -26, 75, Color.black.getRGB()); + Gui.drawRect(-21, 62, -25, 74, i); + Gui.drawRect(20, 61, 26, 75, Color.black.getRGB()); + Gui.drawRect(21, 62, 25, 74, i); + Gui.drawRect(20, -1, 26, 15, Color.black.getRGB()); + Gui.drawRect(21, 0, 25, 14, i); + Gui.drawRect(-20, -1, -9, 5, Color.black.getRGB()); + Gui.drawRect(-21, 0, -10, 4, i); + Gui.drawRect(20, -1, 9, 5, Color.black.getRGB()); + Gui.drawRect(21, 0, 10, 4, i); + Gui.drawRect(20, 70, 9, 75, Color.black.getRGB()); + Gui.drawRect(21, 71, 10, 74, i); + Gui.drawRect(-20, 70, -9, 75, Color.black.getRGB()); + Gui.drawRect(-21, 71, -10, 74, i); + GlStateManager.enableDepth(); + GL11.glPopMatrix(); + } + + } + } + + public static void dbb(AxisAlignedBB axisalignedbb, float f, float f1, float f2) { + float f3 = 0.25F; + Tessellator tessellator = Tessellator.getInstance(); + WorldRenderer worldrenderer = tessellator.getWorldRenderer(); + + worldrenderer.begin(7, DefaultVertexFormats.POSITION_COLOR); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + tessellator.draw(); + worldrenderer.begin(7, DefaultVertexFormats.POSITION_COLOR); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + tessellator.draw(); + worldrenderer.begin(7, DefaultVertexFormats.POSITION_COLOR); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + tessellator.draw(); + worldrenderer.begin(7, DefaultVertexFormats.POSITION_COLOR); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + tessellator.draw(); + worldrenderer.begin(7, DefaultVertexFormats.POSITION_COLOR); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + tessellator.draw(); + worldrenderer.begin(7, DefaultVertexFormats.POSITION_COLOR); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + worldrenderer.pos(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ).color(f, f1, f2, 0.25F).endVertex(); + tessellator.draw(); + } + + public static void stopDrawing() { + GL11.glDisable(3042); + GL11.glEnable(3553); + GL11.glDisable(2848); + GL11.glDisable(3042); + GL11.glEnable(2929); + } + + public static void startDrawing() { + GL11.glEnable(3042); + GL11.glEnable(3042); + GL11.glBlendFunc(770, 771); + GL11.glEnable(2848); + GL11.glDisable(3553); + GL11.glDisable(2929); + + try { + Class oclass = Minecraft.getMinecraft().entityRenderer.getClass(); + Method method = oclass.getDeclaredMethod(RenderUtils.llIll[0], new Class[] { Float.TYPE, Integer.TYPE}); + + method.setAccessible(true); + method.invoke(Minecraft.getMinecraft().entityRenderer, new Object[] { Float.valueOf(PrivateUtils.timer().renderPartialTicks), Integer.valueOf(0)}); + } catch (Exception exception) { + try { + Class oclass1 = Minecraft.getMinecraft().entityRenderer.getClass(); + Method method1 = oclass1.getDeclaredMethod(RenderUtils.llIll[1], new Class[] { Float.TYPE, Integer.TYPE}); + + method1.setAccessible(true); + method1.invoke(Minecraft.getMinecraft().entityRenderer, new Object[] { Float.valueOf(PrivateUtils.timer().renderPartialTicks), Integer.valueOf(0)}); + } catch (Exception exception1) { + ; + } + } + + } + + public static void blockESPBox(BlockPos blockpos, float f, float f1, float f2, float f3) { + double d0 = (double) blockpos.getX() - Game.Minecraft().getRenderManager().viewerPosX; + double d1 = (double) blockpos.getY() - Game.Minecraft().getRenderManager().viewerPosY; + double d2 = (double) blockpos.getZ() - Game.Minecraft().getRenderManager().viewerPosZ; + + GL11.glBlendFunc(770, 771); + GL11.glEnable(3042); + GL11.glLineWidth(f3); + GL11.glColor4d(0.0D, 1.0D, 0.0D, 0.15000000596046448D); + GL11.glDisable(3553); + GL11.glDisable(2929); + GL11.glDepthMask(false); + GL11.glColor4d((double) f, (double) f1, (double) f2, 1000.0D); + RenderGlobal.drawSelectionBoundingBox(new AxisAlignedBB(d0, d1, d2, d0 + 1.0D, d1 + 1.0D, d2 + 1.0D)); + GL11.glEnable(3553); + GL11.glEnable(2929); + GL11.glDepthMask(true); + GL11.glDisable(3042); + } + + public static void drawBorderedRect(float f, float f1, float f2, float f3, float f4, int i, int j) { + drawRect((double) f, (double) f1, (double) f2, (double) f3, j); + float f5 = (float) (i >> 24 & 255) / 255.0F; + float f6 = (float) (i >> 16 & 255) / 255.0F; + float f7 = (float) (i >> 8 & 255) / 255.0F; + float f8 = (float) (i & 255) / 255.0F; + + GL11.glEnable(3042); + GL11.glDisable(3553); + GL11.glBlendFunc(770, 771); + GL11.glEnable(2848); + GL11.glPushMatrix(); + GL11.glColor4f(f6, f7, f8, f5); + GL11.glLineWidth(f4); + GL11.glBegin(1); + GL11.glVertex2d((double) f, (double) f1); + GL11.glVertex2d((double) f, (double) f3); + GL11.glVertex2d((double) f2, (double) f3); + GL11.glVertex2d((double) f2, (double) f1); + GL11.glVertex2d((double) f, (double) f1); + GL11.glVertex2d((double) f2, (double) f1); + GL11.glVertex2d((double) f, (double) f3); + GL11.glVertex2d((double) f2, (double) f3); + GL11.glEnd(); + GL11.glPopMatrix(); + GL11.glEnable(3553); + GL11.glDisable(3042); + GL11.glDisable(2848); + } + + public static void drawRect(double d0, double d1, double d2, double d3, int i) { + double d4; + + if (d0 < d2) { + d4 = d0; + d0 = d2; + d2 = d4; + } + + if (d1 < d3) { + d4 = d1; + d1 = d3; + d3 = d4; + } + + float f = (float) (i >> 24 & 255) / 255.0F; + float f1 = (float) (i >> 16 & 255) / 255.0F; + float f2 = (float) (i >> 8 & 255) / 255.0F; + float f3 = (float) (i & 255) / 255.0F; + Tessellator tessellator = Tessellator.getInstance(); + WorldRenderer worldrenderer = tessellator.getWorldRenderer(); + + GlStateManager.enableBlend(); + GlStateManager.disableTexture2D(); + GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0); + GlStateManager.color(f1, f2, f3, f); + worldrenderer.begin(7, DefaultVertexFormats.POSITION); + worldrenderer.pos(d0, d3, 0.0D).endVertex(); + worldrenderer.pos(d2, d3, 0.0D).endVertex(); + worldrenderer.pos(d2, d1, 0.0D).endVertex(); + worldrenderer.pos(d0, d1, 0.0D).endVertex(); + tessellator.draw(); + GlStateManager.enableTexture2D(); + GlStateManager.disableBlend(); + } + + public static Color blend(Color color, Color color1, double d0) { + float f = (float) d0; + float f1 = 1.0F - f; + float[] afloat = new float[3]; + float[] afloat1 = new float[3]; + + color.getColorComponents(afloat); + color1.getColorComponents(afloat1); + Color color2 = new Color(afloat[0] * f + afloat1[0] * f1, afloat[1] * f + afloat1[1] * f1, afloat[2] * f + afloat1[2] * f1); + + return color2; + } + + public static void drawSolidBox(AxisAlignedBB axisalignedbb) { + GL11.glBegin(10); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glEnd(); + } + + public static void drawOutlinedBox() { + drawOutlinedBox(new AxisAlignedBB(0.0D, 0.0D, 0.0D, 1.0D, 1.0D, 1.0D)); + } + + public static void drawSolidBox() { + drawSolidBox(new AxisAlignedBB(0.0D, 0.0D, 0.0D, 1.0D, 1.0D, 1.0D)); + } + + public static void drawOutlinedBox(AxisAlignedBB axisalignedbb) { + GL11.glBegin(1); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.minY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.maxX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.maxZ); + GL11.glVertex3d(axisalignedbb.minX, axisalignedbb.maxY, axisalignedbb.minZ); + GL11.glEnd(); + } + + static { + llIIIII(); + lIlllll(); + } + + private static void lIlllll() { + llIll = new String[2]; + RenderUtils.llIll[0] = lIlllIl(RenderUtils.lllII[0], RenderUtils.lllII[1]); + RenderUtils.llIll[1] = lIllllI(RenderUtils.lllII[2], RenderUtils.lllII[3]); + RenderUtils.lllII = null; + } + + private static void llIIIII() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + RenderUtils.lllII = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String lIlllIl(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String lIllllI(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +} diff --git a/utils/RotationUtils.java b/utils/RotationUtils.java new file mode 100644 index 0000000..0e36d4f --- /dev/null +++ b/utils/RotationUtils.java @@ -0,0 +1,196 @@ +package me.explicit.utils; + +import net.minecraft.client.Minecraft; +import net.minecraft.entity.Entity; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.util.BlockPos; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.MathHelper; +import net.minecraft.util.Vec3; + +public class RotationUtils { + + public static float getDistanceBetweenAngles(float f, float f1) { + float f2; + + for (f2 = f - f1; f2 < -180.0F; f2 += 360.0F) { + ; + } + + while (f2 > 180.0F) { + f2 -= 360.0F; + } + + return f2; + } + + public static float[] getRotations(Entity entity) { + if (entity == null) { + return null; + } else { + double d0 = entity.posX - Game.Player().posX; + double d1 = entity.posZ - Game.Player().posZ; + EntityLivingBase entitylivingbase = (EntityLivingBase) entity; + double d2 = entitylivingbase.posY + ((double) entitylivingbase.getEyeHeight() - 0.4D) - (Game.Player().posY + (double) Game.Player().getEyeHeight()); + double d3 = (double) MathHelper.sqrt_double(d0 * d0 + d1 * d1); + float f = (float) (Math.atan2(d1, d0) * 180.0D / 3.141592653589793D) - 90.0F; + float f1 = (float) (-(Math.atan2(d2, d3) * 180.0D / 3.141592653589793D)); + + return new float[] { f, f1}; + } + } + + public static float getFovDistanceToEntity(Entity entity) { + float f; + + for (f = Game.Player().rotationYaw; f > 360.0F; f -= 360.0F) { + ; + } + + while (f < -360.0F) { + f += 360.0F; + } + + float f1 = getDistanceBetweenAngles(f, getRotations(entity)[0]); + + return f1; + } + + public static void limitAngleChange(float[] afloat, float[] afloat1, float f) { + float f1 = getAngleDifference(afloat1[0], afloat[0]); + float f2 = getAngleDifference(afloat1[1], afloat[1]); + + Game.Player().rotationYaw = afloat[0] + (f1 > f ? f : Math.max(f1, -f)); + Game.Player().rotationPitch = afloat[1] + (f2 > f ? f : Math.max(f2, -f)); + } + + public static float[] toRotation(Vec3 vec3, boolean flag) { + Vec3 vec31 = new Vec3(Game.Player().posX, Game.Player().getEntityBoundingBox().minY + (double) Game.Player().getEyeHeight(), Game.Player().posZ); + + if (flag) { + vec31.addVector(Game.Player().motionX, Game.Player().motionY, Game.Player().motionZ); + } + + double d0 = vec3.xCoord - vec31.xCoord; + double d1 = vec3.yCoord - vec31.yCoord; + double d2 = vec3.zCoord - vec31.zCoord; + float f = MathHelper.wrapAngleTo180_float((float) Math.toDegrees(Math.atan2(d2, d0)) - 90.0F); + float f1 = MathHelper.wrapAngleTo180_float((float) (-Math.toDegrees(Math.atan2(d1, Math.sqrt(d0 * d0 + d2 * d2))))); + + return new float[] { f, f1}; + } + + private static float getAngleDifference(float f, float f1) { + return ((f - f1) % 360.0F + 540.0F) % 360.0F - 180.0F; + } + + public static boolean canEntityBeSeen(Entity entity) { + Vec3 vec3 = new Vec3(Minecraft.getMinecraft().thePlayer.posX, Minecraft.getMinecraft().thePlayer.posY + (double) Minecraft.getMinecraft().thePlayer.getEyeHeight(), Minecraft.getMinecraft().thePlayer.posZ); + AxisAlignedBB axisalignedbb = entity.getEntityBoundingBox(); + Vec3 vec31 = new Vec3(entity.posX, entity.posY + (double) (entity.getEyeHeight() / 1.32F), entity.posZ); + double d0 = entity.posX - 0.25D; + double d1 = entity.posX + 0.25D; + double d2 = entity.posY; + double d3 = entity.posY + Math.abs(entity.posY - axisalignedbb.maxY); + double d4 = entity.posZ - 0.25D; + double d5 = entity.posZ + 0.25D; + boolean flag = Minecraft.getMinecraft().theWorld.rayTraceBlocks(vec3, vec31) == null; + + if (flag) { + return true; + } else { + vec31 = new Vec3(d1, d2, d4); + flag = Minecraft.getMinecraft().theWorld.rayTraceBlocks(vec3, vec31) == null; + if (flag) { + return true; + } else { + vec31 = new Vec3(d0, d2, d4); + flag = Minecraft.getMinecraft().theWorld.rayTraceBlocks(vec3, vec31) == null; + if (flag) { + return true; + } else { + vec31 = new Vec3(d0, d2, d5); + flag = Minecraft.getMinecraft().theWorld.rayTraceBlocks(vec3, vec31) == null; + if (flag) { + return true; + } else { + vec31 = new Vec3(d1, d2, d5); + flag = Minecraft.getMinecraft().theWorld.rayTraceBlocks(vec3, vec31) == null; + if (flag) { + return true; + } else { + vec31 = new Vec3(d1, d3, d4); + flag = Minecraft.getMinecraft().theWorld.rayTraceBlocks(vec3, vec31) == null; + if (flag) { + return true; + } else { + vec31 = new Vec3(d0, d3, d4); + flag = Minecraft.getMinecraft().theWorld.rayTraceBlocks(vec3, vec31) == null; + if (flag) { + return true; + } else { + vec31 = new Vec3(d0, d3, d5 - 0.1D); + flag = Minecraft.getMinecraft().theWorld.rayTraceBlocks(vec3, vec31) == null; + if (flag) { + return true; + } else { + vec31 = new Vec3(d1, d3, d5); + flag = Minecraft.getMinecraft().theWorld.rayTraceBlocks(vec3, vec31) == null; + return flag; + } + } + } + } + } + } + } + } + } + + public static float getYawChange(float f, double d0, double d1) { + double d2 = d0 - Minecraft.getMinecraft().thePlayer.posX; + double d3 = d1 - Minecraft.getMinecraft().thePlayer.posZ; + double d4 = 0.0D; + + if (d3 < 0.0D && d2 < 0.0D) { + if (d2 != 0.0D) { + d4 = 90.0D + Math.toDegrees(Math.atan(d3 / d2)); + } + } else if (d3 < 0.0D && d2 > 0.0D) { + if (d2 != 0.0D) { + d4 = -90.0D + Math.toDegrees(Math.atan(d3 / d2)); + } + } else if (d3 != 0.0D) { + d4 = Math.toDegrees(-Math.atan(d2 / d3)); + } + + return MathHelper.wrapAngleTo180_float(-(f - (float) d4)); + } + + public static float roundTo360(float f) { + float f1; + + for (f1 = f; f1 > 360.0F; f1 -= 360.0F) { + ; + } + + return f1; + } + + public static float[] getRotationsBlock(BlockPos blockpos, EnumFacing enumfacing) { + double d0 = (double) blockpos.getX() + 0.5D - Game.Minecraft().thePlayer.posX + (double) enumfacing.getFrontOffsetX() / 2.0D; + double d1 = (double) blockpos.getZ() + 0.5D - Game.Minecraft().thePlayer.posZ + (double) enumfacing.getFrontOffsetZ() / 2.0D; + double d2 = (double) blockpos.getY() + 0.5D; + double d3 = Game.Minecraft().thePlayer.posY + (double) Game.Minecraft().thePlayer.getEyeHeight() - d2; + double d4 = (double) MathHelper.sqrt_double(d0 * d0 + d1 * d1); + float f = (float) (Math.atan2(d1, d0) * 180.0D / 3.141592653589793D) - 90.0F; + float f1 = (float) (Math.atan2(d3, d4) * 180.0D / 3.141592653589793D); + + if (f < 0.0F) { + f += 360.0F; + } + + return new float[] { f, f1}; + } +} diff --git a/utils/TimerUtils.java b/utils/TimerUtils.java new file mode 100644 index 0000000..692c33e --- /dev/null +++ b/utils/TimerUtils.java @@ -0,0 +1,26 @@ +package me.explicit.utils; + +public class TimerUtils { + + private long lastMS; + + private long getCurrentMS() { + return System.nanoTime() / 1000000L; + } + + public boolean hasReached(double d0) { + return (double) (this.getCurrentMS() - this.lastMS) >= d0; + } + + public void reset() { + this.lastMS = this.getCurrentMS(); + } + + public boolean delay(float f) { + return (float) (this.getTime() - this.lastMS) >= f; + } + + public long getTime() { + return this.getCurrentMS() - this.lastMS; + } +} diff --git a/utils/VersionCheck.java b/utils/VersionCheck.java new file mode 100644 index 0000000..7e1ad7f --- /dev/null +++ b/utils/VersionCheck.java @@ -0,0 +1,118 @@ +package me.explicit.utils; + +import java.awt.Component; +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStreamReader; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.security.MessageDigest; +import java.util.Arrays; +import java.util.Base64; +import javax.crypto.Cipher; +import javax.crypto.spec.SecretKeySpec; +import javax.swing.JOptionPane; + +public class VersionCheck extends Thread { + + private static final String[] llllIl; + private static String[] lllllI; + + public void run() { + try { + URL url = new URL(VersionCheck.llllIl[0]); + BufferedReader bufferedreader = new BufferedReader(new InputStreamReader(url.openStream())); + boolean flag = false; + + String s; + + while ((s = bufferedreader.readLine()) != null) { + String[] astring = s.split(VersionCheck.llllIl[1]); + String[] astring1 = astring; + int i = astring.length; + + for (int j = 0; j < i; ++j) { + String s1 = astring1[j]; + + if (s1.equalsIgnoreCase(VersionCheck.llllIl[2])) { + flag = true; + } + } + } + + if (!flag) { + JOptionPane.showMessageDialog((Component) null, VersionCheck.llllIl[3], VersionCheck.llllIl[4], 2); + } + + bufferedreader.close(); + } catch (IOException ioexception) { + ioexception.printStackTrace(); + } + + } + + static { + llIllIll(); + llIllIlI(); + } + + private static void llIllIlI() { + llllIl = new String[5]; + VersionCheck.llllIl[0] = llIlIlll(VersionCheck.lllllI[0], VersionCheck.lllllI[1]); + VersionCheck.llllIl[1] = llIllIII(VersionCheck.lllllI[2], VersionCheck.lllllI[3]); + VersionCheck.llllIl[2] = llIllIIl(VersionCheck.lllllI[4], VersionCheck.lllllI[5]); + VersionCheck.llllIl[3] = llIlIlll(VersionCheck.lllllI[6], VersionCheck.lllllI[7]); + VersionCheck.llllIl[4] = llIllIIl(VersionCheck.lllllI[8], VersionCheck.lllllI[9]); + VersionCheck.lllllI = null; + } + + private static void llIllIll() { + String s = (new Exception()).getStackTrace()[0].getFileName(); + + VersionCheck.lllllI = s.substring(s.indexOf("ä") + 1, s.lastIndexOf("ü")).split("ö"); + } + + private static String llIllIIl(String s, String s1) { + s = new String(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8)), StandardCharsets.UTF_8); + StringBuilder stringbuilder = new StringBuilder(); + char[] achar = s1.toCharArray(); + int i = 0; + char[] achar1 = s.toCharArray(); + int j = achar1.length; + + for (int k = 0; k < j; ++k) { + char c0 = achar1[k]; + + stringbuilder.append((char) (c0 ^ achar[i % achar.length])); + ++i; + } + + return String.valueOf(stringbuilder); + } + + private static String llIlIlll(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), "Blowfish"); + Cipher cipher = Cipher.getInstance("Blowfish"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } + + private static String llIllIII(String s, String s1) { + try { + SecretKeySpec secretkeyspec = new SecretKeySpec(Arrays.copyOf(MessageDigest.getInstance("MD5").digest(s1.getBytes(StandardCharsets.UTF_8)), 8), "DES"); + Cipher cipher = Cipher.getInstance("DES"); + + cipher.init(2, secretkeyspec); + return new String(cipher.doFinal(Base64.getDecoder().decode(s.getBytes(StandardCharsets.UTF_8))), StandardCharsets.UTF_8); + } catch (Exception exception) { + exception.printStackTrace(); + return null; + } + } +}