Craftrise Flagsız TP - FLY Source Çekilişi

/*
 * Fly (Fly) Modul - Stashy Source
 * Anti-ban fly with blink packet queue system
 *
 * Bagimliliklar: Module, Category, Event, PacketSendEvent,
 *                BooleanOption, NumberOption, StringOption,
 *                MappingUtils, MinecraftMapper, org.lwjgl.input.Keyboard
 */

package me.stashy.module.impl;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import me.stashy.event.Event;
import me.stashy.event.PacketSendEvent;
import me.stashy.mapping.MinecraftMapper;
import me.stashy.module.Category;
import me.stashy.module.Module;
import me.stashy.setting.BooleanOption;
import me.stashy.setting.NumberOption;
import me.stashy.setting.StringOption;
import me.stashy.util.MappingUtils;
import org.lwjgl.input.Keyboard;

public class BlinkFlyModule
extends Module {
    private final NumberOption speed = new NumberOption("Speed", 0.3, 0.1, 3.0, 0.05, this);
    private final NumberOption maxPackets = new NumberOption("Max Packets", 20.0, 5.0, 200.0, 5.0, this);
    private final NumberOption flushDelay = new NumberOption("Flush Delay", 5.0, 1.0, 20.0, 1.0, this);
    private final StringOption endMode = new StringOption("End Mode", "Return", this, "Return", "SmartFlush", "InstantFlush");
    private final BooleanOption groundSpoof = new BooleanOption("Ground Spoof", true, (Module)this);
    private final BooleanOption noFall = new BooleanOption("No Fall", true, (Module)this);
    private final BooleanOption jitter = new BooleanOption("Jitter", true, (Module)this);
    private final List<Object> queuedPackets = new ArrayList<Object>();
    private boolean isFlushing = false;
    private double startX;
    private double startY;
    private double startZ;
    private int flushTick = 0;
    private int flushIndex = 0;
    private List<Object> flushBuffer = null;
    private int groundSpoofCounter = 0;
    private static final int GROUND_SPOOF_INTERVAL = 20;
    private long jitterSeed = System.nanoTime();

    public BlinkFlyModule() {
        super("FlyTp", "Fly with blink (anti-ban)", Category.MOVEMENT, 33);
        this.addOptions(this.speed, this.maxPackets, this.flushDelay, this.endMode, this.groundSpoof, this.noFall, this.jitter);
    }

    @Override
    public void onEnable() {
        this.queuedPackets.clear();
        this.isFlushing = false;
        this.flushBuffer = null;
        this.flushIndex = 0;
        this.flushTick = 0;
        this.groundSpoofCounter = 0;
        try {
            this.startX = MinecraftMapper.getPosX();
            this.startY = MinecraftMapper.getPosY();
            this.startZ = MinecraftMapper.getPosZ();
        }
        catch (Throwable throwable) {
        }
    }

    @Override
    public void onDisable() {
        String string = (String)this.endMode.getValue();
        if ("Return".equals(string) || "SmartFlush".equals(string) && this.queuedPackets.size() > 40) {
            this.returnToStart();
            this.queuedPackets.clear();
        } else if ("InstantFlush".equals(string)) {
            this.instantFlush();
        } else {
            this.flushBuffer = new ArrayList<Object>(this.queuedPackets);
            this.queuedPackets.clear();
            this.flushIndex = 0;
            this.flushTick = 0;
            this.isFlushing = true;
        }
    }

    @Override
    public void onUpdate() {
        if (this.isFlushing && this.flushBuffer != null) {
            this.tickSmartFlush();
            return;
        }
        if (!this.isEnabled()) {
            return;
        }
        Object object = this.getThePlayer();
        if (object == null) {
            return;
        }
        try {
            double d;
            float f = MinecraftMapper.getRotationYaw();
            float f2 = MinecraftMapper.getRotationPitch();
            float f3 = f * ((float)Math.PI / 180);
            double d2 = (Double)this.speed.getValue();
            double d3 = 0.0;
            double d4 = 0.0;
            double d5 = 0.0;
            if (Keyboard.isKeyDown((int)17)) {
                d3 += -Math.sin(f3) * d2;
                d5 += Math.cos(f3) * d2;
            }
            if (Keyboard.isKeyDown((int)31)) {
                d3 += Math.sin(f3) * d2;
                d5 -= Math.cos(f3) * d2;
            }
            if (Keyboard.isKeyDown((int)30)) {
                d = (double)f3 - 1.5707963267948966;
                d3 += -Math.sin(d) * d2;
                d5 += Math.cos(d) * d2;
            }
            if (Keyboard.isKeyDown((int)32)) {
                d = (double)f3 + 1.5707963267948966;
                d3 += -Math.sin(d) * d2;
                d5 += Math.cos(d) * d2;
            }
            if (Keyboard.isKeyDown((int)57)) {
                d4 += d2 * 0.45;
            }
            if (Keyboard.isKeyDown((int)42)) {
                d4 -= d2 * 0.45;
            }
            if (((Boolean)this.jitter.getValue()).booleanValue() && (d3 != 0.0 || d5 != 0.0)) {
                this.jitterSeed = this.jitterSeed * 1103515245L + 12345L;
                d = ((double)(this.jitterSeed & 0x7FFFL) / 32767.0 - 0.5) * 0.012;
                d3 += d;
                d5 += d;
            }
            MinecraftMapper.setMotionX(d3);
            MinecraftMapper.setMotionY(d4);
            MinecraftMapper.setMotionZ(d5);
            if (((Boolean)this.groundSpoof.getValue()).booleanValue()) {
                ++this.groundSpoofCounter;
                if (this.groundSpoofCounter >= 20) {
                    MinecraftMapper.setOnGround(true);
                    this.groundSpoofCounter = 0;
                } else {
                    MinecraftMapper.setOnGround(false);
                }
            } else {
                MinecraftMapper.setOnGround(false);
            }
            if (this.queuedPackets.size() >= ((Double)this.maxPackets.getValue()).intValue()) {
                this.returnToStart();
                this.queuedPackets.clear();
                this.startX = MinecraftMapper.getPosX();
                this.startY = MinecraftMapper.getPosY();
                this.startZ = MinecraftMapper.getPosZ();
            }
        }
        catch (Throwable throwable) {
        }
    }

    public void onEvent(Event event) {
        if (!this.isEnabled() || this.isFlushing) {
            return;
        }
        if (!(event instanceof PacketSendEvent)) {
            return;
        }
        PacketSendEvent packetSendEvent = (PacketSendEvent)event;
        Object object = packetSendEvent.getPacket();
        if (object == null) {
            return;
        }
        Class<?> clazz = MappingUtils.get("C03PacketPlayer");
        if (clazz != null && clazz.isInstance(object)) {
            if (((Boolean)this.noFall.getValue()).booleanValue()) {
                this.patchOnGround(object, true);
            }
            this.queuedPackets.add(object);
            packetSendEvent.cancel();
        }
    }

    private void tickSmartFlush() {
        if (this.flushBuffer == null || this.flushIndex >= this.flushBuffer.size()) {
            this.isFlushing = false;
            this.flushBuffer = null;
            this.flushIndex = 0;
            return;
        }
        ++this.flushTick;
        int n = ((Double)this.flushDelay.getValue()).intValue();
        if (this.flushTick < n) {
            return;
        }
        this.flushTick = 0;
        int n2 = 3;
        Object object = this.getNetHandler();
        Method method = MappingUtils.getMethod("NetHandlerPlayClient.sendPacket");
        if (object == null || method == null) {
            this.isFlushing = false;
            this.flushBuffer = null;
            return;
        }
        method.setAccessible(true);
        int n3 = Math.min(this.flushIndex + n2, this.flushBuffer.size());
        for (int i = this.flushIndex; i < n3; ++i) {
            try {
                method.invoke(object, this.flushBuffer.get(i));
                continue;
            }
            catch (Throwable throwable) {
            }
        }
        this.flushIndex = n3;
    }

    private void instantFlush() {
        if (this.queuedPackets.isEmpty()) {
            return;
        }
        ArrayList<Object> arrayList = new ArrayList<Object>(this.queuedPackets);
        this.queuedPackets.clear();
        Object object = this.getNetHandler();
        Method method = MappingUtils.getMethod("NetHandlerPlayClient.sendPacket");
        if (object == null || method == null) {
            return;
        }
        method.setAccessible(true);
        for (Object e : arrayList) {
            try {
                method.invoke(object, e);
            }
            catch (Throwable throwable) {}
        }
    }

    private void returnToStart() {
        try {
            Object object = this.getThePlayer();
            if (object == null) {
                return;
            }
            Method method = MappingUtils.getMethod("Entity.setPosition");
            if (method != null) {
                method.setAccessible(true);
                method.invoke(object, this.startX, this.startY, this.startZ);
            } else {
                Field field = MappingUtils.getField("Entity.posX");
                Field field2 = MappingUtils.getField("Entity.posY");
                Field field3 = MappingUtils.getField("Entity.posZ");
                if (field != null) {
                    field.setAccessible(true);
                    field.setDouble(object, this.startX);
                }
                if (field2 != null) {
                    field2.setAccessible(true);
                    field2.setDouble(object, this.startY);
                }
                if (field3 != null) {
                    field3.setAccessible(true);
                    field3.setDouble(object, this.startZ);
                }
            }
            MinecraftMapper.setOnGround(true);
        }
        catch (Throwable throwable) {
        }
    }

    private void patchOnGround(Object object, boolean bl) {
        try {
            for (Field field : object.getClass().getSuperclass().getDeclaredFields()) {
                if (field.getType() != Boolean.TYPE) continue;
                field.setAccessible(true);
                field.setBoolean(object, bl);
                break;
            }
        }
        catch (Throwable throwable) {
        }
    }

    private Object getNetHandler() {
        try {
            Object object = this.getThePlayer();
            if (object == null) {
                return null;
            }
            Field field = MappingUtils.getField("EntityPlayerSP.sendQueue");
            if (field != null) {
                field.setAccessible(true);
                return field.get(object);
            }
        }
        catch (Throwable throwable) {
        }
        return null;
    }
}