first commit

src/main/java/cloudburst/rejects/MeteorRejectsAddon.java

@@ -0,0 +1,32 @@
+package cloudburst.rejects;
+
+import minegame159.meteorclient.MeteorAddon;
+import minegame159.meteorclient.commands.Commands;
+import minegame159.meteorclient.modules.Modules;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import cloudburst.rejects.commands.*;
+import cloudburst.rejects.modules.*;
+
+public class MeteorRejectsAddon extends MeteorAddon {
+	public static final Logger LOG = LogManager.getLogger();
+
+	@Override
+	public void onInitialize() {
+		LOG.info("Initializing Meteor Rejects Addon");
+
+		Modules.get().add(new AntiBot());
+		Modules.get().add(new AutoMountBypassDupe());
+		Modules.get().add(new Baconator());
+		Modules.get().add(new RenderInvisible());
+
+		Commands.get().add(new GiveCommand());
+	}
+
+	@Override
+	public void onRegisterCategories() {
+		RejectCategory.register();
+	}
+}

src/main/java/cloudburst/rejects/RejectCategory.java

@@ -0,0 +1,14 @@
+package cloudburst.rejects;
+
+import net.minecraft.item.Items;
+
+import minegame159.meteorclient.modules.Category;
+import minegame159.meteorclient.modules.Modules;
+
+public class RejectCategory {
+    public static final Category Rejects = new Category("Rejects", Items.DIRT.getDefaultStack());
+    
+    public static void register() {
+        Modules.registerCategory(Rejects);
+    }
+}

src/main/java/cloudburst/rejects/arguments/EnumStringArgumentType.java

@@ -0,0 +1,52 @@
+package cloudburst.rejects.arguments;
+
+import java.util.Collection;
+import java.util.concurrent.CompletableFuture;
+
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+
+import net.minecraft.command.CommandSource;
+import net.minecraft.text.LiteralText;
+
+public class EnumStringArgumentType implements ArgumentType<String> {
+
+    private  Collection<String> EXAMPLES;
+    private static final DynamicCommandExceptionType INVALID_OPTION = new DynamicCommandExceptionType(name ->
+                new LiteralText(name+" is not a valid option."));
+    public EnumStringArgumentType(Collection<String> examples) {
+        this.EXAMPLES = examples;
+    }
+
+    @Override
+    public String parse(StringReader reader) throws CommandSyntaxException {
+        String arg = reader.readUnquotedString();
+        if (!EXAMPLES.contains(arg)) throw INVALID_OPTION.create(arg);
+        return arg;
+    }
+
+    public static String getString(final CommandContext<?> context, final String name) {
+        return context.getArgument(name, String.class);
+    }
+
+    @Override
+    public Collection<String> getExamples() {
+        return EXAMPLES;
+    }
+
+    @Override
+    public String toString() {
+        return "string()";
+    }
+
+    @Override
+    public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+        return CommandSource.suggestMatching(EXAMPLES, builder);
+    }
+    
+}

src/main/java/cloudburst/rejects/mixin/EntityMixin.java

@@ -0,0 +1,22 @@
+package cloudburst.rejects.mixin;
+
+import minegame159.meteorclient.modules.Modules;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+
+import cloudburst.rejects.modules.RenderInvisible;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(Entity.class)
+public abstract class EntityMixin {
+    @Inject(method = "isInvisibleTo(Lnet/minecraft/entity/player/PlayerEntity;)Z", at = @At("HEAD"), cancellable = true)
+    private void isInvisibleToCanceller(PlayerEntity player, CallbackInfoReturnable<Boolean> info) {
+        if (player == null) info.setReturnValue(false);
+
+        if (Modules.get().isActive(RenderInvisible.class)) info.setReturnValue(false);
+    }
+}

src/main/java/cloudburst/rejects/modules/AntiBot.java

