Часть функционала Rotation Hitbox Base Rockstar 2.0

[okiwertik00]

а шо с этим делать ну как запустить все дилда

 

[masussusus]

помогите плиз как мне вобще запустить его или сделать из кода мод

 

[Nepovinka]

Всем привет, решил сделать снап хитбоксы под базу рокстара
В кратце эт не снапы а хиты с норм ротацией под фт, это не перенсос с система! ГПТ код имееться

Пожалуйста, авторизуйтесь для просмотра ссылки.

package moscow.holly.systems.modules.modules.combat;

import com.mojang.blaze3d.systems.RenderSystem;
import moscow.holly.systems.event.EventListener;
import moscow.holly.systems.event.impl.game.AttackEvent;
import moscow.holly.systems.event.impl.player.ClientPlayerTickEvent;
import moscow.holly.systems.event.impl.render.Render3DEvent;
import moscow.holly.systems.modules.api.ModuleCategory;
import moscow.holly.systems.modules.api.ModuleInfo;
import moscow.holly.systems.modules.impl.BaseModule;
import moscow.holly.systems.setting.settings.BooleanSetting;
import moscow.holly.systems.setting.settings.ColorSetting;
import moscow.holly.systems.setting.settings.SelectSetting;
import moscow.holly.systems.setting.settings.SliderSetting;
import moscow.holly.Holly;
import moscow.holly.systems.modules.modules.combat.Aura;
import moscow.holly.utility.colors.ColorRGBA;
import moscow.holly.utility.combat.aura.TargetFinder;
import moscow.holly.utility.rotations.MoveCorrection;
import moscow.holly.utility.rotations.Rotation;
import moscow.holly.utility.rotations.RotationPriority;
import net.minecraft.client.gl.ShaderProgramKeys;
import net.minecraft.client.render.*;
import net.minecraft.client.util.math.MatrixStack;
import net.minecraft.entity.Entity;
import net.minecraft.entity.LivingEntity;
import net.minecraft.util.math.Box;
import net.minecraft.util.math.Vec3d;
import org.joml.Matrix4f;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

@ModuleInfo(name = "Rotating Hitbox", category = ModuleCategory.COMBAT, desc = "Увеличенный хитбокс с ротацией как в Aura-Funtime")
public class RotatingHitbox extends BaseModule {
   
    private static class PerlinNoise {
        private final int[] p = new int[512];
       
        public PerlinNoise(int seed) {
            int[] perm = new int[256];
            for (int i = 0; i < 256; i++) perm[i] = i;
           
            Random r = new Random(seed);
            for (int i = 255; i > 0; i--) {
                int j = r.nextInt(i + 1);
                int t = perm[i];
                perm[i] = perm[j];
                perm[j] = t;
            }
           
            for (int i = 0; i < 256; i++) {
                int v = perm[i] & 255;
                p[i] = v;
                p[i + 256] = v;
            }
        }
       
        private static float fade(float t) {
            return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
        }
       
        private static float lerp(float t, float a, float b) {
            return a + t * (b - a);
        }
       
        private static float grad(int hash, float x, float y, float z) {
            int h = hash & 15;
            float u = h < 8 ? x : y;
            float v = h < 4 ? y : (h == 12 || h == 14 ? x : z);
            return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
        }
       
        public float noise(float x, float y) {
            float z = 0.0f;
            int X = ((int) Math.floor(x)) & 255;
            int Y = ((int) Math.floor(y)) & 255;
            int Z = ((int) Math.floor(z)) & 255;
           
            x = (float) (x - Math.floor(x));
            y = (float) (y - Math.floor(y));
            z = (float) (z - Math.floor(z));
           
            float u = fade(x);
            float v = fade(y);
            float w = fade(z);
           
            int A = p[X] + Y;
            int AA = p[A] + Z;
            int AB = p[A + 1] + Z;
            int B = p[X + 1] + Y;
            int BA = p[B] + Z;
            int BB = p[B + 1] + Z;
           
            return lerp(w,
                lerp(v,
                    lerp(u, grad(p[AA], x, y, z), grad(p[BA], x - 1.0f, y, z)),
                    lerp(u, grad(p[AB], x, y - 1.0f, z), grad(p[BB], x - 1.0f, y - 1.0f, z))),
                lerp(v,
                    lerp(u, grad(p[AA + 1], x, y, z - 1.0f), grad(p[BA + 1], x - 1.0f, y, z - 1.0f)),
                    lerp(u, grad(p[AB + 1], x, y - 1.0f, z - 1.0f), grad(p[BB + 1], x - 1.0f, y - 1.0f, z - 1.0f))));
        }
       
        public float fbm(float x, float y, int octaves, float lacunarity, float gain) {
            float sum = 0.0f;
            float amp = 0.5f;
            float fx = x;
            float fy = y;
           
            for (int i = 0; i < octaves; i++) {
                sum += noise(fx, fy) * amp;
                fx *= lacunarity;
                fy *= lacunarity;
                amp *= gain;
            }
           
            return sum;
        }
    }
   
    private class InternalFTSnapRotation {
       
        private final PerlinNoise perlin = new PerlinNoise(1337);
       
        private static final float NOISE_YAW_MIN = 0.06f;
        private static final float NOISE_YAW_MAX = 0.38f;
        private static final float NOISE_PITCH_MIN = 0.04f;
        private static final float NOISE_PITCH_MAX = 0.22f;
        private static final float NOISE_FREQ_MIN = 0.55f;
        private static final float NOISE_FREQ_MAX = 1.65f;
       
        private float noisePhaseYaw = 0.0f;
        private float noisePhasePitch = 0.0f;
       
        private Vec3d mpCurrent = Vec3d.ZERO;
        private float mpOrbit = 0.0f;
        private long mpLastUpdate = 0L;
        private int mpLastTargetId = Integer.MIN_VALUE;
       
        private float critHeightOffset = 0.0f;
        private long lastAttackTime = 0L;
       
        private float overshootYaw = 0.0f;
        private float overshootPitch = 0.0f;
        private long overshootStartTime = 0L;
        private static final float OVERSHOOT_PROB = 0.25f;
        private static final float OVERSHOOT_MIN = 0.8f;
        private static final float OVERSHOOT_MAX = 2.5f;
        private static final long OVERSHOOT_DURATION = 80;
       
        private float smoothedYaw = 0.0f;
        private float smoothedPitch = 0.0f;
        private long smoothLastTime = 0L;
        private int smoothTargetId = -1;
        private long targetLockTime = 0L;
        private int lastLockedTargetId = -1;
        private float currentSpeedMultiplier = 1.0f;
       
        private boolean savedViewValid = false;
        private float savedYaw = 0.0f;
        private float savedPitch = 0.0f;
        private boolean returnActive = false;
        private long returnStartTime = 0L;
        private float returnYaw = 0.0f;
        private float returnPitch = 0.0f;
        public void notifyTargetChanged(LivingEntity newTarget) {
            if (newTarget == null) {
                lastLockedTargetId = -1;
                overshootYaw = 0.0f;
                overshootPitch = 0.0f;
                return;
            }
           
            int newId = newTarget.getId();
           
            if (lastLockedTargetId != newId) {
                lastLockedTargetId = newId;
                long now = System.currentTimeMillis();
                targetLockTime = now;
               
                currentSpeedMultiplier = rnd(0.65f, 0.95f);
               
                if (ThreadLocalRandom.current().nextFloat() < OVERSHOOT_PROB) {
                    overshootYaw = rnd(OVERSHOOT_MIN, OVERSHOOT_MAX) * (ThreadLocalRandom.current().nextBoolean() ? 1 : -1);
                    overshootPitch = rnd(OVERSHOOT_MIN * 0.6f, OVERSHOOT_MAX * 0.6f) * (ThreadLocalRandom.current().nextBoolean() ? 1 : -1);
                    overshootStartTime = now;
                } else {
                    overshootYaw = 0.0f;
                    overshootPitch = 0.0f;
                }
            }
        }
       
        public void updateSavedView() {
            if (mc.player == null) return;
           
            if (!savedViewValid) {
                savedViewValid = true;
                Rotation currentRotation = Holly.getInstance().getRotationHandler().getCurrentRotation();
                savedYaw = currentRotation.getYaw();
                savedPitch = currentRotation.getPitch();
            }
        }
       
