EntitySelectorParser (forge 1.15.2-31.2.47)

java.lang.Object
- net.minecraft.command.arguments.EntitySelectorParser

public class EntitySelectorParser
extends java.lang.Object

Field Summary

Fields
Modifier and Type	Field and Description
`static java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>>`	`ARBITRARY`
`private boolean`	`checkPermission`
`private boolean`	`currentWorldOnly`
`private int`	`cursorStart`
`private MinMaxBounds.FloatBound`	`distance`
`private java.lang.Double`	`dx`
`private java.lang.Double`	`dy`
`private java.lang.Double`	`dz`
`static com.mojang.brigadier.exceptions.SimpleCommandExceptionType`	`EXPECTED_END_OF_OPTIONS`
`static com.mojang.brigadier.exceptions.DynamicCommandExceptionType`	`EXPECTED_VALUE_FOR_OPTION`
`private java.util.function.Predicate<Entity>`	`filter`
`static java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>>`	`FURTHEST`
`private boolean`	`hasAdvancements`
`private boolean`	`hasGamemodeEquals`
`private boolean`	`hasGamemodeNotEquals`
`private boolean`	`hasNameEquals`
`private boolean`	`hasNameNotEquals`
`private boolean`	`hasPermission`
`private boolean`	`hasScores`
`private boolean`	`hasTeamEquals`
`private boolean`	`hasTeamNotEquals`
`private boolean`	`includeNonPlayers`
`static com.mojang.brigadier.exceptions.SimpleCommandExceptionType`	`INVALID_ENTITY_NAME_OR_UUID`
`private boolean`	`isLimited`
`private boolean`	`isSorted`
`private MinMaxBounds.IntBound`	`level`
`private int`	`limit`
`static java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>>`	`NEAREST`
`static java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>>`	`RANDOM`
`private com.mojang.brigadier.StringReader`	`reader`
`static com.mojang.brigadier.exceptions.SimpleCommandExceptionType`	`SELECTOR_NOT_ALLOWED`
`static com.mojang.brigadier.exceptions.SimpleCommandExceptionType`	`SELECTOR_TYPE_MISSING`
`private boolean`	`self`
`private java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>>`	`sorter`
`static java.util.function.BiFunction<com.mojang.brigadier.suggestion.SuggestionsBuilder,java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder>,java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>>`	`SUGGEST_NONE`
`private java.util.function.BiFunction<com.mojang.brigadier.suggestion.SuggestionsBuilder,java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder>,java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>>`	`suggestionHandler`
`private EntityType<?>`	`type`
`private boolean`	`typeInverse`
`static com.mojang.brigadier.exceptions.DynamicCommandExceptionType`	`UNKNOWN_SELECTOR_TYPE`
`private java.lang.String`	`username`
`private java.util.UUID`	`uuid`
`private java.lang.Double`	`x`
`private MinMaxBoundsWrapped`	`xRotation`
`private java.lang.Double`	`y`
`private MinMaxBoundsWrapped`	`yRotation`
`private java.lang.Double`	`z`

Constructor Summary

