Часть функционала AutoAuth Expensive 3.1

[Neizvesnost_]

Выберите загрузчик игры

1. Vanilla
2. OptiFine

Нормальный AutoAuth, который сохраняет пароль не в основной конфиг, а в отдельный файл

SS: зачем

package expensive.modules.impl.misc;

import com.google.common.eventbus.Subscribe;

import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import expensive.events.EventPacket;
import expensive.events.SettingsChangedEvent;
import expensive.modules.api.Category;
import expensive.modules.api.Function;
import expensive.modules.api.FunctionRegister;
import expensive.modules.api.impl.StringSetting;
import lombok.Getter;
import net.minecraft.network.IPacket;
import net.minecraft.network.play.server.SChatPacket;

import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

@FunctionRegister(name = "AutoAuth", type = Category.Misc)
public class AutoAuth extends Function {

    @Getter
    private final StringSetting password = new StringSetting("Пароль", generateRandomPassword(), "");

    private long lastTime = 0;
    File configFile = new File(mc.gameDir, "\\expensive\\configs\\config.auth");

    public AutoAuth() {
        addSettings(password);
    }

    @Subscribe
    public void onSettingsChanged(SettingsChangedEvent event) {
        if (event.getSetting() == password) {
            savePassword();
        }
    }

    @Subscribe
    public void onPacket(EventPacket event) {
        if (event.isSend()) return;

        IPacket<?> packet = event.getPacket();
        if (packet instanceof SChatPacket chatPacket) {
            String message = chatPacket.getChatComponent().getString();
            if (message == null || message.isEmpty()) return;

            String pass = password.get();
            Map<String, String> commands = new HashMap<>();
            commands.put("/login", String.format("/login %s", pass));
            commands.put("/l", String.format("/l %s", pass));
            commands.put("/register", String.format("/register %s %s", pass, pass));
            commands.put("/reg", String.format("/reg %s %s", pass, pass));

            if (System.currentTimeMillis() - lastTime >= 100) {
                String[] split = message.split(" ");
                StringBuilder commandBuilder = new StringBuilder();

                for (String part : split) {
                    String lowerPart = part.toLowerCase();
                    if (commands.containsKey(lowerPart)) {
                        commandBuilder.append(commands.get(lowerPart));
                        lastTime = System.currentTimeMillis();
                        break;
                    }
                }

                if (!commandBuilder.isEmpty()) {
                    mc.player.sendChatMessage(commandBuilder.toString().trim());
                }
            }
        }
    }

    @Override
    public void onEnable() {
        super.onEnable();
        lastTime = System.currentTimeMillis();
        loadPassword();
    }

    @Override
    public void onDisable() {
        super.onDisable();
        lastTime = 0;
    }

    private String generateRandomPassword() {
        String characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
        Random random = new Random();
        StringBuilder sb = new StringBuilder(10);
        for (int i = 0; i < 10; i++) {
            sb.append(characters.charAt(random.nextInt(characters.length())));
        }
        return sb.toString();
    }

    public void loadPassword() {
        if (!configFile.exists()) return;

        String filePassword = null;
        try (FileReader reader = new FileReader(configFile, StandardCharsets.UTF_8)) {
            JsonObject jsonObject = new JsonParser().parse(reader).getAsJsonObject();
            if (jsonObject.has("password")) {
                filePassword = jsonObject.get("password").getAsString();
            }
        } catch (Exception e) {

            return;
        }

        String currentPassword = password.get();
        if (filePassword != null && !filePassword.equals(currentPassword) &&
                !currentPassword.equals(password.getDefault()) && !currentPassword.isEmpty()) {
            savePassword();
        } else if (filePassword != null && (currentPassword.equals(password.getDefault()) || currentPassword.isEmpty())) {
            password.set(filePassword);
        }
    }