        public void rotateTo(LivingEntity target, boolean attacking) {
            if (mc.player == null || target == null) return;
           
            updateSavedView();
           
            long now = System.currentTimeMillis();
            int tid = target.getId();
           
            if (smoothTargetId == -1) {
                Rotation currentRotation = Holly.getInstance().getRotationHandler().getCurrentRotation();
                smoothedYaw = currentRotation.getYaw();
                smoothedPitch = currentRotation.getPitch();
            }
           
            if (attacking && (now - lastAttackTime) > 400) {
                critHeightOffset = rnd(-0.15f, 0.15f);
                lastAttackTime = now;
            }
           
            float k = 0.035f;
            noisePhaseYaw += k * (0.65f + 0.35f * ((tid * 1103515245) & 255) / 255.0f);
            noisePhasePitch += k * (0.65f + 0.35f * ((tid * 1664525) & 255) / 255.0f);
           
            Vec3d targetPoint = getMultiPoint(target, attacking, now);
           
            Vec3d eyes = mc.player.getEyePos();
            Vec3d direction = targetPoint.subtract(eyes);
           
            double horizontalDistance = Math.sqrt(direction.x * direction.x + direction.z * direction.z);
           
            float targetYaw = (float) Math.toDegrees(Math.atan2(direction.z, direction.x)) - 90.0F;
            float targetPitch = (float) (-Math.toDegrees(Math.atan2(direction.y, horizontalDistance)));
           
            targetYaw = normalizeAngle(targetYaw);
            targetPitch = clamp(targetPitch, -90.0f, 90.0f);
           
            if (smoothTargetId != tid) {
                smoothTargetId = tid;
                smoothLastTime = now;
            }
           
            long dtMs = now - smoothLastTime;
            if (dtMs < 1) dtMs = 1;
            if (dtMs > 120) dtMs = 120;
            smoothLastTime = now;
           
            long timeSinceLock = now - targetLockTime;
            float lockProgress = Math.min(1.0f, timeSinceLock / 1000.0f);
           
            float speedMultiplier = lockProgress * lockProgress * (3.0f - 2.0f * lockProgress);
            speedMultiplier = 0.35f + speedMultiplier * 0.65f;
            speedMultiplier *= currentSpeedMultiplier;
           
            float baseYawSpeed = attacking ? 55.0f : 60.0f;
            float basePitchSpeed = attacking ? 44.0f : 48.0f;
           
            float yawSpeed = baseYawSpeed * speedMultiplier;
            float pitchSpeed = basePitchSpeed * speedMultiplier;
           
            float yawMaxDelta = yawSpeed * ((float) dtMs / 50.0f);
            float pitchMaxDelta = pitchSpeed * ((float) dtMs / 50.0f);
           
            float yawError = normalizeAngle(targetYaw - smoothedYaw);
            float pitchError = targetPitch - smoothedPitch;
           
            smoothedYaw += clamp(yawError, -yawMaxDelta, yawMaxDelta);
            smoothedPitch += clamp(pitchError, -pitchMaxDelta, pitchMaxDelta);
           
            smoothedYaw = normalizeAngle(smoothedYaw);
            smoothedPitch = clamp(smoothedPitch, -90.0f, 90.0f);
           
            float overshootFactor = 0.0f;
            if (overshootYaw != 0.0f || overshootPitch != 0.0f) {
                long timeSinceOvershoot = now - overshootStartTime;
                if (timeSinceOvershoot < OVERSHOOT_DURATION) {
                    overshootFactor = 1.0f - ((float) timeSinceOvershoot / OVERSHOOT_DURATION);
                    overshootFactor = overshootFactor * overshootFactor;
                } else {
                    overshootYaw = 0.0f;
                    overshootPitch = 0.0f;
                }
            }
           
            float jitterYaw = getJitter(now, tid, true);
            float jitterPitch = getJitter(now, tid, false);
           
            float finalYaw = smoothedYaw + jitterYaw + (overshootYaw * overshootFactor);
            float finalPitch = smoothedPitch + jitterPitch + (overshootPitch * overshootFactor);
           
            finalYaw = normalizeAngle(finalYaw);
            finalPitch = clamp(finalPitch, -90.0f, 90.0f);
           
            Rotation rotation = new Rotation(finalYaw, finalPitch);
            Holly.getInstance().getRotationHandler().rotate(
                rotation,
                MoveCorrection.SILENT,
                180.0f,
                180.0f,
                180.0f,
                RotationPriority.OVERRIDE
            );
        }
       
        private Vec3d getMultiPoint(LivingEntity target, boolean attacking, long now) {
            int tid = target.getId();
           
            if (tid != mpLastTargetId) {
                mpLastTargetId = tid;
                mpCurrent = Vec3d.ZERO;
                mpOrbit = rnd(0.0f, (float) (Math.PI * 2.0));
                mpLastUpdate = now;
            }
           
            long dtMs = now - mpLastUpdate;
            if (dtMs < 1) dtMs = 1;
            if (dtMs > 60) dtMs = 60;
            mpLastUpdate = now;
           
            float orbitSpeed = 0.36f;
            float dtScale = (float) dtMs / 50.0f;
            mpOrbit += orbitSpeed * dtScale + rnd(-0.018f, 0.018f) * dtScale;
           
            Vec3d desired = calculateOrbitPoint(mpOrbit, attacking);
           
            float tau = 120.0f;
            float alpha = (float) dtMs / tau;
            alpha = clamp(alpha, 0.0f, 1.0f);
            alpha = alpha * alpha * (3.0f - 2.0f * alpha);
           
            if (mpCurrent == Vec3d.ZERO) {
                mpCurrent = desired;
            } else {
                mpCurrent = new Vec3d(
                    lerp(mpCurrent.x, desired.x, alpha),
                    lerp(mpCurrent.y, desired.y, alpha),
                    lerp(mpCurrent.z, desired.z, alpha)
                );
            }
           
            Box box = target.getBoundingBox();
            double fx = 0.5 + mpCurrent.x * 0.5;
            double fy = mpCurrent.y;
            double fz = 0.5 + mpCurrent.z * 0.5;
           
            fx = clamp(fx, 0.0, 1.0);
            fy = clamp(fy, 0.36, 0.82);
            fz = clamp(fz, 0.0, 1.0);
           
            double x = box.minX + (box.maxX - box.minX) * fx;
            double y = box.minY + (box.maxY - box.minY) * fy;
            double z = box.minZ + (box.maxZ - box.minZ) * fz;
           
            return new Vec3d(
                clamp(x, box.minX + 1.0E-4, box.maxX - 1.0E-4),
                clamp(y, box.minY + 1.0E-4, box.maxY - 1.0E-4),
                clamp(z, box.minZ + 1.0E-4, box.maxZ - 1.0E-4)
            );
        }
       
        private Vec3d calculateOrbitPoint(float orbit, boolean attacking) {
            float o = orbit;
           
            float y = 0.56f
                + 0.10f * (float) Math.sin(o * 0.74f + 0.9f)
                + 0.06f * (float) Math.sin(o * 1.28f + 2.2f)
                - 0.05f * (float) (0.5 + 0.5 * Math.sin(o * 0.35f + 1.7f))
                + critHeightOffset;
           
            float x = (0.22f * (float) Math.sin(o))
                + (0.06f * (float) Math.sin(o * 1.85f + 0.25f));
           
            float z = (0.08f * (float) Math.cos(o * 0.92f + 0.4f))
                + (0.03f * (float) Math.sin(o * 1.35f + 1.1f));
           
            float jitter = 0.020f;
            x += rnd(-jitter, jitter);
            z += rnd(-jitter, jitter);
            y += rnd(-jitter * 0.55f, jitter * 0.55f);
           
            x = clamp(x, -0.46f, 0.46f);
            z = clamp(z, -0.36f, 0.36f);
            y = clamp(y, 0.36f, 0.82f);
           
            return new Vec3d(x, y, z);
        }
       
