Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
Skins
  • Light
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Default (No Skin)
  • No Skin
Collapse

LiquidBounce Forum

YounKooY

YounKoo

@YounKoo
About
Posts
19
Topics
13
Shares
0
Groups
0
Followers
3
Following
0

Posts

Recent Best Controversial

  • A SelfInfo as Akrien Client
    YounKooY YounKoo

    @ukvaporwaves thx

    Kotlin/Java

  • A SelfInfo as Akrien Client
    YounKooY YounKoo

    @P1ayerLk_-0 thx

    Kotlin/Java

  • Who has liquidbounce 1.12.2 b2 src?
    YounKooY YounKoo

    @kawaiinekololis thx

    General

  • Who has liquidbounce 1.12.2 b2 src?
    YounKooY YounKoo

    @lol_-I_know_that_you_see_this Thank you very much indeed

    General

  • A SelfInfo as Akrien Client
    YounKooY YounKoo

    I'm using novoline's font system, you can use LiquidBounce instead, note that novoline's font size is twice as large as Liquidbounce's

    Effect image:2022-11-24_22.53.11.png

    Code:

    @ElementInfo(name = "SelfInfo")
    public class SelfInfo extends Element {
        //code by younkoo(littledye or 情染)
        public static IntegerValue rRed = new IntegerValue("Red", 0, 0, 255);
        public static IntegerValue rGreen = new IntegerValue("Green", 0, 0, 255);
        public static IntegerValue rBlue = new IntegerValue("Blue", 0, 0, 255);
    
        //fix jitter
        public IntegerValue indx = new IntegerValue("noting",120,0,1000);
        public IntegerValue indy = new IntegerValue("noting2",80,0,1000);
    
        public static Color mainColor() {
            return new Color(rRed.get(), rGreen.get(), rBlue.get());
        }
    
        private double armorBarWidth;
    
        private double hurttimeBarWidth;
    
        private double bpsBarWidth;
    
        private double healthBarWidth;
    
        public int x2 = indx.get(), y3 = indy.get();
    
        TimerUtil timerHelper = new TimerUtil();
    
        ScaledResolution sr = new ScaledResolution(mc);
        final float scaledWidth = sr.getScaledWidth();
        final float scaledHeight = sr.getScaledHeight();
    
        //code by younkoo(littledye or 情染)
        //code by younkoo(littledye or 情染)
        //code by younkoo(littledye or 情染)
    
        @Override
        public Border drawElement(float partialTicks) {
            double prevZ = mc.thePlayer.posZ - mc.thePlayer.prevPosZ;
            double prevX = mc.thePlayer.posX - mc.thePlayer.prevPosX;
            double lastDist = Math.sqrt(prevX * prevX + prevZ * prevZ);
            double currSpeed = lastDist * 15.3571428571D / 4;
    
            final float xX = scaledWidth / 2.0f -x2;
            final float yX = scaledHeight / 2.0f + y3;
            VisualBase.drawNewRect(xX + 4.5, yX  + 196.5 - 405, xX + 100.5, yX + 246.5 - 408, new Color(11, 11, 11, 255).getRGB());
            VisualBase.drawNewRect(xX + 5, yX + 198 - 405, xX + 100, yX + 246 - 408, new Color(28, 28, 28, 255).getRGB());
            VisualBase.drawNewRect(xX + 5, yX  + 198 - 405, xX + 100, yX + 208 - 408, new Color(21, 19, 20, 255).getRGB());
            VisualBase.drawNewRect(xX + 44, yX + 210 - 406, xX + 95, yX + 213.5 - 406, new Color(41, 41, 41, 255).getRGB());
            VisualBase.drawNewRect(xX + 44, yX + 219 - 406, xX + 95, yX + 222.5 - 406, new Color(41, 41, 41, 255).getRGB());
            VisualBase.drawNewRect(xX + 44, yX + 228 - 406, xX + 95, yX + 231.5 - 406, new Color(41, 41, 41, 255).getRGB());
            VisualBase.drawNewRect(xX + 44, yX + 237 - 406, xX + 95, yX + 240.5 - 406, new Color(41, 41, 41, 255).getRGB());
            VisualBase.drawNewRect(xX + 5, yX + 197 - 405, xX + 100, yX + 198 - 405, mainColor().getRGB());
    
            Fonts.SF.SF_14.SF_14.drawString("Indicators", xX + 37, yX + 202 - 406, -1);
    
            // armor
            final float armorValue = mc.thePlayer.getTotalArmorValue();
            double armorPercentage = armorValue / 20;
            armorPercentage = MathHelper.clamp_double(armorPercentage, 0.0, 1.0);
    
            final double armorWidth = 51 * armorPercentage;
            this.armorBarWidth = AnimationHelper.animate(armorWidth, this.armorBarWidth, 0.0229999852180481);
            VisualUtils.drawRect(xX + 44, yX + 210 - 406, xX + 44 + this.armorBarWidth, yX + 213.5 - 406, mainColor().getRGB());
    
            Fonts.SF.SF_14.SF_14.drawString("Armor", xX + 8, yX + 211 - 406, -1);
    
            // HurtTime
            double hurttimePercentage = MathHelper.clamp_double(mc.thePlayer.hurtTime, 0.0, 0.6);
            final double hurttimeWidth = 51.0 * hurttimePercentage;
            this.hurttimeBarWidth = AnimationHelper.animate(hurttimeWidth, this.hurttimeBarWidth, 0.0429999852180481);
            VisualUtils.drawRect(xX + 44, yX + 219 - 406, xX + 44 + this.hurttimeBarWidth, yX + 222.5 - 406, mainColor().getRGB());
    
            Fonts.SF.SF_14.SF_14.drawString("HurtTime", xX + 8, yX + 220 - 406, -1);
    
            // HurtTime
            double bpsPercentage = MathHelper.clamp_double(currSpeed, 0.0, 1.0);
            final double bpsBarWidth = 51.0 * bpsPercentage;
            this.bpsBarWidth = AnimationHelper.animate(bpsBarWidth, this.bpsBarWidth, 0.0329999852180481);
    
            VisualUtils.drawRect(xX + 44, yX + 228 - 406, xX + 44 + this.bpsBarWidth, yX + 231.5 - 406, mainColor().getRGB());
    
            Fonts.SF.SF_14.SF_14.drawString("BPS", xX + 8, yX + 229 - 406, -1);
    
            // HurtTime
            final float health = mc.thePlayer.getHealth();
            double hpPercentage = health / mc.thePlayer.getMaxHealth();
            hpPercentage = MathHelper.clamp_double(hpPercentage, 0.0, 1.0);
            final double hpWidth = 51.0 * hpPercentage;
            final String healthStr = String.valueOf((int) mc.thePlayer.getHealth() / 2.0f);
    
            if (timerHelper.hasReached(15L)) {
                this.healthBarWidth = AnimationHelper.animate(hpWidth, this.healthBarWidth, 0.2029999852180481);
                timerHelper.reset();
            }
    
            VisualUtils.drawRect(xX + 44, yX + 237 - 406, xX + 44 + this.healthBarWidth, yX + 240.5 - 406, mainColor().getRGB());
    
            Fonts.SF.SF_14.SF_14.drawString("HP", xX + 8, yX + 238 - 406, -1);
            return new Border(98,-8,194,39);
        }
    
    }
    

    DrawNewRect

    public static void drawNewRect(double left, double top, double right, double bottom, int color) {
            if (left < right) {
                double i = left;
                left = right;
                right = i;
            }
            if (top < bottom) {
                double j = top;
                top = bottom;
                bottom = j;
            }
            float f3 = (float)(color >> 24 & 0xFF) / 255.0f;
            float f = (float)(color >> 16 & 0xFF) / 255.0f;
            float f1 = (float)(color >> 8 & 0xFF) / 255.0f;
            float f2 = (float)(color & 0xFF) / 255.0f;
            Tessellator tessellator = Tessellator.getInstance();
            WorldRenderer vertexbuffer = tessellator.getWorldRenderer();
            GlStateManager.enableBlend();
            GlStateManager.disableTexture2D();
            GlStateManager.tryBlendFuncSeparate(770, 771, 0, 1);
            GlStateManager.color(f, f1, f2, f3);
            vertexbuffer.begin(7, DefaultVertexFormats.POSITION);
            vertexbuffer.pos(left, bottom, 0.0).endVertex();
            vertexbuffer.pos(right, bottom, 0.0).endVertex();
            vertexbuffer.pos(right, top, 0.0).endVertex();
            vertexbuffer.pos(left, top, 0.0).endVertex();
            tessellator.draw();
            GlStateManager.enableTexture2D();
            GlStateManager.disableBlend();
        }
    

    Animate

    public static double animate(double target, double current, double speed) {
            boolean larger;
            boolean bl = larger = target > current;
            if (speed < 0.0) {
                speed = 0.0;
            } else if (speed > 1.0) {
                speed = 1.0;
            }
            double dif = Math.max(target, current) - Math.min(target, current);
            double factor = dif * speed;
            if (factor < 0.1) {
                factor = 0.1;
            }
            current = larger ? (current += factor) : (current -= factor);
            return current;
        }
    
    Kotlin/Java

  • NCP Tower
    YounKooY YounKoo

    can bypass BlocksMC

    private int towerTicks;
    
    @Override
        public void onEnable() {
            towerTicks = 0;
        }
    
    if(mc.thePlayer.onGround) {
                        towerTicks = 0;
                    }
    
                    if(mc.gameSettings.keyBindJump.isKeyDown() && !MovementUtils.isMoving() && !(mc.theWorld.getBlockState(new BlockPos(mc.thePlayer.posX, mc.thePlayer.posY - 1.1, mc.thePlayer.posZ)).getBlock() instanceof BlockAir)) {
                        int IntPosY = (int) mc.thePlayer.posY;
                        if(mc.thePlayer.posY - IntPosY < 0.05) {
                            mc.thePlayer.setPosition(mc.thePlayer.posX, IntPosY, mc.thePlayer.posZ);
                            mc.thePlayer.motionY = 0.42;
                            towerTicks = 1;
                        } else if(towerTicks == 1) {
                            mc.thePlayer.motionY = 0.34;
                            towerTicks++;
                        } else if(towerTicks == 2) {
                            mc.thePlayer.motionY = 0.25;
                            towerTicks++;
                        }
                    }
    

    Throw it in your tower

    code form vestige2.0 October code

    Kotlin/Java

  • Azura-X's Watchdog Speed
    YounKooY YounKoo

    Watchdog Fast

    public class WatchdogFast extends SpeedMode {
        public WatchdogFast() {
            super("WatchdogFast");
        }
        private double speed;
        private int ticks;
    
        @Override
        public void onEnable() {
            speed = 0;
            ticks = 0;
        }
    
        @Override
        public void onDisable() {
            speed = 0;
            ticks = 0;
        }
    
        @Override
        public void onMotion(MotionEvent event) {
            if (mc.thePlayer.onGround) {
                if (MoveUtil.isMoving()) {
                    if (mc.gameSettings.keyBindJump.isKeyDown()) return;
                    mc.thePlayer.jump();
                    BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.5);
                    if (ticks > 0) BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.77);
                    ticks++;
                }
            } else if (MoveUtil.isMoving()) {
                if (mc.thePlayer.motionY > 0.05 && mc.thePlayer.motionY < 0.15) mc.thePlayer.motionY = (float) -0.01;
                if (mc.thePlayer.motionY > -0.07 && mc.thePlayer.motionY < 0.) mc.thePlayer.motionY = (float) -0.09;
            }
            if (!MoveUtil.isMoving()) speed = 0;
        }
    
        @Override
        public void onUpdate() {
    
        }
    
        @Override
        public void onMove(MoveEvent event) {
            if (!MoveUtil.isMoving() || mc.thePlayer.isCollidedHorizontally) speed = 0;
            BhopHelper.setSpeed(MoveUtil.isMoving() ? Math.max(BhopHelper.getBaseSpeed(), MoveUtil.getSpeed()) : 0, event);
        }
    }
    

    Watchdog Low

    public class WatchdogLow extends SpeedMode {
        public WatchdogLow() {
            super("WatchdogLow");
        }
    
        private double speed;
        private int ticks;
    
        @Override
        public void onEnable() {
            speed = 0;
            ticks = 0;
        }
    
        @Override
        public void onDisable() {
            speed = 0;
            ticks = 0;
        }
    
        @Override
        public void onMotion(MotionEvent event) {
            event.setYaw((float) Math.toDegrees(MoveUtil.getDirection()));
            boolean doLowHop = !this.mc.thePlayer.isPotionActive(Potion.jump) &&
                    this.mc.thePlayer.fallDistance <= 0.75F &&
                    !this.mc.thePlayer.isCollidedHorizontally;
            if (mc.thePlayer.onGround) {
                if (MoveUtil.isMoving()) {
                    mc.thePlayer.jump();
                    if (!this.mc.thePlayer.isPotionActive(Potion.jump)) mc.thePlayer.motionY = 0.4;
                    BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.65);
                    if (ticks > 0 && ticks % 2 == 0) {
                        BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.72);
                    }
                    ticks++;
                }
            } else if (MoveUtil.isMoving() && doLowHop) {
                final double groundOffset = MathHelper.round(this.mc.thePlayer.posY - (int) this.mc.thePlayer.posY, 3, 0.0001);
                if (groundOffset == MathHelper.round(0.4, 3, 0.0001)) {
                    mc.thePlayer.motionY = 0.32;
                } else if (groundOffset == MathHelper.round(0.71, 3, 0.0001)) {
                    mc.thePlayer.motionY = 0.04;
                } else if (groundOffset == MathHelper.round(0.75, 3, 0.0001)) {
                    mc.thePlayer.motionY = -0.2;
                } else if (groundOffset == MathHelper.round(0.55, 3, 0.0001)) {
                    mc.thePlayer.motionY = -0.15;
                } else if (groundOffset == MathHelper.round(0.41, 3, 0.0001)) {
                    mc.thePlayer.motionY = -0.2;
                }
            }
            if (!MoveUtil.isMoving()) speed = 0;
        }
    
        @Override
        public void onUpdate() {
    
        }
    
        @Override
        public void onMove(MoveEvent event) {
            if (!MoveUtil.isMoving() || mc.thePlayer.isCollidedHorizontally) speed = 0;
            final double value = MoveUtil.isMoving() ? Math.max(BhopHelper.getBaseSpeed(), MoveUtil.getSpeed()) : 0,
                    yaw = MoveUtil.getDirection(),
                    x = -Math.sin(yaw) * value,
                    z = Math.cos(yaw) * value;
    
            event.setX(x - (x - event.getX()) * (1.0 - 80F / 100));
            event.setZ(z - (z - event.getZ()) * (1.0 - 80F / 100));
            BhopHelper.setSpeed(MoveUtil.isMoving() ? Math.max(BhopHelper.getBaseSpeed(), MoveUtil.getSpeed()) : 0, event);
        }
    
    }
    

    Watchdog Slow

    public class WatchdogSlow extends SpeedMode {
        public WatchdogSlow() {
            super("WatchdogSlow");
        }
    
        private double speed;
        private int ticks;
    
        @Override
        public void onEnable() {
            speed = 0;
            ticks = 0;
        }
    
        @Override
        public void onDisable() {
            speed = 0;
            ticks = 0;
        }
        
        @Override
        public void onMotion(MotionEvent event) {
            if (mc.thePlayer.onGround) {
                if (MoveUtil.isMoving()) {
                    if (mc.gameSettings.keyBindJump.isKeyDown()) return;
                    mc.thePlayer.jump();
                    switch (ticks) {
                        case 0:
                            BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.63);
                            ticks++;
                            break;
                        case 1:
                            BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.75);
                            ticks++;
                            break;
                        case 2:
                            BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.67);
                            ticks++;
                            break;
                        case 3:
                            BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.74);
                            ticks++;
                            break;
                        case 4:
                        case 5:
                            BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.7);
                            ticks++;
                            break;
                        case 6:
                        case 7:
                            BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.64);
                            ticks++;
                            break;
                        case 8:
                            BhopHelper.setSpeed(BhopHelper.getBaseSpeed() * 1.68);
                            ticks = 0;
                            break;
                    }
                }
            }
            if (!MoveUtil.isMoving()) speed = 0;
        }
    
        @Override
        public void onUpdate() {
    
        }
    
        @Override
        public void onMove(MoveEvent event) {
            if (!MoveUtil.isMoving() || mc.thePlayer.isCollidedHorizontally) speed = 0;
            BhopHelper.setSpeed(MoveUtil.isMoving() ? Math.max(BhopHelper.getBaseSpeed(), MoveUtil.getSpeed()) : 0, event);
        }
        
    }
    

    My BhopHelper

    public class BhopHelper extends MinecraftInstance {
        public static final double JUMP_MOTION = 0.41999998688698;
    
        public static void setSpeed(double value, MoveEvent e) {
            double yaw = getDirection();
            double x = -Math.sin(yaw) * value;
            double z = Math.cos(yaw) * value;
            e.setX(x);
            e.setZ(z);
        }
        public static float getBaseSpeed() {
            float baseSpeed = mc.thePlayer.capabilities.getWalkSpeed() * 2.873f;
            if (mc.thePlayer.isPotionActive(Potion.moveSpeed)) {
                final int ampl = mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getAmplifier();
                baseSpeed *= 1.0 + (0.2 * ampl);
            }
            return baseSpeed;
        }
    
        public static double getBaseMoveSpeed() {
            double speed = 0.2873;
            if (mc.thePlayer.isPotionActive(Potion.moveSpeed)) {
                int amplifier = mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getAmplifier();
                speed *= 1.0 + 0.2 * (amplifier + 1);
            }
            return speed;
        }
        public static void strafe() {
            strafe(getHorizontalMotion());
        }
    
        public static void strafe(MoveEvent event) {
            strafe(event, getHorizontalMotion());
        }
    
        public static void strafe(double speed) {
            float direction = (float) Math.toRadians(getPlayerDirection());
    
            if (isMoving()) {
                mc.thePlayer.motionX = -Math.sin(direction) * speed;
                mc.thePlayer.motionZ = Math.cos(direction) * speed;
            } else {
                mc.thePlayer.motionX = mc.thePlayer.motionZ = 0;
            }
        }
    
        public static float[] getRotations(EntityLivingBase entity) {
            double deltaX = entity.posX + (entity.posX - entity.lastTickPosX) - mc.thePlayer.posX,
                    deltaY = entity.posY - 3.5 + entity.getEyeHeight() - mc.thePlayer.posY + mc.thePlayer.getEyeHeight(),
                    deltaZ = entity.posZ + (entity.posZ - entity.lastTickPosZ) - mc.thePlayer.posZ,
                    distance = Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaZ, 2));
    
            float yaw = (float) Math.toDegrees(-Math.atan(deltaX / deltaZ)),
                    pitch = (float) -Math.toDegrees(Math.atan(deltaY / distance));
    
            if(deltaX < 0 && deltaZ < 0) {
                yaw = (float) (90 + Math.toDegrees(Math.atan(deltaZ / deltaX)));
            }else if(deltaX > 0 && deltaZ < 0) {
                yaw = (float) (-90 + Math.toDegrees(Math.atan(deltaZ / deltaX)));
            }
    
            return new float[] {yaw, pitch};
        }
    
        public static void strafe(MoveEvent event, double speed) {
            float direction;
    
            KillAura killaura = (KillAura) LiquidBounce.moduleManager.getModule(KillAura.class);
            TargetStrafe targetStrafe = (TargetStrafe) LiquidBounce.moduleManager.getModule(TargetStrafe.class);
    
            if(killaura.getState() && killaura.getTarget() != null && targetStrafe.getState()) {
                if(!isBlockUnder() || mc.thePlayer.isCollidedHorizontally) {
                    targetStrafe.direction = !targetStrafe.direction;
                }
    
                if(mc.thePlayer.getDistanceToEntity(killaura.getTarget()) >= targetStrafe.getRadiusValue().get()) {
                    direction = getRotations(killaura.getTarget())[0];
                } else {
                    direction = getRotations(killaura.getTarget())[0] + (targetStrafe.direction ? 91 - mc.thePlayer.getDistanceToEntity(killaura.getTarget()) * 3 : -91 + mc.thePlayer.getDistanceToEntity(killaura.getTarget()) * 3);
                }
    
                direction = (float) Math.toRadians(direction);
            } else {
                direction = (float) Math.toRadians(getPlayerDirection());
            }
    
            if (isMoving()) {
                event.setX(mc.thePlayer.motionX = -Math.sin(direction) * speed);
                event.setZ(mc.thePlayer.motionZ = Math.cos(direction) * speed);
            } else {
                event.setX(mc.thePlayer.motionX = 0);
                event.setZ(mc.thePlayer.motionZ = 0);
            }
        }
    
        public static float getPlayerDirection() {
            float direction = mc.thePlayer.rotationYaw;
    
            if (mc.thePlayer.moveForward > 0) {
                if (mc.thePlayer.moveStrafing > 0) {
                    direction -= 45;
                } else if (mc.thePlayer.moveStrafing < 0) {
                    direction += 45;
                }
            } else if (mc.thePlayer.moveForward < 0) {
                if (mc.thePlayer.moveStrafing > 0) {
                    direction -= 135;
                } else if (mc.thePlayer.moveStrafing < 0) {
                    direction += 135;
                } else {
                    direction -= 180;
                }
            } else {
                if (mc.thePlayer.moveStrafing > 0) {
                    direction -= 90;
                } else if (mc.thePlayer.moveStrafing < 0) {
                    direction += 90;
                }
            }
    
            return direction;
        }
    
        public static double getHorizontalMotion() {
            return Math.hypot(mc.thePlayer.motionX, mc.thePlayer.motionZ);
        }
    
        public static boolean isMoving() {
            return mc.thePlayer.moveForward != 0 || mc.thePlayer.moveStrafing != 0;
        }
    
        public static float setFriction(float speed, float friction) {
            float percent = friction;
            float value = speed / 100.0F * percent;
            return value;
        }
    
        public static void setSpeed(MoveEvent moveEvent, double moveSpeed, float yaw, double forward, double strafe) {
            if (forward != 0.0D) {
                if (strafe > 0.0D) {
                    yaw += ((forward > 0.0D) ? -45 : 45);
                } else if (strafe < 0.0D) {
                    yaw += ((forward > 0.0D) ? 45 : -45);
                }
                strafe = 0.0D;
                if (forward > 0.0D) {
                    forward = 1.0D;
                } else if (forward < 0.0D) {
                    forward = -1.0D;
                }
            }
            if (strafe > 0.0D) {
                strafe = 1.0D;
            } else if (strafe < 0.0D) {
                strafe = -1.0D;
            }
            double mx = Math.cos(Math.toRadians((yaw + 90.0F)));
            double mz = Math.sin(Math.toRadians((yaw + 90.0F)));
            moveEvent.setX(forward * moveSpeed * mx + strafe * moveSpeed * mz);
            moveEvent.setZ(forward * moveSpeed * mz - strafe * moveSpeed * mx);
        }
    
        public static void setSpeed(double moveSpeed) {
            float rotationYaw = mc.thePlayer.rotationYaw;
            MovementInput movementInput = mc.thePlayer.movementInput;
            double strafe = movementInput.moveStrafe;
            MovementInput movementInput2 = mc.thePlayer.movementInput;
            setSpeed(moveSpeed, rotationYaw, strafe, movementInput.moveForward);
        }
    
        public static void setSpeed(double moveSpeed, float yaw, double strafe, double forward) {
            if (forward != 0.0D) {
                if (strafe > 0.0D) {
                    yaw += ((forward > 0.0D) ? -45 : 45);
                } else if (strafe < 0.0D) {
                    yaw += ((forward > 0.0D) ? 45 : -45);
                }
                strafe = 0.0D;
                if (forward > 0.0D) {
                    forward = 1.0D;
                } else if (forward < 0.0D) {
                    forward = -1.0D;
                }
            }
            if (strafe > 0.0D) {
                strafe = 1.0D;
            } else if (strafe < 0.0D) {
                strafe = -1.0D;
            }
            double mx = Math.cos(Math.toRadians((yaw + 90.0F)));
            double mz = Math.sin(Math.toRadians((yaw + 90.0F)));
            mc.thePlayer.motionX = forward * moveSpeed * mx + strafe * moveSpeed * mz;
            mc.thePlayer.motionZ = forward * moveSpeed * mz - strafe * moveSpeed * mx;
        }
    }
    

    My MathHelper

    public class MathHelper {
        public static double getRandom_double(double min, double max) {
            if (min > max) return min;
            Random RANDOM = new Random();
            return RANDOM.nextDouble() * (max - min) + min;
        }
    
        public static float getRandom_float(float min, float max) {
            if (min > max) return min;
            Random RANDOM = new Random();
            return RANDOM.nextFloat() * (max - min) + min;
        }
    
        public static long getRandom_long(long min, long max) {
            if (min > max) return min;
            Random RANDOM = new Random();
            return RANDOM.nextLong() * (max - min) + min;
        }
    
        public static int getRandom_int(int min, int max) {
            if (min > max) return min;
            Random RANDOM = new Random();
            return RANDOM.nextInt(max) + min;
        }
    
        public static byte getRandom_byte(byte min, byte max) {
            if (min > max) return min;
            Random RANDOM = new Random();
            return (byte) (RANDOM.nextInt(max) + min);
        }
    
    
        public static double getDifference(double base, double yaw) {
            final double bigger;
            if (base >= yaw)
                bigger = base - yaw;
            else
                bigger = yaw - base;
            return bigger;
        }
    
        public static float getDifference(float base, float yaw) {
            float bigger;
            if (base >= yaw)
                bigger = base - yaw;
            else
                bigger = yaw - base;
            return bigger;
        }
    
        public static long getDifference(long base, long yaw) {
            long bigger;
            if (base >= yaw)
                bigger = base - yaw;
            else
                bigger = yaw - base;
    
            return bigger;
        }
    
        public static double round(double value, int scale, double inc) {
            final double halfOfInc = inc / 2.0;
            final double floored = Math.floor(value / inc) * inc;
    
            if (value >= floored + halfOfInc)
                return new BigDecimal(Math.ceil(value / inc) * inc)
                        .setScale(scale, RoundingMode.HALF_UP)
                        .doubleValue();
            else return new BigDecimal(floored)
                    .setScale(scale, RoundingMode.HALF_UP)
                    .doubleValue();
        }
    
    }
    

    MoveUtil

    public class MoveUtil {
    
        public void strafe(MoveEvent event) {
            strafe(event, getSpeed());
        }
    
        public static void strafe(MoveEvent moveEvent, double movementSpeed) {
            if (mc.thePlayer.movementInput.moveForward > 0.0) {
                mc.thePlayer.movementInput.moveForward = (float) 1.0;
            } else if (mc.thePlayer.movementInput.moveForward < 0.0) {
                mc.thePlayer.movementInput.moveForward = (float) -1.0;
            }
    
            if (mc.thePlayer.movementInput.moveStrafe > 0.0) {
                mc.thePlayer.movementInput.moveStrafe = (float) 1.0;
            } else if (mc.thePlayer.movementInput.moveStrafe < 0.0) {
                mc.thePlayer.movementInput.moveStrafe = (float) -1.0;
            }
    
            if (mc.thePlayer.movementInput.moveForward == 0.0 && mc.thePlayer.movementInput.moveStrafe == 0.0) {
                mc.thePlayer.motionX = 0.0;
                mc.thePlayer.motionZ = 0.0;
            }
    
            if (mc.thePlayer.movementInput.moveForward != 0.0 && mc.thePlayer.movementInput.moveStrafe != 0.0) {
                mc.thePlayer.movementInput.moveForward *= ApacheMath.sin(0.6398355709958845);
                mc.thePlayer.movementInput.moveStrafe *= ApacheMath.cos(0.6398355709958845);
            }
    
            if (moveEvent != null) {
                moveEvent.setX(mc.thePlayer.motionX = mc.thePlayer.movementInput.moveForward * movementSpeed * -ApacheMath.sin(ApacheMath.toRadians(mc.thePlayer.rotationYaw))
                        + mc.thePlayer.movementInput.moveStrafe * movementSpeed * ApacheMath.cos(ApacheMath.toRadians(mc.thePlayer.rotationYaw)));
                moveEvent.setZ(mc.thePlayer.motionZ = mc.thePlayer.movementInput.moveForward * movementSpeed * ApacheMath.cos(ApacheMath.toRadians(mc.thePlayer.rotationYaw))
                        - mc.thePlayer.movementInput.moveStrafe * movementSpeed * -ApacheMath.sin(ApacheMath.toRadians(mc.thePlayer.rotationYaw)));
            } else {
                mc.thePlayer.motionX = mc.thePlayer.movementInput.moveForward * movementSpeed * -ApacheMath.sin(ApacheMath.toRadians(mc.thePlayer.rotationYaw))
                        + mc.thePlayer.movementInput.moveStrafe * movementSpeed * ApacheMath.cos(ApacheMath.toRadians(mc.thePlayer.rotationYaw));
                mc.thePlayer.motionZ = mc.thePlayer.movementInput.moveForward * movementSpeed * ApacheMath.cos(ApacheMath.toRadians(mc.thePlayer.rotationYaw))
                        - mc.thePlayer.movementInput.moveStrafe * movementSpeed * -ApacheMath.sin(ApacheMath.toRadians(mc.thePlayer.rotationYaw));
            }
        }
    
        public static boolean isBlockUnderneath(BlockPos pos) {
            for (int k = 0; k < pos.getY() + 1; k++) {
                if (mc.theWorld.getBlockState(new BlockPos(pos.getX(), k, pos.getZ())).getBlock().getMaterial() != Material.air) {
                    return true;
                }
            }
            return false;
        }
        public static float getSpeed2() {
            return (float) Math.sqrt(mc.thePlayer.motionX * mc.thePlayer.motionX + mc.thePlayer.motionZ * mc.thePlayer.motionZ);
        }
    
        private static final Minecraft mc = Minecraft.getMinecraft();
        public static Float movementYaw;
    
    
        public static double getMotion(final EntityLivingBase player) {
            return MathUtils.distance(player.prevPosX, player.prevPosZ, player.posX, player.posZ);
        }
    
        public static void setSpeed(final MoveEvent moveEvent, final double moveSpeed) {
            setSpeed(moveEvent, moveSpeed, mc.thePlayer.rotationYaw, mc.thePlayer.movementInput.moveStrafe, mc.thePlayer.movementInput.moveForward);
        }
    
        public static void setSpeed(final MoveEvent moveEvent, final double moveSpeed, final float pseudoYaw, final double pseudoStrafe, final double pseudoForward) {
            double forward = pseudoForward;
            double strafe = pseudoStrafe;
            float yaw = pseudoYaw;
    
            if (forward != 0.0) {
                if (strafe > 0.0) {
                    yaw += ((forward > 0.0) ? -25 : 25);
                } else if (strafe < 0.0) {
                    yaw += ((forward > 0.0) ? 25 : -25);
                }
                strafe = 0.0F;
                if (forward > 0.0) {
                    forward = 0.1F;
                } else if (forward < 0.0) {
                    forward = -0.1F;
                }
            }
    
            if (strafe > 0.0) {
                strafe = 1F;
            } else if (strafe < 0.0) {
                strafe = -1F;
            }
            double mx = Math.cos(Math.toRadians((yaw + 90.0F)));
            double mz = Math.sin(Math.toRadians((yaw + 90.0F)));
            moveEvent.setX((forward * moveSpeed * mx + strafe * moveSpeed * mz));
            moveEvent.setZ((forward * moveSpeed * mz - strafe * moveSpeed * mx));
    
        }
    
        public static void setSpeed( MoveEvent e, double speed, float forward, float strafing, float yaw) {
            boolean reversed = forward < 0.0f;
            float strafingYaw = 90.0f *
                    (forward > 0.0f ? 0.5f : reversed ? -0.5f : 1.0f);
    
            if (reversed)
                yaw += 180.0f;
            if (strafing > 0.0f)
                yaw -= strafingYaw;
            else if (strafing < 0.0f)
                yaw += strafingYaw;
    
            double x = Math.cos(Math.toRadians(yaw + 90.0f));
            double z = Math.cos(Math.toRadians(yaw));
    
            e.setX(x * speed);
            e.setZ(z * speed);
        }
    
        public static void setSpeed(double moveSpeed, float yaw, double strafe, double forward) {
    
            double fforward = forward;
            double sstrafe = strafe;
            float yyaw = yaw;
            if (forward != 0.0D) {
                if (strafe > 0.0D) {
                    yaw += ((forward > 0.0D) ? -45 : 45);
                } else if (strafe < 0.0D) {
                    yaw += ((forward > 0.0D) ? 45 : -45);
                }
                strafe = 0.0D;
                if (forward > 0.0D) {
                    forward = 1.0D;
                } else if (forward < 0.0D) {
                    forward = -1.0D;
                }
            }
            if (strafe > 0.0D) {
                strafe = 1.0D;
            } else if (strafe < 0.0D) {
                strafe = -1.0D;
            }
            double mx = Math.cos(Math.toRadians((yaw + 90.0F)));
            double mz = Math.sin(Math.toRadians((yaw + 90.0F)));
            mc.thePlayer.motionX = forward * moveSpeed * mx + strafe * moveSpeed * mz;
            mc.thePlayer.motionZ = forward * moveSpeed * mz - strafe * moveSpeed * mx;
    
    
        }
    
        public static double getDirection(final float yaw) {
            float rotationYaw = yaw;
    
            if (movementYaw != null) {
                rotationYaw = movementYaw;
            }
    
            if (mc.thePlayer.moveForward < 0F) rotationYaw += 180F;
    
            float forward = 1F;
    
            if (mc.thePlayer.moveForward < 0F) forward = -0.5F;
            else if (mc.thePlayer.moveForward > 0F) forward = 0.5F;
    
            if (mc.thePlayer.moveStrafing > 0F) rotationYaw -= 90F * forward;
            if (mc.thePlayer.moveStrafing < 0F) rotationYaw += 90F * forward;
    
            return Math.toRadians(rotationYaw);
        }
    
        public static double getAllowedHorizontalDistance() {
            double horizontalDistance;
            boolean useBaseModifiers = false;
    
            if (PlayerUtil.getBlockRelativeToPlayer(0, 0, 0) instanceof BlockWeb) {
                horizontalDistance = 0.105;
            } else if (isInLiquid()) {
                horizontalDistance = 0.115F;
            } else if (mc.thePlayer.isSneaking()) {
                horizontalDistance = 0.3F * 0.221;
            } else {
                horizontalDistance = 0.221;
                useBaseModifiers = true;
            }
    
            if (useBaseModifiers) {
                if (Math.abs(mc.thePlayer.moveForward) >= 0.8F || Math.abs(mc.thePlayer.moveStrafing) >= 0.8F) {
                    horizontalDistance *= 1.3F;
                }
    
                if (mc.thePlayer.isPotionActive(Potion.moveSpeed) && mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getDuration() > 0) {
                    horizontalDistance *= 1 + (0.2 * (mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getAmplifier() + 1));
                }
    
                if (mc.thePlayer.isPotionActive(Potion.moveSlowdown)) {
                    horizontalDistance = 0.29;
                }
            }
    
            final Block below = PlayerUtil.getBlockRelativeToPlayer(0, -1, 0);
            if (below == Blocks.ice || below == Blocks.packed_ice) {
                horizontalDistance *= 2.5F;
            }
    
            return horizontalDistance;
        }
    
        public static boolean isOnGround(final double height) {
            return !mc.theWorld.getCollidingBoundingBoxes(mc.thePlayer, mc.thePlayer.getEntityBoundingBox().offset(0.0, -height, 0.0)).isEmpty();
        }
    
        /**
         * Used to get the players speed
         */
        public static double getSpeed() {
            // nigga hypot heavy
            return Math.hypot(mc.thePlayer.motionX, mc.thePlayer.motionZ);
        }
    
        /**
         * Sets current speed to itself make strafe
         */
        public static  void strafe() {
            strafe(getSpeed());
        }
    
        /**
         * Checks if the player is moving
         */
        public static boolean isMoving() {
            return mc.thePlayer != null && (mc.thePlayer.movementInput.moveForward != 0F || mc.thePlayer.movementInput.moveStrafe != 0F);
        }
    
        public static  void stop() {
            mc.thePlayer.motionX = mc.thePlayer.motionZ = 0;
        }
    
        /**
         * Sets players speed, with floats
         */
        public static  void strafe(final float speed) {
            if (!isMoving()) return;
    
            final double yaw = getDirection();
    
            mc.thePlayer.motionX = -MathHelper.sin((float) yaw) * speed;
            mc.thePlayer.motionZ = MathHelper.cos((float) yaw) * speed;
        }
    
        /**
         * Used to get the players speed, with doubles
         */
        public static void strafe(final double speed) {
            if (!isMoving()) return;
    
            final double yaw = getDirection();
            mc.thePlayer.motionX = -MathHelper.sin((float) yaw) * speed;
            mc.thePlayer.motionZ = MathHelper.cos((float) yaw) * speed;
        }
    
        public static void strafe(final double speed, double yaw) {
            if (!isMoving()) return;
    
            if (Helper.INSTANCE.getMoveYaw() != 0) {
                yaw = Helper.INSTANCE.getMoveYaw();
            }
    
            mc.thePlayer.motionX = -MathHelper.sin((float) yaw) * speed;
            mc.thePlayer.motionZ = MathHelper.cos((float) yaw) * speed;
        }
    
        public static void forward(final double speed) {
            final double yaw = getDirection();
    
            mc.thePlayer.motionX = -Math.sin(yaw) * speed;
            mc.thePlayer.motionZ = Math.cos(yaw) * speed;
        }
    
        public static double moveSpeed() {
            if (mc.gameSettings.keyBindSprint.isKeyDown()) {
                if (mc.thePlayer.isPotionActive(Potion.moveSpeed)) {
                    if (mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getAmplifier() + 1 == 1) {
                        return 0.18386012061481244;
                    } else {
                        return 0.21450346015841276;
                    }
                } else {
                    return 0.15321676228437875;
                }
            } else {
                if (mc.thePlayer.isPotionActive(Potion.moveSpeed)) {
                    if (mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getAmplifier() + 1 == 1) {
                        return 0.14143085686761;
                    } else {
                        return 0.16500264553372018;
                    }
                } else {
                    return 0.11785905094607611;
                }
            }
        }
    
        /**
         * Gets the direction of were the player is looking
         */
        public static double getDirection() {
            float rotationYaw = mc.thePlayer.rotationYaw;
    
            if (mc.thePlayer.moveForward < 0F) rotationYaw += 180F;
    
            float forward = 1F;
    
            if (mc.thePlayer.moveForward < 0F) forward = -0.5F;
            else if (mc.thePlayer.moveForward > 0F) forward = 0.5F;
    
            if (mc.thePlayer.moveStrafing > 0F) rotationYaw -= 90F * forward;
            if (mc.thePlayer.moveStrafing < 0F) rotationYaw += 90F * forward;
    
            return Math.toRadians(rotationYaw);
        }
    
        public static double getDirectionWrappedTo90() {
            float rotationYaw = mc.thePlayer.rotationYaw;
    
            if (mc.thePlayer.moveForward < 0F && mc.thePlayer.moveStrafing == 0F) rotationYaw += 180F;
    
            final float forward = 1F;
    
            if (mc.thePlayer.moveStrafing > 0F) rotationYaw -= 90F * forward;
            if (mc.thePlayer.moveStrafing < 0F) rotationYaw += 90F * forward;
    
            return Math.toRadians(rotationYaw);
        }
    
        /**
         * Used to get base movement speed
         */
        public static double getBaseMoveSpeed() {
            double baseSpeed = 0.2873D;
    
            if (mc.thePlayer.isPotionActive(Potion.moveSpeed))
                baseSpeed *= 1.0D + 0.2D * (mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getAmplifier() + 1);
    
            return baseSpeed;
        }
    
        public static double getBaseMoveSpeedOther() {
            double baseSpeed = 0.2875D;
    
            if (mc.thePlayer.isPotionActive(Potion.moveSpeed))
                baseSpeed *= 1.0D + 0.2D * (mc.thePlayer.getActivePotionEffect(Potion.moveSpeed).getAmplifier() + 1);
    
            return baseSpeed;
        }
    
        public static double getJumpMotion(float motionY) {
            final Potion potion = Potion.jump;
    
            if (mc.thePlayer.isPotionActive(potion)) {
                final int amplifier = mc.thePlayer.getActivePotionEffect(potion).getAmplifier();
                motionY += (amplifier + 1) * 0.1F;
            }
    
            return motionY;
        }
    
        public static double getPredictedMotionY(final double motionY) {
            return (motionY - 0.08) * 0.98F;
        }
    
        public static void setMoveEventSpeed(final MoveEvent moveEvent, final double moveSpeed) {
            setMoveEvent(moveEvent, moveSpeed, mc.thePlayer.rotationYaw, mc.thePlayer.movementInput.moveStrafe, mc.thePlayer.movementInput.moveForward);
        }
    
        // jumps without setting motionY to 0.42F
        // in other words, increases motionX/Z and everything else that the jump method does, allowing a custom motionY
        public static void jumpNoMotionY() {
            double motionY = mc.thePlayer.motionY;
            mc.thePlayer.jump();
            mc.thePlayer.motionY = motionY;
        }
    
        public static Vector2d getMotion(final double moveSpeed) {
            final MovementInput movementInput = mc.thePlayer.movementInput;
    
            double moveForward = movementInput.moveForward;
            double moveStrafe = movementInput.moveStrafe;
    
            double rotationYaw = mc.thePlayer.rotationYaw;
            if (moveForward != 0.0D || moveStrafe != 0.0D) {
                if (moveStrafe > 0) {
                    moveStrafe = 1;
                } else if (moveStrafe < 0) {
                    moveStrafe = -1;
                }
                if (moveForward != 0.0D) {
                    if (moveStrafe > 0.0D) {
                        rotationYaw += moveForward > 0.0D ? -45 : 45;
                    } else if (moveStrafe < 0.0D) {
                        rotationYaw += moveForward > 0.0D ? 45 : -45;
                    }
                    moveStrafe = 0.0D;
                    if (moveForward > 0.0D) {
                        moveForward = 1.0D;
                    } else if (moveForward < 0.0D) {
                        moveForward = -1.0D;
                    }
                }
                rotationYaw *= 0.995;
                final double cos = Math.cos(Math.toRadians(rotationYaw + 90.0F));
                final double sin = Math.sin(Math.toRadians(rotationYaw + 90.0F));
                return new Vector2d(moveForward * moveSpeed * cos
                        + moveStrafe * moveSpeed * sin, moveForward * moveSpeed * sin
                        - moveStrafe * moveSpeed * cos);
            }
            return new Vector2d(0, 0);
        }
    
        public static void setMoveEvent(final MoveEvent moveEvent, final double moveSpeed, final float pseudoYaw, final double pseudoStrafe, final double pseudoForward) {
            double forward = pseudoForward;
            double strafe = pseudoStrafe;
            float yaw = pseudoYaw;
    
            if (forward != 0.0D) {
                if (strafe > 0.0D) {
                    yaw += ((forward > 0.0D) ? -45 : 45);
                } else if (strafe < 0.0D) {
                    yaw += ((forward > 0.0D) ? 45 : -45);
                }
                strafe = 0.0D;
                if (forward > 0.0D) {
                    forward = 1.0D;
                } else if (forward < 0.0D) {
                    forward = -1.0D;
                }
            }
            if (strafe > 0.0D) {
                strafe = 1.0D;
            } else if (strafe < 0.0D) {
                strafe = -1.0D;
            }
            final double mx = Math.cos(Math.toRadians((yaw + 90.0F)));
            final double mz = Math.sin(Math.toRadians((yaw + 90.0F)));
            moveEvent.setX(forward * moveSpeed * mx + strafe * moveSpeed * mz);
            moveEvent.setZ(forward * moveSpeed * mz - strafe * moveSpeed * mx);
        }
    
    }
    

    speed codes form Azura-X : )

    Kotlin/Java

  • Azura-X's Watchdog Crit
    YounKooY YounKoo

    write in motionevent

    if (mc.thePlayer.onGround) {
                                    event.y += 0.003 + PlayerHelper.getWatchdogUnpatchValues()
                                    if (mc.thePlayer.ticksExisted % 2 === 0) event.y += 0.004 + PlayerHelper.getWatchdogUnpatchValues()
                                    event.onGround = mc.thePlayer.motionY > 0 || MathHelper.getDifference(
                                        mc.thePlayer.posY,
                                        mc.thePlayer.lastTickPosY
                                    ) > 0
                                } else if (mc.thePlayer.motionY > 0) {
                                    event.y -= 0.0003 + PlayerHelper.getWatchdogUnpatchValues()
                                    if (mc.thePlayer.ticksExisted % 2 === 0) event.y += 0.0004 + PlayerHelper.getWatchdogUnpatchValues()
                                }
    

    need

    public static double getWatchdogUnpatchValues() {
            double value = 1.0 / System.currentTimeMillis();
            for (int i = 0; i < master.koitoyuu.utils.helper.MathHelper.getRandom_int(4, 20); i++)
                value *= 1.0 / System.currentTimeMillis();
            return value;
        }
    
    Kotlin/Java

  • Who has liquidbounce 1.12.2 b2 src?
    YounKooY YounKoo

    As in the title , I need liquidbounce 1.12.2 b2 src. Because legacy's api It's troublesome. thx

    General

  • I Made A Simple SessionInfo
    YounKooY YounKoo

    @CookieChinese AutoGG Module来自于SpaceKing

    Kotlin/Java

  • I Made A Simple SessionInfo
    YounKooY YounKoo

    @CookieChinese 好的

    Kotlin/Java

  • [Test] Invtave Disabler
    YounKooY YounKoo

    Disabler Code
    PacketUtils Skid From FDPClient

      private final Queue<Packet<?>> linkedQueue = new LinkedBlockingQueue<>();
        private final TimeHelper timer = new TimeHelper();
        private boolean sendAll;
    
    
        @Override
        public void onEnable() {
            this.timer.reset();
            this.linkedQueue.clear();
            this.sendAll = true;
        }
    
        @EventTarget
        public void onUpdate(UpdateEvent event) {
            if (mc.thePlayer == null) {
                return;
            }
    
            if (mc.thePlayer.ticksExisted < 3) {
                this.linkedQueue.clear();
                this.timer.reset();
            }
    
            if (mc.thePlayer != null && mc.thePlayer.ticksExisted < 150) {
                this.sendAll = true;
            }
    
            if (this.sendAll && this.timer.reach(1000L * RandomUtils.nextInt(5, 20))) {
                boolean maxed = this.linkedQueue.size() >= 500;
    
                if (!maxed && !this.linkedQueue.isEmpty()) {
                    Packet<?> packet = this.linkedQueue.poll();
    
                    PacketUtils.sendPacketNoEvent((Packet<INetHandlerPlayServer>) packet);
                }
    
                this.timer.reset();
            }
    
        }
    
        @EventTarget
        public void onPacket(PacketEvent event) {
            if (event.getPacket() instanceof C00PacketKeepAlive) {
                event.cancelEvent();
    
                this.linkedQueue.add(event.getPacket());
            }
    
            if (event.getPacket() instanceof C0FPacketConfirmTransaction) {
                C0FPacketConfirmTransaction packet = (C0FPacketConfirmTransaction) event.getPacket();
    
                if (packet.getUid() > 0 && packet.getUid() < 75) {
                    return;
                }
    
                this.linkedQueue.add(event.getPacket());
                event.cancelEvent();
            }
    
            if (event.getPacket() instanceof C0FPacketConfirmTransaction && mc.thePlayer.ticksExisted % 2 == 0 && !Objects.requireNonNull(LiquidBounce.moduleManager.getModule(Scaffold.class)).isToggled()) {
                event.cancelEvent();
            }
            if (Objects.requireNonNull(LiquidBounce.moduleManager.getModule(Scaffold.class)).isToggled() && event.getPacket() instanceof C0BPacketEntityAction) {
                event.cancelEvent();
            }
    
            if (mc.thePlayer != null && mc.thePlayer.ticksExisted < 8) {
                this.linkedQueue.clear();
                this.timer.reset();
            }
        }
    

    TimeHelper

    package net.ccbluex.liquidbounce.utils;
    
    public class TimeHelper {
        private long prevMS;
    
        public boolean reach(double milliSeconds) {
            return (float) (this.getTime() - this.prevMS) >= milliSeconds;
        }
    
        public void reset() {
            this.prevMS = this.getTime();
        }
    
        private long getTime() {
            return System.nanoTime() / 1000000L;
        }
    
        public long getMs() {
            return (getDelay() / 1000000L) - this.prevMS;
        }
    
        public long getDelay() {
            return System.nanoTime();
        }
    }
    
    TestTestTestTest!!!!!
    Kotlin/Java

  • Hypixel InvMove
    YounKooY YounKoo

    Add in your InvMove Module

    Add this to Switch

        private final BoolValue hypixelBypass = new BoolValue("HypixelBypass", false);
    
    

    This write on Packet Event

            if(hypixelBypass.get()) {
            
                        if (mc.currentScreen != null && !(mc.currentScreen instanceof GuiChat) && mc.currentScreen instanceof GuiInventory) {
            
                            if (event.getPacket() instanceof S08PacketPlayerPosLook) {
            
                                event.cancelEvent();
            
                                ClientUtils.displayChatMessage("Trying Disabled S08...");
            
                                if (event.getPacket() instanceof C0FPacketConfirmTransaction) {
            
                                    event.cancelEvent();
            
                                    ClientUtils.displayChatMessage("Trying Disabled C0F...");
            
                                }
            
                            }
            
                        }
            
                    }
    Kotlin/Java

  • I Made A Simple SessionInfo
    YounKooY YounKoo

    Preview:
    ![SYS{6UUK~$5JZPUB6WB4~9.png

    Code

    @ElementInfo(name = "Session")
    class Session(x: Double = 15.0, y: Double = 10.0, scale: Float = 1F,
                      side: Side = Side(Side.Horizontal.LEFT, Side.Vertical.UP)
    ) : Element(x, y, scale, side) {
    
        private val radiusValue = FloatValue("Radius", 4.25f, 0f, 10f)
        private val bgredValue = IntegerValue("Bg-R", 255, 0, 255)
        private val bggreenValue = IntegerValue("Bg-G", 255, 0, 255)
        private val bgblueValue = IntegerValue("Bg-B", 255, 0, 255)
        private val bgalphaValue = IntegerValue("Bg-Alpha", 150, 0, 255)
    
        val lineValue = BoolValue("Line", true)
        private val redValue = IntegerValue("Line-R", 255, 0, 255)
        private val greenValue = IntegerValue("Line-G", 255, 0, 255)
        private val blueValue = IntegerValue("Line-B", 255, 0, 255)
        private val colorRedValue2 = IntegerValue("Line-R2", 0, 0, 255)
        private val colorGreenValue2 = IntegerValue("Line-G2", 111, 0, 255)
        private val colorBlueValue2 = IntegerValue("Line-B2", 255, 0, 255)
    
        val fontValue = FontValue("Font", Fonts.font35)
    
        override fun drawElement(): Border? {
            val fontRenderer = fontValue.get()
    
            val y2 = fontRenderer.FONT_HEIGHT * 5 + 11.0
            val x2 = 140.0
    
            var durationInMillis: Long = System.currentTimeMillis() - LiquidBounce.playTimeStart
            var second = durationInMillis / 1000 % 60
            var minute = durationInMillis / (1000 * 60) % 60
            var hour = durationInMillis / (1000 * 60 * 60) % 24
            var time: String
            time = String.format("%02dh %02dm %02ds", hour, minute, second)
    
            RenderUtils.drawRoundedRect(-2f, -2f, x2.toFloat(), y2.toFloat(), radiusValue.get(), Color(bgredValue.get(), bggreenValue.get(), bgblueValue.get(), bgalphaValue.get()).rgb)
          if(lineValue.get()) {
              RenderUtils.drawGradientSideways(
                  2.44,
                  fontRenderer.FONT_HEIGHT + 2.5 + 0.0,
                  138.0 + -2.44,
                  fontRenderer.FONT_HEIGHT + 2.5 + 1.16,
                  Color(redValue.get(), greenValue.get(), blueValue.get()).rgb,
                  Color(colorRedValue2.get(), colorGreenValue2.get(), colorBlueValue2.get()).rgb
              )
          }
            val autogg = LiquidBounce.moduleManager.getModule(AutoGG::class.java) as AutoGG?
            fontRenderer.drawCenteredString("Session Info", x2.toFloat() / 2f, 3f, Color.WHITE.rgb, true)
            fontRenderer.drawStringWithShadow("Play Time: $time", 2f, fontRenderer.FONT_HEIGHT + 8f, Color.WHITE.rgb)
            fontRenderer.drawStringWithShadow("Players Killed: " + CombatListener.killCounts,2f , fontRenderer.FONT_HEIGHT * 2 + 8f, Color.WHITE.rgb)
            fontRenderer.drawStringWithShadow("Win: " + autogg!!.getWin(), 2f, fontRenderer.FONT_HEIGHT * 3 + 8f, Color.WHITE.rgb)
            fontRenderer.drawStringWithShadow("Total: " + CombatListener.totalPlayed, 2f, fontRenderer.FONT_HEIGHT * 4 + 8f, Color.WHITE.rgb)
            return Border(-2f, -2f, x2.toFloat(), y2.toFloat())
        }
    }
    

    Needed

    object CombatListener : Listenable {
        var syncEntity: EntityLivingBase? = null
        var killCounts = 0
        var totalPlayed = 0
        var win = 0
        var startTime = System.currentTimeMillis()
    
        @EventTarget
        private fun onAttack(event: AttackEvent) { syncEntity = event.targetEntity as EntityLivingBase?
        }
    
        @EventTarget
        private fun onUpdate(event: UpdateEvent) {
            if(syncEntity != null && syncEntity!!.isDead) {
                ++killCounts
                syncEntity = null
            }
        }
    
        @EventTarget(ignoreCondition = true)
        private fun onPacket(event: PacketEvent) {
            val packet = event.packet
            if (event.packet is C00Handshake) startTime = System.currentTimeMillis()
    
            if (packet is S45PacketTitle) {
                val title = packet.message.formattedText
                if(title.contains("Winner")){
                    win++
                }
                if(title.contains("BedWar")){
                    totalPlayed++
                }
                if(title.contains("SkyWar")){
                    totalPlayed++
                }
            }
        }
    
        override fun handleEvents() = true
    
        init {
            LiquidBounce.eventManager.registerListener(this)
        }
    }
    

    AutoGG

    @ModuleInfo(name = "AutoGG", description = "End a game send GG", category = ModuleCategory.MISC,spacedName = "Auto GG")
    public class AutoGG extends Module {
        private TextValue ggMessage = new TextValue("GGMessage", "[QingRanSense] GG try to buy QingRanSense");
        private TextValue winMessage = new TextValue("WinMessage", "Winner");
        private BoolValue play = new BoolValue("AutoPlay",true);
        private BoolValue disable = new BoolValue("AutoDisable",true);
        private ListValue mode = new ListValue("Mode", new String[] {"BedWars_1v1", "BedWars_2v2", "BedWars_3v3","BedWars_4v4", "SkyWars_Solo", "SkyWars_Solo_Insane","SkyWars_Solo_LuckyBlock","SkyWars_Team","SkyWars_Team_Insane","SkyWars_Team_LuckyBlock","SurivialGames_Solo","SurivialGames_Team","MiniWalls"}, "SkyWars_Solo");
        private IntegerValue delay = new IntegerValue("Delay", 3, 0, 5);
        public static boolean winning = false;
        private TimerUtil timer = new TimerUtil();
        private Timer timer1 = new Timer();
        private double time = 0.0;
        public int win = 0;
        int a;
    
        @Override
        public String getTag() {
            return mode.get();
        }
    
        @EventTarget
        public void onPacket(PacketEvent packetEvent) {
            Packet<?> packet = packetEvent.getPacket();
            if(packet instanceof S02PacketChat) {
                if(((S02PacketChat) packet).getChatComponent().getUnformattedText().contains(winMessage.get())) {
                    mc.thePlayer.sendChatMessage(ggMessage.get());
                    winning = true;
                    int delay1 = delay.get();
                    if(disable.get()) {
                        LiquidBounce.moduleManager.getModule(KillAura.class).setState(false);
                        LiquidBounce.moduleManager.getModule(ChestStealer.class).setState(false);
                        LiquidBounce.moduleManager.getModule(InvManager.class).setState(false);
                        LiquidBounce.moduleManager.getModule(ChestAura.class).setState(false);
                        win += 1;
                        LiquidBounce.hud.addNotification(new Notification("Will Send You to Next Game", Notification.Type.SUCCESS, delay1 * 1000 - 500));
                    }
                    if(play.get()) {
                        this.timer1.schedule(new TimerTask() {
                            public void run() {
                                switch (mode.get()) {
                                    case "BedWars_1v1":
                                        mc.thePlayer.sendChatMessage("/play bedwars_eight_one");
                                        break;
                                    case "BedWars_2v2":
                                        mc.thePlayer.sendChatMessage("/play bedwars_eight_two");
                                        break;
                                    case "BedWars_3v3":
                                        mc.thePlayer.sendChatMessage("/play bedwars_four_three");
                                        break;
                                    case "BedWars_4v4":
                                        mc.thePlayer.sendChatMessage("/play bedwars_four_four");
                                        break;
                                    case "SkyWars_Solo":
                                        mc.thePlayer.sendChatMessage("/play solo_normal");
                                        break;
                                    case "SkyWars_Solo_Insane":
                                        mc.thePlayer.sendChatMessage("/play solo_insane");
                                        break;
                                    case "SkyWars_Solo_LuckyBlock":
                                        mc.thePlayer.sendChatMessage("/play solo_insane_lucky");
                                        break;
                                    case "SkyWars_Team":
                                        mc.thePlayer.sendChatMessage("/play teams_normal");
                                        break;
                                    case "SkyWars_Team_Insane":
                                        mc.thePlayer.sendChatMessage("/play teams_insane");
                                        break;
                                    case "SkyWars_Team_LuckyBlock":
                                        mc.thePlayer.sendChatMessage("/play teams_insane_lucky");
                                        break;
                                    case "SurivialGames_Solo":
                                        mc.thePlayer.sendChatMessage("/play blitz_solo_normal");
                                        break;
                                    case "SurivialGames_Team":
                                        mc.thePlayer.sendChatMessage("/play blitz_teams_normal");
                                        break;
                                    case "MiniWalls":
                                        mc.thePlayer.sendChatMessage("/play arcade_mini_walls");
                                        break;
                                }
                                winning = false;
                            }
                        }, (delay.get().longValue() * 10) * 100);
                    }
                }
            }
        }
    
        @Override
        public void onDisable() {
            a = -40;
            winning = false;
        }
    
        public int getWin(){
            return win;
        }
    
    }
    

    And Add this in your LiquidBounce.kt

        var playTimeStart: Long = 0
    
    Kotlin/Java

  • CubeCraft Disabler
    YounKooY YounKoo

    Code

        KillAura killAura = (KillAura) LiquidBounce.moduleManager.getModule(KillAura.class);
        EntityPlayerSP entityPlayerSP;
    
        @EventTarget
        public void onPacket(PacketEvent event) {
            if(killAura == null) {
                return;
            }
            
            Packet p = event.getPacket();
    
            if (p instanceof C03PacketPlayer.C06PacketPlayerPosLook && !Objects.requireNonNull(LiquidBounce.moduleManager.getModule(Scaffold.class)).isToggled()) {
                event.cancelEvent();
            }
            if (p instanceof C03PacketPlayer && !((C03PacketPlayer)p).isMoving() && !mc.thePlayer.isUsingItem()) {
                event.cancelEvent();
            }
            if (p instanceof C00PacketKeepAlive) {
                event.cancelEvent();
            }
            if (p instanceof C0FPacketConfirmTransaction) {
                event.cancelEvent();
            }
            if (p instanceof C0CPacketInput) {
                event.cancelEvent();
            }
            if (p instanceof C01PacketPing) {
                event.cancelEvent();
            }
            if (killAura.getTarget() == null) {
                assert (p instanceof C0BPacketEntityAction);
                C0BPacketEntityAction c0B = (C0BPacketEntityAction)p;
                if (c0B.getAction().equals(C0BPacketEntityAction.Action.START_SPRINTING)) {
                    if (entityPlayerSP.serverSprintState) {
                        sendPacketSilent(new C0BPacketEntityAction(mc.thePlayer, C0BPacketEntityAction.Action.STOP_SPRINTING));
                        entityPlayerSP.serverSprintState = false;
                    }
                    event.cancelEvent();
                }
            }
        }
    
        public void sendPacketSilent(Packet packet) {
            mc.getNetHandler().getNetworkManager().sendPacket(packet, null, new GenericFutureListener[0]);
        }
    
    Kotlin/Java

  • BlocksMc Disabler
    YounKooY YounKoo

    Code

    EntityPlayerSP entityPlayerSP;
        private final Queue<Packet<?>> packet = new ConcurrentLinkedDeque();
        float voidTP;
    
        @Override
        public void onEnable() {
            if (mc.isSingleplayer()) {
                return;
            }
            if (mc.thePlayer != null) {
                mc.thePlayer.ticksExisted = 0;
            }
        }
        @EventTarget
        public void onPacket(PacketEvent event) {
            Packet p = event.getPacket();
            if (mc.thePlayer.ticksExisted < 250 && p instanceof S07PacketRespawn) {
                this.packet.clear();
                return;
            }
            
            if (p instanceof C0BPacketEntityAction) {
                C0BPacketEntityAction c0B = (C0BPacketEntityAction)p;
                if (c0B.getAction().equals(C0BPacketEntityAction.Action.START_SPRINTING)) {
                    if (entityPlayerSP.serverSprintState) {
                        sendPacketSilent(new C0BPacketEntityAction(mc.thePlayer, C0BPacketEntityAction.Action.STOP_SPRINTING));
                        entityPlayerSP.serverSprintState = false;
                    }
                    event.cancelEvent();
                }
                if (c0B.getAction().equals(C0BPacketEntityAction.Action.STOP_SPRINTING)) {
                    event.cancelEvent();
                }
            }
            if (p instanceof C00PacketKeepAlive || p instanceof C0FPacketConfirmTransaction) {
                packet.add(p);
                event.cancelEvent();
                if (packet.size() > 500) {
                    sendPacketSilent(this.packet.poll());
                }
            }
            if (p instanceof C03PacketPlayer) {
                if (mc.thePlayer.ticksExisted % 50 == 0) {
                    sendPacketUnlogged(new C18PacketSpectate(UUID.randomUUID()));
                    voidTP = (float) MathHelper.getRandomDoubleInRange(new Random(), 0.78, 0.98);
                    sendPacketUnlogged(new C0CPacketInput(voidTP, voidTP, false, false));
                }
                if (mc.thePlayer.ticksExisted % 120 == 0) {
                    voidTP = (float)MathHelper.getRandomDoubleInRange(new Random(), 0.01, 20.0);
                }
            }
        }
    
        public static void sendPacketUnlogged(Packet<? extends INetHandler> packet) {
            mc.getNetHandler().getNetworkManager().sendPacket(packet);
        }
    
        public void sendPacketSilent(Packet packet) {
            mc.getNetHandler().getNetworkManager().sendPacket(packet, null, new GenericFutureListener[0]);
        }
    
    Kotlin/Java

  • Hypixel NoSlow
    YounKooY YounKoo

    Code:

    onMotion

                    case "Hypixel":
                        if (event.isPre()) {
                            final int curSlot = mc.thePlayer.inventory.currentItem;
                            final int spoof = curSlot == 0 ? 1 : -1;
                                mc.getNetHandler().addToSendQueue(new C09PacketHeldItemChange(curSlot + spoof));
    
                            mc.getNetHandler().addToSendQueue(new C09PacketHeldItemChange(curSlot));
                        }
    
                        if (event.isPost()) {
                            mc.getNetHandler().addToSendQueue(new C08PacketPlayerBlockPlacement(mc.thePlayer.inventory.getCurrentItem()));
                        }
                        break;
    

    on Packet

                case "Hypixel":
                    if (event.getPacket() instanceof S30PacketWindowItems)
                        if(mc.thePlayer.isUsingItem()) {
                            event.cancelEvent();
                        }
                    break;
    
    Kotlin/Java

  • Share My UIs && Shader background
    YounKooY YounKoo

    My Simple GuiMainMenu As this

    ![RJ1$~M7]~~B~XF(RP1IX{E.png
    My Shader
    background.zip
    Code

    package master.koitoyuu.ui
    
    import master.koitoyuu.ui.login.LoginButton
    import master.koitoyuu.utils.Translate
    import net.ccbluex.liquidbounce.ui.client.GuiBackground
    import net.ccbluex.liquidbounce.ui.client.GuiModsMenu
    import net.ccbluex.liquidbounce.ui.client.altmanager.GuiAltManager
    import net.ccbluex.liquidbounce.ui.font.Fonts
    import net.minecraft.client.gui.*
    import net.minecraft.client.renderer.GlStateManager
    import net.minecraft.client.resources.I18n
    import net.minecraft.util.ResourceLocation
    import org.lwjgl.opengl.GL11
    import java.awt.Color
    
    class MeMainMenu : GuiScreen(), GuiYesNoCallback {
        var alpha = 255
        private var currentX = 0f
        private var currentY = 0f
        var translate: Translate? = null
        var hue = 0.0f
    
    
        override fun initGui() {
            val defaultHeight = this.height / 4 + 30
            val defaultWidth = this.width / 2 - 60
            val buttonWidth = 120
            val buttonHeight = 20
            this.buttonList.add(LoginButton(0, defaultWidth, defaultHeight, buttonWidth, buttonHeight, "Single Player"))
            this.buttonList.add(LoginButton(1, defaultWidth, defaultHeight + 25, buttonWidth, buttonHeight, "Multi Player"))
            this.buttonList.add(LoginButton(2, defaultWidth, defaultHeight + 50, buttonWidth, buttonHeight, "Alt Manager"))
            this.buttonList.add(LoginButton(3, defaultWidth, defaultHeight + 75, buttonWidth, buttonHeight, "Script Manager"))
            this.buttonList.add(LoginButton(4, defaultWidth, defaultHeight + 100, buttonWidth, buttonHeight, "Back Ground"))
            this.buttonList.add(LoginButton(5, defaultWidth, defaultHeight + 125, buttonWidth, buttonHeight, "Game Options"))
            this.buttonList.add(LoginButton(6, defaultWidth, defaultHeight + 150, buttonWidth, buttonHeight, "Quit Game"))
            translate = Translate(0f, 0f)
            super.initGui()
        }
    
        override fun drawScreen(mouseX: Int, mouseY: Int, partialTicks: Float) {
            val defaultHeight = this.height / 4 + 30
            val defaultWidth = this.width / 2 - 60
    
            //ChangeInfos
            val changes = ArrayList<String>()
            changes.add("#221017")
            changes.add("[+] Add LoginGui")
            changes.add("[+] Add New Menu")
            changes.add("")
    
            drawBackground(0)
            hue += 1f
            if (hue > 255.0f) {
                hue = 0.0f
            }
            translate?.interpolate(width.toFloat(), height.toFloat(), 4.0)
            val xmod2 = width / 2 - (translate!!.x / 2).toDouble()
            val ymod2 = height / 2 - (translate!!.y / 2).toDouble()
            GlStateManager.translate(xmod2, ymod2, 0.0)
            GlStateManager.scale(translate!!.x / width, translate!!.y / height, 1f)
    
            //ClientUpdate
            Fonts.sf40.drawStringWithShadow("Changelog:", 5f, 5f, Color(255, 255, 255, 220).rgb)
            //循环绘制info
            for (i in changes.indices) {
                Fonts.sf35.drawStringWithShadow(changes[i], 5f, 16f + i * 12, Color(255, 255, 255, 220).rgb)
            }
    
            super.drawScreen(mouseX, mouseY, partialTicks)
        }
    
    
        override fun actionPerformed(button: GuiButton) {
            when (button.id) {
                0 -> mc.displayGuiScreen(GuiSelectWorld(this))
                1 -> mc.displayGuiScreen(GuiMultiplayer(this))
                2 -> mc.displayGuiScreen(GuiAltManager(this))
                3 -> mc.displayGuiScreen(GuiModsMenu(this))
                4 -> mc.displayGuiScreen(GuiBackground(this))
                5 -> mc.displayGuiScreen(GuiOptions(this, mc.gameSettings))
                6 -> mc.shutdown()
            }
        }
        override fun keyTyped(typedChar: Char, keyCode: Int) {}
    }
    

    A Simple GuiLogin As this![V99ODWC52S_7@{J3{HL{ZE.png

    My GuiLogin Shader
    loginground.zip

    Codes

    login.zip

    Kotlin/Java
  • Login

  • Login or register to search.
  • First post
    Last post
0
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups