Начинающий
Начинающий
- Статус
- Онлайн
- Регистрация
- 29 Ноя 2023
- Сообщения
- 48
- Реакции
- 0
чет пытаюсь спатсить с гпт там но килка не бьет .
почему килка не бьет?ну или пж дайте промт для ии чтобы нормально написала
могу купить готовое за рубликов 100-200 , под mytheria https://yougame.biz/threads/366144/
Код:
package ru.mytheria.main.module.combat;
import lombok.Getter;
import lombok.experimental.NonFinal;
import meteordevelopment.orbit.EventHandler;
import net.minecraft.block.Blocks;
import net.minecraft.client.MinecraftClient;
import net.minecraft.entity.*;
import net.minecraft.entity.effect.StatusEffects;
import net.minecraft.entity.mob.HostileEntity;
import net.minecraft.entity.mob.Monster;
import net.minecraft.entity.passive.AnimalEntity;
import net.minecraft.entity.passive.SquidEntity;
import net.minecraft.entity.passive.TameableEntity;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.entity.projectile.ProjectileUtil;
import net.minecraft.item.*;
import net.minecraft.text.Text;
import net.minecraft.util.Hand;
import net.minecraft.util.hit.BlockHitResult;
import net.minecraft.util.hit.EntityHitResult;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Box;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import net.minecraft.util.hit.HitResult; // Новый импорт
import net.minecraft.world.RaycastContext;
import ru.mytheria.api.events.impl.*;
import ru.mytheria.api.module.Category;
import ru.mytheria.api.module.Module;
import ru.mytheria.api.module.settings.Setting;
import ru.mytheria.api.module.settings.impl.*;
import org.joml.Vector2f;
import java.security.SecureRandom;
import java.util.*;
import java.util.concurrent.ThreadLocalRandom;
// =========================================================================
// >>>>> 0. УТИЛИТАРНЫЕ КЛАССЫ (ВОССТАНОВЛЕНЫ) <<<<<
// =========================================================================
// Утилитарный класс для подсчёта здоровья сущностей
class EntityCalculator {
private static final MinecraftClient mc = MinecraftClient.getInstance();
public static double health(LivingEntity entity) {
return entity.getHealth() + entity.getAbsorptionAmount();
}
public static double calculateEntityScore(LivingEntity entity, boolean health, boolean distance, double maxDistance) {
double score = 1.0;
if (health) score += health(entity);
if (distance) score *= 1 + entity.distanceTo(mc.player) / maxDistance;
return score;
}
}
// Утилитарный класс для ракурсов
class RaytracingUtil {
private static final MinecraftClient mc = MinecraftClient.getInstance();
// Вернул оригинальную Raycast проверку (прямой луч от глаз к глазам)
public static boolean canSeeThroughWall(Entity entity) {
if (mc.player == null || mc.world == null) return false;
return mc.world.raycast(new RaycastContext(
mc.player.getEyePos(),
entity.getEyePos(),
RaycastContext.ShapeType.COLLIDER,
RaycastContext.FluidHandling.NONE,
mc.player
)).getType() == BlockHitResult.Type.MISS;
}
}
// Утилитарный класс для чувствительности мыши
class SensUtil {
private static final MinecraftClient mc = MinecraftClient.getInstance();
public static float getGCDValue() {
if (mc.options.getMouseSensitivity() == null) return 0.001f;
float sens = (float) (mc.options.getMouseSensitivity().getValue() * 0.6 + 0.2);
float t = sens * sens * sens * 8.0f;
return t * 0.15f;
}
public static float getGCD() {
float sens = (float) (mc.options.getMouseSensitivity().getValue() * 0.6 + 0.2);
return sens * sens * sens * 8;
}
}
// Класс для хранения углов
record AngleDelta(float yawDelta, float pitchDelta) {}
// Утилитарный класс для расчёта углов
class MathAngle {
private static final MinecraftClient mc = MinecraftClient.getInstance();
public static AngleDelta calculateDelta(Vector2f current, Vector2f target) {
float yawDelta = MathHelper.wrapDegrees(target.y - current.y);
float pitchDelta = target.x - current.x;
return new AngleDelta(yawDelta, pitchDelta);
}
public static Vector2f calculateAnglesToTarget(Entity target) {
if (mc.player == null) return new Vector2f(0, 0);
double deltaX = target.getX() - mc.player.getX();
double deltaY = (target.getEyeY() - mc.player.getEyeY());
double deltaZ = target.getZ() - mc.player.getZ();
double distanceXZ = Math.sqrt(deltaX * deltaX + deltaZ * deltaZ);
float yaw = (float) Math.toDegrees(Math.atan2(deltaZ, deltaX)) - 90.0f;
float pitch = (float) -Math.toDegrees(Math.atan2(deltaY, distanceXZ));
pitch = MathHelper.clamp(pitch, -90.0f, 90.0f);
yaw = MathHelper.wrapDegrees(yaw);
return new Vector2f(pitch, yaw);
}
}
// Класс для управления атакой (Минимально изменен, чтобы не сломать)
class AttackHandler {
private static final MinecraftClient mc = MinecraftClient.getInstance();
private static long lastLeftClickTime = 0;
private static Entity selected = null;
// ВАЖНО: ЭТОТ МЕТОД НЕ ИСПОЛЬЗУЕТСЯ В 1.9 ЛОГИКЕ КИЛЛ-АУРЫ В ЭТОМ МОДУЛЕ
public static void updateAttack(LivingEntity target, float attackRange, boolean onlyCrits) {
if (mc.player == null || mc.interactionManager == null || target == null) return;
// ... (Логика 1.8 с CPS и кулдауном)
}
private static Entity getMouseOver(Entity target, double distance) {
Entity entity = mc.getCameraEntity();
if (entity == null || mc.world == null || target == null) return null;
Vec3d start = entity.getEyePos();
Vec3d end = start.add(entity.getRotationVector().multiply(distance)); // Луч по направлению взгляда
EntityHitResult hitResult = ProjectileUtil.raycast(
entity,
start,
end,
entity.getBoundingBox().expand(distance).expand(1.0),
e -> e == target,
distance * distance
);
return hitResult != null ? hitResult.getEntity() : null;
}
public static boolean canPerformCriticals() {
if (mc.player == null) return false;
BlockPos feetPos = mc.player.getBlockPos();
BlockPos headPos = feetPos.up();
boolean isInCobweb = mc.world.getBlockState(feetPos).isOf(Blocks.COBWEB) ||
mc.world.getBlockState(headPos).isOf(Blocks.COBWEB);
if (mc.player.getMainHandStack().getItem() instanceof MaceItem) {
return true;
}
return !isInCobweb &&
!mc.player.hasStatusEffect(StatusEffects.BLINDNESS) &&
!mc.player.hasStatusEffect(StatusEffects.MINING_FATIGUE) &&
!mc.player.hasStatusEffect(StatusEffects.SLOW_FALLING) &&
!mc.player.isSubmergedInWater() &&
!mc.player.isTouchingWater() &&
!mc.player.isInLava() &&
!mc.player.isClimbing() &&
!mc.player.isOnGround() &&
mc.player.fallDistance > 0;
}
public static boolean canAttackSimple(LivingEntity target, float range) {
if (mc.player == null || target == null) return false;
return mc.player.distanceTo(target) <= range;
}
}
// Селектор целей
class TargetSelector {
private static final MinecraftClient mc = MinecraftClient.getInstance();
private static final Set<UUID> friends = new HashSet<>();
public static LivingEntity findTarget(float range, boolean targetPlayers, boolean targetMobs, boolean targetAnimals) {
if (mc.player == null || mc.world == null) return null;
Box searchBox = mc.player.getBoundingBox().expand(range);
List<LivingEntity> validTargets = new ArrayList<>();
for (Entity entity : mc.world.getEntitiesByClass(LivingEntity.class, searchBox, e ->
isValidTarget((LivingEntity) e, range, targetPlayers, targetMobs, targetAnimals))) {
validTargets.add((LivingEntity) entity);
}
if (validTargets.isEmpty()) return null;
// Сортировка по дистанции
validTargets.sort(Comparator.comparingDouble(e -> mc.player.distanceTo(e)));
return validTargets.get(0);
}
private static boolean isValidTarget(LivingEntity entity, float range,
boolean targetPlayers, boolean targetMobs, boolean targetAnimals) {
if (entity == mc.player) return false;
if (!entity.isAlive() || entity.isInvulnerable()) return false;
if (mc.player.distanceTo(entity) > range) return false;
if (entity instanceof PlayerEntity) {
if (!targetPlayers) return false;
if (friends.contains(entity.getUuid())) return false;
PlayerEntity player = (PlayerEntity) entity;
if (player.isSpectator() || player.isCreative()) return false;
} else if (entity instanceof Monster || entity instanceof HostileEntity || entity instanceof SquidEntity) {
if (!targetMobs) return false;
} else if (entity instanceof AnimalEntity) {
if (!targetAnimals) return false;
if (entity instanceof TameableEntity tameable) {
if (tameable.isTamed() && tameable.getOwnerUuid() != null &&
tameable.getOwnerUuid().equals(mc.player.getUuid())) {
return false;
}
}
} else {
return false;
}
return true;
}
}
// =========================================================================
// >>>>> 1. ОСНОВНОЙ КЛАСС (AttackAura) <<<<<
// =========================================================================
@Getter
public class AttackAura extends Module {
private static final MinecraftClient mc = MinecraftClient.getInstance();
private static final SecureRandom secureRandom = new SecureRandom();
// --- НАСТРОЙКИ ---
private final SliderSetting distance = new SliderSetting(Text.of("Дистанция"), Text.of("Дистанция атаки"), () -> true)
.set(3f, 6f, 0.1f).set(4.2f);
private final SliderSetting rotationSpeed = new SliderSetting(Text.of("Скорость поворота"), Text.of("Скорость наведения"), () -> true)
.set(0.1f, 1.0f, 0.01f).set(0.95f);
private final ModeSetting rotationMode = new ModeSetting(Text.of("Режим ротации"), Text.of("Тип ротации"), () -> true)
.set("Плавная", "HvH", "FunTime", "SpookyTime V1", "SpookyTime V2", "HolyWorld Test", "Sloth Test").setDefault("Плавная");
private final ModeSetting attackMode = new ModeSetting(Text.of("Режим атаки"), Text.of("Механика атаки"), () -> true)
.set("1.9", "1.8").setDefault("1.9");
private final SliderSetting cps = new SliderSetting(Text.of("CPS"), Text.of("Кликов в секунду"), () -> attackMode.getValue().equals("1.8"))
.set(1f, 20f, 0.5f).set(12f);
private final BooleanSetting onlyCrits = new BooleanSetting(Text.of("Только криты"), Text.of("Атаковать только с критами"), () -> false).set(false);
private final BooleanSetting targetPlayers = new BooleanSetting(Text.of("Игроки"), Text.of("Атаковать игроков"), () -> true).set(true);
private final BooleanSetting targetMobs = new BooleanSetting(Text.of("Мобы"), Text.of("Атаковать мобов"), () -> true).set(false);
private final BooleanSetting targetAnimals = new BooleanSetting(Text.of("Животные"), Text.of("Атаковать животных"), () -> false).set(false);
private final BooleanSetting attackThroughBlocks = new BooleanSetting(Text.of("Бить через блоки"), Text.of("Атаковать через стены"), () -> false).set(false);
private final BooleanSetting onlyWeapon = new BooleanSetting(Text.of("Только оружие"), Text.of("Только с оружием"), () -> false).set(false);
// НАСТРОЙКИ ДЛЯ ОБХОДА
private final BooleanSetting funTimeBypass = new BooleanSetting(Text.of("FunTime Bypass"), Text.of("Обход FunTime"), () -> false).set(false);
private final SliderSetting rotationRandomization = new SliderSetting(Text.of("Рандомизация"), Text.of("Случайность ротации"), () -> true)
.set(0f, 10f, 0.1f).set(2f);
private final List<Setting> settings = new ArrayList<>();
// --- ПЕРЕМЕННЫЕ ---
@NonFinal
private LivingEntity target = null;
public static Vector2f headVector = new Vector2f(0f, 0f);
@NonFinal
private float spoofYaw, spoofPitch;
@NonFinal
private boolean isAuraSpoofing = false;
@NonFinal
private boolean shouldAttackNextTick = false; // Флаг для атаки в TickEvent
// ТАЙМЕРЫ как в оригинале
private long lastAttackTime = 0;
private long lastRotationUpdate = 0;
private int attackTicks = 0;
private int funtimeTicks = 0;
private int grimTicks = 0;
private boolean canAttackNow = false;
private Vec3d targetPos; // Предсказание движения
public AttackAura() {
super(Text.of("AttackAura"), Category.COMBAT);
initSettings();
}
private void initSettings() {
settings.add(distance); settings.add(rotationSpeed); settings.add(rotationMode);
settings.add(attackMode); settings.add(cps); settings.add(onlyCrits);
settings.add(targetPlayers); settings.add(targetMobs); settings.add(targetAnimals);
settings.add(attackThroughBlocks); settings.add(onlyWeapon); settings.add(funTimeBypass);
settings.add(rotationRandomization);
}
@Override
public void activate() {
super.activate();
target = null;
if (mc.player != null) {
headVector = new Vector2f(mc.player.getPitch(), mc.player.getYaw());
}
isAuraSpoofing = false;
shouldAttackNextTick = false;
canAttackNow = false;
lastAttackTime = 0;
lastRotationUpdate = System.currentTimeMillis();
attackTicks = 0;
funtimeTicks = 0;
grimTicks = 0;
}
@Override
public void deactivate() {
target = null;
if (isAuraSpoofing && mc.player != null) {
mc.player.setYaw(spoofYaw);
mc.player.setPitch(spoofPitch);
}
isAuraSpoofing = false;
shouldAttackNextTick = false;
canAttackNow = false;
super.deactivate();
}
// =========================================================================
// >>>>> 2. СЛОЖНАЯ РОТАЦИОННАЯ ЛОГИКА (Render Thread) <<<<<
// =========================================================================
@EventHandler
public void onRender3D(EventRender3D event) {
if (!this.isEnabled() || mc.player == null || mc.world == null) return;
// Поиск цели
target = TargetSelector.findTarget(distance.getValue(), targetPlayers.getValue(),
targetMobs.getValue(), targetAnimals.getValue());
if (target != null) {
// СЛОЖНАЯ РОТАЦИЯ
applyComplexRotation();
// Проверяем можем ли атаковать (учитывает кулдаун)
canAttackNow = canAttack();
} else {
canAttackNow = false;
}
}
private void applyComplexRotation() {
if (mc.player == null || target == null) return;
// Полная логика ротации как в оригинале
float rotationYawSpeed = 60f;
float rotationPitchSpeed = 33f;
if (rotationMode.getValue().equals("HvH")) {
rotationYawSpeed = 180f;
rotationPitchSpeed = 90f;
} else if (rotationMode.getValue().equals("FunTime")) {
rotationYawSpeed = 60f;
rotationPitchSpeed = 30f;
}
// Вызываем полную ротацию
rotation(rotationYawSpeed, rotationPitchSpeed);
}
// ПОЛНАЯ ЛОГИКА РОТАЦИИ КАК В ОРИГИНАЛЕ (ВОССТАНОВЛЕНА)
private void rotation(float rotationYawSpeed, float rotationPitchSpeed) {
if (target == null) return;
float multiplier = 1.1787f;
float elytraBoostMultiplier = 1;
float boostedYawSpeed = rotationYawSpeed * elytraBoostMultiplier;
float boostedPitchSpeed = rotationPitchSpeed * elytraBoostMultiplier;
// Предсказание движения
targetPos = target.getEyePos();
if (target.isGliding()) {
Vec3d predictedVelocity = calcGlidingVelocity(target, target.getVelocity());
targetPos = targetPos.add(predictedVelocity);
}
Vec3d playerPos = mc.player.getEyePos();
Vec3d vec = targetPos.subtract(playerPos).add(
0,
MathHelper.clamp(mc.player.getEyePos().y - targetPos.y, 0, target.getHeight() * (mc.player.getPos().distanceTo(targetPos) / distance.getValue())) - 0.44f,
0
);
float yawToTarget = (float) MathHelper.wrapDegrees(Math.toDegrees(Math.atan2(vec.z, vec.x)) - 90.0);
float pitchToTarget = (float) (-Math.toDegrees(Math.atan2(vec.y, Math.sqrt(vec.x * vec.x + vec.z * vec.z))));
pitchToTarget = MathHelper.clamp(pitchToTarget, -90f, 90f);
float yawDelta = MathHelper.wrapDegrees(yawToTarget - headVector.y);
float pitchDelta = MathHelper.wrapDegrees(pitchToTarget - headVector.x);
// float dynamicYawSpeed = boostedYawSpeed * 1.29f * multiplier;
// float dynamicPitchSpeed = boostedPitchSpeed * (0.4f + secureRandom.nextFloat() * 0.3f) * multiplier;
// СЛОЖНАЯ ЛОГИКА ДЛЯ КАЖДОГО РЕЖИМА
switch (rotationMode.getValue()) {
case "Плавная":
float speed = secureRandom.nextFloat(125, 140) * rotationSpeed.getValue(); // Учет rotationSpeed
float clampedYaw = Math.min(Math.max(Math.abs(yawDelta), 0), speed);
float clampedPitch = Math.min(Math.max(Math.abs(pitchDelta), 0f), 20);
float yaw = headVector.y + (yawDelta > 0 ? clampedYaw : -clampedYaw);
float pitch = MathHelper.clamp(headVector.x + (pitchDelta > 0 ? clampedPitch : -clampedPitch), -90, 90);
// Рандомизация для обхода
float ceilValue = secureRandom.nextFloat(1, 2);
yaw += (float) (Math.ceil(ceilValue * Math.cos(System.currentTimeMillis() / 70D)));
pitch = MathHelper.clamp(pitch, -90.0f, 90.0f);
float gcd = SensUtil.getGCDValue();
yaw -= (yaw - headVector.y) % gcd;
pitch -= (pitch - headVector.x) % gcd;
headVector = new Vector2f(pitch, yaw);
break;
case "HvH":
Vec3d hvhTargetPos = target.getPos().add(0, target.getHeight() / 2, 0);
Vec3d hvhPlayerPos = mc.player.getEyePos();
Vec3d hvhVec = hvhTargetPos.subtract(hvhPlayerPos);
float hvhYawToTarget = (float) MathHelper.wrapDegrees(Math.toDegrees(Math.atan2(hvhVec.z, hvhVec.x)) - 90.0);
float hvhPitchToTarget = (float) (-Math.toDegrees(Math.atan2(hvhVec.y, Math.sqrt(hvhVec.x * hvhVec.x + hvhVec.z * hvhVec.z))));
float hvhCeilValue = secureRandom.nextFloat(1, 2);
hvhYawToTarget += (float) (Math.ceil(hvhCeilValue * Math.cos(System.currentTimeMillis() / 100D)));
headVector = new Vector2f(hvhPitchToTarget, hvhYawToTarget);
break;
case "FunTime":
float yawSpeed = funtimeTicks < 1 || mc.player.isUsingItem() ? secureRandom.nextFloat(0.1f, 1.5f) : secureRandom.nextFloat(900, 1600);
float pitchSpeed = 6;
float clampedYawFT = Math.min(Math.max(Math.abs(yawDelta), 0f), yawSpeed);
float clampedPitchFT = Math.min(Math.max(Math.abs(pitchDelta), 0f), pitchSpeed);
float yawFT = headVector.y + (yawDelta > 0 ? clampedYawFT : -clampedYawFT);
float pitchFT = MathHelper.clamp(headVector.x + (pitchDelta > 0 ? clampedPitchFT : -clampedPitchFT), -90f, 90f);
float maxYawChange = mc.player.distanceTo(target) < 1.7 ? 44 : 57.0f;
float maxPitchChange = 15.5f;
float ceilValueFT = secureRandom.nextFloat(8, 9);
yawFT = headVector.y + MathHelper.clamp(yawFT - headVector.y, -maxYawChange, maxYawChange);
pitchFT = MathHelper.clamp(headVector.x + MathHelper.clamp(pitchFT - headVector.x, -maxPitchChange, maxPitchChange), -89.0F, 89.0F);
yawFT += (float) (Math.ceil(ceilValueFT * Math.cos(System.currentTimeMillis() / 55D)));
pitchFT += (float) (Math.ceil(MathHelper.lerp(secureRandom.nextFloat(), 2, 7) * Math.sin(System.currentTimeMillis() / 80D)));
pitchFT = MathHelper.clamp(pitchFT, -90.0f, 90.0f);
float gcdFT = SensUtil.getGCDValue();
yawFT -= (yawFT - headVector.y) % gcdFT;
pitchFT -= (pitchFT - headVector.x) % gcdFT;
headVector = new Vector2f(pitchFT, yawFT);
break;
case "SpookyTime V1":
float speedST1 = secureRandom.nextFloat(45, 87) * rotationSpeed.getValue();
float clampedYawST1 = Math.min(Math.max(Math.abs(yawDelta), 0), speedST1);
float clampedPitchST1 = Math.min(Math.max(Math.abs(pitchDelta), 0f), 10);
float yawST1 = headVector.y + (yawDelta > 0 ? clampedYawST1 : -clampedYawST1);
float pitchST1 = MathHelper.clamp(headVector.x + (pitchDelta > 0 ? clampedPitchST1 : -clampedPitchST1), -68, 68);
float maxYawChangeST1 = 27.0f;
float maxPitchChangeST1 = 9.5f;
yawST1 = headVector.y + MathHelper.clamp(yawST1 - headVector.y, -maxYawChangeST1, maxYawChangeST1);
pitchST1 = MathHelper.clamp(headVector.x + MathHelper.clamp(pitchST1 - headVector.x, -maxPitchChangeST1, maxPitchChangeST1), -89.0F, 89.0F);
float ceilValueST1 = secureRandom.nextFloat(8, 14);
yawST1 += (float) (Math.ceil(ceilValueST1 * Math.cos(System.currentTimeMillis() / 90D)));
pitchST1 += (float) (Math.ceil(MathHelper.lerp(secureRandom.nextFloat(), 2, 4) * Math.sin(System.currentTimeMillis() / 70D)));
pitchST1 = MathHelper.clamp(pitchST1, -90.0f, 90.0f);
float gcdST1 = SensUtil.getGCDValue();
yawST1 -= (yawST1 - headVector.y) % gcdST1;
pitchST1 -= (pitchST1 - headVector.x) % gcdST1;
headVector = new Vector2f(pitchST1, yawST1);
break;
// Добавить логику для SpookyTime V2, HolyWorld Test, Sloth Test, если она есть
default:
// По умолчанию используем прямой прицел
headVector = MathAngle.calculateAnglesToTarget(target);
break;
}
}
// Метод предсказания движения
private Vec3d calcGlidingVelocity(LivingEntity entity, Vec3d oldVelocity) {
Vec3d vec3d = entity.getRotationVector();
float f = entity.getPitch() * (float) (Math.PI / 180.0);
double d = Math.sqrt(vec3d.x * vec3d.x + vec3d.z * vec3d.z);
double e = oldVelocity.horizontalLength();
double g = 0.08;
double h = MathHelper.square(Math.cos((double)f));
oldVelocity = oldVelocity.add(0.0, g * (-1.0 + h * 0.75), 0.0);
if (oldVelocity.y < 0.0 && d > 0.0) {
double i = oldVelocity.y * -0.1 * h;
oldVelocity = oldVelocity.add(vec3d.x * i / d, i, vec3d.z * i / d);
}
if (f < 0.0F && d > 0.0) {
double i = e * (double)(-MathHelper.sin(f)) * 0.04;
oldVelocity = oldVelocity.add(-vec3d.x * i / d, i * 3.2, -vec3d.z * i / d);
}
if (d > 0.0) {
oldVelocity = oldVelocity.add((vec3d.x / d * e - oldVelocity.x) * 0.1, 0.0, (vec3d.z / d * e - oldVelocity.z) * 0.1);
}
return oldVelocity.multiply(0.99F, 0.98F, 0.99F);
}
// =========================================================================
// >>>>> 3. CORE LOGIC (Sync/PostSync/Tick) <<<<<
// =========================================================================
private boolean canAttack() {
if (mc.player == null || target == null) return false;
// ВАЖНО: ПРОВЕРКА КУЛДАУНА (1.9)
if (attackMode.getValue().equals("1.9")) {
float attackCooldown = mc.player.getAttackCooldownProgress(0.5f);
if (attackCooldown < 0.9f) {
return false;
}
}
// ВАЖНО: ПРОВЕРКА CPS (1.8)
if (attackMode.getValue().equals("1.8")) {
long currentTime = System.currentTimeMillis();
float requiredCps = cps.getValue();
long delayMs = (long) (1000.0 / requiredCps);
long randomDelay = (long) (delayMs * ThreadLocalRandom.current().nextFloat(0.7f, 1.2f));
if (currentTime - lastAttackTime < randomDelay) {
return false;
}
}
// Проверка дистанции
float currentDistance = mc.player.distanceTo(target);
if (currentDistance > distance.getValue()) {
return false;
}
// Проверка только критов
if (onlyCrits.getValue() && !AttackHandler.canPerformCriticals()) {
return false;
}
// Проверка оружия
if (onlyWeapon.getValue() && !isHoldingWeapon()) {
return false;
}
// Проверка видимости
if (!attackThroughBlocks.getValue() && !RaytracingUtil.canSeeThroughWall(target)) {
return false;
}
return true;
}
private boolean isHoldingWeapon() {
if (mc.player == null) return false;
var heldItem = mc.player.getMainHandStack().getItem();
return heldItem instanceof SwordItem ||
heldItem instanceof AxeItem ||
heldItem instanceof TridentItem ||
heldItem instanceof MaceItem;
}
private boolean shouldAttack() {
return canAttackNow && target != null && target.isAlive();
}
// Событие Pre-Sync (ПЕРЕД отправкой пакета движения)
@EventHandler
public void onSync(EventSync eventSync) {
if (!this.isEnabled() || mc.player == null) return;
if (shouldAttack()) {
// Сохраняем реальную ротацию для спуфа
if (!isAuraSpoofing) {
spoofYaw = mc.player.getYaw();
spoofPitch = mc.player.getPitch();
System.out.println("Aura: НАЧАЛО СПУФА");
}
isAuraSpoofing = true;
shouldAttackNextTick = true; // Планируем атаку на следующий тик (в TickEvent)
// Применяем спуф-ротацию
mc.player.setYaw(headVector.y);
mc.player.setPitch(headVector.x);
mc.player.setHeadYaw(headVector.y);
mc.player.setBodyYaw(headVector.y);
System.out.println("Aura Sync: Ротация применена.");
} else {
isAuraSpoofing = false;
shouldAttackNextTick = false;
}
}
// Событие Post-Sync (ПОСЛЕ отправки пакета движения)
@EventHandler
public void onPostSync(EventPostSync eventPostSync) {
if (!this.isEnabled() || !isAuraSpoofing || mc.player == null) return;
// Восстанавливаем реальную ротацию после отправки пакета, чтобы избежать визуальных дерганий
mc.player.setYaw(spoofYaw);
mc.player.setPitch(spoofPitch);
mc.player.setHeadYaw(spoofYaw); // Восстанавливаем также голову и тело
mc.player.setBodyYaw(spoofYaw);
System.out.println("Aura PostSync: Углы восстановлены.");
}
// Событие Tick (ИСПОЛНЕНИЕ АТАКИ)
@EventHandler
public void onTickEvent(TickEvent event) {
if (!this.isEnabled() || mc.player == null || mc.world == null) return;
// Атака в N+1 тике, если запланирована
if (shouldAttackNextTick && target != null && target.isAlive()) {
if (mc.interactionManager != null) {
if (canAttack()) { // Повторная финальная проверка перед атакой
mc.interactionManager.attackEntity(mc.player, target);
mc.player.swingHand(Hand.MAIN_HAND);
lastAttackTime = System.currentTimeMillis();
System.out.println("Aura Tick: АТАКА! (1.9 или 1.8)");
}
}
shouldAttackNextTick = false;
isAuraSpoofing = false; // Сброс спуфа после атаки (чтобы начать цикл заново)
}
// Сброс если цель исчезла
if (shouldAttackNextTick && (target == null || !isTargetValid(target))) {
shouldAttackNextTick = false;
isAuraSpoofing = false;
}
// Обновление цели если текущая не валидна
if (target != null && !isTargetValid(target)) {
target = null;
canAttackNow = false;
}
// Обновление тиков для логики ротации
updateLogicTicks();
}
private void updateLogicTicks() {
// Логика обновления тиков как в оригинале
long currentTime = System.currentTimeMillis();
if (attackMode.getValue().equals("1.9")) {
float attackCd = mc.player.getAttackCooldownProgress(0.5f);
funtimeTicks = (attackCd >= 0.9f || attackCd <= 0.1f) ? 1 : 0;
} else {
funtimeTicks = 0;
}
attackTicks = (currentTime - lastAttackTime > 300) ? 1 : 0;
grimTicks = (currentTime - lastAttackTime > 400) ? 1 : 0;
}
private boolean isTargetValid(LivingEntity entity) {
if (!entity.isAlive()) return false;
if (mc.player.distanceTo(entity) > distance.getValue() * 1.5f) return false;
if (entity instanceof PlayerEntity && !targetPlayers.getValue()) return false;
if ((entity instanceof Monster || entity instanceof HostileEntity) && !targetMobs.getValue()) return false;
if (entity instanceof AnimalEntity && !targetAnimals.getValue()) return false;
return true;
}
@Override
public List<Setting> getSettingLayers() {
return settings;
}
}могу купить готовое за рубликов 100-200 , под mytheria https://yougame.biz/threads/366144/
Последнее редактирование:
