ojsama.js

// this is free and unencumbered software released into the public
// domain. refer to the attached UNLICENSE or http://unlicense.org/
//
// [![Build Status](
// https://travis-ci.org/Francesco149/ojsama.svg?branch=master)](
// https://travis-ci.org/Francesco149/ojsama)
//
// pure javascript implementation of
// https://github.com/Francesco149/oppai-ng intended to be easier
// to use and set up for js developers as well as more portable
// than straight up bindings at the cost of some performance
//
// installation:
// ----------------------------------------------------------------
// since this is a single-file library, you can just drop the file
// into your project:
// ```sh
// cd my/project
// curl https://waa.ai/ojsama > ojsama.js
// ```
//
// or include it directly in a html page:
// ```html
// <script type="text/javascript" src="ojsama.min.js"></script>
// ```
//
// it's also available as a npm package:
// ```sh
// npm install ojsama
// ```
//
// you can find full documentation of the code at
// http://hnng.moe/stuff/ojsama.html or simply read ojsama.js
//
// usage (nodejs):
// ----------------------------------------------------------------
// (change ./ojsama to ojsama if you installed through npm)
//
// ```js
// var readline = require("readline");
// var osu = require("./ojsama");
//
// var parser = new osu.parser();
// readline.createInterface({
//   input: process.stdin, terminal: falsei
// })
// .on("line", parser.feed_line.bind(parser))
// .on("close", function() {
//   console.log(osu.ppv2({map: parser.map}).toString());
// });
// ```
//
// ```sh
// $ curl https://osu.ppy.sh/osu/67079 | node minexample.js
// 133.24 pp (36.23 aim, 40.61 speed, 54.42 acc)
// ```
//
// advanced usage (nodejs with acc, mods, combo...):
// ----------------------------------------------------------------
// ```js
// var readline = require("readline");
// var osu = require("./ojsama");
//
// var mods = osu.modbits.none;
// var acc_percent;
// var combo;
// var nmiss;
//
// // get mods, acc, combo, misses from command line arguments
// // format: +HDDT 95% 300x 1m
// var argv = process.argv;
//
// for (var i = 2; i < argv.length; ++i)
// {
//   if (argv[i].startsWith("+")) {
//     mods = osu.modbits.from_string(argv[i].slice(1) || "");
//   }
//
//   else if (argv[i].endsWith("%")) {
//     acc_percent = parseFloat(argv[i]);
//   }
//
//   else if (argv[i].endsWith("x")) {
//     combo = parseInt(argv[i]);
//   }
//
//   else if (argv[i].endsWith("m")) {
//     nmiss = parseInt(argv[i]);
//   }
// }
//
// var parser = new osu.parser();
// readline.createInterface({
//   input: process.stdin, terminal: false
// })
// .on("line", parser.feed_line.bind(parser))
// .on("close", function() {
//   var map = parser.map;
//   console.log(map.toString());
//
//   if (mods) {
//     console.log("+" + osu.modbits.string(mods));
//   }
//
//   var stars = new osu.diff().calc({map: map, mods: mods});
//   console.log(stars.toString());
//
//   var pp = osu.ppv2({
//     stars: stars,
//     combo: combo,
//     nmiss: nmiss,
//     acc_percent: acc_percent,
//   });
//
//   var max_combo = map.max_combo();
//   combo = combo || max_combo;
//
//   console.log(pp.computed_accuracy.toString());
//   console.log(combo + "/" + max_combo + "x");
//
//   console.log(pp.toString());
// });
// ```
//
// ```sh
// $ curl https://osu.ppy.sh/osu/67079 | node example.js
// TERRA - Tenjou no Hoshi ~Reimeiki~ [BMax] mapped by ouranhshc
//
// AR5 OD8 CS4 HP8
// 262 circles, 69 sliders, 5 spinners
// 469 max combo
//
// 4.33 stars (2.09 aim, 2.19 speed)
// 100.00% 0x100 0x50 0xmiss
// 469/469x
// 133.24 pp (36.23 aim, 40.61 speed, 54.42 acc)
//
// $ curl https://osu.ppy.sh/osu/67079 \
// | node example.js +HDDT 98% 400x 1m
// ...
// +HDDT
// 6.13 stars (2.92 aim, 3.11 speed)
// 97.92% 9x100 0x50 1xmiss
// 400/469x
// 266.01 pp (99.70 aim, 101.68 speed, 60.41 acc)
// ```
//
// usage (in the browser)
// ----------------------------------------------------------------
// ```html
// <!DOCTYPE html>
// <html>
// <head>
//   <meta charset="utf-8" />
//   <script type="text/javascript" src="ojsama.min.js"></script>
//   <script type="text/javascript">
//   function load_file()
//   {
//     var frame = document.getElementById("osufile");
//     var contents = frame.contentWindow
//       .document.body.childNodes[0].innerHTML;
//
//     var parser = new osu.parser().feed(contents);
//     console.log(parser.toString());
//
//     var str = parser.map.toString();
//     str += osu.ppv2({map: parser.map}).toString();
//
//     document.getElementById("result").innerHTML = str;
//   }
//   </script>
// </head>
// <body>
//   <iframe id="osufile" src="test.osu" onload="load_file();"
//   style="display: none;">
//   </iframe>
//   <blockquote><pre id="result">calculating...</pre></blockquote>
// </body>
// </html>
// ```
//
// (this example assumes you have a test.osu beatmap in the same
// directory)
//
// performance
// ----------------------------------------------------------------
// this is around 50-60% slower than the C implementation and uses
// ~10 times more memory.
// ```sh
// $ busybox time -v node --use_strict test.js
// ...
// User time (seconds): 16.58
// System time (seconds): 0.43
// Percent of CPU this job got: 101%
// Elapsed (wall clock) time (h:mm:ss or m:ss): 0m 16.70s
// ...
// Maximum resident set size (kbytes): 314080
// Minor (reclaiming a frame) page faults: 20928
// Voluntary context switches: 72138
// Involuntary context switches: 16689
// ```

// # code documentation

// when used outside of node, a osu namespace will be exposed
// without polluting the global scope

var osu = {};

if (typeof exports !== "undefined") {
  osu = exports;
}