        private float getJitter(long now, int tid, boolean isYaw) {
            float amp = isYaw
                ? lerp(NOISE_YAW_MIN, NOISE_YAW_MAX, 0.5f)
                : lerp(NOISE_PITCH_MIN, NOISE_PITCH_MAX, 0.5f);
           
            float freq = lerp(NOISE_FREQ_MIN, NOISE_FREQ_MAX, 0.5f);
           
            float phase = isYaw ? noisePhaseYaw : noisePhasePitch;
            float tt = (float) ((now % 100000L) / 1000.0);
           
            float noise = perlin.fbm((tt * freq + phase), (float) (tid * 0.013 + 0.11), 4, 2.0f, 0.55f);
            float sway = perlin.noise((tt * 0.22f + phase * 0.07f), (float) (tid * 0.009 + 9.3));
           
            return (noise * 0.72f + sway * 0.28f) * amp;
        }
       
        public void reset() {
            noisePhaseYaw = rnd(0.0f, 999.0f);
            noisePhasePitch = rnd(0.0f, 999.0f);
            mpCurrent = Vec3d.ZERO;
            mpOrbit = 0.0f;
            mpLastUpdate = 0L;
            mpLastTargetId = Integer.MIN_VALUE;
            smoothedYaw = 0.0f;
            smoothedPitch = 0.0f;
            smoothLastTime = 0L;
            smoothTargetId = -1;
            targetLockTime = 0L;
            lastLockedTargetId = -1;
            currentSpeedMultiplier = 1.0f;
            savedViewValid = false;
            returnActive = false;
            overshootYaw = 0.0f;
            overshootPitch = 0.0f;
        }
       
        private float normalizeAngle(float angle) {
            angle = angle % 360.0F;
            if (angle >= 180.0F) angle -= 360.0F;
            if (angle < -180.0F) angle += 360.0F;
            return angle;
        }
       
        private static float clamp(float value, float min, float max) {
            if (value < min) return min;
            if (value > max) return max;
            return value;
        }
       
        private static double clamp(double value, double min, double max) {
            if (value < min) return min;
            if (value > max) return max;
            return value;
        }
       
        private static float lerp(float a, float b, float t) {
            return a + (b - a) * t;
        }
       
        private static double lerp(double a, double b, double t) {
            return a + (b - a) * t;
        }
    }
   
    private static RotatingHitbox instance;
   
    private final TargetFinder targetFinder = new TargetFinder();
    private final InternalFTSnapRotation ftSnapRotation = new InternalFTSnapRotation();
    private final SliderSetting attackRange = new SliderSetting(this, "Дистанция поиска")
        .min(1.0F).max(6.0F).step(0.1F).currentValue(3.5F);
   
    private final SliderSetting expandSize = new SliderSetting(this, "Размер увеличения")
        .min(0.1F).max(2.0F).step(0.1F).currentValue(0.5F);
   
    private final SelectSetting targetTypes = new SelectSetting(this, "Типы целей");
    private final SelectSetting.Value players = new SelectSetting.Value(targetTypes, "Players").select();
    private final SelectSetting.Value mobs = new SelectSetting.Value(targetTypes, "Mobs").select();
    private final SelectSetting.Value animals = new SelectSetting.Value(targetTypes, "Animals");
   
    private final BooleanSetting ignoreWalls = new BooleanSetting(this, "Игнорировать стены");
   
    private final BooleanSetting antiReach = new BooleanSetting(this, "Анти-Reach");
   
    private final SliderSetting antiReachDistance = new SliderSetting(this, "Дистанция Анти-Reach")
        .min(1.0F).max(3.0F).step(0.01F).currentValue(2.85F);
   
    private final BooleanSetting fakeSwing = new BooleanSetting(this, "Фейк свинг");
   
    private final BooleanSetting legitSprint = new BooleanSetting(this, "Легит спринт")
        .enable();
   
    private final BooleanSetting autoTargetESP = new BooleanSetting(this, "Авто TargetESP")
        .enable();
   
    private final SliderSetting lineWidth = new SliderSetting(this, "Толщина линий")
        .min(1.0F).max(5.0F).step(0.5F).currentValue(2.5F);
   
    private final ColorSetting hitboxColor = new ColorSetting(this, "Цвет хитбокса")
        .color(new ColorRGBA(100, 150, 255, 100));
   
    private final ColorSetting activeColor = new ColorSetting(this, "Цвет при активации")
        .color(new ColorRGBA(255, 50, 50, 120));
   
    private LivingEntity currentTarget = null;
    private boolean isAimingAtHitbox = false;
   
    private boolean sprintResetActive = false;
    private long sprintResetStartTime = 0;
    private static final long SPRINT_RESET_DURATION = 250;
   
    private final Map<Integer, Box> originalHitboxes = new HashMap<>();
   
    public RotatingHitbox() {
        instance = this;
    }
   
    public static RotatingHitbox getInstance() {
        return instance;
    }
   
    private final EventListener<ClientPlayerTickEvent> onTick = event -> {
        if (mc.player == null || mc.world == null) {
            resetState();
            return;
        }
       
        List<String> selectedTypes = targetTypes.getSelectedValues().stream()
            .map(SelectSetting.Value::getName)
            .toList();
       
        targetFinder.searchTargets(
            attackRange.getCurrentValue(),
            90.0f,
            ignoreWalls.isEnabled(),
            selectedTypes
        );
       
        targetFinder.validateTarget(target -> {
            if (target == null || !target.isAlive() || target.getHealth() <= 0) {
                return false;
            }
           
            float distance = mc.player.distanceTo(target);
            return distance <= attackRange.getCurrentValue();
        });
       
        LivingEntity previousTarget = currentTarget;
        currentTarget = targetFinder.getCurrentTarget();
       
        if (currentTarget != previousTarget) {
            ftSnapRotation.notifyTargetChanged(currentTarget);
        }
       
        if (currentTarget != null) {
            isAimingAtHitbox = isLookingAtExpandedHitbox();
           
            if (isAimingAtHitbox && !isAuraEnabled()) {
                ftSnapRotation.updateSavedView();
                ftSnapRotation.rotateTo(currentTarget, false);
               
                if (legitSprint.isEnabled()) {
                    handleLegitSprintReset();
                }
            }
           
            if (autoTargetESP.isEnabled()) {
                Holly.getInstance().getTargetManager().setCurrentTarget(currentTarget);
            }
        } else {
            sprintResetActive = false;
           
            if (autoTargetESP.isEnabled()) {
                Holly.getInstance().getTargetManager().setCurrentTarget(null);
            }
        }
    };
   
    private final EventListener<Render3DEvent> onRender3D = event -> {
        if (mc.player == null || mc.world == null) {
            return;
        }
       
        List<String> selectedTypes = targetTypes.getSelectedValues().stream()
            .map(SelectSetting.Value::getName)
            .toList();
       
        for (Entity entity : mc.world.getEntities()) {
            if (entity instanceof LivingEntity livingEntity && livingEntity != mc.player) {
                boolean isValidType = false;
                for (String type : selectedTypes) {
                    if (type.equals("Players") && livingEntity instanceof net.minecraft.entity.player.PlayerEntity) {
                        isValidType = true;
                        break;
                    } else if (type.equals("Mobs") && livingEntity instanceof net.minecraft.entity.mob.MobEntity) {
                        isValidType = true;
                        break;
                    } else if (type.equals("Animals") && livingEntity instanceof net.minecraft.entity.passive.AnimalEntity) {
                        isValidType = true;
                        break;
                    }
                }
               
                if (isValidType && livingEntity.isAlive()) {
                    int id = livingEntity.getId();
                   
                    if (!originalHitboxes.containsKey(id)) {
                        originalHitboxes.put(id, getOriginalHitbox(livingEntity));
                    }
                   
                    float radius = getEntityRadius(livingEntity);
                    float expandedRadius = radius + expandSize.getCurrentValue();
                    setEntityHitbox(livingEntity, expandedRadius);
                   
                    Box expandedBox = calculateExpandedHitbox(livingEntity);
                    boolean isCurrentTarget = (livingEntity == currentTarget && isAimingAtHitbox);
                    renderHitbox(event.getMatrices(), expandedBox, isCurrentTarget);
                }
            }
        }
    };
   
    private final EventListener<AttackEvent> onAttack = event -> {
        Entity target = event.getEntity();
       
        if (legitSprint.isEnabled() && target instanceof LivingEntity) {
            sprintResetActive = true;
            sprintResetStartTime = System.currentTimeMillis();
        }
       
        if (!antiReach.isEnabled() || mc.player == null) {
            return;
        }
       
        if (!(target instanceof LivingEntity livingEntity)) {
            return;
        }
       
        if (livingEntity == mc.player) {
            return;
        }
       
        Box originalBox = getOriginalHitbox(livingEntity);
        Vec3d eyes = mc.player.getEyePos();
        Vec3d closestPoint = getClosestPoint(eyes, originalBox);
        double distance = eyes.distanceTo(closestPoint);
       
        double maxDistance = antiReachDistance.getCurrentValue();
       
        if (distance > maxDistance) {
            event.cancel();
           
            if (fakeSwing.isEnabled() && mc.player != null) {
                mc.player.swingHand(net.minecraft.util.Hand.MAIN_HAND);
                mc.player.resetLastAttackedTicks();
            }
        }
    };
   
    private Box getOriginalHitbox(Entity entity) {
        return entity.getType().getDimensions().getBoxAt(entity.getPos());
    }
   
    private float getEntityRadius(Entity entity) {
        Box box = getOriginalHitbox(entity);
        return (float)(box.getLengthX() / 2.0);
    }
   
    private void setEntityHitbox(LivingEntity entity, float radius) {
        entity.setBoundingBox(
            new Box(
                entity.getX() - radius,
                entity.getBoundingBox().minY,
                entity.getZ() - radius,
                entity.getX() + radius,
                entity.getBoundingBox().maxY,
                entity.getZ() + radius
            )
        );
    }
   
    private Box calculateExpandedHitbox(LivingEntity target) {
        float radius = getEntityRadius(target);
        float expandedRadius = radius + expandSize.getCurrentValue();
       
        return new Box(
            target.getX() - expandedRadius,
            target.getBoundingBox().minY,
            target.getZ() - expandedRadius,
            target.getX() + expandedRadius,
            target.getBoundingBox().maxY,
            target.getZ() + expandedRadius
        );
    }
   
    private boolean isLookingAtExpandedHitbox() {
        if (mc.player == null || currentTarget == null) {
            return false;
        }
       
        float yaw = mc.player.getYaw();
        float pitch = mc.player.getPitch();
       
        float yawRad = (float) Math.toRadians(yaw);
        float pitchRad = (float) Math.toRadians(pitch);
       
        float x = (float)(-Math.sin(yawRad) * Math.cos(pitchRad));
        float y = (float)(-Math.sin(pitchRad));
        float z = (float)(Math.cos(yawRad) * Math.cos(pitchRad));
        Vec3d direction = new Vec3d(x, y, z);
       
        Vec3d eyes = mc.player.getEyePos();
       
        Box expandedBox = calculateExpandedHitbox(currentTarget);
       
        if (expandedBox.contains(eyes)) {
            return true;
        }
       
        Vec3d end = eyes.add(direction.multiply(attackRange.getCurrentValue() + 2.0));
        return expandedBox.raycast(eyes, end).isPresent();
    }
   
    private void resetState() {
        isAimingAtHitbox = false;
    }
   
    private void handleLegitSprintReset() {
        if (mc.player == null) return;
       
        long currentTime = System.currentTimeMillis();
       
        if (sprintResetActive) {
            mc.options.sprintKey.setPressed(false);
            mc.player.setSprinting(false);
           
            if (currentTime - sprintResetStartTime >= SPRINT_RESET_DURATION) {
                sprintResetActive = false;
            }
        }
    }
   
    private boolean isAuraEnabled() {
        return Holly.getInstance().getModuleManager().getModule(Aura.class).isEnabled();
    }
   
    private void restoreAllHitboxes() {
        if (mc.world == null) return;
       
        for (Entity entity : mc.world.getEntities()) {
            if (entity instanceof LivingEntity livingEntity && livingEntity != mc.player) {
                int id = livingEntity.getId();
                if (originalHitboxes.containsKey(id)) {
                    float radius = getEntityRadius(livingEntity);
                    setEntityHitbox(livingEntity, radius);
                }
            }
        }
       
        originalHitboxes.clear();
    }
   
    private Vec3d getClosestPoint(Vec3d point, Box box) {
        double x = Math.max(box.minX, Math.min(point.x, box.maxX));
        double y = Math.max(box.minY, Math.min(point.y, box.maxY));
        double z = Math.max(box.minZ, Math.min(point.z, box.maxZ));
        return new Vec3d(x, y, z);
    }
   
    private void renderHitbox(MatrixStack matrices, Box box, boolean active) {
        if (mc.player == null) return;
       
        matrices.push();
       
        RenderSystem.enableBlend();
        RenderSystem.defaultBlendFunc();
        RenderSystem.disableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);
        RenderSystem.lineWidth(lineWidth.getCurrentValue());
       
        Vec3d cameraPos = mc.gameRenderer.getCamera().getPos();
        matrices.translate(-cameraPos.x, -cameraPos.y, -cameraPos.z);
       
        ColorRGBA color = active ? activeColor.getColor() : hitboxColor.getColor();
       
        drawBoxFilled(matrices, box, color);
       
        ColorRGBA outlineColor = new ColorRGBA(
            Math.min(255, color.getRed() + 50),
            Math.min(255, color.getGreen() + 50),
            Math.min(255, color.getBlue() + 50),
            Math.min(255, color.getAlpha() + 80)
        );
        drawBoxOutline(matrices, box, outlineColor);
       
        RenderSystem.lineWidth(1.0f);
        RenderSystem.enableDepthTest();
        RenderSystem.enableCull();
        RenderSystem.disableBlend();
       
        matrices.pop();
    }
   
    private void drawBoxFilled(MatrixStack matrices, Box box, ColorRGBA color) {
        Matrix4f matrix = matrices.peek().getPositionMatrix();
       
        Tessellator tessellator = Tessellator.getInstance();
        BufferBuilder buffer = tessellator.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_COLOR);
       
        float r = color.getRed() / 255.0f;
        float g = color.getGreen() / 255.0f;
        float b = color.getBlue() / 255.0f;
        float a = color.getAlpha() / 255.0f * 0.5f;
       
        float minX = (float) box.minX;
        float minY = (float) box.minY;
        float minZ = (float) box.minZ;
        float maxX = (float) box.maxX;
        float maxY = (float) box.maxY;
        float maxZ = (float) box.maxZ;
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
       
        BufferRenderer.drawWithGlobalProgram(buffer.end());
    }
   
    private void drawBoxOutline(MatrixStack matrices, Box box, ColorRGBA color) {
        Matrix4f matrix = matrices.peek().getPositionMatrix();
       
        Tessellator tessellator = Tessellator.getInstance();
        BufferBuilder buffer = tessellator.begin(VertexFormat.DrawMode.DEBUG_LINES, VertexFormats.POSITION_COLOR);
       
        float r = color.getRed() / 255.0f;
        float g = color.getGreen() / 255.0f;
        float b = color.getBlue() / 255.0f;
        float a = color.getAlpha() / 255.0f;
       
        float minX = (float) box.minX;
        float minY = (float) box.minY;
        float minZ = (float) box.minZ;
        float maxX = (float) box.maxX;
        float maxY = (float) box.maxY;
        float maxZ = (float) box.maxZ;
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
       
        BufferRenderer.drawWithGlobalProgram(buffer.end());
    }
   
    @Override
    public void onEnable() {
        targetFinder.releaseTarget();
        currentTarget = null;
        isAimingAtHitbox = false;
        originalHitboxes.clear();
        ftSnapRotation.reset();
        sprintResetActive = false;
        sprintResetStartTime = 0;
    }
   
    @Override
    public void onDisable() {
        targetFinder.releaseTarget();
        currentTarget = null;
        isAimingAtHitbox = false;
        restoreAllHitboxes();
        ftSnapRotation.reset();
        sprintResetActive = false;
       
        if (autoTargetESP.isEnabled()) {
            Holly.getInstance().getTargetManager().setCurrentTarget(null);
        }
    }
   
    private static float rnd(float a, float b) {
        if (b <= a) return a;
        return a + ThreadLocalRandom.current().nextFloat() * (b - a);
    }
}

я 3 дня пытался с клауд сонетом 4.5 эту залупу сделать, респект

 

[Micronix]

Всем привет, решил сделать снап хитбоксы под базу рокстара
В кратце эт не снапы а хиты с норм ротацией под фт, это не перенсос с система! ГПТ код имееться

Пожалуйста, авторизуйтесь для просмотра ссылки.

package moscow.holly.systems.modules.modules.combat;

import com.mojang.blaze3d.systems.RenderSystem;
import moscow.holly.systems.event.EventListener;
import moscow.holly.systems.event.impl.game.AttackEvent;
import moscow.holly.systems.event.impl.player.ClientPlayerTickEvent;
import moscow.holly.systems.event.impl.render.Render3DEvent;
import moscow.holly.systems.modules.api.ModuleCategory;
import moscow.holly.systems.modules.api.ModuleInfo;
import moscow.holly.systems.modules.impl.BaseModule;
import moscow.holly.systems.setting.settings.BooleanSetting;
import moscow.holly.systems.setting.settings.ColorSetting;
import moscow.holly.systems.setting.settings.SelectSetting;
import moscow.holly.systems.setting.settings.SliderSetting;
import moscow.holly.Holly;
import moscow.holly.systems.modules.modules.combat.Aura;
import moscow.holly.utility.colors.ColorRGBA;
import moscow.holly.utility.combat.aura.TargetFinder;
import moscow.holly.utility.rotations.MoveCorrection;
import moscow.holly.utility.rotations.Rotation;
import moscow.holly.utility.rotations.RotationPriority;
import net.minecraft.client.gl.ShaderProgramKeys;
import net.minecraft.client.render.*;
import net.minecraft.client.util.math.MatrixStack;
import net.minecraft.entity.Entity;
import net.minecraft.entity.LivingEntity;
import net.minecraft.util.math.Box;
import net.minecraft.util.math.Vec3d;
import org.joml.Matrix4f;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.concurrent.ThreadLocalRandom;

@ModuleInfo(name = "Rotating Hitbox", category = ModuleCategory.COMBAT, desc = "Увеличенный хитбокс с ротацией как в Aura-Funtime")
public class RotatingHitbox extends BaseModule {
   
    private static class PerlinNoise {
        private final int[] p = new int[512];
       
        public PerlinNoise(int seed) {
            int[] perm = new int[256];
            for (int i = 0; i < 256; i++) perm[i] = i;
           
            Random r = new Random(seed);
            for (int i = 255; i > 0; i--) {
                int j = r.nextInt(i + 1);
                int t = perm[i];
                perm[i] = perm[j];
                perm[j] = t;
            }
           
            for (int i = 0; i < 256; i++) {
                int v = perm[i] & 255;
                p[i] = v;
                p[i + 256] = v;
            }
        }
       
        private static float fade(float t) {
            return t * t * t * (t * (t * 6.0f - 15.0f) + 10.0f);
        }
       
        private static float lerp(float t, float a, float b) {
            return a + t * (b - a);
        }
       
        private static float grad(int hash, float x, float y, float z) {
            int h = hash & 15;
            float u = h < 8 ? x : y;
            float v = h < 4 ? y : (h == 12 || h == 14 ? x : z);
            return ((h & 1) == 0 ? u : -u) + ((h & 2) == 0 ? v : -v);
        }
       
        public float noise(float x, float y) {
            float z = 0.0f;
            int X = ((int) Math.floor(x)) & 255;
            int Y = ((int) Math.floor(y)) & 255;
            int Z = ((int) Math.floor(z)) & 255;
           
            x = (float) (x - Math.floor(x));
            y = (float) (y - Math.floor(y));
            z = (float) (z - Math.floor(z));
           
            float u = fade(x);
            float v = fade(y);
            float w = fade(z);
           
            int A = p[X] + Y;
            int AA = p[A] + Z;
            int AB = p[A + 1] + Z;
            int B = p[X + 1] + Y;
            int BA = p[B] + Z;
            int BB = p[B + 1] + Z;
           
            return lerp(w,
                lerp(v,
                    lerp(u, grad(p[AA], x, y, z), grad(p[BA], x - 1.0f, y, z)),
                    lerp(u, grad(p[AB], x, y - 1.0f, z), grad(p[BB], x - 1.0f, y - 1.0f, z))),
                lerp(v,
                    lerp(u, grad(p[AA + 1], x, y, z - 1.0f), grad(p[BA + 1], x - 1.0f, y, z - 1.0f)),
                    lerp(u, grad(p[AB + 1], x, y - 1.0f, z - 1.0f), grad(p[BB + 1], x - 1.0f, y - 1.0f, z - 1.0f))));
        }
       
        public float fbm(float x, float y, int octaves, float lacunarity, float gain) {
            float sum = 0.0f;
            float amp = 0.5f;
            float fx = x;
            float fy = y;
           
            for (int i = 0; i < octaves; i++) {
                sum += noise(fx, fy) * amp;
                fx *= lacunarity;
                fy *= lacunarity;
                amp *= gain;
            }
           
            return sum;
        }
    }
   
    private class InternalFTSnapRotation {
       
        private final PerlinNoise perlin = new PerlinNoise(1337);
       
        private static final float NOISE_YAW_MIN = 0.06f;
        private static final float NOISE_YAW_MAX = 0.38f;
        private static final float NOISE_PITCH_MIN = 0.04f;
        private static final float NOISE_PITCH_MAX = 0.22f;
        private static final float NOISE_FREQ_MIN = 0.55f;
        private static final float NOISE_FREQ_MAX = 1.65f;
       
        private float noisePhaseYaw = 0.0f;
        private float noisePhasePitch = 0.0f;
       
        private Vec3d mpCurrent = Vec3d.ZERO;
        private float mpOrbit = 0.0f;
        private long mpLastUpdate = 0L;
        private int mpLastTargetId = Integer.MIN_VALUE;
       
        private float critHeightOffset = 0.0f;
        private long lastAttackTime = 0L;
       
        private float overshootYaw = 0.0f;
        private float overshootPitch = 0.0f;
        private long overshootStartTime = 0L;
        private static final float OVERSHOOT_PROB = 0.25f;
        private static final float OVERSHOOT_MIN = 0.8f;
        private static final float OVERSHOOT_MAX = 2.5f;
        private static final long OVERSHOOT_DURATION = 80;
       
        private float smoothedYaw = 0.0f;
        private float smoothedPitch = 0.0f;
        private long smoothLastTime = 0L;
        private int smoothTargetId = -1;
        private long targetLockTime = 0L;
        private int lastLockedTargetId = -1;
        private float currentSpeedMultiplier = 1.0f;
       
        private boolean savedViewValid = false;
        private float savedYaw = 0.0f;
        private float savedPitch = 0.0f;
        private boolean returnActive = false;
        private long returnStartTime = 0L;
        private float returnYaw = 0.0f;
        private float returnPitch = 0.0f;
        public void notifyTargetChanged(LivingEntity newTarget) {
            if (newTarget == null) {
                lastLockedTargetId = -1;
                overshootYaw = 0.0f;
                overshootPitch = 0.0f;
                return;
            }
           
            int newId = newTarget.getId();
           
            if (lastLockedTargetId != newId) {
                lastLockedTargetId = newId;
                long now = System.currentTimeMillis();
                targetLockTime = now;
               
                currentSpeedMultiplier = rnd(0.65f, 0.95f);
               
                if (ThreadLocalRandom.current().nextFloat() < OVERSHOOT_PROB) {
                    overshootYaw = rnd(OVERSHOOT_MIN, OVERSHOOT_MAX) * (ThreadLocalRandom.current().nextBoolean() ? 1 : -1);
                    overshootPitch = rnd(OVERSHOOT_MIN * 0.6f, OVERSHOOT_MAX * 0.6f) * (ThreadLocalRandom.current().nextBoolean() ? 1 : -1);
                    overshootStartTime = now;
                } else {
                    overshootYaw = 0.0f;
                    overshootPitch = 0.0f;
                }
            }
        }
       
        public void updateSavedView() {
            if (mc.player == null) return;
           
            if (!savedViewValid) {
                savedViewValid = true;
                Rotation currentRotation = Holly.getInstance().getRotationHandler().getCurrentRotation();
                savedYaw = currentRotation.getYaw();
                savedPitch = currentRotation.getPitch();
            }
        }
       
        public void rotateTo(LivingEntity target, boolean attacking) {
            if (mc.player == null || target == null) return;
           
            updateSavedView();
           
            long now = System.currentTimeMillis();
            int tid = target.getId();
           
            if (smoothTargetId == -1) {
                Rotation currentRotation = Holly.getInstance().getRotationHandler().getCurrentRotation();
                smoothedYaw = currentRotation.getYaw();
                smoothedPitch = currentRotation.getPitch();
            }
           
            if (attacking && (now - lastAttackTime) > 400) {
                critHeightOffset = rnd(-0.15f, 0.15f);
                lastAttackTime = now;
            }
           
            float k = 0.035f;
            noisePhaseYaw += k * (0.65f + 0.35f * ((tid * 1103515245) & 255) / 255.0f);
            noisePhasePitch += k * (0.65f + 0.35f * ((tid * 1664525) & 255) / 255.0f);
           
            Vec3d targetPoint = getMultiPoint(target, attacking, now);
           
            Vec3d eyes = mc.player.getEyePos();
            Vec3d direction = targetPoint.subtract(eyes);
           
            double horizontalDistance = Math.sqrt(direction.x * direction.x + direction.z * direction.z);
           
            float targetYaw = (float) Math.toDegrees(Math.atan2(direction.z, direction.x)) - 90.0F;
            float targetPitch = (float) (-Math.toDegrees(Math.atan2(direction.y, horizontalDistance)));
           
            targetYaw = normalizeAngle(targetYaw);
            targetPitch = clamp(targetPitch, -90.0f, 90.0f);
           
            if (smoothTargetId != tid) {
                smoothTargetId = tid;
                smoothLastTime = now;
            }
           
            long dtMs = now - smoothLastTime;
            if (dtMs < 1) dtMs = 1;
            if (dtMs > 120) dtMs = 120;
            smoothLastTime = now;
           
            long timeSinceLock = now - targetLockTime;
            float lockProgress = Math.min(1.0f, timeSinceLock / 1000.0f);
           
            float speedMultiplier = lockProgress * lockProgress * (3.0f - 2.0f * lockProgress);
            speedMultiplier = 0.35f + speedMultiplier * 0.65f;
            speedMultiplier *= currentSpeedMultiplier;
           
            float baseYawSpeed = attacking ? 55.0f : 60.0f;
            float basePitchSpeed = attacking ? 44.0f : 48.0f;
           
            float yawSpeed = baseYawSpeed * speedMultiplier;
            float pitchSpeed = basePitchSpeed * speedMultiplier;
           
            float yawMaxDelta = yawSpeed * ((float) dtMs / 50.0f);
            float pitchMaxDelta = pitchSpeed * ((float) dtMs / 50.0f);
           
            float yawError = normalizeAngle(targetYaw - smoothedYaw);
            float pitchError = targetPitch - smoothedPitch;
           
            smoothedYaw += clamp(yawError, -yawMaxDelta, yawMaxDelta);
            smoothedPitch += clamp(pitchError, -pitchMaxDelta, pitchMaxDelta);
           
            smoothedYaw = normalizeAngle(smoothedYaw);
            smoothedPitch = clamp(smoothedPitch, -90.0f, 90.0f);
           
            float overshootFactor = 0.0f;
            if (overshootYaw != 0.0f || overshootPitch != 0.0f) {
                long timeSinceOvershoot = now - overshootStartTime;
                if (timeSinceOvershoot < OVERSHOOT_DURATION) {
                    overshootFactor = 1.0f - ((float) timeSinceOvershoot / OVERSHOOT_DURATION);
                    overshootFactor = overshootFactor * overshootFactor;
                } else {
                    overshootYaw = 0.0f;
                    overshootPitch = 0.0f;
                }
            }
           
            float jitterYaw = getJitter(now, tid, true);
            float jitterPitch = getJitter(now, tid, false);
           
            float finalYaw = smoothedYaw + jitterYaw + (overshootYaw * overshootFactor);
            float finalPitch = smoothedPitch + jitterPitch + (overshootPitch * overshootFactor);
           
            finalYaw = normalizeAngle(finalYaw);
            finalPitch = clamp(finalPitch, -90.0f, 90.0f);
           
            Rotation rotation = new Rotation(finalYaw, finalPitch);
            Holly.getInstance().getRotationHandler().rotate(
                rotation,
                MoveCorrection.SILENT,
                180.0f,
                180.0f,
                180.0f,
                RotationPriority.OVERRIDE
            );
        }
       
        private Vec3d getMultiPoint(LivingEntity target, boolean attacking, long now) {
            int tid = target.getId();
           
            if (tid != mpLastTargetId) {
                mpLastTargetId = tid;
                mpCurrent = Vec3d.ZERO;
                mpOrbit = rnd(0.0f, (float) (Math.PI * 2.0));
                mpLastUpdate = now;
            }
           
            long dtMs = now - mpLastUpdate;
            if (dtMs < 1) dtMs = 1;
            if (dtMs > 60) dtMs = 60;
            mpLastUpdate = now;
           
            float orbitSpeed = 0.36f;
            float dtScale = (float) dtMs / 50.0f;
            mpOrbit += orbitSpeed * dtScale + rnd(-0.018f, 0.018f) * dtScale;
           
            Vec3d desired = calculateOrbitPoint(mpOrbit, attacking);
           
            float tau = 120.0f;
            float alpha = (float) dtMs / tau;
            alpha = clamp(alpha, 0.0f, 1.0f);
            alpha = alpha * alpha * (3.0f - 2.0f * alpha);
           
            if (mpCurrent == Vec3d.ZERO) {
                mpCurrent = desired;
            } else {
                mpCurrent = new Vec3d(
                    lerp(mpCurrent.x, desired.x, alpha),
                    lerp(mpCurrent.y, desired.y, alpha),
                    lerp(mpCurrent.z, desired.z, alpha)
                );
            }
           
            Box box = target.getBoundingBox();
            double fx = 0.5 + mpCurrent.x * 0.5;
            double fy = mpCurrent.y;
            double fz = 0.5 + mpCurrent.z * 0.5;
           
            fx = clamp(fx, 0.0, 1.0);
            fy = clamp(fy, 0.36, 0.82);
            fz = clamp(fz, 0.0, 1.0);
           
            double x = box.minX + (box.maxX - box.minX) * fx;
            double y = box.minY + (box.maxY - box.minY) * fy;
            double z = box.minZ + (box.maxZ - box.minZ) * fz;
           
            return new Vec3d(
                clamp(x, box.minX + 1.0E-4, box.maxX - 1.0E-4),
                clamp(y, box.minY + 1.0E-4, box.maxY - 1.0E-4),
                clamp(z, box.minZ + 1.0E-4, box.maxZ - 1.0E-4)
            );
        }
       
        private Vec3d calculateOrbitPoint(float orbit, boolean attacking) {
            float o = orbit;
           
            float y = 0.56f
                + 0.10f * (float) Math.sin(o * 0.74f + 0.9f)
                + 0.06f * (float) Math.sin(o * 1.28f + 2.2f)
                - 0.05f * (float) (0.5 + 0.5 * Math.sin(o * 0.35f + 1.7f))
                + critHeightOffset;
           
            float x = (0.22f * (float) Math.sin(o))
                + (0.06f * (float) Math.sin(o * 1.85f + 0.25f));
           
            float z = (0.08f * (float) Math.cos(o * 0.92f + 0.4f))
                + (0.03f * (float) Math.sin(o * 1.35f + 1.1f));
           
            float jitter = 0.020f;
            x += rnd(-jitter, jitter);
            z += rnd(-jitter, jitter);
            y += rnd(-jitter * 0.55f, jitter * 0.55f);
           
            x = clamp(x, -0.46f, 0.46f);
            z = clamp(z, -0.36f, 0.36f);
            y = clamp(y, 0.36f, 0.82f);
           
            return new Vec3d(x, y, z);
        }
       
        private float getJitter(long now, int tid, boolean isYaw) {
            float amp = isYaw
                ? lerp(NOISE_YAW_MIN, NOISE_YAW_MAX, 0.5f)
                : lerp(NOISE_PITCH_MIN, NOISE_PITCH_MAX, 0.5f);
           
            float freq = lerp(NOISE_FREQ_MIN, NOISE_FREQ_MAX, 0.5f);
           
            float phase = isYaw ? noisePhaseYaw : noisePhasePitch;
            float tt = (float) ((now % 100000L) / 1000.0);
           
            float noise = perlin.fbm((tt * freq + phase), (float) (tid * 0.013 + 0.11), 4, 2.0f, 0.55f);
            float sway = perlin.noise((tt * 0.22f + phase * 0.07f), (float) (tid * 0.009 + 9.3));
           
            return (noise * 0.72f + sway * 0.28f) * amp;
        }
       
        public void reset() {
            noisePhaseYaw = rnd(0.0f, 999.0f);
            noisePhasePitch = rnd(0.0f, 999.0f);
            mpCurrent = Vec3d.ZERO;
            mpOrbit = 0.0f;
            mpLastUpdate = 0L;
            mpLastTargetId = Integer.MIN_VALUE;
            smoothedYaw = 0.0f;
            smoothedPitch = 0.0f;
            smoothLastTime = 0L;
            smoothTargetId = -1;
            targetLockTime = 0L;
            lastLockedTargetId = -1;
            currentSpeedMultiplier = 1.0f;
            savedViewValid = false;
            returnActive = false;
            overshootYaw = 0.0f;
            overshootPitch = 0.0f;
        }
       
        private float normalizeAngle(float angle) {
            angle = angle % 360.0F;
            if (angle >= 180.0F) angle -= 360.0F;
            if (angle < -180.0F) angle += 360.0F;
            return angle;
        }
       
        private static float clamp(float value, float min, float max) {
            if (value < min) return min;
            if (value > max) return max;
            return value;
        }
       
        private static double clamp(double value, double min, double max) {
            if (value < min) return min;
            if (value > max) return max;
            return value;
        }
       
        private static float lerp(float a, float b, float t) {
            return a + (b - a) * t;
        }
       
        private static double lerp(double a, double b, double t) {
            return a + (b - a) * t;
        }
    }
   
    private static RotatingHitbox instance;
   
    private final TargetFinder targetFinder = new TargetFinder();
    private final InternalFTSnapRotation ftSnapRotation = new InternalFTSnapRotation();
    private final SliderSetting attackRange = new SliderSetting(this, "Дистанция поиска")
        .min(1.0F).max(6.0F).step(0.1F).currentValue(3.5F);
   
    private final SliderSetting expandSize = new SliderSetting(this, "Размер увеличения")
        .min(0.1F).max(2.0F).step(0.1F).currentValue(0.5F);
   
    private final SelectSetting targetTypes = new SelectSetting(this, "Типы целей");
    private final SelectSetting.Value players = new SelectSetting.Value(targetTypes, "Players").select();
    private final SelectSetting.Value mobs = new SelectSetting.Value(targetTypes, "Mobs").select();
    private final SelectSetting.Value animals = new SelectSetting.Value(targetTypes, "Animals");
   
    private final BooleanSetting ignoreWalls = new BooleanSetting(this, "Игнорировать стены");
   
    private final BooleanSetting antiReach = new BooleanSetting(this, "Анти-Reach");
   
    private final SliderSetting antiReachDistance = new SliderSetting(this, "Дистанция Анти-Reach")
        .min(1.0F).max(3.0F).step(0.01F).currentValue(2.85F);
   
    private final BooleanSetting fakeSwing = new BooleanSetting(this, "Фейк свинг");
   
    private final BooleanSetting legitSprint = new BooleanSetting(this, "Легит спринт")
        .enable();
   
    private final BooleanSetting autoTargetESP = new BooleanSetting(this, "Авто TargetESP")
        .enable();
   
    private final SliderSetting lineWidth = new SliderSetting(this, "Толщина линий")
        .min(1.0F).max(5.0F).step(0.5F).currentValue(2.5F);
   
    private final ColorSetting hitboxColor = new ColorSetting(this, "Цвет хитбокса")
        .color(new ColorRGBA(100, 150, 255, 100));
   
    private final ColorSetting activeColor = new ColorSetting(this, "Цвет при активации")
        .color(new ColorRGBA(255, 50, 50, 120));
   
    private LivingEntity currentTarget = null;
    private boolean isAimingAtHitbox = false;
   
    private boolean sprintResetActive = false;
    private long sprintResetStartTime = 0;
    private static final long SPRINT_RESET_DURATION = 250;
   
    private final Map<Integer, Box> originalHitboxes = new HashMap<>();
   
    public RotatingHitbox() {
        instance = this;
    }
   
    public static RotatingHitbox getInstance() {
        return instance;
    }
   
    private final EventListener<ClientPlayerTickEvent> onTick = event -> {
        if (mc.player == null || mc.world == null) {
            resetState();
            return;
        }
       
        List<String> selectedTypes = targetTypes.getSelectedValues().stream()
            .map(SelectSetting.Value::getName)
            .toList();
       
        targetFinder.searchTargets(
            attackRange.getCurrentValue(),
            90.0f,
            ignoreWalls.isEnabled(),
            selectedTypes
        );
       
        targetFinder.validateTarget(target -> {
            if (target == null || !target.isAlive() || target.getHealth() <= 0) {
                return false;
            }
           
            float distance = mc.player.distanceTo(target);
            return distance <= attackRange.getCurrentValue();
        });
       
        LivingEntity previousTarget = currentTarget;
        currentTarget = targetFinder.getCurrentTarget();
       
        if (currentTarget != previousTarget) {
            ftSnapRotation.notifyTargetChanged(currentTarget);
        }
       
        if (currentTarget != null) {
            isAimingAtHitbox = isLookingAtExpandedHitbox();
           
            if (isAimingAtHitbox && !isAuraEnabled()) {
                ftSnapRotation.updateSavedView();
                ftSnapRotation.rotateTo(currentTarget, false);
               
                if (legitSprint.isEnabled()) {
                    handleLegitSprintReset();
                }
            }
           
            if (autoTargetESP.isEnabled()) {
                Holly.getInstance().getTargetManager().setCurrentTarget(currentTarget);
            }
        } else {
            sprintResetActive = false;
           
            if (autoTargetESP.isEnabled()) {
                Holly.getInstance().getTargetManager().setCurrentTarget(null);
            }
        }
    };
   
    private final EventListener<Render3DEvent> onRender3D = event -> {
        if (mc.player == null || mc.world == null) {
            return;
        }
       
        List<String> selectedTypes = targetTypes.getSelectedValues().stream()
            .map(SelectSetting.Value::getName)
            .toList();
       
        for (Entity entity : mc.world.getEntities()) {
            if (entity instanceof LivingEntity livingEntity && livingEntity != mc.player) {
                boolean isValidType = false;
                for (String type : selectedTypes) {
                    if (type.equals("Players") && livingEntity instanceof net.minecraft.entity.player.PlayerEntity) {
                        isValidType = true;
                        break;
                    } else if (type.equals("Mobs") && livingEntity instanceof net.minecraft.entity.mob.MobEntity) {
                        isValidType = true;
                        break;
                    } else if (type.equals("Animals") && livingEntity instanceof net.minecraft.entity.passive.AnimalEntity) {
                        isValidType = true;
                        break;
                    }
                }
               
                if (isValidType && livingEntity.isAlive()) {
                    int id = livingEntity.getId();
                   
                    if (!originalHitboxes.containsKey(id)) {
                        originalHitboxes.put(id, getOriginalHitbox(livingEntity));
                    }
                   
                    float radius = getEntityRadius(livingEntity);
                    float expandedRadius = radius + expandSize.getCurrentValue();
                    setEntityHitbox(livingEntity, expandedRadius);
                   
                    Box expandedBox = calculateExpandedHitbox(livingEntity);
                    boolean isCurrentTarget = (livingEntity == currentTarget && isAimingAtHitbox);
                    renderHitbox(event.getMatrices(), expandedBox, isCurrentTarget);
                }
            }
        }
    };
   
    private final EventListener<AttackEvent> onAttack = event -> {
        Entity target = event.getEntity();
       
        if (legitSprint.isEnabled() && target instanceof LivingEntity) {
            sprintResetActive = true;
            sprintResetStartTime = System.currentTimeMillis();
        }
       
        if (!antiReach.isEnabled() || mc.player == null) {
            return;
        }
       
        if (!(target instanceof LivingEntity livingEntity)) {
            return;
        }
       
        if (livingEntity == mc.player) {
            return;
        }
       
        Box originalBox = getOriginalHitbox(livingEntity);
        Vec3d eyes = mc.player.getEyePos();
        Vec3d closestPoint = getClosestPoint(eyes, originalBox);
        double distance = eyes.distanceTo(closestPoint);
       
        double maxDistance = antiReachDistance.getCurrentValue();
       
        if (distance > maxDistance) {
            event.cancel();
           
            if (fakeSwing.isEnabled() && mc.player != null) {
                mc.player.swingHand(net.minecraft.util.Hand.MAIN_HAND);
                mc.player.resetLastAttackedTicks();
            }
        }
    };
   
