Часть функционала DiscordRPC Rockstar 2.0

usxhsjgd · Суббота в 15:38

Сливаю вам RPC на рокстар спасибки gemini

build.gradle:

plugins {
    id 'fabric-loom' version '1.12.7'
    id 'maven-publish'
}

group = 'moscow.rockstar'
version = '1.0.0'

base {
    archivesName = 'rockstar'
}

repositories {
    maven { url = 'https://maven.fabricmc.net/' }
    mavenCentral()
    maven { url = 'https://jitpack.io' }
}

dependencies {
    minecraft "com.mojang:minecraft:${project.minecraft_version}"
    mappings "net.fabricmc:yarn:${project.minecraft_version}+build.8:v2"

    modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
    modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_api_version}"

    compileOnly "io.github.llamalad7:mixinextras-fabric:${project.mixinextras_version}"
    annotationProcessor "io.github.llamalad7:mixinextras-fabric:${project.mixinextras_version}"

    compileOnly "org.projectlombok:lombok:1.18.32"
    annotationProcessor "org.projectlombok:lombok:1.18.32"

    compileOnly "javax.annotation:javax.annotation-api:1.3.2"

    implementation "com.google.zxing:core:3.5.3"
    implementation "com.google.zxing:javase:3.5.3"
    include "com.google.zxing:core:3.5.3"
    include "com.google.zxing:javase:3.5.3"

    compileOnly "com.google.code.findbugs:jsr305:3.0.2"
    implementation "org.nanohttpd:nanohttpd:2.3.1"
    implementation "ai.catboost:catboost-prediction:1.2.7"

    implementation 'com.github.jagrosh:DiscordIPC:master-SNAPSHOT'
    include 'com.github.jagrosh:DiscordIPC:master-SNAPSHOT'
}

loom {
    accessWidenerPath = file('src/main/resources/rockstar.accesswidener')
}

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
    withSourcesJar()
}

tasks.withType(JavaCompile).configureEach {
    options.encoding = 'UTF-8'
    options.release = 21
}

потом удалите с сурсов папку com src/main/java это его путь

Rockstar.java:

package moscow.rockstar;

import java.awt.image.BufferedImage;
import java.net.URL;
import javax.imageio.ImageIO;
import lombok.Generated;
import moscow.rockstar.framework.shader.GlProgram;
import moscow.rockstar.systems.ai.AIPredict;
import moscow.rockstar.systems.commands.CommandRegistry;
import moscow.rockstar.systems.config.ConfigDropHandler;
import moscow.rockstar.systems.config.ConfigManager;
import moscow.rockstar.systems.discord.DiscordManager;
import moscow.rockstar.systems.event.EventIntegration;
import moscow.rockstar.systems.event.EventManager;
import moscow.rockstar.systems.event.handlers.ServerConnectionHandler;
import moscow.rockstar.systems.file.FileManager;
import moscow.rockstar.systems.friends.FriendManager;
import moscow.rockstar.systems.localization.Localizator;
import moscow.rockstar.systems.modules.ModuleManager;
import moscow.rockstar.systems.modules.constructions.swinganim.SwingManager;
import moscow.rockstar.systems.modules.constructions.swinganim.presets.SwingPresetManager;
import moscow.rockstar.systems.modules.listeners.ModuleTickListener;
import moscow.rockstar.systems.modules.listeners.ModuleWidgetRenderer;
import moscow.rockstar.systems.notifications.NotificationManager;
import moscow.rockstar.systems.poshalko.PoshalkoHandler;
import moscow.rockstar.systems.target.TargetManager;
import moscow.rockstar.systems.theme.ThemeManager;
import moscow.rockstar.systems.waypoints.WayPointsManager;
import moscow.rockstar.ui.hud.Hud;
import moscow.rockstar.ui.menu.MenuScreen;
import moscow.rockstar.utility.game.TitleBarHelper;
import moscow.rockstar.utility.game.WebUtility;
import moscow.rockstar.utility.game.server.TPSHandler;
import moscow.rockstar.utility.interfaces.IMinecraft;
import moscow.rockstar.utility.math.calculator.ChatListener;
import moscow.rockstar.utility.render.DrawUtility;
import moscow.rockstar.utility.rotations.RotationHandler;
import moscow.rockstar.utility.rotations.RotationUpdateListener;
import moscow.rockstar.utility.sounds.MusicTracker;
import net.fabricmc.fabric.api.resource.ResourceManagerHelper;
import net.fabricmc.fabric.api.resource.SimpleSynchronousResourceReloadListener;
import net.minecraft.client.texture.NativeImageBackedTexture;
import net.minecraft.resource.ResourceManager;
import net.minecraft.resource.ResourceType;
import net.minecraft.util.Identifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import ru.kotopushka.compiler.sdk.annotations.Compile;
import ru.kotopushka.compiler.sdk.annotations.CompileBytecode;
import ru.kotopushka.compiler.sdk.annotations.Initialization;

public enum Rockstar implements IMinecraft {
    INSTANCE;