    public void savePassword() {
        JsonObject jsonObject = new JsonObject();
        jsonObject.addProperty("password", password.get());
        String content = new GsonBuilder().setPrettyPrinting().create().toJson(jsonObject);
        try (FileWriter writer = new FileWriter(configFile, StandardCharsets.UTF_8)) {
            writer.write(content);
        } catch (Exception e) {
        }
    }
}

package expensive.events;

import expensive.modules.api.Setting;
import lombok.AllArgsConstructor;
import lombok.Data;

@Data
@AllArgsConstructor
public class SettingsChangedEvent {
    private final Setting<?> setting;
    private final Object oldValue;
    private final Object newValue;
}

package expensive.modules.api;

import expensive.events.SettingsChangedEvent;
import expensive.main.Expensive;

import java.util.function.Supplier;

public class Setting<Value> implements ISetting {

    Value defaultVal;
    protected Value value;
    String settingName;
    public Supplier<Boolean> visible = () -> true;

    public Setting(String name, Value defaultVal) {
        this.settingName = name;
        this.defaultVal = defaultVal;
        this.value = defaultVal;
    }


    public String getName() {
        return settingName;
    }

    public void set(Value value) {
        if (value != null && !value.equals(this.value)) {
            Value oldValue = this.value;
            this.value = value;
            Expensive.getInstance().getEventBus().post(new SettingsChangedEvent(this, oldValue, value));
        }
    }

    @Override
    public Setting<?> setVisible(Supplier<Boolean> bool) {
        visible = bool;
        return this;
    }

    public Value getDefault() {
        return defaultVal;
    }

    public Value get() {
        return value;
    }

}

package expensive.main.config;

import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import expensive.display.styles.Style;
import expensive.main.Expensive;
import expensive.modules.api.Setting;
import expensive.modules.api.impl.*;
import expensive.util.client.main.IMinecraft;
import lombok.Getter;
import net.minecraft.client.Minecraft;

import java.io.File;
import java.util.Map;
import java.util.function.Consumer;

@Getter
public class Config implements IMinecraft {
    private final File file;
    private final String name;

    public Config(String name) {
        this.name = name;
        this.file = new File(new File(Minecraft.getInstance().gameDir, "\\expensive\\configs"), name + ".exp");
    }

    public void loadConfig(JsonObject jsonObject) {
        if (jsonObject == null) {
            return;
        }

        if (jsonObject.has("functions")) {
            loadFunctionSettings(jsonObject.getAsJsonObject("functions"));
        }

        if (jsonObject.has("styles")) {
            loadStyleSettings(jsonObject.getAsJsonObject("styles"));
        }
    }
    private void loadStyleSettings(JsonObject stylesObject) {
        for (Map.Entry<String, JsonElement> entry : stylesObject.entrySet()) {
            String styleName = entry.getKey();
            JsonObject styleObject = entry.getValue().getAsJsonObject();
            Style style = findStyleByName(styleName);
            if (style != null && styleObject.has("selected")) {
                boolean isSelected = styleObject.get("selected").getAsBoolean();
                if (isSelected) {
                    Expensive.getInstance().getStyleManager().setCurrentStyle(style);
                }
            }
        }
    }

    private Style findStyleByName(String styleName) {
        for (Style style : Expensive.getInstance().getStyleManager().getStyleList()) {
            if (style.getStyleName().equalsIgnoreCase(styleName)) {
                return style;
            }
        }
        return null;
    }
    private void loadFunctionSettings(JsonObject functionsObject) {
        Expensive.getInstance().getFunctionRegistry().getFunctions().forEach(f -> {
            JsonObject moduleObject = functionsObject.getAsJsonObject(f.getName().toLowerCase());
            if (moduleObject == null) {
                return;
            }

            f.setState(false,true);
            loadSettingFromJson(moduleObject, "bind", value -> f.setBind(value.getAsInt()));
            loadSettingFromJson(moduleObject, "state", value -> f.setState(value.getAsBoolean(),true));
            f.getSettings().forEach(setting -> {
                if (f.getName().equals("AutoAuth") && setting.getName().equals("Пароль")) {
                    return;
                }
                loadIndividualSetting(moduleObject, setting);
            });
        });
    }

