* this is meant to be a single file library that's as portable and
* easy to set up as possible for java projects that need
* pp/difficulty calculation.
*
* when running the test suite, speed is roughly equivalent to the C
* implementation, but peak memory usage is almost 80 times higher.
* if you are on a system with limited resources or you don't want
* to spend time installing and setting up java, you can use the C
* implementation which doesn't depend on any third party software.
* -----------------------------------------------------------------
* usage:
* put Koohii.java in your project's folder
* -----------------------------------------------------------------
* import java.io.BufferedReader;
* import java.io.InputStreamReader;
*
* class Example {
*
* public static void main(String[] args) throws java.io.IOException
* {
* BufferedReader stdin =
* new BufferedReader(new InputStreamReader(System.in)
* );
*
* Koohii.Map beatmap = new Koohii.Parser().map(stdin);
* Koohii.DiffCalc stars = new Koohii.DiffCalc().calc(beatmap);
* System.out.printf("%s stars\n", stars.total);
*
* Koohii.PPv2 pp = Koohii.PPv2(
* stars.aim, stars.speed, beatmap
* );
*
* System.out.printf("%s pp\n", pp.total);
* }
*
* }
* -----------------------------------------------------------------
* javac Example.java
* cat /path/to/file.osu | java Example
* -----------------------------------------------------------------
* this is free and unencumbered software released into the
* public domain.
*
* refer to the attached UNLICENSE or http://unlicense.org/
* * * @param mapstats the base beatmap stats * @param flags bitmask that specifies which stats to modify. only * the stats specified here need to be initialized in * mapstats. * @return mapstats * @see MapStats */ public static MapStats mods_apply(int mods, MapStats mapstats, int flags) { mapstats.speed = 1.0f; if ((mods & MODS_MAP_CHANGING) == 0) { return mapstats; } if ((mods & (MODS_DT | MODS_NC)) != 0) { mapstats.speed = 1.5f; } if ((mods & MODS_HT) != 0) { mapstats.speed *= 0.75f; } float od_ar_hp_multiplier = 1.0f; if ((mods & MODS_HR) != 0) { od_ar_hp_multiplier = 1.4f; } if ((mods & MODS_EZ) != 0) { od_ar_hp_multiplier *= 0.5f; } if ((flags & APPLY_AR) != 0) { mapstats.ar *= od_ar_hp_multiplier; /* convert AR into milliseconds window */ double arms = mapstats.ar < 5.0f ? AR0_MS - AR_MS_STEP1 * mapstats.ar : AR5_MS - AR_MS_STEP2 * (mapstats.ar - 5.0f); /* stats must be capped to 0-10 before HT/DT which brings them to a range of -4.42->11.08 for OD and -5->11 for AR */ arms = Math.min(AR0_MS, Math.max(AR10_MS, arms)); arms /= mapstats.speed; mapstats.ar = (float)( arms > AR5_MS ? (AR0_MS - arms) / AR_MS_STEP1 : 5.0 + (AR5_MS - arms) / AR_MS_STEP2 ); } if ((flags & APPLY_OD) != 0) { mapstats.od *= od_ar_hp_multiplier; double odms = OD0_MS - Math.ceil(OD_MS_STEP * mapstats.od); odms = Math.min(OD0_MS, Math.max(OD10_MS, odms)); odms /= mapstats.speed; mapstats.od = (float)((OD0_MS - odms) / OD_MS_STEP); } if ((flags & APPLY_CS) != 0) { if ((mods & MODS_HR) != 0) { mapstats.cs *= 1.3f; } if ((mods & MODS_EZ) != 0) { mapstats.cs *= 0.5f; } mapstats.cs = Math.min(10.0f, mapstats.cs); } if ((flags & APPLY_HP) != 0) { mapstats.hp = Math.min(10.0f, mapstats.hp * od_ar_hp_multiplier); } return mapstats; } /* ------------------------------------------------------------- */ /* difficulty calculator */ /** * arbitrary thresholds to determine when a stream is spaced * enough that it becomes hard to alternate. */ private final static double SINGLE_SPACING = 125.0; /** strain decay per interval. */ private final static double[] DECAY_BASE = { 0.3, 0.15 }; /** balances speed and aim. */ private final static double[] WEIGHT_SCALING = { 1400.0, 26.25 }; /** * max strains are weighted from highest to lowest, this is how * much the weight decays. */ private final static double DECAY_WEIGHT = 0.9; /** * strains are calculated by analyzing the map in chunks and taking * the peak strains in each chunk. this is the length of a strain * interval in milliseconds */ private final static double STRAIN_STEP = 400.0; /** non-normalized diameter where the small circle buff starts. */ private final static double CIRCLESIZE_BUFF_THRESHOLD = 30.0; /** global stars multiplier. */ private final static double STAR_SCALING_FACTOR = 0.0675; /** in osu! pixels */ private final static double PLAYFIELD_WIDTH = 512.0, PLAYFIELD_HEIGHT = 384.0; private final static Vector2 PLAYFIELD_CENTER = new Vector2( PLAYFIELD_WIDTH / 2.0, PLAYFIELD_HEIGHT / 2.0 ); /** * 50% of the difference between aim and speed is added to total * star rating to compensate for aim/speed only maps */ private final static double EXTREME_SCALING_FACTOR = 0.5; private final static double MIN_SPEED_BONUS = 75.0; private final static double MAX_SPEED_BONUS = 45.0; private final static double ANGLE_BONUS_SCALE = 90.0; private final static double AIM_TIMING_THRESHOLD = 107; private final static double SPEED_ANGLE_BONUS_BEGIN = 5 * Math.PI / 6; private final static double AIM_ANGLE_BONUS_BEGIN = Math.PI / 3; private static double d_spacing_weight(int type, double distance, double delta_time, double prev_distance, double prev_delta_time, double angle) { double strain_time = Math.max(delta_time, 50.0); double prev_strain_time = Math.max(prev_delta_time, 50.0); double angle_bonus; switch (type) { case DIFF_AIM: { double result = 0.0; if (!Double.isNaN(angle) && angle > AIM_ANGLE_BONUS_BEGIN) { angle_bonus = Math.sqrt( Math.max(prev_distance - ANGLE_BONUS_SCALE, 0.0) * Math.pow(Math.sin(angle - AIM_ANGLE_BONUS_BEGIN), 2.0) * Math.max(distance - ANGLE_BONUS_SCALE, 0.0) ); result = ( 1.5 * Math.pow(Math.max(0.0, angle_bonus), 0.99) / Math.max(AIM_TIMING_THRESHOLD, prev_strain_time) ); } double weighted_distance = Math.pow(distance, 0.99); return Math.max(result + weighted_distance / Math.max(AIM_TIMING_THRESHOLD, strain_time), weighted_distance / strain_time); } case DIFF_SPEED: { distance = Math.min(distance, SINGLE_SPACING); delta_time = Math.max(delta_time, MAX_SPEED_BONUS); double speed_bonus = 1.0; if (delta_time < MIN_SPEED_BONUS) { speed_bonus += Math.pow((MIN_SPEED_BONUS - delta_time) / 40.0, 2); } angle_bonus = 1.0; if (!Double.isNaN(angle) && angle < SPEED_ANGLE_BONUS_BEGIN) { double s = Math.sin(1.5 * (SPEED_ANGLE_BONUS_BEGIN - angle)); angle_bonus += Math.pow(s, 2) / 3.57; if (angle < Math.PI / 2.0) { angle_bonus = 1.28; if (distance < ANGLE_BONUS_SCALE && angle < Math.PI / 4.0) { angle_bonus += (1.0 - angle_bonus) * Math.min((ANGLE_BONUS_SCALE - distance) / 10.0, 1.0); } else if (distance < ANGLE_BONUS_SCALE) { angle_bonus += (1.0 - angle_bonus) * Math.min((ANGLE_BONUS_SCALE - distance) / 10.0, 1.0) * Math.sin((Math.PI / 2.0 - angle) * 4.0 / Math.PI); } } } return ( (1 + (speed_bonus - 1) * 0.75) * angle_bonus * (0.95 + speed_bonus * Math.pow(distance / SINGLE_SPACING, 3.5)) ) / strain_time; } } throw new UnsupportedOperationException( "this difficulty type does not exist" ); } /** * calculates the strain for one difficulty type and stores it in * obj. this assumes that normpos is already computed. * this also sets is_single if type is DIFF_SPEED */ private static void d_strain(int type, HitObject obj, HitObject prev, double speed_mul) { double value = 0.0; double time_elapsed = (obj.time - prev.time) / speed_mul; double decay = Math.pow(DECAY_BASE[type], time_elapsed / 1000.0); obj.delta_time = time_elapsed; /* this implementation doesn't account for sliders */ if ((obj.type & (OBJ_SLIDER | OBJ_CIRCLE)) != 0) { double distance = new Vector2(obj.normpos).sub(prev.normpos).len(); obj.d_distance = distance; if (type == DIFF_SPEED) { obj.is_single = distance > SINGLE_SPACING; } value = d_spacing_weight(type, distance, time_elapsed, prev.d_distance, prev.delta_time, obj.angle); value *= WEIGHT_SCALING[type]; } obj.strains[type] = prev.strains[type] * decay + value; } /** * difficulty calculator, can be reused in subsequent calc() calls. */ public static class DiffCalc { /** star rating. */ public double total; /** aim stars. */ public double aim; /** aim difficulty (used to calc length bonus) */ public double aim_difficulty; /** aim length bonus (unused at the moment) */ public double aim_length_bonus; /** speed stars. */ public double speed; /** speed difficulty (used to calc length bonus) */ public double speed_difficulty; /** speed length bonus (unused at the moment) */ public double speed_length_bonus; /** * number of notes that are considered singletaps by the * difficulty calculator. */ public int nsingles; /** * number of taps slower or equal to the singletap threshold * value. */ public int nsingles_threshold; /** * the beatmap we want to calculate the difficulty for. * must be set or passed to calc() explicitly. * persists across calc() calls unless it's changed or explicity * passed to calc() * @see DiffCalc#calc(Koohii.Map, int, double) * @see DiffCalc#calc(Koohii.Map, int) * @see DiffCalc#calc(Koohii.Map) */ public Map beatmap = null; private double speed_mul; private final ArrayList* Koohii.MapStats mapstats = new Koohii.MapStats(); * mapstats.ar = 9; * Koohii.mods_apply(Koohii.MODS_DT, mapstats, Koohii.APPLY_AR); * // mapstats.ar is now 10.33, mapstats.speed is 1.5 *