From ad2db98de67447dce500e2487bf1c89278221a73 Mon Sep 17 00:00:00 2001 From: Jab125 <67534807+Jab125@users.noreply.github.com> Date: Sat, 4 Jan 2025 16:42:57 +1100 Subject: [PATCH] enums part 1 --- .../legacy_tweaks/tweaks/Tweak.java | 118 ++++++++++++++++-- 1 file changed, 111 insertions(+), 7 deletions(-) diff --git a/src/main/java/xyz/violaflower/legacy_tweaks/tweaks/Tweak.java b/src/main/java/xyz/violaflower/legacy_tweaks/tweaks/Tweak.java index bf9eca92..55b1ce43 100644 --- a/src/main/java/xyz/violaflower/legacy_tweaks/tweaks/Tweak.java +++ b/src/main/java/xyz/violaflower/legacy_tweaks/tweaks/Tweak.java @@ -3,9 +3,14 @@ import net.minecraft.util.Mth; import xyz.violaflower.legacy_tweaks.LegacyTweaks; -import java.util.*; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; import java.util.function.Consumer; import java.util.function.Function; +import java.util.function.Supplier; import java.util.stream.Collectors; public abstract class Tweak implements TweakParent { @@ -157,6 +162,23 @@ public Double getMax() { }); } + public static class EnumProvider> { + private final T defaultValue; + private final Supplier values; + private EnumProvider(T defaultValue, Supplier values) { + this.defaultValue = defaultValue; + this.values = values; + } + } + + public > EnumProvider enumProvider(T defaultValue, Supplier values) { + return new EnumProvider<>(defaultValue, values); + } + + public > EnumSliderOption addSliderOption(String name, EnumProvider enumProvider) { + return new EnumSliderOption<>(name, enumProvider, ignored -> {}) {}; + } + public IntSliderOption addSliderOption(String name, int min, int max) { return add(new IntSliderOption(name, ignored -> {}) { @Override @@ -182,15 +204,20 @@ public BooleanOption(String name, Consumer onChanged) { this.value = false; } + @Override + public String format(Boolean aBoolean) { + return aBoolean == null ? null : aBoolean.toString(); + } + public boolean isOn() { return get(); } } - public abstract class SliderOption extends Option { + public abstract static class NumberSliderOption extends SliderOption { private final Function newT; - public SliderOption(String name, Function newT, Consumer onChanged) { - super(name, onChanged); + public NumberSliderOption(String name, Function newT, Consumer onChanged) { + super(name, newT, onChanged); this.newT = newT; } @@ -203,15 +230,80 @@ public double normalize() { return Mth.clampedMap(value, min, max, 0, 1); } + @Override + public double doubleValue(T value) { + return value.doubleValue(); + } + public T unNormalize(double normalise) { - // double value = get().doubleValue(); + // double value = get().doubleValue(); double min = getMin().doubleValue(); double max = getMax().doubleValue(); return newT.apply(Mth.map(normalise, 0, 1, min, max)); } } - public class DoubleSliderOption extends SliderOption { + public abstract static class SliderOption extends Option { + private final Function newT; + public SliderOption(String name, Function newT, Consumer onChanged) { + super(name, onChanged); + this.newT = newT; + } + + public abstract T getMin(); + public abstract T getMax(); + public double normalize() { + double value = doubleValue(get()); + double min = doubleValue(getMin()); + double max = doubleValue(getMax()); + return Mth.clampedMap(value, min, max, 0, 1); + } + + public abstract double doubleValue(T value); + + public T unNormalize(double normalise) { + // double value = get().doubleValue(); + double min = doubleValue(getMin()); + double max = doubleValue(getMax()); + return newT.apply(Mth.map(normalise, 0, 1, min, max)); + } + + @Override + public String format(T num) { + return num == null ? "null" : num.toString(); + } + } + + public static class EnumSliderOption> extends SliderOption { + private final EnumProvider provider; + public EnumSliderOption(String name, EnumProvider provider, Consumer onChanged) { + super(name, f -> provider.values.get()[f.intValue()], onChanged); + this.provider = provider; + this.value = this.provider.defaultValue; + } + + @Override + public T getMax() { + return provider.values.get()[provider.values.get().length-1]; + } + + @Override + public double doubleValue(T value) { + return value.ordinal(); + } + + @Override + public T getMin() { + return provider.values.get()[0]; + } + + @Override + public String format(T t) { + return t == null ? "null" : t.toString(); + } + } + + public static class DoubleSliderOption extends NumberSliderOption { public DoubleSliderOption(String name, Consumer onChanged) { super(name, f -> f, onChanged); this.value = 0D; @@ -226,9 +318,14 @@ public Double getMax() { public Double getMin() { return 0.0; } + + @Override + public String format(Double double_) { + return double_ == null ? "null" : double_.toString(); + } } - public class IntSliderOption extends SliderOption { + public static class IntSliderOption extends NumberSliderOption { public IntSliderOption(String name, Consumer onChanged) { super(name, Double::intValue, onChanged); this.value = 0; @@ -243,6 +340,11 @@ public Integer getMax() { public Integer getMin() { return 0; } + + @Override + public String format(Integer integer) { + return integer == null ? "null" : integer.toString(); + } } public abstract static class Option { @@ -268,5 +370,7 @@ public void set(T t) { public void setConsumer(Consumer onChanged) { this.onChanged = onChanged; } + + public abstract String format(T t); } }