package im.expensive.functions.impl.combat; impor...

Below is a cleaned-up version of the same code that should compile in more recent (1.15–1.16+) mappings. The most common issues in the original code were:

1. Using rotationPitchHead – This field does not exist in recent versions; replace it with the standard rotationPitch.
2. Using rotationYawOffset incorrectly – In modern mappings, you typically use renderYawOffset for model/body rotation, not rotationYawOffset.
3. Assigning Integer.MIN_VALUE to a float field – This will not compile without a cast and usually is not what you actually want. Set it to 0.0F (or similar) when resetting.

Everything else is left as close to your original logic as possible. If you still get missing-method errors (e.g., getDistanceEyePos, AntiBot.isBot), those likely refer to utility methods/classes that are specific to your client and not part of vanilla/Forge. You would need to ensure those methods/classes exist in your codebase or remove them if they do not.

java
package im.expensive.functions.impl.combat;

import com.google.common.eventbus.Subscribe;
import im.expensive.Expensive;
import im.expensive.command.friends.FriendStorage;
import im.expensive.events.EventInput;
import im.expensive.events.EventMotion;
import im.expensive.events.EventUpdate;
import im.expensive.functions.api.Category;
import im.expensive.functions.api.Function;
import im.expensive.functions.api.FunctionRegister;
import im.expensive.functions.settings.impl.BooleanSetting;
import im.expensive.functions.settings.impl.ModeListSetting;
import im.expensive.functions.settings.impl.ModeSetting;
import im.expensive.functions.settings.impl.SliderSetting;
import im.expensive.utils.math.SensUtils;
import im.expensive.utils.math.StopWatch;
import im.expensive.utils.player.InventoryUtil;
import im.expensive.utils.player.MouseUtil;
import im.expensive.utils.player.MoveUtils;
import lombok.Getter;
import net.minecraft.client.entity.player.ClientPlayerEntity;
import net.minecraft.enchantment.EnchantmentHelper;
import net.minecraft.enchantment.Enchantments;
import net.minecraft.entity.Entity;
import net.minecraft.entity.LivingEntity;
import net.minecraft.entity.item.ArmorStandEntity;
import net.minecraft.entity.monster.MonsterEntity;
import net.minecraft.entity.passive.AnimalEntity;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.inventory.container.ClickType;
import net.minecraft.item.ArmorItem;
import net.minecraft.item.ItemStack;
import net.minecraft.network.play.client.CHeldItemChangePacket;
import net.minecraft.tags.FluidTags;
import net.minecraft.util.Hand;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.vector.Vector2f;
import net.minecraft.util.math.vector.Vector3d;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

import static java.lang.Math.hypot;
import static net.minecraft.util.math.MathHelper.clamp;
import static net.minecraft.util.math.MathHelper.wrapDegrees;

@FunctionRegister(name = "KillAura", type = Category.Combat)
public class KillAura extends Function {
    @Getter
    private final ModeSetting type = new ModeSetting("Тип", "Плавная", "Плавная", "Резкая");
    private final SliderSetting attackRange = new SliderSetting("Дистанция аттаки", 3f, 3f, 6f, 0.1f);

    final ModeListSetting targets = new ModeListSetting("Таргеты",
            new BooleanSetting("Игроки", true),
            new BooleanSetting("Голые", true),
            new BooleanSetting("Мобы", false),
            new BooleanSetting("Животные", false),
            new BooleanSetting("Друзья", false),
            new BooleanSetting("Голые невидимки", true),
            new BooleanSetting("Невидимки", true));

    @Getter
    final ModeListSetting options = new ModeListSetting("Опции",
            new BooleanSetting("Только криты", true),
            new BooleanSetting("Ломать щит", true),
            new BooleanSetting("Отжимать щит", true),
            new BooleanSetting("Ускорять ротацию при атаке", false),
            new BooleanSetting("Синхронизировать атаку с ТПС", false),
            new BooleanSetting("Фокусировать одну цель", true),
            new BooleanSetting("Коррекция движения", true));
    final ModeSetting correctionType = new ModeSetting("Тип коррекции", "Незаметный", "Незаметный", "Сфокусированный");

