Вопрос Как зафиксить AimModulo360

[r4ffly]

я тупое создание которое не понимает как зафиксить AimModulo360 в attackaura буду блогодарен если укажете на ошибки почему и где

package rich.modules.impl.combat;

import antidaunleak.api.annotation.Native;
import lombok.Getter;
import java.util.Random;
import lombok.experimental.NonFinal;
import net.minecraft.entity.LivingEntity;
import net.minecraft.item.Items;
import net.minecraft.item.ItemStack;
import net.minecraft.network.packet.c2s.play.ClientCommandC2SPacket;
import net.minecraft.util.Pair;
import net.minecraft.util.PlayerInput;
import net.minecraft.util.math.Box;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import rich.Initialization;
import rich.events.api.EventHandler;
import rich.events.api.types.EventType;
import rich.events.impl.InputEvent;
import rich.events.impl.RotationUpdateEvent;
import rich.events.impl.TickEvent;
import rich.modules.impl.combat.aura.Angle;
import rich.modules.impl.combat.aura.AngleConfig;
import rich.modules.impl.combat.aura.AngleConnection;
import rich.modules.impl.combat.aura.MathAngle;
import rich.modules.impl.combat.aura.attack.StrikeManager;
import rich.modules.impl.combat.aura.attack.StrikerConstructor;
import rich.modules.impl.combat.aura.impl.*;
import rich.modules.impl.combat.aura.impl.RotateConstructor;
import rich.modules.impl.combat.aura.rotations.*;
import rich.modules.impl.combat.aura.target.MultiPoint;
import rich.modules.impl.combat.aura.target.TargetFinder;
import rich.modules.impl.movement.ElytraTarget;
import rich.modules.module.ModuleStructure;
import rich.modules.module.category.ModuleCategory;
import rich.modules.module.setting.implement.*;
import rich.util.Instance;
import rich.util.math.TaskPriority;

import java.util.Objects;

public class Aura extends ModuleStructure {

    @Native(type = Native.Type.VMProtectBeginUltra)
    public static Aura getInstance() {
        return Instance.get(Aura.class);
    }

    private final SelectSetting moveFix = new SelectSetting("Коррекция движения", "Select move fix mode")
            .value("Сфокусированная", "Свободная", "Преследование", "Таргет", "Отключена")
            .selected("Focus");

    @Getter
    public final SliderSettings attackrange = new SliderSettings("Дистанция удара", "Set range value")
            .range(2.0f, 6.0f)
            .setValue(3.0f);

    private final SliderSettings lookrange = new SliderSettings("Дистанция поиска", "Set look range value")
            .range(0.0f, 10.0f)
            .setValue(1.5f);

    public final MultiSelectSetting options = new MultiSelectSetting("Настройки", "Select settings")
            .value("Бить сквозь стены", "Рандомизация крита", "Не бить если ешь")
            .selected("Бить сквозь стены", "Рандомизация крита", "Не бить если ешь");

    private final MultiSelectSetting targetType = new MultiSelectSetting("Настройка целей", "Select target settings")
            .value("Игроки", "Мобы", "Животные", "Друзья", "Стойки для брони")
            .selected("Игроки", "Мобы", "Животные");

    @Getter
    private final BooleanSetting spearMode = new BooleanSetting("Spear режим", "Включить атаку копьями")
            .setValue(false);

    @Getter
    private final SliderSettings spearRange = new SliderSettings("Дистанция копий", "Дистанция атаки копьями")
            .range(3.0f, 12.0f)
            .setValue(8.0f)
            .visible(() -> spearMode.isValue());

    @Getter
    private final SelectSetting resetSprintMode = new SelectSetting("Сброс спринта", "Reset sprint mode")
            .value("Легитный", "Пакетный", "Nuclear")
            .selected("Легитный");

    @Getter
    private final BooleanSetting checkCrit = new BooleanSetting("Только криты", "Only critical hits")
            .setValue(true);

    @Getter
    private final BooleanSetting smartCrits = new BooleanSetting("Умные криты",
            "Smart crits - attack on ground when possible")
            .setValue(true)
            .visible(() -> checkCrit.isValue());

    @Getter
    private final BooleanSetting click18Mode = new BooleanSetting("1.8 клики", "Включить режим закликивания как в 1.8")
            .setValue(false);

    @Getter
    private final SelectSetting mode = new SelectSetting("Режим наводки", "Select aim mode")
            .value("Matrix", "FunTime Snap", "Snap", "SpookyTime", "HvH", "Sloth")
            .selected("Matrix");

    public Aura() {
        super("Aura", ModuleCategory.COMBAT);
        settings(mode, attackrange, lookrange, options, targetType, spearMode, spearRange, moveFix, resetSprintMode, checkCrit, smartCrits, click18Mode);
    }

    @NonFinal
    public LivingEntity target;

    @NonFinal
    public LivingEntity lastTarget;

    private int sprintResetTimer = 0;
    private static final int RESET_DELAY = 3;
    private boolean wasSprinting = false;

    private final Random clickRandom = new Random();
    private long lastClickTime = 0;
    private long nextClickDelay = 0;

    private float continuousYaw = 0f;
    private float continuousPitch = 0f;
    private boolean rotationInitialized = false;
    private static final float MAX_ROTATION_DELTA = 180.0f;

    TargetFinder targetSelector = new TargetFinder();
    MultiPoint pointFinder = new MultiPoint();

    @Override
    public void deactivate() {
        AngleConnection.INSTANCE.startReturning();
        AngleConnection.INSTANCE.reset();
        Initialization.getInstance().getManager()
                .getAttackPerpetrator()
                .getAttackHandler()
                .resetPendingState();
        target = null;
        lastTarget = null;

        if (wasSprinting) {
            mc.player.setSprinting(true);
            wasSprinting = false;
        }

        sprintResetTimer = 0;

        if (mc.player != null) {
            rotationInitialized = false;
        }
    }

    @EventHandler
    private void tick(TickEvent event) {
        if (resetSprintMode.isSelected("Nuclear")) {
            if (sprintResetTimer > 0) {
                sprintResetTimer--;
                if (sprintResetTimer == 0 && wasSprinting) {
                    mc.player.setSprinting(true);
                    mc.getNetworkHandler().sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.START_SPRINTING));
                    wasSprinting = false;

                    rich.modules.impl.movement.AutoSprint.resetServerState();
                }
            }
        }
    }

    @EventHandler
    public void onRotationUpdate(RotationUpdateEvent e) {
        switch (e.getType()) {
            case EventType.PRE -> {
                target = updateTarget();

                if (target != null) {
                    rotateToTarget(getConfig());
                    lastTarget = target;
                } else {
                    Initialization.getInstance().getManager()
                            .getAttackPerpetrator()
                            .getAttackHandler()
                            .resetPendingState();
                    resetRotation();
                }
            }
            case EventType.POST -> {
                if (Aura.getInstance().target != null) {
                    if (canPerformAttack()) {
                        Initialization.getInstance().getManager().getAttackPerpetrator().performAttack(getConfig());
                        this.checkTargetState();
                    }
                }
            }
        }
    }

    /**
     * Безопасное создание угла - НЕ допускаем дельту больше 120 градусов за один раз.
     * Это защищает от срабатывания AimModulo360 (>320 после маленькой дельты).
     */
    private Angle createSafeAngle(Angle rawAngle) {
        if (mc.player == null) return rawAngle;

        float currentYaw = AngleConnection.INSTANCE.getRotation().getYaw();
        float currentPitch = AngleConnection.INSTANCE.getRotation().getPitch();

        float targetYaw = rawAngle.getYaw();
        float targetPitch = rawAngle.getPitch();

        // shortest path через wrapDegrees - всегда даёт значение от -180 до 180
        float deltaYaw = MathHelper.wrapDegrees(targetYaw - currentYaw);
        float deltaPitch = targetPitch - currentPitch;

        // Жёсткий лимит дельты - НИКОГДА не больше 120 градусов за один кадр.
        // Этот лимит работает совместно с лимитами в RotateConstructor (Sloth и т.д.)
        deltaYaw = MathHelper.clamp(deltaYaw, -120f, 120f);
        deltaPitch = MathHelper.clamp(deltaPitch, -90f, 90f);

        float finalYaw = currentYaw + deltaYaw;
        float finalPitch = MathHelper.clamp(currentPitch + deltaPitch, -90f, 90f);

        return new Angle(finalYaw, finalPitch);
    }

    @Native(type = Native.Type.VMProtectBeginMutation)
    public StrikerConstructor.AttackPerpetratorConfigurable getConfig() {
        float baseRange = attackrange.getValue();

        Pair<Vec3d, Box> pointData = pointFinder.computeVector(
                target,
                baseRange,
                AngleConnection.INSTANCE.getRotation(),
                getSmoothMode().randomValue(),
                options.isSelected("Бить сквозь стены"));

        Vec3d computedPoint = pointData.getLeft();
        Box hitbox = pointData.getRight();

        if (mc.player.isGliding() && target.isGliding()) {
            Vec3d targetVelocity = target.getVelocity();
            double targetSpeed = targetVelocity.horizontalLength();

            float leadTicks = 0;
            if (ElytraTarget.shouldElytraTarget && ElytraTarget.getInstance() != null
                    && ElytraTarget.getInstance().isState()) {
                leadTicks = ElytraTarget.getInstance().elytraForward.getValue();
            }

            if (targetSpeed > 0.35) {
                Vec3d predictedPos = target.getEntityPos().add(targetVelocity.multiply(leadTicks));
                computedPoint = predictedPos.add(0, target.getHeight() / 2, 0);

                hitbox = new Box(
                        predictedPos.x - target.getWidth() / 2,
                        predictedPos.y,
                        predictedPos.z - target.getWidth() / 2,
                        predictedPos.x + target.getWidth() / 2,
                        predictedPos.y + target.getHeight(),
                        predictedPos.z + target.getWidth() / 2);
            }
        }


        Angle rawAngle = MathAngle.fromVec3d(computedPoint.subtract(Objects.requireNonNull(mc.player).getEyePos()));


        Angle safeAngle = createSafeAngle(rawAngle);

        return new StrikerConstructor.AttackPerpetratorConfigurable(
                target,
                safeAngle,
                baseRange,
                options.getSelected(),
                mode,
                hitbox);
    }

    public AngleConfig getRotationConfig() {
        boolean visibleCorrection = !moveFix.isSelected("Отключена");
        boolean freeCorrection = moveFix.isSelected("Свободная");
        return new AngleConfig(getSmoothMode(), visibleCorrection, freeCorrection);
    }

    private void rotateToTarget(StrikerConstructor.AttackPerpetratorConfigurable config) {
        StrikeManager attackHandler = Initialization.getInstance().getManager().getAttackPerpetrator()
                .getAttackHandler();
        AngleConnection controller = AngleConnection.INSTANCE;


        Angle safeAngle = config.getAngle();
        Angle.VecRotation rotation = new Angle.VecRotation(safeAngle, safeAngle.toVector());
        AngleConfig rotationConfig = getRotationConfig();

        boolean elytraMode = mc.player.isGliding() && ElytraTarget.getInstance() != null
                && ElytraTarget.getInstance().isState();

        switch (mode.getSelected()) {

            case "FunTime Snap" -> {
                if (attackHandler.canAttack(config, 5)) {
                    controller.clear();
                    controller.rotateTo(rotation, target, 60, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }

            case "Snap" -> {
                if (attackHandler.canAttack(config, 0)) {
                    controller.rotateTo(rotation, target, 0, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }

            case "Matrix", "SpookyTime", "Sloth" -> {
                controller.rotateTo(rotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
            }

            case "HvH" -> {
                if (target != null && target.isAlive()) {
                    Angle.VecRotation vecRotation = new Angle.VecRotation(safeAngle, safeAngle.toVector());
                    controller.rotateTo(vecRotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }
        }

        if (elytraMode) {
            controller.rotateTo(rotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
        }
    }

    @EventHandler
    public void onInput(InputEvent event) {
        if (mc.player == null || mc.world == null)
            return;

        PlayerInput input = event.getInput();
        if (input == null)
            return;

        if (!isState())
            return;

        if (target == null || !target.isAlive())
            return;

        boolean w = mc.options.forwardKey.isPressed();
        boolean s = mc.options.backKey.isPressed();
        boolean a = mc.options.leftKey.isPressed();
        boolean d = mc.options.rightKey.isPressed();

        if (moveFix.isSelected("Таргет")) {
            Vec3d playerPos = mc.player.getEntityPos();
            Vec3d targetPos = target.getEntityPos();

            Vec3d moveTarget = new Vec3d(targetPos.x, playerPos.y, targetPos.z);
            Vec3d dir = moveTarget.subtract(playerPos).normalize();

            float yaw = MathHelper.wrapDegrees(AngleConnection.INSTANCE.getRotation().getYaw());
            float moveAngle = (float) Math.toDegrees(Math.atan2(dir.z, dir.x)) - 90F;
            float angleDiff = MathHelper.wrapDegrees(moveAngle - yaw);

            boolean forward = false, back = false, left = false, right = false;

            if (angleDiff >= -22.5 && angleDiff < 22.5) {
                forward = true;
            } else if (angleDiff >= 22.5 && angleDiff < 67.5) {
                forward = true;
                right = true;
            } else if (angleDiff >= 67.5 && angleDiff < 112.5) {
                right = true;
            } else if (angleDiff >= 112.5 && angleDiff < 157.5) {
                back = true;
                right = true;
            } else if (angleDiff >= -67.5 && angleDiff < -22.5) {
                forward = true;
                left = true;
            } else if (angleDiff >= -112.5 && angleDiff < -67.5) {
                left = true;
            } else if (angleDiff >= -157.5 && angleDiff < -112.5) {
                back = true;
                left = true;
            } else {
                back = true;
            }

            event.setDirectionalLow(forward, back, left, right);
            return;
        }

        if (moveFix.isSelected("Преследование")) {
            if (resetSprintMode.isSelected("Nuclear")) {
                if (mc.player.isSprinting()) {
                    mc.player.setSprinting(false);
                    mc.getNetworkHandler().sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.STOP_SPRINTING));
                    wasSprinting = true;
                    sprintResetTimer = RESET_DELAY;
                }
            }

            if (!w && !s && !a && !d)
                return;

            Vec3d playerPos = mc.player.getEntityPos();
            Box targetBox = target.getBoundingBox();
            Vec3d center = targetBox.getCenter();

            float targetYaw = MathHelper.wrapDegrees(target.getYaw());
            double rad = Math.toRadians(targetYaw);

            Vec3d forwardDir = new Vec3d(-Math.sin(rad), 0, Math.cos(rad)).normalize();
            Vec3d rightDir = new Vec3d(-forwardDir.z, 0, forwardDir.x).normalize();
            Vec3d leftDir = rightDir.multiply(-1);

            double halfWidth = target.getWidth() / 2.0;
            double offset = halfWidth + 0.1;

            Vec3d moveTargetVec = center;
            Vec3d offsetVec = Vec3d.ZERO;

            if (w)
                offsetVec = offsetVec.add(forwardDir);
            if (s)
                offsetVec = offsetVec.add(forwardDir.multiply(-1.0));
            if (a)
                offsetVec = offsetVec.add(leftDir);
            if (d)
                offsetVec = offsetVec.add(rightDir);

            if (offsetVec.lengthSquared() > 0) {
                offsetVec = offsetVec.normalize().multiply(offset);
                moveTargetVec = center.add(offsetVec);
            }

            moveTargetVec = new Vec3d(moveTargetVec.x, playerPos.y, moveTargetVec.z);
            Vec3d dir = moveTargetVec.subtract(playerPos).normalize();

            float yaw = MathHelper.wrapDegrees(AngleConnection.INSTANCE.getRotation().getYaw());
            float moveAngle = (float) Math.toDegrees(Math.atan2(dir.z, dir.x)) - 90F;
            float angleDiff = MathHelper.wrapDegrees(moveAngle - yaw);

            boolean forward = false, back = false, left = false, right = false;

            if (angleDiff >= -22.5 && angleDiff < 22.5) {
                forward = true;
            } else if (angleDiff >= 22.5 && angleDiff < 67.5) {
                forward = true;
                right = true;
            } else if (angleDiff >= 67.5 && angleDiff < 112.5) {
                right = true;
            } else if (angleDiff >= 112.5 && angleDiff < 157.5) {
                back = true;
                right = true;
            } else if (angleDiff >= -67.5 && angleDiff < -22.5) {
                forward = true;
                left = true;
            } else if (angleDiff >= -112.5 && angleDiff < -67.5) {
                left = true;
            } else if (angleDiff >= -157.5 && angleDiff < -112.5) {
                back = true;
                left = true;
            } else {
                back = true;
            }

            event.setDirectionalLow(forward, back, left, right);
        }
    }

    private LivingEntity updateTarget() {
        TargetFinder.EntityFilter filter = new TargetFinder.EntityFilter(targetType.getSelected());
        float range = attackrange.getValue() + 0.25F
                + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                ? ElytraTarget.getInstance().elytraFindRange.getValue()
                : lookrange.getValue());

        float dynamicFov = 360;

        targetSelector.searchTargets(mc.world.getEntities(), range, dynamicFov,
                options.isSelected("Бить сквозь стены"));

        LivingEntity bestTarget = findBestTarget(filter);

        return bestTarget;
    }

    private LivingEntity findBestTarget(TargetFinder.EntityFilter filter) {
        LivingEntity bestTarget = null;
        double bestDistance = Double.MAX_VALUE;

        for (net.minecraft.entity.Entity entity : mc.world.getEntities()) {
            if (!(entity instanceof LivingEntity)) continue;

            LivingEntity living = (LivingEntity) entity;

            if (!filter.isValid(living)) continue;

            float range = attackrange.getValue() + 0.25F
                    + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                    ? ElytraTarget.getInstance().elytraFindRange.getValue()
                    : lookrange.getValue());

            double distance = mc.player.distanceTo(living);
            if (distance > range) continue;

            if (!options.isSelected("Бить сквозь стены")) {
                if (!pointFinder.hasValidPoint(living, range, false)) continue;
            }

            if (distance < bestDistance) {
                bestTarget = living;
                bestDistance = distance;
            }
        }

        return bestTarget;
    }

    public RotateConstructor getSmoothMode() {
        if (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()) {
            return new LinearConstructor();
        }
        return switch (mode.getSelected()) {
            case "FunTime Snap" -> new FTAngle();
            case "SpookyTime" -> new SPAngle();
            case "Snap" -> new SnapAngle();
            case "Matrix" -> new MatrixAngle();
            case "HvH" -> new HvHAngle();
            case "Sloth" -> new Sloth();
            default -> new LinearConstructor();
        };
    }

    private void onTargetLost() {
        this.resetRotation();
        Aura.getInstance().target = null;
        lastTarget = null;

        Initialization.getInstance().getManager()
                .getAttackPerpetrator()
                .getAttackHandler()
                .resetPendingState();
    }

    private void resetRotation() {
        if (mc.player != null) {
            AngleConnection.INSTANCE.startReturning();
            AngleConnection.INSTANCE.reset();
            rotationInitialized = false;
        }
    }

    private boolean canPerformAttack() {
        // Режим 1.8 кликов с рандомизацией CPS (12-22)
        if (click18Mode.isValue()) {
            long now = System.currentTimeMillis();

            if (nextClickDelay == 0) {
                nextClickDelay = generateRandomClickDelay();
            }

            if (now - lastClickTime < nextClickDelay) {
                return false;
            }

            if (checkCrit.isValue()) {
                if (!canPerformCriticalHit()) {
                    return false;
                }
            }

            lastClickTime = now;
            nextClickDelay = generateRandomClickDelay();
            return true;
        }

        float cooldownProgress = mc.player.getAttackCooldownProgress(0.5f);
        if (cooldownProgress < 0.85f) {
            return false;
        }

        if (checkCrit.isValue()) {
            if (!canPerformCriticalHit()) {
                return false;
            }
        }

        return true;
    }

    private long generateRandomClickDelay() {
        // Рандом от 45 до 83 мс
        int minDelay = 45;  // 22 CPS
        int maxDelay = 83;  // 12 CPS

        long baseDelay = minDelay + clickRandom.nextInt(maxDelay - minDelay + 1);

        // Добавляем небольшой человеческий джиттер ±4мс
        baseDelay += clickRandom.nextInt(9) - 4;

        return Math.max(40, baseDelay); // минимум 40мс
    }

    private boolean canPerformCriticalHit() {
        if (mc.player.isTouchingWater() || mc.player.isClimbing() || mc.player.hasVehicle()) {
            return false;
        }

        if (mc.player.isOnGround()) {
            return false;
        }

        boolean hasBadEffect = mc.player.hasStatusEffect(net.minecraft.entity.effect.StatusEffects.SLOW_FALLING) ||
                mc.world.getBlockState(mc.player.getBlockPos()).isOf(net.minecraft.block.Blocks.COBWEB) ||
                mc.player.isInFluid() ||
                mc.player.isGliding();

        if (hasBadEffect) {
            return false;
        }

        if (mc.player.fallDistance <= 0.1F) {
            return false;
        }

        if (mc.player.getVelocity().y >= -0.1) {
            return false;
        }

        if (smartCrits.isValue()) {
            return mc.player.fallDistance >= 1.0F;
        }

        return true;
    }



    private void checkTargetState() {
        if (target == null || !target.isAlive()) {
            Initialization.getInstance().getManager()
                    .getAttackPerpetrator()
                    .getAttackHandler()
                    .resetPendingState();
        }
    }

    private boolean isValidTarget(LivingEntity entity) {
        if (entity == null || !entity.isAlive()) return false;
        if (entity == mc.player) return false;

        double distance = mc.player.distanceTo(entity);
        float maxRange = attackrange.getValue() + 0.25F
                + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                ? ElytraTarget.getInstance().elytraFindRange.getValue()
                : lookrange.getValue());

        if (distance > maxRange) return false;

        TargetFinder.EntityFilter filter = new TargetFinder.EntityFilter(targetType.getSelected());
        return filter.isValid(entity);
    }
}

package rich.modules.impl.combat.aura;

import lombok.AccessLevel;
import lombok.Getter;
import lombok.experimental.FieldDefaults;
import net.minecraft.entity.LivingEntity;
import net.minecraft.network.packet.c2s.play.PlayerMoveC2SPacket;
import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import rich.IMinecraft;
import rich.Initialization;
import rich.events.api.EventHandler;
import rich.events.api.EventManager;
import rich.events.api.types.EventType;
import rich.events.impl.PacketEvent;
import rich.events.impl.PlayerVelocityStrafeEvent;
import rich.events.impl.RotationUpdateEvent;
import rich.events.impl.TickEvent;
import rich.modules.module.ModuleStructure;
import rich.util.math.TaskPriority;
import rich.util.math.TaskProcessor;

@Getter
@FieldDefaults(level = AccessLevel.PRIVATE)
public class AngleConnection implements IMinecraft {
    public static AngleConnection INSTANCE = new AngleConnection();

    AngleConstructor lastRotationPlan;
    final TaskProcessor<AngleConstructor> rotationPlanTaskProcessor = new TaskProcessor<>();
    public Angle currentAngle;
    Angle previousAngle;
    Angle serverAngle = Angle.DEFAULT;
    Angle fakeAngle;
    boolean returning = false;


    public AngleConnection() {
        Initialization.getInstance().getManager().getEventManager().register(this);
    }

    public void setRotation(Angle value) {
        if (value == null) {
            this.previousAngle = this.currentAngle != null ? this.currentAngle : MathAngle.cameraAngle();
        } else {
            this.previousAngle = this.currentAngle;

            // АНТИДЕТЕКТ AimModulo360:
            // Если новый yaw слишком близко к границе ±360 и предыдущий был на другой стороне,
            // делаем его непрерывным, прибавляя/вычитая 360
            if (this.currentAngle != null) {
                float prevYaw = this.currentAngle.getYaw();
                float newYaw = value.getYaw();
                float delta = newYaw - prevYaw;

                // Если дельта подозрительно большая (>180) — значит произошла нормализация
                // Корректируем чтобы yaw остался непрерывным
                while (delta > 180f) {
                    newYaw -= 360f;
                    delta = newYaw - prevYaw;
                }
                while (delta < -180f) {
                    newYaw += 360f;
                    delta = newYaw - prevYaw;
                }

                value = new Angle(newYaw, value.getPitch());
            }
        }

        this.currentAngle = value;
    }

    public Angle getRotation() {
        return currentAngle != null ? currentAngle : MathAngle.cameraAngle();
    }

    public Angle getFakeRotation() {
        if (fakeAngle != null) {
            return fakeAngle;
        }

        return currentAngle != null ? currentAngle : previousAngle != null ? previousAngle : MathAngle.cameraAngle();
    }

    public void setFakeRotation(Angle angle) {
        this.fakeAngle = angle;
    }

    public Angle getPreviousRotation() {
        return currentAngle != null && previousAngle != null ? previousAngle : new Angle(mc.player.lastYaw, mc.player.lastPitch);
    }

    public Angle getMoveRotation() {
        AngleConstructor rotationPlan = getCurrentRotationPlan();
        return currentAngle != null && rotationPlan != null && rotationPlan.isMoveCorrection() ? currentAngle : MathAngle.cameraAngle();
    }

    public AngleConstructor getCurrentRotationPlan() {
        return rotationPlanTaskProcessor.fetchActiveTaskValue() != null ? rotationPlanTaskProcessor.fetchActiveTaskValue() : lastRotationPlan;
    }

    public void rotateTo(Angle.VecRotation vecRotation, LivingEntity entity, int reset, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(vecRotation.getAngle(), vecRotation.getVec(), entity, reset), taskPriority, provider);
    }

    public void rotateTo(Angle angle, int reset, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(angle, angle.toVector(), null, reset), taskPriority, provider);
    }

    public void rotateTo(Angle angle, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(angle, angle.toVector(), null, 1), taskPriority, provider);
    }

    public void rotateTo(AngleConstructor plan, TaskPriority taskPriority, ModuleStructure provider) {
        returning = false;
        rotationPlanTaskProcessor.addTask(new TaskProcessor.Task<>(1, taskPriority.getPriority(), provider, plan));
    }


    public void update() {
        AngleConstructor activePlan = getCurrentRotationPlan();

        if (activePlan == null) {
            if (currentAngle != null && returning) {
                Angle cameraAngle = MathAngle.cameraAngle();
                double diff = computeRotationDifference(currentAngle, cameraAngle);

                if (diff < 0.5) {
                    setRotation(null);
                    lastRotationPlan = null;
                    returning = false;
                } else {
                    float speed = 0.25f;
                    float distanceFactor = Math.min(1.0f, (float) diff / 30.0f);
                    speed = speed + (0.4f * distanceFactor);

                    float yawDiff = MathHelper.wrapDegrees(cameraAngle.getYaw() - currentAngle.getYaw());
                    float newYaw = currentAngle.getYaw() + yawDiff * speed;
                    float newPitch = MathHelper.lerp(speed, currentAngle.getPitch(), cameraAngle.getPitch());

                    setRotation(new Angle(newYaw, newPitch).adjustSensitivity());
                }
            }
            return;
        }

        returning = false;

        Angle clientAngle = MathAngle.cameraAngle();

        if (lastRotationPlan != null) {
            double differenceFromCurrentToPlayer = computeRotationDifference(serverAngle, clientAngle);
            if (activePlan.getTicksUntilReset() <= rotationPlanTaskProcessor.tickCounter && differenceFromCurrentToPlayer < activePlan.getResetThreshold()) {
                setRotation(null);
                lastRotationPlan = null;
                rotationPlanTaskProcessor.tickCounter = 0;
                return;
            }
        }

        Angle newAngle = activePlan.nextRotation(currentAngle != null ? currentAngle : clientAngle, rotationPlanTaskProcessor.fetchActiveTaskValue() == null).adjustSensitivity();

        setRotation(newAngle);

        lastRotationPlan = activePlan;
        rotationPlanTaskProcessor.tick(1);
    }


    public static double computeRotationDifference(Angle a, Angle b) {
        return Math.hypot(Math.abs(computeAngleDifference(a.getYaw(), b.getYaw())), Math.abs(a.getPitch() - b.getPitch()));
    }

    public static float computeAngleDifference(float a, float b) {
        return MathHelper.wrapDegrees(a - b);
    }


    private Vec3d fixVelocity(Vec3d currVelocity, Vec3d movementInput, float speed) {
        if (currentAngle != null) {
            float yaw = currentAngle.getYaw();
            double d = movementInput.lengthSquared();

            if (d < 1.0E-7) {
                return Vec3d.ZERO;
            } else {
                Vec3d vec3d = (d > 1.0 ? movementInput.normalize() : movementInput).multiply(speed);

                float f = MathHelper.sin(yaw * 0.017453292f);
                float g = MathHelper.cos(yaw * 0.017453292f);

                return new Vec3d(vec3d.getX() * g - vec3d.getZ() * f, vec3d.getY(), vec3d.getZ() * g + vec3d.getX() * f);
            }
        }
        return currVelocity;
    }

    public void clear() {
        rotationPlanTaskProcessor.activeTasks.clear();
    }

    public void startReturning() {
//        clear();
//        lastRotationPlan = null;
//        rotationPlanTaskProcessor.tickCounter = 0;
//        returning = true;
    }

    public void reset() {
//        clear();
        currentAngle = null;
        previousAngle = null;
        fakeAngle = null;
        lastRotationPlan = null;
        rotationPlanTaskProcessor.tickCounter = 0;
//        returning = false;
    }

    @EventHandler
    public void onPlayerVelocityStrafe(PlayerVelocityStrafeEvent e) {
        AngleConstructor currentRotationPlan = getCurrentRotationPlan();
        if (currentRotationPlan != null && currentRotationPlan.isMoveCorrection()) {
            e.setVelocity(fixVelocity(e.getVelocity(), e.getMovementInput(), e.getSpeed()));
        }
    }

    @EventHandler
    public void onTick(TickEvent e) {
        EventManager.callEvent(new RotationUpdateEvent(EventType.PRE));
        update();
        EventManager.callEvent(new RotationUpdateEvent(EventType.POST));
    }

    @EventHandler
    public void onPacket(PacketEvent event) {
        if (!event.isCancelled()) switch (event.getPacket()) {
            case PlayerMoveC2SPacket player when player.changesLook() ->
                    serverAngle = new Angle(player.getYaw(1), player.getPitch(1));
            case PlayerPositionLookS2CPacket player ->
                    serverAngle = new Angle(player.change().yaw(), player.change().pitch());
            default -> {
            }
        }
    }
}

надеюсь на лутше а то уже несколько дней пытаюсь делать что неиронка не помогает что не я сам

 

[des1ght_1]

я тупое создание которое не понимает как зафиксить AimModulo360 в attackaura буду блогодарен если укажете на ошибки почему и где

package rich.modules.impl.combat;

import antidaunleak.api.annotation.Native;
import lombok.Getter;
import java.util.Random;
import lombok.experimental.NonFinal;
import net.minecraft.entity.LivingEntity;
import net.minecraft.item.Items;
import net.minecraft.item.ItemStack;
import net.minecraft.network.packet.c2s.play.ClientCommandC2SPacket;
import net.minecraft.util.Pair;
import net.minecraft.util.PlayerInput;
import net.minecraft.util.math.Box;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import rich.Initialization;
import rich.events.api.EventHandler;
import rich.events.api.types.EventType;
import rich.events.impl.InputEvent;
import rich.events.impl.RotationUpdateEvent;
import rich.events.impl.TickEvent;
import rich.modules.impl.combat.aura.Angle;
import rich.modules.impl.combat.aura.AngleConfig;
import rich.modules.impl.combat.aura.AngleConnection;
import rich.modules.impl.combat.aura.MathAngle;
import rich.modules.impl.combat.aura.attack.StrikeManager;
import rich.modules.impl.combat.aura.attack.StrikerConstructor;
import rich.modules.impl.combat.aura.impl.*;
import rich.modules.impl.combat.aura.impl.RotateConstructor;
import rich.modules.impl.combat.aura.rotations.*;
import rich.modules.impl.combat.aura.target.MultiPoint;
import rich.modules.impl.combat.aura.target.TargetFinder;
import rich.modules.impl.movement.ElytraTarget;
import rich.modules.module.ModuleStructure;
import rich.modules.module.category.ModuleCategory;
import rich.modules.module.setting.implement.*;
import rich.util.Instance;
import rich.util.math.TaskPriority;

import java.util.Objects;

public class Aura extends ModuleStructure {

    @Native(type = Native.Type.VMProtectBeginUltra)
    public static Aura getInstance() {
        return Instance.get(Aura.class);
    }

    private final SelectSetting moveFix = new SelectSetting("Коррекция движения", "Select move fix mode")
            .value("Сфокусированная", "Свободная", "Преследование", "Таргет", "Отключена")
            .selected("Focus");

    @Getter
    public final SliderSettings attackrange = new SliderSettings("Дистанция удара", "Set range value")
            .range(2.0f, 6.0f)
            .setValue(3.0f);

    private final SliderSettings lookrange = new SliderSettings("Дистанция поиска", "Set look range value")
            .range(0.0f, 10.0f)
            .setValue(1.5f);

    public final MultiSelectSetting options = new MultiSelectSetting("Настройки", "Select settings")
            .value("Бить сквозь стены", "Рандомизация крита", "Не бить если ешь")
            .selected("Бить сквозь стены", "Рандомизация крита", "Не бить если ешь");

    private final MultiSelectSetting targetType = new MultiSelectSetting("Настройка целей", "Select target settings")
            .value("Игроки", "Мобы", "Животные", "Друзья", "Стойки для брони")
            .selected("Игроки", "Мобы", "Животные");

    @Getter
    private final BooleanSetting spearMode = new BooleanSetting("Spear режим", "Включить атаку копьями")
            .setValue(false);

    @Getter
    private final SliderSettings spearRange = new SliderSettings("Дистанция копий", "Дистанция атаки копьями")
            .range(3.0f, 12.0f)
            .setValue(8.0f)
            .visible(() -> spearMode.isValue());

    @Getter
    private final SelectSetting resetSprintMode = new SelectSetting("Сброс спринта", "Reset sprint mode")
            .value("Легитный", "Пакетный", "Nuclear")
            .selected("Легитный");

    @Getter
    private final BooleanSetting checkCrit = new BooleanSetting("Только криты", "Only critical hits")
            .setValue(true);

    @Getter
    private final BooleanSetting smartCrits = new BooleanSetting("Умные криты",
            "Smart crits - attack on ground when possible")
            .setValue(true)
            .visible(() -> checkCrit.isValue());

    @Getter
    private final BooleanSetting click18Mode = new BooleanSetting("1.8 клики", "Включить режим закликивания как в 1.8")
            .setValue(false);

    @Getter
    private final SelectSetting mode = new SelectSetting("Режим наводки", "Select aim mode")
            .value("Matrix", "FunTime Snap", "Snap", "SpookyTime", "HvH", "Sloth")
            .selected("Matrix");

    public Aura() {
        super("Aura", ModuleCategory.COMBAT);
        settings(mode, attackrange, lookrange, options, targetType, spearMode, spearRange, moveFix, resetSprintMode, checkCrit, smartCrits, click18Mode);
    }

    @NonFinal
    public LivingEntity target;

    @NonFinal
    public LivingEntity lastTarget;

    private int sprintResetTimer = 0;
    private static final int RESET_DELAY = 3;
    private boolean wasSprinting = false;

    private final Random clickRandom = new Random();
    private long lastClickTime = 0;
    private long nextClickDelay = 0;

    private float continuousYaw = 0f;
    private float continuousPitch = 0f;
    private boolean rotationInitialized = false;
    private static final float MAX_ROTATION_DELTA = 180.0f;

    TargetFinder targetSelector = new TargetFinder();
    MultiPoint pointFinder = new MultiPoint();

    @Override
    public void deactivate() {
        AngleConnection.INSTANCE.startReturning();
        AngleConnection.INSTANCE.reset();
        Initialization.getInstance().getManager()
                .getAttackPerpetrator()
                .getAttackHandler()
                .resetPendingState();
        target = null;
        lastTarget = null;

        if (wasSprinting) {
            mc.player.setSprinting(true);
            wasSprinting = false;
        }

        sprintResetTimer = 0;

        if (mc.player != null) {
            rotationInitialized = false;
        }
    }

    @EventHandler
    private void tick(TickEvent event) {
        if (resetSprintMode.isSelected("Nuclear")) {
            if (sprintResetTimer > 0) {
                sprintResetTimer--;
                if (sprintResetTimer == 0 && wasSprinting) {
                    mc.player.setSprinting(true);
                    mc.getNetworkHandler().sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.START_SPRINTING));
                    wasSprinting = false;

                    rich.modules.impl.movement.AutoSprint.resetServerState();
                }
            }
        }
    }

    @EventHandler
    public void onRotationUpdate(RotationUpdateEvent e) {
        switch (e.getType()) {
            case EventType.PRE -> {
                target = updateTarget();

                if (target != null) {
                    rotateToTarget(getConfig());
                    lastTarget = target;
                } else {
                    Initialization.getInstance().getManager()
                            .getAttackPerpetrator()
                            .getAttackHandler()
                            .resetPendingState();
                    resetRotation();
                }
            }
            case EventType.POST -> {
                if (Aura.getInstance().target != null) {
                    if (canPerformAttack()) {
                        Initialization.getInstance().getManager().getAttackPerpetrator().performAttack(getConfig());
                        this.checkTargetState();
                    }
                }
            }
        }
    }

    /**
     * Безопасное создание угла - НЕ допускаем дельту больше 120 градусов за один раз.
     * Это защищает от срабатывания AimModulo360 (>320 после маленькой дельты).
     */
    private Angle createSafeAngle(Angle rawAngle) {
        if (mc.player == null) return rawAngle;

        float currentYaw = AngleConnection.INSTANCE.getRotation().getYaw();
        float currentPitch = AngleConnection.INSTANCE.getRotation().getPitch();

        float targetYaw = rawAngle.getYaw();
        float targetPitch = rawAngle.getPitch();

        // shortest path через wrapDegrees - всегда даёт значение от -180 до 180
        float deltaYaw = MathHelper.wrapDegrees(targetYaw - currentYaw);
        float deltaPitch = targetPitch - currentPitch;

        // Жёсткий лимит дельты - НИКОГДА не больше 120 градусов за один кадр.
        // Этот лимит работает совместно с лимитами в RotateConstructor (Sloth и т.д.)
        deltaYaw = MathHelper.clamp(deltaYaw, -120f, 120f);
        deltaPitch = MathHelper.clamp(deltaPitch, -90f, 90f);

        float finalYaw = currentYaw + deltaYaw;
        float finalPitch = MathHelper.clamp(currentPitch + deltaPitch, -90f, 90f);

        return new Angle(finalYaw, finalPitch);
    }

    @Native(type = Native.Type.VMProtectBeginMutation)
    public StrikerConstructor.AttackPerpetratorConfigurable getConfig() {
        float baseRange = attackrange.getValue();

        Pair<Vec3d, Box> pointData = pointFinder.computeVector(
                target,
                baseRange,
                AngleConnection.INSTANCE.getRotation(),
                getSmoothMode().randomValue(),
                options.isSelected("Бить сквозь стены"));

        Vec3d computedPoint = pointData.getLeft();
        Box hitbox = pointData.getRight();

        if (mc.player.isGliding() && target.isGliding()) {
            Vec3d targetVelocity = target.getVelocity();
            double targetSpeed = targetVelocity.horizontalLength();

            float leadTicks = 0;
            if (ElytraTarget.shouldElytraTarget && ElytraTarget.getInstance() != null
                    && ElytraTarget.getInstance().isState()) {
                leadTicks = ElytraTarget.getInstance().elytraForward.getValue();
            }

            if (targetSpeed > 0.35) {
                Vec3d predictedPos = target.getEntityPos().add(targetVelocity.multiply(leadTicks));
                computedPoint = predictedPos.add(0, target.getHeight() / 2, 0);

                hitbox = new Box(
                        predictedPos.x - target.getWidth() / 2,
                        predictedPos.y,
                        predictedPos.z - target.getWidth() / 2,
                        predictedPos.x + target.getWidth() / 2,
                        predictedPos.y + target.getHeight(),
                        predictedPos.z + target.getWidth() / 2);
            }
        }


        Angle rawAngle = MathAngle.fromVec3d(computedPoint.subtract(Objects.requireNonNull(mc.player).getEyePos()));


        Angle safeAngle = createSafeAngle(rawAngle);

        return new StrikerConstructor.AttackPerpetratorConfigurable(
                target,
                safeAngle,
                baseRange,
                options.getSelected(),
                mode,
                hitbox);
    }

    public AngleConfig getRotationConfig() {
        boolean visibleCorrection = !moveFix.isSelected("Отключена");
        boolean freeCorrection = moveFix.isSelected("Свободная");
        return new AngleConfig(getSmoothMode(), visibleCorrection, freeCorrection);
    }

    private void rotateToTarget(StrikerConstructor.AttackPerpetratorConfigurable config) {
        StrikeManager attackHandler = Initialization.getInstance().getManager().getAttackPerpetrator()
                .getAttackHandler();
        AngleConnection controller = AngleConnection.INSTANCE;


        Angle safeAngle = config.getAngle();
        Angle.VecRotation rotation = new Angle.VecRotation(safeAngle, safeAngle.toVector());
        AngleConfig rotationConfig = getRotationConfig();

        boolean elytraMode = mc.player.isGliding() && ElytraTarget.getInstance() != null
                && ElytraTarget.getInstance().isState();

        switch (mode.getSelected()) {

            case "FunTime Snap" -> {
                if (attackHandler.canAttack(config, 5)) {
                    controller.clear();
                    controller.rotateTo(rotation, target, 60, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }

            case "Snap" -> {
                if (attackHandler.canAttack(config, 0)) {
                    controller.rotateTo(rotation, target, 0, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }

            case "Matrix", "SpookyTime", "Sloth" -> {
                controller.rotateTo(rotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
            }

            case "HvH" -> {
                if (target != null && target.isAlive()) {
                    Angle.VecRotation vecRotation = new Angle.VecRotation(safeAngle, safeAngle.toVector());
                    controller.rotateTo(vecRotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }
        }

        if (elytraMode) {
            controller.rotateTo(rotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
        }
    }

    @EventHandler
    public void onInput(InputEvent event) {
        if (mc.player == null || mc.world == null)
            return;

        PlayerInput input = event.getInput();
        if (input == null)
            return;

        if (!isState())
            return;

        if (target == null || !target.isAlive())
            return;

        boolean w = mc.options.forwardKey.isPressed();
        boolean s = mc.options.backKey.isPressed();
        boolean a = mc.options.leftKey.isPressed();
        boolean d = mc.options.rightKey.isPressed();

        if (moveFix.isSelected("Таргет")) {
            Vec3d playerPos = mc.player.getEntityPos();
            Vec3d targetPos = target.getEntityPos();

            Vec3d moveTarget = new Vec3d(targetPos.x, playerPos.y, targetPos.z);
            Vec3d dir = moveTarget.subtract(playerPos).normalize();

            float yaw = MathHelper.wrapDegrees(AngleConnection.INSTANCE.getRotation().getYaw());
            float moveAngle = (float) Math.toDegrees(Math.atan2(dir.z, dir.x)) - 90F;
            float angleDiff = MathHelper.wrapDegrees(moveAngle - yaw);

            boolean forward = false, back = false, left = false, right = false;

            if (angleDiff >= -22.5 && angleDiff < 22.5) {
                forward = true;
            } else if (angleDiff >= 22.5 && angleDiff < 67.5) {
                forward = true;
                right = true;
            } else if (angleDiff >= 67.5 && angleDiff < 112.5) {
                right = true;
            } else if (angleDiff >= 112.5 && angleDiff < 157.5) {
                back = true;
                right = true;
            } else if (angleDiff >= -67.5 && angleDiff < -22.5) {
                forward = true;
                left = true;
            } else if (angleDiff >= -112.5 && angleDiff < -67.5) {
                left = true;
            } else if (angleDiff >= -157.5 && angleDiff < -112.5) {
                back = true;
                left = true;
            } else {
                back = true;
            }

            event.setDirectionalLow(forward, back, left, right);
            return;
        }

        if (moveFix.isSelected("Преследование")) {
            if (resetSprintMode.isSelected("Nuclear")) {
                if (mc.player.isSprinting()) {
                    mc.player.setSprinting(false);
                    mc.getNetworkHandler().sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.STOP_SPRINTING));
                    wasSprinting = true;
                    sprintResetTimer = RESET_DELAY;
                }
            }

            if (!w && !s && !a && !d)
                return;

            Vec3d playerPos = mc.player.getEntityPos();
            Box targetBox = target.getBoundingBox();
            Vec3d center = targetBox.getCenter();

            float targetYaw = MathHelper.wrapDegrees(target.getYaw());
            double rad = Math.toRadians(targetYaw);

            Vec3d forwardDir = new Vec3d(-Math.sin(rad), 0, Math.cos(rad)).normalize();
            Vec3d rightDir = new Vec3d(-forwardDir.z, 0, forwardDir.x).normalize();
            Vec3d leftDir = rightDir.multiply(-1);

            double halfWidth = target.getWidth() / 2.0;
            double offset = halfWidth + 0.1;

            Vec3d moveTargetVec = center;
            Vec3d offsetVec = Vec3d.ZERO;

            if (w)
                offsetVec = offsetVec.add(forwardDir);
            if (s)
                offsetVec = offsetVec.add(forwardDir.multiply(-1.0));
            if (a)
                offsetVec = offsetVec.add(leftDir);
            if (d)
                offsetVec = offsetVec.add(rightDir);

            if (offsetVec.lengthSquared() > 0) {
                offsetVec = offsetVec.normalize().multiply(offset);
                moveTargetVec = center.add(offsetVec);
            }

            moveTargetVec = new Vec3d(moveTargetVec.x, playerPos.y, moveTargetVec.z);
            Vec3d dir = moveTargetVec.subtract(playerPos).normalize();

            float yaw = MathHelper.wrapDegrees(AngleConnection.INSTANCE.getRotation().getYaw());
            float moveAngle = (float) Math.toDegrees(Math.atan2(dir.z, dir.x)) - 90F;
            float angleDiff = MathHelper.wrapDegrees(moveAngle - yaw);

            boolean forward = false, back = false, left = false, right = false;

            if (angleDiff >= -22.5 && angleDiff < 22.5) {
                forward = true;
            } else if (angleDiff >= 22.5 && angleDiff < 67.5) {
                forward = true;
                right = true;
            } else if (angleDiff >= 67.5 && angleDiff < 112.5) {
                right = true;
            } else if (angleDiff >= 112.5 && angleDiff < 157.5) {
                back = true;
                right = true;
            } else if (angleDiff >= -67.5 && angleDiff < -22.5) {
                forward = true;
                left = true;
            } else if (angleDiff >= -112.5 && angleDiff < -67.5) {
                left = true;
            } else if (angleDiff >= -157.5 && angleDiff < -112.5) {
                back = true;
                left = true;
            } else {
                back = true;
            }

            event.setDirectionalLow(forward, back, left, right);
        }
    }

    private LivingEntity updateTarget() {
        TargetFinder.EntityFilter filter = new TargetFinder.EntityFilter(targetType.getSelected());
        float range = attackrange.getValue() + 0.25F
                + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                ? ElytraTarget.getInstance().elytraFindRange.getValue()
                : lookrange.getValue());

        float dynamicFov = 360;

        targetSelector.searchTargets(mc.world.getEntities(), range, dynamicFov,
                options.isSelected("Бить сквозь стены"));

        LivingEntity bestTarget = findBestTarget(filter);

        return bestTarget;
    }

    private LivingEntity findBestTarget(TargetFinder.EntityFilter filter) {
        LivingEntity bestTarget = null;
        double bestDistance = Double.MAX_VALUE;

        for (net.minecraft.entity.Entity entity : mc.world.getEntities()) {
            if (!(entity instanceof LivingEntity)) continue;

            LivingEntity living = (LivingEntity) entity;

            if (!filter.isValid(living)) continue;

            float range = attackrange.getValue() + 0.25F
                    + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                    ? ElytraTarget.getInstance().elytraFindRange.getValue()
                    : lookrange.getValue());

            double distance = mc.player.distanceTo(living);
            if (distance > range) continue;

            if (!options.isSelected("Бить сквозь стены")) {
                if (!pointFinder.hasValidPoint(living, range, false)) continue;
            }

            if (distance < bestDistance) {
                bestTarget = living;
                bestDistance = distance;
            }
        }

        return bestTarget;
    }

    public RotateConstructor getSmoothMode() {
        if (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()) {
            return new LinearConstructor();
        }
        return switch (mode.getSelected()) {
            case "FunTime Snap" -> new FTAngle();
            case "SpookyTime" -> new SPAngle();
            case "Snap" -> new SnapAngle();
            case "Matrix" -> new MatrixAngle();
            case "HvH" -> new HvHAngle();
            case "Sloth" -> new Sloth();
            default -> new LinearConstructor();
        };
    }

    private void onTargetLost() {
        this.resetRotation();
        Aura.getInstance().target = null;
        lastTarget = null;

        Initialization.getInstance().getManager()
                .getAttackPerpetrator()
                .getAttackHandler()
                .resetPendingState();
    }

    private void resetRotation() {
        if (mc.player != null) {
            AngleConnection.INSTANCE.startReturning();
            AngleConnection.INSTANCE.reset();
            rotationInitialized = false;
        }
    }

    private boolean canPerformAttack() {
        // Режим 1.8 кликов с рандомизацией CPS (12-22)
        if (click18Mode.isValue()) {
            long now = System.currentTimeMillis();

            if (nextClickDelay == 0) {
                nextClickDelay = generateRandomClickDelay();
            }

            if (now - lastClickTime < nextClickDelay) {
                return false;
            }

            if (checkCrit.isValue()) {
                if (!canPerformCriticalHit()) {
                    return false;
                }
            }

            lastClickTime = now;
            nextClickDelay = generateRandomClickDelay();
            return true;
        }

        float cooldownProgress = mc.player.getAttackCooldownProgress(0.5f);
        if (cooldownProgress < 0.85f) {
            return false;
        }

        if (checkCrit.isValue()) {
            if (!canPerformCriticalHit()) {
                return false;
            }
        }

        return true;
    }

    private long generateRandomClickDelay() {
        // Рандом от 45 до 83 мс
        int minDelay = 45;  // 22 CPS
        int maxDelay = 83;  // 12 CPS

        long baseDelay = minDelay + clickRandom.nextInt(maxDelay - minDelay + 1);

        // Добавляем небольшой человеческий джиттер ±4мс
        baseDelay += clickRandom.nextInt(9) - 4;

        return Math.max(40, baseDelay); // минимум 40мс
    }

    private boolean canPerformCriticalHit() {
        if (mc.player.isTouchingWater() || mc.player.isClimbing() || mc.player.hasVehicle()) {
            return false;
        }

        if (mc.player.isOnGround()) {
            return false;
        }

        boolean hasBadEffect = mc.player.hasStatusEffect(net.minecraft.entity.effect.StatusEffects.SLOW_FALLING) ||
                mc.world.getBlockState(mc.player.getBlockPos()).isOf(net.minecraft.block.Blocks.COBWEB) ||
                mc.player.isInFluid() ||
                mc.player.isGliding();

        if (hasBadEffect) {
            return false;
        }

        if (mc.player.fallDistance <= 0.1F) {
            return false;
        }

        if (mc.player.getVelocity().y >= -0.1) {
            return false;
        }

        if (smartCrits.isValue()) {
            return mc.player.fallDistance >= 1.0F;
        }

        return true;
    }



    private void checkTargetState() {
        if (target == null || !target.isAlive()) {
            Initialization.getInstance().getManager()
                    .getAttackPerpetrator()
                    .getAttackHandler()
                    .resetPendingState();
        }
    }

    private boolean isValidTarget(LivingEntity entity) {
        if (entity == null || !entity.isAlive()) return false;
        if (entity == mc.player) return false;

        double distance = mc.player.distanceTo(entity);
        float maxRange = attackrange.getValue() + 0.25F
                + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                ? ElytraTarget.getInstance().elytraFindRange.getValue()
                : lookrange.getValue());

        if (distance > maxRange) return false;

        TargetFinder.EntityFilter filter = new TargetFinder.EntityFilter(targetType.getSelected());
        return filter.isValid(entity);
    }
}

package rich.modules.impl.combat.aura;

import lombok.AccessLevel;
import lombok.Getter;
import lombok.experimental.FieldDefaults;
import net.minecraft.entity.LivingEntity;
import net.minecraft.network.packet.c2s.play.PlayerMoveC2SPacket;
import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import rich.IMinecraft;
import rich.Initialization;
import rich.events.api.EventHandler;
import rich.events.api.EventManager;
import rich.events.api.types.EventType;
import rich.events.impl.PacketEvent;
import rich.events.impl.PlayerVelocityStrafeEvent;
import rich.events.impl.RotationUpdateEvent;
import rich.events.impl.TickEvent;
import rich.modules.module.ModuleStructure;
import rich.util.math.TaskPriority;
import rich.util.math.TaskProcessor;

@Getter
@FieldDefaults(level = AccessLevel.PRIVATE)
public class AngleConnection implements IMinecraft {
    public static AngleConnection INSTANCE = new AngleConnection();

    AngleConstructor lastRotationPlan;
    final TaskProcessor<AngleConstructor> rotationPlanTaskProcessor = new TaskProcessor<>();
    public Angle currentAngle;
    Angle previousAngle;
    Angle serverAngle = Angle.DEFAULT;
    Angle fakeAngle;
    boolean returning = false;


    public AngleConnection() {
        Initialization.getInstance().getManager().getEventManager().register(this);
    }

    public void setRotation(Angle value) {
        if (value == null) {
            this.previousAngle = this.currentAngle != null ? this.currentAngle : MathAngle.cameraAngle();
        } else {
            this.previousAngle = this.currentAngle;

            // АНТИДЕТЕКТ AimModulo360:
            // Если новый yaw слишком близко к границе ±360 и предыдущий был на другой стороне,
            // делаем его непрерывным, прибавляя/вычитая 360
            if (this.currentAngle != null) {
                float prevYaw = this.currentAngle.getYaw();
                float newYaw = value.getYaw();
                float delta = newYaw - prevYaw;

                // Если дельта подозрительно большая (>180) — значит произошла нормализация
                // Корректируем чтобы yaw остался непрерывным
                while (delta > 180f) {
                    newYaw -= 360f;
                    delta = newYaw - prevYaw;
                }
                while (delta < -180f) {
                    newYaw += 360f;
                    delta = newYaw - prevYaw;
                }

                value = new Angle(newYaw, value.getPitch());
            }
        }

        this.currentAngle = value;
    }

    public Angle getRotation() {
        return currentAngle != null ? currentAngle : MathAngle.cameraAngle();
    }

    public Angle getFakeRotation() {
        if (fakeAngle != null) {
            return fakeAngle;
        }

        return currentAngle != null ? currentAngle : previousAngle != null ? previousAngle : MathAngle.cameraAngle();
    }

    public void setFakeRotation(Angle angle) {
        this.fakeAngle = angle;
    }

    public Angle getPreviousRotation() {
        return currentAngle != null && previousAngle != null ? previousAngle : new Angle(mc.player.lastYaw, mc.player.lastPitch);
    }

    public Angle getMoveRotation() {
        AngleConstructor rotationPlan = getCurrentRotationPlan();
        return currentAngle != null && rotationPlan != null && rotationPlan.isMoveCorrection() ? currentAngle : MathAngle.cameraAngle();
    }

    public AngleConstructor getCurrentRotationPlan() {
        return rotationPlanTaskProcessor.fetchActiveTaskValue() != null ? rotationPlanTaskProcessor.fetchActiveTaskValue() : lastRotationPlan;
    }

    public void rotateTo(Angle.VecRotation vecRotation, LivingEntity entity, int reset, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(vecRotation.getAngle(), vecRotation.getVec(), entity, reset), taskPriority, provider);
    }

    public void rotateTo(Angle angle, int reset, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(angle, angle.toVector(), null, reset), taskPriority, provider);
    }

    public void rotateTo(Angle angle, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(angle, angle.toVector(), null, 1), taskPriority, provider);
    }

    public void rotateTo(AngleConstructor plan, TaskPriority taskPriority, ModuleStructure provider) {
        returning = false;
        rotationPlanTaskProcessor.addTask(new TaskProcessor.Task<>(1, taskPriority.getPriority(), provider, plan));
    }


    public void update() {
        AngleConstructor activePlan = getCurrentRotationPlan();

        if (activePlan == null) {
            if (currentAngle != null && returning) {
                Angle cameraAngle = MathAngle.cameraAngle();
                double diff = computeRotationDifference(currentAngle, cameraAngle);

                if (diff < 0.5) {
                    setRotation(null);
                    lastRotationPlan = null;
                    returning = false;
                } else {
                    float speed = 0.25f;
                    float distanceFactor = Math.min(1.0f, (float) diff / 30.0f);
                    speed = speed + (0.4f * distanceFactor);

                    float yawDiff = MathHelper.wrapDegrees(cameraAngle.getYaw() - currentAngle.getYaw());
                    float newYaw = currentAngle.getYaw() + yawDiff * speed;
                    float newPitch = MathHelper.lerp(speed, currentAngle.getPitch(), cameraAngle.getPitch());

                    setRotation(new Angle(newYaw, newPitch).adjustSensitivity());
                }
            }
            return;
        }

        returning = false;

        Angle clientAngle = MathAngle.cameraAngle();

        if (lastRotationPlan != null) {
            double differenceFromCurrentToPlayer = computeRotationDifference(serverAngle, clientAngle);
            if (activePlan.getTicksUntilReset() <= rotationPlanTaskProcessor.tickCounter && differenceFromCurrentToPlayer < activePlan.getResetThreshold()) {
                setRotation(null);
                lastRotationPlan = null;
                rotationPlanTaskProcessor.tickCounter = 0;
                return;
            }
        }

        Angle newAngle = activePlan.nextRotation(currentAngle != null ? currentAngle : clientAngle, rotationPlanTaskProcessor.fetchActiveTaskValue() == null).adjustSensitivity();

        setRotation(newAngle);

        lastRotationPlan = activePlan;
        rotationPlanTaskProcessor.tick(1);
    }


    public static double computeRotationDifference(Angle a, Angle b) {
        return Math.hypot(Math.abs(computeAngleDifference(a.getYaw(), b.getYaw())), Math.abs(a.getPitch() - b.getPitch()));
    }

    public static float computeAngleDifference(float a, float b) {
        return MathHelper.wrapDegrees(a - b);
    }


    private Vec3d fixVelocity(Vec3d currVelocity, Vec3d movementInput, float speed) {
        if (currentAngle != null) {
            float yaw = currentAngle.getYaw();
            double d = movementInput.lengthSquared();

            if (d < 1.0E-7) {
                return Vec3d.ZERO;
            } else {
                Vec3d vec3d = (d > 1.0 ? movementInput.normalize() : movementInput).multiply(speed);

                float f = MathHelper.sin(yaw * 0.017453292f);
                float g = MathHelper.cos(yaw * 0.017453292f);

                return new Vec3d(vec3d.getX() * g - vec3d.getZ() * f, vec3d.getY(), vec3d.getZ() * g + vec3d.getX() * f);
            }
        }
        return currVelocity;
    }

    public void clear() {
        rotationPlanTaskProcessor.activeTasks.clear();
    }

    public void startReturning() {
//        clear();
//        lastRotationPlan = null;
//        rotationPlanTaskProcessor.tickCounter = 0;
//        returning = true;
    }

    public void reset() {
//        clear();
        currentAngle = null;
        previousAngle = null;
        fakeAngle = null;
        lastRotationPlan = null;
        rotationPlanTaskProcessor.tickCounter = 0;
//        returning = false;
    }

    @EventHandler
    public void onPlayerVelocityStrafe(PlayerVelocityStrafeEvent e) {
        AngleConstructor currentRotationPlan = getCurrentRotationPlan();
        if (currentRotationPlan != null && currentRotationPlan.isMoveCorrection()) {
            e.setVelocity(fixVelocity(e.getVelocity(), e.getMovementInput(), e.getSpeed()));
        }
    }

    @EventHandler
    public void onTick(TickEvent e) {
        EventManager.callEvent(new RotationUpdateEvent(EventType.PRE));
        update();
        EventManager.callEvent(new RotationUpdateEvent(EventType.POST));
    }

    @EventHandler
    public void onPacket(PacketEvent event) {
        if (!event.isCancelled()) switch (event.getPacket()) {
            case PlayerMoveC2SPacket player when player.changesLook() ->
                    serverAngle = new Angle(player.getYaw(1), player.getPitch(1));
            case PlayerPositionLookS2CPacket player ->
                    serverAngle = new Angle(player.change().yaw(), player.change().pitch());
            default -> {
            }
        }
    }
}

надеюсь на лутше а то уже несколько дней пытаюсь делать что неиронка не помогает что не я сам

А что не так с ним ты бы сказал саму ошибку хотябы

 

[GoogleEmoloyer]

 

[AloneWithDog]

Посмотреть вложение 335530

Спасибо за профессиональный разбор!

 

[hammermen]

я тупое создание которое не понимает как зафиксить AimModulo360 в attackaura буду блогодарен если укажете на ошибки почему и где

package rich.modules.impl.combat;