Constructors
Constructor and Description
`EntitySelectorParser(com.mojang.brigadier.StringReader readerIn)`
`EntitySelectorParser(com.mojang.brigadier.StringReader readerIn, boolean hasPermissionIn)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addFilter(java.util.function.Predicate<Entity> filterIn)`
`EntitySelector`	`build()`
`private AxisAlignedBB`	`createAABB(double sizeX, double sizeY, double sizeZ)`
`private java.util.function.Predicate<Entity>`	`createRotationPredicate(MinMaxBoundsWrapped angleBounds, java.util.function.ToDoubleFunction<Entity> angleFunc)`
`private static void`	`fillSelectorSuggestions(com.mojang.brigadier.suggestion.SuggestionsBuilder suggestionBuilder)`
`java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>`	`fillSuggestions(com.mojang.brigadier.suggestion.SuggestionsBuilder builder, java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)`
`void`	`func_218114_a(EntityType<?> p_218114_1_)`
`boolean`	`func_218115_f()`
`MinMaxBounds.FloatBound`	`getDistance()`
`java.lang.Double`	`getDx()`
`java.lang.Double`	`getDy()`
`java.lang.Double`	`getDz()`
`MinMaxBounds.IntBound`	`getLevel()`
`com.mojang.brigadier.StringReader`	`getReader()`
`java.lang.Double`	`getX()`
`MinMaxBoundsWrapped`	`getXRotation()`
`java.lang.Double`	`getY()`
`MinMaxBoundsWrapped`	`getYRotation()`
`java.lang.Double`	`getZ()`
`boolean`	`hasAdvancements()`
`boolean`	`hasGamemodeEquals()`
`boolean`	`hasGamemodeNotEquals()`
`boolean`	`hasNameEquals()`
`boolean`	`hasNameNotEquals()`
`boolean`	`hasScores()`
`boolean`	`hasTeamEquals()`
`boolean`	`isCurrentEntity()`
`boolean`	`isLimited()`
`boolean`	`isSorted()`
`boolean`	`isTypeLimited()`
`boolean`	`isTypeLimitedInversely()`
`EntitySelector`	`parse()`
`void`	`parseArguments()`
`protected void`	`parseSelector()`
`protected void`	`parseSingleEntity()`
`void`	`setCurrentWorldOnly()`
`void`	`setDistance(MinMaxBounds.FloatBound distanceIn)`
`void`	`setDx(double dxIn)`
`void`	`setDy(double dyIn)`
`void`	`setDz(double dzIn)`
`void`	`setHasAdvancements(boolean value)`
`void`	`setHasGamemodeEquals(boolean value)`
`void`	`setHasGamemodeNotEquals(boolean value)`
`void`	`setHasNameEquals(boolean value)`
`void`	`setHasNameNotEquals(boolean value)`
`void`	`setHasScores(boolean value)`
`void`	`setHasTeamEquals(boolean value)`
`void`	`setHasTeamNotEquals(boolean value)`
`void`	`setIncludeNonPlayers(boolean includeNonPlayersIn)`
`void`	`setLevel(MinMaxBounds.IntBound levelIn)`
`void`	`setLimit(int limitIn)`
`void`	`setLimited(boolean value)`
`void`	`setSorted(boolean value)`
`void`	`setSorter(java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>> sorterIn)`
`void`	`setSuggestionHandler(java.util.function.BiFunction<com.mojang.brigadier.suggestion.SuggestionsBuilder,java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder>,java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>> suggestionHandlerIn)`
`void`	`setTypeLimitedInversely()`
`void`	`setX(double xIn)`
`void`	`setXRotation(MinMaxBoundsWrapped xRotationIn)`
`void`	`setY(double yIn)`
`void`	`setYRotation(MinMaxBoundsWrapped yRotationIn)`
`void`	`setZ(double zIn)`
`boolean`	`shouldInvertValue()`
`private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>`	`suggestCommaOrEnd(com.mojang.brigadier.suggestion.SuggestionsBuilder builder, java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)`
`private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>`	`suggestName(com.mojang.brigadier.suggestion.SuggestionsBuilder builder, java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)`
`private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>`	`suggestNameOrSelector(com.mojang.brigadier.suggestion.SuggestionsBuilder suggestionBuilder, java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)`
`private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>`	`suggestOpenBracket(com.mojang.brigadier.suggestion.SuggestionsBuilder builder, java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)`
`private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>`	`suggestOptions(com.mojang.brigadier.suggestion.SuggestionsBuilder builder, java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)`
`private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>`	`suggestOptionsOrEnd(com.mojang.brigadier.suggestion.SuggestionsBuilder builder, java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)`
`private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>`	`suggestSelector(com.mojang.brigadier.suggestion.SuggestionsBuilder builder, java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)`
`void`	`updateFilter()`

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