    private Box getOriginalHitbox(Entity entity) {
        return entity.getType().getDimensions().getBoxAt(entity.getPos());
    }
   
    private float getEntityRadius(Entity entity) {
        Box box = getOriginalHitbox(entity);
        return (float)(box.getLengthX() / 2.0);
    }
   
    private void setEntityHitbox(LivingEntity entity, float radius) {
        entity.setBoundingBox(
            new Box(
                entity.getX() - radius,
                entity.getBoundingBox().minY,
                entity.getZ() - radius,
                entity.getX() + radius,
                entity.getBoundingBox().maxY,
                entity.getZ() + radius
            )
        );
    }
   
    private Box calculateExpandedHitbox(LivingEntity target) {
        float radius = getEntityRadius(target);
        float expandedRadius = radius + expandSize.getCurrentValue();
       
        return new Box(
            target.getX() - expandedRadius,
            target.getBoundingBox().minY,
            target.getZ() - expandedRadius,
            target.getX() + expandedRadius,
            target.getBoundingBox().maxY,
            target.getZ() + expandedRadius
        );
    }
   
    private boolean isLookingAtExpandedHitbox() {
        if (mc.player == null || currentTarget == null) {
            return false;
        }
       
        float yaw = mc.player.getYaw();
        float pitch = mc.player.getPitch();
       
        float yawRad = (float) Math.toRadians(yaw);
        float pitchRad = (float) Math.toRadians(pitch);
       
        float x = (float)(-Math.sin(yawRad) * Math.cos(pitchRad));
        float y = (float)(-Math.sin(pitchRad));
        float z = (float)(Math.cos(yawRad) * Math.cos(pitchRad));
        Vec3d direction = new Vec3d(x, y, z);
       
        Vec3d eyes = mc.player.getEyePos();
       
        Box expandedBox = calculateExpandedHitbox(currentTarget);
       
        if (expandedBox.contains(eyes)) {
            return true;
        }
       
        Vec3d end = eyes.add(direction.multiply(attackRange.getCurrentValue() + 2.0));
        return expandedBox.raycast(eyes, end).isPresent();
    }
   
    private void resetState() {
        isAimingAtHitbox = false;
    }
   
    private void handleLegitSprintReset() {
        if (mc.player == null) return;
       
        long currentTime = System.currentTimeMillis();
       
        if (sprintResetActive) {
            mc.options.sprintKey.setPressed(false);
            mc.player.setSprinting(false);
           
            if (currentTime - sprintResetStartTime >= SPRINT_RESET_DURATION) {
                sprintResetActive = false;
            }
        }
    }
   
    private boolean isAuraEnabled() {
        return Holly.getInstance().getModuleManager().getModule(Aura.class).isEnabled();
    }
   
    private void restoreAllHitboxes() {
        if (mc.world == null) return;
       
        for (Entity entity : mc.world.getEntities()) {
            if (entity instanceof LivingEntity livingEntity && livingEntity != mc.player) {
                int id = livingEntity.getId();
                if (originalHitboxes.containsKey(id)) {
                    float radius = getEntityRadius(livingEntity);
                    setEntityHitbox(livingEntity, radius);
                }
            }
        }
       
        originalHitboxes.clear();
    }
   
    private Vec3d getClosestPoint(Vec3d point, Box box) {
        double x = Math.max(box.minX, Math.min(point.x, box.maxX));
        double y = Math.max(box.minY, Math.min(point.y, box.maxY));
        double z = Math.max(box.minZ, Math.min(point.z, box.maxZ));
        return new Vec3d(x, y, z);
    }
   
    private void renderHitbox(MatrixStack matrices, Box box, boolean active) {
        if (mc.player == null) return;
       
        matrices.push();
       
        RenderSystem.enableBlend();
        RenderSystem.defaultBlendFunc();
        RenderSystem.disableDepthTest();
        RenderSystem.disableCull();
        RenderSystem.setShader(ShaderProgramKeys.POSITION_COLOR);
        RenderSystem.lineWidth(lineWidth.getCurrentValue());
       
        Vec3d cameraPos = mc.gameRenderer.getCamera().getPos();
        matrices.translate(-cameraPos.x, -cameraPos.y, -cameraPos.z);
       
        ColorRGBA color = active ? activeColor.getColor() : hitboxColor.getColor();
       
        drawBoxFilled(matrices, box, color);
       
        ColorRGBA outlineColor = new ColorRGBA(
            Math.min(255, color.getRed() + 50),
            Math.min(255, color.getGreen() + 50),
            Math.min(255, color.getBlue() + 50),
            Math.min(255, color.getAlpha() + 80)
        );
        drawBoxOutline(matrices, box, outlineColor);
       
        RenderSystem.lineWidth(1.0f);
        RenderSystem.enableDepthTest();
        RenderSystem.enableCull();
        RenderSystem.disableBlend();
       
        matrices.pop();
    }
   
    private void drawBoxFilled(MatrixStack matrices, Box box, ColorRGBA color) {
        Matrix4f matrix = matrices.peek().getPositionMatrix();
       
        Tessellator tessellator = Tessellator.getInstance();
        BufferBuilder buffer = tessellator.begin(VertexFormat.DrawMode.QUADS, VertexFormats.POSITION_COLOR);
       
        float r = color.getRed() / 255.0f;
        float g = color.getGreen() / 255.0f;
        float b = color.getBlue() / 255.0f;
        float a = color.getAlpha() / 255.0f * 0.5f;
       
        float minX = (float) box.minX;
        float minY = (float) box.minY;
        float minZ = (float) box.minZ;
        float maxX = (float) box.maxX;
        float maxY = (float) box.maxY;
        float maxZ = (float) box.maxZ;
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
       
        BufferRenderer.drawWithGlobalProgram(buffer.end());
    }
   
    private void drawBoxOutline(MatrixStack matrices, Box box, ColorRGBA color) {
        Matrix4f matrix = matrices.peek().getPositionMatrix();
       
        Tessellator tessellator = Tessellator.getInstance();
        BufferBuilder buffer = tessellator.begin(VertexFormat.DrawMode.DEBUG_LINES, VertexFormats.POSITION_COLOR);
       
        float r = color.getRed() / 255.0f;
        float g = color.getGreen() / 255.0f;
        float b = color.getBlue() / 255.0f;
        float a = color.getAlpha() / 255.0f;
       
        float minX = (float) box.minX;
        float minY = (float) box.minY;
        float minZ = (float) box.minZ;
        float maxX = (float) box.maxX;
        float maxY = (float) box.maxY;
        float maxZ = (float) box.maxZ;
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, minZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, minZ).color(r, g, b, a);
       
        buffer.vertex(matrix, maxX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, maxX, maxY, maxZ).color(r, g, b, a);
       
        buffer.vertex(matrix, minX, minY, maxZ).color(r, g, b, a);
        buffer.vertex(matrix, minX, maxY, maxZ).color(r, g, b, a);
       
        BufferRenderer.drawWithGlobalProgram(buffer.end());
    }
   
    @Override
    public void onEnable() {
        targetFinder.releaseTarget();
        currentTarget = null;
        isAimingAtHitbox = false;
        originalHitboxes.clear();
        ftSnapRotation.reset();
        sprintResetActive = false;
        sprintResetStartTime = 0;
    }
   
    @Override
    public void onDisable() {
        targetFinder.releaseTarget();
        currentTarget = null;
        isAimingAtHitbox = false;
        restoreAllHitboxes();
        ftSnapRotation.reset();
        sprintResetActive = false;
       
        if (autoTargetESP.isEnabled()) {
            Holly.getInstance().getTargetManager().setCurrentTarget(null);
        }
    }
   
    private static float rnd(float a, float b) {
        if (b <= a) return a;
        return a + ThreadLocalRandom.current().nextFloat() * (b - a);
    }
}

дай TargetFinder пж