import antidaunleak.api.annotation.Native;
import lombok.Getter;
import java.util.Random;
import lombok.experimental.NonFinal;
import net.minecraft.entity.LivingEntity;
import net.minecraft.item.Items;
import net.minecraft.item.ItemStack;
import net.minecraft.network.packet.c2s.play.ClientCommandC2SPacket;
import net.minecraft.util.Pair;
import net.minecraft.util.PlayerInput;
import net.minecraft.util.math.Box;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import rich.Initialization;
import rich.events.api.EventHandler;
import rich.events.api.types.EventType;
import rich.events.impl.InputEvent;
import rich.events.impl.RotationUpdateEvent;
import rich.events.impl.TickEvent;
import rich.modules.impl.combat.aura.Angle;
import rich.modules.impl.combat.aura.AngleConfig;
import rich.modules.impl.combat.aura.AngleConnection;
import rich.modules.impl.combat.aura.MathAngle;
import rich.modules.impl.combat.aura.attack.StrikeManager;
import rich.modules.impl.combat.aura.attack.StrikerConstructor;
import rich.modules.impl.combat.aura.impl.*;
import rich.modules.impl.combat.aura.impl.RotateConstructor;
import rich.modules.impl.combat.aura.rotations.*;
import rich.modules.impl.combat.aura.target.MultiPoint;
import rich.modules.impl.combat.aura.target.TargetFinder;
import rich.modules.impl.movement.ElytraTarget;
import rich.modules.module.ModuleStructure;
import rich.modules.module.category.ModuleCategory;
import rich.modules.module.setting.implement.*;
import rich.util.Instance;
import rich.util.math.TaskPriority;

import java.util.Objects;

public class Aura extends ModuleStructure {

    @Native(type = Native.Type.VMProtectBeginUltra)
    public static Aura getInstance() {
        return Instance.get(Aura.class);
    }

    private final SelectSetting moveFix = new SelectSetting("Коррекция движения", "Select move fix mode")
            .value("Сфокусированная", "Свободная", "Преследование", "Таргет", "Отключена")
            .selected("Focus");

    @Getter
    public final SliderSettings attackrange = new SliderSettings("Дистанция удара", "Set range value")
            .range(2.0f, 6.0f)
            .setValue(3.0f);

    private final SliderSettings lookrange = new SliderSettings("Дистанция поиска", "Set look range value")
            .range(0.0f, 10.0f)
            .setValue(1.5f);

    public final MultiSelectSetting options = new MultiSelectSetting("Настройки", "Select settings")
            .value("Бить сквозь стены", "Рандомизация крита", "Не бить если ешь")
            .selected("Бить сквозь стены", "Рандомизация крита", "Не бить если ешь");

    private final MultiSelectSetting targetType = new MultiSelectSetting("Настройка целей", "Select target settings")
            .value("Игроки", "Мобы", "Животные", "Друзья", "Стойки для брони")
            .selected("Игроки", "Мобы", "Животные");

    @Getter
    private final BooleanSetting spearMode = new BooleanSetting("Spear режим", "Включить атаку копьями")
            .setValue(false);

    @Getter
    private final SliderSettings spearRange = new SliderSettings("Дистанция копий", "Дистанция атаки копьями")
            .range(3.0f, 12.0f)
            .setValue(8.0f)
            .visible(() -> spearMode.isValue());

    @Getter
    private final SelectSetting resetSprintMode = new SelectSetting("Сброс спринта", "Reset sprint mode")
            .value("Легитный", "Пакетный", "Nuclear")
            .selected("Легитный");

    @Getter
    private final BooleanSetting checkCrit = new BooleanSetting("Только криты", "Only critical hits")
            .setValue(true);

    @Getter
    private final BooleanSetting smartCrits = new BooleanSetting("Умные криты",
            "Smart crits - attack on ground when possible")
            .setValue(true)
            .visible(() -> checkCrit.isValue());

    @Getter
    private final BooleanSetting click18Mode = new BooleanSetting("1.8 клики", "Включить режим закликивания как в 1.8")
            .setValue(false);

    @Getter
    private final SelectSetting mode = new SelectSetting("Режим наводки", "Select aim mode")
            .value("Matrix", "FunTime Snap", "Snap", "SpookyTime", "HvH", "Sloth")
            .selected("Matrix");

    public Aura() {
        super("Aura", ModuleCategory.COMBAT);
        settings(mode, attackrange, lookrange, options, targetType, spearMode, spearRange, moveFix, resetSprintMode, checkCrit, smartCrits, click18Mode);
    }

    @NonFinal
    public LivingEntity target;

    @NonFinal
    public LivingEntity lastTarget;

    private int sprintResetTimer = 0;
    private static final int RESET_DELAY = 3;
    private boolean wasSprinting = false;

    private final Random clickRandom = new Random();
    private long lastClickTime = 0;
    private long nextClickDelay = 0;

    private float continuousYaw = 0f;
    private float continuousPitch = 0f;
    private boolean rotationInitialized = false;
    private static final float MAX_ROTATION_DELTA = 180.0f;

    TargetFinder targetSelector = new TargetFinder();
    MultiPoint pointFinder = new MultiPoint();

    @Override
    public void deactivate() {
        AngleConnection.INSTANCE.startReturning();
        AngleConnection.INSTANCE.reset();
        Initialization.getInstance().getManager()
                .getAttackPerpetrator()
                .getAttackHandler()
                .resetPendingState();
        target = null;
        lastTarget = null;

        if (wasSprinting) {
            mc.player.setSprinting(true);
            wasSprinting = false;
        }

        sprintResetTimer = 0;

        if (mc.player != null) {
            rotationInitialized = false;
        }
    }