    public static final String NAME = "Rockstar";
    public static final String BUILD_TYPE = "Beta";
    public static final String VERSION = "2.0";
    public static final String MOD_ID = "Rockstar".toLowerCase();
    public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
    private EventManager eventManager;
    private ThemeManager themeManager;
    private ModuleManager moduleManager;
    private CommandRegistry commandManager;
    private FriendManager friendManager;
    private DiscordManager discordManager;
    private RotationHandler rotationHandler;
    private TargetManager targetManager;
    private MusicTracker musicTracker;
    private FileManager fileManager;
    private NotificationManager notificationManager;
    private ConfigManager configManager;
    private SwingManager swingManager;
    private TPSHandler tpsHandler;
    private AIPredict ai;
    private Hud hud;
    private ServerConnectionHandler serverConnectionHandler;
    private PoshalkoHandler poshalkoHandler;
    private WayPointsManager wayPointsManager;
    private SwingPresetManager swingPresetManager;
    private MenuScreen menuScreen;
    private ChatListener chatListener;
    private boolean panic;

    @Compile
    @Initialization
    public void initialize() {
        LOGGER.info("Initializing {}...", "Rockstar");
        this.musicTracker = new MusicTracker();
        this.wayPointsManager = new WayPointsManager();
        this.eventManager = new EventManager();
        this.friendManager = new FriendManager();
        this.themeManager = new ThemeManager();
        this.discordManager = new DiscordManager();
        this.rotationHandler = new RotationHandler(new RotationUpdateListener());
        this.targetManager = new TargetManager();
        this.fileManager = new FileManager();
        this.moduleManager = new ModuleManager(new ModuleTickListener(), new ModuleWidgetRenderer());
        this.hud = new Hud();
        this.tpsHandler = new TPSHandler();
        this.notificationManager = new NotificationManager();
        this.fileManager.registerClientFiles();
        this.moduleManager.registerModules();
        this.moduleManager.enableModules();
        this.configManager = new ConfigManager();
        this.configManager.handle();
        this.commandManager = new CommandRegistry();
        this.commandManager.initCommands();
        this.swingManager = new SwingManager();
        this.swingPresetManager = new SwingPresetManager();
        this.swingPresetManager.handle();
        this.fileManager.loadClientFiles();
        ResourceManagerHelper.get(ResourceType.CLIENT_RESOURCES).registerReloadListener(new SimpleSynchronousResourceReloadListener() {
            public Identifier getFabricId() {
                return Rockstar.id("after_shader_load");
            }

            public void reload(ResourceManager manager) {
                GlProgram.loadAndSetupPrograms();
            }
        });
        DrawUtility.initializeShaders();
        Localizator.loadTranslations();
        this.chatListener = new ChatListener();
        this.serverConnectionHandler = new ServerConnectionHandler();
        this.poshalkoHandler = new PoshalkoHandler();
        String osName = System.getProperty("os.name");
        String pcName = System.getProperty("user.name");
        if (osName.toLowerCase().contains("windows") && !pcName.equals("sheluvparis")) {
            this.discordManager.connect();
        }

        ConfigDropHandler.init();
        TitleBarHelper.setDarkTitleBar();
        new EventIntegration();
        this.createAvatar();
        LOGGER.info("{} initialized", "Rockstar");
    }

    public void shutdown() {
        LOGGER.info("Shutting down...");
        this.fileManager.saveClientFiles();
        if (!this.isPanic()) {
            this.configManager.getAutoSaveConfig().save();
        }

        if (!this.isPanic()) {
            this.swingPresetManager.getAutoSavePreset().save();
        }

        this.discordManager.stop();

        this.setPanic(false);
    }

    public static Rockstar getInstance() {
        return INSTANCE;
    }

    public static Identifier id(String path) {
        return Identifier.of(MOD_ID, path);
    }

    @CompileBytecode
    private void createAvatar() {
        try {
            BufferedImage bufferedImage = ImageIO.read(new URL("https://rockstar.pub/api/avatars/ConeTin.jpg?t=1754613855632"));
            if (bufferedImage == null) {
                return;
            }

            Identifier id = id("temp/avatar");
            mc.getTextureManager().registerTexture(id, new NativeImageBackedTexture(WebUtility.bufferedImageToNativeImage(bufferedImage, true)));
        } catch (Exception var3) {
        }
    }

    @Generated
    public EventManager getEventManager() {
        return this.eventManager;
    }

    @Generated
    public ThemeManager getThemeManager() {
        return this.themeManager;
    }

    @Generated
    public ModuleManager getModuleManager() {
        return this.moduleManager;
    }

    @Generated
    public CommandRegistry getCommandManager() {
        return this.commandManager;
    }

    @Generated
    public FriendManager getFriendManager() {
        return this.friendManager;
    }

    @Generated
    public DiscordManager getDiscordManager() {
        return this.discordManager;
    }

    @Generated
    public RotationHandler getRotationHandler() {
        return this.rotationHandler;
    }

    @Generated
    public TargetManager getTargetManager() {
        return this.targetManager;
    }

    @Generated
    public MusicTracker getMusicTracker() {
        return this.musicTracker;
    }