    private void loadIndividualSetting(JsonObject moduleObject, Setting<?> setting) {
        JsonElement settingElement = moduleObject.get(setting.getName());

        if (settingElement == null || settingElement.isJsonNull()) {
            return;
        }

        if (setting instanceof SliderSetting) {
            ((SliderSetting) setting).set(settingElement.getAsFloat());
        } if (setting instanceof BooleanSetting) {
            ((BooleanSetting) setting).set(settingElement.getAsBoolean());
        } if (setting instanceof ColorSetting) {
            ((ColorSetting) setting).set(settingElement.getAsInt());
        } if (setting instanceof ModeSetting) {
            ((ModeSetting) setting).set(settingElement.getAsString());
        } if (setting instanceof BindSetting) {
            ((BindSetting) setting).set(settingElement.getAsInt());
        } if (setting instanceof StringSetting) {
            ((StringSetting) setting).set(settingElement.getAsString());
        } if (setting instanceof ModeListSetting) {
            loadModeListSetting((ModeListSetting) setting, moduleObject);

        }
    }

    private void loadModeListSetting(ModeListSetting setting, JsonObject moduleObject) {
        JsonObject elements = moduleObject.getAsJsonObject(setting.getName());
        setting.get().forEach(option -> {
            JsonElement optionElement = elements.get(option.getName());
            if (optionElement != null && !optionElement.isJsonNull()) {

                option.set(optionElement.getAsBoolean());
            }
        });
    }

    private void loadSettingFromJson(JsonObject jsonObject, String key, Consumer<JsonElement> consumer) {
        JsonElement element = jsonObject.get(key);
        if (element != null && !element.isJsonNull()) {
            consumer.accept(element);
        }
    }



    public JsonElement saveConfig() {
        JsonObject functionsObject = new JsonObject();
        JsonObject stylesObject = new JsonObject();

        saveFunctionSettings(functionsObject);
        saveStyleSettings(stylesObject);

        JsonObject newObject = new JsonObject();
        newObject.add("functions", functionsObject);
        newObject.add("styles", stylesObject);

        return newObject;
    }

    private void saveFunctionSettings(JsonObject functionsObject) {
        Expensive.getInstance().getFunctionRegistry().getFunctions().forEach(module -> {
            JsonObject moduleObject = new JsonObject();

            moduleObject.addProperty("bind", module.getBind());
            moduleObject.addProperty("state", module.isState());

            module.getSettings().forEach(setting -> {
                if (module.getName().equals("AutoAuth") && setting.getName().equals("Пароль")) {
                    return;
                }
                saveIndividualSetting(moduleObject, setting);
            });
            functionsObject.add(module.getName().toLowerCase(), moduleObject);
        });
    }

    private void saveIndividualSetting(JsonObject moduleObject, Setting<?> setting) {
        if (setting instanceof BooleanSetting) {
            moduleObject.addProperty(setting.getName(), ((BooleanSetting) setting).get());
        } if (setting instanceof SliderSetting) {
            moduleObject.addProperty(setting.getName(), ((SliderSetting) setting).get());
        } if (setting instanceof ModeSetting) {
            moduleObject.addProperty(setting.getName(), ((ModeSetting) setting).get());
        } if (setting instanceof ColorSetting) {
            moduleObject.addProperty(setting.getName(), ((ColorSetting) setting).get());
        } if (setting instanceof BindSetting) {
            moduleObject.addProperty(setting.getName(), ((BindSetting) setting).get());
        } if (setting instanceof StringSetting) {
            moduleObject.addProperty(setting.getName(), ((StringSetting) setting).get());
        } if (setting instanceof ModeListSetting) {
            saveModeListSetting(moduleObject, (ModeListSetting) setting);

        }
    }

