Начинающий
Начинающий
- Статус
- Оффлайн
- Регистрация
- 23 Авг 2025
- Сообщения
- 18
- Реакции
- 0
- Выберите загрузчик игры
- Fabric
Всем привкт, изучал ач RW (сразу говорю все с помощью Chat LGBT) и сделал небольшой буст таймера, мб кому то надо
Пожалуйста, авторизуйтесь для просмотра ссылки.
LGBTTimerBypass$$$:
package code.lovesense.features.impl.movement;
import code.lovesense.events.packet.PacketEvent;
import code.lovesense.events.player.TickEvent;
import code.lovesense.features.module.Module;
import code.lovesense.features.module.ModuleCategory;
import code.lovesense.features.module.setting.implement.BooleanSetting;
import code.lovesense.features.module.setting.implement.MultiSelectSetting;
import code.lovesense.features.module.setting.implement.SelectSetting;
import code.lovesense.features.module.setting.implement.SliderSettings;
import code.lovesense.utils.client.Instance;
import code.lovesense.utils.client.managers.event.EventHandler;
import code.lovesense.utils.client.packet.network.Network;
import code.lovesense.utils.client.timer.ClientTimerController;
import code.lovesense.utils.input.MoveUtil;
import lombok.AccessLevel;
import lombok.experimental.FieldDefaults;
import lombok.experimental.NonFinal;
import net.minecraft.block.Blocks;
import net.minecraft.network.packet.s2c.common.CommonPingS2CPacket;
import net.minecraft.network.packet.s2c.common.KeepAliveS2CPacket;
import net.minecraft.network.packet.s2c.play.GameJoinS2CPacket;
import net.minecraft.network.packet.s2c.play.PlayerPositionLookS2CPacket;
import net.minecraft.util.math.MathHelper;
import code.lovesense.utils.display.interfaces.QuickImports;
import code.lovesense.utils.interactions.interact.PlayerInteractionHelper;
import java.util.Random;
@FieldDefaults(level = AccessLevel.PRIVATE)
public class Timer extends Module implements QuickImports {
private static final String PROFILE_RILIWORLD = "РилиВорлд";
private static final String PROFILE_CUSTOM = "Кастом";
private static final long TIMER_ENERGY_MAX_MS = 2_000L;
private static final long TIMER_RECOVERY_MS = 3_000L;
final SelectSetting profile = new SelectSetting("Тип", "Профиль работы таймера")
.value(PROFILE_RILIWORLD, PROFILE_CUSTOM)
.selected(PROFILE_CUSTOM);
final SelectSetting mode = new SelectSetting("Режим", "Основной тип работы таймера")
.value("Anchor-aware", "Buffer", "Burst", "Jitter")
.selected("Anchor-aware")
.visible(this::isCustomProfile);
final SliderSettings speed = new SliderSettings("Скорость", "Основная скорость ускорения")
.setValue(1.16F)
.range(1.0F, 2.5F)
.step(0.01F)
.visible(this::isCustomProfile);
final SliderSettings idleSpeed = new SliderSettings("Idle speed", "Скорость вне anchor-окна")
.setValue(1.01F)
.range(1.0F, 1.3F)
.step(0.01F)
.visible(() -> isCustomProfile() && mode.isSelected("Anchor-aware"));
final SliderSettings anchorWindowMs = new SliderSettings("Anchor window", "Размер окна вокруг ping/transaction")
.setValue(80.0F)
.range(15, 250)
.step(1.0F)
.visible(() -> isCustomProfile() && mode.isSelected("Anchor-aware"));
final SliderSettings bufferChargeSpeed = new SliderSettings("Charge speed", "Скорость набора буфера")
.setValue(0.92F)
.range(0.5F, 1.0F)
.step(0.01F)
.visible(() -> isCustomProfile() && mode.isSelected("Buffer"));
final SliderSettings bufferSpendSpeed = new SliderSettings("Spend speed", "Скорость расхода буфера")
.setValue(1.18F)
.range(1.0F, 2.5F)
.step(0.01F)
.visible(() -> isCustomProfile() && mode.isSelected("Buffer"));
final SliderSettings bufferLimitMs = new SliderSettings("Buffer limit", "Максимальный накопленный drift буфера")
.setValue(90.0F)
.range(20, 180)
.step(1.0F)
.visible(() -> isCustomProfile() && mode.isSelected("Buffer"));
final SliderSettings burstSpeed = new SliderSettings("Burst speed", "Скорость во время всплеска")
.setValue(1.22F)
.range(1.0F, 2.5F)
.step(0.01F)
.visible(() -> isCustomProfile() && mode.isSelected("Burst"));
final SliderSettings burstTicks = new SliderSettings("Burst ticks", "Длина burst-фазы в тиках")
.setValue(4.0F)
.range(1, 12)
.step(1.0F)
.visible(() -> isCustomProfile() && mode.isSelected("Burst"));
final SliderSettings burstRestTicks = new SliderSettings("Burst rest", "Пауза между burst-фазами в тиках")
.setValue(18.0F)
.range(1, 60)
.step(1.0F)
.visible(() -> isCustomProfile() && mode.isSelected("Burst"));
final BooleanSetting jitterOverlay = new BooleanSetting("Jitter overlay", "Добавляет джиттер поверх основного типа")
.setValue(false)
.visible(() -> isCustomProfile() && !mode.isSelected("Jitter"));
final SliderSettings jitterAmount = new SliderSettings("Jitter amount", "Амплитуда джиттера поверх базовой скорости")
.setValue(0.05F)
.range(0.0F, 0.35F)
.step(0.01F)
.visible(() -> isCustomProfile() && (mode.isSelected("Jitter") || jitterOverlay.isValue()));
final SliderSettings jitterRefreshMs = new SliderSettings("Jitter refresh", "Частота обновления джиттера")
.setValue(120.0F)
.range(25, 500)
.step(1.0F)
.visible(() -> isCustomProfile() && (mode.isSelected("Jitter") || jitterOverlay.isValue()));
final BooleanSetting contextAware = new BooleanSetting("Context-aware", "Включает таймер только в safe-state")
.setValue(true)
.visible(this::isCustomProfile);
final MultiSelectSetting safeState = new MultiSelectSetting("Safe-state", "Ограничения для работы context-aware таймера")
.value("На земле", "Без воды", "Без урона", "Не использовать предмет", "Без элитры", "Без GUI", "Без паутины")
.selected("На земле", "Без воды", "Без урона", "Не использовать предмет", "Без элитры", "Без GUI")
.visible(() -> isCustomProfile() && contextAware.isValue());
final BooleanSetting lagbackAware = new BooleanSetting("Lagback-aware", "Сбрасывает таймер после серверного ресинка")
.setValue(true)
.visible(this::isCustomProfile);
final SliderSettings lagbackCooldownMs = new SliderSettings("Lagback cooldown", "Время отката к 1.0 после лагбека")
.setValue(1500.0F)
.range(100, 5000)
.step(10.0F)
.visible(() -> isCustomProfile() && lagbackAware.isValue());
final BooleanSetting versionAware = new BooleanSetting("Version-aware", "Подстраивает агрессию по типу anchor-пакетов и серверу")
.setValue(true)
.visible(this::isCustomProfile);
@NonFinal
final Random random = new Random();
@NonFinal
long lastAnchorMs = -1L;
@NonFinal
float anchorIntervalMs = 250.0F;
@NonFinal
long lagbackUntilMs = 0L;
@NonFinal
double bufferedDriftMs = 0.0D;
@NonFinal
boolean spendingBuffer;
@NonFinal
int burstTicksLeft;
@NonFinal
int burstRestLeft;
@NonFinal
long nextJitterUpdateMs;
@NonFinal
float jitterOffset;
@NonFinal
boolean seenCommonPing;
@NonFinal
long timerEnergyMs = TIMER_ENERGY_MAX_MS;
@NonFinal
long lastEnergyUpdateMs;
@NonFinal
String lastProfile = PROFILE_CUSTOM;
@NonFinal
CustomSnapshot customSnapshot = new CustomSnapshot();
public static Timer getInstance() {
return Instance.get(Timer.class);
}
public Timer() {
super("Timer", ModuleCategory.MOVEMENT);
setup(
profile,
mode,
speed,
idleSpeed,
anchorWindowMs,
bufferChargeSpeed,
bufferSpendSpeed,
bufferLimitMs,
burstSpeed,
burstTicks,
burstRestTicks,
jitterOverlay,
jitterAmount,
jitterRefreshMs,
contextAware,
safeState,
lagbackAware,
lagbackCooldownMs,
versionAware
);
}
@Override
public void activate() {
resetRuntimeState(false);
ClientTimerController.ensureInstalled();
ClientTimerController.setSpeed(1.0F);
super.activate();
}
@Override
public void deactivate() {
ClientTimerController.uninstall();
resetRuntimeState(false);
super.deactivate();
}
@EventHandler
public void onTick(TickEvent event) {
long now = System.currentTimeMillis();
syncProfile();
updateTimerEnergy(now);
if (mc.player == null || mc.world == null) {
ClientTimerController.setSpeed(1.0F);
return;
}
ClientTimerController.ensureInstalled();
ClientTimerController.setSpeed(resolveTimerSpeed(now));
}
@EventHandler
public void onPacket(PacketEvent event) {
if (event.getType() != PacketEvent.Type.RECEIVE) {
return;
}
long now = System.currentTimeMillis();
switch (event.getPacket()) {
case GameJoinS2CPacket ignored -> resetRuntimeState(true);
case CommonPingS2CPacket ignored -> registerAnchor(now, true);
case KeepAliveS2CPacket ignored -> registerAnchor(now, false);
case PlayerPositionLookS2CPacket ignored -> handleLagback(now);
default -> {
}
}
}
private float resolveTimerSpeed(long now) {
if (timerEnergyMs <= 0L) {
coolDownPatterns();
return 1.0F;
}
if (!MoveUtil.isMoving()) {
coolDownPatterns();
return 1.0F;
}
if (isLagbackAware() && now < lagbackUntilMs) {
coolDownPatterns();
return 1.0F;
}
if (isContextAware() && !isSafeToAccelerate()) {
coolDownPatterns();
return 1.0F;
}
String resolvedMode = getEffectiveMode();
float resolved = switch (resolvedMode) {
case "Anchor-aware" -> resolveAnchorAware(now);
case "Buffer" -> resolveBuffer();
case "Burst" -> resolveBurst();
case "Jitter" -> resolveJitter(getEffectiveSpeed(), now);
default -> 1.0F;
};
if (!"Jitter".equals(resolvedMode) && isJitterOverlay()) {
resolved = resolveJitter(resolved, now);
}
if (isVersionAware()) {
resolved = applyVersionAware(resolved);
}
return MathHelper.clamp(resolved, 0.05F, 3.0F);
}
private float resolveAnchorAware(long now) {
float activeSpeed = getEffectiveSpeed();
float passiveSpeed = getEffectiveIdleSpeed();
if (lastAnchorMs < 0L) {
return passiveSpeed;
}
long elapsed = now - lastAnchorMs;
boolean inPostWindow = elapsed <= getEffectiveAnchorWindowMs();
boolean inPreWindow = false;
if (anchorIntervalMs > 0.0F && elapsed < anchorIntervalMs) {
float untilNextAnchor = anchorIntervalMs - elapsed;
inPreWindow = untilNextAnchor <= getEffectiveAnchorWindowMs() * 0.35F;
}
return inPostWindow || inPreWindow ? activeSpeed : passiveSpeed;
}
private float resolveBuffer() {
float charge = Math.min(1.0F, bufferChargeSpeed.getValue());
float spend = Math.max(1.0F, bufferSpendSpeed.getValue());
double limit = Math.max(1.0F, bufferLimitMs.getValue());
if (spendingBuffer) {
bufferedDriftMs = Math.max(0.0D, bufferedDriftMs - Math.max(0.0F, spend - 1.0F) * 50.0D);
if (bufferedDriftMs <= 0.5D) {
bufferedDriftMs = 0.0D;
spendingBuffer = false;
}
return spend;
}
bufferedDriftMs = Math.min(limit, bufferedDriftMs + Math.max(0.0F, 1.0F - charge) * 50.0D);
if (bufferedDriftMs >= limit - 0.5D) {
spendingBuffer = true;
}
return charge;
}
private float resolveBurst() {
if (burstTicksLeft > 0) {
burstTicksLeft--;
if (burstTicksLeft == 0) {
burstRestLeft = Math.max(0, burstRestTicks.getInt());
}
return burstSpeed.getValue();
}
if (burstRestLeft > 0) {
burstRestLeft--;
return 1.0F;
}
burstTicksLeft = Math.max(1, burstTicks.getInt());
return resolveBurst();
}
private float resolveJitter(float baseSpeed, long now) {
if (now >= nextJitterUpdateMs) {
float amplitude = getEffectiveJitterAmount();
float gaussian = (float) (random.nextGaussian() * amplitude * 0.5F);
jitterOffset = MathHelper.clamp(gaussian, -amplitude, amplitude);
nextJitterUpdateMs = now + Math.max(25L, getEffectiveJitterRefreshMs());
}
return Math.max(0.05F, baseSpeed + jitterOffset);
}
private float applyVersionAware(float value) {
if (value <= 1.0F) {
return value;
}
float cap = seenCommonPing ? 1.15F : 1.22F;
if (Network.isReallyWorld() || Network.isHolyWorld() || Network.isCopyTime()) {
cap = Math.min(cap, seenCommonPing ? 1.12F : 1.16F);
}
return Math.min(value, cap);
}
private boolean isSafeToAccelerate() {
if (mc.player == null || mc.world == null) {
return false;
}
if (safeState.isSelected("На земле") && !mc.player.isOnGround()) {
return false;
}
if (safeState.isSelected("Без воды") && (mc.player.isTouchingWater() || mc.player.isSubmergedInWater() || mc.player.isInLava())) {
return false;
}
if (safeState.isSelected("Без урона") && mc.player.hurtTime > 0) {
return false;
}
if (safeState.isSelected("Не использовать предмет") && mc.player.isUsingItem()) {
return false;
}
if (safeState.isSelected("Без элитры") && mc.player.isGliding()) {
return false;
}
if (safeState.isSelected("Без GUI") && mc.currentScreen != null) {
return false;
}
if (safeState.isSelected("Без паутины") && PlayerInteractionHelper.isPlayerInBlock(Blocks.COBWEB)) {
return false;
}
return true;
}
private void registerAnchor(long now, boolean commonPing) {
if (lastAnchorMs > 0L) {
long sample = now - lastAnchorMs;
if (sample > 0L && sample < 5_000L) {
anchorIntervalMs = MathHelper.clamp(anchorIntervalMs * 0.75F + sample * 0.25F, 40.0F, 1_000.0F);
}
}
lastAnchorMs = now;
seenCommonPing |= commonPing;
}
private void handleLagback(long now) {
if (!isLagbackAware()) {
return;
}
lagbackUntilMs = Math.max(lagbackUntilMs, now + getEffectiveLagbackCooldownMs());
coolDownPatterns();
}
private void coolDownPatterns() {
spendingBuffer = false;
bufferedDriftMs = 0.0D;
burstTicksLeft = 0;
burstRestLeft = Math.max(0, burstRestTicks.getInt());
}
private void resetRuntimeState(boolean resetEnergy) {
lastAnchorMs = -1L;
anchorIntervalMs = 250.0F;
lagbackUntilMs = 0L;
bufferedDriftMs = 0.0D;
spendingBuffer = false;
burstTicksLeft = 0;
burstRestLeft = Math.max(0, burstRestTicks.getInt());
nextJitterUpdateMs = 0L;
jitterOffset = 0.0F;
seenCommonPing = false;
if (resetEnergy) {
timerEnergyMs = TIMER_ENERGY_MAX_MS;
} else {
timerEnergyMs = Math.max(0L, Math.min(timerEnergyMs, TIMER_ENERGY_MAX_MS));
}
lastEnergyUpdateMs = 0L;
lastProfile = profile.getSelected();
}
public float getTimerChargePercent() {
return MathHelper.clamp(timerEnergyMs / (float) TIMER_ENERGY_MAX_MS, 0.0F, 1.0F);
}
private boolean isCustomProfile() {
return profile.isSelected(PROFILE_CUSTOM);
}
private String getEffectiveMode() {
return profile.isSelected(PROFILE_RILIWORLD) ? "Anchor-aware" : mode.getSelected();
}
private float getEffectiveSpeed() {
return profile.isSelected(PROFILE_RILIWORLD) ? 1.35F : speed.getValue();
}
private float getEffectiveIdleSpeed() {
return profile.isSelected(PROFILE_RILIWORLD) ? 1.14F : idleSpeed.getValue();
}
private int getEffectiveAnchorWindowMs() {
return profile.isSelected(PROFILE_RILIWORLD) ? 106 : anchorWindowMs.getInt();
}
private boolean isJitterOverlay() {
return profile.isSelected(PROFILE_RILIWORLD) || jitterOverlay.isValue();
}
private float getEffectiveJitterAmount() {
return profile.isSelected(PROFILE_RILIWORLD) ? 0.16F : jitterAmount.getValue();
}
private int getEffectiveJitterRefreshMs() {
return profile.isSelected(PROFILE_RILIWORLD) ? 165 : jitterRefreshMs.getInt();
}
private boolean isContextAware() {
return profile.isSelected(PROFILE_RILIWORLD) ? false : contextAware.isValue();
}
private boolean isLagbackAware() {
return profile.isSelected(PROFILE_RILIWORLD) ? true : lagbackAware.isValue();
}
private int getEffectiveLagbackCooldownMs() {
return profile.isSelected(PROFILE_RILIWORLD) ? 4999 : lagbackCooldownMs.getInt();
}
private boolean isVersionAware() {
return profile.isSelected(PROFILE_RILIWORLD) || versionAware.isValue();
}
public void updateTimerEnergy(long now) {
if (mc.player == null || mc.world == null) {
timerEnergyMs = TIMER_ENERGY_MAX_MS;
lastEnergyUpdateMs = now;
return;
}
if (lastEnergyUpdateMs <= 0L) {
lastEnergyUpdateMs = now;
return;
}
long elapsed = Math.max(0L, now - lastEnergyUpdateMs);
if (elapsed <= 0L) {
return;
}
boolean moving = MoveUtil.isMoving();
boolean allowDrain = state;
if (allowDrain && moving) {
timerEnergyMs = Math.max(0L, timerEnergyMs - elapsed);
} else if (!moving) {
long recovery = Math.round(elapsed * (double) TIMER_ENERGY_MAX_MS / TIMER_RECOVERY_MS);
timerEnergyMs = Math.min(TIMER_ENERGY_MAX_MS, timerEnergyMs + Math.max(0L, recovery));
}
lastEnergyUpdateMs = now;
}
private void syncProfile() {
String selected = profile.getSelected();
if (!selected.equals(lastProfile)) {
if (PROFILE_RILIWORLD.equals(selected)) {
customSnapshot.capture(this);
} else if (PROFILE_CUSTOM.equals(selected)) {
customSnapshot.restore(this);
}
lastProfile = selected;
}
if (PROFILE_RILIWORLD.equals(selected)) {
applyRiliWorldPreset();
}
}
private void applyRiliWorldPreset() {
mode.setSelected("Anchor-aware");
speed.setValue(1.35F);
idleSpeed.setValue(1.14F);
anchorWindowMs.setValue(106.0F);
jitterOverlay.setValue(true);
jitterAmount.setValue(0.16F);
jitterRefreshMs.setValue(165.0F);
contextAware.setValue(false);
lagbackAware.setValue(true);
lagbackCooldownMs.setValue(4999.0F);
versionAware.setValue(true);
}
private static class CustomSnapshot {
private boolean captured;
private String mode;
private float speed;
private float idleSpeed;
private float anchorWindowMs;
private boolean jitterOverlay;
private float jitterAmount;
private float jitterRefreshMs;
private boolean contextAware;
private boolean lagbackAware;
private float lagbackCooldownMs;
private boolean versionAware;
public void capture(Timer timer) {
captured = true;
mode = timer.mode.getSelected();
speed = timer.speed.getValue();
idleSpeed = timer.idleSpeed.getValue();
anchorWindowMs = timer.anchorWindowMs.getValue();
jitterOverlay = timer.jitterOverlay.isValue();
jitterAmount = timer.jitterAmount.getValue();
jitterRefreshMs = timer.jitterRefreshMs.getValue();
contextAware = timer.contextAware.isValue();
lagbackAware = timer.lagbackAware.isValue();
lagbackCooldownMs = timer.lagbackCooldownMs.getValue();
versionAware = timer.versionAware.isValue();
}
public void restore(Timer timer) {
if (!captured) {
return;
}
timer.mode.setSelected(mode);
timer.speed.setValue(speed);
timer.idleSpeed.setValue(idleSpeed);
timer.anchorWindowMs.setValue(anchorWindowMs);
timer.jitterOverlay.setValue(jitterOverlay);
timer.jitterAmount.setValue(jitterAmount);
timer.jitterRefreshMs.setValue(jitterRefreshMs);
timer.contextAware.setValue(contextAware);
timer.lagbackAware.setValue(lagbackAware);
timer.lagbackCooldownMs.setValue(lagbackCooldownMs);
timer.versionAware.setValue(versionAware);
}
}
}
Последнее редактирование:
