package net.rustnotmc.client;

/**
 * The numbers that make our player move the way our player moves.
 *
 * The player is the vanilla one with two things changed: the crouch is a
 * little faster and the jump is a little higher. Both numbers live here so
 * that the rest of the code has one place to point at, and so that a change
 * is one line.
 *
 * They can be set from the command line:
 *
 *     -Drsx.sneakSpeed=1.6 -Drsx.jumpHeight=1.4
 *
 * A value that is set below the floor is not taken: the crouch stays at 1.5
 * blocks per second and the jump at 1.5 blocks. The defaults are the ones we
 * want, and they are not put through the floor.
 */
public final class RsxPlayerTuning {

    /** How fast the player walks, in blocks per second. The vanilla. */
    public static final float WALK_SPEED = 4.317F;

    /** How fast the player crouches, in blocks per second. */
    public static final float SNEAK_SPEED = 1.5F;

    /** How much the vanilla crouch slows the movement down. */
    public static final float VANILLA_SNEAK_FACTOR = 0.3F;

    /** How high the player jumps, in blocks. The vanilla jumps 1.25. */
    public static final float JUMP_HEIGHT = 1.35F;

    /** The crouch never goes below this, in blocks per second. */
    public static final float SNEAK_SPEED_FLOOR = 1.5F;

    /** The jump never goes below this, in blocks. */
    public static final float JUMP_HEIGHT_FLOOR = 1.5F;

    /** The jump the vanilla has, in blocks. Used to scale the jump speed. */
    private static final float VANILLA_JUMP_HEIGHT = 1.25F;

    /** The speed the vanilla jumps with. */
    private static final float VANILLA_JUMP_MOTION = 0.42F;

    private RsxPlayerTuning() {
    }

    /** The crouch speed: the setting, or the default. */
    public static float sneakSpeed() {
        return setting("rsx.sneakSpeed", SNEAK_SPEED, SNEAK_SPEED_FLOOR);
    }

    /** The jump height: the setting, or the default. */
    public static float jumpHeight() {
        return setting("rsx.jumpHeight", JUMP_HEIGHT, JUMP_HEIGHT_FLOOR);
    }

    /** The factor the crouch slows the movement down by. */
    public static float sneakFactor() {
        return sneakSpeed() / WALK_SPEED;
    }

    /**
     * How much faster our crouch is than the vanilla one.
     *
     * The vanilla already multiplied the movement by a third. We undo that
     * and put ours in its place.
     */
    public static float sneakCorrection() {
        return sneakFactor() / VANILLA_SNEAK_FACTOR;
    }

    /** The upward speed a jump of our height needs. */
    public static float jumpMotion() {
        return jumpMotion(jumpHeight());
    }

    /**
     * The upward speed a jump of that height needs.
     *
     * The vanilla jumps with 0.42 and that carries it 1.25 blocks. The height
     * grows with the square of the speed, so the speed for a height is the
     * vanilla one times the square root of the ratio.
     */
    public static float jumpMotion(float height) {
        if (height <= 0.0F) {
            return VANILLA_JUMP_MOTION;
        }
        return VANILLA_JUMP_MOTION * (float) Math.sqrt(height / VANILLA_JUMP_HEIGHT);
    }

    private static float setting(String name, float fallback, float floor) {
        String value = System.getProperty(name);
        if (value == null || value.trim().isEmpty()) {
            return fallback;
        }
        float parsed;
        try {
            parsed = Float.parseFloat(value.trim());
        } catch (NumberFormatException ignored) {
            return fallback;
        }
        if (parsed != parsed) {
            return fallback;
        }
        return parsed < floor ? floor : parsed;
    }
}