(function() {

osu.VERSION_MAJOR = 2;
osu.VERSION_MINOR = 2;
osu.VERSION_PATCH = 0;

// internal utilities
// ----------------------------------------------------------------

// override console with nop when running in a browser

var log = {warn: Function.prototype};

if (typeof exports !== "undefined") {
  log = console;
}

var array_toFixed = function(arr, n) {
  var res = new Array(arr.length);
  for (var i = 0; i < res.length; ++i) {
    res[i] = arr[i].toFixed(n);
  }
  return res;
};

function isUndefined(val) {
  return typeof val === "undefined";
}

// timing point
// ----------------------------------------------------------------
// defines parameters such as timing and sampleset for an interval.
// for pp calculation we only need time and ms_per_beat
//
// it can inherit from its preceeding point by having
// change = false and setting ms_per_beat to a negative value which
// represents the bpm multiplier as ```-100 * bpm_multiplier```

function timing(values) {
  this.time = values.time || 0.0;
  this.ms_per_beat = values.ms_per_beat;
  if (this.ms_per_beat === undefined) {
    this.ms_per_beat = 600.0;
  }
  this.change = values.change;
  if (this.change === undefined) {
    this.change = true;
  }
}

timing.prototype.toString = function() {
  return "{ time: " + this.time.toFixed(2) + ", "
    + "ms_per_beat: " + this.ms_per_beat.toFixed(2) + " }";
}

// hit objects
// ----------------------------------------------------------------
// partial structure of osu! hitobjects with just enough data for
// pp calculation

// bitmask constants for object types. note that the type can
// contain other flags so you should always check type with
// ```if (type & objtypes.circle) { ... }```

var objtypes = {
  circle: 1<<0,
  slider: 1<<1,
  spinner: 1<<3,
};

// all we need from circles is their position. all positions
// stored in the objects are in playfield coordinates (512*384
// rect)

function circle(values) {
  this.pos = values.pos || [0, 0];
}

circle.prototype.toString = function() {
  return "pos: [" + array_toFixed(this.pos, 2) + "]";
};

// to calculate max combo we need to compute slider ticks
//
// the beatmap stores the distance travelled in one repetition and
// the number of repetitions. this is enough to calculate distance
// per tick using timing information and slider velocity.
//
// note that 1 repetition means no repeats (1 loop)

function slider(values) {
  this.pos = values.pos || [0, 0];
  this.distance = values.distance || 0.0;
  this.repetitions = values.repetitions || 1;
}

slider.prototype.toString = function() {
  return (
    "pos: " + array_toFixed(this.pos, 2) + ", " +
    "distance: " + this.distance.toFixed(2) + ", " +
    "repetitions: " + this.repetitions
  );
};

// generic hitobject
//
// the only common property is start time (in millisecond).
// object-specific properties are stored in data, which can be
// an instance of circle, slider, or null

function hitobject(values) {
  this.time = values.time || 0.0;
  this.type = values.type || 0;
  if (!isUndefined(values.data)) this.data = values.data;
}

hitobject.prototype.typestr = function() {
  var res = "";
  if (this.type & objtypes.circle) res += "circle | ";
  if (this.type & objtypes.slider) res += "slider | ";
  if (this.type & objtypes.spinner) res += "spinner | ";
  return res.substring(0, Math.max(0, res.length - 3));
};

hitobject.prototype.toString = function() {
  return (
    "{ time: " + this.time.toFixed(2) + ", " + 
    "type: " + this.typestr() +
    (this.data ? ", " + this.data.toString() : "") +
    " }"
  );
};

// beatmap
// ----------------------------------------------------------------

// gamemode constants

var modes = {
  std: 0,
};

// partial beatmap structure with just enough data for pp
// calculation

function beatmap() {
  this.reset();
}

beatmap.prototype.reset = function() {
  this.format_version = 1;
  this.mode = modes.std;
  this.title = this.title_unicode = "";
  this.artist = this.artist_unicode = "";
  this.creator = "";
  this.version = "";
  this.ar = undefined;
  this.cs = this.od = this.hp = 5.0;
  this.sv = this.tick_rate = 1.0;
  this.ncircles = this.nsliders = this.nspinners = 0;
  if (!this.objects) {
    this.objects = [];
  } else {
    this.objects.length = 0;
  }
  if (!this.timing_points) {
    this.timing_points = [];
  } else {
    this.timing_points.length = 0;
  }
  return this;
};

// max combo calculation
//
// this is given by ncircles + nspinners + nsliders * 2
// (heads and tails) + nsliderticks
//
// we approximate slider ticks by calculating the
// playfield pixels per beat for the current section
// and dividing the total distance travelled by
// pixels per beat. this gives us the number of beats,
// which multiplied by the tick rate gives use the
// tick count.

beatmap.prototype.max_combo = function() {
  var res = this.ncircles + this.nspinners;
  var tindex = -1;
  var tnext = Number.NEGATIVE_INFINITY;
  var px_per_beat = 0.0;

  for (var i = 0; i < this.objects.length; ++i) {
    var obj = this.objects[i];
    if (!(obj.type & objtypes.slider)) {
      continue;
    }

    // keep track of the current timing point without
    // looping through all of them for every object
    while (obj.time >= tnext) {
      ++tindex;
      if (this.timing_points.length > tindex + 1) {
        tnext = this.timing_points[tindex + 1].time;
      } else {
        tnext = Number.POSITIVE_INFINITY;
      }

      var t = this.timing_points[tindex];
      var sv_multiplier = 1.0;
      if (!t.change && t.ms_per_beat < 0) {
        sv_multiplier = -100.0 / t.ms_per_beat;
      }

      // beatmaps older than format v8 don't apply
      // the bpm multiplier to slider ticks
      if (this.format_version < 8) {
        px_per_beat = this.sv * 100.0;
      } else {
        px_per_beat = this.sv * 100.0 * sv_multiplier;
      }
    }

    var sl = obj.data;
    var num_beats = (sl.distance * sl.repetitions) / px_per_beat;

    // subtract an epsilon to prevent accidental
    // ceiling of whole values such as 2.00....1 -> 3 due
    // to rounding errors

    var ticks = Math.ceil(
      (num_beats - 0.1) / sl.repetitions
      * this.tick_rate
    );

    --ticks;
    ticks *= sl.repetitions;
    ticks += sl.repetitions + 1;

    res += Math.max(0, ticks);
  }

  return res;
};

beatmap.prototype.toString = function() {
  var res = this.artist + " - " + this.title + " [";
  if (this.title_unicode || this.artist_unicode) {
    res += "(" + this.artist_unicode + " - "
      + this.title_unicode + ")";
  }
  res += (
    this.version + "] mapped by " + this.creator + "\n"
    + "\n"
    + "AR" + parseFloat(this.ar.toFixed(2)) + " "
    + "OD" + parseFloat(this.od.toFixed(2)) + " "
    + "CS" + parseFloat(this.cs.toFixed(2)) + " "
    + "HP" + parseFloat(this.hp.toFixed(2)) + "\n"
    + this.ncircles + " circles, "
    + this.nsliders + " sliders, "
    + this.nspinners + " spinners" + "\n"
    + this.max_combo() + " max combo" + "\n"
  );
  return res;
};

// beatmap parser
// ----------------------------------------------------------------

// partial .osu file parser built around pp calculation

function parser() {
  // once you're done feeding data to the parser, you will find
  // the parsed beatmap in this object
  this.map = new beatmap();
  this.reset();
}

parser.prototype.reset = function() {
  this.map.reset();

  // parser state: number of lines fed, last touched line,
  // last touched substring and the current section name
  //
  // these can be used to debug syntax errors

  this.nline = 0;
  this.curline = "";
  this.lastpos = "";
  this.section = "";
  return this;
};

// you can feed a single line or a whole block of text which
// will be split into lines. partial lines are not allowed
//
// both feed functions return the parser instance for easy
// chaining

parser.prototype.feed_line = function(line) {
  this.curline = this.lastpos = line;
  ++this.nline;

  // comments
  if (line.startsWith(" ") || line.startsWith("_")) {
    return this;
  }

  // now that we've handled space comments we can trim space
  line = this.curline = line.trim();
  if (line.length <= 0) {
    return this;
  }

  // c++ style comments
  if (line.startsWith("//")) {
    return this;
  }

  // [SectionName]
  if (line.startsWith("[")) {
    // on old maps there's no ar and ar = od
    if (this.section == "Difficulty" && isUndefined(this.map.ar)) {
      this.map.ar = this.map.od;
    }
    this.section = line.substring(1, line.length - 1);
    return this;
  }

  if (!line) {
    return this;
  }

  switch (this.section) {
  case "Metadata": this._metadata(); break;
  case "General": this._general(); break;
  case "Difficulty": this._difficulty(); break;
  case "TimingPoints": this._timing_points(); break;
  case "HitObjects": this._objects(); break;
  default:
    var fmtpos = line.indexOf("file format v");
    if (fmtpos< 0) {
      break;
    }
    this.map.format_version = parseInt(line.substring(fmtpos + 13));
    break;
  }
  return this;
};

parser.prototype.feed = function(str) {
  var lines = lines = str.split("\n");
  for (var i = 0; i < lines.length; ++i) {
    this.feed_line(lines[i]);
  }
  return this;
};

// returns the parser state formatted into a string. useful
// for debugging syntax errors

parser.prototype.toString = function() {
  return (
    "at line " + this.nline + "\n" +
    this.curline + "\n" +
    "-> " + this.lastpos + " <-"
  );
};

// _(internal)_ parser utilities

parser.prototype._setpos = function(str) {
  this.lastpos = str.trim();
  return this.lastpos;
};

parser.prototype._warn = function() {
  log.warn.apply(null, Array.prototype.slice.call(arguments));
  log.warn(this.toString());
};

parser.prototype._property = function() {
  var s = this.curline.split(":", 2);
  s[0] = s[0] && this._setpos(s[0]);
  s[1] = s[1] && this._setpos(s[1]);
  return s;
};

// _(internal)_ line parsers for each section

parser.prototype._metadata = function() {
  var p = this._property();
  switch (p[0]) {
  case "Title":
    this.map.title = p[1];
    break;
  case "TitleUnicode":
    this.map.title_unicode = p[1];
    break;
  case "Artist":
    this.map.artist = p[1];
    break;
  case "ArtistUnicode":
    this.map.artist_unicode = p[1];
    break;
  case "Creator":
    this.map.creator = p[1];
    break;
  case "Version":
    this.map.version = p[1];
    break;
  case "BeatmapID":
    this.map.beatmapId = parseInt(p[1]);
    break;
  case "BeatmapSetID":
    this.map.beatmapsetId = parseInt(p[1]);
    break;
  }
};

parser.prototype._general = function() {
  var p = this._property();
  if (p[0] !== "Mode") {
    return;
  }
  this.map.mode = parseInt(this._setpos(p[1]));
};

parser.prototype._difficulty = function() {
  var p = this._property();
  switch (p[0]) {
  case "CircleSize":
    this.map.cs = parseFloat(this._setpos(p[1]));
    break;
  case "OverallDifficulty":
    this.map.od = parseFloat(this._setpos(p[1]));
    break;
  case "ApproachRate":
    this.map.ar = parseFloat(this._setpos(p[1]));
    break;
  case "HPDrainRate":
    this.map.hp = parseFloat(this._setpos(p[1]));
    break;
  case "SliderMultiplier":
    this.map.sv = parseFloat(this._setpos(p[1]));
    break;
  case "SliderTickRate":
    this.map.tick_rate = parseFloat(this._setpos(p[1]));
    break;
  }
};

parser.prototype._timing_points = function() {
  var s = this.curline.split(",");
  if (s.length > 8) {
    this._warn("timing point with trailing values");
  } else if (s.length < 2) {
    this._warn("ignoring malformed timing point");
    return;
  }
  var t = new timing({
    time: parseFloat(this._setpos(s[0])),
    ms_per_beat: parseFloat(this._setpos(s[1])),
  });
  if (s.length >= 7) {
    t.change = s[6].trim() !== "0";
  }
  this.map.timing_points.push(t);
};

parser.prototype._objects = function() {
  var s = this.curline.split(",");
  var d;
  if (s.length > 11) {
    this._warn("object with trailing values");
  } else if (s.length < 4) {
    this._warn("ignoring malformed hitobject");
    return;
  }
  var obj = new hitobject({
    time: parseFloat(this._setpos(s[2])),
    type: parseInt(this._setpos(s[3])),
  });
  if (isNaN(obj.time) || isNaN(obj.type)) {
    this._warn("ignoring malformed hitobject");
    return;
  }
  if ((obj.type & objtypes.circle) != 0) {
    ++this.map.ncircles;
    d = obj.data = new circle({
      pos: [
        parseFloat(this._setpos(s[0])),
        parseFloat(this._setpos(s[1])),
      ]
    });
    if (isNaN(d.pos[0]) || isNaN(d.pos[1])) {
      this._warn("ignoring malformed circle");
      return;
    }
  } else if ((obj.type & osu.objtypes.spinner) != 0) {
    ++this.map.nspinners;
  } else if ((obj.type & osu.objtypes.slider) != 0) {
    if (s.length < 8) {
      this._warn("ignoring malformed slider");
      return;
    }
    ++this.map.nsliders;
    d = obj.data = new slider({
      pos: [
        parseFloat(this._setpos(s[0])),
        parseFloat(this._setpos(s[1])),
      ],
      repetitions: parseInt(this._setpos(s[6])),
      distance: parseFloat(this._setpos(s[7])),
    });
    if (isNaN(d.pos[0]) || isNaN(d.pos[1]) ||
      isNaN(d.repetitions) || isNaN(d.distance))
    {
      this._warn("ignoring malformed slider");
      return;
    }
  }
  this.map.objects.push(obj);
}

// difficulty calculation
// ----------------------------------------------------------------

// mods bitmask constants
// NOTE: td is touch device, but it's also the value for the
// legacy no video mod

var modbits = {
  nomod: 0,
  nf: 1<<0,
  ez: 1<<1,
  td: 1<<2,
  hd: 1<<3,
  hr: 1<<4,
  dt: 1<<6,
  ht: 1<<8,
  nc: 1<<9,
  fl: 1<<10,
  so: 1<<12,
};

// construct the mods bitmask from a string such as "HDHR"

modbits.from_string = function(str) {
  var mask = 0;
  str = str.toLowerCase();
  while (str != "") {
    var nchars = 1;
    for (var property in modbits) {
      if (property.length != 2) {
        continue;
      }
      if (!modbits.hasOwnProperty(property)) {
        continue;
      }
      if (str.startsWith(property)) {
        mask |= modbits[property];
        nchars = 2;
        break;
      }
    }
    str = str.slice(nchars);
  }
  return mask;
};

// convert mods bitmask into a string, such as "HDHR"

modbits.string = function(mods) {
  var res = "";
  for (var property in modbits) {
    if (property.length != 2) {
      continue;
    }
    if (!modbits.hasOwnProperty(property)) {
      continue;
    }
    if (mods & modbits[property]) {
      res += property.toUpperCase();
    }
  }
  if (res.indexOf("DT") >= 0 && res.indexOf("NC") >= 0) {
    res = res.replace("DT", "");
  }
  return res;
};

modbits.speed_changing = modbits.dt | modbits.ht | modbits.nc;
modbits.map_changing = modbits.hr | modbits.ez | modbits.speed_changing;

// _(internal)_
// osu!standard stats constants

var OD0_MS = 80;
var OD10_MS = 20;
var AR0_MS = 1800.0;
var AR5_MS = 1200.0;
var AR10_MS = 450.0;

var OD_MS_STEP = (OD0_MS - OD10_MS) / 10.0;
var AR_MS_STEP1 = (AR0_MS - AR5_MS) / 5.0;
var AR_MS_STEP2 = (AR5_MS - AR10_MS) / 5.0;

// _(internal)_
// utility functions to apply speed and flat multipliers to
// stats where speed changes apply (ar and od)

function modify_ar(base_ar, speed_mul, multiplier) {
  var ar = base_ar;
  ar *= multiplier;

  // convert AR into milliseconds window

  var arms = (
    ar < 5.0 ?
      AR0_MS - AR_MS_STEP1 * ar
      : AR5_MS - AR_MS_STEP2 * (ar - 5.0)
  );

  // 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 /= speed_mul;

  ar = (
    arms > AR5_MS ?
      (AR0_MS - arms) / AR_MS_STEP1
      : 5.0 + (AR5_MS - arms) / AR_MS_STEP2
  );
  return ar;
}

function modify_od(base_od, speed_mul, multiplier) {
  var od = base_od;
  od *= multiplier;
  var odms = OD0_MS - Math.ceil(OD_MS_STEP * od);
  odms = Math.min(OD0_MS, Math.max(OD10_MS, odms));
  odms /= speed_mul;
  od = (OD0_MS - odms) / OD_MS_STEP;
  return od;
}

// stores osu!standard beatmap stats

function std_beatmap_stats(values) {
  this.ar = values.ar;
  this.od = values.od;
  this.hp = values.hp;
  this.cs = values.cs;
  this.speed_mul = 1.0;

  // previously calculated mod combinations are cached in a map

  this._mods_cache = {};
}

// applies difficulty modifiers to a map's ar, od, cs, hp and
// returns the modified stats and the speed multiplier.
//
// unspecified stats are ignored and not returned

std_beatmap_stats.prototype.with_mods = function(mods) {
  if (this._mods_cache[mods]) {
    return this._mods_cache[mods];
  }
  var stats = this._mods_cache[mods] = new std_beatmap_stats(this);
  if (!(mods & modbits.map_changing)) {
    return stats;
  }
  if (mods & (modbits.dt|modbits.nc)) {
    stats.speed_mul = 1.5;
  }
  if (mods & modbits.ht) {
    stats.speed_mul *= 0.75;
  }

  var od_ar_hp_multiplier = 1.0;
  if (mods & modbits.hr) od_ar_hp_multiplier = 1.4;
  if (mods & modbits.ez) od_ar_hp_multiplier *= 0.5;
  if (stats.ar) {
    stats.ar = modify_ar(stats.ar, stats.speed_mul, od_ar_hp_multiplier);
  }
  if (stats.od) {
    stats.od = modify_od(stats.od, stats.speed_mul, od_ar_hp_multiplier);
  }

  if (stats.cs) {
    if (mods & modbits.hr) stats.cs *= 1.3;
    if (mods & modbits.ez) stats.cs *= 0.5;
    stats.cs = Math.min(10.0, stats.cs);
  }
  if (stats.hp) {
    stats.hp *= od_ar_hp_multiplier;
    stats.hp = Math.min(10.0, stats.hp);
  }
  return stats;
};

// osu! standard hit object with difficulty calculation values
// obj is the underlying hitobject

function std_diff_hitobject(obj) {
  this.obj = obj;
  this.reset();
}

std_diff_hitobject.prototype.reset = function() {
  this.strains = [ 0.0, 0.0 ];
  this.normpos = [ 0.0, 0.0 ];
  this.angle = 0.0;
  this.is_single = false;
  this.delta_time = 0.0;
  this.d_distance = 0.0;
  return this;
};

std_diff_hitobject.prototype.toString = function() {
  return (
    "{ strains: [" + array_toFixed(this.strains, 2)
    + "], normpos: [" + array_toFixed(this.normpos, 2)
    + "], is_single: " + this.is_single + " }"
  );
};

// _(internal)_
// 2D point operations

function vec_sub(a, b) { return [a[0] - b[0], a[1] - b[1]]; }
function vec_mul(a, b) { return [a[0] * b[0], a[1] * b[1]]; }
function vec_len(v) { return Math.sqrt(v[0] * v[0] + v[1] * v[1]); }
function vec_dot(a, b) { return a[0] * b[0] + a[1] * b[1]; }

// _(internal)_
// difficulty calculation constants

var DIFF_SPEED = 0;
var DIFF_AIM = 1;
var SINGLE_SPACING = 125.0;
var DECAY_BASE = [ 0.3, 0.15 ];
var WEIGHT_SCALING = [ 1400.0, 26.25 ];
var DECAY_WEIGHT = 0.9;
var STRAIN_STEP = 400.0;
var CIRCLESIZE_BUFF_THRESHOLD = 30.0;
var STAR_SCALING_FACTOR = 0.0675;
var PLAYFIELD_SIZE = [512.0, 384.0];
var PLAYFIELD_CENTER = vec_mul(PLAYFIELD_SIZE, [0.5, 0.5]);
var EXTREME_SCALING_FACTOR = 0.5;

// osu!standard difficulty calculator
//
// does not account for sliders because slider calculations are
// expensive and not worth the small accuracy increase

function std_diff() {
  this.objects = [];
  this.reset();

  // make some parameters persist so they can be
  // re-used in subsequent calls if no new value is specified

  this.map = undefined;
  this.mods = modbits.nomod;
  this.singletap_threshold = 125.0;
}

std_diff.prototype.reset = function() {
  // star rating

  this.total = 0.0;
  this.aim = 0.0;
  this.aim_difficulty = 0.0;
  this.aim_length_bonus = 0.0;
  this.speed = 0.0;
  this.speed_difficulty = 0.0;
  this.speed_length_bonus = 0.0;

  // number of notes that are seen as singletaps by the
  // difficulty calculator

  this.nsingles = 0;

  // number of notes that are faster than the interval given
  // in calc(). these singletap statistic are not required in
  // star rating, but they are a free byproduct of the
  // calculation which could be useful

  this.nsingles_threshold = 0;
};

std_diff.prototype._length_bonus = function(stars, difficulty) {
  return 0.32 + 0.5 * (Math.log10(difficulty + stars) - Math.log10(stars));
};

// calculate difficulty and return current instance, which
// contains the results
//
// params:
// * map: the beatmap we want to calculate difficulty for. if
//   unspecified, it will default to the last map used
//   in previous calls.
// * mods: mods bitmask, defaults to modbits.nomod
// * singletap_threshold: interval threshold in milliseconds
//   for singletaps. defaults to 240 bpm 1/2 singletaps
//   ```(60000 / 240) / 2``` .
//   see nsingles_threshold

std_diff.prototype.calc = function(params) {
  var map = this.map = params.map || this.map;
  if (!map) {
    throw new TypeError("no map given");
  }

  var mods = this.mods = params.mods || this.mods;
  var singletap_threshold = this.singletap_threshold
    = params.singletap_threshold || singletap_threshold;

  // apply mods to the beatmap's stats

  var stats = new std_beatmap_stats({cs: map.cs}).with_mods(mods);
  var speed_mul = stats.speed_mul;
  this._init_objects(this.objects, map, stats.cs);

  var speed = this._calc_individual(DIFF_SPEED, this.objects, speed_mul);
  this.speed = speed.difficulty;
  this.speed_difficulty = speed.total;

  var aim = this._calc_individual(DIFF_AIM, this.objects, speed_mul);
  this.aim = aim.difficulty;
  this.aim_difficulty = aim.total;

  this.aim_length_bonus = this._length_bonus(this.aim, this.aim_difficulty);
  this.speed_length_bonus = this._length_bonus(this.speed,
    this.speed_difficulty);
  this.aim = Math.sqrt(this.aim) * STAR_SCALING_FACTOR;
  this.speed = Math.sqrt(this.speed) * STAR_SCALING_FACTOR;

  if (mods & modbits.td) {
    this.aim = Math.pow(this.aim, 0.8);
  }

  // total stars mixes speed and aim in such a way that
  // heavily aim or speed focused maps get a bonus

  this.total = (
    this.aim + this.speed + Math.abs(this.speed - this.aim) *
    EXTREME_SCALING_FACTOR
  );

  // singletap stats

  this.nsingles = 0;
  this.nsingles_threshold = 0;

  for (var i = 1; i < this.objects.length; ++i) {
    var obj = this.objects[i].obj;
    var prev = this.objects[i - 1].obj;
    if (this.objects[i].is_single) {
      ++this.nsingles;
    }
    if (!(obj.type & (objtypes.circle|objtypes.slider))) {
      continue;
    }
    var interval = (obj.time - prev.time) / speed_mul;
    if (interval >= singletap_threshold) {
      ++this.nsingles_threshold;
    }
  }
  return this;
};

std_diff.prototype.toString = function() {
  return (
    this.total.toFixed(2) + " stars (" + this.aim.toFixed(2) +
    " aim, " + this.speed.toFixed(2) + " speed)"
  );
};

// _(internal)_
// calculate spacing weight for a difficulty type

// ~200BPM 1/4 streams
var MIN_SPEED_BONUS = 75.0;

// ~330BPM 1/4 streams
var MAX_SPEED_BONUS = 45.0;

var ANGLE_BONUS_SCALE = 90;
var AIM_TIMING_THRESHOLD = 107;
var SPEED_ANGLE_BONUS_BEGIN = 5 * Math.PI / 6;
var AIM_ANGLE_BONUS_BEGIN = Math.PI / 3;

std_diff.prototype._spacing_weight = function(type, distance, delta_time,
  prev_distance, prev_delta_time, angle)
{
  var angle_bonus;
  var strain_time = Math.max(delta_time, 50.0);
  switch (type) {
    case DIFF_AIM: {
      var prev_strain_time = Math.max(prev_delta_time, 50.0);
      var result = 0.0;
      if (angle !== null && 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);
      }
      var 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);
      var 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 (angle !== null && angle < SPEED_ANGLE_BONUS_BEGIN) {
        var 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 {
    name: "NotImplementedError",
    message: "this difficulty type does not exist"
  };
};

// _(internal)_
// calculate a single strain and store it in the diffobj

std_diff.prototype._calc_strain = function(type, diffobj, prev_diffobj,
  speed_mul)
{
  var obj = diffobj.obj;
  var prev_obj = prev_diffobj.obj;

  var value = 0.0;
  var time_elapsed = (obj.time - prev_obj.time) / speed_mul;
  var decay = Math.pow(DECAY_BASE[type],
    time_elapsed / 1000.0);

  diffobj.delta_time = time_elapsed;

  if ((obj.type & (objtypes.slider|objtypes.circle)) != 0) {
    var distance = vec_len(vec_sub(diffobj.normpos, prev_diffobj.normpos));
    diffobj.d_distance = distance;
    if (type == DIFF_SPEED) {
      diffobj.is_single = distance > SINGLE_SPACING;
    }
    value = this._spacing_weight(type, distance, time_elapsed,
      prev_diffobj.d_distance, prev_diffobj.delta_time, diffobj.angle);
    value *= WEIGHT_SCALING[type];
  }

  diffobj.strains[type] = prev_diffobj.strains[type] * decay + value;
};

// _(internal)_
// calculate a specific type of difficulty
//
// the map is analyzed in chunks of STRAIN_STEP duration.
// for each chunk the highest hitobject strains are added to
// a list which is then collapsed into a weighted sum, much
// like scores are weighted on a user's profile.
//
// for subsequent chunks, the initial max strain is calculated
// by decaying the previous hitobject's strain until the
// beginning of the new chunk
//
// the first object doesn't generate a strain
// so we begin with an incremented interval end
//
// also don't forget to manually add the peak strain for the last
// section which would otherwise be ignored

std_diff.prototype._calc_individual = function(type, diffobjs, speed_mul) {
  var strains = [];
  var strain_step = STRAIN_STEP * speed_mul;
  var interval_end = (
    Math.ceil(diffobjs[0].obj.time / strain_step) * strain_step
  );
  var max_strain = 0.0;
  var i;

  for (i = 0; i < diffobjs.length; ++i) {
    if (i > 0) {
      this._calc_strain(type, diffobjs[i], diffobjs[i - 1],
        speed_mul);
    }
    while (diffobjs[i].obj.time > interval_end) {
      strains.push(max_strain);
      if (i > 0) {
        var decay = Math.pow(DECAY_BASE[type],
          (interval_end - diffobjs[i - 1].obj.time) / 1000.0);
        max_strain = diffobjs[i - 1].strains[type] * decay;
      } else {
        max_strain = 0.0;
      }
      interval_end += strain_step;
    }
    max_strain = Math.max(max_strain, diffobjs[i].strains[type]);
  }

  strains.push(max_strain);

  var weight = 1.0;
  var total = 0.0;
  var difficulty = 0.0;

  strains.sort(function (a, b) { return b - a; });

  for (i = 0; i < strains.length; ++i) {
    total += Math.pow(strains[i], 1.2);
    difficulty += strains[i] * weight;
    weight *= DECAY_WEIGHT;
  }

  return {difficulty: difficulty, total: total};
};

// _(internal)_
// positions are normalized on circle radius so that we can
// calc as if everything was the same circlesize.
//
// this creates a scaling vector that normalizes positions

std_diff.prototype._normalizer_vector = function(circlesize) {
  var radius = (PLAYFIELD_SIZE[0] / 16.0)
    * (1.0 - 0.7 * (circlesize - 5.0) / 5.0);
  var scaling_factor = 52.0 / radius;

  // high circlesize (small circles) bonus

  if (radius < CIRCLESIZE_BUFF_THRESHOLD) {
    scaling_factor *= 1.0
      + Math.min(CIRCLESIZE_BUFF_THRESHOLD - radius, 5.0) / 50.0;
  }
  return [scaling_factor, scaling_factor];
}

// _(internal)_
// initialize diffobjs (or reset if already initialized) and
// populate it with the normalized position of the map's
// objects

std_diff.prototype._init_objects = function(diffobjs, map,
  circlesize)
{
  if (diffobjs.length != map.objects.length) {
    diffobjs.length = map.objects.length;
  }

  var scaling_vec = this._normalizer_vector(circlesize);
  var normalized_center = vec_mul(PLAYFIELD_CENTER, scaling_vec);

  for (var i = 0; i < diffobjs.length; ++i) {
    if (!diffobjs[i]) {
      diffobjs[i] = new std_diff_hitobject(map.objects[i]);
    } else {
      diffobjs[i].reset();
    }

    var pos;
    var obj = diffobjs[i].obj;
    if (obj.type & objtypes.spinner) {
      diffobjs[i].normpos = normalized_center.slice();
    } else if (obj.type & (objtypes.slider|objtypes.circle)) {
      diffobjs[i].normpos = vec_mul(obj.data.pos, scaling_vec);
    }
    if (i >= 2) {
      var prev1 = diffobjs[i - 1];
      var prev2 = diffobjs[i - 2];
      var v1 = vec_sub(prev2.normpos, prev1.normpos);
      var v2 = vec_sub(diffobjs[i].normpos, prev1.normpos);
      var dot = vec_dot(v1, v2);
      var det = v1[0] * v2[1] - v1[1] * v2[0];
      diffobjs[i].angle = Math.abs(Math.atan2(det, dot));
    } else {
      diffobjs[i].angle = null;
    }
  }
};

// generic difficulty calculator that creates and uses
// mode-specific calculators based on the map's mode field

function diff() {
  // calculators for different modes are cached for reuse within
  // this instance

  this.calculators = [];
  this.map = undefined;
}

// figures out what difficulty calculator to use based on the
// beatmap's gamemode and calls it with params
//
// if no map is specified in params, the last map used in
// previous calls will be used. this simplifies subsequent
// calls for the same beatmap
//
// see gamemode-specific calculators above for params
//
// returns the chosen gamemode-specific difficulty calculator

diff.prototype.calc = function(params) {
  var calculator;
  var map = this.map = params.map || this.map;
  if (!map) {
    throw new TypeError("no map given");
  }
  if (!this.calculators[map.mode]) {
    switch (map.mode) {
      case modes.std:
        calculator = new std_diff();
        break;
      default:
        throw {
          name: "NotImplementedError",
          message: "this gamemode is not yet supported"
        };
    }
    this.calculators[map.mode] = calculator;
  } else {
    calculator = this.calculators[map.mode];
  }
  return calculator.calc(params);
};

// pp calculation
// ----------------------------------------------------------------

// osu!standard accuracy calculator
//
// if percent and nobjects are specified, n300, n100 and n50 will
// be automatically calculated to be the closest to the given
// acc percent

function std_accuracy(values) {
  this.nmiss = values.nmiss || 0;

  if (values.n300 === undefined) {
    this.n300 = -1;
  } else {
    this.n300 = values.n300;
  }

  this.n100 = values.n100 || 0;
  this.n50 = values.n50 || 0;

  var nobjects;

  if (values.nobjects) {
    var n300 = this.n300;
    nobjects = values.nobjects;
    var hitcount;

    if (n300 < 0) {
      n300 = Math.max(0, nobjects - this.n100 - this.n50 - this.nmiss);
    }

    hitcount = n300 + this.n100 + this.n50 + this.nmiss;

    if (hitcount > nobjects) {
      n300 -= Math.min(n300, hitcount - nobjects);
    }

    hitcount = n300 + this.n100 + this.n50 + this.nmiss;

    if (hitcount > nobjects) {
      this.n100 -= Math.min(this.n100, hitcount - nobjects);
    }

    hitcount = n300 + this.n100 + this.n50 + this.nmiss;

    if (hitcount > nobjects) {
      this.n50 -= Math.min(this.n50, hitcount - nobjects);
    }

    hitcount = n300 + this.n100 + this.n50 + this.nmiss;

    if (hitcount > nobjects) {
      this.nmiss -= Math.min(this.nmiss, hitcount - nobjects);
    }

    this.n300 = nobjects - this.n100 - this.n50 - this.nmiss;
  }

  if (values.percent !== undefined) {
    nobjects = values.nobjects;
    if (nobjects === undefined) {
      throw new TypeError("nobjects is required when specifying percent");
    }

    var max300 = nobjects - this.nmiss;

    var maxacc = new std_accuracy({
      n300: max300, n100: 0, n50: 0, nmiss: this.nmiss
    }).value() * 100.0;

    var acc_percent = values.percent;
    acc_percent = Math.max(0.0, Math.min(maxacc, acc_percent));

    // just some black magic maths from wolfram alpha

    this.n100 = Math.round(
      -3.0 * ((acc_percent * 0.01 - 1.0) * nobjects + this.nmiss) * 0.5
    );

    if (this.n100 > max300) {
      // acc lower than all 100s, use 50s
      this.n100 = 0;
      this.n50 = Math.round(
        -6.0 * ((acc_percent * 0.01 - 1.0) * nobjects + this.nmiss) * 0.5
      );
      this.n50 = Math.min(max300, this.n50);
    }

    this.n300 = nobjects - this.n100 - this.n50 - this.nmiss;
  }
}

// computes the accuracy value (0.0-1.0)
//
// if n300 was specified in the constructor, nobjects is not
// required and will be automatically computed

std_accuracy.prototype.value = function(nobjects) {
  var n300 = this.n300;
  if (n300 < 0) {
    if (!nobjects) {
      throw new TypeError("either n300 or nobjects must be specified");
    }
    n300 = nobjects - this.n100 - this.n50 - this.nmiss;
  } else {
    nobjects = n300 + this.n100 + this.n50 + this.nmiss;
  }
  var res = (
    (n300 * 300.0 + this.n100 * 100.0 + this.n50 * 50.0) /
    (nobjects * 300.0)
  );
  return Math.max(0, Math.min(res, 1.0));
};

std_accuracy.prototype.toString = function() {
  return (
    (this.value() * 100.0).toFixed(2) + "% "
    + this.n100 + "x100 " + this.n50 + "x50 "
    + this.nmiss + "xmiss"
  );
}

// osu! standard ppv2 calculator

function std_ppv2() {
  this.aim = 0.0;
  this.speed = 0.0;
  this.acc = 0.0;

  // accuracy used in the last calc() call

  this.computed_accuracy = undefined;
}

// metaparams:
// map, stars, acc_percent
//
// params:
// aim_stars, speed_stars, max_combo, nsliders, ncircles,
// nobjects, base_ar = 5, base_od = 5, mode = modes.std,
// mods = modbits.nomod, combo = max_combo - nmiss,
// n300 = nobjects - n100 - n50 - nmiss, n100 = 0, n50 = 0,
// nmiss = 0, score_version = 1
//
// if stars is defined, map and mods are obtained from stars as
// well as aim_stars and speed_stars
//
// if map is defined, max_combo, nsliders, ncircles, nobjects,
// base_ar, base_od will be obtained from this beatmap
//
// if map is defined and stars is not defined, a new difficulty
// calculator will be created on the fly to compute stars for map
//
// if acc_percent is defined, n300, n100, n50 will be automatically
// calculated to be as close as possible to this value

std_ppv2.prototype.calc = function(params) {
  // parameters handling

  var stars = params.stars;
  var map = params.map;
  var max_combo, nsliders, ncircles, nobjects, base_ar, base_od;
  var mods;
  var aim_stars, speed_stars;

  if (stars) {
    map = stars.map;
  }

  if (map) {
    max_combo = map.max_combo();
    nsliders = map.nsliders;
    ncircles = map.ncircles;
    nobjects = map.objects.length;
    base_ar = map.ar;
    base_od = map.od;

    if (!stars) {
      stars = new std_diff().calc(params);
    }
  } else {
    max_combo = params.max_combo;
    if (!max_combo || max_combo < 0) {
      throw new TypeError("max_combo must be > 0");
    }

    nsliders = params.nsliders;
    ncircles = params.ncircles;
    nobjects = params.nobjects;
    if ([nsliders, ncircles, nobjects].some(isNaN)) {
      throw new TypeError(
        "nsliders, ncircles, nobjects are required (must be numbers) "
      );
    }
    if (nobjects < nsliders + ncircles) {
      throw new TypeError(
        "nobjects must be >= nsliders + ncircles"
      );
    }

    base_ar = params.base_ar;
    if (isUndefined(base_ar)) base_ar = 5;
    base_od = params.base_od;
    if (isUndefined(base_od)) base_od = 5;
  }

  if (stars) {
    mods = stars.mods;
    aim_stars = stars.aim;
    speed_stars = stars.speed;
  } else {
    mods = params.mods || modbits.nomod;
    aim_stars = params.aim_stars;
    speed_stars = params.speed_stars;
  }

  if ([aim_stars, speed_stars].some(isNaN)) {
    throw new TypeError("aim and speed stars required (must be numbers)");
  }

  var nmiss = params.nmiss || 0;
  var n50 = params.n50 || 0;
  var n100 = params.n100 || 0;

  var n300 = params.n300;
  if (n300 === undefined) {
    n300 = nobjects - n100 - n50 - nmiss;
  }

  var combo = params.combo;
  if (combo === undefined) {
    combo = max_combo - nmiss;
  }

  var score_version = params.score_version || 1;

  // common values used in all pp calculations

  var nobjects_over_2k = nobjects / 2000.0;
  var length_bonus = 0.95 + 0.4 * Math.min(1.0, nobjects_over_2k);

  if (nobjects > 2000) {
    length_bonus += Math.log10(nobjects_over_2k) * 0.5;
  }

  var combo_break = Math.pow(combo, 0.8) / Math.pow(max_combo, 0.8);
  var mapstats = (
    new std_beatmap_stats({ar: base_ar, od: base_od}).with_mods(mods)
  );

  this.computed_accuracy = new std_accuracy({
    percent: params.acc_percent,
    nobjects: nobjects,
    n300: n300, n100: n100, n50: n50, nmiss: nmiss
  });

  n300 = this.computed_accuracy.n300;
  n100 = this.computed_accuracy.n100;
  n50 = this.computed_accuracy.n50;

  var doubletap_penalty = Math.pow(0.98, n50 < nobjects / 500.0 ? 0 : n50 - nobjects / 500.0);

  var accuracy = this.computed_accuracy.value();

  // high/low ar bonus

  var ar_bonus = 0.0;
  if (mapstats.ar > 10.33) {
    ar_bonus += 0.4 * (mapstats.ar - 10.33);
  } else if (mapstats.ar < 8.0) {
    ar_bonus += 0.01 * (8.0 - mapstats.ar);
  }

  ar_bonus = 1.0 + Math.min(ar_bonus, ar_bonus * (nobjects / 1000.0));

  // aim pp

  var aim = this._base(aim_stars);
  aim *= length_bonus;

  if (nmiss > 0) {
    aim *= 0.97 * Math.pow(1 - Math.pow(nmiss / nobjects, 0.775), nmiss);
  }

  aim *= combo_break;
  aim *= ar_bonus;

  var hd_bonus = 1.0;
  if (mods & modbits.hd) {
    hd_bonus *= 1.0 + 0.04 * (12.0 - mapstats.ar);
  }

  aim *= hd_bonus;

  if (mods & modbits.fl) {
    var fl_bonus = 1.0 + 0.35 * Math.min(1.0, nobjects / 200.0);
    if (nobjects > 200) {
      fl_bonus += 0.3 * Math.min(1.0, (nobjects - 200) / 300.0);
    }
    if (nobjects > 500) {
      fl_bonus += (nobjects - 500) / 1200.0;
    }
    aim *= fl_bonus;
  }

  var acc_bonus = 0.5 + accuracy / 2.0;
  var od_squared = Math.pow(mapstats.od, 2);
  var od_bonus = 0.98 + od_squared / 2500.0;

  aim *= acc_bonus;
  aim *= od_bonus;

  this.aim = aim;

  // speed pp

  var speed = this._base(speed_stars);
  speed *= length_bonus;

  if (nmiss > 0) {
    speed *= 0.97 * Math.pow(1 - Math.pow(nmiss / nobjects, 0.775), Math.pow(nmiss, 0.875));
  }

  speed *= doubletap_penalty;
  speed *= combo_break;
  if (mapstats.ar > 10.33) {
    speed *= ar_bonus;
  }
  speed *= hd_bonus;

  speed *= (0.95 + od_squared / 750) * Math.pow(accuracy, (14.5 - Math.max(mapstats.od, 8)) / 2);

  this.speed = speed;

  // accuracy pp
  //
  // scorev1 ignores sliders and spinners since they are free
  // 300s

  var real_acc = accuracy;

  switch (score_version) {
    case 1:
      var nspinners = nobjects - nsliders - ncircles;
      real_acc = new std_accuracy({
        n300: Math.max(0, n300 - nsliders - nspinners),
        n100: n100,
        n50: n50,
        nmiss: nmiss
      }).value();
      real_acc = Math.max(0.0, real_acc);
      break;
    case 2:
      ncircles = nobjects;
      break;
    default:
      throw new {
        name: "NotImplementedError",
        message: "unsupported scorev" + score_version
      };
  }

  var acc = (
    Math.pow(1.52163, mapstats.od) *
    Math.pow(real_acc, 24.0) * 2.83
  );

  acc *= Math.min(1.15, Math.pow(ncircles / 1000.0, 0.3));
  if (mods & modbits.hd) acc *= 1.08;
  if (mods & modbits.fl) acc *= 1.02;

  this.acc = acc;

  // total pp

  var final_multiplier = 1.12;
  if (mods & modbits.nf) final_multiplier *= Math.max(0.9, 1.0 - 0.02 * nmiss);
  if (mods & modbits.so) final_multiplier *= 1.0 - Math.pow(nspinners / nobjects, 0.85);

  this.total = Math.pow(
    Math.pow(aim, 1.1) + Math.pow(speed, 1.1) +
    Math.pow(acc, 1.1),
    1.0 / 1.1
  ) * final_multiplier;

  return this;
};

std_ppv2.prototype.toString = function() {
  return (
    this.total.toFixed(2) + " pp (" + this.aim.toFixed(2)
    + " aim, " + this.speed.toFixed(2) + " speed, "
    + this.acc.toFixed(2) + " acc)"
  );
};

// _(internal)_ base pp value for stars
std_ppv2.prototype._base = function(stars) {
  return (
    Math.pow(5.0 * Math.max(1.0, stars / 0.0675) - 4.0, 3.0) / 100000.0
  );
};

// generic pp calc function that figures out what calculator to use
// based on the params' mode and passes through params and
// return value for calc()

function ppv2(params) {
  var mode;
  if (params.map) {
    mode = params.map.mode;
  } else {
    mode = params.mode || modes.std;
  }
  switch (mode) {
  case modes.std:
    return new std_ppv2().calc(params);
  }
  throw {
    name: "NotImplementedError",
    message: "this gamemode is not yet supported"
  };
}

// exports
// ----------------------------------------------------------------

osu.timing = timing;
osu.objtypes = objtypes;
osu.circle = circle;
osu.slider = slider;
osu.hitobject = hitobject;
osu.modes = modes;
osu.beatmap = beatmap;
osu.parser = parser;
osu.modbits = modbits;
osu.std_beatmap_stats = std_beatmap_stats;
osu.std_diff_hitobject = std_diff_hitobject;
osu.std_diff = std_diff;
osu.diff = diff;
osu.std_accuracy = std_accuracy;
osu.std_ppv2 = std_ppv2;
osu.ppv2 = ppv2;

})();