    @Getter
    private final StopWatch stopWatch = new StopWatch();
    private Vector2f rotateVector = new Vector2f(0, 0);
    @Getter
    private LivingEntity target;
    private Entity selected;

    int ticks = 0;
    boolean isRotated;

    final AutoPotion autoPotion;

    public KillAura(AutoPotion autoPotion) {
        this.autoPotion = autoPotion;
        addSettings(type, attackRange, targets, options, correctionType);
    }

    @Subscribe
    public void onInput(EventInput eventInput) {
        // Correct movement if enabled and "Незаметная" correction is chosen
        if (options.getValueByName("Коррекция движения").get() 
                && correctionType.is("Незаметный") 
                && target != null 
                && mc.player != null) {
            MoveUtils.fixMovement(eventInput, rotateVector.x);
        }
    }

    @Subscribe
    public void onUpdate(EventUpdate e) {
        // If "Фокусировать одну цель" is ON, only re-select if current target is invalid
        // Otherwise re-select each tick
        if (options.getValueByName("Фокусировать одну цель").get()) {
            if (target == null || !isValid(target)) {
                updateTarget();
            }
        } else {
            updateTarget();
        }

        // If we do have a target and we are not prevented by autoPotion
        if (target != null && !(autoPotion.isState() && autoPotion.isActive())) {
            isRotated = false;
            // Attack only if we have enough "cooldown" (or if crit requirements are satisfied)
            if (shouldPlayerFalling() && stopWatch.hasTimeElapsed()) {
                updateAttack();
                ticks = 2;
            }
            // Handle rotation style
            if (type.is("Резкая")) {
                if (ticks > 0) {
                    updateRotation(true, 180, 90);
                    ticks--;
                } else {
                    reset();
                }
            } else {
                // "Плавная" rotation
                if (!isRotated) {
                    updateRotation(false, 80, 35);
                }
            }
        } else {
            stopWatch.setLastMS(0);
            reset();
        }
    }

    @Subscribe
    private void onWalking(EventMotion e) {
        if (target == null || (autoPotion.isState() && autoPotion.isActive())) return;

        float yaw = rotateVector.x;
        float pitch = rotateVector.y;

        // Apply rotation to the motion/event
        e.setYaw(yaw);
        e.setPitch(pitch);

        // Sync the actual player rotations. 
        // rotationYawHead exists; rotationPitchHead does NOT in newer mappings, so use rotationPitch.
        mc.player.rotationYawHead = yaw;
        mc.player.renderYawOffset = yaw;
        mc.player.rotationPitch = pitch;
    }

    private void updateTarget() {
        List<LivingEntity> validTargets = new ArrayList<>();

        for (Entity entity : mc.world.getAllEntities()) {
            if (entity instanceof LivingEntity living && isValid(living)) {
                validTargets.add(living);
            }
        }

        if (validTargets.isEmpty()) {
            target = null;
            return;
        }

        if (validTargets.size() == 1) {
            target = validTargets.get(0);
            return;
        }

        // Sort by (1) armor descending, (2) health ascending, (3) distance ascending
        validTargets.sort(Comparator
                .<LivingEntity>comparingDouble(object -> {
                    if (object instanceof PlayerEntity player) {
                        return -getEntityArmor(player);
                    }
                    return -object.getTotalArmorValue();
                })
                .thenComparingDouble(object -> getEntityHealth(object))
                .thenComparingDouble(object -> mc.player.getDistance(object)));

        target = validTargets.get(0);
    }

    float lastYaw, lastPitch;

