Plex-FAWE/worldedit-core/src/main/java/com/sk89q/worldedit/command/ToolCommands.java

/*
 * WorldEdit, a Minecraft world manipulation toolkit
 * Copyright (C) sk89q <http://www.sk89q.com>
 * Copyright (C) WorldEdit team and contributors
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

package com.sk89q.worldedit.command;

import com.fastasyncworldedit.core.configuration.Caption;
import com.fastasyncworldedit.core.command.tool.brush.InspectBrush;
import com.google.common.collect.Collections2;
import com.sk89q.worldedit.LocalConfiguration;
import com.sk89q.worldedit.LocalSession;
import com.sk89q.worldedit.WorldEdit;
import com.sk89q.worldedit.WorldEditException;
import com.sk89q.worldedit.blocks.BaseItemStack;
import com.sk89q.worldedit.command.tool.BlockDataCyler;
import com.sk89q.worldedit.command.tool.BlockReplacer;
import com.sk89q.worldedit.command.tool.BrushTool;
import com.sk89q.worldedit.command.tool.DistanceWand;
import com.sk89q.worldedit.command.tool.FloatingTreeRemover;
import com.sk89q.worldedit.command.tool.FloodFillTool;
import com.sk89q.worldedit.command.tool.InvalidToolBindException;
import com.sk89q.worldedit.command.tool.LongRangeBuildTool;
import com.sk89q.worldedit.command.tool.NavigationWand;
import com.sk89q.worldedit.command.tool.QueryTool;
import com.sk89q.worldedit.command.tool.SelectionWand;
import com.sk89q.worldedit.command.tool.StackTool;
import com.sk89q.worldedit.command.tool.Tool;
import com.sk89q.worldedit.command.tool.TreePlanter;
import com.sk89q.worldedit.command.util.CommandPermissions;
import com.sk89q.worldedit.command.util.CommandPermissionsConditionGenerator;
import com.sk89q.worldedit.command.util.SubCommandPermissionCondition;
import com.sk89q.worldedit.entity.Player;
import com.sk89q.worldedit.function.mask.Mask;
import com.sk89q.worldedit.function.pattern.Pattern;
import com.sk89q.worldedit.internal.command.CommandRegistrationHandler;
import com.sk89q.worldedit.internal.command.CommandUtil;
import com.sk89q.worldedit.util.HandSide;
import com.sk89q.worldedit.util.TreeGenerator;
import com.sk89q.worldedit.util.formatting.text.Component;
import com.sk89q.worldedit.util.formatting.text.TextComponent;
import com.sk89q.worldedit.util.formatting.text.event.ClickEvent;
import com.sk89q.worldedit.util.formatting.text.format.TextColor;
import com.sk89q.worldedit.world.block.BlockStateHolder;
import org.enginehub.piston.CommandManager;
import org.enginehub.piston.CommandManagerService;
import org.enginehub.piston.CommandMetadata;
import org.enginehub.piston.CommandParameters;
import org.enginehub.piston.annotation.Command;
import org.enginehub.piston.annotation.CommandContainer;
import org.enginehub.piston.annotation.param.Arg;
import org.enginehub.piston.part.SubCommandPart;

import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

@CommandContainer(superTypes = CommandPermissionsConditionGenerator.Registration.class)
public class ToolCommands {

    private static final Component UNBIND_COMMAND_COMPONENT = TextComponent.builder("/tool unbind", TextColor.AQUA)
            .clickEvent(ClickEvent.suggestCommand("/tool unbind"))
            .build();

    public static void register(CommandRegistrationHandler registration,
                                CommandManager commandManager,
                                CommandManagerService commandManagerService,
                                WorldEdit worldEdit) {
        // Collect the tool commands
        CommandManager collect = commandManagerService.newCommandManager();

        registration.register(
            collect,
            ToolCommandsRegistration.builder(),
            new ToolCommands(worldEdit)
        );

        // Register deprecated global commands
        Set<org.enginehub.piston.Command> commands = collect.getAllCommands()
            .collect(Collectors.toSet());
        for (org.enginehub.piston.Command command : commands) {
            if (command.getAliases().contains("unbind")) {
                // Don't register new /tool <whatever> alias
                command = command.toBuilder().aliases(
                    Collections2.filter(command.getAliases(), alias -> !"unbind".equals(alias))
                ).build();
            }
            if (command.getName().equals("stacker")) {
                // Don't register /stacker
                continue;
            }
            commandManager.register(CommandUtil.deprecate(
                command, "Global tool names cause conflicts "
                    + "and will be removed in WorldEdit 8",
                CommandUtil.ReplacementMessageGenerator.forNewCommand(ToolCommands::asNonGlobal)
            ));
        }

        // Remove aliases with / in them, since it doesn't make sense for sub-commands.
        Set<org.enginehub.piston.Command> nonGlobalCommands = commands.stream()
            .map(command ->
                command.toBuilder().aliases(
                    Collections2.filter(command.getAliases(), alias -> !alias.startsWith("/"))
                ).build()
            )
            .collect(Collectors.toSet());
        commandManager.register("tool", command -> {
            command.addPart(SubCommandPart.builder(
                    Caption.of("tool"),
                TextComponent.of("The tool to bind")
            )
                .withCommands(nonGlobalCommands)
                .required()
                .build());
            command.description(TextComponent.of("Binds a tool to the item in your hand"));

            command.condition(new SubCommandPermissionCondition.Generator(nonGlobalCommands).build());
        });
    }

    private static String asNonGlobal(org.enginehub.piston.Command oldCommand,
                                      CommandParameters oldParameters) {
        String name = Optional.ofNullable(oldParameters.getMetadata())
            .map(CommandMetadata::getCalledName)
            .filter(n -> !n.startsWith("/"))
            .orElseGet(oldCommand::getName);
        return "/tool " + name;
    }

    static void setToolNone(Player player, LocalSession session, boolean isBrush)
        throws InvalidToolBindException {
        //FAWE start
        isBrush = session.getTool(player) instanceof BrushTool;
        session.setTool(player.getItemInHand(HandSide.MAIN_HAND).getType(), null);
        //FAWE end
        player.print(Caption.of(isBrush ? "worldedit.brush.none.equip" : "worldedit.tool.none.equip"));
    }

    static void sendUnbindInstruction(Player sender, Component commandComponent) {
        sender.print(Caption.of("worldedit.tool.unbind-instruction", commandComponent));
    }

    private static void setTool(Player player, LocalSession session, Tool tool,
                                String translationKey) throws InvalidToolBindException {
        BaseItemStack itemStack = player.getItemInHand(HandSide.MAIN_HAND);
        session.setTool(itemStack.getType(), tool);
        player.print(Caption.of(translationKey, itemStack.getRichName()));
        sendUnbindInstruction(player, UNBIND_COMMAND_COMPONENT);
    }

    private final WorldEdit we;

    public ToolCommands(WorldEdit we) {
        this.we = we;
    }

    @Command(
        name = "none",
        aliases = "unbind",
        desc = "Unbind a bound tool from your current item"
    )
    @CommandPermissions("worldedit.tool.none")
    public void none(Player player, LocalSession session) throws WorldEditException {
        setToolNone(player, session, false);
    }

    @Command(
        name = "selwand",
        aliases = "/selwand",
        desc = "Selection wand tool"
    )
    @CommandPermissions("worldedit.setwand")
    public void selwand(Player player, LocalSession session) throws WorldEditException {
        //FAWE start - instance-inized
        setTool(player, session, SelectionWand.INSTANCE, "worldedit.tool.selwand.equip");
        //FAWE end
    }

    @Command(
        name = "navwand",
        aliases = "/navwand",
        desc = "Navigation wand tool"
    )
    @CommandPermissions("worldedit.setwand")
    public void navwand(Player player, LocalSession session) throws WorldEditException {
        //FAWE start - instance-inized
        setTool(player, session, NavigationWand.INSTANCE, "worldedit.tool.navwand.equip");
        //FAWE end
    }

    @Command(
        name = "info",
        aliases = { "/info" },
        desc = "Block information tool"
    )
    @CommandPermissions("worldedit.tool.info")
    public void info(Player player, LocalSession session) throws WorldEditException {
        setTool(player, session, new QueryTool(), "worldedit.tool.info.equip");
    }

    //FAWE start
    @Command(
            name = "inspect",
            aliases = { "/inspect" },
            desc = "Inspect edits within a radius"
    )
    @CommandPermissions("worldedit.tool.inspect")
    public void inspectBrush(Player player, LocalSession session) throws WorldEditException {
        setTool(player, session, new InspectBrush(), "worldedit.tool.info.equip");
    }
    //FAWE end

    @Command(
        name = "tree",
        aliases = { "/tree" },
        desc = "Tree generator tool"
    )
    @CommandPermissions("worldedit.tool.tree")
    public void tree(Player player, LocalSession session,
                     @Arg(desc = "Type of tree to generate", def = "tree")
                     TreeGenerator.TreeType type) throws WorldEditException {
        setTool(player, session, new TreePlanter(type), "worldedit.tool.tree.equip");
    }

    @Command(
        name = "stacker",
        desc = "Block stacker tool"
    )
    @CommandPermissions("worldedit.tool.stack")
    public void stacker(Player player, LocalSession session,
                        @Arg(desc = "The max range of the stack", def = "10")
                            int range,
                        @Arg(desc = "The mask to stack until", def = "!#existing")
                            Mask mask) throws WorldEditException {
        setTool(player, session, new StackTool(range, mask), "worldedit.tool.stack.equip");
    }

    @Command(
        name = "repl",
        aliases = { "/repl" },
        desc = "Block replacer tool"
    )
    @CommandPermissions("worldedit.tool.replacer")
    public void repl(Player player, LocalSession session,
                     @Arg(desc = "The pattern of blocks to place")
                         Pattern pattern) throws WorldEditException {
        setTool(player, session, new BlockReplacer(pattern), "worldedit.tool.repl.equip");
    }

    @Command(
        name = "cycler",
        aliases = { "/cycler" },
        desc = "Block data cycler tool"
    )
    @CommandPermissions("worldedit.tool.data-cycler")
    public void cycler(Player player, LocalSession session) throws WorldEditException {
        setTool(player, session, new BlockDataCyler(), "worldedit.tool.data-cycler.equip");
    }

    @Command(
        name = "floodfill",
        aliases = { "flood", "/flood", "/floodfill" },
        desc = "Flood fill tool"
    )
    @CommandPermissions("worldedit.tool.flood-fill")
    public void floodFill(Player player, LocalSession session,
                          @Arg(desc = "The pattern to flood fill")
                              Pattern pattern,
                          @Arg(desc = "The range to perform the fill")
                              int range) throws WorldEditException {

        LocalConfiguration config = we.getConfiguration();

        if (range > config.maxSuperPickaxeSize) {
            player.print(Caption.of("worldedit.tool.superpickaxe.max-range", TextComponent.of(config.maxSuperPickaxeSize)));
            return;
        }
        setTool(player, session, new FloodFillTool(range, pattern), "worldedit.tool.floodfill.equip");
    }

    @Command(
        name = "deltree",
        aliases = { "/deltree" },
        desc = "Floating tree remover tool"
    )
    @CommandPermissions("worldedit.tool.deltree")
    public void deltree(Player player, LocalSession session) throws WorldEditException {
        setTool(player, session, new FloatingTreeRemover(), "worldedit.tool.deltree.equip");
    }

    @Command(
        name = "farwand",
        aliases = { "/warwand" },
        desc = "Wand at a distance tool"
    )
    @CommandPermissions("worldedit.tool.farwand")
    public void farwand(Player player, LocalSession session) throws WorldEditException {
        setTool(player, session, new DistanceWand(), "worldedit.tool.farwand.equip");
    }

    @Command(
        name = "lrbuild",
        aliases = { "/lrbuild" },
        desc = "Long-range building tool"
    )
    @CommandPermissions("worldedit.tool.lrbuild")
    public void longrangebuildtool(Player player, LocalSession session,
                                   @Arg(desc = "Pattern to set on left-click")
                                       Pattern primary,
                                   @Arg(desc = "Pattern to set on right-click")
                                       Pattern secondary) throws WorldEditException {
        setTool(player, session, new LongRangeBuildTool(primary, secondary), "worldedit.tool.lrbuild.equip");
        Component primaryName;
        Component secondaryName;
        if (primary instanceof BlockStateHolder) {
            primaryName = ((BlockStateHolder<?>) primary).getBlockType().getRichName();
        } else {
            primaryName = TextComponent.of("pattern");
        }
        if (secondary instanceof BlockStateHolder) {
            secondaryName = ((BlockStateHolder<?>) secondary).getBlockType().getRichName();
        } else {
            secondaryName = TextComponent.of("pattern");
        }
        player.print(Caption.of("worldedit.tool.lrbuild.set", primaryName, secondaryName));
    }
}