pitch shifter; lv 0 irid fix

common/src/main/java/net/lerariemann/infinity/iridescence/Iridescence.java

···
     }
 
     public static void tryBeginJourney(LivingEntity entity, int amplifier) {
-        int i = Iridescence.getAmplifierOnApply(entity, amplifier);
-        if (i >= 0) {
+        int amplifier1 = Iridescence.getAmplifierOnApply(entity, amplifier);
+        if (amplifier1 >= 0) {
             entity.addStatusEffect(new StatusEffectInstance(ModStatusEffects.IRIDESCENT_EFFECT,
-                    Iridescence.getEffectLength(amplifier), i));
+                    Iridescence.getEffectLength(amplifier1), amplifier1));
             entity.removeStatusEffect(ModStatusEffects.IRIDESCENT_COOLDOWN);
             entity.addStatusEffect(new StatusEffectInstance(ModStatusEffects.IRIDESCENT_COOLDOWN,
-                    Iridescence.getCooldownDuration(), amplifier > 0 ? 1 : 0, false, false, false));
+                    Iridescence.getCooldownDuration(), amplifier1 > 0 ? 1 : 0, false, false, false));
             if (entity instanceof ServerPlayerEntity player) {
                 player.increaseStat(ModStats.IRIDESCENCE, 1);
                 ModCriteria.IRIDESCENT.get().trigger(player);

common/src/main/java/net/lerariemann/infinity/mixin/options/SoundSystemMixin.java

···
+package net.lerariemann.infinity.mixin.options;
+
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import net.lerariemann.infinity.access.InfinityOptionsAccess;
+import net.lerariemann.infinity.options.InfinityOptions;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.sound.SoundSystem;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+
+@Mixin(SoundSystem.class)
+public class SoundSystemMixin {
+    @ModifyExpressionValue(method = "getAdjustedPitch", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/sound/SoundInstance;getPitch()F"))
+    float inj(float original) {
+        InfinityOptions options =((InfinityOptionsAccess) MinecraftClient.getInstance()).infinity$getOptions();
+        if (!options.isEmpty()) return options.getSoundPitch().apply(original);
+        return original;
+    }
+}

common/src/main/java/net/lerariemann/infinity/options/InfinityOptions.java

···
 import org.joml.Vector3f;
 
 import java.io.File;
+import java.util.function.Function;
 
-public record InfinityOptions(NbtCompound data) {
+public class InfinityOptions {
+    public NbtCompound data;
+    public PitchShifter shifter;
+
+    public InfinityOptions(NbtCompound data) {
+        this.data = data;
+        this.shifter = data.contains("pitch_shift") ? new PitchShifter(data.getCompound("pitch_shift")) : new PitchShifter();
+    }
+
+    public NbtCompound data() {
+        return data;
+    }
+
     public static InfinityOptions empty() {
         return new InfinityOptions(new NbtCompound());
     }
···
 
     public float getLunarOffset(int i) {
         return fullLunarTest("lunar_offset", i, 0.0f);
+    }
+
+    public Function<Float, Float> getSoundPitch() {
+        return shifter.applier();
     }
 
     public float getHorizonShadingRatio() {

common/src/main/java/net/lerariemann/infinity/options/PitchShifter.java

···
+package net.lerariemann.infinity.options;
+
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.nbt.NbtElement;
+
+import java.util.function.Function;
+
+public class PitchShifter {
+    Type type;
+    float value;
+
+    String getString(NbtCompound comp, String s) {
+        if (!comp.contains(s, NbtElement.STRING_TYPE)) return "empty";
+        return comp.getString(s);
+    }
+
+    float getFloat(NbtCompound comp, String s) {
+        if (!comp.contains(s, NbtElement.FLOAT_TYPE)) return 1;
+        return comp.getFloat(s);
+    }
+
+    PitchShifter(NbtCompound comp) {
+        type = decodeType(getString(comp, "type"));
+        if (type != Type.EMPTY) {
+            value = getFloat(comp, "value");
+        }
+    }
+
+    PitchShifter() {
+        type = Type.EMPTY;
+    }
+
+    Function<Float, Float> applier() {
+        return switch (type) {
+            case EMPTY -> f -> f;
+            case CONSTANT -> f -> value;
+            case ADD -> f -> f + value;
+        };
+    }
+
+    Type decodeType(String s) {
+        return switch (s) {
+            case "constant" -> Type.CONSTANT;
+            case "add" -> Type.ADD;
+            default -> Type.EMPTY;
+        };
+    }
+
+    enum Type {
+        EMPTY,
+        CONSTANT,
+        ADD
+    }
+}

common/src/main/java/net/lerariemann/infinity/options/RandomInfinityOptions.java

···
         data.putFloat("star_size_modifier", (float)(0.03*r.nextExponential()));
         data.putDouble("time_scale", timeScale(r));
         data.putDouble("mavity", mavity(r));
+        data.put("pitch_shift", pitchShift(r));
     }
 
     public static double timeScale(Random r) {
···
             res[i] = points.get(i+1) - points.get(i);
         }
         return res;
+    }
+
+    public static NbtCompound pitchShift(Random r) {
+        NbtCompound comp = new NbtCompound();
+        int i = r.nextInt(-1, 2);
+        switch (i) {
+            case -1 -> {
+                comp.putString("type", "empty");
+                return comp;
+            }
+            case 0 -> {
+                comp.putString("type", "constant");
+                comp.putFloat("value", r.nextFloat(0.5f, 2.0f));
+                return comp;
+            }
+            case 1 -> {
+                comp.putString("type", "add");
+                comp.putFloat("value", r.nextFloat(-1.0f, 1.0f));
+                return comp;
+            }
+        }
+        return comp;
     }
 }

common/src/main/resources/infinity.mixins.json

···
     "mobs.passive.TurtleEntityMixin",
     "mobs.passive.WolfEntityMixin",
     "options.DimensionTypeMixin",
+    "options.EntityMixin",
     "options.PlayerManagerMixin",
-    "options.ServerWorldMixin",
-    "options.EntityMixin"
+    "options.ServerWorldMixin"
   ],
   "client": [
     "iridescence.LivingEntityRendererMixin",
···
     "options.ClientWorldMixin",
     "options.GameRendererMixin",
     "options.MinecraftClientMixin",
+    "options.SoundSystemMixin",
     "options.WorldRendererMixin"
   ],
   "injectors": {