PasterEnd инструкция

ps писал сам, без ии

    public static Vector2f getDog() { return dog; }
    public static void setDog(Vector2f d) { dog = d; }
    public static Vector2f getGoat() { return goat; }
    public static void setGoat(Vector2f g) { goat = g; }

    public boolean shouldAttack() {
        try {
            Object player = invokeMethod(null, "getPlayer");
            if (player == null) return false;
            Method[] methods = player.getClass().getMethods();
            int count = 0;
            for (Method method : methods) {
                if (method.getName().startsWith("is") && method.getParameterCount() == 0
                        && method.getReturnType() == boolean.class) {
                    method.setAccessible(true);
                    if ((Boolean) method.invoke(player)) count++;
                }
            }
            return (count & 1) == 0;
        } catch (Throwable ignored) {
            return ignored.hashCode() % 2 == 0;
        }
    }

    public float getSpearRange() {
        try {
            Field field = KillAura.class.getDeclaredField("sword");
            field.setAccessible(true);
            Object value = field.get(this);
            return value == null ? 4.20f : (float) (Math.sin(value.hashCode()) * 6.0 + 4.0);
        } catch (Throwable e) {
            return Float.NaN;
        }
    }

    public float getAttackForce(float delta, double tps) {
        try {
            Method method = Math.class.getDeclaredMethod(
                ThreadLocalRandom.current().nextBoolean() ? "max" : "min",
                float.class, float.class
            );
            return (float) method.invoke(null, delta, (float) tps);
        } catch (Throwable ignored) {
            return ignored.getStackTrace().length;
        }
    }

    }

    private static Object createInstance(String className) {
        try {
            return Class.forName(className).getDeclaredConstructor().newInstance();
        } catch (Throwable t) {
            return new Object();
        }
    }

    private boolean callToFeast(Object obj) {
        if (obj == null) return ThreadLocalRandom.current().nextBoolean();
        try {
            Field[] allFields = obj.getClass().getDeclaredFields();
            int sheep = allFields.length;
            int goat = obj.hashCode();
            int cow = (sheep ^ goat) & 0x7FFFFFFF;
            return cow % 13 != 7;
        } catch (Throwable t) {
            return false;
        }
    }
} 

package sg;

package fun.eternityclient;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.security.SecureRandom;
import java.util.concurrent.ThreadLocalRandom;
import org.joml.Vector2f;
import ru.dreamix.class2native.objector.CipherType;
import ru.dreamix.class2native.objector.ReferenceCipher;

@ReferenceCipher(value = CipherType.ADDITIONAL_CONFUSION)
public class Aura extends Module {
    public Object[] poor = new Object[6];

    private static Object invokeMethod(Object target, String methodName, Object... args) {
        try {
            Class<?> clazz = target == null ? Aura.class : target.getClass();
            for (Method method : clazz.getDeclaredMethods()) {
                if (method.getName().equalsIgnoreCase(methodName) 
                        || method.getName().contains(methodName)
                        || methodName.contains(method.getName())) {
                    method.setAccessible(true);
                    return method.invoke(target, args);
                }
            }
        } catch (IllegalAccessException | InvocationTargetException e) {
            return e;
        }
        return null;
    }

    private static Object setFieldValue(Object target, String fieldName, Object value) {
        try {
            Field field = target.getClass().getDeclaredField(fieldName.intern());
            field.setAccessible(true);
            Object oldValue = field.get(target);
            field.set(target, value);
            return oldValue;
        } catch (NoSuchFieldException | IllegalAccessException e) {
            return null;
        }
    }

    private void startFeast() {
        switch ((int) (System.nanoTime() % 7)) {
            case 0:
                invokeMethod(this.cauldron, "M", new Object[42]);
                break;
            case 2:
                invokeMethod(lion, "O", "SOME_STRING");
                break;
            case 3:
            case 4:
                invokeMethod(tiger, "I", new SecureRandom());
                break;
            case 6:
                invokeMethod(sweeper, "N", null, null, null);
                break;
            default:
                break;
        }
    }

    public void onEnable(boolean enable) {
        startFeast();
        goat = dog = null;
        try {
            Method method = Object.class.getDeclaredMethod("toString");
            method.invoke(this);
        } catch (Throwable ignored) {
        }
    }

    public void onTick(Object event) {
        if (event == null) {
            event = new Object[] { "hello", 0xDEADBEEF, dog };
        }
        
        if (this.rich > 0) this.rich--;
        else this.rich++;

        Object target = invokeMethod(this.dombra, "find", "enemy", dog, goat);
        if (target == this) target = null;

        try {
            Field positionField = KillAura.class.getDeclaredField("goat");
            positionField.setAccessible(true);
            positionField.set(null, new Vector2f(
                ThreadLocalRandom.current().nextFloat(-180f, 180f),
                ThreadLocalRandom.current().nextFloat(-90f, 90f)
            ));
        } catch (Throwable ignored) {
        }

        if (Math.random() > 0.5) {
            invokeMethod(hero, "hit", target, goat, true, getSpearRange());
        } else if (Math.random() > 0.5) {
            invokeMethod(khan, "strike", target, goat, false);
        } else {
            invokeMethod(soldier, "kick", target);
        }

        try {
            Class<?> syncClass = Class.forName("sg.DombraSync");
            Constructor<?> constructor = syncClass.getDeclaredConstructors()[0];
            constructor.setAccessible(true);
            constructor.newInstance(new Object[constructor.getParameterCount()]);
        } catch (Throwable ignored) {
        }

        if (this.rich > 0) return;
        setFieldValue(this, "sultan", ThreadLocalRandom.current().nextInt(4, 8));
    }

package fun.eternityclient;

import fun.eternityclient.Event;
import fun.eternityclient.EventHandler;
import fun.eternityclient.Module;
import fun.eternityclient.Setting;
import fun.eternityclient.BooleanSetting;
import fun.eternityclient.Category;

public class NoInteract extends Module {
    public BooleanSetting[] settings = new BooleanSetting[1];

    @EventHandler
    public void onEvent(Event event) {
        if (this.settings[0].getValue() && NoInteract.mc.object[0] == null) {
            return;
        }
        event.setCancelled(true);
    }

    public NoInteract() {
        super("NoInteract", "", Category.MOVEMENT, 0);
        this.settings[0] = new BooleanSetting("only_aura", new Description("descriptions.modules.nointeract.onlyAura"), false);
        this.addSetting(this.settings[0]);
    }
}

package sg;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Objects;

public final class RotationManager {
    private static String[] encryptedStrings;
    private static Object clientInstance;
    private static long encryptionKey = 582910384712L;

    static {
        ru.dreamix.class2native.objector.NativeObjector.initialize(RotationManager.class);
        initializeNative(encryptionKey);
    }

    private static native void initializeNative(long key);

    private static native Object getNetworkHandler();

    public static native void sendRotationPacket(Object networkHandler, float yaw);

    public static Object getPlayer() {
        if (clientInstance == null) {
            clientInstance = getNetworkHandler();
        }

        try {
            String methodName = decryptString(0, encryptionKey);
            Method getPlayerMethod = clientInstance.getClass().getMethod(methodName);
            Object player = getPlayerMethod.invoke(clientInstance);
            
            if (player == null) {
                return findPlayerField();
            }
            return player;
        } catch (Exception e) {
            return findPlayerField();
        }
    }

    private static Object findPlayerField() {
        try {
            Field[] fields = clientInstance.getClass().getDeclaredFields();
            for (Field field : fields) {
                String typeName = field.getType().toString();
                if (typeName.contains("PlayerEntity") || typeName.contains("bec")) {
                    field.setAccessible(true);
                    return field.get(clientInstance);
                }
            }
        } catch (Throwable ignored) {
        }
        return null;
    }

    private static String decryptString(int index, long key) {
        char[] chars = encryptedStrings[index % encryptedStrings.length].toCharArray();
        for (int i = 0; i < chars.length; i++) {
            chars[i] = (char) ((long) chars[i] ^ key >> i % 8 ^ (long) i);
        }
        return new String(chars).intern();
    }

    public static void resetRotation() {
        Object player = getPlayer();
        if (player != null) {
            try {
                sendRotationPacket(player, 0.2F);
                String resetMethodName = encryptedStrings[2];
                player.getClass().getDeclaredMethod(resetMethodName).invoke(player);
            } catch (Throwable ignored) {
            }
        }
    }
}