288 lines
13 KiB
Java
288 lines
13 KiB
Java
|
package net.minecraft.advancements.critereon;
|
||
|
|
|
||
|
|
import com.mojang.brigadier.StringReader;
|
||
|
|
import com.mojang.brigadier.exceptions.CommandSyntaxException;
|
||
|
|
import com.mojang.brigadier.exceptions.DynamicCommandExceptionType;
|
||
|
|
import com.mojang.brigadier.exceptions.SimpleCommandExceptionType;
|
||
|
|
import com.mojang.datafixers.util.Either;
|
||
|
|
import com.mojang.serialization.Codec;
|
||
|
|
import com.mojang.serialization.codecs.RecordCodecBuilder;
|
||
|
|
import com.mojang.serialization.codecs.RecordCodecBuilder.Instance;
|
||
|
|
import io.netty.buffer.ByteBuf;
|
||
|
|
import java.util.Optional;
|
||
|
|
import java.util.function.Function;
|
||
|
|
import java.util.function.Supplier;
|
||
|
|
import net.minecraft.network.chat.Component;
|
||
|
|
import net.minecraft.network.codec.ByteBufCodecs;
|
||
|
|
import net.minecraft.network.codec.StreamCodec;
|
||
|
|
|
||
|
|
public interface MinMaxBounds<T extends Number> {
|
||
|
|
SimpleCommandExceptionType ERROR_EMPTY = new SimpleCommandExceptionType(Component.translatable("argument.range.empty"));
|
||
|
|
SimpleCommandExceptionType ERROR_SWAPPED = new SimpleCommandExceptionType(Component.translatable("argument.range.swapped"));
|
||
|
|
|
||
|
|
Optional<T> min();
|
||
|
|
|
||
|
|
Optional<T> max();
|
||
|
|
|
||
|
|
default boolean isAny() {
|
||
|
|
return this.min().isEmpty() && this.max().isEmpty();
|
||
|
|
}
|
||
|
|
|
||
|
|
default Optional<T> unwrapPoint() {
|
||
|
|
Optional<T> optional = this.min();
|
||
|
|
Optional<T> optional1 = this.max();
|
||
|
|
return optional.equals(optional1) ? optional : Optional.empty();
|
||
|
|
}
|
||
|
|
|
||
|
|
static <T extends Number, R extends MinMaxBounds<T>> Codec<R> createCodec(Codec<T> p_297837_, MinMaxBounds.BoundsFactory<T, R> p_298619_) {
|
||
|
|
Codec<R> codec = RecordCodecBuilder.create(
|
||
|
|
p_325235_ -> p_325235_.group(
|
||
|
|
p_297837_.optionalFieldOf("min").forGetter(MinMaxBounds::min), p_297837_.optionalFieldOf("max").forGetter(MinMaxBounds::max)
|
||
|
|
)
|
||
|
|
.apply(p_325235_, p_298619_::create)
|
||
|
|
);
|
||
|
|
return Codec.either(codec, p_297837_)
|
||
|
|
.xmap(
|
||
|
|
p_299505_ -> p_299505_.map(p_300863_ -> (R)p_300863_, p_300712_ -> p_298619_.create(Optional.of((T)p_300712_), Optional.of((T)p_300712_))),
|
||
|
|
p_300263_ -> {
|
||
|
|
Optional<T> optional = p_300263_.unwrapPoint();
|
||
|
|
return optional.isPresent() ? Either.right(optional.get()) : Either.left((R)p_300263_);
|
||
|
|
}
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
static <B extends ByteBuf, T extends Number, R extends MinMaxBounds<T>> StreamCodec<B, R> createStreamCodec(
|
||
|
|
final StreamCodec<B, T> p_391981_, final MinMaxBounds.BoundsFactory<T, R> p_396126_
|
||
|
|
) {
|
||
|
|
return new StreamCodec<B, R>() {
|
||
|
|
private static final int MIN_FLAG = 1;
|
||
|
|
public static final int MAX_FLAG = 2;
|
||
|
|
|
||
|
|
public R decode(B p_393437_) {
|
||
|
|
byte b0 = p_393437_.readByte();
|
||
|
|
Optional<T> optional = (b0 & 1) != 0 ? Optional.of(p_391981_.decode(p_393437_)) : Optional.empty();
|
||
|
|
Optional<T> optional1 = (b0 & 2) != 0 ? Optional.of(p_391981_.decode(p_393437_)) : Optional.empty();
|
||
|
|
return p_396126_.create(optional, optional1);
|
||
|
|
}
|
||
|
|
|
||
|
|
public void encode(B p_392435_, R p_396875_) {
|
||
|
|
Optional<T> optional = p_396875_.min();
|
||
|
|
Optional<T> optional1 = p_396875_.max();
|
||
|
|
p_392435_.writeByte((optional.isPresent() ? 1 : 0) | (optional1.isPresent() ? 2 : 0));
|
||
|
|
optional.ifPresent(p_397001_ -> p_391981_.encode(p_392435_, (T)p_397001_));
|
||
|
|
optional1.ifPresent(p_393724_ -> p_391981_.encode(p_392435_, (T)p_393724_));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
}
|
||
|
|
|
||
|
|
static <T extends Number, R extends MinMaxBounds<T>> R fromReader(
|
||
|
|
StringReader p_55314_,
|
||
|
|
MinMaxBounds.BoundsFromReaderFactory<T, R> p_55315_,
|
||
|
|
Function<String, T> p_55316_,
|
||
|
|
Supplier<DynamicCommandExceptionType> p_55317_,
|
||
|
|
Function<T, T> p_55318_
|
||
|
|
) throws CommandSyntaxException {
|
||
|
|
if (!p_55314_.canRead()) {
|
||
|
|
throw ERROR_EMPTY.createWithContext(p_55314_);
|
||
|
|
} else {
|
||
|
|
int i = p_55314_.getCursor();
|
||
|
|
|
||
|
|
try {
|
||
|
|
Optional<T> optional = readNumber(p_55314_, p_55316_, p_55317_).map(p_55318_);
|
||
|
|
Optional<T> optional1;
|
||
|
|
if (p_55314_.canRead(2) && p_55314_.peek() == '.' && p_55314_.peek(1) == '.') {
|
||
|
|
p_55314_.skip();
|
||
|
|
p_55314_.skip();
|
||
|
|
optional1 = readNumber(p_55314_, p_55316_, p_55317_).map(p_55318_);
|
||
|
|
if (optional.isEmpty() && optional1.isEmpty()) {
|
||
|
|
throw ERROR_EMPTY.createWithContext(p_55314_);
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
optional1 = optional;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (optional.isEmpty() && optional1.isEmpty()) {
|
||
|
|
throw ERROR_EMPTY.createWithContext(p_55314_);
|
||
|
|
} else {
|
||
|
|
return p_55315_.create(p_55314_, optional, optional1);
|
||
|
|
}
|
||
|
|
} catch (CommandSyntaxException commandsyntaxexception) {
|
||
|
|
p_55314_.setCursor(i);
|
||
|
|
throw new CommandSyntaxException(commandsyntaxexception.getType(), commandsyntaxexception.getRawMessage(), commandsyntaxexception.getInput(), i);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static <T extends Number> Optional<T> readNumber(StringReader p_55320_, Function<String, T> p_55321_, Supplier<DynamicCommandExceptionType> p_55322_) throws CommandSyntaxException {
|
||
|
|
int i = p_55320_.getCursor();
|
||
|
|
|
||
|
|
while (p_55320_.canRead() && isAllowedInputChat(p_55320_)) {
|
||
|
|
p_55320_.skip();
|
||
|
|
}
|
||
|
|
|
||
|
|
String s = p_55320_.getString().substring(i, p_55320_.getCursor());
|
||
|
|
if (s.isEmpty()) {
|
||
|
|
return Optional.empty();
|
||
|
|
} else {
|
||
|
|
try {
|
||
|
|
return Optional.of(p_55321_.apply(s));
|
||
|
|
} catch (NumberFormatException numberformatexception) {
|
||
|
|
throw p_55322_.get().createWithContext(p_55320_, s);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static boolean isAllowedInputChat(StringReader p_55312_) {
|
||
|
|
char c0 = p_55312_.peek();
|
||
|
|
if ((c0 < '0' || c0 > '9') && c0 != '-') {
|
||
|
|
return c0 != '.' ? false : !p_55312_.canRead(2) || p_55312_.peek(1) != '.';
|
||
|
|
} else {
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
@FunctionalInterface
|
||
|
|
public interface BoundsFactory<T extends Number, R extends MinMaxBounds<T>> {
|
||
|
|
R create(Optional<T> p_300137_, Optional<T> p_298711_);
|
||
|
|
}
|
||
|
|
|
||
|
|
@FunctionalInterface
|
||
|
|
public interface BoundsFromReaderFactory<T extends Number, R extends MinMaxBounds<T>> {
|
||
|
|
R create(StringReader p_55333_, Optional<T> p_297501_, Optional<T> p_300423_) throws CommandSyntaxException;
|
||
|
|
}
|
||
|
|
|
||
|
|
public record Doubles(Optional<Double> min, Optional<Double> max, Optional<Double> minSq, Optional<Double> maxSq)
|
||
|
|
implements MinMaxBounds<Double> {
|
||
|
|
public static final MinMaxBounds.Doubles ANY = new MinMaxBounds.Doubles(Optional.empty(), Optional.empty());
|
||
|
|
public static final Codec<MinMaxBounds.Doubles> CODEC = MinMaxBounds.<Double, Doubles>createCodec(Codec.DOUBLE, MinMaxBounds.Doubles::new);
|
||
|
|
public static final StreamCodec<ByteBuf, MinMaxBounds.Doubles> STREAM_CODEC = MinMaxBounds.<ByteBuf, Double, Doubles>createStreamCodec(ByteBufCodecs.DOUBLE, MinMaxBounds.Doubles::new);
|
||
|
|
|
||
|
|
private Doubles(Optional<Double> p_299492_, Optional<Double> p_300933_) {
|
||
|
|
this(p_299492_, p_300933_, squareOpt(p_299492_), squareOpt(p_300933_));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static MinMaxBounds.Doubles create(StringReader p_154796_, Optional<Double> p_299495_, Optional<Double> p_301206_) throws CommandSyntaxException {
|
||
|
|
if (p_299495_.isPresent() && p_301206_.isPresent() && p_299495_.get() > p_301206_.get()) {
|
||
|
|
throw ERROR_SWAPPED.createWithContext(p_154796_);
|
||
|
|
} else {
|
||
|
|
return new MinMaxBounds.Doubles(p_299495_, p_301206_);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Optional<Double> squareOpt(Optional<Double> p_299805_) {
|
||
|
|
return p_299805_.map(p_296138_ -> p_296138_ * p_296138_);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Doubles exactly(double p_154787_) {
|
||
|
|
return new MinMaxBounds.Doubles(Optional.of(p_154787_), Optional.of(p_154787_));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Doubles between(double p_154789_, double p_154790_) {
|
||
|
|
return new MinMaxBounds.Doubles(Optional.of(p_154789_), Optional.of(p_154790_));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Doubles atLeast(double p_154805_) {
|
||
|
|
return new MinMaxBounds.Doubles(Optional.of(p_154805_), Optional.empty());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Doubles atMost(double p_154809_) {
|
||
|
|
return new MinMaxBounds.Doubles(Optional.empty(), Optional.of(p_154809_));
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean matches(double p_154811_) {
|
||
|
|
return this.min.isPresent() && this.min.get() > p_154811_ ? false : this.max.isEmpty() || !(this.max.get() < p_154811_);
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean matchesSqr(double p_154813_) {
|
||
|
|
return this.minSq.isPresent() && this.minSq.get() > p_154813_ ? false : this.maxSq.isEmpty() || !(this.maxSq.get() < p_154813_);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Doubles fromReader(StringReader p_154794_) throws CommandSyntaxException {
|
||
|
|
return fromReader(p_154794_, p_154807_ -> p_154807_);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Doubles fromReader(StringReader p_154800_, Function<Double, Double> p_154801_) throws CommandSyntaxException {
|
||
|
|
return MinMaxBounds.fromReader(
|
||
|
|
p_154800_, MinMaxBounds.Doubles::create, Double::parseDouble, CommandSyntaxException.BUILT_IN_EXCEPTIONS::readerInvalidDouble, p_154801_
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public Optional<Double> min() {
|
||
|
|
return this.min;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public Optional<Double> max() {
|
||
|
|
return this.max;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
public record Ints(Optional<Integer> min, Optional<Integer> max, Optional<Long> minSq, Optional<Long> maxSq)
|
||
|
|
implements MinMaxBounds<Integer> {
|
||
|
|
public static final MinMaxBounds.Ints ANY = new MinMaxBounds.Ints(Optional.empty(), Optional.empty());
|
||
|
|
public static final Codec<MinMaxBounds.Ints> CODEC = MinMaxBounds.<Integer, Ints>createCodec(Codec.INT, MinMaxBounds.Ints::new);
|
||
|
|
public static final StreamCodec<ByteBuf, MinMaxBounds.Ints> STREAM_CODEC = MinMaxBounds.<ByteBuf, Integer, Ints>createStreamCodec(ByteBufCodecs.INT, MinMaxBounds.Ints::new);
|
||
|
|
|
||
|
|
private Ints(Optional<Integer> p_299979_, Optional<Integer> p_297344_) {
|
||
|
|
this(p_299979_, p_297344_, p_299979_.map(p_296140_ -> p_296140_.longValue() * p_296140_.longValue()), squareOpt(p_297344_));
|
||
|
|
}
|
||
|
|
|
||
|
|
private static MinMaxBounds.Ints create(StringReader p_55378_, Optional<Integer> p_297316_, Optional<Integer> p_300359_) throws CommandSyntaxException {
|
||
|
|
if (p_297316_.isPresent() && p_300359_.isPresent() && p_297316_.get() > p_300359_.get()) {
|
||
|
|
throw ERROR_SWAPPED.createWithContext(p_55378_);
|
||
|
|
} else {
|
||
|
|
return new MinMaxBounds.Ints(p_297316_, p_300359_);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
private static Optional<Long> squareOpt(Optional<Integer> p_300285_) {
|
||
|
|
return p_300285_.map(p_296139_ -> p_296139_.longValue() * p_296139_.longValue());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Ints exactly(int p_55372_) {
|
||
|
|
return new MinMaxBounds.Ints(Optional.of(p_55372_), Optional.of(p_55372_));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Ints between(int p_154815_, int p_154816_) {
|
||
|
|
return new MinMaxBounds.Ints(Optional.of(p_154815_), Optional.of(p_154816_));
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Ints atLeast(int p_55387_) {
|
||
|
|
return new MinMaxBounds.Ints(Optional.of(p_55387_), Optional.empty());
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Ints atMost(int p_154820_) {
|
||
|
|
return new MinMaxBounds.Ints(Optional.empty(), Optional.of(p_154820_));
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean matches(int p_55391_) {
|
||
|
|
return this.min.isPresent() && this.min.get() > p_55391_ ? false : this.max.isEmpty() || this.max.get() >= p_55391_;
|
||
|
|
}
|
||
|
|
|
||
|
|
public boolean matchesSqr(long p_154818_) {
|
||
|
|
return this.minSq.isPresent() && this.minSq.get() > p_154818_ ? false : this.maxSq.isEmpty() || this.maxSq.get() >= p_154818_;
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Ints fromReader(StringReader p_55376_) throws CommandSyntaxException {
|
||
|
|
return fromReader(p_55376_, p_55389_ -> p_55389_);
|
||
|
|
}
|
||
|
|
|
||
|
|
public static MinMaxBounds.Ints fromReader(StringReader p_55382_, Function<Integer, Integer> p_55383_) throws CommandSyntaxException {
|
||
|
|
return MinMaxBounds.fromReader(
|
||
|
|
p_55382_, MinMaxBounds.Ints::create, Integer::parseInt, CommandSyntaxException.BUILT_IN_EXCEPTIONS::readerInvalidInt, p_55383_
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public Optional<Integer> min() {
|
||
|
|
return this.min;
|
||
|
|
}
|
||
|
|
|
||
|
|
@Override
|
||
|
|
public Optional<Integer> max() {
|
||
|
|
return this.max;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|