INVALID_ENTITY_NAME_OR_UUID

public static final com.mojang.brigadier.exceptions.SimpleCommandExceptionType INVALID_ENTITY_NAME_OR_UUID

UNKNOWN_SELECTOR_TYPE

public static final com.mojang.brigadier.exceptions.DynamicCommandExceptionType UNKNOWN_SELECTOR_TYPE

SELECTOR_NOT_ALLOWED

public static final com.mojang.brigadier.exceptions.SimpleCommandExceptionType SELECTOR_NOT_ALLOWED

SELECTOR_TYPE_MISSING

public static final com.mojang.brigadier.exceptions.SimpleCommandExceptionType SELECTOR_TYPE_MISSING

EXPECTED_END_OF_OPTIONS

public static final com.mojang.brigadier.exceptions.SimpleCommandExceptionType EXPECTED_END_OF_OPTIONS

EXPECTED_VALUE_FOR_OPTION

public static final com.mojang.brigadier.exceptions.DynamicCommandExceptionType EXPECTED_VALUE_FOR_OPTION

ARBITRARY

public static final java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>> ARBITRARY

NEAREST

public static final java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>> NEAREST

FURTHEST

public static final java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>> FURTHEST

RANDOM

public static final java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>> RANDOM

SUGGEST_NONE

public static final java.util.function.BiFunction<com.mojang.brigadier.suggestion.SuggestionsBuilder,java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder>,java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>> SUGGEST_NONE

reader

private final com.mojang.brigadier.StringReader reader

hasPermission
```
private final boolean hasPermission
```

limit
```
private int limit
```

includeNonPlayers
```
private boolean includeNonPlayers
```

currentWorldOnly
```
private boolean currentWorldOnly
```

distance

private MinMaxBounds.FloatBound distance

level
```
private MinMaxBounds.IntBound level
```

x
```
@Nullable
private java.lang.Double x
```

y
```
@Nullable
private java.lang.Double y
```

z
```
@Nullable
private java.lang.Double z
```

dx
```
@Nullable
private java.lang.Double dx
```

dy
```
@Nullable
private java.lang.Double dy
```

dz
```
@Nullable
private java.lang.Double dz
```

xRotation
```
private MinMaxBoundsWrapped xRotation
```

yRotation
```
private MinMaxBoundsWrapped yRotation
```

filter

private java.util.function.Predicate<Entity> filter

sorter

private java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>> sorter

self
```
private boolean self
```

username

@Nullable
private java.lang.String username

cursorStart
```
private int cursorStart
```

uuid
```
@Nullable
private java.util.UUID uuid
```

suggestionHandler

private java.util.function.BiFunction<com.mojang.brigadier.suggestion.SuggestionsBuilder,java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder>,java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>> suggestionHandler

hasNameEquals
```
private boolean hasNameEquals
```

hasNameNotEquals
```
private boolean hasNameNotEquals
```

isLimited
```
private boolean isLimited
```

isSorted
```
private boolean isSorted
```

hasGamemodeEquals
```
private boolean hasGamemodeEquals
```

hasGamemodeNotEquals
```
private boolean hasGamemodeNotEquals
```

hasTeamEquals
```
private boolean hasTeamEquals
```

hasTeamNotEquals
```
private boolean hasTeamNotEquals
```

type
```
@Nullable
private EntityType<?> type
```

typeInverse
```
private boolean typeInverse
```

hasScores
```
private boolean hasScores
```

hasAdvancements
```
private boolean hasAdvancements
```

checkPermission
```
private boolean checkPermission
```

Constructor Detail

EntitySelectorParser

public EntitySelectorParser(com.mojang.brigadier.StringReader readerIn)

EntitySelectorParser

public EntitySelectorParser(com.mojang.brigadier.StringReader readerIn,
                            boolean hasPermissionIn)

Method Detail

build
```
public EntitySelector build()
```

createAABB

