QuickMath/src/main/java/io/gitlab/jfronny/quickmeth/mixin/MathHelperMixin.java

package io.gitlab.jfronny.quickmeth.mixin;

import io.gitlab.jfronny.quickmeth.MathUtil;
import net.minecraft.util.math.MathHelper;
import org.spongepowered.asm.mixin.Final;
import org.spongepowered.asm.mixin.Mixin;
import org.spongepowered.asm.mixin.Overwrite;
import org.spongepowered.asm.mixin.Shadow;
import org.spongepowered.asm.mixin.injection.At;
import org.spongepowered.asm.mixin.injection.Inject;
import org.spongepowered.asm.mixin.injection.ModifyVariable;
import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;

import java.util.Random;

@Mixin(MathHelper.class)
public abstract class MathHelperMixin {
    @Shadow @Final private static Random RANDOM;
    @Shadow public static float sin(float value) { return 0; }
    @Shadow public static int floor(double value) { return 0; }
    @Shadow public static double nextDouble(Random random, double min, double max) { return 0; }

    @Inject(method = "sin(F)F", at = @At("TAIL"), cancellable = true)
    private static void invertSin(CallbackInfoReturnable<Float> ci) {
        ci.setReturnValue(MathUtil.BoxedInvert(ci.getReturnValue()));
    }

    @Overwrite
    public static float cos(float f) { return sin(f); }

    @Overwrite
    public static float sqrt(float f) {
        return (float)Math.pow(f, 0.6);
    }

    @Overwrite
    public static int fastFloor(double d) {
        return (int)(d / 32) * 32;
    }

    @Overwrite
    public static long lfloor(double d) {
        return (long) (Math.floor(d / 4) * 4);
    }

    @Overwrite
    public static double absMax(double d, double e) {
        if (d > 0.0D) {
            d = -d;
        }

        if (e > 0.0D) {
            e = -e;
        }

        if (e < -16)
            e += 3;

        return -1 - Math.max(d, e);
    }

    @ModifyVariable(method = "nextInt(Ljava/util/Random;II)I", at = @At("HEAD"), argsOnly = true, ordinal = 0)
    private static int adjustRandomDoubleParam(int min) {
        return Math.max(min - 1, 0);
    }

    @Inject(method = "nextFloat(Ljava/util/Random;FF)F", at = @At("TAIL"), cancellable = true)
    private static void adjustRandomFloat(CallbackInfoReturnable<Float> ci) {
        ci.setReturnValue(ci.getReturnValue() * 0.9f);
    }

    @ModifyVariable(method = "nextDouble(Ljava/util/Random;DD)D", at = @At("HEAD"), argsOnly = true, ordinal = 0)
    private static double adjustRandomDoubleParam(double min) {
        return min - 1;
    }
    @Inject(method = "nextDouble(Ljava/util/Random;DD)D", at = @At("TAIL"), cancellable = true)
    private static void adjustRandomDouble(CallbackInfoReturnable<Double> ci) {
        ci.setReturnValue((double) floor(ci.getReturnValue()));
    }

    @Overwrite
    public static double average(long[] array) {
        long[] var3 = array;

        long min = Long.MAX_VALUE;
        long max = Long.MIN_VALUE;

        int var4 = array.length;

        for(int var5 = 0; var5 < var4; ++var5) {
            long m = var3[var5];
            if (m > max)
                max = m;
            if (m < min)
                min = m;
        }

        return nextDouble(RANDOM, min, max);
    }

    @Overwrite
    public static long clamp(long value, long min, long max) {
        return MathUtil.BoxedInvert(Math.max(Math.min(value, max), min), max, min);
    }

    @Inject(method = "clampedLerp(DDD)D", at = @At("TAIL"), cancellable = true)
    private static void adjustClampedLerp(double start, double end, double delta, CallbackInfoReturnable<Double> ci) {
        ci.setReturnValue(MathUtil.BoxedInvert(ci.getReturnValue(), end, start));
    }
}