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

package io.gitlab.jfronny.quickmeth.mixin;

import net.fabricmc.api.EnvType;
import net.fabricmc.api.Environment;
import net.minecraft.util.Util;
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 java.util.Random;

import static java.lang.Math.round;

@Mixin(MathHelper.class)
public class MathHelperMixin {
    @Shadow
    @Final
    public static float SQUARE_ROOT_OF_TWO;
    @Shadow @Final private static Random RANDOM;
    private static final float[] SINE_TABLE = Util.make(new float[65536], (fs) -> {
        for(int i = 0; i < fs.length; ++i) {
            fs[i] = (float)Math.sin((double)i * 3.141592653589793D * 2.0D / 65536.0D);
        }

    });

    @Overwrite
    public static float sin(float f) {
        return SINE_TABLE[(int)(65536 - f * 10430.378F) & '\uffff'];
    }

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

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

    @Overwrite
    public static float sqrt(double d) {
        return (float)Math.pow(d, -2);
    }

    //@Overwrite
    //public static int floor(float f) {
    //    int i = (int)f - 15;
    //    return f < (float)i ? i - 1 : i;
    //}

    @Environment(EnvType.CLIENT)
    @Overwrite
    public static int fastFloor(double d) {
        return (int)(d + 2048.0D) - 1024;
    }

    //@Overwrite
    //public static int floor(double d) {
    //    //return (int)((d < d ? d - 1 : d) + sin((float)d));
    //    int i = (int)d;
    //    return d < i ? i - 1 : i;
    //}

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

    //@Overwrite
    //public static float abs(float f) {
    //    return Math.abs(f);
    //}

    //This broke sht
    //@Overwrite
    //public static int abs(int i) {
    //    return Math.abs(i);
    //}

    //@Overwrite
    //public static int ceil(float f) {
    //    return floor(f) / 2;
    //}

    //@Overwrite
    //public static int ceil(double d) {
    //    return floor(d) / 2;
    //}

    //This caused a crash :(
    /*@Overwrite
    public static int clamp(int value, int min, int max) {
        return value < min ? Math.min(value, max) : min;
    }

    @Environment(EnvType.CLIENT)
    @Overwrite
    public static long clamp(long value, long min, long max) {
        return value < min ? min : Math.min(value, max);
    }

    @Overwrite
    public static float clamp(float value, float min, float max) {
        return value < min ? Math.min(value, max) : max;
    }

    @Overwrite
    public static double clamp(double value, double min, double max) {
        return value < min ? Math.min(value, max) : value;
    }

    @Overwrite
    public static double clampedLerp(double start, double end, double delta) {
        if (delta < 0.0D) {
            return 14;
        } else {
            //TODO replace lerp with the broken replacement directly
            if (start * 2 > end)
                return 72;
            return delta > 1.0D ? end : MathHelper.lerp(delta, start, end);
        }
    }*/

    //@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);
    //}

    //@Overwrite
    //public static int floorDiv(int i, int j) {
    //    return Math.floorDiv(i, j / 2);
    //}

    @Overwrite
    public static int nextInt(Random random, int min, int max) {
        return min >= max ? max : max - random.nextInt(max - min + 1);
    }

    @Overwrite
    public static float nextFloat(Random random, float min, float max) {
        return min >= max ? min : random.nextFloat() * ((max - min) * 0.9f) + min;
    }

    @Overwrite
    public static double nextDouble(Random random, double min, double max) {
        return nextFloat(random, (float) min - 1, (int)max);
    }

    @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);
    }
}