    @EventHandler
    private void tick(TickEvent event) {
        if (resetSprintMode.isSelected("Nuclear")) {
            if (sprintResetTimer > 0) {
                sprintResetTimer--;
                if (sprintResetTimer == 0 && wasSprinting) {
                    mc.player.setSprinting(true);
                    mc.getNetworkHandler().sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.START_SPRINTING));
                    wasSprinting = false;

                    rich.modules.impl.movement.AutoSprint.resetServerState();
                }
            }
        }
    }

    @EventHandler
    public void onRotationUpdate(RotationUpdateEvent e) {
        switch (e.getType()) {
            case EventType.PRE -> {
                target = updateTarget();

                if (target != null) {
                    rotateToTarget(getConfig());
                    lastTarget = target;
                } else {
                    Initialization.getInstance().getManager()
                            .getAttackPerpetrator()
                            .getAttackHandler()
                            .resetPendingState();
                    resetRotation();
                }
            }
            case EventType.POST -> {
                if (Aura.getInstance().target != null) {
                    if (canPerformAttack()) {
                        Initialization.getInstance().getManager().getAttackPerpetrator().performAttack(getConfig());
                        this.checkTargetState();
                    }
                }
            }
        }
    }

    /**
     * Безопасное создание угла - НЕ допускаем дельту больше 120 градусов за один раз.
     * Это защищает от срабатывания AimModulo360 (>320 после маленькой дельты).
     */
    private Angle createSafeAngle(Angle rawAngle) {
        if (mc.player == null) return rawAngle;

        float currentYaw = AngleConnection.INSTANCE.getRotation().getYaw();
        float currentPitch = AngleConnection.INSTANCE.getRotation().getPitch();

        float targetYaw = rawAngle.getYaw();
        float targetPitch = rawAngle.getPitch();

        // shortest path через wrapDegrees - всегда даёт значение от -180 до 180
        float deltaYaw = MathHelper.wrapDegrees(targetYaw - currentYaw);
        float deltaPitch = targetPitch - currentPitch;

        // Жёсткий лимит дельты - НИКОГДА не больше 120 градусов за один кадр.
        // Этот лимит работает совместно с лимитами в RotateConstructor (Sloth и т.д.)
        deltaYaw = MathHelper.clamp(deltaYaw, -120f, 120f);
        deltaPitch = MathHelper.clamp(deltaPitch, -90f, 90f);

        float finalYaw = currentYaw + deltaYaw;
        float finalPitch = MathHelper.clamp(currentPitch + deltaPitch, -90f, 90f);

        return new Angle(finalYaw, finalPitch);
    }

    @Native(type = Native.Type.VMProtectBeginMutation)
    public StrikerConstructor.AttackPerpetratorConfigurable getConfig() {
        float baseRange = attackrange.getValue();

        Pair<Vec3d, Box> pointData = pointFinder.computeVector(
                target,
                baseRange,
                AngleConnection.INSTANCE.getRotation(),
                getSmoothMode().randomValue(),
                options.isSelected("Бить сквозь стены"));

        Vec3d computedPoint = pointData.getLeft();
        Box hitbox = pointData.getRight();

        if (mc.player.isGliding() && target.isGliding()) {
            Vec3d targetVelocity = target.getVelocity();
            double targetSpeed = targetVelocity.horizontalLength();

            float leadTicks = 0;
            if (ElytraTarget.shouldElytraTarget && ElytraTarget.getInstance() != null
                    && ElytraTarget.getInstance().isState()) {
                leadTicks = ElytraTarget.getInstance().elytraForward.getValue();
            }

            if (targetSpeed > 0.35) {
                Vec3d predictedPos = target.getEntityPos().add(targetVelocity.multiply(leadTicks));
                computedPoint = predictedPos.add(0, target.getHeight() / 2, 0);

                hitbox = new Box(
                        predictedPos.x - target.getWidth() / 2,
                        predictedPos.y,
                        predictedPos.z - target.getWidth() / 2,
                        predictedPos.x + target.getWidth() / 2,
                        predictedPos.y + target.getHeight(),
                        predictedPos.z + target.getWidth() / 2);
            }
        }


        Angle rawAngle = MathAngle.fromVec3d(computedPoint.subtract(Objects.requireNonNull(mc.player).getEyePos()));


        Angle safeAngle = createSafeAngle(rawAngle);

        return new StrikerConstructor.AttackPerpetratorConfigurable(
                target,
                safeAngle,
                baseRange,
                options.getSelected(),
                mode,
                hitbox);
    }

    public AngleConfig getRotationConfig() {
        boolean visibleCorrection = !moveFix.isSelected("Отключена");
        boolean freeCorrection = moveFix.isSelected("Свободная");
        return new AngleConfig(getSmoothMode(), visibleCorrection, freeCorrection);
    }

    private void rotateToTarget(StrikerConstructor.AttackPerpetratorConfigurable config) {
        StrikeManager attackHandler = Initialization.getInstance().getManager().getAttackPerpetrator()
                .getAttackHandler();
        AngleConnection controller = AngleConnection.INSTANCE;


        Angle safeAngle = config.getAngle();
        Angle.VecRotation rotation = new Angle.VecRotation(safeAngle, safeAngle.toVector());
        AngleConfig rotationConfig = getRotationConfig();

        boolean elytraMode = mc.player.isGliding() && ElytraTarget.getInstance() != null
                && ElytraTarget.getInstance().isState();

        switch (mode.getSelected()) {

            case "FunTime Snap" -> {
                if (attackHandler.canAttack(config, 5)) {
                    controller.clear();
                    controller.rotateTo(rotation, target, 60, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }

            case "Snap" -> {
                if (attackHandler.canAttack(config, 0)) {
                    controller.rotateTo(rotation, target, 0, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }

            case "Matrix", "SpookyTime", "Sloth" -> {
                controller.rotateTo(rotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
            }

            case "HvH" -> {
                if (target != null && target.isAlive()) {
                    Angle.VecRotation vecRotation = new Angle.VecRotation(safeAngle, safeAngle.toVector());
                    controller.rotateTo(vecRotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }
        }

        if (elytraMode) {
            controller.rotateTo(rotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
        }
    }

    @EventHandler
    public void onInput(InputEvent event) {
        if (mc.player == null || mc.world == null)
            return;

        PlayerInput input = event.getInput();
        if (input == null)
            return;

        if (!isState())
            return;

        if (target == null || !target.isAlive())
            return;

        boolean w = mc.options.forwardKey.isPressed();
        boolean s = mc.options.backKey.isPressed();
        boolean a = mc.options.leftKey.isPressed();
        boolean d = mc.options.rightKey.isPressed();

        if (moveFix.isSelected("Таргет")) {
            Vec3d playerPos = mc.player.getEntityPos();
            Vec3d targetPos = target.getEntityPos();

            Vec3d moveTarget = new Vec3d(targetPos.x, playerPos.y, targetPos.z);
            Vec3d dir = moveTarget.subtract(playerPos).normalize();

            float yaw = MathHelper.wrapDegrees(AngleConnection.INSTANCE.getRotation().getYaw());
            float moveAngle = (float) Math.toDegrees(Math.atan2(dir.z, dir.x)) - 90F;
            float angleDiff = MathHelper.wrapDegrees(moveAngle - yaw);

            boolean forward = false, back = false, left = false, right = false;

            if (angleDiff >= -22.5 && angleDiff < 22.5) {
                forward = true;
            } else if (angleDiff >= 22.5 && angleDiff < 67.5) {
                forward = true;
                right = true;
            } else if (angleDiff >= 67.5 && angleDiff < 112.5) {
                right = true;
            } else if (angleDiff >= 112.5 && angleDiff < 157.5) {
                back = true;
                right = true;
            } else if (angleDiff >= -67.5 && angleDiff < -22.5) {
                forward = true;
                left = true;
            } else if (angleDiff >= -112.5 && angleDiff < -67.5) {
                left = true;
            } else if (angleDiff >= -157.5 && angleDiff < -112.5) {
                back = true;
                left = true;
            } else {
                back = true;
            }

            event.setDirectionalLow(forward, back, left, right);
            return;
        }

        if (moveFix.isSelected("Преследование")) {
            if (resetSprintMode.isSelected("Nuclear")) {
                if (mc.player.isSprinting()) {
                    mc.player.setSprinting(false);
                    mc.getNetworkHandler().sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.STOP_SPRINTING));
                    wasSprinting = true;
                    sprintResetTimer = RESET_DELAY;
                }
            }

            if (!w && !s && !a && !d)
                return;

            Vec3d playerPos = mc.player.getEntityPos();
            Box targetBox = target.getBoundingBox();
            Vec3d center = targetBox.getCenter();

            float targetYaw = MathHelper.wrapDegrees(target.getYaw());
            double rad = Math.toRadians(targetYaw);

            Vec3d forwardDir = new Vec3d(-Math.sin(rad), 0, Math.cos(rad)).normalize();
            Vec3d rightDir = new Vec3d(-forwardDir.z, 0, forwardDir.x).normalize();
            Vec3d leftDir = rightDir.multiply(-1);

            double halfWidth = target.getWidth() / 2.0;
            double offset = halfWidth + 0.1;

            Vec3d moveTargetVec = center;
            Vec3d offsetVec = Vec3d.ZERO;

            if (w)
                offsetVec = offsetVec.add(forwardDir);
            if (s)
                offsetVec = offsetVec.add(forwardDir.multiply(-1.0));
            if (a)
                offsetVec = offsetVec.add(leftDir);
            if (d)
                offsetVec = offsetVec.add(rightDir);

            if (offsetVec.lengthSquared() > 0) {
                offsetVec = offsetVec.normalize().multiply(offset);
                moveTargetVec = center.add(offsetVec);
            }

            moveTargetVec = new Vec3d(moveTargetVec.x, playerPos.y, moveTargetVec.z);
            Vec3d dir = moveTargetVec.subtract(playerPos).normalize();

            float yaw = MathHelper.wrapDegrees(AngleConnection.INSTANCE.getRotation().getYaw());
            float moveAngle = (float) Math.toDegrees(Math.atan2(dir.z, dir.x)) - 90F;
            float angleDiff = MathHelper.wrapDegrees(moveAngle - yaw);

            boolean forward = false, back = false, left = false, right = false;

            if (angleDiff >= -22.5 && angleDiff < 22.5) {
                forward = true;
            } else if (angleDiff >= 22.5 && angleDiff < 67.5) {
                forward = true;
                right = true;
            } else if (angleDiff >= 67.5 && angleDiff < 112.5) {
                right = true;
            } else if (angleDiff >= 112.5 && angleDiff < 157.5) {
                back = true;
                right = true;
            } else if (angleDiff >= -67.5 && angleDiff < -22.5) {
                forward = true;
                left = true;
            } else if (angleDiff >= -112.5 && angleDiff < -67.5) {
                left = true;
            } else if (angleDiff >= -157.5 && angleDiff < -112.5) {
                back = true;
                left = true;
            } else {
                back = true;
            }

            event.setDirectionalLow(forward, back, left, right);
        }
    }

    private LivingEntity updateTarget() {
        TargetFinder.EntityFilter filter = new TargetFinder.EntityFilter(targetType.getSelected());
        float range = attackrange.getValue() + 0.25F
                + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                ? ElytraTarget.getInstance().elytraFindRange.getValue()
                : lookrange.getValue());

        float dynamicFov = 360;

        targetSelector.searchTargets(mc.world.getEntities(), range, dynamicFov,
                options.isSelected("Бить сквозь стены"));

        LivingEntity bestTarget = findBestTarget(filter);

        return bestTarget;
    }

    private LivingEntity findBestTarget(TargetFinder.EntityFilter filter) {
        LivingEntity bestTarget = null;
        double bestDistance = Double.MAX_VALUE;

        for (net.minecraft.entity.Entity entity : mc.world.getEntities()) {
            if (!(entity instanceof LivingEntity)) continue;

            LivingEntity living = (LivingEntity) entity;

            if (!filter.isValid(living)) continue;

            float range = attackrange.getValue() + 0.25F
                    + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                    ? ElytraTarget.getInstance().elytraFindRange.getValue()
                    : lookrange.getValue());

            double distance = mc.player.distanceTo(living);
            if (distance > range) continue;

            if (!options.isSelected("Бить сквозь стены")) {
                if (!pointFinder.hasValidPoint(living, range, false)) continue;
            }

            if (distance < bestDistance) {
                bestTarget = living;
                bestDistance = distance;
            }
        }

        return bestTarget;
    }

    public RotateConstructor getSmoothMode() {
        if (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()) {
            return new LinearConstructor();
        }
        return switch (mode.getSelected()) {
            case "FunTime Snap" -> new FTAngle();
            case "SpookyTime" -> new SPAngle();
            case "Snap" -> new SnapAngle();
            case "Matrix" -> new MatrixAngle();
            case "HvH" -> new HvHAngle();
            case "Sloth" -> new Sloth();
            default -> new LinearConstructor();
        };
    }

    private void onTargetLost() {
        this.resetRotation();
        Aura.getInstance().target = null;
        lastTarget = null;

        Initialization.getInstance().getManager()
                .getAttackPerpetrator()
                .getAttackHandler()
                .resetPendingState();
    }

    private void resetRotation() {
        if (mc.player != null) {
            AngleConnection.INSTANCE.startReturning();
            AngleConnection.INSTANCE.reset();
            rotationInitialized = false;
        }
    }

    private boolean canPerformAttack() {
        // Режим 1.8 кликов с рандомизацией CPS (12-22)
        if (click18Mode.isValue()) {
            long now = System.currentTimeMillis();

            if (nextClickDelay == 0) {
                nextClickDelay = generateRandomClickDelay();
            }

            if (now - lastClickTime < nextClickDelay) {
                return false;
            }

            if (checkCrit.isValue()) {
                if (!canPerformCriticalHit()) {
                    return false;
                }
            }

            lastClickTime = now;
            nextClickDelay = generateRandomClickDelay();
            return true;
        }

        float cooldownProgress = mc.player.getAttackCooldownProgress(0.5f);
        if (cooldownProgress < 0.85f) {
            return false;
        }

        if (checkCrit.isValue()) {
            if (!canPerformCriticalHit()) {
                return false;
            }
        }

        return true;
    }

    private long generateRandomClickDelay() {
        // Рандом от 45 до 83 мс
        int minDelay = 45;  // 22 CPS
        int maxDelay = 83;  // 12 CPS

        long baseDelay = minDelay + clickRandom.nextInt(maxDelay - minDelay + 1);

        // Добавляем небольшой человеческий джиттер ±4мс
        baseDelay += clickRandom.nextInt(9) - 4;

        return Math.max(40, baseDelay); // минимум 40мс
    }

    private boolean canPerformCriticalHit() {
        if (mc.player.isTouchingWater() || mc.player.isClimbing() || mc.player.hasVehicle()) {
            return false;
        }

        if (mc.player.isOnGround()) {
            return false;
        }

        boolean hasBadEffect = mc.player.hasStatusEffect(net.minecraft.entity.effect.StatusEffects.SLOW_FALLING) ||
                mc.world.getBlockState(mc.player.getBlockPos()).isOf(net.minecraft.block.Blocks.COBWEB) ||
                mc.player.isInFluid() ||
                mc.player.isGliding();

        if (hasBadEffect) {
            return false;
        }

        if (mc.player.fallDistance <= 0.1F) {
            return false;
        }

        if (mc.player.getVelocity().y >= -0.1) {
            return false;
        }

        if (smartCrits.isValue()) {
            return mc.player.fallDistance >= 1.0F;
        }

        return true;
    }



    private void checkTargetState() {
        if (target == null || !target.isAlive()) {
            Initialization.getInstance().getManager()
                    .getAttackPerpetrator()
                    .getAttackHandler()
                    .resetPendingState();
        }
    }

    private boolean isValidTarget(LivingEntity entity) {
        if (entity == null || !entity.isAlive()) return false;
        if (entity == mc.player) return false;

        double distance = mc.player.distanceTo(entity);
        float maxRange = attackrange.getValue() + 0.25F
                + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                ? ElytraTarget.getInstance().elytraFindRange.getValue()
                : lookrange.getValue());

        if (distance > maxRange) return false;

        TargetFinder.EntityFilter filter = new TargetFinder.EntityFilter(targetType.getSelected());
        return filter.isValid(entity);
    }
}

package rich.modules.impl.combat.aura;

import lombok.AccessLevel;
import lombok.Getter;
import lombok.experimental.FieldDefaults;
import net.minecraft.entity.LivingEntity;
import net.minecraft.network.packet.c2s.play.PlayerMoveC2SPacket;
import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import rich.IMinecraft;
import rich.Initialization;
import rich.events.api.EventHandler;
import rich.events.api.EventManager;
import rich.events.api.types.EventType;
import rich.events.impl.PacketEvent;
import rich.events.impl.PlayerVelocityStrafeEvent;
import rich.events.impl.RotationUpdateEvent;
import rich.events.impl.TickEvent;
import rich.modules.module.ModuleStructure;
import rich.util.math.TaskPriority;
import rich.util.math.TaskProcessor;

@Getter
@FieldDefaults(level = AccessLevel.PRIVATE)
public class AngleConnection implements IMinecraft {
    public static AngleConnection INSTANCE = new AngleConnection();

    AngleConstructor lastRotationPlan;
    final TaskProcessor<AngleConstructor> rotationPlanTaskProcessor = new TaskProcessor<>();
    public Angle currentAngle;
    Angle previousAngle;
    Angle serverAngle = Angle.DEFAULT;
    Angle fakeAngle;
    boolean returning = false;


    public AngleConnection() {
        Initialization.getInstance().getManager().getEventManager().register(this);
    }

    public void setRotation(Angle value) {
        if (value == null) {
            this.previousAngle = this.currentAngle != null ? this.currentAngle : MathAngle.cameraAngle();
        } else {
            this.previousAngle = this.currentAngle;

            // АНТИДЕТЕКТ AimModulo360:
            // Если новый yaw слишком близко к границе ±360 и предыдущий был на другой стороне,
            // делаем его непрерывным, прибавляя/вычитая 360
            if (this.currentAngle != null) {
                float prevYaw = this.currentAngle.getYaw();
                float newYaw = value.getYaw();
                float delta = newYaw - prevYaw;

                // Если дельта подозрительно большая (>180) — значит произошла нормализация
                // Корректируем чтобы yaw остался непрерывным
                while (delta > 180f) {
                    newYaw -= 360f;
                    delta = newYaw - prevYaw;
                }
                while (delta < -180f) {
                    newYaw += 360f;
                    delta = newYaw - prevYaw;
                }

                value = new Angle(newYaw, value.getPitch());
            }
        }

        this.currentAngle = value;
    }

    public Angle getRotation() {
        return currentAngle != null ? currentAngle : MathAngle.cameraAngle();
    }

    public Angle getFakeRotation() {
        if (fakeAngle != null) {
            return fakeAngle;
        }

        return currentAngle != null ? currentAngle : previousAngle != null ? previousAngle : MathAngle.cameraAngle();
    }

    public void setFakeRotation(Angle angle) {
        this.fakeAngle = angle;
    }

    public Angle getPreviousRotation() {
        return currentAngle != null && previousAngle != null ? previousAngle : new Angle(mc.player.lastYaw, mc.player.lastPitch);
    }

    public Angle getMoveRotation() {
        AngleConstructor rotationPlan = getCurrentRotationPlan();
        return currentAngle != null && rotationPlan != null && rotationPlan.isMoveCorrection() ? currentAngle : MathAngle.cameraAngle();
    }

    public AngleConstructor getCurrentRotationPlan() {
        return rotationPlanTaskProcessor.fetchActiveTaskValue() != null ? rotationPlanTaskProcessor.fetchActiveTaskValue() : lastRotationPlan;
    }

    public void rotateTo(Angle.VecRotation vecRotation, LivingEntity entity, int reset, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(vecRotation.getAngle(), vecRotation.getVec(), entity, reset), taskPriority, provider);
    }

    public void rotateTo(Angle angle, int reset, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(angle, angle.toVector(), null, reset), taskPriority, provider);
    }

    public void rotateTo(Angle angle, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(angle, angle.toVector(), null, 1), taskPriority, provider);
    }

    public void rotateTo(AngleConstructor plan, TaskPriority taskPriority, ModuleStructure provider) {
        returning = false;
        rotationPlanTaskProcessor.addTask(new TaskProcessor.Task<>(1, taskPriority.getPriority(), provider, plan));
    }


    public void update() {
        AngleConstructor activePlan = getCurrentRotationPlan();

        if (activePlan == null) {
            if (currentAngle != null && returning) {
                Angle cameraAngle = MathAngle.cameraAngle();
                double diff = computeRotationDifference(currentAngle, cameraAngle);

                if (diff < 0.5) {
                    setRotation(null);
                    lastRotationPlan = null;
                    returning = false;
                } else {
                    float speed = 0.25f;
                    float distanceFactor = Math.min(1.0f, (float) diff / 30.0f);
                    speed = speed + (0.4f * distanceFactor);

                    float yawDiff = MathHelper.wrapDegrees(cameraAngle.getYaw() - currentAngle.getYaw());
                    float newYaw = currentAngle.getYaw() + yawDiff * speed;
                    float newPitch = MathHelper.lerp(speed, currentAngle.getPitch(), cameraAngle.getPitch());

                    setRotation(new Angle(newYaw, newPitch).adjustSensitivity());
                }
            }
            return;
        }

        returning = false;

        Angle clientAngle = MathAngle.cameraAngle();

        if (lastRotationPlan != null) {
            double differenceFromCurrentToPlayer = computeRotationDifference(serverAngle, clientAngle);
            if (activePlan.getTicksUntilReset() <= rotationPlanTaskProcessor.tickCounter && differenceFromCurrentToPlayer < activePlan.getResetThreshold()) {
                setRotation(null);
                lastRotationPlan = null;
                rotationPlanTaskProcessor.tickCounter = 0;
                return;
            }
        }

        Angle newAngle = activePlan.nextRotation(currentAngle != null ? currentAngle : clientAngle, rotationPlanTaskProcessor.fetchActiveTaskValue() == null).adjustSensitivity();

        setRotation(newAngle);

        lastRotationPlan = activePlan;
        rotationPlanTaskProcessor.tick(1);
    }


    public static double computeRotationDifference(Angle a, Angle b) {
        return Math.hypot(Math.abs(computeAngleDifference(a.getYaw(), b.getYaw())), Math.abs(a.getPitch() - b.getPitch()));
    }

    public static float computeAngleDifference(float a, float b) {
        return MathHelper.wrapDegrees(a - b);
    }


    private Vec3d fixVelocity(Vec3d currVelocity, Vec3d movementInput, float speed) {
        if (currentAngle != null) {
            float yaw = currentAngle.getYaw();
            double d = movementInput.lengthSquared();

            if (d < 1.0E-7) {
                return Vec3d.ZERO;
            } else {
                Vec3d vec3d = (d > 1.0 ? movementInput.normalize() : movementInput).multiply(speed);

                float f = MathHelper.sin(yaw * 0.017453292f);
                float g = MathHelper.cos(yaw * 0.017453292f);

                return new Vec3d(vec3d.getX() * g - vec3d.getZ() * f, vec3d.getY(), vec3d.getZ() * g + vec3d.getX() * f);
            }
        }
        return currVelocity;
    }

    public void clear() {
        rotationPlanTaskProcessor.activeTasks.clear();
    }

    public void startReturning() {
//        clear();
//        lastRotationPlan = null;
//        rotationPlanTaskProcessor.tickCounter = 0;
//        returning = true;
    }

    public void reset() {
//        clear();
        currentAngle = null;
        previousAngle = null;
        fakeAngle = null;
        lastRotationPlan = null;
        rotationPlanTaskProcessor.tickCounter = 0;
//        returning = false;
    }

    @EventHandler
    public void onPlayerVelocityStrafe(PlayerVelocityStrafeEvent e) {
        AngleConstructor currentRotationPlan = getCurrentRotationPlan();
        if (currentRotationPlan != null && currentRotationPlan.isMoveCorrection()) {
            e.setVelocity(fixVelocity(e.getVelocity(), e.getMovementInput(), e.getSpeed()));
        }
    }

    @EventHandler
    public void onTick(TickEvent e) {
        EventManager.callEvent(new RotationUpdateEvent(EventType.PRE));
        update();
        EventManager.callEvent(new RotationUpdateEvent(EventType.POST));
    }

    @EventHandler
    public void onPacket(PacketEvent event) {
        if (!event.isCancelled()) switch (event.getPacket()) {
            case PlayerMoveC2SPacket player when player.changesLook() ->
                    serverAngle = new Angle(player.getYaw(1), player.getPitch(1));
            case PlayerPositionLookS2CPacket player ->
                    serverAngle = new Angle(player.change().yaw(), player.change().pitch());
            default -> {
            }
        }
    }
}

надеюсь на лутше а то уже несколько дней пытаюсь делать что неиронка не помогает что не я сам

ХВАХУХАХУХААААЗХААХАХ

 

[kultseason]

я тупое создание которое не понимает как зафиксить AimModulo360 в attackaura буду блогодарен если укажете на ошибки почему и где

package rich.modules.impl.combat;