private AxisAlignedBB createAABB(double sizeX,
                                 double sizeY,
                                 double sizeZ)

updateFilter
```
public void updateFilter()
```

createRotationPredicate

private java.util.function.Predicate<Entity> createRotationPredicate(MinMaxBoundsWrapped angleBounds,
                                                                     java.util.function.ToDoubleFunction<Entity> angleFunc)

parseSelector

protected void parseSelector()
                      throws com.mojang.brigadier.exceptions.CommandSyntaxException

Throws:: com.mojang.brigadier.exceptions.CommandSyntaxException

parseSingleEntity

protected void parseSingleEntity()
                          throws com.mojang.brigadier.exceptions.CommandSyntaxException

Throws:: com.mojang.brigadier.exceptions.CommandSyntaxException

parseArguments

public void parseArguments()
                    throws com.mojang.brigadier.exceptions.CommandSyntaxException

Throws:: com.mojang.brigadier.exceptions.CommandSyntaxException

shouldInvertValue
```
public boolean shouldInvertValue()
```

func_218115_f
```
public boolean func_218115_f()
```

getReader

public com.mojang.brigadier.StringReader getReader()

addFilter

public void addFilter(java.util.function.Predicate<Entity> filterIn)

setCurrentWorldOnly
```
public void setCurrentWorldOnly()
```

getDistance

public MinMaxBounds.FloatBound getDistance()

setDistance

public void setDistance(MinMaxBounds.FloatBound distanceIn)

getLevel

public MinMaxBounds.IntBound getLevel()

setLevel

public void setLevel(MinMaxBounds.IntBound levelIn)

getXRotation

public MinMaxBoundsWrapped getXRotation()

setXRotation

public void setXRotation(MinMaxBoundsWrapped xRotationIn)

getYRotation

public MinMaxBoundsWrapped getYRotation()

setYRotation

public void setYRotation(MinMaxBoundsWrapped yRotationIn)

getX

@Nullable
public java.lang.Double getX()

getY

@Nullable
public java.lang.Double getY()

getZ

@Nullable
public java.lang.Double getZ()

setX
```
public void setX(double xIn)
```

setY
```
public void setY(double yIn)
```

setZ
```
public void setZ(double zIn)
```

setDx
```
public void setDx(double dxIn)
```

setDy
```
public void setDy(double dyIn)
```

setDz
```
public void setDz(double dzIn)
```

getDx

@Nullable
public java.lang.Double getDx()

getDy

@Nullable
public java.lang.Double getDy()

getDz

@Nullable
public java.lang.Double getDz()

setLimit
```
public void setLimit(int limitIn)
```

setIncludeNonPlayers

public void setIncludeNonPlayers(boolean includeNonPlayersIn)

setSorter

public void setSorter(java.util.function.BiConsumer<Vec3d,java.util.List<? extends Entity>> sorterIn)

parse

public EntitySelector parse()
                     throws com.mojang.brigadier.exceptions.CommandSyntaxException

Throws:: com.mojang.brigadier.exceptions.CommandSyntaxException

fillSelectorSuggestions

private static void fillSelectorSuggestions(com.mojang.brigadier.suggestion.SuggestionsBuilder suggestionBuilder)

suggestNameOrSelector

private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions> suggestNameOrSelector(com.mojang.brigadier.suggestion.SuggestionsBuilder suggestionBuilder,
                                                                                                                  java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)

suggestName

private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions> suggestName(com.mojang.brigadier.suggestion.SuggestionsBuilder builder,
                                                                                                        java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)

suggestSelector

private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions> suggestSelector(com.mojang.brigadier.suggestion.SuggestionsBuilder builder,
                                                                                                            java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)

suggestOpenBracket

private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions> suggestOpenBracket(com.mojang.brigadier.suggestion.SuggestionsBuilder builder,
                                                                                                               java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)

suggestOptionsOrEnd