@@ -0,0 +1,51 @@
+package cloudburst.rejects.modules;
+
+import meteordevelopment.orbit.EventHandler;
+import minegame159.meteorclient.events.world.TickEvent;
+import minegame159.meteorclient.modules.Module;
+import minegame159.meteorclient.settings.BoolSetting;
+import minegame159.meteorclient.settings.Setting;
+import minegame159.meteorclient.settings.SettingGroup;
+import minegame159.meteorclient.utils.entity.EntityUtils;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+
+import cloudburst.rejects.RejectCategory;
+
+
+public class AntiBot extends Module {
+
+	private final SettingGroup sgGeneral = settings.getDefaultGroup();
+
+	private final Setting<Boolean> removeInvisible = sgGeneral.add(new BoolSetting.Builder()
+			.name("remove-invisible")
+			.description("Removes bot only if they are invisible.")
+			.defaultValue(true)
+			.build()
+	);
+
+	public AntiBot()
+	{
+		super(RejectCategory.Rejects, "anti-bot", "Detects and removes bots.");
+	}
+
+	@EventHandler
+	public void onTick(TickEvent.Post tickEvent)
+	{
+		for (Entity entity : mc.world.getEntities())
+		{
+			if (removeInvisible.get() && !entity.isInvisible()) continue;
+
+			if (isBot(entity)) entity.remove();
+		}
+	}
+
+	private boolean isBot(Entity entity)
+	{
+		if (entity == null) return false;
+		if (!(entity instanceof PlayerEntity)) return false;
+
+		// Gamemode check
+		return EntityUtils.getGameMode(((PlayerEntity)entity)) == null; // Assume bot if invalid gamemode
+	}
+}

src/main/java/cloudburst/rejects/modules/AutoMountBypassDupe.java