import antidaunleak.api.annotation.Native;
import lombok.Getter;
import java.util.Random;
import lombok.experimental.NonFinal;
import net.minecraft.entity.LivingEntity;
import net.minecraft.item.Items;
import net.minecraft.item.ItemStack;
import net.minecraft.network.packet.c2s.play.ClientCommandC2SPacket;
import net.minecraft.util.Pair;
import net.minecraft.util.PlayerInput;
import net.minecraft.util.math.Box;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import rich.Initialization;
import rich.events.api.EventHandler;
import rich.events.api.types.EventType;
import rich.events.impl.InputEvent;
import rich.events.impl.RotationUpdateEvent;
import rich.events.impl.TickEvent;
import rich.modules.impl.combat.aura.Angle;
import rich.modules.impl.combat.aura.AngleConfig;
import rich.modules.impl.combat.aura.AngleConnection;
import rich.modules.impl.combat.aura.MathAngle;
import rich.modules.impl.combat.aura.attack.StrikeManager;
import rich.modules.impl.combat.aura.attack.StrikerConstructor;
import rich.modules.impl.combat.aura.impl.*;
import rich.modules.impl.combat.aura.impl.RotateConstructor;
import rich.modules.impl.combat.aura.rotations.*;
import rich.modules.impl.combat.aura.target.MultiPoint;
import rich.modules.impl.combat.aura.target.TargetFinder;
import rich.modules.impl.movement.ElytraTarget;
import rich.modules.module.ModuleStructure;
import rich.modules.module.category.ModuleCategory;
import rich.modules.module.setting.implement.*;
import rich.util.Instance;
import rich.util.math.TaskPriority;

import java.util.Objects;

public class Aura extends ModuleStructure {

    @Native(type = Native.Type.VMProtectBeginUltra)
    public static Aura getInstance() {
        return Instance.get(Aura.class);
    }

    private final SelectSetting moveFix = new SelectSetting("Коррекция движения", "Select move fix mode")
            .value("Сфокусированная", "Свободная", "Преследование", "Таргет", "Отключена")
            .selected("Focus");

    @Getter
    public final SliderSettings attackrange = new SliderSettings("Дистанция удара", "Set range value")
            .range(2.0f, 6.0f)
            .setValue(3.0f);

    private final SliderSettings lookrange = new SliderSettings("Дистанция поиска", "Set look range value")
            .range(0.0f, 10.0f)
            .setValue(1.5f);

    public final MultiSelectSetting options = new MultiSelectSetting("Настройки", "Select settings")
            .value("Бить сквозь стены", "Рандомизация крита", "Не бить если ешь")
            .selected("Бить сквозь стены", "Рандомизация крита", "Не бить если ешь");

    private final MultiSelectSetting targetType = new MultiSelectSetting("Настройка целей", "Select target settings")
            .value("Игроки", "Мобы", "Животные", "Друзья", "Стойки для брони")
            .selected("Игроки", "Мобы", "Животные");

    @Getter
    private final BooleanSetting spearMode = new BooleanSetting("Spear режим", "Включить атаку копьями")
            .setValue(false);

    @Getter
    private final SliderSettings spearRange = new SliderSettings("Дистанция копий", "Дистанция атаки копьями")
            .range(3.0f, 12.0f)
            .setValue(8.0f)
            .visible(() -> spearMode.isValue());

    @Getter
    private final SelectSetting resetSprintMode = new SelectSetting("Сброс спринта", "Reset sprint mode")
            .value("Легитный", "Пакетный", "Nuclear")
            .selected("Легитный");

    @Getter
    private final BooleanSetting checkCrit = new BooleanSetting("Только криты", "Only critical hits")
            .setValue(true);

    @Getter
    private final BooleanSetting smartCrits = new BooleanSetting("Умные криты",
            "Smart crits - attack on ground when possible")
            .setValue(true)
            .visible(() -> checkCrit.isValue());

    @Getter
    private final BooleanSetting click18Mode = new BooleanSetting("1.8 клики", "Включить режим закликивания как в 1.8")
            .setValue(false);

    @Getter
    private final SelectSetting mode = new SelectSetting("Режим наводки", "Select aim mode")
            .value("Matrix", "FunTime Snap", "Snap", "SpookyTime", "HvH", "Sloth")
            .selected("Matrix");

    public Aura() {
        super("Aura", ModuleCategory.COMBAT);
        settings(mode, attackrange, lookrange, options, targetType, spearMode, spearRange, moveFix, resetSprintMode, checkCrit, smartCrits, click18Mode);
    }

    @NonFinal
    public LivingEntity target;

    @NonFinal
    public LivingEntity lastTarget;

    private int sprintResetTimer = 0;
    private static final int RESET_DELAY = 3;
    private boolean wasSprinting = false;

    private final Random clickRandom = new Random();
    private long lastClickTime = 0;
    private long nextClickDelay = 0;

    private float continuousYaw = 0f;
    private float continuousPitch = 0f;
    private boolean rotationInitialized = false;
    private static final float MAX_ROTATION_DELTA = 180.0f;

    TargetFinder targetSelector = new TargetFinder();
    MultiPoint pointFinder = new MultiPoint();

    @Override
    public void deactivate() {
        AngleConnection.INSTANCE.startReturning();
        AngleConnection.INSTANCE.reset();
        Initialization.getInstance().getManager()
                .getAttackPerpetrator()
                .getAttackHandler()
                .resetPendingState();
        target = null;
        lastTarget = null;

        if (wasSprinting) {
            mc.player.setSprinting(true);
            wasSprinting = false;
        }

        sprintResetTimer = 0;

        if (mc.player != null) {
            rotationInitialized = false;
        }
    }