    /**
     * Updates rotation to face the target
     *
     * @param attacking if true, we can speed up rotation
     * @param rotationYawSpeed maximum yaw speed
     * @param rotationPitchSpeed maximum pitch speed
     */
    private void updateRotation(boolean attacking, float rotationYawSpeed, float rotationPitchSpeed) {
        // The vector from our eyes to the target
        Vector3d vec = target.getPositionVec()
                .add(0, clamp(mc.player.getPosYEye() - target.getPosY(), 
                              0, 
                              target.getHeight() * (mc.player.getDistanceEyePos(target) / attackRange.get())), 
                     0)
                .subtract(mc.player.getEyePosition(1.0F));

        isRotated = true;

        float yawToTarget = (float) wrapDegrees(Math.toDegrees(Math.atan2(vec.z, vec.x)) - 90.0);
        float pitchToTarget = (float) (-Math.toDegrees(Math.atan2(vec.y, hypot(vec.x, vec.z))));

        float yawDelta = wrapDegrees(yawToTarget - rotateVector.x);
        float pitchDelta = wrapDegrees(pitchToTarget - rotateVector.y);

        switch (type.get()) {
            case "Плавная" -> {
                // Smooth rotation
                float clampedYaw = Math.min(Math.max(Math.abs(yawDelta), 1.0f), rotationYawSpeed);
                float clampedPitch = Math.min(Math.max(Math.abs(pitchDelta), 1.0f), rotationPitchSpeed);

                if (attacking && selected != target && options.getValueByName("Ускорять ротацию при атаке").get()) {
                    // If we want to speed up rotation on attack
                    clampedPitch = Math.max(Math.abs(pitchDelta), 1.0f);
                } else {
                    // Slow pitch a bit more for smoothness
                    clampedPitch /= 3f;
                }

                // This condition in your original code forces at least a 3.1f difference if under 3.0f
                // (Be aware: this can cause odd snapping.)
                if (Math.abs(clampedYaw - this.lastYaw) <= 3.0f) {
                    clampedYaw = this.lastYaw + 3.1f;
                }

                // Apply +/- direction
                float yaw = rotateVector.x + (yawDelta > 0 ? clampedYaw : -clampedYaw);
                float pitch = clamp(rotateVector.y + (pitchDelta > 0 ? clampedPitch : -clampedPitch), -89.0F, 89.0F);

                // Snap to GCD (custom method from your SensUtils)
                float gcd = SensUtils.getGCDValue();
                yaw -= (yaw - rotateVector.x) % gcd;
                pitch -= (pitch - rotateVector.y) % gcd;

                rotateVector = new Vector2f(yaw, pitch);
                lastYaw = clampedYaw;
                lastPitch = clampedPitch;

                // Body correction if option is enabled
                if (options.getValueByName("Коррекция движения").get()) {
                    mc.player.renderYawOffset = yaw;
                }
            }
            case "Резкая" -> {
                // Instant or "sharp" rotation
                int roundedYaw = (int) yawDelta;
                float yaw = rotateVector.x + roundedYaw;
                float pitch = clamp(rotateVector.y + pitchDelta, -90, 90);

                float gcd = SensUtils.getGCDValue();
                yaw -= (yaw - rotateVector.x) % gcd;
                pitch -= (pitch - rotateVector.y) % gcd;

                rotateVector = new Vector2f(yaw, pitch);

                if (options.getValueByName("Коррекция движения").get()) {
                    mc.player.renderYawOffset = yaw;
                }
            }
        }
    }

    /**
     * Tries to attack the target if our crosshair truly lines up (MouseUtil check) 
     * and certain conditions are met (e.g. break shield).
     */
    private void updateAttack() {
        selected = MouseUtil.getMouseOver(target, rotateVector.x, rotateVector.y, attackRange.get());

        // Possibly speed up rotation
        if (options.getValueByName("Ускорять ротацию при атаке").get()) {
            updateRotation(true, 60, 35);
        }

        // If we cannot actually "see" the target as per the MouseUtil raytrace, skip
        if (selected == null || selected != target || mc.player.isElytraFlying()) {
            return;
        }

        // Unblock if currently holding up shield
        if (mc.player.isBlocking() && options.getValueByName("Отжимать щит").get()) {
            mc.playerController.onStoppedUsingItem(mc.player);
        }

        // Attack & swing
        stopWatch.setLastMS(500); // Resets your timer for next
        mc.playerController.attackEntity(mc.player, target);
        mc.player.swingArm(Hand.MAIN_HAND);

        // Attempt to break an opponent's shield if they're blocking
        if (target instanceof PlayerEntity player && options.getValueByName("Ломать щит").get()) {
            breakShieldPlayer(player);
        }
    }

