Support diagonal stack

core/src/main/java/com/boydti/fawe/Fawe.java

@@ -27,6 +27,7 @@ import com.sk89q.worldedit.BlockWorldVector;
 import com.sk89q.worldedit.CuboidClipboard;
 import com.sk89q.worldedit.EditSession;
 import com.sk89q.worldedit.LocalSession;
+import com.sk89q.worldedit.PlayerDirection;
 import com.sk89q.worldedit.Vector;
 import com.sk89q.worldedit.Vector2D;
 import com.sk89q.worldedit.WorldEdit;
@@ -110,6 +111,7 @@ import com.sk89q.worldedit.function.visitor.RegionVisitor;
 import com.sk89q.worldedit.history.change.EntityCreate;
 import com.sk89q.worldedit.history.change.EntityRemove;
 import com.sk89q.worldedit.internal.LocalWorldAdapter;
+import com.sk89q.worldedit.internal.command.WorldEditBinding;
 import com.sk89q.worldedit.internal.expression.Expression;
 import com.sk89q.worldedit.internal.expression.runtime.ExpressionEnvironment;
 import com.sk89q.worldedit.internal.expression.runtime.Functions;
@@ -588,6 +590,8 @@ public class Fawe {
             DefaultBlockParser.inject(); // Fix block lookups
             BlockPattern.inject(); // Optimization
             AbstractPattern.inject();
+            PlayerDirection.inject(); // Diagonal commands
+            WorldEditBinding.inject(); //
             // Mask
             Mask.inject(); // Extend deprecated mask
             BlockMask.inject(); // Optimizations

core/src/main/java/com/boydti/fawe/regions/general/plot/CreateFromImage.java

@@ -147,10 +147,10 @@ public class CreateFromImage extends Command {
                             fp.sendMessage(BBC.getPrefix() + "/2 cfi smooth <url|mask> <radius> <iterations> [whiteonly]");
                             fp.sendMessage(BBC.getPrefix() + "/2 cfi waterHeight <height>");
                             fp.sendMessage(BBC.getPrefix() + "/2 cfi waterId <number-id>");
-                            fp.sendMessage(BBC.getPrefix() + "/2 cfi color <image-url>");
+                            fp.sendMessage(BBC.getPrefix() + "/2 cfi color <image-url> [image or fawe mask] [whiteOnly=true]");
                             fp.sendMessage(BBC.getPrefix() + "/2 cfi glass <image-url>");
                             fp.sendMessage(BBC.getPrefix() + "/2 cfi biomeColor <image-url>");
-                            fp.sendMessage(BBC.getPrefix() + "/2 cfi blockBiomeColor <image-url>");
+                            fp.sendMessage(BBC.getPrefix() + "/2 cfi blockBiomeColor <image-url> [image or fawe mask] [whiteOnly=true]");
                             fp.sendMessage(BBC.getPrefix() + "/2 cfi paletteComplexity <min=0> <max=100>");
                             fp.sendMessage(BBC.getPrefix() + "/2 cfi paletteRandomization <true|false>");
                             fp.sendMessage(BBC.getPrefix() + "/2 cfi paletteBlocks <block-list|#clipboard>");

core/src/main/java/com/sk89q/worldedit/PlayerDirection.java

@@ -0,0 +1,134 @@
+/*
+ * 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 Lesser 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 Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.sk89q.worldedit;
+
+import com.sk89q.worldedit.entity.Player;
+import com.sk89q.worldedit.util.Direction;
+
+/**
+ * The player's direction.
+ *
+ * <p>In the future, this class will be replaced with {@link Direction}.</p>
+ */
+public enum PlayerDirection {
+
+    NORTH(new Vector(0, 0, -1), new Vector(-1, 0, 0), true),
+    NORTH_EAST((new Vector(1, 0, -1)), (new Vector(-1, 0, -1)), false),
+    EAST(new Vector(1, 0, 0), new Vector(0, 0, -1), true),
+    SOUTH_EAST((new Vector(1, 0, 1)), (new Vector(1, 0, -1)), false),
+    SOUTH(new Vector(0, 0, 1), new Vector(1, 0, 0), true),
+    SOUTH_WEST((new Vector(-1, 0, 1)), (new Vector(1, 0, 1)), false),
+    WEST(new Vector(-1, 0, 0), new Vector(0, 0, 1), true),
+    NORTH_WEST((new Vector(-1, 0, -1)), (new Vector(-1, 0, 1)), false),
+    UP(new Vector(0, 1, 0), new Vector(0, 0, 1), true),
+    DOWN(new Vector(0, -1, 0), new Vector(0, 0, 1), true);
+
+    private final Vector dir;
+    private final Vector leftDir;
+    private final boolean isOrthogonal;
+
+    PlayerDirection(Vector vec, Vector leftDir, boolean isOrthogonal) {
+        this.dir = vec;
+        this.leftDir = leftDir;
+        this.isOrthogonal = isOrthogonal;
+    }
+
+    public static PlayerDirection valueOf(Player player, String dirStr) throws UnknownDirectionException {
+        final PlayerDirection dir;
+
+        switch (dirStr.charAt(0)) {
+            case 'w':
+                dir = PlayerDirection.WEST;
+                break;
+
+            case 'e':
+                dir = PlayerDirection.EAST;
+                break;
+
+            case 's':
+                if (dirStr.indexOf('w') > 0) {
+                    return PlayerDirection.SOUTH_WEST;
+                }
+
+                if (dirStr.indexOf('e') > 0) {
+                    return PlayerDirection.SOUTH_EAST;
+                }
+                dir = PlayerDirection.SOUTH;
+                break;
+
+            case 'n':
+                if (dirStr.indexOf('w') > 0) {
+                    return PlayerDirection.NORTH_WEST;
+                }
+
+                if (dirStr.indexOf('e') > 0) {
+                    return PlayerDirection.NORTH_EAST;
+                }
+                dir = PlayerDirection.NORTH;
+                break;
+
+            case 'u':
+                dir = PlayerDirection.UP;
+                break;
+
+            case 'd':
+                dir = PlayerDirection.DOWN;
+                break;
+
+            case 'm': // me
+            case 'f': // forward
+                dir = player.getCardinalDirection(0);
+                break;
+
+            case 'b': // back
+                dir = player.getCardinalDirection(180);
+                break;
+
+            case 'l': // left
+                dir = player.getCardinalDirection(-90);
+                break;
+
+            case 'r': // right
+                dir = player.getCardinalDirection(90);
+                break;
+
+            default:
+                throw new UnknownDirectionException(dirStr);
+        }
+        return dir;
+    }
+
+    public Vector vector() {
+        return dir;
+    }
+
+    @Deprecated
+    public Vector leftVector() {
+        return leftDir;
+    }
+
+    public boolean isOrthogonal() {
+        return isOrthogonal;
+    }
+
+    public static Class<?> inject() {
+        return PlayerDirection.class;
+    }
+}

core/src/main/java/com/sk89q/worldedit/command/RegionCommands.java

@@ -621,9 +621,8 @@ public class RegionCommands extends MethodCommands {
 
         if (moveSelection) {
             try {
-                final Vector size = region.getMaximumPoint().subtract(region.getMinimumPoint());
-
-                final Vector shiftVector = direction.multiply(count * (Math.abs(direction.dot(size)) + 1));
+                final Vector size = region.getMaximumPoint().subtract(region.getMinimumPoint()).add(1, 1, 1);
+                Vector shiftVector = new Vector(direction.getX() * size.getX() * count, direction.getY() * size.getY() * count, direction.getZ() * size.getZ() * count);
                 region.shift(shiftVector);
 
                 session.getRegionSelector(player.getWorld()).learnChanges();

core/src/main/java/com/sk89q/worldedit/internal/command/WorldEditBinding.java

@@ -0,0 +1,341 @@
+/*
+ * 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 Lesser 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 Lesser General Public License
+ * for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.sk89q.worldedit.internal.command;
+
+import com.sk89q.worldedit.EditSession;
+import com.sk89q.worldedit.IncompleteRegionException;
+import com.sk89q.worldedit.LocalSession;
+import com.sk89q.worldedit.PlayerDirection;
+import com.sk89q.worldedit.UnknownDirectionException;
+import com.sk89q.worldedit.Vector;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.WorldEditException;
+import com.sk89q.worldedit.blocks.BaseBlock;
+import com.sk89q.worldedit.entity.Entity;
+import com.sk89q.worldedit.entity.Player;
+import com.sk89q.worldedit.extension.input.NoMatchException;
+import com.sk89q.worldedit.extension.input.ParserContext;
+import com.sk89q.worldedit.extension.platform.Actor;
+import com.sk89q.worldedit.extent.Extent;
+import com.sk89q.worldedit.function.mask.Mask;
+import com.sk89q.worldedit.function.pattern.Pattern;
+import com.sk89q.worldedit.internal.annotation.Direction;
+import com.sk89q.worldedit.internal.annotation.Selection;
+import com.sk89q.worldedit.regions.Region;
+import com.sk89q.worldedit.util.TreeGenerator;
+import com.sk89q.worldedit.util.TreeGenerator.TreeType;
+import com.sk89q.worldedit.util.command.parametric.ArgumentStack;
+import com.sk89q.worldedit.util.command.parametric.BindingBehavior;
+import com.sk89q.worldedit.util.command.parametric.BindingHelper;
+import com.sk89q.worldedit.util.command.parametric.BindingMatch;
+import com.sk89q.worldedit.util.command.parametric.ParameterException;
+import com.sk89q.worldedit.world.World;
+import com.sk89q.worldedit.world.biome.BaseBiome;
+import com.sk89q.worldedit.world.biome.Biomes;
+import com.sk89q.worldedit.world.registry.BiomeRegistry;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Binds standard WorldEdit classes such as {@link Player} and {@link LocalSession}.
+ */
+public class WorldEditBinding extends BindingHelper {
+
+    private final WorldEdit worldEdit;
+
+    /**
+     * Create a new instance.
+     *
+     * @param worldEdit the WorldEdit instance to bind to
+     */
+    public WorldEditBinding(WorldEdit worldEdit) {
+        this.worldEdit = worldEdit;
+    }
+
+    /**
+     * Gets a selection from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @param selection the annotation
+     * @return a selection
+     * @throws IncompleteRegionException if no selection is available
+     * @throws ParameterException on other error
+     */
+    @BindingMatch(classifier = Selection.class,
+            type = Region.class,
+            behavior = BindingBehavior.PROVIDES)
+    public Object getSelection(ArgumentStack context, Selection selection) throws IncompleteRegionException, ParameterException {
+        Player sender = getPlayer(context);
+        LocalSession session = worldEdit.getSessionManager().get(sender);
+        return session.getSelection(sender.getWorld());
+    }
+
+    /**
+     * Gets an {@link EditSession} from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @return an edit session
+     * @throws ParameterException on other error
+     */
+    @BindingMatch(type = EditSession.class,
+            behavior = BindingBehavior.PROVIDES)
+    public EditSession getEditSession(ArgumentStack context) throws ParameterException {
+        Player sender = getPlayer(context);
+        LocalSession session = worldEdit.getSessionManager().get(sender);
+        EditSession editSession = session.createEditSession(sender);
+        editSession.enableQueue();
+        context.getContext().getLocals().put(EditSession.class, editSession);
+        session.tellVersion(sender);
+        return editSession;
+    }
+
+    /**
+     * Gets an {@link LocalSession} from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @return a local session
+     * @throws ParameterException on error
+     */
+    @BindingMatch(type = LocalSession.class,
+            behavior = BindingBehavior.PROVIDES)
+    public LocalSession getLocalSession(ArgumentStack context) throws ParameterException {
+        Player sender = getPlayer(context);
+        return worldEdit.getSessionManager().get(sender);
+    }
+
+    /**
+     * Gets an {@link Actor} from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @return a local player
+     * @throws ParameterException on error
+     */
+    @BindingMatch(type = Actor.class,
+            behavior = BindingBehavior.PROVIDES)
+    public Actor getActor(ArgumentStack context) throws ParameterException {
+        Actor sender = context.getContext().getLocals().get(Actor.class);
+        if (sender == null) {
+            throw new ParameterException("Missing 'Actor'");
+        } else {
+            return sender;
+        }
+    }
+
+    /**
+     * Gets an {@link Player} from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @return a local player
+     * @throws ParameterException on error
+     */
+    @BindingMatch(type = Player.class,
+            behavior = BindingBehavior.PROVIDES)
+    public Player getPlayer(ArgumentStack context) throws ParameterException {
+        Actor sender = context.getContext().getLocals().get(Actor.class);
+        if (sender == null) {
+            throw new ParameterException("No player to get a session for");
+        } else if (sender instanceof Player) {
+            return (Player) sender;
+        } else {
+            throw new ParameterException("Caller is not a player");
+        }
+    }
+
+    /**
+     * Gets an {@link BaseBlock} from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @return a pattern
+     * @throws ParameterException on error
+     * @throws WorldEditException on error
+     */
+    @BindingMatch(type = BaseBlock.class,
+            behavior = BindingBehavior.CONSUMES,
+            consumedCount = 1)
+    public BaseBlock getBaseBlock(ArgumentStack context) throws ParameterException, WorldEditException {
+        Actor actor = context.getContext().getLocals().get(Actor.class);
+        ParserContext parserContext = new ParserContext();
+        parserContext.setActor(context.getContext().getLocals().get(Actor.class));
+        if (actor instanceof Entity) {
+            Extent extent = ((Entity) actor).getExtent();
+            if (extent instanceof World) {
+                parserContext.setWorld((World) extent);
+            }
+        }
+        parserContext.setSession(worldEdit.getSessionManager().get(actor));
+        try {
+            return worldEdit.getBlockFactory().parseFromInput(context.next(), parserContext);
+        } catch (NoMatchException e) {
+            throw new ParameterException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Gets an {@link Pattern} from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @return a pattern
+     * @throws ParameterException on error
+     * @throws WorldEditException on error
+     */
+    @BindingMatch(type = Pattern.class,
+            behavior = BindingBehavior.CONSUMES,
+            consumedCount = 1)
+    public Pattern getPattern(ArgumentStack context) throws ParameterException, WorldEditException {
+        Actor actor = context.getContext().getLocals().get(Actor.class);
+        ParserContext parserContext = new ParserContext();
+        parserContext.setActor(context.getContext().getLocals().get(Actor.class));
+        if (actor instanceof Entity) {
+            Extent extent = ((Entity) actor).getExtent();
+            if (extent instanceof World) {
+                parserContext.setWorld((World) extent);
+            }
+        }
+        parserContext.setSession(worldEdit.getSessionManager().get(actor));
+        try {
+            return worldEdit.getPatternFactory().parseFromInput(context.next(), parserContext);
+        } catch (NoMatchException e) {
+            throw new ParameterException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Gets an {@link Mask} from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @return a pattern
+     * @throws ParameterException on error
+     * @throws WorldEditException on error
+     */
+    @BindingMatch(type = Mask.class,
+            behavior = BindingBehavior.CONSUMES,
+            consumedCount = 1)
+    public Mask getMask(ArgumentStack context) throws ParameterException, WorldEditException {
+        Actor actor = context.getContext().getLocals().get(Actor.class);
+        ParserContext parserContext = new ParserContext();
+        parserContext.setActor(context.getContext().getLocals().get(Actor.class));
+        if (actor instanceof Entity) {
+            Extent extent = ((Entity) actor).getExtent();
+            if (extent instanceof World) {
+                parserContext.setWorld((World) extent);
+            }
+        }
+        parserContext.setSession(worldEdit.getSessionManager().get(actor));
+        try {
+            return worldEdit.getMaskFactory().parseFromInput(context.next(), parserContext);
+        } catch (NoMatchException e) {
+            throw new ParameterException(e.getMessage(), e);
+        }
+    }
+
+    /**
+     * Get a direction from the player.
+     *
+     * @param context the context
+     * @param direction the direction annotation
+     * @return a pattern
+     * @throws ParameterException on error
+     * @throws UnknownDirectionException on an unknown direction
+     */
+    @BindingMatch(classifier = Direction.class,
+            type = Vector.class,
+            behavior = BindingBehavior.CONSUMES,
+            consumedCount = 1)
+    public Vector getDirection(ArgumentStack context, Direction direction)
+            throws ParameterException, UnknownDirectionException {
+        Player sender = getPlayer(context);
+        return PlayerDirection.valueOf(sender, context.next()).vector();
+    }
+
+    /**
+     * Gets an {@link TreeType} from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @return a pattern
+     * @throws ParameterException on error
+     * @throws WorldEditException on error
+     */
+    @BindingMatch(type = TreeType.class,
+            behavior = BindingBehavior.CONSUMES,
+            consumedCount = 1)
+    public TreeType getTreeType(ArgumentStack context) throws ParameterException, WorldEditException {
+        String input = context.next();
+        if (input != null) {
+            TreeType type = TreeGenerator.lookup(input);
+            if (type != null) {
+                return type;
+            } else {
+                throw new ParameterException(
+                        String.format("Can't recognize tree type '%s' -- choose from: %s", input, Arrays.toString(TreeType.values())));
+            }
+        } else {
+            return TreeType.TREE;
+        }
+    }
+
+    /**
+     * Gets an {@link BaseBiome} from a {@link ArgumentStack}.
+     *
+     * @param context the context
+     * @return a pattern
+     * @throws ParameterException on error
+     * @throws WorldEditException on error
+     */
+    @BindingMatch(type = BaseBiome.class,
+            behavior = BindingBehavior.CONSUMES,
+            consumedCount = 1)
+    public BaseBiome getBiomeType(ArgumentStack context) throws ParameterException, WorldEditException {
+        String input = context.next();
+        if (input != null) {
+            Actor actor = context.getContext().getLocals().get(Actor.class);
+            World world;
+            if (actor instanceof Entity) {
+                Extent extent = ((Entity) actor).getExtent();
+                if (extent instanceof World) {
+                    world = (World) extent;
+                } else {
+                    throw new ParameterException("A world is required.");
+                }
+            } else {
+                throw new ParameterException("An entity is required.");
+            }
+
+            BiomeRegistry biomeRegistry = world.getWorldData().getBiomeRegistry();
+            List<BaseBiome> knownBiomes = biomeRegistry.getBiomes();
+            BaseBiome biome = Biomes.findBiomeByName(knownBiomes, input, biomeRegistry);
+            if (biome != null) {
+                return biome;
+            } else {
+                throw new ParameterException(
+                        String.format("Can't recognize biome type '%s' -- use /biomelist to list available types", input));
+            }
+        } else {
+            throw new ParameterException(
+                    "This command takes a 'default' biome if one is not set, except there is no particular " +
+                            "biome that should be 'default', so the command should not be taking a default biome");
+        }
+    }
+
+    public static Class<?> inject() {
+        return WorldEditBinding.class;
+    }
+
+}