@@ -0,0 +1,224 @@
+/*
+ * This file is part of the Meteor Client distribution (https://github.com/MeteorDevelopment/meteor-client/).
+ * Copyright (c) 2021 Meteor Development.
+ */
+
+package cloudburst.rejects.modules;
+
+//Created by squidoodly 12/07/2020
+
+import meteordevelopment.orbit.EventHandler;
+import minegame159.meteorclient.events.packets.PacketEvent;
+import minegame159.meteorclient.events.world.TickEvent;
+import minegame159.meteorclient.modules.Module;
+import minegame159.meteorclient.modules.Modules;
+import minegame159.meteorclient.modules.player.MountBypass;
+import minegame159.meteorclient.settings.BoolSetting;
+import minegame159.meteorclient.settings.IntSetting;
+import minegame159.meteorclient.settings.Setting;
+import minegame159.meteorclient.settings.SettingGroup;
+import minegame159.meteorclient.utils.player.ChatUtils;
+import minegame159.meteorclient.utils.player.InvUtils;
+import net.minecraft.block.ShulkerBoxBlock;
+import net.minecraft.client.gui.screen.ingame.HorseScreen;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.passive.AbstractDonkeyEntity;
+import net.minecraft.entity.passive.LlamaEntity;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.Items;
+import net.minecraft.network.packet.c2s.play.ClientCommandC2SPacket;
+import net.minecraft.network.packet.c2s.play.PlayerInteractEntityC2SPacket;
+import net.minecraft.network.packet.c2s.play.PlayerMoveC2SPacket;
+import net.minecraft.screen.slot.SlotActionType;
+import net.minecraft.util.Hand;
+import org.lwjgl.glfw.GLFW;
+
+import java.util.ArrayList;
+import java.util.List;
+import cloudburst.rejects.RejectCategory;
+
+public class AutoMountBypassDupe extends Module {
+    private final SettingGroup sgGeneral = settings.getDefaultGroup();
+
+    private final Setting<Boolean> shulkersOnly = sgGeneral.add(new BoolSetting.Builder()
+            .name("shulker-only")
+            .description("Only moves shulker boxes into the inventory")
+            .defaultValue(true)
+            .build());
+
+    private final Setting<Boolean> faceDown = sgGeneral.add(new BoolSetting.Builder()
+            .name("rotate-down")
+            .description("Faces down when dropping items.")
+            .defaultValue(true)
+            .build()
+    );
+
+    private final Setting<Integer> delay = sgGeneral.add(new IntSetting.Builder()
+            .name("delay")
+            .description("The delay in ticks between actions.")
+            .defaultValue(4)
+            .min(0)
+            .build()
+    );
+
+    private final List<Integer> slotsToMove = new ArrayList<>();
+    private final List<Integer> slotsToThrow = new ArrayList<>();
+
+    private boolean noCancel = false;
+    private AbstractDonkeyEntity entity;
+    private boolean sneak = false;
+    private int timer;
+
+    public AutoMountBypassDupe() {
+        super(RejectCategory.Rejects, "auto-mount-bypass-dupe", "Does the mount bypass dupe for you. Disable with esc.");
+    }
+
+    @Override
+    public void onActivate() {
+        timer = 0;
+    }
+
+    @EventHandler
+    private void onSendPacket(PacketEvent.Send event) {
+        if (noCancel) return;
+
+        Modules.get().get(MountBypass.class).onSendPacket(event);
+    }
+
+    @EventHandler
+    private void onTick(TickEvent.Post event) {
+        if (GLFW.glfwGetKey(mc.getWindow().getHandle(), GLFW.GLFW_KEY_ESCAPE) == GLFW.GLFW_PRESS) {
+            toggle();
+            mc.player.closeHandledScreen();
+            return;
+        }
+
+        if (timer <= 0) {
+            timer = delay.get();
+        } else {
+            timer--;
+            return;
+        }
+
+        int slots = getInvSize(mc.player.getVehicle());
+
+        for (Entity e : mc.world.getEntities()) {
+            if (e.distanceTo(mc.player) < 5 && e instanceof AbstractDonkeyEntity && ((AbstractDonkeyEntity) e).isTame()) {
+                entity = (AbstractDonkeyEntity) e;
+            }
+        }
+        if (entity == null) return;
+
+        if (sneak) {
+            mc.player.networkHandler.sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.RELEASE_SHIFT_KEY));
+            mc.player.setSneaking(false);
+            sneak = false;
+            return;
+        }
+
+        if (slots == -1) {
+            if (entity.hasChest() || mc.player.getMainHandStack().getItem() == Items.CHEST){
+                mc.player.networkHandler.sendPacket(new PlayerInteractEntityC2SPacket(entity, Hand.MAIN_HAND, mc.player.isSneaking()));
+            } else {
+                int slot = InvUtils.findItemWithCount(Items.CHEST).slot;
+                if (slot != -1 && slot < 9) {
+                    mc.player.inventory.selectedSlot  = slot;
+                } else {
+                    ChatUtils.moduleError(this, "Cannot find chest in your hotbar... disabling.");
+                    this.toggle();
+                }
+            }
+        } else if (slots == 0) {
+            if (isDupeTime()) {
+                if (!slotsToThrow.isEmpty()) {
+                    if (faceDown.get()) {
+                        mc.player.networkHandler.sendPacket(new PlayerMoveC2SPacket.LookOnly(mc.player.yaw, 90, mc.player.isOnGround()));
+                    }
+                    for (int i : slotsToThrow) {
+                        InvUtils.clickSlot(i, 1, SlotActionType.THROW);
+                    }
+                    slotsToThrow.clear();
+                } else {
+                    for (int i = 2; i < getDupeSize() + 1; i++) {
+                        slotsToThrow.add(i);
+                    }
+                }
+            } else {
+                mc.player.closeHandledScreen();
+                mc.player.networkHandler.sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.PRESS_SHIFT_KEY));
+
+                mc.player.setSneaking(true);
+                sneak = true;
+            }
+        } else if (!(mc.currentScreen instanceof HorseScreen)) {
+            mc.player.openRidingInventory();
+        } else if (slots > 0 ) {
+            if (slotsToMove.isEmpty()) {
+                boolean empty = true;
+                for (int i = 2; i <= slots; i++) {
+                    if (!(mc.player.currentScreenHandler.getStacks().get(i).isEmpty())) {
+                        empty = false;
+                        break;
+                    }
+                }
+                if (empty) {
+                    for (int i = slots + 2; i < mc.player.currentScreenHandler.getStacks().size(); i++) {
+                        if (!(mc.player.currentScreenHandler.getStacks().get(i).isEmpty())) {
+                            if (mc.player.currentScreenHandler.getSlot(i).getStack().getItem() == Items.CHEST) continue;
+                            if (!(mc.player.currentScreenHandler.getSlot(i).getStack().getItem() instanceof BlockItem && ((BlockItem) mc.player.currentScreenHandler.getSlot(i).getStack().getItem()).getBlock() instanceof ShulkerBoxBlock) && shulkersOnly.get()) continue;
+                            slotsToMove.add(i);
+
+                            if (slotsToMove.size() >= slots) break;
+                        }
+                    }
+                } else {
+                    noCancel = true;
+                    mc.player.networkHandler.sendPacket(new PlayerInteractEntityC2SPacket(entity, Hand.MAIN_HAND, entity.getPos().add(entity.getWidth() / 2, entity.getHeight() / 2, entity.getWidth() / 2), mc.player.isSneaking()));
+                    noCancel = false;
+                    return;
+                }
+            }
+
+            if (!slotsToMove.isEmpty()) {
+                for (int i : slotsToMove) InvUtils.clickSlot(i, 0, SlotActionType.QUICK_MOVE);
+                slotsToMove.clear();
+            }
+        }
+    }
+
+    private int getInvSize(Entity e){
+        if (!(e instanceof AbstractDonkeyEntity)) return -1;
+
+        if (!((AbstractDonkeyEntity)e).hasChest()) return 0;
+
+        if (e instanceof LlamaEntity) {
+            return 3 * ((LlamaEntity) e).getStrength();
+        }
+
+        return 15;
+    }
+
+    private boolean isDupeTime() {
+        if (mc.player.getVehicle() != entity || entity.hasChest() || mc.player.currentScreenHandler.getStacks().size() == 46) {
+            return false;
+        }
+
+        if (mc.player.currentScreenHandler.getStacks().size() > 38) {
+            for (int i = 2; i < getDupeSize() + 1; i++) {
+                if (mc.player.currentScreenHandler.getSlot(i).hasStack()) {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private int getDupeSize() {
+        if (mc.player.getVehicle() != entity || entity.hasChest() || mc.player.currentScreenHandler.getStacks().size() == 46) {
+            return 0;
+        }
+
+        return mc.player.currentScreenHandler.getStacks().size() - 38;
+    }
+}

src/main/java/cloudburst/rejects/modules/Baconator.java

@@ -0,0 +1,130 @@
+package cloudburst.rejects.modules;
+
+import meteordevelopment.orbit.EventHandler;
+import minegame159.meteorclient.events.world.TickEvent;
+import minegame159.meteorclient.modules.Module;
+import minegame159.meteorclient.settings.BoolSetting;
+import minegame159.meteorclient.settings.DoubleSetting;
+import minegame159.meteorclient.settings.EntityTypeListSetting;
+import minegame159.meteorclient.settings.IntSetting;
+import minegame159.meteorclient.settings.Setting;
+import minegame159.meteorclient.settings.SettingGroup;
+import minegame159.meteorclient.utils.Utils;
+import minegame159.meteorclient.utils.player.InvUtils;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.Blocks;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.FlintAndSteelItem;
+import net.minecraft.item.Items;
+import net.minecraft.util.Hand;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.math.Direction;
+import net.minecraft.util.math.Vec3d;
+
+import cloudburst.rejects.RejectCategory;
+import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
+
+public class Baconator extends Module {
+    private final SettingGroup sgGeneral = settings.getDefaultGroup();
+
+    private final Setting<Double> distance = sgGeneral.add(new DoubleSetting.Builder().name("distance")
+            .description("The maximum distance the aniaml has to be to be roasted.").min(0.0).defaultValue(5.0)
+            .build());
+
+    private final Setting<Boolean> antiBreak = sgGeneral.add(new BoolSetting.Builder().name("anti-break")
+            .description("Prevents flint and steel from being broken.").defaultValue(false).build());
+
+    private final Setting<Integer> tickInterval = sgGeneral.add(new IntSetting.Builder().name("tick-interval").defaultValue(5).build());
+
+    private final Setting<Object2BooleanMap<EntityType<?>>> entities = sgGeneral
+            .add(new EntityTypeListSetting.Builder().name("entities").description("Entities to cook.")
+                    .defaultValue(Utils.asObject2BooleanOpenHashMap(EntityType.PIG, EntityType.COW, EntityType.SHEEP,
+                            EntityType.CHICKEN, EntityType.RABBIT))
+                    .build());
+
+    private Entity entity;
+    private int preSlot;
+    private int ticks = 0;
+
+    public Baconator() {
+        super(RejectCategory.Rejects, "baconator", "Ignites every alive piece of food.");
+    }
+
+    @Override
+    public void onDeactivate() {
+        entity = null;
+    }
+
+    @EventHandler
+    private void onTick(TickEvent.Pre event) {
+        entity = null;
+        ticks++;
+        for (Entity entity : mc.world.getEntities()) {
+            if (!entities.get().getBoolean(entity.getType()) || mc.player.distanceTo(entity) > distance.get()) continue;
+
+            boolean findNewFlintAndSteel = false;
+            if (mc.player.inventory.getMainHandStack().getItem() instanceof FlintAndSteelItem) {
+                if (antiBreak.get() && mc.player.inventory.getMainHandStack()
+                        .getDamage() >= mc.player.inventory.getMainHandStack().getMaxDamage() - 1)
+                    findNewFlintAndSteel = true;
+            } else if (mc.player.inventory.offHand.get(0).getItem() instanceof FlintAndSteelItem) {
+                if (antiBreak.get() && mc.player.inventory.offHand.get(0)
+                        .getDamage() >= mc.player.inventory.offHand.get(0).getMaxDamage() - 1)
+                    findNewFlintAndSteel = true;
+            } else {
+                findNewFlintAndSteel = true;
+            }
+
+            boolean foundFlintAndSteel = !findNewFlintAndSteel;
+            if (findNewFlintAndSteel) {
+                int slot = InvUtils.findItemInHotbar(Items.FLINT_AND_STEEL, itemStack -> (!antiBreak.get()
+                        || (antiBreak.get() && itemStack.getDamage() < itemStack.getMaxDamage() - 1)));
+
+                if (slot != -1) {
+                    mc.player.inventory.selectedSlot = slot;
+                    foundFlintAndSteel = true;
+                }
+            }
+
+            if (foundFlintAndSteel) {
+                this.entity = entity;
+
+                // if (rotate.get()) Rotations.rotate(Rotations.getYaw(entity),
+                // Rotations.getPitch(entity), -100, this::interact);
+                interact();
+
+                return;
+            }
+        }
+    }
+
+    private void interact() {
+        Block block = mc.world.getBlockState(entity.getBlockPos()).getBlock();
+        Block bottom = mc.world.getBlockState(entity.getBlockPos().down()).getBlock();
+        if (block.is(Blocks.WATER) || bottom.is(Blocks.GRASS_PATH))
+            return;
+        if (block.is(Blocks.GRASS))
+            mc.interactionManager.attackBlock(entity.getBlockPos(), Direction.DOWN);
+        LivingEntity animal = (LivingEntity) entity;
+
+        if (animal.getHealth() < 1) {
+            mc.interactionManager.attackBlock(entity.getBlockPos(), Direction.DOWN);
+            mc.interactionManager.attackBlock(entity.getBlockPos().west(), Direction.DOWN);
+            mc.interactionManager.attackBlock(entity.getBlockPos().east(), Direction.DOWN);
+            mc.interactionManager.attackBlock(entity.getBlockPos().north(), Direction.DOWN);
+            mc.interactionManager.attackBlock(entity.getBlockPos().south(), Direction.DOWN);
+        } else {
+            if (ticks >= tickInterval.get()) {
+                mc.interactionManager.interactBlock(mc.player, mc.world, Hand.MAIN_HAND, new BlockHitResult(
+                    entity.getPos().subtract(new Vec3d(0, 1, 0)), Direction.UP, entity.getBlockPos().down(), false));
+                ticks = 0;
+            }
+
+        }
+
+        mc.player.inventory.selectedSlot = preSlot;
+    }
+}

src/main/java/cloudburst/rejects/modules/RenderInvisible.java

@@ -0,0 +1,12 @@
+package cloudburst.rejects.modules;
+
+import cloudburst.rejects.RejectCategory;
+import minegame159.meteorclient.modules.Module;
+
+public class RenderInvisible extends Module {
+
+    public RenderInvisible() {
+        super(RejectCategory.Rejects, "render-invisible", "Renders invisible entities.");
+    }
+    
+}