    /**
     * Checks if we have cooled attack (and, if "Только криты", 
     * that we are in mid-air for guaranteed critical).
     */
    private boolean shouldPlayerFalling() {
        // Cancel reasons
        boolean isBadState =
                mc.player.isInWater() && mc.player.areEyesInFluid(FluidTags.WATER)
                || mc.player.isInLava()
                || mc.player.isOnLadder()
                || mc.player.isPassenger()
                || mc.player.abilities.isFlying;

        float attackStrength = mc.player.getCooledAttackStrength(
                options.getValueByName("Синхронизировать атаку с ТПС").get()
                        ? Expensive.getInstance().getTpsCalc().getAdjustTicks()
                        : 1.5f
        );

        if (attackStrength < 0.92f) return false;

        // If only crits are allowed, we must be falling (not on ground, with some fallDistance)
        if (!isBadState && options.getValueByName("Только криты").get()) {
            return !mc.player.isOnGround() && mc.player.fallDistance > 0;
        }

        return true;
    }

    /**
     * Validity checks for potential targets (distance, invisibility rules, friend checks, etc.).
     */
    private boolean isValid(LivingEntity entity) {
        // Exclude ourselves
        if (entity instanceof ClientPlayerEntity) return false;

        // Not fully spawned in yet
        if (entity.ticksExisted < 3) return false;

        // Range check
        if (mc.player.getDistanceEyePos(entity) > attackRange.get()) return false;

        // Example custom check (requires your AntiBot class)
        // if (AntiBot.isBot(entity)) return false;

        // Player checks
        if (entity instanceof PlayerEntity p) {
            // Skip friends if "Друзья" is off
            if (!targets.getValueByName("Друзья").get() && FriendStorage.isFriend(p.getName().getString())) {
                return false;
            }
            // Skip ourselves by name
            if (p.getName().getString().equalsIgnoreCase(mc.player.getName().getString())) {
                return false;
            }
            // If "Игроки" is off, skip all players
            if (!targets.getValueByName("Игроки").get()) {
                return false;
            }
            // Armor 0 -> "Голые" toggles
            if (p.getTotalArmorValue() == 0 && !targets.getValueByName("Голые").get()) {
                return false;
            }
            // Invisible with no armor?
            if (p.isInvisible() && p.getTotalArmorValue() == 0 && !targets.getValueByName("Голые невидимки").get()) {
                return false;
            }
            // Invisible in general
            if (p.isInvisible() && !targets.getValueByName("Невидимки").get()) {
                return false;
            }
        }

        // Mobs
        if (entity instanceof MonsterEntity && !targets.getValueByName("Мобы").get()) {
            return false;
        }

        // Animals
        if (entity instanceof AnimalEntity && !targets.getValueByName("Животные").get()) {
            return false;
        }

        // Must be alive, not an armor stand
        return !entity.isInvulnerable() && entity.isAlive() && !(entity instanceof ArmorStandEntity);
    }