    @EventHandler
    private void tick(TickEvent event) {
        if (resetSprintMode.isSelected("Nuclear")) {
            if (sprintResetTimer > 0) {
                sprintResetTimer--;
                if (sprintResetTimer == 0 && wasSprinting) {
                    mc.player.setSprinting(true);
                    mc.getNetworkHandler().sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.START_SPRINTING));
                    wasSprinting = false;

                    rich.modules.impl.movement.AutoSprint.resetServerState();
                }
            }
        }
    }

    @EventHandler
    public void onRotationUpdate(RotationUpdateEvent e) {
        switch (e.getType()) {
            case EventType.PRE -> {
                target = updateTarget();

                if (target != null) {
                    rotateToTarget(getConfig());
                    lastTarget = target;
                } else {
                    Initialization.getInstance().getManager()
                            .getAttackPerpetrator()
                            .getAttackHandler()
                            .resetPendingState();
                    resetRotation();
                }
            }
            case EventType.POST -> {
                if (Aura.getInstance().target != null) {
                    if (canPerformAttack()) {
                        Initialization.getInstance().getManager().getAttackPerpetrator().performAttack(getConfig());
                        this.checkTargetState();
                    }
                }
            }
        }
    }

    /**
     * Безопасное создание угла - НЕ допускаем дельту больше 120 градусов за один раз.
     * Это защищает от срабатывания AimModulo360 (>320 после маленькой дельты).
     */
    private Angle createSafeAngle(Angle rawAngle) {
        if (mc.player == null) return rawAngle;

        float currentYaw = AngleConnection.INSTANCE.getRotation().getYaw();
        float currentPitch = AngleConnection.INSTANCE.getRotation().getPitch();

        float targetYaw = rawAngle.getYaw();
        float targetPitch = rawAngle.getPitch();

        // shortest path через wrapDegrees - всегда даёт значение от -180 до 180
        float deltaYaw = MathHelper.wrapDegrees(targetYaw - currentYaw);
        float deltaPitch = targetPitch - currentPitch;

        // Жёсткий лимит дельты - НИКОГДА не больше 120 градусов за один кадр.
        // Этот лимит работает совместно с лимитами в RotateConstructor (Sloth и т.д.)
        deltaYaw = MathHelper.clamp(deltaYaw, -120f, 120f);
        deltaPitch = MathHelper.clamp(deltaPitch, -90f, 90f);

        float finalYaw = currentYaw + deltaYaw;
        float finalPitch = MathHelper.clamp(currentPitch + deltaPitch, -90f, 90f);

        return new Angle(finalYaw, finalPitch);
    }

    @Native(type = Native.Type.VMProtectBeginMutation)
    public StrikerConstructor.AttackPerpetratorConfigurable getConfig() {
        float baseRange = attackrange.getValue();

        Pair<Vec3d, Box> pointData = pointFinder.computeVector(
                target,
                baseRange,
                AngleConnection.INSTANCE.getRotation(),
                getSmoothMode().randomValue(),
                options.isSelected("Бить сквозь стены"));

        Vec3d computedPoint = pointData.getLeft();
        Box hitbox = pointData.getRight();

        if (mc.player.isGliding() && target.isGliding()) {
            Vec3d targetVelocity = target.getVelocity();
            double targetSpeed = targetVelocity.horizontalLength();

            float leadTicks = 0;
            if (ElytraTarget.shouldElytraTarget && ElytraTarget.getInstance() != null
                    && ElytraTarget.getInstance().isState()) {
                leadTicks = ElytraTarget.getInstance().elytraForward.getValue();
            }

            if (targetSpeed > 0.35) {
                Vec3d predictedPos = target.getEntityPos().add(targetVelocity.multiply(leadTicks));
                computedPoint = predictedPos.add(0, target.getHeight() / 2, 0);

                hitbox = new Box(
                        predictedPos.x - target.getWidth() / 2,
                        predictedPos.y,
                        predictedPos.z - target.getWidth() / 2,
                        predictedPos.x + target.getWidth() / 2,
                        predictedPos.y + target.getHeight(),
                        predictedPos.z + target.getWidth() / 2);
            }
        }


        Angle rawAngle = MathAngle.fromVec3d(computedPoint.subtract(Objects.requireNonNull(mc.player).getEyePos()));


        Angle safeAngle = createSafeAngle(rawAngle);

        return new StrikerConstructor.AttackPerpetratorConfigurable(
                target,
                safeAngle,
                baseRange,
                options.getSelected(),
                mode,
                hitbox);
    }

    public AngleConfig getRotationConfig() {
        boolean visibleCorrection = !moveFix.isSelected("Отключена");
        boolean freeCorrection = moveFix.isSelected("Свободная");
        return new AngleConfig(getSmoothMode(), visibleCorrection, freeCorrection);
    }

    private void rotateToTarget(StrikerConstructor.AttackPerpetratorConfigurable config) {
        StrikeManager attackHandler = Initialization.getInstance().getManager().getAttackPerpetrator()
                .getAttackHandler();
        AngleConnection controller = AngleConnection.INSTANCE;


        Angle safeAngle = config.getAngle();
        Angle.VecRotation rotation = new Angle.VecRotation(safeAngle, safeAngle.toVector());
        AngleConfig rotationConfig = getRotationConfig();

        boolean elytraMode = mc.player.isGliding() && ElytraTarget.getInstance() != null
                && ElytraTarget.getInstance().isState();

        switch (mode.getSelected()) {

            case "FunTime Snap" -> {
                if (attackHandler.canAttack(config, 5)) {
                    controller.clear();
                    controller.rotateTo(rotation, target, 60, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }

            case "Snap" -> {
                if (attackHandler.canAttack(config, 0)) {
                    controller.rotateTo(rotation, target, 0, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }

            case "Matrix", "SpookyTime", "Sloth" -> {
                controller.rotateTo(rotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
            }

            case "HvH" -> {
                if (target != null && target.isAlive()) {
                    Angle.VecRotation vecRotation = new Angle.VecRotation(safeAngle, safeAngle.toVector());
                    controller.rotateTo(vecRotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
                }
            }
        }

        if (elytraMode) {
            controller.rotateTo(rotation, target, 1, rotationConfig, TaskPriority.HIGH_IMPORTANCE_1, this);
        }
    }

    @EventHandler
    public void onInput(InputEvent event) {
        if (mc.player == null || mc.world == null)
            return;

        PlayerInput input = event.getInput();
        if (input == null)
            return;

        if (!isState())
            return;

        if (target == null || !target.isAlive())
            return;

        boolean w = mc.options.forwardKey.isPressed();
        boolean s = mc.options.backKey.isPressed();
        boolean a = mc.options.leftKey.isPressed();
        boolean d = mc.options.rightKey.isPressed();

        if (moveFix.isSelected("Таргет")) {
            Vec3d playerPos = mc.player.getEntityPos();
            Vec3d targetPos = target.getEntityPos();

            Vec3d moveTarget = new Vec3d(targetPos.x, playerPos.y, targetPos.z);
            Vec3d dir = moveTarget.subtract(playerPos).normalize();

            float yaw = MathHelper.wrapDegrees(AngleConnection.INSTANCE.getRotation().getYaw());
            float moveAngle = (float) Math.toDegrees(Math.atan2(dir.z, dir.x)) - 90F;
            float angleDiff = MathHelper.wrapDegrees(moveAngle - yaw);

            boolean forward = false, back = false, left = false, right = false;

            if (angleDiff >= -22.5 && angleDiff < 22.5) {
                forward = true;
            } else if (angleDiff >= 22.5 && angleDiff < 67.5) {
                forward = true;
                right = true;
            } else if (angleDiff >= 67.5 && angleDiff < 112.5) {
                right = true;
            } else if (angleDiff >= 112.5 && angleDiff < 157.5) {
                back = true;
                right = true;
            } else if (angleDiff >= -67.5 && angleDiff < -22.5) {
                forward = true;
                left = true;
            } else if (angleDiff >= -112.5 && angleDiff < -67.5) {
                left = true;
            } else if (angleDiff >= -157.5 && angleDiff < -112.5) {
                back = true;
                left = true;
            } else {
                back = true;
            }

            event.setDirectionalLow(forward, back, left, right);
            return;
        }

        if (moveFix.isSelected("Преследование")) {
            if (resetSprintMode.isSelected("Nuclear")) {
                if (mc.player.isSprinting()) {
                    mc.player.setSprinting(false);
                    mc.getNetworkHandler().sendPacket(new ClientCommandC2SPacket(mc.player, ClientCommandC2SPacket.Mode.STOP_SPRINTING));
                    wasSprinting = true;
                    sprintResetTimer = RESET_DELAY;
                }
            }

            if (!w && !s && !a && !d)
                return;

            Vec3d playerPos = mc.player.getEntityPos();
            Box targetBox = target.getBoundingBox();
            Vec3d center = targetBox.getCenter();

            float targetYaw = MathHelper.wrapDegrees(target.getYaw());
            double rad = Math.toRadians(targetYaw);

            Vec3d forwardDir = new Vec3d(-Math.sin(rad), 0, Math.cos(rad)).normalize();
            Vec3d rightDir = new Vec3d(-forwardDir.z, 0, forwardDir.x).normalize();
            Vec3d leftDir = rightDir.multiply(-1);

            double halfWidth = target.getWidth() / 2.0;
            double offset = halfWidth + 0.1;

            Vec3d moveTargetVec = center;
            Vec3d offsetVec = Vec3d.ZERO;

            if (w)
                offsetVec = offsetVec.add(forwardDir);
            if (s)
                offsetVec = offsetVec.add(forwardDir.multiply(-1.0));
            if (a)
                offsetVec = offsetVec.add(leftDir);
            if (d)
                offsetVec = offsetVec.add(rightDir);

            if (offsetVec.lengthSquared() > 0) {
                offsetVec = offsetVec.normalize().multiply(offset);
                moveTargetVec = center.add(offsetVec);
            }

            moveTargetVec = new Vec3d(moveTargetVec.x, playerPos.y, moveTargetVec.z);
            Vec3d dir = moveTargetVec.subtract(playerPos).normalize();

            float yaw = MathHelper.wrapDegrees(AngleConnection.INSTANCE.getRotation().getYaw());
            float moveAngle = (float) Math.toDegrees(Math.atan2(dir.z, dir.x)) - 90F;
            float angleDiff = MathHelper.wrapDegrees(moveAngle - yaw);

            boolean forward = false, back = false, left = false, right = false;

            if (angleDiff >= -22.5 && angleDiff < 22.5) {
                forward = true;
            } else if (angleDiff >= 22.5 && angleDiff < 67.5) {
                forward = true;
                right = true;
            } else if (angleDiff >= 67.5 && angleDiff < 112.5) {
                right = true;
            } else if (angleDiff >= 112.5 && angleDiff < 157.5) {
                back = true;
                right = true;
            } else if (angleDiff >= -67.5 && angleDiff < -22.5) {
                forward = true;
                left = true;
            } else if (angleDiff >= -112.5 && angleDiff < -67.5) {
                left = true;
            } else if (angleDiff >= -157.5 && angleDiff < -112.5) {
                back = true;
                left = true;
            } else {
                back = true;
            }

            event.setDirectionalLow(forward, back, left, right);
        }
    }

    private LivingEntity updateTarget() {
        TargetFinder.EntityFilter filter = new TargetFinder.EntityFilter(targetType.getSelected());
        float range = attackrange.getValue() + 0.25F
                + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                ? ElytraTarget.getInstance().elytraFindRange.getValue()
                : lookrange.getValue());

        float dynamicFov = 360;

        targetSelector.searchTargets(mc.world.getEntities(), range, dynamicFov,
                options.isSelected("Бить сквозь стены"));

        LivingEntity bestTarget = findBestTarget(filter);

        return bestTarget;
    }

    private LivingEntity findBestTarget(TargetFinder.EntityFilter filter) {
        LivingEntity bestTarget = null;
        double bestDistance = Double.MAX_VALUE;

        for (net.minecraft.entity.Entity entity : mc.world.getEntities()) {
            if (!(entity instanceof LivingEntity)) continue;

            LivingEntity living = (LivingEntity) entity;

            if (!filter.isValid(living)) continue;

            float range = attackrange.getValue() + 0.25F
                    + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                    ? ElytraTarget.getInstance().elytraFindRange.getValue()
                    : lookrange.getValue());

            double distance = mc.player.distanceTo(living);
            if (distance > range) continue;

            if (!options.isSelected("Бить сквозь стены")) {
                if (!pointFinder.hasValidPoint(living, range, false)) continue;
            }

            if (distance < bestDistance) {
                bestTarget = living;
                bestDistance = distance;
            }
        }

        return bestTarget;
    }

    public RotateConstructor getSmoothMode() {
        if (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()) {
            return new LinearConstructor();
        }
        return switch (mode.getSelected()) {
            case "FunTime Snap" -> new FTAngle();
            case "SpookyTime" -> new SPAngle();
            case "Snap" -> new SnapAngle();
            case "Matrix" -> new MatrixAngle();
            case "HvH" -> new HvHAngle();
            case "Sloth" -> new Sloth();
            default -> new LinearConstructor();
        };
    }

    private void onTargetLost() {
        this.resetRotation();
        Aura.getInstance().target = null;
        lastTarget = null;

        Initialization.getInstance().getManager()
                .getAttackPerpetrator()
                .getAttackHandler()
                .resetPendingState();
    }

    private void resetRotation() {
        if (mc.player != null) {
            AngleConnection.INSTANCE.startReturning();
            AngleConnection.INSTANCE.reset();
            rotationInitialized = false;
        }
    }

    private boolean canPerformAttack() {
        // Режим 1.8 кликов с рандомизацией CPS (12-22)
        if (click18Mode.isValue()) {
            long now = System.currentTimeMillis();

            if (nextClickDelay == 0) {
                nextClickDelay = generateRandomClickDelay();
            }

            if (now - lastClickTime < nextClickDelay) {
                return false;
            }

            if (checkCrit.isValue()) {
                if (!canPerformCriticalHit()) {
                    return false;
                }
            }

            lastClickTime = now;
            nextClickDelay = generateRandomClickDelay();
            return true;
        }

        float cooldownProgress = mc.player.getAttackCooldownProgress(0.5f);
        if (cooldownProgress < 0.85f) {
            return false;
        }

        if (checkCrit.isValue()) {
            if (!canPerformCriticalHit()) {
                return false;
            }
        }

        return true;
    }

    private long generateRandomClickDelay() {
        // Рандом от 45 до 83 мс
        int minDelay = 45;  // 22 CPS
        int maxDelay = 83;  // 12 CPS

        long baseDelay = minDelay + clickRandom.nextInt(maxDelay - minDelay + 1);

        // Добавляем небольшой человеческий джиттер ±4мс
        baseDelay += clickRandom.nextInt(9) - 4;

        return Math.max(40, baseDelay); // минимум 40мс
    }

    private boolean canPerformCriticalHit() {
        if (mc.player.isTouchingWater() || mc.player.isClimbing() || mc.player.hasVehicle()) {
            return false;
        }

        if (mc.player.isOnGround()) {
            return false;
        }

        boolean hasBadEffect = mc.player.hasStatusEffect(net.minecraft.entity.effect.StatusEffects.SLOW_FALLING) ||
                mc.world.getBlockState(mc.player.getBlockPos()).isOf(net.minecraft.block.Blocks.COBWEB) ||
                mc.player.isInFluid() ||
                mc.player.isGliding();

        if (hasBadEffect) {
            return false;
        }

        if (mc.player.fallDistance <= 0.1F) {
            return false;
        }

        if (mc.player.getVelocity().y >= -0.1) {
            return false;
        }

        if (smartCrits.isValue()) {
            return mc.player.fallDistance >= 1.0F;
        }

        return true;
    }



    private void checkTargetState() {
        if (target == null || !target.isAlive()) {
            Initialization.getInstance().getManager()
                    .getAttackPerpetrator()
                    .getAttackHandler()
                    .resetPendingState();
        }
    }

    private boolean isValidTarget(LivingEntity entity) {
        if (entity == null || !entity.isAlive()) return false;
        if (entity == mc.player) return false;

        double distance = mc.player.distanceTo(entity);
        float maxRange = attackrange.getValue() + 0.25F
                + (mc.player.isGliding() && ElytraTarget.getInstance() != null && ElytraTarget.getInstance().isState()
                ? ElytraTarget.getInstance().elytraFindRange.getValue()
                : lookrange.getValue());

        if (distance > maxRange) return false;

        TargetFinder.EntityFilter filter = new TargetFinder.EntityFilter(targetType.getSelected());
        return filter.isValid(entity);
    }
}

package rich.modules.impl.combat.aura;

import lombok.AccessLevel;
import lombok.Getter;
import lombok.experimental.FieldDefaults;
import net.minecraft.entity.LivingEntity;
import net.minecraft.network.packet.c2s.play.PlayerMoveC2SPacket;
import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import rich.IMinecraft;
import rich.Initialization;
import rich.events.api.EventHandler;
import rich.events.api.EventManager;
import rich.events.api.types.EventType;
import rich.events.impl.PacketEvent;
import rich.events.impl.PlayerVelocityStrafeEvent;
import rich.events.impl.RotationUpdateEvent;
import rich.events.impl.TickEvent;
import rich.modules.module.ModuleStructure;
import rich.util.math.TaskPriority;
import rich.util.math.TaskProcessor;

@Getter
@FieldDefaults(level = AccessLevel.PRIVATE)
public class AngleConnection implements IMinecraft {
    public static AngleConnection INSTANCE = new AngleConnection();

    AngleConstructor lastRotationPlan;
    final TaskProcessor<AngleConstructor> rotationPlanTaskProcessor = new TaskProcessor<>();
    public Angle currentAngle;
    Angle previousAngle;
    Angle serverAngle = Angle.DEFAULT;
    Angle fakeAngle;
    boolean returning = false;


    public AngleConnection() {
        Initialization.getInstance().getManager().getEventManager().register(this);
    }

    public void setRotation(Angle value) {
        if (value == null) {
            this.previousAngle = this.currentAngle != null ? this.currentAngle : MathAngle.cameraAngle();
        } else {
            this.previousAngle = this.currentAngle;

            // АНТИДЕТЕКТ AimModulo360:
            // Если новый yaw слишком близко к границе ±360 и предыдущий был на другой стороне,
            // делаем его непрерывным, прибавляя/вычитая 360
            if (this.currentAngle != null) {
                float prevYaw = this.currentAngle.getYaw();
                float newYaw = value.getYaw();
                float delta = newYaw - prevYaw;

                // Если дельта подозрительно большая (>180) — значит произошла нормализация
                // Корректируем чтобы yaw остался непрерывным
                while (delta > 180f) {
                    newYaw -= 360f;
                    delta = newYaw - prevYaw;
                }
                while (delta < -180f) {
                    newYaw += 360f;
                    delta = newYaw - prevYaw;
                }

                value = new Angle(newYaw, value.getPitch());
            }
        }

        this.currentAngle = value;
    }

    public Angle getRotation() {
        return currentAngle != null ? currentAngle : MathAngle.cameraAngle();
    }

    public Angle getFakeRotation() {
        if (fakeAngle != null) {
            return fakeAngle;
        }

        return currentAngle != null ? currentAngle : previousAngle != null ? previousAngle : MathAngle.cameraAngle();
    }

    public void setFakeRotation(Angle angle) {
        this.fakeAngle = angle;
    }

    public Angle getPreviousRotation() {
        return currentAngle != null && previousAngle != null ? previousAngle : new Angle(mc.player.lastYaw, mc.player.lastPitch);
    }

    public Angle getMoveRotation() {
        AngleConstructor rotationPlan = getCurrentRotationPlan();
        return currentAngle != null && rotationPlan != null && rotationPlan.isMoveCorrection() ? currentAngle : MathAngle.cameraAngle();
    }

    public AngleConstructor getCurrentRotationPlan() {
        return rotationPlanTaskProcessor.fetchActiveTaskValue() != null ? rotationPlanTaskProcessor.fetchActiveTaskValue() : lastRotationPlan;
    }

    public void rotateTo(Angle.VecRotation vecRotation, LivingEntity entity, int reset, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(vecRotation.getAngle(), vecRotation.getVec(), entity, reset), taskPriority, provider);
    }

    public void rotateTo(Angle angle, int reset, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(angle, angle.toVector(), null, reset), taskPriority, provider);
    }

    public void rotateTo(Angle angle, AngleConfig configurable, TaskPriority taskPriority, ModuleStructure provider) {
        rotateTo(configurable.createRotationPlan(angle, angle.toVector(), null, 1), taskPriority, provider);
    }

    public void rotateTo(AngleConstructor plan, TaskPriority taskPriority, ModuleStructure provider) {
        returning = false;
        rotationPlanTaskProcessor.addTask(new TaskProcessor.Task<>(1, taskPriority.getPriority(), provider, plan));
    }


    public void update() {
        AngleConstructor activePlan = getCurrentRotationPlan();

        if (activePlan == null) {
            if (currentAngle != null && returning) {
                Angle cameraAngle = MathAngle.cameraAngle();
                double diff = computeRotationDifference(currentAngle, cameraAngle);

                if (diff < 0.5) {
                    setRotation(null);
                    lastRotationPlan = null;
                    returning = false;
                } else {
                    float speed = 0.25f;
                    float distanceFactor = Math.min(1.0f, (float) diff / 30.0f);
                    speed = speed + (0.4f * distanceFactor);

                    float yawDiff = MathHelper.wrapDegrees(cameraAngle.getYaw() - currentAngle.getYaw());
                    float newYaw = currentAngle.getYaw() + yawDiff * speed;
                    float newPitch = MathHelper.lerp(speed, currentAngle.getPitch(), cameraAngle.getPitch());

                    setRotation(new Angle(newYaw, newPitch).adjustSensitivity());
                }
            }
            return;
        }

        returning = false;

        Angle clientAngle = MathAngle.cameraAngle();

        if (lastRotationPlan != null) {
            double differenceFromCurrentToPlayer = computeRotationDifference(serverAngle, clientAngle);
            if (activePlan.getTicksUntilReset() <= rotationPlanTaskProcessor.tickCounter && differenceFromCurrentToPlayer < activePlan.getResetThreshold()) {
                setRotation(null);
                lastRotationPlan = null;
                rotationPlanTaskProcessor.tickCounter = 0;
                return;
            }
        }

        Angle newAngle = activePlan.nextRotation(currentAngle != null ? currentAngle : clientAngle, rotationPlanTaskProcessor.fetchActiveTaskValue() == null).adjustSensitivity();

        setRotation(newAngle);

        lastRotationPlan = activePlan;
        rotationPlanTaskProcessor.tick(1);
    }


    public static double computeRotationDifference(Angle a, Angle b) {
        return Math.hypot(Math.abs(computeAngleDifference(a.getYaw(), b.getYaw())), Math.abs(a.getPitch() - b.getPitch()));
    }

    public static float computeAngleDifference(float a, float b) {
        return MathHelper.wrapDegrees(a - b);
    }


    private Vec3d fixVelocity(Vec3d currVelocity, Vec3d movementInput, float speed) {
        if (currentAngle != null) {
            float yaw = currentAngle.getYaw();
            double d = movementInput.lengthSquared();

            if (d < 1.0E-7) {
                return Vec3d.ZERO;
            } else {
                Vec3d vec3d = (d > 1.0 ? movementInput.normalize() : movementInput).multiply(speed);

                float f = MathHelper.sin(yaw * 0.017453292f);
                float g = MathHelper.cos(yaw * 0.017453292f);

                return new Vec3d(vec3d.getX() * g - vec3d.getZ() * f, vec3d.getY(), vec3d.getZ() * g + vec3d.getX() * f);
            }
        }
        return currVelocity;
    }

    public void clear() {
        rotationPlanTaskProcessor.activeTasks.clear();
    }

    public void startReturning() {
//        clear();
//        lastRotationPlan = null;
//        rotationPlanTaskProcessor.tickCounter = 0;
//        returning = true;
    }

    public void reset() {
//        clear();
        currentAngle = null;
        previousAngle = null;
        fakeAngle = null;
        lastRotationPlan = null;
        rotationPlanTaskProcessor.tickCounter = 0;
//        returning = false;
    }

    @EventHandler
    public void onPlayerVelocityStrafe(PlayerVelocityStrafeEvent e) {
        AngleConstructor currentRotationPlan = getCurrentRotationPlan();
        if (currentRotationPlan != null && currentRotationPlan.isMoveCorrection()) {
            e.setVelocity(fixVelocity(e.getVelocity(), e.getMovementInput(), e.getSpeed()));
        }
    }

    @EventHandler
    public void onTick(TickEvent e) {
        EventManager.callEvent(new RotationUpdateEvent(EventType.PRE));
        update();
        EventManager.callEvent(new RotationUpdateEvent(EventType.POST));
    }

    @EventHandler
    public void onPacket(PacketEvent event) {
        if (!event.isCancelled()) switch (event.getPacket()) {
            case PlayerMoveC2SPacket player when player.changesLook() ->
                    serverAngle = new Angle(player.getYaw(1), player.getPitch(1));
            case PlayerPositionLookS2CPacket player ->
                    serverAngle = new Angle(player.change().yaw(), player.change().pitch());
            default -> {
            }
        }
    }
}

надеюсь на лутше а то уже несколько дней пытаюсь делать что неиронка не помогает что не я сам

/**<br> * Безопасное создание угла - НЕ допускаем дельту больше 120 градусов за один раз.<br> * Это защищает от срабатывания AimModulo360 (&gt;320 после маленькой дельты).<br> */


тяжелый случай

 

[r4ffly]

/**<br> * Безопасное создание угла - НЕ допускаем дельту больше 120 градусов за один раз.<br> * Это защищает от срабатывания AimModulo360 (&gt;320 после маленькой дельты).<br> */


тяжелый случай

спасибо помог прочитал текст я сам не мог