    @Generated
    public FileManager getFileManager() {
        return this.fileManager;
    }

    @Generated
    public NotificationManager getNotificationManager() {
        return this.notificationManager;
    }

    @Generated
    public ConfigManager getConfigManager() {
        return this.configManager;
    }

    @Generated
    public SwingManager getSwingManager() {
        return this.swingManager;
    }

    @Generated
    public TPSHandler getTpsHandler() {
        return this.tpsHandler;
    }

    @Generated
    public AIPredict getAi() {
        return this.ai;
    }

    @Generated
    public Hud getHud() {
        return this.hud;
    }

    @Generated
    public ServerConnectionHandler getServerConnectionHandler() {
        return this.serverConnectionHandler;
    }

    @Generated
    public PoshalkoHandler getPoshalkoHandler() {
        return this.poshalkoHandler;
    }

    @Generated
    public WayPointsManager getWayPointsManager() {
        return this.wayPointsManager;
    }

    @Generated
    public SwingPresetManager getSwingPresetManager() {
        return this.swingPresetManager;
    }

    @Generated
    public MenuScreen getMenuScreen() {
        return this.menuScreen;
    }

    @Generated
    public ChatListener getChatListener() {
        return this.chatListener;
    }

    @Generated
    public boolean isPanic() {
        return this.panic;
    }

    @Generated
    public void setMenuScreen(MenuScreen menuScreen) {
        this.menuScreen = menuScreen;
    }

    @Generated
    public void setPanic(boolean panic) {
        this.panic = panic;
    }
}

DiscordManager.java:

package moscow.rockstar.systems.discord;

import com.jagrosh.discordipc.IPCClient;
import com.jagrosh.discordipc.IPCListener;
import com.jagrosh.discordipc.entities.RichPresence;
import java.time.OffsetDateTime;
import moscow.rockstar.Rockstar;
import moscow.rockstar.utility.interfaces.IMinecraft;

public class DiscordManager implements IMinecraft {
    private final IPCClient client = new IPCClient(1368178867952422993L);
    private final OffsetDateTime startTimestamp = OffsetDateTime.now();
    private boolean isReady = false;

    public void connect() {
        new Thread(() -> {
            try {
                this.client.setListener(new IPCListener() {
                    public void onReady(IPCClient client) {
                        isReady = true;
                        Rockstar.LOGGER.info("Discord RPC connected!");
                        updatePresence("В главном меню", "Branch: " + Rockstar.BUILD_TYPE);
                    }
                });
                this.client.connect();
            } catch (Exception e) {
                Rockstar.LOGGER.error("Failed to connect Discord RPC", e);
            }
        }, "Discord-RPC-Thread").start();
    }

    public void updatePresence(String details, String state) {
        if (!isReady) {
            return;
        }

        try {
            RichPresence.Builder builder = new RichPresence.Builder()
                    .setDetails(details)
                    .setState(state)
                    .setStartTimestamp(this.startTimestamp)
                    .setLargeImage("animlogo", "t.me/rockclient");

            this.client.sendRichPresence(builder.build());
        } catch (Exception e) {
            Rockstar.LOGGER.error("Failed to update Discord RPC", e);
        }
    }

    public void stop() {
        if (this.client != null && this.isReady) {
            this.client.close();
        }
    }
}

ServerConnectionHandler.java:

package moscow.rockstar.systems.event.handlers;

import moscow.rockstar.Rockstar;
import moscow.rockstar.systems.event.EventListener;
import moscow.rockstar.systems.event.impl.network.ServerConnectionEvent;
import moscow.rockstar.systems.event.impl.player.ClientPlayerTickEvent;
import moscow.rockstar.utility.interfaces.IMinecraft;

public class ServerConnectionHandler implements IMinecraft {
    private boolean messageSent = false;
    private boolean connected;

    private final EventListener<ServerConnectionEvent> onServerConnection = event -> {
        this.connected = true;
        this.messageSent = false;

        if (mc.getCurrentServerEntry() != null) {
            String serverIp = mc.getCurrentServerEntry().address;
            Rockstar.getInstance().getDiscordManager().updatePresence("Играет на: " + serverIp, "UID: 1 | Branch: " + Rockstar.BUILD_TYPE);
        } else {
            Rockstar.getInstance().getDiscordManager().updatePresence("Одиночная игра", "UID: 1 | Branch: " + Rockstar.BUILD_TYPE);
        }
    };

    private final EventListener<ClientPlayerTickEvent> onClientPlayerTick = event -> {
        if (this.connected && !this.messageSent && mc.player != null && mc.player.age > 100 && mc.getCurrentServerEntry() != null) {
            this.messageSent = true;
        }
    };

    public ServerConnectionHandler() {
        Rockstar.getInstance().getEventManager().subscribe(this);
    }
}

удачного использования пастеркам

usxhsjgd · Суббота в 15:11

одобрите уже :pepe11:

pastalend_twink · Суббота в 18:18

ну +- ведь любой через гпт напишет йоу но все равно годно

Часть функционала DiscordRPC Rockstar 2.0

Похожие темы