import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
private void addRotationFilters(List<Predicate<Entity>> filters) {
    Selector sel = this.selector;
    // If the Z's are uncommented, don't forget to implement them
    // Optional<Double> rotMinZ = sel.get(ArgumentTypes.ROTATION.minimum().z());
    // Optional<Double> rotMaxZ = sel.get(ArgumentTypes.ROTATION.maximum().z());
    Optional<Double> rotMinX = sel.get(ArgumentTypes.ROTATION.minimum().x());
    if (rotMinX.isPresent()) {
        double rmx = rotMinX.get();
        filters.add(input -> input.getRotation().getX() >= rmx);
    }
    Optional<Double> rotMinY = sel.get(ArgumentTypes.ROTATION.minimum().y());
    if (rotMinY.isPresent()) {
        double rmy = rotMinY.get();
        filters.add(input -> input.getRotation().getY() >= rmy);
    }
    Optional<Double> rotMaxX = sel.get(ArgumentTypes.ROTATION.maximum().x());
    if (rotMaxX.isPresent()) {
        double rx = rotMaxX.get();
        filters.add(input -> input.getRotation().getX() <= rx);
    }
    Optional<Double> rotMaxY = sel.get(ArgumentTypes.ROTATION.maximum().y());
    if (rotMaxY.isPresent()) {
        double ry = rotMaxY.get();
        filters.add(input -> input.getRotation().getY() <= ry);
    }
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Nonnull
@Override
public List<String> complete(
        @Nonnull CommandSource src, CommandArgs args, CommandContext context) {
    Object state = args.getState();
    final Optional<String> nextArg = args.nextIfPresent();
    args.setState(state);
    List<String> choices = nextArg.map(Selector::complete).orElseGet(ImmutableList::of);

    if (choices.isEmpty()) {
        choices = super.complete(src, args, context);
    }

    if (choices.size() == 1) {
        currentSurvivalGame = choices.get(0);
    } else {
        currentSurvivalGame = null;
    }

    return choices;
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Override
public ParseResult<ClanPlayer> parseValue(CommandSource commandSource, String value, NormalFilledParameter parameter) {
    ClanPlayerImpl clanPlayer = null;
    if (value.startsWith("@")) {
        Set<Entity> entities = Selector.parse(value).resolve(commandSource);
        if (entities.size() > 0 && entities.toArray()[0] instanceof Player) {
            UUID uuid = ((Player) entities.toArray()[0]).getUniqueId();
            clanPlayer = ClansImpl.getInstance().getClanPlayer(uuid);
        } else {
            return ParseResult.newErrorResult("Selector produced no results");
        }

    } else {
        clanPlayer = ClansImpl.getInstance().getClanPlayer(value);
    }


    if (clanPlayer != null) {
        return ParseResult.newSuccessResult((ClanPlayer) clanPlayer);
    } else {
        UUID playerUUID = UUIDUtils.getUUID(value);
        Optional<Player> playerOp = playerUUID == null ? Optional.empty() : Sponge.getServer().getPlayer(playerUUID);
        if (playerOp.isPresent()) {
            return ParseResult.newSuccessResult(ClansImpl.getInstance().createClanPlayer(playerUUID, value));
        } else {
            return ParseResult.newErrorResult(Messages.PLAYER_DOES_NOT_EXIST);
        }
    }
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Override
public SelectorText deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
    final JsonObject obj = json.getAsJsonObject();
    final Selector selector = Selector.parse(obj.get(SELECTOR).getAsString());
    final SelectorText.Builder builder = SelectorText.builder(selector);
    deserialize(obj, builder, context);
    return builder.build();
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Override
public Selector parseRawSelector(String selector) {
    checkArgument(selector.startsWith("@"), "Invalid selector %s", selector);
    // If multi-character types are possible, this handles it
    int argListIndex = selector.indexOf('[');
    if (argListIndex < 0) {
        argListIndex = selector.length();
    } else {
        int end = selector.indexOf(']');
        checkArgument(end > argListIndex && selector.charAt(end - 1) != ',', "Invalid selector %s",
                selector);
    }
    String typeStr = selector.substring(1, argListIndex);
    Optional<SelectorType> optSelectorType = this.selectorTypeRegistry.getById(typeStr);
    checkArgument(optSelectorType.isPresent(), "No type known as '%s'", typeStr);
    try {
        Map<String, String> rawMap;
        if (argListIndex == selector.length()) {
            rawMap = ImmutableMap.of();
        } else {
            rawMap = this.parseArgumentsMap(selector.substring(argListIndex + 1, selector.length() - 1));
        }
        Map<ArgumentType<?>, Argument<?>> arguments = parseArguments(rawMap);
        return new LanternSelector(optSelectorType.get(), ImmutableMap.copyOf(arguments));
    } catch (Exception e) {
        throw new IllegalArgumentException("Invalid selector " + selector, e);
    }
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
private SelectorResolver(Collection<? extends Extent> extents, @Nullable Vector3d position, @Nullable CommandSource original, Selector selector,
        boolean force) {
    this.extents = ImmutableSet.copyOf(extents);
    this.position = position == null ? ORIGIN : position;
    this.original = Optional.ofNullable(original);
    this.selector = checkNotNull(selector);
    this.selectorFilter = makeFilter();
    this.alwaysUsePosition = force;
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
private Predicate<Entity> makeFilter() {
    // for easier reading
    final Selector sel = this.selector;
    final Vector3d position = getPositionOrDefault(this.position, ArgumentTypes.POSITION);
    final List<Predicate<Entity>> filters = new ArrayList<>();
    addTypeFilters(filters);
    addDimensionFilters(position, filters);
    addRadiusFilters(position, filters);
    addLevelFilters(filters);
    addGamemodeFilters(filters);
    addNameFilters(filters);
    addRotationFilters(filters);
    addTeamFilters(filters);
    addScoreFilters(filters);
    SelectorType selectorType = sel.getType();
    final Optional<Argument.Invertible<EntityType>> type = sel.getArgument(ArgumentTypes.ENTITY_TYPE);
    // isn't an ALL_ENTITIES selector or it is a RANDOM selector for only players
    final boolean isPlayerOnlySelector =
        selectorType == SelectorTypes.ALL_PLAYERS || selectorType == SelectorTypes.NEAREST_PLAYER
            || (selectorType == SelectorTypes.RANDOM && type.isPresent() && !type.get().isInverted()
            && type.get().getValue() != EntityTypes.PLAYER);
    if (isPlayerOnlySelector) {
        // insert at the start so it applies first
        filters.add(0, requireTypePredicate(Entity.class, Player.class));
    }
    return Functional.predicateAnd(filters);
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
private void addGamemodeFilters(List<Predicate<Entity>> filters) {
    Selector sel = this.selector;
    Optional<GameMode> gamemode = sel.get(ArgumentTypes.GAME_MODE);
    // If the game mode is NOT_SET, that means accept any
    if (gamemode.isPresent() && gamemode.get() != GameModes.NOT_SET) {
        final GameMode actualMode = gamemode.get();
        filters.add(input -> {
            Optional<GameModeData> mode = input.get(GameModeData.class);
            return mode.isPresent() && mode.get() == actualMode;
        });
    }
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
private void addNameFilters(List<Predicate<Entity>> filters) {
    Selector sel = this.selector;
    Optional<Argument.Invertible<String>> nameOpt = sel.getArgument(ArgumentTypes.NAME);
    if (nameOpt.isPresent()) {
        final String name = nameOpt.get().getValue();
        final boolean inverted = nameOpt.get().isInverted();
        filters.add(input -> {
            Optional<DisplayNameData> dispName = input.get(DisplayNameData.class);
            return inverted ^ (dispName.isPresent() && name.equals(dispName.get().displayName().get().toPlain()));
        });
    }
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
private void addRadiusFilters(final Vector3d position, List<Predicate<Entity>> filters) {
    final Selector sel = this.selector;
    Optional<Integer> radiusMin = sel.get(ArgumentTypes.RADIUS.minimum());
    Optional<Integer> radiusMax = sel.get(ArgumentTypes.RADIUS.maximum());
    if (radiusMin.isPresent()) {
        int radMin = radiusMin.get();
        int radMinSquared = radMin * radMin;
        filters.add(input -> input.getLocation().getPosition().distanceSquared(position) >= radMinSquared);
    }
    if (radiusMax.isPresent()) {
        int radMax = radiusMax.get();
        int radMaxSquared = radMax * radMax;
        filters.add(input -> input.getLocation().getPosition().distanceSquared(position) <= radMaxSquared);
    }
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
private void addTypeFilters(List<Predicate<Entity>> filters) {
    Selector sel = this.selector;
    Optional<Argument.Invertible<EntityType>> typeOpt = sel.getArgument(ArgumentTypes.ENTITY_TYPE);
    if (typeOpt.isPresent()) {
        Argument.Invertible<EntityType> typeArg = typeOpt.get();
        boolean inverted = typeArg.isInverted();
        EntityType type = typeArg.getValue();
        filters.add(input -> inverted ^ input.getType() == type);
    }
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Override
public Selector.Builder add(Argument<?>... arguments) {
    for (Argument<?> argument : checkNotNull(arguments, "arguments")) {
        checkNotNull(argument, "argument");
        this.arguments.put(argument.getType(), argument);
    }
    return this;
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Override
public Selector.Builder remove(Argument<?>... arguments) {
    for (Argument<?> argument : checkNotNull(arguments, "arguments")) {
        checkNotNull(argument, "argument");
        this.arguments.remove(argument.getType());
    }
    return this;
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@SuppressWarnings("unused")
private boolean processSelector(final CommandSource source, final String argument) throws CommandException, PluginDisableException, ServerDisableException, EMessageException {
	int start = -1;
	int cpt = -1;
	int open = 0;
	boolean type = false;
	
	for (char c : argument.toCharArray()) {
		cpt++;
		
		if (start == -1) {
			if (c != '@') continue;
			if (cpt != 0 && argument.charAt(cpt-1) != ' ') continue;
			start = cpt;
		} else if (cpt == start + 1) {
			if (this.plugin.getGame().getRegistry().getAllOf(SelectorType.class).stream().filter(t -> t.getName().equals(String.valueOf(c))).findAny().isPresent()) {
				type = true;
			} else {
				start = -1;
			}
		} else if (cpt == start + 2) {
			if (c == ' ') {
				cpt--;
				break;
			}
			if (c == '[') {
				open = 1;
			} else {
				start = -1;
				type = false;
			}
		} else {
			if (c == '[') {
				open++;
			} else if (c == ']') {
				open--;
				if (open == 0) {
					break;
				}
			}
		}
	}
	
	if (start != -1 && open == 0 && type) {
		String stringSelector = argument.substring(start, cpt+1);
		String first = (start == 0) ? "" : argument.substring(0, start);
		String last = (cpt+1 == argument.length()) ? "" : argument.substring(cpt+1, argument.length());
		
		try {
			List<Entity> players = new ArrayList<Entity>(Selector.parse(stringSelector).resolve(source));
			players.removeIf(entity -> !(entity instanceof Player));
			
			if (players.isEmpty()) return false;
			
			for (Entity player : players) {
				this.processExecute(source, first + ((Player) player).getName() + last);
			}
			return true;
		} catch (IllegalArgumentException e) {}
	}
	return false;
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Override
public Selector.Builder createBuilder() {
    return new LanternSelectorBuilder();
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
private void addScoreFilters(List<Predicate<Entity>> filters) {
    Selector sel = this.selector;
    sel.getArguments();
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
public LanternSelectorBuilder(Selector selector) {
    this.from(selector);
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Override
public Selector build() {
    checkState(this.type != null, "type is not set");
    return new LanternSelector(this.type, ImmutableMap.copyOf(this.arguments));
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Override
public Selector.Builder from(Selector selector) {
    this.type = selector.getType();
    this.arguments = Maps.newLinkedHashMap(((LanternSelector) selector).arguments);
    return this;
}
 

import org.spongepowered.api.text.selector.Selector; //导入依赖的package包/类
@Override
public Selector.Builder reset() {
    this.type = null;
    this.arguments = Maps.newLinkedHashMap();
    return this;
}