Начинающий
Начинающий
- Статус
- Онлайн
- Регистрация
- 9 Сен 2025
- Сообщения
- 6
- Реакции
- 0
Здравствууйте пишу софт на 1,21,4 уже есть aim assist недавно в этой теме и хочу спросить почему все равно банит если что то убрать надо скажите или дайте что нибудь не судите строго знаю дохуя гпт кода но я уже все перепробывал ни FT ни Space times не обходит
package fun.exort.module.list.combat;
import com.google.common.eventbus.Subscribe;
import fun.exort.event.list.EventUpdate;
import fun.exort.module.Module;
import fun.exort.module.ModuleCategory;
import fun.exort.module.ModuleInformation;
import fun.exort.module.settings.BooleanSetting;
import fun.exort.module.settings.ModeSetting;
import fun.exort.module.settings.NumberSetting;
import fun.exort.util.FriendManager;
import fun.exort.util.render.builders.Builder;
import fun.exort.util.render.builders.states.QuadColorState;
import fun.exort.util.render.builders.states.SizeState;
import fun.exort.util.render.renderers.impl.BuiltTexture;
import net.fabricmc.fabric.api.client.rendering.v1.HudRenderCallback;
import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderContext;
import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderEvents;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.gui.DrawContext;
import net.minecraft.client.render.RenderTickCounter;
import net.minecraft.client.texture.AbstractTexture;
import net.minecraft.client.texture.NativeImage;
import net.minecraft.client.texture.NativeImageBackedTexture;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.entity.projectile.ProjectileUtil;
import net.minecraft.item.ArmorItem;
import net.minecraft.item.ItemStack;
import net.minecraft.util.hit.BlockHitResult;
import net.minecraft.util.hit.EntityHitResult;
import net.minecraft.util.hit.HitResult;
import net.minecraft.util.math.Box;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.RaycastContext;
import org.joml.Matrix4f;
import java.awt.Color;
import java.io.IOException;
import java.io.InputStream;
import java.util.Comparator;
import java.util.Random;
@ModuleInformation(
moduleName = "AimAssist",
moduleCategory = ModuleCategory.Combat
,
moduleKeybind = 82
)
public class AimAssist extends Module {
public final NumberSetting fov = new NumberSetting("Fov", this, 360, 20, 360, 5);
public final BooleanSetting drawFov = new BooleanSetting("Draw Fov", this, true);
public final NumberSetting maxYawSpeed = new NumberSetting("MaxYawSpeed", this, 8.0, 0.1, 25.0, 0.1);
public final NumberSetting maxPitchSpeed = new NumberSetting("MaxPitchSpeed", this, 0.2, 0.1, 10.0, 0.1);
public final NumberSetting maxDelta = new NumberSetting("MaxDelta (Limiter)", this, 45.0, 5.0, 180.0, 1.0);
public final NumberSetting aimHeight = new NumberSetting("AimHeight", this, 0.95, 0.2, 1.0, 0.1);
public final NumberSetting distance = new NumberSetting("Distance", this, 3.5, 2.0, 5.0, 0.1);
public final NumberSetting smoothFactor = new NumberSetting("SmoothFactor", this, 0.15, 0.01, 0.5, 0.01);
public final BooleanSetting wallCheck = new BooleanSetting("WallCheck", this, false);
public static boolean onSelfDestruct = false;
public final ModeSetting Rotation = new ModeSetting("Rotation ", this, "Hybrid", "LEGIT", "Hybrid", "CUSTOM");
public final BooleanSetting smoothEnabled = new BooleanSetting("Smooth", this, true);
private final NumberSetting behindSpeedMultiplier = new NumberSetting("BehindMultiplier", this, 0.65, 0.1, 1.0, 0.1);
private static PlayerEntity lockedTarget = null;
private static float currentYawSpeed = 0f;
private static float currentPitchSpeed = 0f;
private NumberSetting acceleration = new NumberSetting("Acceleration", this, 0.15, 0.1, 1.0, 0.1);
private NumberSetting deceleration = new NumberSetting("Deceleration", this, 0.5, 0.1, 1.0, 0.1);
private NumberSetting predictStrength = new NumberSetting("Predict Strength", this, 1.2, 0.1, 10, 0.1);
private BooleanSetting randomEnabled = new BooleanSetting("Randomize AimHeight", this, true);
private NumberSetting randomMinHeight = new NumberSetting("Min Height", this, 0.3, 0.2, 0.8, 0.05);
private NumberSetting randomMaxHeight = new NumberSetting("Max Height", this, 0.95, 0.5, 1.0, 0.05);
private NumberSetting randomUpdateTicks = new NumberSetting("Update Delay (ticks)", this, 30, 5, 100, 5);
private BooleanSetting randomizeTiming = new BooleanSetting("Randomize Timing", this, true);
private NumberSetting timingRandomRange = new NumberSetting("Timing Random Range (ms)", this, 10, 1, 30, 1);
private BooleanSetting randomizeMicroMovements = new BooleanSetting("Randomize MicroMovements", this, true);
private NumberSetting microMovementChance = new NumberSetting("MicroMovement Chance %", this, 5, 1, 20, 1);
private NumberSetting microMovementStrength = new NumberSetting("MicroMovement Strength", this, 0.1, 0.01, 0.5, 0.01);
private BooleanSetting overShoot = new BooleanSetting("OverShoot", this, true);
private NumberSetting overShootChance = new NumberSetting("OverShootChance %", this, 0.5, 0.1, 10, 0.1);
private NumberSetting overShootStrength = new NumberSetting("OverShootStrength", this, 1.5, 0.2, 40, 0.1);
private final NumberSetting finalError = new NumberSetting("Final Error (deg)", this, 0.25, 0.0, 1.5, 0.05);
public final NumberSetting microMovementInterval = new NumberSetting("Micro Interval (ms)", this, 50, 20, 200, 10);
public final NumberSetting microMovementDecay = new NumberSetting("Micro Decay", this, 0.95, 0.85, 1.0, 0.01);
public final NumberSetting microMovementYawWeight = new NumberSetting("Micro Yaw Weight", this, 1.0, 0.5, 2.0, 0.1);
public final NumberSetting microMovementPitchWeight = new NumberSetting("Micro Pitch Weight", this, 0.4, 0.1, 1.0, 0.1);
public final BooleanSetting NoiseEnabled = new BooleanSetting("Noise", this, true);
public final NumberSetting NoiseStrength = new NumberSetting("Noise Strength", this, 0.8, 0.1, 3.0, 0.05);
public final NumberSetting NoiseFrequency = new NumberSetting("Noise Frequency", this, 0.025, 0.01, 0.1, 0.002);
public final NumberSetting NoiseSmoothing = new NumberSetting("Noise Smoothing", this, 0.85, 0.6, 0.95, 0.01);
public final ModeSetting NoiseType = new ModeSetting("Noise Type", this, "Perlin", "Sine", "Perlin", "Smooth");
public final BooleanSetting gcdFix = new BooleanSetting("GCD Fix", this, true);
public final NumberSetting gcdMultiplier = new NumberSetting("GCD Multiplier", this, 1.0, 0.5, 1.6, 0.1);
public final NumberSetting gcdRandomness = new NumberSetting("GCD Randomness %", this, 12.5, 0.0, 50.0, 1.0);
private long onTargetStartTime = 0;
private final long REQUIRED_TIME_ON_TARGET_MS = 50;
private boolean helpEnabled = true;
private Random random = new Random();
private float currentRandomHeight = 0.95f;
private int updateCounter = 0;
private float lastTargetYaw = 0;
private float lastTargetPitch = 0;
private String lastAppliedMode = "";
private long lastRenderTime = 0;
private boolean overshootActive = false;
private float overshootErrorYaw = 0f;
private float overshootErrorPitch = 0f;
private float overshootDecay = 0.9f;
private float overshootNoiseBlend = 0f;
private int microMovementCooldown = 0;
private long lastMicroMovementTime = 0;
private float lastMicroYawSpeed = 0f;
private float lastMicroPitchSpeed = 0f;
private int microMovementType = 0;
private float noisePhaseYaw = 0f;
private float noisePhasePitch = 0f;
private float lastNoiseYaw = 0f;
private float lastNoisePitch = 0f;
private float perlinX = 0f;
private float perlinY = 0f;
private AbstractTexture circleTexture = null;
public AimAssist() {
addSetting(Rotation);
addSetting(drawFov);
WorldRenderEvents.BEFORE_ENTITIES.register(this::onWorldRender);
HudRenderCallback.EVENT.register(this::onHudRender);
}
@override
public void onEnable() {
super.onEnable();
resetTarget();
updateRandomHeight();
lastAppliedMode = "";
lastRenderTime = System.currentTimeMillis();
overshootActive = false;
resetMicroMovements();
resetNoise();
onTargetStartTime = 0;
helpEnabled = true;
}
@override
public void onDisable() {
super.onDisable();
resetTarget();
overshootActive = false;
onTargetStartTime = 0;
helpEnabled = true;
}
private void loadCircleTexture() {
if (circleTexture != null) return;
try {
InputStream inputStream = getClass().getClassLoader().getResourceAsStream("assets/fear/icons/circle.png");
if (inputStream == null) {
System.err.println("Could not find texture: assets/fear/icons/circle.png");
return;
}
NativeImage image = NativeImage.read(inputStream);
inputStream.close();
circleTexture = new NativeImageBackedTexture(image);
} catch (IOException e) {
System.err.println("Failed to load circle texture: " + e.getMessage());
}
}
private void onHudRender(DrawContext context, RenderTickCounter tickCounter) {
if (!isEnabled() || !drawFov.getValue() || mc.player == null) return;
float currentFov = fov.getFloatValue();
loadCircleTexture();
if (circleTexture == null) return;
float screenWidth = context.getScaledWindowWidth();
float screenHeight = context.getScaledWindowHeight();
float mcFov = mc.options.getFov().getValue().floatValue();
float radius = (float)(
Math.tan(Math.toRadians(currentFov / 2f)) /
Math.tan(Math.toRadians(mcFov / 2f))
) * (screenHeight / 2f);
radius *= 0.58f;
radius = Math.max(1f, Math.min(radius, screenHeight));
float size = radius * 2f;
float x = (screenWidth / 2f) - radius;
float y = (screenHeight / 2f) - radius;
Matrix4f matrix = context.getMatrices().peek().getPositionMatrix();
BuiltTexture circle = Builder.texture()
.size(new SizeState(size, size))
.texture(0, 0, 1, 1, circleTexture)
.color(new QuadColorState(new Color(255, 255, 255, 255)))
.build();
circle.render(matrix, x, y);
}
private void resetTarget() {
lockedTarget = null;
currentYawSpeed = 0f;
currentPitchSpeed = 0f;
lastTargetYaw = 0;
lastTargetPitch = 0;
overshootActive = false;
}
private void resetMicroMovements() {
microMovementCooldown = 0;
lastMicroMovementTime = 0;
lastMicroYawSpeed = 0f;
lastMicroPitchSpeed = 0f;
microMovementType = 0;
}
private void resetNoise() {
noisePhaseYaw = 0f;
noisePhasePitch = 0f;
lastNoiseYaw = 0f;
lastNoisePitch = 0f;
perlinX = 0f;
perlinY = 0f;
}
private boolean isCrosshairOnTarget(PlayerEntity target) {
if (mc.player == null || mc.world == null || target == null) return false;
Vec3d eyePos = mc.player.getEyePos();
Vec3d lookVec = mc.player.getRotationVec(1.0F);
double maxDist = distance.getFloatValue();
Vec3d endPos = eyePos.add(lookVec.multiply(maxDist));
Box box = mc.player.getBoundingBox()
.stretch(lookVec.multiply(maxDist))
.expand(1.0, 1.0, 1.0);
EntityHitResult hit = ProjectileUtil.raycast(
mc.player,
eyePos,
endPos,
box,
entity -> entity == target,
maxDist * maxDist
);
return hit != null && hit.getEntity() == target;
}
private float addNoiseMovements(float dt) {
if (!NoiseEnabled.getValue()) return 0f;
float timeScale = dt * 60.0f;
float noiseYawRaw = 0f;
float freqStep = NoiseFrequency.getFloatValue() * timeScale;
float strength = NoiseStrength.getFloatValue();
float alpha = 1.0f - (float)Math.exp(-NoiseSmoothing.getFloatValue() * timeScale);
switch (NoiseType.getValue()) {
case "Perlin":
noiseYawRaw = (float)(
Math.sin(perlinX) * 0.4 +
Math.sin(perlinX * 2.17) * 0.3 +
Math.sin(perlinX * 4.93) * 0.2 +
Math.sin(perlinX * 11.37) * 0.1
) * strength;
perlinX += freqStep;
perlinY += freqStep * 0.83f;
lastNoiseYaw = MathHelper.lerp(alpha, lastNoiseYaw, noiseYawRaw);
break;
case "Sine":
noisePhaseYaw += freqStep;
noiseYawRaw = (float)(Math.sin(noisePhaseYaw) * Math.sin(noisePhaseYaw * 0.5) * strength);
lastNoiseYaw = MathHelper.lerp(alpha, lastNoiseYaw, noiseYawRaw);
break;
case "Smooth":
default:
if (random.nextInt(6) == 0) {
noiseYawRaw = (float)(random.nextGaussian() * strength * 0.5);
lastNoiseYaw = MathHelper.lerp(alpha, lastNoiseYaw, noiseYawRaw);
} else {
float naturalDecay = 1.0f - (float)Math.exp(-0.05f * timeScale);
lastNoiseYaw = MathHelper.lerp(naturalDecay, lastNoiseYaw, 0f);
}
break;
}
float maxNoiseChange = 0.15f * timeScale;
float change = noiseYawRaw - lastNoiseYaw;
if (Math.abs(change) > maxNoiseChange) {
lastNoiseYaw += Math.signum(change) * maxNoiseChange;
}
if (mc.player != null && Math.abs(lastTargetYaw - mc.player.getYaw()) < 1.5f) {
return lastNoiseYaw;
}
return lastNoiseYaw * 0.4f;
}
private void addRandomMicroMovements(float timeScale) {
if (!randomizeMicroMovements.getValue()) return;
if (microMovementCooldown > 0) {
microMovementCooldown--;
if (microMovementDecay.getFloatValue() < 1.0f) {
float decayAlpha = 1.0f - (float)Math.exp(-(1.0f - microMovementDecay.getFloatValue()) * timeScale * 10.0f);
currentYawSpeed = MathHelper.lerp(decayAlpha, currentYawSpeed, 0f);
currentPitchSpeed = MathHelper.lerp(decayAlpha, currentPitchSpeed, 0f);
}
return;
}
long now = System.currentTimeMillis();
long interval = (long) microMovementInterval.getValue();
if (now - lastMicroMovementTime < interval) return;
float baseChance = microMovementChance.getFloatValue() / 100.0f;
float actualChance = baseChance;
if (Math.abs(currentYawSpeed) < 0.3f && Math.abs(currentPitchSpeed) < 0.2f) {
actualChance *= 1.3f;
} else if (Math.abs(currentYawSpeed) > maxYawSpeed.getFloatValue() * 0.7f) {
actualChance *= 0.5f;
}
if (now - lastMicroMovementTime > interval * 2) {
actualChance *= 1.2f;
}
if (random.nextFloat() >= actualChance) return;
float strength = microMovementStrength.getFloatValue();
float yawWeight = microMovementYawWeight.getFloatValue();
float pitchWeight = microMovementPitchWeight.getFloatValue();
microMovementType = random.nextInt(4);
float yawMicro = 0f;
float pitchMicro = 0f;
int cooldownTicks = 0;
switch(microMovementType) {
case 0:
yawMicro = (random.nextFloat() - 0.5f) * strength * yawWeight;
pitchMicro = (random.nextFloat() - 0.5f) * strength * pitchWeight * 0.6f;
cooldownTicks = 2 + random.nextInt(2);
break;
case 1:
yawMicro = (random.nextFloat() - 0.5f) * strength * yawWeight * 1.5f;
pitchMicro = (random.nextFloat() - 0.5f) * strength * pitchWeight * 0.4f;
cooldownTicks = 3 + random.nextInt(3);
break;
case 2:
for (int i = 0; i < 2; i++) {
currentYawSpeed += (random.nextFloat() - 0.5f) * strength * yawWeight * 0.4f;
currentPitchSpeed += (random.nextFloat() - 0.5f) * strength * pitchWeight * 0.3f;
}
cooldownTicks = 1;
break;
case 3:
if (lockedTarget != null && mc.player != null) {
float currentYaw = mc.player.getYaw();
float yawDiff = MathHelper.wrapDegrees(lastTargetYaw - currentYaw);
float correctionDir = Math.signum(yawDiff);
yawMicro = correctionDir * strength * yawWeight * 0.6f;
pitchMicro = (random.nextFloat() - 0.5f) * strength * pitchWeight * 0.3f;
}
cooldownTicks = 4 + random.nextInt(2);
break;
}
currentYawSpeed += yawMicro * timeScale;
currentPitchSpeed += pitchMicro * timeScale;
lastMicroYawSpeed = yawMicro;
lastMicroPitchSpeed = pitchMicro;
microMovementCooldown = cooldownTicks;
lastMicroMovementTime = now;
}
private void tryStartOvershoot(float yawDiff, float pitchDiff) {
if (!overShoot.getValue()) return;
if (overshootActive) return;
if (Math.abs(yawDiff) < 4.0f) return;
float chance = overShootChance.getFloatValue() / 100f;
if (random.nextFloat() > chance) return;
float strength = overShootStrength.getFloatValue();
float direction = Math.signum(yawDiff);
overshootErrorYaw = direction * (0.5f + random.nextFloat()) * strength;
overshootErrorPitch = (random.nextFloat() - 0.5f) * strength * 0.4f;
overshootDecay = 0.82f + random.nextFloat() * 0.1f;
overshootNoiseBlend = 0.6f + random.nextFloat() * 0.4f;
overshootActive = true;
}
private void updateOvershoot(float noiseValue, float timeScale) {
if (!overshootActive) return;
overshootErrorYaw *= overshootDecay;
overshootErrorPitch *= overshootDecay;
overshootErrorYaw += noiseValue * overshootNoiseBlend * 0.5f;
overshootErrorPitch += noiseValue * overshootNoiseBlend * 0.2f;
if (Math.abs(overshootErrorYaw) < 0.2f) {
if (random.nextFloat() < 0.35f) {
overshootErrorYaw *= 0.5f;
} else {
overshootErrorYaw = 0f;
}
}
if (Math.abs(overshootErrorPitch) < 0.1f) {
overshootErrorPitch = 0f;
}
if (Math.abs(overshootErrorYaw) < 0.05f && Math.abs(overshootErrorPitch) < 0.05f) {
overshootActive = false;
}
}
private float addFinalError(float angle, float errorDeg) {
if (errorDeg <= 0) return angle;
return angle + (random.nextFloat() - 0.5f) * errorDeg * 2;
}
private void updateRandomHeight() {
if (!randomEnabled.getValue()) {
currentRandomHeight = aimHeight.getFloatValue();
return;
}
float min = randomMinHeight.getFloatValue();
float max = randomMaxHeight.getFloatValue();
if (min > max) {
float temp = min; min = max; max = temp;
}
currentRandomHeight = min + random.nextFloat() * (max - min);
}
private float getCurrentAimHeight() {
if (randomEnabled.getValue()) {
return currentRandomHeight;
}
return aimHeight.getFloatValue();
}
private void applyModeSettings(String mode) {
switch (mode) {
case "Hybrid":
removeAllSettings();
fov.setValue(360);
maxPitchSpeed.setValue(1.5);
maxYawSpeed.setValue(10.67);
maxDelta.setValue(32.5);
aimHeight.setValue(0.9);
distance.setValue(4.2);
smoothFactor.setValue(0.125);
smoothEnabled.setValue(true);
acceleration.setValue(0.40);
deceleration.setValue(0.2);
wallCheck.setValue(true);
randomEnabled.setValue(true);
randomMaxHeight.setValue(0.93);
randomMinHeight.setValue(0.7);
randomUpdateTicks.setValue(5);
randomizeTiming.setValue(true);
timingRandomRange.setValue(15);
randomizeMicroMovements.setValue(true);
microMovementChance.setValue(6);
microMovementStrength.setValue(1.1);
overShoot.setValue(true);
overShootChance.setValue(5);
overShootStrength.setValue(1.6);
finalError.setValue(1);
NoiseEnabled.setValue(true);
NoiseStrength.setValue(4.4);
NoiseFrequency.setValue(0.015);
NoiseSmoothing.setValue(0.75);
NoiseType.setValue("Perlin");
microMovementInterval.setValue(15);
microMovementDecay.setValue(0.75);
microMovementYawWeight.setValue(1.6);
microMovementPitchWeight.setValue(1.0);
gcdFix.setValue(true);
gcdMultiplier.setValue(1.0);
gcdRandomness.setValue(0);
break;
case "LEGIT":
removeAllSettings();
fov.setValue(120);
maxPitchSpeed.setValue(0.7);
maxYawSpeed.setValue(5.5);
maxDelta.setValue(30);
aimHeight.setValue(1.0);
distance.setValue(3.8);
smoothFactor.setValue(0.12);
acceleration.setValue(0.42);
deceleration.setValue(0.2);
smoothEnabled.setValue(true);
wallCheck.setValue(true);
randomEnabled.setValue(true);
randomMinHeight.setValue(0.65);
randomMaxHeight.setValue(0.9);
randomUpdateTicks.setValue(40);
randomizeTiming.setValue(true);
timingRandomRange.setValue(8);
randomizeMicroMovements.setValue(true);
microMovementChance.setValue(6);
microMovementStrength.setValue(1.1);
overShoot.setValue(false);
finalError.setValue(0.2);
microMovementInterval.setValue(20);
microMovementDecay.setValue(0.77);
microMovementYawWeight.setValue(1.6);
microMovementPitchWeight.setValue(0.35);
NoiseEnabled.setValue(true);
NoiseStrength.setValue(3.5);
NoiseFrequency.setValue(0.018);
NoiseSmoothing.setValue(0.89);
NoiseType.setValue("Perlin");
gcdFix.setValue(true);
gcdMultiplier.setValue(0.8);
gcdRandomness.setValue(11.0);
break;
case "CUSTOM":
addAllSettings();
break;
}
}
private float applyGCD(float targetAngle, float currentAngle) {
if (!gcdFix.getValue() || mc.options == null) return targetAngle;
float sens = 0.6f;
float f = sens * 0.6F + 0.2F;
float gcd = f * f * f * 1.2F;
float variation = (float) (1.0 + (random.nextGaussian() * (gcdRandomness.getFloatValue() / 100.0f)));
gcd *= gcdMultiplier.getFloatValue() * Math.max(0.1f, variation);
if (gcd < 0.0001f) gcd = 0.0001f;
float delta = targetAngle - currentAngle;
float exactSteps = delta / gcd;
int steps = (int) exactSteps;
float remainder = Math.abs(exactSteps - steps);
if (random.nextFloat() < remainder) {
steps += Math.signum(exactSteps);
}
return currentAngle + (steps * gcd);
}
private void performAimUpdate(float dt) {
if (!isEnabled()) return;
if (mc.player == null || mc.world == null) return;
if (mc.player.isUsingItem()) return;
if (onSelfDestruct) { super.onDisable(); return; }
String currentMode = Rotation.getValue();
if (!currentMode.equals(lastAppliedMode)) {
applyModeSettings(currentMode);
lastAppliedMode = currentMode;
}
if (randomEnabled.getValue()) {
updateCounter++;
if (updateCounter >= randomUpdateTicks.getIntValue()) {
updateRandomHeight();
updateCounter = 0;
}
}
float currentYaw = mc.player.getYaw();
float currentPitch = mc.player.getPitch();
// Проверка валидности залоченной цели
if (lockedTarget != null) {
boolean isTargetDead = !lockedTarget.isAlive();
boolean isTargetOutOfRange = mc.player.squaredDistanceTo(lockedTarget) > distance.getFloatValue() * distance.getFloatValue();
if (isTargetDead || isTargetOutOfRange) {
lockedTarget = null;
}
}
// Поиск новой цели только если нет залоченной
if (lockedTarget == null) {
PlayerEntity bestTarget = findBestTarget(mc);
if (bestTarget != null) {
lockedTarget = bestTarget;
}
}
if (lockedTarget == null) {
onTargetStartTime = 0;
helpEnabled = true;
return;
}
PlayerEntity target = lockedTarget;
if (wallCheck.getValue()) {
Vec3d eyePos = mc.player.getEyePos();
Vec3d targetPos = target.getEyePos();
BlockHitResult blockHit = mc.world.raycast(new RaycastContext(
eyePos,
targetPos,
RaycastContext.ShapeType.COLLIDER,
RaycastContext.FluidHandling.NONE,
mc.player
));
if (blockHit != null && blockHit.getType() != HitResult.Type.MISS) {
return;
}
}
if (Math.abs(mc.player.getY() - target.getY()) > 3.0 && mc.player.squaredDistanceTo(target) < 4.0) {
return;
}
boolean currentlyOnTarget = isCrosshairOnTarget(target);
if (currentlyOnTarget) {
if (onTargetStartTime == 0) {
onTargetStartTime = System.currentTimeMillis();
}
if (System.currentTimeMillis() - onTargetStartTime >= REQUIRED_TIME_ON_TARGET_MS) {
helpEnabled = false;
}
} else {
onTargetStartTime = 0;
helpEnabled = true;
}
float eyeHeight = target.getEyeHeight(target.getPose());
float targetHeight = getCurrentAimHeight();
Vec3d predictedPos = new Vec3d(
target.getX() + (target.getX() - target.prevX) * predictStrength.getValue(),
target.getY(),
target.getZ() + (target.getZ() - target.prevZ) * predictStrength.getValue()
);
Vec3d targetPos = predictedPos.add(0, eyeHeight * targetHeight, 0);
Vec3d delta = targetPos.subtract(mc.player.getEyePos());
float targetYaw = (float) MathHelper.wrapDegrees(Math.toDegrees(Math.atan2(delta.z, delta.x)) - 90);
float targetPitch = (float) -Math.toDegrees(Math.atan2(delta.y, Math.sqrt(delta.x * delta.x + delta.z * delta.z)));
targetPitch = MathHelper.clamp(targetPitch, -90f, 90f);
lastTargetYaw = targetYaw;
lastTargetPitch = targetPitch;
float finalErrorDeg = finalError.getFloatValue();
if (finalErrorDeg > 0) {
lastTargetYaw = addFinalError(lastTargetYaw, finalErrorDeg);
lastTargetPitch = addFinalError(lastTargetPitch, finalErrorDeg);
}
float noiseValue = addNoiseMovements(dt);
float timeScale = dt * 60.0f;
updateOvershoot(noiseValue, timeScale);
if (overshootActive) {
lastTargetYaw += overshootErrorYaw;
lastTargetPitch += overshootErrorPitch;
}
float yawDiff = MathHelper.wrapDegrees(lastTargetYaw - currentYaw);
float pitchDiff = lastTargetPitch - currentPitch;
if (Math.abs(yawDiff) > fov.getFloatValue() / 2f) return;
tryStartOvershoot(yawDiff, pitchDiff);
// ================= НОВАЯ ЛОГИКА ДЛЯ currentlyOnCrosshair =================
// Если цель на прицеле, применяем Noise + Randomize Aim Height (движение вверх-вниз с 30% силой)
if (currentlyOnTarget) {
// Основной шум (Noise)
yawDiff = noiseValue * 2.0f;
// Randomize Aim Height - движение вверх/вниз с силой 30% от максимальной скорости
// Генерируем синусоидальное движение для плавного подъёма и опускания прицела
float aimHeightNoise = (float)(Math.sin(System.currentTimeMillis() / 200.0) * 0.5 + Math.sin(System.currentTimeMillis() / 87.0) * 0.5);
aimHeightNoise = MathHelper.clamp(aimHeightNoise, -0.8f, 0.8f);
// Сила движения = 30% от стандартной скорости + небольшой случайный разброс
float aimHeightStrength = 0.3f * (0.85f + random.nextFloat() * 0.3f);
// Применяем вертикальное движение с ограничением, чтобы не улететь слишком далеко от цели
pitchDiff = (aimHeightNoise * aimHeightStrength * 1.2f) + (noiseValue * 0.4f);
// Дополнительная маленькая случайность для более натурального вида
if (random.nextInt(100) < 15) {
pitchDiff += (random.nextFloat() - 0.5f) * 0.8f;
}
} else {
// Стандартное поведение, когда цель НЕ на прицеле
yawDiff += noiseValue;
pitchDiff += noiseValue * 0.4f;
}
// ========================================================================
float currentYawDiff = yawDiff;
boolean isBehind = Math.abs(currentYawDiff) > fov.getFloatValue() && Math.abs(currentYawDiff) <= 180f;
float targetYawSpeed;
float targetPitchSpeed;
if (isBehind) {
targetYawSpeed = (maxYawSpeed.getFloatValue() * behindSpeedMultiplier.getFloatValue()) * (random.nextBoolean() ? 1.1f : 0.9f);
targetPitchSpeed = (maxPitchSpeed.getFloatValue() * behindSpeedMultiplier.getFloatValue()) * (random.nextBoolean() ? 1.1f : 0.9f);
} else {
targetYawSpeed = maxYawSpeed.getFloatValue() * (random.nextBoolean() ? 1.1f : 0.9f);
targetPitchSpeed = maxPitchSpeed.getFloatValue() * (random.nextBoolean() ? 1.1f : 0.9f);
}
// Если цель на прицеле - ограничиваем скорость поворота по вертикали 30%
if (currentlyOnTarget) {
targetPitchSpeed *= 0.3f;
}
float newYaw = currentYaw;
float newPitch = currentPitch;
if (smoothEnabled.getValue()) {
float speedMultiplier = 1.0f;
float baseYawLerp = 1.0f - (float)Math.exp(-smoothFactor.getFloatValue() * timeScale);
float basePitchLerp = 1.0f - (float)Math.exp(-smoothFactor.getFloatValue() * timeScale);
float desiredYawStep = yawDiff * baseYawLerp * speedMultiplier;
float desiredPitchStep = pitchDiff * basePitchLerp * speedMultiplier;
desiredYawStep = MathHelper.clamp(desiredYawStep, -targetYawSpeed * timeScale, targetYawSpeed * timeScale);
desiredPitchStep = MathHelper.clamp(desiredPitchStep, -targetPitchSpeed * timeScale, targetPitchSpeed * timeScale);
float accelYawLerp = 1.0f - (float)Math.exp(-acceleration.getFloatValue() * timeScale);
float decelYawLerp = 1.0f - (float)Math.exp(-deceleration.getFloatValue() * timeScale);
if (Math.abs(desiredYawStep) > Math.abs(currentYawSpeed)) {
currentYawSpeed = MathHelper.lerp(accelYawLerp, currentYawSpeed, desiredYawStep);
} else {
currentYawSpeed = MathHelper.lerp(decelYawLerp, currentYawSpeed, desiredYawStep);
}
float accelPitchLerp = 1.0f - (float)Math.exp(-acceleration.getFloatValue() * 0.8f * timeScale);
float decelPitchLerp = 1.0f - (float)Math.exp(-deceleration.getFloatValue() * 0.8f * timeScale);
if (Math.abs(desiredPitchStep) > Math.abs(currentPitchSpeed)) {
currentPitchSpeed = MathHelper.lerp(accelPitchLerp, currentPitchSpeed, desiredPitchStep);
} else {
currentPitchSpeed = MathHelper.lerp(decelPitchLerp, currentPitchSpeed, desiredPitchStep);
}
if (helpEnabled) {
addRandomMicroMovements(timeScale);
}
float maxJump = maxDelta.getFloatValue() * timeScale;
currentYawSpeed = MathHelper.clamp(currentYawSpeed, -maxJump, maxJump);
currentPitchSpeed = MathHelper.clamp(currentPitchSpeed, -maxJump, maxJump);
newYaw = currentYaw + currentYawSpeed;
newPitch = currentPitch + currentPitchSpeed;
} else {
float lerpFactor = 1.0f - (float)Math.exp(-0.5f * timeScale);
float yawStep = yawDiff * lerpFactor;
float pitchStep = pitchDiff * lerpFactor;
yawStep = MathHelper.clamp(yawStep, -targetYawSpeed * timeScale, targetYawSpeed * timeScale);
pitchStep = MathHelper.clamp(pitchStep, -targetPitchSpeed * timeScale, targetPitchSpeed * timeScale);
float maxJump = maxDelta.getFloatValue() * timeScale;
yawStep = MathHelper.clamp(yawStep, -maxJump, maxJump);
pitchStep = MathHelper.clamp(pitchStep, -maxJump, maxJump);
newYaw = currentYaw + yawStep;
newPitch = currentPitch + pitchStep;
}
if (helpEnabled) {
newYaw += (random.nextFloat() - 0.5f) * 0.03f * timeScale;
newPitch += (random.nextFloat() - 0.5f) * 0.03f * timeScale;
}
newYaw = applyGCD(newYaw, currentYaw);
newPitch = applyGCD(newPitch, currentPitch);
mc.player.setYaw(newYaw);
mc.player.setPitch(newPitch);
}
private void onWorldRender(WorldRenderContext context) {
if (!isEnabled()) return;
long now = System.currentTimeMillis();
if (lastRenderTime == 0) lastRenderTime = now;
float dt = (now - lastRenderTime) / 1000.0f;
lastRenderTime = now;
if (dt > 0.1f) dt = 0.1f;
if (dt <= 0f) return;
performAimUpdate(dt);
}
private PlayerEntity findBestTarget(MinecraftClient client) {
return client.world.getPlayers().stream()
.filter(p -> p != client.player && p.isAlive())
.filter(p -> client.player.squaredDistanceTo(p) <= distance.getFloatValue() * distance.getFloatValue())
.filter(p -> {
if (p.isInvisible() && !hasAnyArmor(p)) return false;
return !FriendManager.isFriend(p.getName().getString().toLowerCase());
})
.filter(p -> {
if (!wallCheck.getValue()) return true;
Vec3d eyePos = mc.player.getEyePos();
Vec3d targetPos = p.getEyePos();
BlockHitResult blockHit = mc.world.raycast(new RaycastContext(
eyePos,
targetPos,
RaycastContext.ShapeType.COLLIDER,
RaycastContext.FluidHandling.NONE,
mc.player
));
return blockHit == null || blockHit.getType() == HitResult.Type.MISS;
})
.min(Comparator.comparingDouble(p -> {
double dist = client.player.squaredDistanceTo(p);
double angle = Math.abs(angleToEntity(client.player, p));
Vec3d lookVec = client.player.getRotationVec(1.0F);
Vec3d toTarget = p.getEyePos().subtract(client.player.getEyePos()).normalize();
double dot = lookVec.dotProduct(toTarget);
if (dot < 0) angle *= 2;
return dist * 0.3 + angle * 0.7;
}))
.orElse(null);
}
private double angleToEntity(PlayerEntity player, PlayerEntity target) {
Vec3d look = player.getRotationVec(1.0F);
Vec3d toTarget = target.getEyePos().subtract(player.getEyePos()).normalize();
return Math.acos(MathHelper.clamp(look.dotProduct(toTarget), -1.0, 1.0)) * (180.0 / Math.PI);
}
private boolean hasAnyArmor(PlayerEntity player) {
for (ItemStack armorStack : player.getArmorItems()) {
if (!armorStack.isEmpty() && armorStack.getItem() instanceof ArmorItem) {
return true;
}
}
return false;
}
private void removeAllSettings() {
removeSetting(fov); removeSetting(drawFov); removeSetting(maxPitchSpeed); removeSetting(maxYawSpeed);
removeSetting(maxDelta); removeSetting(aimHeight); removeSetting(distance);
removeSetting(smoothFactor); removeSetting(smoothEnabled);
removeSetting(acceleration); removeSetting(deceleration); removeSetting(wallCheck);
removeSetting(randomEnabled); removeSetting(randomMinHeight); removeSetting(randomMaxHeight);
removeSetting(randomUpdateTicks); removeSetting(randomizeTiming); removeSetting(timingRandomRange);
removeSetting(randomizeMicroMovements); removeSetting(microMovementChance); removeSetting(microMovementStrength);
removeSetting(overShoot); removeSetting(overShootChance); removeSetting(overShootStrength);
removeSetting(finalError); removeSetting(microMovementInterval); removeSetting(microMovementDecay);
removeSetting(microMovementYawWeight); removeSetting(microMovementPitchWeight);
removeSetting(NoiseEnabled); removeSetting(NoiseStrength); removeSetting(NoiseFrequency);
removeSetting(NoiseSmoothing); removeSetting(NoiseType);
removeSetting(gcdFix); removeSetting(gcdMultiplier); removeSetting(gcdRandomness);
}
private void addAllSettings() {
addSetting(fov); addSetting(drawFov); addSetting(maxPitchSpeed); addSetting(maxYawSpeed);
addSetting(maxDelta); addSetting(aimHeight); addSetting(distance);
addSetting(smoothFactor); addSetting(smoothEnabled);
addSetting(acceleration); addSetting(deceleration); addSetting(wallCheck);
addSetting(randomEnabled); addSetting(randomMinHeight); addSetting(randomMaxHeight);
addSetting(randomUpdateTicks); addSetting(randomizeTiming); addSetting(timingRandomRange);
addSetting(randomizeMicroMovements); addSetting(microMovementChance); addSetting(microMovementStrength);
addSetting(overShoot); addSetting(overShootChance); addSetting(overShootStrength);
addSetting(finalError); addSetting(microMovementInterval); addSetting(microMovementDecay);
addSetting(microMovementYawWeight); addSetting(microMovementPitchWeight);
addSetting(NoiseEnabled); addSetting(NoiseStrength); addSetting(NoiseFrequency);
addSetting(NoiseSmoothing); addSetting(NoiseType);
addSetting(gcdFix); addSetting(gcdMultiplier); addSetting(gcdRandomness);
}
}
package fun.exort.module.list.combat;
import com.google.common.eventbus.Subscribe;
import fun.exort.event.list.EventUpdate;
import fun.exort.module.Module;
import fun.exort.module.ModuleCategory;
import fun.exort.module.ModuleInformation;
import fun.exort.module.settings.BooleanSetting;
import fun.exort.module.settings.ModeSetting;
import fun.exort.module.settings.NumberSetting;
import fun.exort.util.FriendManager;
import fun.exort.util.render.builders.Builder;
import fun.exort.util.render.builders.states.QuadColorState;
import fun.exort.util.render.builders.states.SizeState;
import fun.exort.util.render.renderers.impl.BuiltTexture;
import net.fabricmc.fabric.api.client.rendering.v1.HudRenderCallback;
import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderContext;
import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderEvents;
import net.minecraft.client.MinecraftClient;
import net.minecraft.client.gui.DrawContext;
import net.minecraft.client.render.RenderTickCounter;
import net.minecraft.client.texture.AbstractTexture;
import net.minecraft.client.texture.NativeImage;
import net.minecraft.client.texture.NativeImageBackedTexture;
import net.minecraft.entity.player.PlayerEntity;
import net.minecraft.entity.projectile.ProjectileUtil;
import net.minecraft.item.ArmorItem;
import net.minecraft.item.ItemStack;
import net.minecraft.util.hit.BlockHitResult;
import net.minecraft.util.hit.EntityHitResult;
import net.minecraft.util.hit.HitResult;
import net.minecraft.util.math.Box;
import net.minecraft.util.math.MathHelper;
import net.minecraft.util.math.Vec3d;
import net.minecraft.world.RaycastContext;
import org.joml.Matrix4f;
import java.awt.Color;
import java.io.IOException;
import java.io.InputStream;
import java.util.Comparator;
import java.util.Random;
@ModuleInformation(
moduleName = "AimAssist",
moduleCategory = ModuleCategory.Combat
,
moduleKeybind = 82
)
public class AimAssist extends Module {
public final NumberSetting fov = new NumberSetting("Fov", this, 360, 20, 360, 5);
public final BooleanSetting drawFov = new BooleanSetting("Draw Fov", this, true);
public final NumberSetting maxYawSpeed = new NumberSetting("MaxYawSpeed", this, 8.0, 0.1, 25.0, 0.1);
public final NumberSetting maxPitchSpeed = new NumberSetting("MaxPitchSpeed", this, 0.2, 0.1, 10.0, 0.1);
public final NumberSetting maxDelta = new NumberSetting("MaxDelta (Limiter)", this, 45.0, 5.0, 180.0, 1.0);
public final NumberSetting aimHeight = new NumberSetting("AimHeight", this, 0.95, 0.2, 1.0, 0.1);
public final NumberSetting distance = new NumberSetting("Distance", this, 3.5, 2.0, 5.0, 0.1);
public final NumberSetting smoothFactor = new NumberSetting("SmoothFactor", this, 0.15, 0.01, 0.5, 0.01);
public final BooleanSetting wallCheck = new BooleanSetting("WallCheck", this, false);
public static boolean onSelfDestruct = false;
public final ModeSetting Rotation = new ModeSetting("Rotation ", this, "Hybrid", "LEGIT", "Hybrid", "CUSTOM");
public final BooleanSetting smoothEnabled = new BooleanSetting("Smooth", this, true);
private final NumberSetting behindSpeedMultiplier = new NumberSetting("BehindMultiplier", this, 0.65, 0.1, 1.0, 0.1);
private static PlayerEntity lockedTarget = null;
private static float currentYawSpeed = 0f;
private static float currentPitchSpeed = 0f;
private NumberSetting acceleration = new NumberSetting("Acceleration", this, 0.15, 0.1, 1.0, 0.1);
private NumberSetting deceleration = new NumberSetting("Deceleration", this, 0.5, 0.1, 1.0, 0.1);
private NumberSetting predictStrength = new NumberSetting("Predict Strength", this, 1.2, 0.1, 10, 0.1);
private BooleanSetting randomEnabled = new BooleanSetting("Randomize AimHeight", this, true);
private NumberSetting randomMinHeight = new NumberSetting("Min Height", this, 0.3, 0.2, 0.8, 0.05);
private NumberSetting randomMaxHeight = new NumberSetting("Max Height", this, 0.95, 0.5, 1.0, 0.05);
private NumberSetting randomUpdateTicks = new NumberSetting("Update Delay (ticks)", this, 30, 5, 100, 5);
private BooleanSetting randomizeTiming = new BooleanSetting("Randomize Timing", this, true);
private NumberSetting timingRandomRange = new NumberSetting("Timing Random Range (ms)", this, 10, 1, 30, 1);
private BooleanSetting randomizeMicroMovements = new BooleanSetting("Randomize MicroMovements", this, true);
private NumberSetting microMovementChance = new NumberSetting("MicroMovement Chance %", this, 5, 1, 20, 1);
private NumberSetting microMovementStrength = new NumberSetting("MicroMovement Strength", this, 0.1, 0.01, 0.5, 0.01);
private BooleanSetting overShoot = new BooleanSetting("OverShoot", this, true);
private NumberSetting overShootChance = new NumberSetting("OverShootChance %", this, 0.5, 0.1, 10, 0.1);
private NumberSetting overShootStrength = new NumberSetting("OverShootStrength", this, 1.5, 0.2, 40, 0.1);
private final NumberSetting finalError = new NumberSetting("Final Error (deg)", this, 0.25, 0.0, 1.5, 0.05);
public final NumberSetting microMovementInterval = new NumberSetting("Micro Interval (ms)", this, 50, 20, 200, 10);
public final NumberSetting microMovementDecay = new NumberSetting("Micro Decay", this, 0.95, 0.85, 1.0, 0.01);
public final NumberSetting microMovementYawWeight = new NumberSetting("Micro Yaw Weight", this, 1.0, 0.5, 2.0, 0.1);
public final NumberSetting microMovementPitchWeight = new NumberSetting("Micro Pitch Weight", this, 0.4, 0.1, 1.0, 0.1);
public final BooleanSetting NoiseEnabled = new BooleanSetting("Noise", this, true);
public final NumberSetting NoiseStrength = new NumberSetting("Noise Strength", this, 0.8, 0.1, 3.0, 0.05);
public final NumberSetting NoiseFrequency = new NumberSetting("Noise Frequency", this, 0.025, 0.01, 0.1, 0.002);
public final NumberSetting NoiseSmoothing = new NumberSetting("Noise Smoothing", this, 0.85, 0.6, 0.95, 0.01);
public final ModeSetting NoiseType = new ModeSetting("Noise Type", this, "Perlin", "Sine", "Perlin", "Smooth");
public final BooleanSetting gcdFix = new BooleanSetting("GCD Fix", this, true);
public final NumberSetting gcdMultiplier = new NumberSetting("GCD Multiplier", this, 1.0, 0.5, 1.6, 0.1);
public final NumberSetting gcdRandomness = new NumberSetting("GCD Randomness %", this, 12.5, 0.0, 50.0, 1.0);
private long onTargetStartTime = 0;
private final long REQUIRED_TIME_ON_TARGET_MS = 50;
private boolean helpEnabled = true;
private Random random = new Random();
private float currentRandomHeight = 0.95f;
private int updateCounter = 0;
private float lastTargetYaw = 0;
private float lastTargetPitch = 0;
private String lastAppliedMode = "";
private long lastRenderTime = 0;
private boolean overshootActive = false;
private float overshootErrorYaw = 0f;
private float overshootErrorPitch = 0f;
private float overshootDecay = 0.9f;
private float overshootNoiseBlend = 0f;
private int microMovementCooldown = 0;
private long lastMicroMovementTime = 0;
private float lastMicroYawSpeed = 0f;
private float lastMicroPitchSpeed = 0f;
private int microMovementType = 0;
private float noisePhaseYaw = 0f;
private float noisePhasePitch = 0f;
private float lastNoiseYaw = 0f;
private float lastNoisePitch = 0f;
private float perlinX = 0f;
private float perlinY = 0f;
private AbstractTexture circleTexture = null;
public AimAssist() {
addSetting(Rotation);
addSetting(drawFov);
WorldRenderEvents.BEFORE_ENTITIES.register(this::onWorldRender);
HudRenderCallback.EVENT.register(this::onHudRender);
}
@override
public void onEnable() {
super.onEnable();
resetTarget();
updateRandomHeight();
lastAppliedMode = "";
lastRenderTime = System.currentTimeMillis();
overshootActive = false;
resetMicroMovements();
resetNoise();
onTargetStartTime = 0;
helpEnabled = true;
}
@override
public void onDisable() {
super.onDisable();
resetTarget();
overshootActive = false;
onTargetStartTime = 0;
helpEnabled = true;
}
private void loadCircleTexture() {
if (circleTexture != null) return;
try {
InputStream inputStream = getClass().getClassLoader().getResourceAsStream("assets/fear/icons/circle.png");
if (inputStream == null) {
System.err.println("Could not find texture: assets/fear/icons/circle.png");
return;
}
NativeImage image = NativeImage.read(inputStream);
inputStream.close();
circleTexture = new NativeImageBackedTexture(image);
} catch (IOException e) {
System.err.println("Failed to load circle texture: " + e.getMessage());
}
}
private void onHudRender(DrawContext context, RenderTickCounter tickCounter) {
if (!isEnabled() || !drawFov.getValue() || mc.player == null) return;
float currentFov = fov.getFloatValue();
loadCircleTexture();
if (circleTexture == null) return;
float screenWidth = context.getScaledWindowWidth();
float screenHeight = context.getScaledWindowHeight();
float mcFov = mc.options.getFov().getValue().floatValue();
float radius = (float)(
Math.tan(Math.toRadians(currentFov / 2f)) /
Math.tan(Math.toRadians(mcFov / 2f))
) * (screenHeight / 2f);
radius *= 0.58f;
radius = Math.max(1f, Math.min(radius, screenHeight));
float size = radius * 2f;
float x = (screenWidth / 2f) - radius;
float y = (screenHeight / 2f) - radius;
Matrix4f matrix = context.getMatrices().peek().getPositionMatrix();
BuiltTexture circle = Builder.texture()
.size(new SizeState(size, size))
.texture(0, 0, 1, 1, circleTexture)
.color(new QuadColorState(new Color(255, 255, 255, 255)))
.build();
circle.render(matrix, x, y);
}
private void resetTarget() {
lockedTarget = null;
currentYawSpeed = 0f;
currentPitchSpeed = 0f;
lastTargetYaw = 0;
lastTargetPitch = 0;
overshootActive = false;
}
private void resetMicroMovements() {
microMovementCooldown = 0;
lastMicroMovementTime = 0;
lastMicroYawSpeed = 0f;
lastMicroPitchSpeed = 0f;
microMovementType = 0;
}
private void resetNoise() {
noisePhaseYaw = 0f;
noisePhasePitch = 0f;
lastNoiseYaw = 0f;
lastNoisePitch = 0f;
perlinX = 0f;
perlinY = 0f;
}
private boolean isCrosshairOnTarget(PlayerEntity target) {
if (mc.player == null || mc.world == null || target == null) return false;
Vec3d eyePos = mc.player.getEyePos();
Vec3d lookVec = mc.player.getRotationVec(1.0F);
double maxDist = distance.getFloatValue();
Vec3d endPos = eyePos.add(lookVec.multiply(maxDist));
Box box = mc.player.getBoundingBox()
.stretch(lookVec.multiply(maxDist))
.expand(1.0, 1.0, 1.0);
EntityHitResult hit = ProjectileUtil.raycast(
mc.player,
eyePos,
endPos,
box,
entity -> entity == target,
maxDist * maxDist
);
return hit != null && hit.getEntity() == target;
}
private float addNoiseMovements(float dt) {
if (!NoiseEnabled.getValue()) return 0f;
float timeScale = dt * 60.0f;
float noiseYawRaw = 0f;
float freqStep = NoiseFrequency.getFloatValue() * timeScale;
float strength = NoiseStrength.getFloatValue();
float alpha = 1.0f - (float)Math.exp(-NoiseSmoothing.getFloatValue() * timeScale);
switch (NoiseType.getValue()) {
case "Perlin":
noiseYawRaw = (float)(
Math.sin(perlinX) * 0.4 +
Math.sin(perlinX * 2.17) * 0.3 +
Math.sin(perlinX * 4.93) * 0.2 +
Math.sin(perlinX * 11.37) * 0.1
) * strength;
perlinX += freqStep;
perlinY += freqStep * 0.83f;
lastNoiseYaw = MathHelper.lerp(alpha, lastNoiseYaw, noiseYawRaw);
break;
case "Sine":
noisePhaseYaw += freqStep;
noiseYawRaw = (float)(Math.sin(noisePhaseYaw) * Math.sin(noisePhaseYaw * 0.5) * strength);
lastNoiseYaw = MathHelper.lerp(alpha, lastNoiseYaw, noiseYawRaw);
break;
case "Smooth":
default:
if (random.nextInt(6) == 0) {
noiseYawRaw = (float)(random.nextGaussian() * strength * 0.5);
lastNoiseYaw = MathHelper.lerp(alpha, lastNoiseYaw, noiseYawRaw);
} else {
float naturalDecay = 1.0f - (float)Math.exp(-0.05f * timeScale);
lastNoiseYaw = MathHelper.lerp(naturalDecay, lastNoiseYaw, 0f);
}
break;
}
float maxNoiseChange = 0.15f * timeScale;
float change = noiseYawRaw - lastNoiseYaw;
if (Math.abs(change) > maxNoiseChange) {
lastNoiseYaw += Math.signum(change) * maxNoiseChange;
}
if (mc.player != null && Math.abs(lastTargetYaw - mc.player.getYaw()) < 1.5f) {
return lastNoiseYaw;
}
return lastNoiseYaw * 0.4f;
}
private void addRandomMicroMovements(float timeScale) {
if (!randomizeMicroMovements.getValue()) return;
if (microMovementCooldown > 0) {
microMovementCooldown--;
if (microMovementDecay.getFloatValue() < 1.0f) {
float decayAlpha = 1.0f - (float)Math.exp(-(1.0f - microMovementDecay.getFloatValue()) * timeScale * 10.0f);
currentYawSpeed = MathHelper.lerp(decayAlpha, currentYawSpeed, 0f);
currentPitchSpeed = MathHelper.lerp(decayAlpha, currentPitchSpeed, 0f);
}
return;
}
long now = System.currentTimeMillis();
long interval = (long) microMovementInterval.getValue();
if (now - lastMicroMovementTime < interval) return;
float baseChance = microMovementChance.getFloatValue() / 100.0f;
float actualChance = baseChance;
if (Math.abs(currentYawSpeed) < 0.3f && Math.abs(currentPitchSpeed) < 0.2f) {
actualChance *= 1.3f;
} else if (Math.abs(currentYawSpeed) > maxYawSpeed.getFloatValue() * 0.7f) {
actualChance *= 0.5f;
}
if (now - lastMicroMovementTime > interval * 2) {
actualChance *= 1.2f;
}
if (random.nextFloat() >= actualChance) return;
float strength = microMovementStrength.getFloatValue();
float yawWeight = microMovementYawWeight.getFloatValue();
float pitchWeight = microMovementPitchWeight.getFloatValue();
microMovementType = random.nextInt(4);
float yawMicro = 0f;
float pitchMicro = 0f;
int cooldownTicks = 0;
switch(microMovementType) {
case 0:
yawMicro = (random.nextFloat() - 0.5f) * strength * yawWeight;
pitchMicro = (random.nextFloat() - 0.5f) * strength * pitchWeight * 0.6f;
cooldownTicks = 2 + random.nextInt(2);
break;
case 1:
yawMicro = (random.nextFloat() - 0.5f) * strength * yawWeight * 1.5f;
pitchMicro = (random.nextFloat() - 0.5f) * strength * pitchWeight * 0.4f;
cooldownTicks = 3 + random.nextInt(3);
break;
case 2:
for (int i = 0; i < 2; i++) {
currentYawSpeed += (random.nextFloat() - 0.5f) * strength * yawWeight * 0.4f;
currentPitchSpeed += (random.nextFloat() - 0.5f) * strength * pitchWeight * 0.3f;
}
cooldownTicks = 1;
break;
case 3:
if (lockedTarget != null && mc.player != null) {
float currentYaw = mc.player.getYaw();
float yawDiff = MathHelper.wrapDegrees(lastTargetYaw - currentYaw);
float correctionDir = Math.signum(yawDiff);
yawMicro = correctionDir * strength * yawWeight * 0.6f;
pitchMicro = (random.nextFloat() - 0.5f) * strength * pitchWeight * 0.3f;
}
cooldownTicks = 4 + random.nextInt(2);
break;
}
currentYawSpeed += yawMicro * timeScale;
currentPitchSpeed += pitchMicro * timeScale;
lastMicroYawSpeed = yawMicro;
lastMicroPitchSpeed = pitchMicro;
microMovementCooldown = cooldownTicks;
lastMicroMovementTime = now;
}
private void tryStartOvershoot(float yawDiff, float pitchDiff) {
if (!overShoot.getValue()) return;
if (overshootActive) return;
if (Math.abs(yawDiff) < 4.0f) return;
float chance = overShootChance.getFloatValue() / 100f;
if (random.nextFloat() > chance) return;
float strength = overShootStrength.getFloatValue();
float direction = Math.signum(yawDiff);
overshootErrorYaw = direction * (0.5f + random.nextFloat()) * strength;
overshootErrorPitch = (random.nextFloat() - 0.5f) * strength * 0.4f;
overshootDecay = 0.82f + random.nextFloat() * 0.1f;
overshootNoiseBlend = 0.6f + random.nextFloat() * 0.4f;
overshootActive = true;
}
private void updateOvershoot(float noiseValue, float timeScale) {
if (!overshootActive) return;
overshootErrorYaw *= overshootDecay;
overshootErrorPitch *= overshootDecay;
overshootErrorYaw += noiseValue * overshootNoiseBlend * 0.5f;
overshootErrorPitch += noiseValue * overshootNoiseBlend * 0.2f;
if (Math.abs(overshootErrorYaw) < 0.2f) {
if (random.nextFloat() < 0.35f) {
overshootErrorYaw *= 0.5f;
} else {
overshootErrorYaw = 0f;
}
}
if (Math.abs(overshootErrorPitch) < 0.1f) {
overshootErrorPitch = 0f;
}
if (Math.abs(overshootErrorYaw) < 0.05f && Math.abs(overshootErrorPitch) < 0.05f) {
overshootActive = false;
}
}
private float addFinalError(float angle, float errorDeg) {
if (errorDeg <= 0) return angle;
return angle + (random.nextFloat() - 0.5f) * errorDeg * 2;
}
private void updateRandomHeight() {
if (!randomEnabled.getValue()) {
currentRandomHeight = aimHeight.getFloatValue();
return;
}
float min = randomMinHeight.getFloatValue();
float max = randomMaxHeight.getFloatValue();
if (min > max) {
float temp = min; min = max; max = temp;
}
currentRandomHeight = min + random.nextFloat() * (max - min);
}
private float getCurrentAimHeight() {
if (randomEnabled.getValue()) {
return currentRandomHeight;
}
return aimHeight.getFloatValue();
}
private void applyModeSettings(String mode) {
switch (mode) {
case "Hybrid":
removeAllSettings();
fov.setValue(360);
maxPitchSpeed.setValue(1.5);
maxYawSpeed.setValue(10.67);
maxDelta.setValue(32.5);
aimHeight.setValue(0.9);
distance.setValue(4.2);
smoothFactor.setValue(0.125);
smoothEnabled.setValue(true);
acceleration.setValue(0.40);
deceleration.setValue(0.2);
wallCheck.setValue(true);
randomEnabled.setValue(true);
randomMaxHeight.setValue(0.93);
randomMinHeight.setValue(0.7);
randomUpdateTicks.setValue(5);
randomizeTiming.setValue(true);
timingRandomRange.setValue(15);
randomizeMicroMovements.setValue(true);
microMovementChance.setValue(6);
microMovementStrength.setValue(1.1);
overShoot.setValue(true);
overShootChance.setValue(5);
overShootStrength.setValue(1.6);
finalError.setValue(1);
NoiseEnabled.setValue(true);
NoiseStrength.setValue(4.4);
NoiseFrequency.setValue(0.015);
NoiseSmoothing.setValue(0.75);
NoiseType.setValue("Perlin");
microMovementInterval.setValue(15);
microMovementDecay.setValue(0.75);
microMovementYawWeight.setValue(1.6);
microMovementPitchWeight.setValue(1.0);
gcdFix.setValue(true);
gcdMultiplier.setValue(1.0);
gcdRandomness.setValue(0);
break;
case "LEGIT":
removeAllSettings();
fov.setValue(120);
maxPitchSpeed.setValue(0.7);
maxYawSpeed.setValue(5.5);
maxDelta.setValue(30);
aimHeight.setValue(1.0);
distance.setValue(3.8);
smoothFactor.setValue(0.12);
acceleration.setValue(0.42);
deceleration.setValue(0.2);
smoothEnabled.setValue(true);
wallCheck.setValue(true);
randomEnabled.setValue(true);
randomMinHeight.setValue(0.65);
randomMaxHeight.setValue(0.9);
randomUpdateTicks.setValue(40);
randomizeTiming.setValue(true);
timingRandomRange.setValue(8);
randomizeMicroMovements.setValue(true);
microMovementChance.setValue(6);
microMovementStrength.setValue(1.1);
overShoot.setValue(false);
finalError.setValue(0.2);
microMovementInterval.setValue(20);
microMovementDecay.setValue(0.77);
microMovementYawWeight.setValue(1.6);
microMovementPitchWeight.setValue(0.35);
NoiseEnabled.setValue(true);
NoiseStrength.setValue(3.5);
NoiseFrequency.setValue(0.018);
NoiseSmoothing.setValue(0.89);
NoiseType.setValue("Perlin");
gcdFix.setValue(true);
gcdMultiplier.setValue(0.8);
gcdRandomness.setValue(11.0);
break;
case "CUSTOM":
addAllSettings();
break;
}
}
private float applyGCD(float targetAngle, float currentAngle) {
if (!gcdFix.getValue() || mc.options == null) return targetAngle;
float sens = 0.6f;
float f = sens * 0.6F + 0.2F;
float gcd = f * f * f * 1.2F;
float variation = (float) (1.0 + (random.nextGaussian() * (gcdRandomness.getFloatValue() / 100.0f)));
gcd *= gcdMultiplier.getFloatValue() * Math.max(0.1f, variation);
if (gcd < 0.0001f) gcd = 0.0001f;
float delta = targetAngle - currentAngle;
float exactSteps = delta / gcd;
int steps = (int) exactSteps;
float remainder = Math.abs(exactSteps - steps);
if (random.nextFloat() < remainder) {
steps += Math.signum(exactSteps);
}
return currentAngle + (steps * gcd);
}
private void performAimUpdate(float dt) {
if (!isEnabled()) return;
if (mc.player == null || mc.world == null) return;
if (mc.player.isUsingItem()) return;
if (onSelfDestruct) { super.onDisable(); return; }
String currentMode = Rotation.getValue();
if (!currentMode.equals(lastAppliedMode)) {
applyModeSettings(currentMode);
lastAppliedMode = currentMode;
}
if (randomEnabled.getValue()) {
updateCounter++;
if (updateCounter >= randomUpdateTicks.getIntValue()) {
updateRandomHeight();
updateCounter = 0;
}
}
float currentYaw = mc.player.getYaw();
float currentPitch = mc.player.getPitch();
// Проверка валидности залоченной цели
if (lockedTarget != null) {
boolean isTargetDead = !lockedTarget.isAlive();
boolean isTargetOutOfRange = mc.player.squaredDistanceTo(lockedTarget) > distance.getFloatValue() * distance.getFloatValue();
if (isTargetDead || isTargetOutOfRange) {
lockedTarget = null;
}
}
// Поиск новой цели только если нет залоченной
if (lockedTarget == null) {
PlayerEntity bestTarget = findBestTarget(mc);
if (bestTarget != null) {
lockedTarget = bestTarget;
}
}
if (lockedTarget == null) {
onTargetStartTime = 0;
helpEnabled = true;
return;
}
PlayerEntity target = lockedTarget;
if (wallCheck.getValue()) {
Vec3d eyePos = mc.player.getEyePos();
Vec3d targetPos = target.getEyePos();
BlockHitResult blockHit = mc.world.raycast(new RaycastContext(
eyePos,
targetPos,
RaycastContext.ShapeType.COLLIDER,
RaycastContext.FluidHandling.NONE,
mc.player
));
if (blockHit != null && blockHit.getType() != HitResult.Type.MISS) {
return;
}
}
if (Math.abs(mc.player.getY() - target.getY()) > 3.0 && mc.player.squaredDistanceTo(target) < 4.0) {
return;
}
boolean currentlyOnTarget = isCrosshairOnTarget(target);
if (currentlyOnTarget) {
if (onTargetStartTime == 0) {
onTargetStartTime = System.currentTimeMillis();
}
if (System.currentTimeMillis() - onTargetStartTime >= REQUIRED_TIME_ON_TARGET_MS) {
helpEnabled = false;
}
} else {
onTargetStartTime = 0;
helpEnabled = true;
}
float eyeHeight = target.getEyeHeight(target.getPose());
float targetHeight = getCurrentAimHeight();
Vec3d predictedPos = new Vec3d(
target.getX() + (target.getX() - target.prevX) * predictStrength.getValue(),
target.getY(),
target.getZ() + (target.getZ() - target.prevZ) * predictStrength.getValue()
);
Vec3d targetPos = predictedPos.add(0, eyeHeight * targetHeight, 0);
Vec3d delta = targetPos.subtract(mc.player.getEyePos());
float targetYaw = (float) MathHelper.wrapDegrees(Math.toDegrees(Math.atan2(delta.z, delta.x)) - 90);
float targetPitch = (float) -Math.toDegrees(Math.atan2(delta.y, Math.sqrt(delta.x * delta.x + delta.z * delta.z)));
targetPitch = MathHelper.clamp(targetPitch, -90f, 90f);
lastTargetYaw = targetYaw;
lastTargetPitch = targetPitch;
float finalErrorDeg = finalError.getFloatValue();
if (finalErrorDeg > 0) {
lastTargetYaw = addFinalError(lastTargetYaw, finalErrorDeg);
lastTargetPitch = addFinalError(lastTargetPitch, finalErrorDeg);
}
float noiseValue = addNoiseMovements(dt);
float timeScale = dt * 60.0f;
updateOvershoot(noiseValue, timeScale);
if (overshootActive) {
lastTargetYaw += overshootErrorYaw;
lastTargetPitch += overshootErrorPitch;
}
float yawDiff = MathHelper.wrapDegrees(lastTargetYaw - currentYaw);
float pitchDiff = lastTargetPitch - currentPitch;
if (Math.abs(yawDiff) > fov.getFloatValue() / 2f) return;
tryStartOvershoot(yawDiff, pitchDiff);
// ================= НОВАЯ ЛОГИКА ДЛЯ currentlyOnCrosshair =================
// Если цель на прицеле, применяем Noise + Randomize Aim Height (движение вверх-вниз с 30% силой)
if (currentlyOnTarget) {
// Основной шум (Noise)
yawDiff = noiseValue * 2.0f;
// Randomize Aim Height - движение вверх/вниз с силой 30% от максимальной скорости
// Генерируем синусоидальное движение для плавного подъёма и опускания прицела
float aimHeightNoise = (float)(Math.sin(System.currentTimeMillis() / 200.0) * 0.5 + Math.sin(System.currentTimeMillis() / 87.0) * 0.5);
aimHeightNoise = MathHelper.clamp(aimHeightNoise, -0.8f, 0.8f);
// Сила движения = 30% от стандартной скорости + небольшой случайный разброс
float aimHeightStrength = 0.3f * (0.85f + random.nextFloat() * 0.3f);
// Применяем вертикальное движение с ограничением, чтобы не улететь слишком далеко от цели
pitchDiff = (aimHeightNoise * aimHeightStrength * 1.2f) + (noiseValue * 0.4f);
// Дополнительная маленькая случайность для более натурального вида
if (random.nextInt(100) < 15) {
pitchDiff += (random.nextFloat() - 0.5f) * 0.8f;
}
} else {
// Стандартное поведение, когда цель НЕ на прицеле
yawDiff += noiseValue;
pitchDiff += noiseValue * 0.4f;
}
// ========================================================================
float currentYawDiff = yawDiff;
boolean isBehind = Math.abs(currentYawDiff) > fov.getFloatValue() && Math.abs(currentYawDiff) <= 180f;
float targetYawSpeed;
float targetPitchSpeed;
if (isBehind) {
targetYawSpeed = (maxYawSpeed.getFloatValue() * behindSpeedMultiplier.getFloatValue()) * (random.nextBoolean() ? 1.1f : 0.9f);
targetPitchSpeed = (maxPitchSpeed.getFloatValue() * behindSpeedMultiplier.getFloatValue()) * (random.nextBoolean() ? 1.1f : 0.9f);
} else {
targetYawSpeed = maxYawSpeed.getFloatValue() * (random.nextBoolean() ? 1.1f : 0.9f);
targetPitchSpeed = maxPitchSpeed.getFloatValue() * (random.nextBoolean() ? 1.1f : 0.9f);
}
// Если цель на прицеле - ограничиваем скорость поворота по вертикали 30%
if (currentlyOnTarget) {
targetPitchSpeed *= 0.3f;
}
float newYaw = currentYaw;
float newPitch = currentPitch;
if (smoothEnabled.getValue()) {
float speedMultiplier = 1.0f;
float baseYawLerp = 1.0f - (float)Math.exp(-smoothFactor.getFloatValue() * timeScale);
float basePitchLerp = 1.0f - (float)Math.exp(-smoothFactor.getFloatValue() * timeScale);
float desiredYawStep = yawDiff * baseYawLerp * speedMultiplier;
float desiredPitchStep = pitchDiff * basePitchLerp * speedMultiplier;
desiredYawStep = MathHelper.clamp(desiredYawStep, -targetYawSpeed * timeScale, targetYawSpeed * timeScale);
desiredPitchStep = MathHelper.clamp(desiredPitchStep, -targetPitchSpeed * timeScale, targetPitchSpeed * timeScale);
float accelYawLerp = 1.0f - (float)Math.exp(-acceleration.getFloatValue() * timeScale);
float decelYawLerp = 1.0f - (float)Math.exp(-deceleration.getFloatValue() * timeScale);
if (Math.abs(desiredYawStep) > Math.abs(currentYawSpeed)) {
currentYawSpeed = MathHelper.lerp(accelYawLerp, currentYawSpeed, desiredYawStep);
} else {
currentYawSpeed = MathHelper.lerp(decelYawLerp, currentYawSpeed, desiredYawStep);
}
float accelPitchLerp = 1.0f - (float)Math.exp(-acceleration.getFloatValue() * 0.8f * timeScale);
float decelPitchLerp = 1.0f - (float)Math.exp(-deceleration.getFloatValue() * 0.8f * timeScale);
if (Math.abs(desiredPitchStep) > Math.abs(currentPitchSpeed)) {
currentPitchSpeed = MathHelper.lerp(accelPitchLerp, currentPitchSpeed, desiredPitchStep);
} else {
currentPitchSpeed = MathHelper.lerp(decelPitchLerp, currentPitchSpeed, desiredPitchStep);
}
if (helpEnabled) {
addRandomMicroMovements(timeScale);
}
float maxJump = maxDelta.getFloatValue() * timeScale;
currentYawSpeed = MathHelper.clamp(currentYawSpeed, -maxJump, maxJump);
currentPitchSpeed = MathHelper.clamp(currentPitchSpeed, -maxJump, maxJump);
newYaw = currentYaw + currentYawSpeed;
newPitch = currentPitch + currentPitchSpeed;
} else {
float lerpFactor = 1.0f - (float)Math.exp(-0.5f * timeScale);
float yawStep = yawDiff * lerpFactor;
float pitchStep = pitchDiff * lerpFactor;
yawStep = MathHelper.clamp(yawStep, -targetYawSpeed * timeScale, targetYawSpeed * timeScale);
pitchStep = MathHelper.clamp(pitchStep, -targetPitchSpeed * timeScale, targetPitchSpeed * timeScale);
float maxJump = maxDelta.getFloatValue() * timeScale;
yawStep = MathHelper.clamp(yawStep, -maxJump, maxJump);
pitchStep = MathHelper.clamp(pitchStep, -maxJump, maxJump);
newYaw = currentYaw + yawStep;
newPitch = currentPitch + pitchStep;
}
if (helpEnabled) {
newYaw += (random.nextFloat() - 0.5f) * 0.03f * timeScale;
newPitch += (random.nextFloat() - 0.5f) * 0.03f * timeScale;
}
newYaw = applyGCD(newYaw, currentYaw);
newPitch = applyGCD(newPitch, currentPitch);
mc.player.setYaw(newYaw);
mc.player.setPitch(newPitch);
}
private void onWorldRender(WorldRenderContext context) {
if (!isEnabled()) return;
long now = System.currentTimeMillis();
if (lastRenderTime == 0) lastRenderTime = now;
float dt = (now - lastRenderTime) / 1000.0f;
lastRenderTime = now;
if (dt > 0.1f) dt = 0.1f;
if (dt <= 0f) return;
performAimUpdate(dt);
}
private PlayerEntity findBestTarget(MinecraftClient client) {
return client.world.getPlayers().stream()
.filter(p -> p != client.player && p.isAlive())
.filter(p -> client.player.squaredDistanceTo(p) <= distance.getFloatValue() * distance.getFloatValue())
.filter(p -> {
if (p.isInvisible() && !hasAnyArmor(p)) return false;
return !FriendManager.isFriend(p.getName().getString().toLowerCase());
})
.filter(p -> {
if (!wallCheck.getValue()) return true;
Vec3d eyePos = mc.player.getEyePos();
Vec3d targetPos = p.getEyePos();
BlockHitResult blockHit = mc.world.raycast(new RaycastContext(
eyePos,
targetPos,
RaycastContext.ShapeType.COLLIDER,
RaycastContext.FluidHandling.NONE,
mc.player
));
return blockHit == null || blockHit.getType() == HitResult.Type.MISS;
})
.min(Comparator.comparingDouble(p -> {
double dist = client.player.squaredDistanceTo(p);
double angle = Math.abs(angleToEntity(client.player, p));
Vec3d lookVec = client.player.getRotationVec(1.0F);
Vec3d toTarget = p.getEyePos().subtract(client.player.getEyePos()).normalize();
double dot = lookVec.dotProduct(toTarget);
if (dot < 0) angle *= 2;
return dist * 0.3 + angle * 0.7;
}))
.orElse(null);
}
private double angleToEntity(PlayerEntity player, PlayerEntity target) {
Vec3d look = player.getRotationVec(1.0F);
Vec3d toTarget = target.getEyePos().subtract(player.getEyePos()).normalize();
return Math.acos(MathHelper.clamp(look.dotProduct(toTarget), -1.0, 1.0)) * (180.0 / Math.PI);
}
private boolean hasAnyArmor(PlayerEntity player) {
for (ItemStack armorStack : player.getArmorItems()) {
if (!armorStack.isEmpty() && armorStack.getItem() instanceof ArmorItem) {
return true;
}
}
return false;
}
private void removeAllSettings() {
removeSetting(fov); removeSetting(drawFov); removeSetting(maxPitchSpeed); removeSetting(maxYawSpeed);
removeSetting(maxDelta); removeSetting(aimHeight); removeSetting(distance);
removeSetting(smoothFactor); removeSetting(smoothEnabled);
removeSetting(acceleration); removeSetting(deceleration); removeSetting(wallCheck);
removeSetting(randomEnabled); removeSetting(randomMinHeight); removeSetting(randomMaxHeight);
removeSetting(randomUpdateTicks); removeSetting(randomizeTiming); removeSetting(timingRandomRange);
removeSetting(randomizeMicroMovements); removeSetting(microMovementChance); removeSetting(microMovementStrength);
removeSetting(overShoot); removeSetting(overShootChance); removeSetting(overShootStrength);
removeSetting(finalError); removeSetting(microMovementInterval); removeSetting(microMovementDecay);
removeSetting(microMovementYawWeight); removeSetting(microMovementPitchWeight);
removeSetting(NoiseEnabled); removeSetting(NoiseStrength); removeSetting(NoiseFrequency);
removeSetting(NoiseSmoothing); removeSetting(NoiseType);
removeSetting(gcdFix); removeSetting(gcdMultiplier); removeSetting(gcdRandomness);
}
private void addAllSettings() {
addSetting(fov); addSetting(drawFov); addSetting(maxPitchSpeed); addSetting(maxYawSpeed);
addSetting(maxDelta); addSetting(aimHeight); addSetting(distance);
addSetting(smoothFactor); addSetting(smoothEnabled);
addSetting(acceleration); addSetting(deceleration); addSetting(wallCheck);
addSetting(randomEnabled); addSetting(randomMinHeight); addSetting(randomMaxHeight);
addSetting(randomUpdateTicks); addSetting(randomizeTiming); addSetting(timingRandomRange);
addSetting(randomizeMicroMovements); addSetting(microMovementChance); addSetting(microMovementStrength);
addSetting(overShoot); addSetting(overShootChance); addSetting(overShootStrength);
addSetting(finalError); addSetting(microMovementInterval); addSetting(microMovementDecay);
addSetting(microMovementYawWeight); addSetting(microMovementPitchWeight);
addSetting(NoiseEnabled); addSetting(NoiseStrength); addSetting(NoiseFrequency);
addSetting(NoiseSmoothing); addSetting(NoiseType);
addSetting(gcdFix); addSetting(gcdMultiplier); addSetting(gcdRandomness);
}
}