    private void saveModeListSetting(JsonObject moduleObject, ModeListSetting setting) {
        JsonObject elements = new JsonObject();
        setting.get().forEach(option -> elements.addProperty(option.getName(), option.get()));
        moduleObject.add(setting.getName(), elements);
    }

    private void saveStyleSettings(JsonObject stylesObject) {
        for (Style style : Expensive.getInstance().getStyleManager().getStyleList()) {
            JsonObject styleObject = new JsonObject();
            styleObject.addProperty("selected", Expensive.getInstance().getStyleManager().getCurrentStyle() == style);
            stylesObject.add(style.getStyleName(), styleObject);
        }
    }
}

package expensive.main.config;

import com.google.gson.GsonBuilder;
import com.google.gson.JsonObject;
import com.google.gson.JsonParser;
import expensive.main.Expensive;
import expensive.modules.impl.misc.AutoAuth;
import net.minecraft.client.Minecraft;

import java.io.*;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

public class ConfigStorage {
    public final Logger logger = Logger.getLogger(ConfigStorage.class.getName());

    public final File CONFIG_DIR = new File(Minecraft.getInstance().gameDir, "\\expensive\\configs");
    public final File AUTOCFG_DIR = new File(CONFIG_DIR, "autocfg.exp");
    public final File AUTOAUTH_CONFIG = new File(CONFIG_DIR, "config.auth");

    public final JsonParser jsonParser = new JsonParser();

    public void init() throws IOException {
        setupFolder();
    }

    public void setupFolder() {
        if (!CONFIG_DIR.exists()) {
            CONFIG_DIR.mkdirs();
        }
        if (!AUTOCFG_DIR.exists()) {
            try {
                AUTOCFG_DIR.createNewFile();
            } catch (IOException e) {
            }
        }
        loadConfiguration("autocfg");
        loadAutoAuthPassword();
    }

    public boolean isEmpty() {
        return getConfigs().isEmpty();
    }

    public List<Config> getConfigs() {
        List<Config> configs = new ArrayList<>();
        File[] configFiles = CONFIG_DIR.listFiles();

        if (configFiles != null) {
            for (File configFile : configFiles) {
                if (configFile.isFile() && configFile.getName().endsWith(".exp") && !configFile.getName().equals("config.auth")) {
                    String configName = configFile.getName().replace(".exp", "");
                    Config config = findConfig(configName);
                    if (config != null) {
                        configs.add(config);
                    }
                }
            }
        }

        return configs;
    }

    public void loadConfiguration(String configuration) {
        Config config = findConfig(configuration);
        if (config == null)
            return;

        try (FileReader reader = new FileReader(config.getFile(), StandardCharsets.UTF_8)) {
            JsonObject object = jsonParser.parse(reader).getAsJsonObject();
            config.loadConfig(object);
        } catch (Exception e) {
        }
        loadAutoAuthPassword();
    }

    public void saveConfiguration(String configuration) {
        Config config = new Config(configuration);
        String contentPrettyPrint = new GsonBuilder().setPrettyPrinting().create().toJson(config.saveConfig());
        try (FileWriter writer = new FileWriter(config.getFile(), StandardCharsets.UTF_8)) {
            writer.write(contentPrettyPrint);
        } catch (Exception e) {
        }
    }

    public Config findConfig(String configName) {
        if (configName == null) return null;
        File configFile = new File(CONFIG_DIR, configName + ".exp");
        if (configFile.exists())
            return new Config(configName);

        return null;
    }

    private void loadAutoAuthPassword() {
        AutoAuth autoAuth = Expensive.getInstance().getFunctionRegistry().getAutoAuth();
        if (!AUTOAUTH_CONFIG.exists())
            autoAuth.savePassword();

        autoAuth.loadPassword();
    }
}

 

[hexadev]

autoauth каждый второй школьник написать может