Oumarle Omar

Tu peux faire un mode qui peut fonctionner avec tous les schématiques même ceux qui sont nB Tous les schématiques ça fonctionne avec tout et genre tu peux les charger et activer une heure commande il faut que tu actives à une option appeler progressif printer où ça va progressivement faire les blocs je construis ton schématique

Kodari AI
KodariNov 9 at 2:53 pm 2
ProgressiveSchematicPrinter
Plugin Minecraft permettant de charger et d'imprimer progressivement des schématiques (y compris les fichiers .nbt) dans le monde. Les joueurs peuvent charger n'importe quel schématique via une commande, puis activer le mode "progressif" qui place les blocs un par un, créant un effet de construction animée en temps réel. Compatible avec tous les formats de schématiques, y compris ceux au format NBT.

Plugin créé avec WorldEdit requis.

Place les fichiers dans plugins/SchematicPrinter/schematics/, puis utilise :

  • /schematic load <fichier> pour charger un schématique.

  • /schematic progressive on ou off pour activer ou désactiver la construction progressive.

  • /schematic paste pour construire à ta position.

  • /schematic stop pour arrêter une construction.

La vitesse se règle avec blocks-per-tick dans config.yml. Les formats reconnus dépendent de la version de WorldEdit installée : la compatibilité avec tous les fichiers NBT ou schématiques n’est pas garantie.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
settings.gradle
Code
5 240
src/main/java/com/kodari/schematicprinter/SchematicPrinter.java
package com.kodari.schematicprinter;

import com.sk89q.worldedit.WorldEdit;
import com.sk89q.worldedit.EditSession;
import com.sk89q.worldedit.bukkit.BukkitAdapter;
import com.sk89q.worldedit.extent.clipboard.Clipboard;
import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormat;
import com.sk89q.worldedit.extent.clipboard.io.ClipboardFormats;
import com.sk89q.worldedit.extent.clipboard.io.ClipboardReader;
import com.sk89q.worldedit.math.BlockVector3;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitTask;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;