    /**
     * Attempts to break an opponent's shield by quickly switching to an axe (if found).
     */
    private void breakShieldPlayer(PlayerEntity entity) {
        if (!entity.isBlocking()) return;

        int invSlot = InventoryUtil.getInstance().getAxeInInventory(false);
        int hotBarSlot = InventoryUtil.getInstance().getAxeInInventory(true);

        if (hotBarSlot == -1 && invSlot != -1) {
            int bestSlot = InventoryUtil.getInstance().findBestSlotInHotBar();

            // Quick in-inventory pickup swap
            mc.playerController.windowClick(0, invSlot, 0, ClickType.PICKUP, mc.player);
            mc.playerController.windowClick(0, bestSlot + 36, 0, ClickType.PICKUP, mc.player);

            // Attack with the axe
            mc.player.connection.sendPacket(new CHeldItemChangePacket(bestSlot));
            mc.playerController.attackEntity(mc.player, entity);
            mc.player.swingArm(Hand.MAIN_HAND);
            mc.player.connection.sendPacket(new CHeldItemChangePacket(mc.player.inventory.currentItem));

            // Swap items back
            mc.playerController.windowClick(0, bestSlot + 36, 0, ClickType.PICKUP, mc.player);
            mc.playerController.windowClick(0, invSlot, 0, ClickType.PICKUP, mc.player);
        }

        if (hotBarSlot != -1) {
            mc.player.connection.sendPacket(new CHeldItemChangePacket(hotBarSlot));
            mc.playerController.attackEntity(mc.player, entity);
            mc.player.swingArm(Hand.MAIN_HAND);
            mc.player.connection.sendPacket(new CHeldItemChangePacket(mc.player.inventory.currentItem));
        }
    }

    /**
     * Reset rotation to your player's current angles.
     */
    private void reset() {
        if (options.getValueByName("Коррекция движения").get()) {
            // In the original code, you set this to Integer.MIN_VALUE, 
            // but that is unsafe for a float. Usually you just zero it out:
            mc.player.renderYawOffset = 0.0F;
        }
        rotateVector = new Vector2f(mc.player.rotationYaw, mc.player.rotationPitch);
    }

    @Override
    public void onEnable() {
        super.onEnable();
        reset();
        target = null;
    }

    @Override
    public void onDisable() {
        super.onDisable();
        reset();
        stopWatch.setLastMS(0);
        target = null;
    }

    /**
     * Approximate "armor value" for a PlayerEntity, including protection enchantments.
     */
    private double getEntityArmor(PlayerEntity entityPlayer2) {
        double total = 0.0;
        for (int i = 0; i < 4; ++i) {
            ItemStack is = entityPlayer2.inventory.armorInventory.get(i);
            if (is.getItem() instanceof ArmorItem) {
                total += getProtectionLvl(is);
            }
        }
        return total;
    }

    private double getProtectionLvl(ItemStack stack) {
        if (stack.getItem() instanceof ArmorItem armor) {
            double dmgReduction = armor.getDamageReduceAmount();
            // If enchanted with PROTECTION, add some value
            if (stack.isEnchanted()) {
                dmgReduction += (double) EnchantmentHelper.getEnchantmentLevel(Enchantments.PROTECTION, stack) * 0.25;
            }
            return dmgReduction;
        }
        return 0.0;
    }

    /**
     * A rough measure of entity "threat": Health + absorption, 
     * plus some weighting for armor if it's a Player.
     */
    private double getEntityHealth(LivingEntity ent) {
        if (ent instanceof PlayerEntity player) {
            // Weighted by armor
            return (player.getHealth() + player.getAbsorptionAmount()) 
                    * (getEntityArmor(player) / 20.0);
        }
        return ent.getHealth() + ent.getAbsorptionAmount();
    }
}

Key Changes

1. Removed rotationPitchHead: In modern (1.15–1.16+ official) mappings, there is no separate rotationPitchHead; use rotationPitch instead.
2. Replaced rotationYawOffset with renderYawOffset: The commonly used field for body rotation is renderYawOffset.
3. Set renderYawOffset to 0.0F on reset (instead of Integer.MIN_VALUE). This avoids a type mismatch and strange behavior.
4. Left the rest of your logic intact, including your event calls and checks.

If your build still complains about missing methods (like getDistanceEyePos, isBot, etc.), you will need to provide or remove those utility classes/methods from your codebase. Otherwise, the above version should at least fix the typical mapping and type problems so it compiles under a standard 1.15–1.16+ mod setup.