2014-04-04 00:52:53 +00:00
|
|
|
/*
|
|
|
|
* WorldEdit, a Minecraft world manipulation toolkit
|
|
|
|
* Copyright (C) sk89q <http://www.sk89q.com>
|
|
|
|
* Copyright (C) WorldEdit team and contributors
|
|
|
|
*
|
2014-04-04 22:03:18 +00:00
|
|
|
* 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
|
2014-04-04 00:52:53 +00:00
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
2014-04-04 22:03:18 +00:00
|
|
|
* 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.
|
2014-04-04 00:52:53 +00:00
|
|
|
*
|
2014-04-04 22:03:18 +00:00
|
|
|
* You should have received a copy of the GNU Lesser General Public License
|
2014-04-04 00:52:53 +00:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2014-07-09 00:39:33 +00:00
|
|
|
package com.sk89q.worldedit.extension.factory;
|
2014-04-04 00:52:53 +00:00
|
|
|
|
2018-08-21 17:22:37 +00:00
|
|
|
import com.boydti.fawe.command.SuggestInputParseException;
|
2018-08-12 14:03:07 +00:00
|
|
|
import com.boydti.fawe.jnbt.JSON2NBT;
|
|
|
|
import com.boydti.fawe.jnbt.NBTException;
|
|
|
|
import com.boydti.fawe.util.MathMan;
|
|
|
|
import com.boydti.fawe.util.StringMan;
|
|
|
|
import com.sk89q.jnbt.CompoundTag;
|
|
|
|
import com.sk89q.worldedit.*;
|
2018-08-10 10:29:06 +00:00
|
|
|
|
2018-08-21 17:22:37 +00:00
|
|
|
import com.sk89q.worldedit.extension.platform.Platform;
|
2018-08-12 14:03:07 +00:00
|
|
|
import com.sk89q.worldedit.world.block.BlockState;
|
|
|
|
import com.sk89q.worldedit.blocks.BaseItem;
|
2018-12-23 16:19:33 +00:00
|
|
|
import com.sk89q.worldedit.IncompleteRegionException;
|
|
|
|
import com.sk89q.worldedit.NotABlockException;
|
|
|
|
import com.sk89q.worldedit.WorldEdit;
|
|
|
|
import com.sk89q.worldedit.WorldEditException;
|
2018-08-10 10:29:06 +00:00
|
|
|
import com.sk89q.worldedit.world.block.BaseBlock;
|
2018-06-17 13:13:22 +00:00
|
|
|
import com.sk89q.worldedit.blocks.MobSpawnerBlock;
|
|
|
|
import com.sk89q.worldedit.blocks.SignBlock;
|
|
|
|
import com.sk89q.worldedit.blocks.SkullBlock;
|
2014-07-29 14:57:45 +00:00
|
|
|
import com.sk89q.worldedit.blocks.metadata.MobType;
|
2014-04-05 00:54:14 +00:00
|
|
|
import com.sk89q.worldedit.entity.Player;
|
2014-04-04 00:52:53 +00:00
|
|
|
import com.sk89q.worldedit.extension.input.DisallowedUsageException;
|
|
|
|
import com.sk89q.worldedit.extension.input.InputParseException;
|
|
|
|
import com.sk89q.worldedit.extension.input.NoMatchException;
|
2014-04-05 00:54:14 +00:00
|
|
|
import com.sk89q.worldedit.extension.input.ParserContext;
|
|
|
|
import com.sk89q.worldedit.extension.platform.Actor;
|
2018-06-17 12:04:35 +00:00
|
|
|
import com.sk89q.worldedit.extension.platform.Capability;
|
2018-08-12 14:03:07 +00:00
|
|
|
import com.sk89q.worldedit.extent.inventory.BlockBag;
|
|
|
|
import com.sk89q.worldedit.extent.inventory.SlottableBlockBag;
|
2014-04-04 00:52:53 +00:00
|
|
|
import com.sk89q.worldedit.internal.registry.InputParser;
|
2018-12-23 16:19:33 +00:00
|
|
|
import com.sk89q.worldedit.math.BlockVector3;
|
|
|
|
import com.sk89q.worldedit.registry.state.Property;
|
2018-06-17 07:50:04 +00:00
|
|
|
import com.sk89q.worldedit.util.HandSide;
|
2014-04-05 09:59:38 +00:00
|
|
|
import com.sk89q.worldedit.world.World;
|
2018-07-17 07:31:07 +00:00
|
|
|
import com.sk89q.worldedit.world.block.BlockState;
|
|
|
|
import com.sk89q.worldedit.world.block.BlockStateHolder;
|
|
|
|
import com.sk89q.worldedit.world.block.BlockTypes;
|
2018-07-23 02:48:11 +00:00
|
|
|
import com.sk89q.worldedit.world.registry.LegacyMapper;
|
2018-06-17 13:13:22 +00:00
|
|
|
|
2018-08-12 14:03:07 +00:00
|
|
|
import java.util.Arrays;
|
2018-08-21 17:22:37 +00:00
|
|
|
import java.util.List;
|
|
|
|
import java.util.function.Predicate;
|
|
|
|
import java.util.function.Supplier;
|
|
|
|
import java.util.stream.Collectors;
|
|
|
|
import java.util.stream.Stream;
|
2014-04-04 00:52:53 +00:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Parses block input strings.
|
|
|
|
*/
|
2018-08-12 14:03:07 +00:00
|
|
|
public class DefaultBlockParser extends InputParser<BlockStateHolder> {
|
2014-04-04 00:52:53 +00:00
|
|
|
|
2018-08-12 14:03:07 +00:00
|
|
|
public DefaultBlockParser(WorldEdit worldEdit) {
|
2014-04-04 00:52:53 +00:00
|
|
|
super(worldEdit);
|
|
|
|
}
|
|
|
|
|
2018-08-12 17:31:26 +00:00
|
|
|
private static BlockState getBlockInHand(Actor actor, HandSide handSide) throws InputParseException {
|
2014-04-05 00:54:14 +00:00
|
|
|
if (actor instanceof Player) {
|
|
|
|
try {
|
2018-06-17 07:50:04 +00:00
|
|
|
return ((Player) actor).getBlockInHand(handSide);
|
2014-04-05 00:54:14 +00:00
|
|
|
} catch (NotABlockException e) {
|
|
|
|
throw new InputParseException("You're not holding a block!");
|
|
|
|
} catch (WorldEditException e) {
|
|
|
|
throw new InputParseException("Unknown error occurred: " + e.getMessage(), e);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
throw new InputParseException("The user is not a player!");
|
2014-04-04 00:52:53 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-18 12:51:21 +00:00
|
|
|
public BlockStateHolder parseFromInput(String input, ParserContext context)
|
2016-06-17 23:59:41 +00:00
|
|
|
throws InputParseException {
|
|
|
|
String originalInput = input;
|
2014-04-04 00:52:53 +00:00
|
|
|
input = input.replace(";", "|");
|
2016-06-17 23:59:41 +00:00
|
|
|
Exception suppressed = null;
|
|
|
|
try {
|
2018-06-18 12:51:21 +00:00
|
|
|
BlockStateHolder modified = parseLogic(input, context);
|
2016-06-17 23:59:41 +00:00
|
|
|
if (modified != null) {
|
|
|
|
return modified;
|
|
|
|
}
|
|
|
|
} catch (Exception e) {
|
|
|
|
suppressed = e;
|
|
|
|
}
|
|
|
|
try {
|
|
|
|
return parseLogic(originalInput, context);
|
|
|
|
} catch (Exception e) {
|
|
|
|
if (suppressed != null) {
|
|
|
|
e.addSuppressed(suppressed);
|
|
|
|
}
|
|
|
|
throw e;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-17 13:13:22 +00:00
|
|
|
private static String[] EMPTY_STRING_ARRAY = new String[]{};
|
|
|
|
|
2018-06-19 07:26:22 +00:00
|
|
|
/**
|
|
|
|
* Backwards compatibility for wool colours in block syntax.
|
|
|
|
*
|
|
|
|
* @param string Input string
|
|
|
|
* @return Mapped string
|
|
|
|
*/
|
|
|
|
private String woolMapper(String string) {
|
|
|
|
switch (string.toLowerCase()) {
|
|
|
|
case "white":
|
|
|
|
return BlockTypes.WHITE_WOOL.getId();
|
|
|
|
case "black":
|
|
|
|
return BlockTypes.BLACK_WOOL.getId();
|
|
|
|
case "blue":
|
|
|
|
return BlockTypes.BLUE_WOOL.getId();
|
|
|
|
case "brown":
|
|
|
|
return BlockTypes.BROWN_WOOL.getId();
|
|
|
|
case "cyan":
|
|
|
|
return BlockTypes.CYAN_WOOL.getId();
|
|
|
|
case "gray":
|
|
|
|
case "grey":
|
|
|
|
return BlockTypes.GRAY_WOOL.getId();
|
|
|
|
case "green":
|
|
|
|
return BlockTypes.GREEN_WOOL.getId();
|
|
|
|
case "light_blue":
|
|
|
|
case "lightblue":
|
|
|
|
return BlockTypes.LIGHT_BLUE_WOOL.getId();
|
|
|
|
case "light_gray":
|
|
|
|
case "light_grey":
|
|
|
|
case "lightgray":
|
|
|
|
case "lightgrey":
|
|
|
|
return BlockTypes.LIGHT_GRAY_WOOL.getId();
|
|
|
|
case "lime":
|
|
|
|
return BlockTypes.LIME_WOOL.getId();
|
|
|
|
case "magenta":
|
|
|
|
return BlockTypes.MAGENTA_WOOL.getId();
|
|
|
|
case "orange":
|
|
|
|
return BlockTypes.ORANGE_WOOL.getId();
|
|
|
|
case "pink":
|
|
|
|
return BlockTypes.PINK_WOOL.getId();
|
|
|
|
case "purple":
|
|
|
|
return BlockTypes.PURPLE_WOOL.getId();
|
|
|
|
case "yellow":
|
|
|
|
return BlockTypes.YELLOW_WOOL.getId();
|
|
|
|
case "red":
|
|
|
|
return BlockTypes.RED_WOOL.getId();
|
|
|
|
default:
|
|
|
|
return string;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private BlockStateHolder parseLogic(String input, ParserContext context) throws InputParseException {
|
2018-08-12 14:03:07 +00:00
|
|
|
String[] blockAndExtraData = input.trim().split("\\|", 2);
|
2018-06-19 07:26:22 +00:00
|
|
|
blockAndExtraData[0] = woolMapper(blockAndExtraData[0]);
|
2014-04-04 00:52:53 +00:00
|
|
|
|
2018-07-23 02:48:11 +00:00
|
|
|
BlockState state = null;
|
2018-08-12 14:03:07 +00:00
|
|
|
CompoundTag nbt = null;
|
2018-06-17 07:50:04 +00:00
|
|
|
|
2018-07-23 02:48:11 +00:00
|
|
|
// Legacy matcher
|
|
|
|
if (context.isTryingLegacy()) {
|
|
|
|
try {
|
|
|
|
String[] split = blockAndExtraData[0].split(":");
|
|
|
|
if (split.length == 1) {
|
|
|
|
state = LegacyMapper.getInstance().getBlockFromLegacy(Integer.parseInt(split[0]));
|
2018-08-12 14:03:07 +00:00
|
|
|
} else if (MathMan.isInteger(split[0])) {
|
2018-07-23 02:48:11 +00:00
|
|
|
state = LegacyMapper.getInstance().getBlockFromLegacy(Integer.parseInt(split[0]), Integer.parseInt(split[1]));
|
2018-08-12 14:03:07 +00:00
|
|
|
} else {
|
|
|
|
BlockTypes type = BlockTypes.get(split[0].toLowerCase());
|
|
|
|
if (type != null) {
|
|
|
|
state = LegacyMapper.getInstance().getBlockFromLegacy(type.getLegacyCombinedId() >> 4, Integer.parseInt(split[1]));
|
|
|
|
}
|
2018-07-23 02:48:11 +00:00
|
|
|
}
|
2018-08-12 14:03:07 +00:00
|
|
|
} catch (NumberFormatException ignore) {}
|
2018-07-23 02:48:11 +00:00
|
|
|
}
|
2014-04-04 00:52:53 +00:00
|
|
|
|
2018-07-23 02:48:11 +00:00
|
|
|
if (state == null) {
|
2018-07-31 06:14:36 +00:00
|
|
|
String typeString;
|
|
|
|
String stateString = null;
|
|
|
|
int stateStart = blockAndExtraData[0].indexOf('[');
|
|
|
|
if (stateStart == -1) {
|
|
|
|
typeString = blockAndExtraData[0];
|
|
|
|
} else {
|
|
|
|
typeString = blockAndExtraData[0].substring(0, stateStart);
|
|
|
|
stateString = blockAndExtraData[0].substring(stateStart + 1, blockAndExtraData[0].length() - 1);
|
|
|
|
}
|
|
|
|
if (typeString == null || typeString.isEmpty()) {
|
2018-07-23 02:48:11 +00:00
|
|
|
throw new InputParseException("Invalid format");
|
|
|
|
}
|
2018-08-12 14:03:07 +00:00
|
|
|
// PosX
|
|
|
|
if (typeString.matches("pos[0-9]+")) {
|
|
|
|
int index = Integer.parseInt(typeString.replaceAll("[a-z]+", ""));
|
2018-07-23 02:48:11 +00:00
|
|
|
// Get the block type from the "primary position"
|
|
|
|
final World world = context.requireWorld();
|
2018-12-23 16:19:33 +00:00
|
|
|
final BlockVector3 primaryPosition;
|
2018-07-23 02:48:11 +00:00
|
|
|
try {
|
2018-08-12 14:03:07 +00:00
|
|
|
primaryPosition = context.requireSession().getRegionSelector(world).getVerticies().get(index - 1);
|
2018-07-23 02:48:11 +00:00
|
|
|
} catch (IncompleteRegionException e) {
|
|
|
|
throw new InputParseException("Your selection is not complete.");
|
|
|
|
}
|
2018-08-12 14:03:07 +00:00
|
|
|
state = world.getBlock(primaryPosition);
|
|
|
|
} else if (typeString.equalsIgnoreCase("hand")) {
|
|
|
|
// Get the block type from the item in the user's hand.
|
|
|
|
state = getBlockInHand(context.requireActor(), HandSide.MAIN_HAND);
|
|
|
|
} else if (typeString.equalsIgnoreCase("offhand")) {
|
|
|
|
// Get the block type from the item in the user's off hand.
|
|
|
|
state = getBlockInHand(context.requireActor(), HandSide.OFF_HAND);
|
|
|
|
} else if (typeString.matches("slot[0-9]+")) {
|
|
|
|
int slot = Integer.parseInt(typeString.substring(4)) - 1;
|
|
|
|
Actor actor = context.requireActor();
|
|
|
|
if (!(actor instanceof Player)) {
|
|
|
|
throw new InputParseException("The user is not a player!");
|
|
|
|
}
|
|
|
|
Player player = (Player) actor;
|
|
|
|
BlockBag bag = player.getInventoryBlockBag();
|
|
|
|
if (bag == null || !(bag instanceof SlottableBlockBag)) {
|
|
|
|
throw new InputParseException("Unsupported!");
|
|
|
|
}
|
|
|
|
SlottableBlockBag slottable = (SlottableBlockBag) bag;
|
|
|
|
BaseItem item = slottable.getItem(slot);
|
2018-07-23 02:48:11 +00:00
|
|
|
|
2018-08-12 14:03:07 +00:00
|
|
|
if (!item.getType().hasBlockType()) {
|
|
|
|
throw new InputParseException("You're not holding a block!");
|
|
|
|
}
|
|
|
|
state = item.getType().getBlockType().getDefaultState();
|
|
|
|
nbt = item.getNbtData();
|
2018-07-23 02:48:11 +00:00
|
|
|
} else {
|
2018-08-15 04:02:51 +00:00
|
|
|
BlockTypes type = BlockTypes.parse(typeString.toLowerCase());
|
2018-08-15 14:34:20 +00:00
|
|
|
if (type != null) state = type.getDefaultState();
|
2018-08-12 14:03:07 +00:00
|
|
|
if (state == null) {
|
2018-07-23 02:48:11 +00:00
|
|
|
throw new NoMatchException("Does not match a valid block type: '" + input + "'");
|
|
|
|
}
|
2014-04-04 00:52:53 +00:00
|
|
|
}
|
2018-08-12 14:03:07 +00:00
|
|
|
if (nbt == null) nbt = state.getNbtData();
|
2014-04-04 00:52:53 +00:00
|
|
|
|
2018-08-12 14:03:07 +00:00
|
|
|
if (stateString != null) {
|
2018-08-27 16:56:28 +00:00
|
|
|
state = BlockState.get(state.getBlockType(), "[" + stateString + "]", state);
|
2018-07-23 02:48:11 +00:00
|
|
|
}
|
2018-08-12 14:03:07 +00:00
|
|
|
}
|
2018-06-17 13:13:22 +00:00
|
|
|
|
2018-08-12 14:03:07 +00:00
|
|
|
if (blockAndExtraData.length > 1 && blockAndExtraData[1].startsWith("{")) {
|
|
|
|
String joined = StringMan.join(Arrays.copyOfRange(blockAndExtraData, 1, blockAndExtraData.length), "|");
|
|
|
|
try {
|
|
|
|
nbt = JSON2NBT.getTagFromJson(joined);
|
|
|
|
} catch (NBTException e) {
|
|
|
|
throw new NoMatchException(e.getMessage());
|
|
|
|
}
|
2014-04-04 00:52:53 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check if the item is allowed
|
2018-08-12 14:03:07 +00:00
|
|
|
BlockTypes blockType = state.getBlockType();
|
|
|
|
|
2018-07-01 12:03:22 +00:00
|
|
|
if (context.isRestricted()) {
|
|
|
|
Actor actor = context.requireActor();
|
2018-08-12 14:03:07 +00:00
|
|
|
if (actor != null) {
|
2018-10-02 11:32:24 +00:00
|
|
|
if (!actor.hasPermission("worldedit.anyblock") && worldEdit.getConfiguration().disallowedBlocks.contains(blockType)) {
|
2018-08-12 14:03:07 +00:00
|
|
|
throw new DisallowedUsageException("You are not allowed to use '" + input + "'");
|
|
|
|
}
|
|
|
|
if (nbt != null) {
|
|
|
|
if (!actor.hasPermission("worldedit.anyblock")) {
|
|
|
|
throw new DisallowedUsageException("You are not allowed to nbt'");
|
|
|
|
}
|
|
|
|
}
|
2018-07-01 12:03:22 +00:00
|
|
|
}
|
2014-04-04 00:52:53 +00:00
|
|
|
}
|
|
|
|
|
2018-08-12 14:03:07 +00:00
|
|
|
if (nbt != null) return new BaseBlock(state, nbt);
|
|
|
|
|
2018-06-17 13:13:22 +00:00
|
|
|
if (blockType == BlockTypes.SIGN || blockType == BlockTypes.WALL_SIGN) {
|
|
|
|
// Allow special sign text syntax
|
|
|
|
String[] text = new String[4];
|
|
|
|
text[0] = blockAndExtraData.length > 1 ? blockAndExtraData[1] : "";
|
|
|
|
text[1] = blockAndExtraData.length > 2 ? blockAndExtraData[2] : "";
|
|
|
|
text[2] = blockAndExtraData.length > 3 ? blockAndExtraData[3] : "";
|
|
|
|
text[3] = blockAndExtraData.length > 4 ? blockAndExtraData[4] : "";
|
|
|
|
return new SignBlock(state, text);
|
2018-07-19 02:55:02 +00:00
|
|
|
} else if (blockType == BlockTypes.SPAWNER) {
|
2018-06-17 13:13:22 +00:00
|
|
|
// Allow setting mob spawn type
|
|
|
|
if (blockAndExtraData.length > 1) {
|
|
|
|
String mobName = blockAndExtraData[1];
|
|
|
|
for (MobType mobType : MobType.values()) {
|
|
|
|
if (mobType.getName().toLowerCase().equals(mobName.toLowerCase())) {
|
|
|
|
mobName = mobType.getName();
|
|
|
|
break;
|
2014-04-04 00:52:53 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-21 17:22:37 +00:00
|
|
|
Platform capability = worldEdit.getPlatformManager().queryCapability(Capability.USER_COMMANDS);
|
|
|
|
if (!capability.isValidMobType(mobName)) {
|
|
|
|
final String finalMobName = mobName.toLowerCase();
|
|
|
|
throw new SuggestInputParseException("Unknown mob type '" + mobName + "'", mobName, () -> Stream.of(MobType.values())
|
|
|
|
.map(m -> m.getName().toLowerCase())
|
|
|
|
.filter(s -> s.startsWith(finalMobName))
|
|
|
|
.collect(Collectors.toList()));
|
2014-04-04 00:52:53 +00:00
|
|
|
}
|
2018-06-17 13:13:22 +00:00
|
|
|
return new MobSpawnerBlock(state, mobName);
|
|
|
|
} else {
|
|
|
|
return new MobSpawnerBlock(state, MobType.PIG.getName());
|
|
|
|
}
|
|
|
|
} else if (blockType == BlockTypes.PLAYER_HEAD || blockType == BlockTypes.PLAYER_WALL_HEAD) {
|
|
|
|
// allow setting type/player/rotation
|
|
|
|
if (blockAndExtraData.length <= 1) {
|
|
|
|
return new SkullBlock(state);
|
|
|
|
}
|
2014-04-04 00:52:53 +00:00
|
|
|
|
2018-06-17 13:13:22 +00:00
|
|
|
String type = blockAndExtraData[1];
|
2014-04-04 00:52:53 +00:00
|
|
|
|
2018-06-17 13:13:22 +00:00
|
|
|
return new SkullBlock(state, type.replace(" ", "_")); // valid MC usernames
|
|
|
|
} else {
|
2018-06-18 12:51:21 +00:00
|
|
|
return state;
|
2014-04-04 00:52:53 +00:00
|
|
|
}
|
|
|
|
}
|
2018-08-12 14:03:07 +00:00
|
|
|
}
|