private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions> suggestOptionsOrEnd(com.mojang.brigadier.suggestion.SuggestionsBuilder builder,
                                                                                                                java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)

suggestOptions

private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions> suggestOptions(com.mojang.brigadier.suggestion.SuggestionsBuilder builder,
                                                                                                           java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)

suggestCommaOrEnd

private java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions> suggestCommaOrEnd(com.mojang.brigadier.suggestion.SuggestionsBuilder builder,
                                                                                                              java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)

isCurrentEntity
```
public boolean isCurrentEntity()
```

setSuggestionHandler

public void setSuggestionHandler(java.util.function.BiFunction<com.mojang.brigadier.suggestion.SuggestionsBuilder,java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder>,java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions>> suggestionHandlerIn)

fillSuggestions

public java.util.concurrent.CompletableFuture<com.mojang.brigadier.suggestion.Suggestions> fillSuggestions(com.mojang.brigadier.suggestion.SuggestionsBuilder builder,
                                                                                                           java.util.function.Consumer<com.mojang.brigadier.suggestion.SuggestionsBuilder> consumer)

hasNameEquals
```
public boolean hasNameEquals()
```

setHasNameEquals

public void setHasNameEquals(boolean value)

hasNameNotEquals
```
public boolean hasNameNotEquals()
```

setHasNameNotEquals

public void setHasNameNotEquals(boolean value)

isLimited
```
public boolean isLimited()
```

setLimited

public void setLimited(boolean value)

isSorted
```
public boolean isSorted()
```

setSorted
```
public void setSorted(boolean value)
```

hasGamemodeEquals
```
public boolean hasGamemodeEquals()
```

setHasGamemodeEquals

public void setHasGamemodeEquals(boolean value)

hasGamemodeNotEquals
```
public boolean hasGamemodeNotEquals()
```

setHasGamemodeNotEquals

public void setHasGamemodeNotEquals(boolean value)

hasTeamEquals
```
public boolean hasTeamEquals()
```

setHasTeamEquals

public void setHasTeamEquals(boolean value)

setHasTeamNotEquals

public void setHasTeamNotEquals(boolean value)

func_218114_a

public void func_218114_a(EntityType<?> p_218114_1_)

setTypeLimitedInversely
```
public void setTypeLimitedInversely()
```

isTypeLimited
```
public boolean isTypeLimited()
```

isTypeLimitedInversely

public boolean isTypeLimitedInversely()

hasScores
```
public boolean hasScores()
```

setHasScores

public void setHasScores(boolean value)

hasAdvancements
```
public boolean hasAdvancements()
```

setHasAdvancements

public void setHasAdvancements(boolean value)

Class EntitySelectorParser

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

INVALID_ENTITY_NAME_OR_UUID

UNKNOWN_SELECTOR_TYPE

SELECTOR_NOT_ALLOWED

SELECTOR_TYPE_MISSING

EXPECTED_END_OF_OPTIONS

EXPECTED_VALUE_FOR_OPTION

ARBITRARY

NEAREST

FURTHEST

RANDOM

SUGGEST_NONE

reader

hasPermission

limit

includeNonPlayers

currentWorldOnly

distance

level

x

y

z

dx

dy

dz

xRotation

yRotation

filter

sorter

self

username

cursorStart

uuid

suggestionHandler

hasNameEquals

hasNameNotEquals

isLimited

isSorted

hasGamemodeEquals

hasGamemodeNotEquals

hasTeamEquals

hasTeamNotEquals

type

typeInverse

hasScores

hasAdvancements

checkPermission

Constructor Detail

EntitySelectorParser

EntitySelectorParser

Method Detail

build

createAABB

updateFilter

createRotationPredicate

parseSelector

parseSingleEntity

parseArguments

shouldInvertValue

func_218115_f

getReader

addFilter

setCurrentWorldOnly

getDistance

setDistance

getLevel

setLevel

getXRotation

setXRotation

getYRotation

setYRotation

getX

getY

getZ

setX