public class SchematicPrinter extends JavaPlugin {
    private final Map<UUID, Clipboard> clipboards = new HashMap<>();
    private final Map<UUID, PrintJob> jobs = new HashMap<>();
    private boolean progressive;
    private File schematicDirectory;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        progressive = getConfig().getBoolean("progressive-printer", true);
        schematicDirectory = new File(getDataFolder(), "schematics");
        if (!schematicDirectory.isDirectory() && !schematicDirectory.mkdirs()) {
            getLogger().warning("Impossible de créer le dossier des schematics.");
        }
    }

    @Override
    public void onDisable() {
        for (PrintJob job : jobs.values().toArray(new PrintJob[0])) {
            job.finish();
        }
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (!(sender instanceof Player)) {
            sender.sendMessage("Cette commande doit être utilisée par un joueur.");
            return true;
        }
        Player player = (Player) sender;
        if (args.length == 0) {
            usage(player);
            return true;
        }
        switch (args[0].toLowerCase(Locale.ROOT)) {
            case "load":
                if (args.length != 2) {
                    player.sendMessage(ChatColor.RED + "Utilisation : /schematic load <fichier>");
                } else {
                    load(player, args[1]);
                }
                break;
            case "paste":
                if (args.length != 1) {
                    usage(player);
                } else {
                    paste(player);
                }
                break;
            case "progressive":
                if (args.length != 2 || (!args[1].equalsIgnoreCase("on") && !args[1].equalsIgnoreCase("off"))) {
                    player.sendMessage(ChatColor.RED + "Utilisation : /schematic progressive <on|off>");
                } else {
                    progressive = args[1].equalsIgnoreCase("on");
                    getConfig().set("progressive-printer", progressive);
                    saveConfig();
                    player.sendMessage(ChatColor.GREEN + "Progressive printer : " + (progressive ? "activé" : "désactivé"));
                }
                break;
            case "stop":
                PrintJob job = jobs.get(player.getUniqueId());
                if (job == null) {
                    player.sendMessage(ChatColor.RED + "Aucune construction en cours.");
                } else {
                    job.finish();
                    player.sendMessage(ChatColor.YELLOW + "Construction arrêtée ; les blocs déjà placés restent en place.");
                }
                break;
            default:
                usage(player);
        }
        return true;
    }

    private void usage(Player player) {
        player.sendMessage(ChatColor.YELLOW + "/schematic load <fichier> | paste | progressive <on|off> | stop");
    }

    private void load(Player player, String name) {
        try {
            File root = schematicDirectory.getCanonicalFile();
            File file = new File(root, name).getCanonicalFile();
            if (!file.toPath().startsWith(root.toPath()) || !file.isFile()) {
                player.sendMessage(ChatColor.RED + "Fichier introuvable dans le dossier schematics du plugin.");
                return;
            }
            ClipboardFormat format = ClipboardFormats.findByFile(file);
            if (format == null) {
                player.sendMessage(ChatColor.RED + "Format non reconnu par WorldEdit : " + name);
                return;
            }
            try (ClipboardReader reader = format.getReader(new FileInputStream(file))) {
                Clipboard clipboard = reader.read();
                clipboards.put(player.getUniqueId(), clipboard);
            }
            player.sendMessage(ChatColor.GREEN + "Schematic chargé : " + name);
        } catch (IOException | RuntimeException e) {
            player.sendMessage(ChatColor.RED + "Impossible de charger le fichier : " + e.getMessage());
            getLogger().warning("Chargement échoué : " + e.getMessage());
        }
    }

    private void paste(Player player) {
        Clipboard clipboard = clipboards.get(player.getUniqueId());
        if (clipboard == null) {
            player.sendMessage(ChatColor.RED + "Charge d'abord un fichier avec /schematic load <fichier>.");
            return;
        }
        if (jobs.containsKey(player.getUniqueId())) {
            player.sendMessage(ChatColor.RED + "Une construction est déjà en cours. Utilise /schematic stop.");
            return;
        }
        BlockVector3 target = BlockVector3.at(player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ());
        EditSession session = WorldEdit.getInstance().newEditSession(BukkitAdapter.adapt(player.getWorld()));
        PrintJob job = new PrintJob(player, clipboard, target, session,
                progressive ? Math.max(1, getConfig().getInt("blocks-per-tick", 100)) : Integer.MAX_VALUE,
                getConfig().getBoolean("include-air", false));
        jobs.put(player.getUniqueId(), job);
        job.task = getServer().getScheduler().runTaskTimer(this, job, 1L, 1L);
        player.sendMessage(ChatColor.GREEN + "Construction démarrée à ta position" + (progressive ? " en mode progressif." : "."));
    }

    private final class PrintJob implements Runnable {
        private final Player player;
        private final Clipboard clipboard;
        private final BlockVector3 target;
        private final EditSession session;
        private final Iterator<BlockVector3> blocks;
        private final int perTick;
        private final boolean includeAir;
        private BukkitTask task;

        private PrintJob(Player player, Clipboard clipboard, BlockVector3 target, EditSession session, int perTick, boolean includeAir) {
            this.player = player;
            this.clipboard = clipboard;
            this.target = target;
            this.session = session;
            this.blocks = clipboard.getRegion().iterator();
            this.perTick = perTick;
            this.includeAir = includeAir;
        }

        @Override
        public void run() {
            try {
                int processed = 0;
                while (processed < perTick && blocks.hasNext()) {
                    BlockVector3 source = blocks.next();
                    processed++;
                    if (!includeAir && clipboard.getBlock(source).getBlockType().getMaterial().isAir()) {
                        continue;
                    }
                    session.setBlock(target.add(source.subtract(clipboard.getOrigin())), clipboard.getFullBlock(source));
                }
                session.flushSession();
                if (!blocks.hasNext()) {
                    finish();
                    player.sendMessage(ChatColor.GREEN + "Construction terminée.");
                }
            } catch (Exception e) {
                finish();
                player.sendMessage(ChatColor.RED + "Construction interrompue : " + e.getMessage());
                getLogger().warning("Construction échouée : " + e.getMessage());
            }
        }

        private void finish() {
            if (task != null) {
                task.cancel();
            }
            jobs.remove(player.getUniqueId(), this);
            session.close();
        }
    }