Merge pull request #1 from Raltyro/Continuous-Tempo-Change

Continuous Tempo Change (Thank you Ralty, Im sorry Im still learning this stuff)

source/funkin/backend/system/Conductor.hx

@@ -1,17 +1,24 @@
 package funkin.backend.system;
 
-import funkin.backend.chart.ChartData;
 import flixel.FlxState;
-import funkin.backend.system.interfaces.IBeatReceiver;
 import flixel.util.FlxSignal.FlxTypedSignal;
+import funkin.backend.chart.ChartData;
+import funkin.backend.system.interfaces.IBeatReceiver;
 
 @:structInit
-class BPMChangeEvent {
+class BPMChangeEvent
-	public var stepTime:Float;
+{
 	public var songTime:Float;
 	public var bpm:Float;
-	public var beatsPerMeasure:Float;
+	public var beatsPerMeasure:Float = 4;
-	public var stepsPerBeat:Int;
+	public var stepsPerBeat:Int = 4;
+
+	public var endSongTime:Float = 0;
+	public var continuous:Bool = false;
+
+	public var stepTime:Float;
+	public var beatTime:Float;
+	public var measureTime:Float;
 }
 
 final class Conductor
@@ -22,41 +29,15 @@ final class Conductor
 	public static var onMeasureHit:FlxTypedSignal<Int->Void> = new FlxTypedSignal();
 	public static var onBeatHit:FlxTypedSignal<Int->Void> = new FlxTypedSignal();
 	public static var onStepHit:FlxTypedSignal<Int->Void> = new FlxTypedSignal();
-	public static var onBPMChange:FlxTypedSignal<Float->Void> = new FlxTypedSignal();
+	public static var onBPMChange:FlxTypedSignal<(Float,Float)->Void> = new FlxTypedSignal();
 	public static var onTimeSignatureChange:FlxTypedSignal<(Float,Float)->Void> = new FlxTypedSignal();
 
-	/**
-	 * Current BPM
-	 */
-	public static var bpm:Float = 100;
-
-	/**
-	 * Current Crochet (time per beat), in milliseconds.
-	 */
-	public static var crochet:Float = ((60 / bpm) * 1000); // beats in milliseconds
-
-	/**
-	 * Current StepCrochet (time per step), in milliseconds.
-	 */
-	public static var stepCrochet:Float = crochet / 4; // steps in milliseconds
-
-	/**
-	 * Number of beats per mesure (top number in time signature). Defaults to 4.
-	 */
-	public static var beatsPerMeasure:Float = 4;
-
-	/**
-	 * Number of steps per beat (bottom number in time signature). Defaults to 4.
-	 */
-	public static var stepsPerBeat:Int = 4;
-
-
 	/**
 	 * Current position of the song, in milliseconds.
 	 */
 	public static var songPosition(get, default):Float;
 	private static function get_songPosition() {
-		if (songOffset != Options.songOffset) trace(songOffset = Options.songOffset);
+		if (songOffset != Options.songOffset) songOffset = Options.songOffset;
 		return songPosition - songOffset;
 	}
 
@@ -65,6 +46,60 @@ final class Conductor
 	 */
 	public static var songOffset:Float = 0;
 
+
+	/**
+	 * Current bpmChangeMap index
+	 */
+	public static var curChangeIndex:Int = 0;
+
+	/**
+	 * Current bpmChangeMap
+	 */
+	public static var curChange(get, never):Null<BPMChangeEvent>;
+	private static function get_curChange()
+		return bpmChangeMap[curChangeIndex];
+
+	/**
+	 * Current BPM
+	 */
+	public static var bpm(get, never):Float;
+	private static function get_bpm()
+		return curChangeIndex == 0 ? startingBPM : getTimeWithIndexInBPM(songPosition, curChangeIndex);
+
+	/**
+	 * Starting BPM
+	 */
+	public static var startingBPM(get, never):Float;
+	private static function get_startingBPM()
+		return bpmChangeMap.length == 0 ? 100 : bpmChangeMap[0].bpm;
+
+	/**
+	 * Current Crochet (time per beat), in milliseconds.
+	 * It should be crotchet but ehhh, now it's there for backward compatibility.
+	 */
+	public static var crochet(get, never):Float;
+	private static function get_crochet() return 15000 * stepsPerBeat / bpm;
+
+	/**
+	 * Current StepCrochet (time per step), in milliseconds.
+	 */
+	public static var stepCrochet(get, never):Float;
+	private static function get_stepCrochet() return 15000 / bpm;
+
+	/**
+	 * Number of beats per mesure (top number in time signature). Defaults to 4.
+	 */
+	public static var beatsPerMeasure(get, never):Float;
+	private static function get_beatsPerMeasure()
+		return bpmChangeMap.length == 0 ? 4 : bpmChangeMap[curChangeIndex].beatsPerMeasure;
+
+	/**
+	 * Number of steps per beat (bottom number in time signature). Defaults to 4.
+	 */
+	public static var stepsPerBeat(get, never):Float;
+	private static function get_stepsPerBeat()
+		return bpmChangeMap.length == 0 ? 4 : bpmChangeMap[curChangeIndex].stepsPerBeat;
+
 	/**
 	 * Current step
 	 */
@@ -80,7 +115,6 @@ final class Conductor
 	 */
 	public static var curMeasure:Int = 0;
 
-
 	/**
 	 * Current step, as a `Float` (ex: 4.94, instead of 4)
 	 */
@@ -103,89 +137,88 @@ final class Conductor
 	/**
 	 * Array of all BPM changes that have been mapped.
 	 */
-	public static var bpmChangeMap:Array<BPMChangeEvent> = [];
+	public static var bpmChangeMap:Array<BPMChangeEvent>;
 
 	@:dox(hide) public function new() {}
 
 	public static function reset() {
 		songPosition = lastSongPos = curBeatFloat = curStepFloat = curBeat = curStep = 0;
-		bpmChangeMap = [];
+		changeBPM();
-		changeBPM(0, 4, 4);
 	}
 
+	public static function changeBPM(bpm:Float = 100, beatsPerMeasure:Float = 4, stepsPerBeat:Int = 4)
+		bpmChangeMap = [{bpm: bpm, beatsPerMeasure: beatsPerMeasure, stepsPerBeat: stepsPerBeat, songTime: 0, stepTime: 0, beatTime: 0, measureTime: 0}];
+
 	public static function setupSong(SONG:ChartData) {
 		reset();
 		mapBPMChanges(SONG);
-		changeBPM(SONG.meta.bpm, cast SONG.meta.beatsPerMeasure.getDefault(4), cast SONG.meta.stepsPerBeat.getDefault(4));
 	}
+
+	private static function mapBPMChange(curChange:BPMChangeEvent, time:Float, bpm:Float, ?endTime:Float, ?prevChange:BPMChangeEvent):BPMChangeEvent {
+		var beatTime:Float, measureTime:Float, stepTime:Float;
+		if (curChange.continuous)
+			stepTime = curChange.stepTime + (((curChange.endSongTime - curChange.songTime) * (curChange.bpm - prevChange.bpm))
+				/ Math.log(curChange.bpm / prevChange.bpm) + (time - curChange.endSongTime) * curChange.bpm) / 15000;
+		else
+			stepTime = curChange.stepTime + (time - curChange.songTime) / (15000 / curChange.bpm);
+
+		beatTime = curChange.beatTime + (stepTime - curChange.stepTime) / curChange.stepsPerBeat;
+		measureTime = curChange.measureTime + (beatTime - curChange.beatTime) / curChange.beatsPerMeasure;
+
+		bpmChangeMap.push(curChange = {
+			songTime: time,
+			stepTime: stepTime,
+			beatTime: beatTime,
+			measureTime: measureTime,
+			bpm: bpm,
+			beatsPerMeasure: curChange.beatsPerMeasure,
+			stepsPerBeat: curChange.stepsPerBeat
+		});
+		if (curChange.continuous = (endTime is Float && endTime != 0)) curChange.endSongTime = endTime;
+		return curChange;
+	}
+
 	/**
 	 * Maps BPM changes from a song.
 	 * @param song Song to map BPM changes from.
 	 */
 	public static function mapBPMChanges(song:ChartData) {
-		bpmChangeMap = [
+		var curChange:BPMChangeEvent = {
-			{
+			songTime: 0,
-				stepTime: 0,
+			stepTime: 0,
-				songTime: 0,
+			beatTime: 0,
-				bpm: song.meta.bpm,
+			measureTime: 0,
-				beatsPerMeasure: song.meta.beatsPerMeasure.getDefault(4),
+			bpm: song.meta.bpm,
-				stepsPerBeat: song.meta.stepsPerBeat.getDefault(4)
+			beatsPerMeasure: song.meta.beatsPerMeasure.getDefault(4),
-			}
+			stepsPerBeat: CoolUtil.floorInt(song.meta.stepsPerBeat.getDefault(4))
-		];
+		};
-
+		bpmChangeMap = [curChange];
 		if (song.events == null) return;
 
-		var curBPM:Float = song.meta.bpm;
+		// fix the sort first...
-		var curBeatsPerMeasure:Float = song.meta.beatsPerMeasure.getDefault(4);
+		var events:Array<ChartEvent> = [];
-		var curStepsPerBeat:Int = song.meta.stepsPerBeat.getDefault(4);
+		for (e in song.events) if (e.params != null && (e.name == "BPM Change" || e.name == "Time Signature Change")) events.push(e);
-		var songTime:Float = 0;
+		events.sort(function(a, b) return Std.int(a.time - b.time));
-		var stepTime:Float = 0;
 
-		for(e in song.events) {
+		var prevChange:BPMChangeEvent = null;
-			var name = e.name;
+		for (e in events) {
-			var params = e.params;
+			if (bpmChangeMap.length > 3) prevChange = bpmChangeMap[bpmChangeMap.length - 2];
-			var eventTime = e.time;
+			var name = e.name, params = e.params, time = e.time;
-			if(params == null) continue;
+			if (name == "BPM Change" && params[0] is Float && curChange.bpm != params[0])
+				curChange = mapBPMChange(curChange, time, params[0], params[1], prevChange);
+			else if (name == "Time Signature Change") {
+				//if (beatsPerMeasure == curChange.beatsPerMeasure && stepsPerBeat == curChange.stepsPerBeat) continue;
+				/* TODO: make so time sigs doesnt stop the bpm change if its in the duration of bpm change */
 
-			if (name == "BPM Change" && params[0] is Float) {
+				if (curChange.songTime != time) curChange = mapBPMChange(curChange, time, curChange.bpm, null, prevChange);
-				if (params[0] == curBPM) continue;
+				curChange.beatsPerMeasure = params[0];
-				var steps = (eventTime - songTime) / ((60 / curBPM) * 1000 / stepsPerBeat);
+				curChange.stepsPerBeat = params[1];
-				stepTime += steps;
+				
-				songTime = eventTime;
+				curChange.stepTime = CoolUtil.floorInt(curChange.stepTime + .99998);
-				curBPM = params[0];
+				curChange.beatTime = CoolUtil.floorInt(curChange.beatTime + .99998);
-
+				curChange.measureTime = CoolUtil.floorInt(curChange.measureTime + .99998);
-				bpmChangeMap.push({
-					stepTime: stepTime,
-					songTime: songTime,
-					bpm: curBPM,
-					beatsPerMeasure: curBeatsPerMeasure, // keep old beatsPerMeasure and stepsPerMeasure so shit doesnt break
-					stepsPerBeat: curStepsPerBeat
-				});
-			} else if (name == "Time Signature Change") {
-				var newBeatsPerMeasure = params[0];
-				var newStepsPerBeat = params[1];
-
-				if (newBeatsPerMeasure == curBeatsPerMeasure && newStepsPerBeat == curStepsPerBeat) continue;
-
-				var steps = (eventTime - songTime) / ((60 / curBPM) * 1000 / stepsPerBeat);
-				stepTime += steps;
-				songTime = eventTime;
-
-				curBeatsPerMeasure = newBeatsPerMeasure;
-				curStepsPerBeat = newStepsPerBeat;
-
-				bpmChangeMap.push({
-					stepTime: stepTime,
-					songTime: songTime,
-					bpm: curBPM, // keep old bpm so shit doesnt break
-					beatsPerMeasure: curBeatsPerMeasure,
-					stepsPerBeat: curStepsPerBeat
-				});
 			}
 		}
-
-		// sort from early to last
-		bpmChangeMap.sort(function(a, b) return Std.int(a.songTime - b.songTime));
 	}
 
 	private static var elapsed:Float;
@@ -215,6 +248,7 @@ final class Conductor
 			reset();
 	}
 	private static var __lastChange:BPMChangeEvent;
+	private static var __updateStep:Bool;
 	private static var __updateBeat:Bool;
 	private static var __updateMeasure:Bool;
 
@@ -223,144 +257,227 @@ final class Conductor
 
 		__updateSongPos(FlxG.elapsed);
 
-		if (bpm > 0) {
+		var oldStep = curStep, oldBeat = curBeat, oldMeasure = curMeasure, oldChangeIndex = curChangeIndex;
-			// Check for BPM change
-			__lastChange = {
-				stepTime: 0,
-				songTime: 0,
-				bpm: 0,
-				beatsPerMeasure: beatsPerMeasure,
-				stepsPerBeat: stepsPerBeat
-			};
 
-			var currentPos = Conductor.songPosition;
+		if ((curChangeIndex = getTimeInChangeIndex(songPosition, curChangeIndex)) > 0) {
+			var change = curChange;
+			curStepFloat = getTimeWithBPMInSteps(songPosition, curChangeIndex, getTimeWithIndexInBPM(songPosition, curChangeIndex));
+			curBeatFloat = change.beatTime + (curStepFloat - change.stepTime) / change.stepsPerBeat;
+			curMeasureFloat = change.measureTime + (curBeatFloat - change.beatTime) / change.beatsPerMeasure;
+		}
+		else
+			curMeasureFloat = (curBeatFloat = (curStepFloat = songPosition / stepCrochet) / stepsPerBeat) / beatsPerMeasure;
 
-			for (change in Conductor.bpmChangeMap) {
+		if (curChangeIndex != oldChangeIndex) {
-				if (currentPos >= change.songTime)
+			var prev = bpmChangeMap[oldChangeIndex];
-					__lastChange = change;
+			if (prev != null) {
-				else
+				if (beatsPerMeasure != prev.beatsPerMeasure || stepsPerBeat != prev.stepsPerBeat)
-					break;
+					onTimeSignatureChange.dispatch(beatsPerMeasure, stepsPerBeat);
+
+				if (curChange.bpm != prev.bpm) onBPMChange.dispatch(curChange.bpm, curChange.endSongTime);
 			}
-
+			else {
-			// Change BPM if necessary and check for time signature change
+				onTimeSignatureChange.dispatch(beatsPerMeasure, stepsPerBeat);
-			if ((__lastChange.bpm > 0 && bpm != __lastChange.bpm) || (__lastChange.beatsPerMeasure != beatsPerMeasure || __lastChange.stepsPerBeat != stepsPerBeat)) {
+				onBPMChange.dispatch(curChange.bpm, curChange.endSongTime);
-				changeBPM(__lastChange.bpm, __lastChange.beatsPerMeasure, __lastChange.stepsPerBeat);
 			}
+		}
 
-			curStepFloat = __lastChange.stepTime + ((currentPos - __lastChange.songTime) / Conductor.stepCrochet);
+		if (__updateStep = (curStep != (curStep = CoolUtil.floorInt(curStepFloat)))) {
-			curBeatFloat = curStepFloat / stepsPerBeat;
+			if (curStep > oldStep) for (i in oldStep...curStep) onStepHit.dispatch(i + 1);
-			curMeasureFloat = curBeatFloat / beatsPerMeasure;
+			else onStepHit.dispatch(curStep);
+		}
 
-			var oldStep = curStep;
+		if (__updateBeat = (curBeat != (curBeat = CoolUtil.floorInt(curBeatFloat)))) {
-			var oldBeat = curBeat;
+			if (curBeat > oldBeat) for (i in oldBeat...curBeat) onBeatHit.dispatch(i + 1);
-			var oldMeasure = curMeasure;
+			else onBeatHit.dispatch(curBeat);
-			if (curStep != (curStep = CoolUtil.floorInt(curStepFloat))) {
+		}
-				if (curStep < oldStep && oldStep - curStep < 2) return;
-				// updates step
-				__updateBeat = curBeat != (curBeat = CoolUtil.floorInt(curBeatFloat));
-				__updateMeasure = __updateBeat && (curMeasure != (curMeasure = CoolUtil.floorInt(curMeasureFloat)));
 
-				if (curStep > oldStep) {
+		if (__updateMeasure = (curMeasure != (curMeasure = CoolUtil.floorInt(curMeasureFloat)))) {
-					for(i in oldStep...curStep) {
+			if (curMeasure > oldMeasure) for (i in oldMeasure...curMeasure) onMeasureHit.dispatch(i + 1);
-						onStepHit.dispatch(i+1);
+			else onMeasureHit.dispatch(curMeasure);
+		}
+
+		if (__updateStep || __updateBeat || __updateMeasure) {
+			var state = FlxG.state;
+			while (state != null) {
+				if (state is IBeatReceiver && (state.subState == null || state.persistentUpdate)) {
+					var st = cast(state, IBeatReceiver);
+
+					if (__updateStep) {
+						if (curStep > oldStep) for (i in oldStep...curStep) st.stepHit(i + 1);
+						else st.stepHit(curStep);
+					}
+
+					if (__updateBeat) {
+						if (curBeat > oldBeat) for (i in oldBeat...curBeat) st.beatHit(i + 1);
+						else st.beatHit(curBeat);
+					}
+
+					if (__updateMeasure) {
+						if (curMeasure > oldMeasure) for (i in oldMeasure...curMeasure) st.measureHit(i + 1);
+						else st.measureHit(curMeasure);
 					}
 				}
-				if (__updateBeat && curBeat > oldBeat) {
+				state = state.subState;
-					for(i in oldBeat...curBeat) {
-						onBeatHit.dispatch(i+1);
-					}
-				}
-				if (__updateMeasure && curMeasure > oldMeasure) {
-					for(i in oldMeasure...curMeasure) {
-						onMeasureHit.dispatch(i+1);
-					}
-				}
-
-				if (FlxG.state is IBeatReceiver) {
-					var state = FlxG.state;
-					while(state != null) {
-						if (state is IBeatReceiver && (state.subState == null || state.persistentUpdate)) {
-							var st = cast(state, IBeatReceiver);
-							if (curStep > oldStep) {
-								for(i in oldStep...curStep) {
-									st.stepHit(i+1);
-								}
-							}
-							if (__updateBeat && curBeat > oldBeat) {
-								for(i in oldBeat...curBeat) {
-									st.beatHit(i+1);
-								}
-							}
-							if (__updateMeasure && curMeasure > oldMeasure) {
-								for(i in oldMeasure...curMeasure) {
-									st.measureHit(i+1);
-								}
-							}
-						}
-						state = state.subState;
-					}
-				}
-
 			}
 		}
 	}
 
-	public static function changeBPM(newBpm:Float, newBeatsPerMeasure:Float = 4, newStepsPerBeat:Int = 4)
+	public static function getTimeInChangeIndex(time:Float, index:Int = 0):Int {
-	{
+		if (bpmChangeMap.length < 2) return bpmChangeMap.length - 1;
-		var timesignChange = (beatsPerMeasure != newBeatsPerMeasure || stepsPerBeat != newStepsPerBeat);
+		else if (bpmChangeMap[index = CoolUtil.boundInt(index, 0, bpmChangeMap.length - 1)].songTime > time) {
-		var bpmChange = (bpm != newBpm);
+			while (--index > 0) if (time > bpmChangeMap[index].songTime) return index;
-
+			return 0;
-		beatsPerMeasure = newBeatsPerMeasure;
+		}
-		stepsPerBeat = newStepsPerBeat;
+		else {
-		bpm = newBpm;
+			for (i in index...bpmChangeMap.length) if (bpmChangeMap[i].songTime > time) return i - 1;
-
+			return bpmChangeMap.length - 1;
-		crochet = (60 / bpm) * 1000;
+		}
-		stepCrochet = crochet / stepsPerBeat;
-
-		if (timesignChange) onTimeSignatureChange.dispatch(beatsPerMeasure, stepsPerBeat);
-		if (bpmChange) onBPMChange.dispatch(bpm);
 	}
 
-	public static function getTimeForStep(step:Float) {
+	public static function getStepsInChangeIndex(stepTime:Float, index:Int = 0):Int {
-		var bpmChange:BPMChangeEvent = {
+		if (bpmChangeMap.length < 2) return bpmChangeMap.length - 1;
-			stepTime: 0,
+		else if (bpmChangeMap[index = CoolUtil.boundInt(index, 0, bpmChangeMap.length - 1)].stepTime > stepTime) {
-			songTime: 0,
+			while (--index > 0) if (stepTime > bpmChangeMap[index].stepTime) return index;
-			bpm: bpm,
+			return 0;
-			beatsPerMeasure: beatsPerMeasure,
+		}
-			stepsPerBeat: stepsPerBeat
+		else {
-		};
+			for (i in index...bpmChangeMap.length) if (bpmChangeMap[i].stepTime > stepTime) return i - 1;
-
+			return bpmChangeMap.length - 1;
-		for(change in bpmChangeMap)
+		}
-			if (change.stepTime < step && change.stepTime >= bpmChange.stepTime)
-				bpmChange = change;
-		// possible break here
-
-		return bpmChange.songTime + ((step - bpmChange.stepTime) * ((60 / bpmChange.bpm) * (1000 / bpmChange.stepsPerBeat)));
 	}
 
-	public static function getStepForTime(time:Float) {
+	public static function getBeatsInChangeIndex(beatTime:Float, index:Int = 0):Int {
-		var bpmChange:BPMChangeEvent = {
+		if (bpmChangeMap.length < 2) return bpmChangeMap.length - 1;
-			stepTime: 0,
+		else if (bpmChangeMap[index = CoolUtil.boundInt(index, 0, bpmChangeMap.length - 1)].beatTime > beatTime) {
-			songTime: 0,
+			while (--index > 0) if (beatTime > bpmChangeMap[index].beatTime) return index;
-			bpm: bpm,
+			return 0;
-			beatsPerMeasure: beatsPerMeasure,
+		}
-			stepsPerBeat: stepsPerBeat
+		else {
-		};
+			for (i in index...bpmChangeMap.length) if (bpmChangeMap[i].beatTime > beatTime) return i - 1;
-
+			return bpmChangeMap.length - 1;
-		for(change in bpmChangeMap)
+		}
-			if (change.songTime < time && change.songTime >= bpmChange.songTime)
-				bpmChange = change;
-		// possible break here
-
-		return bpmChange.stepTime + ((time - bpmChange.songTime) / ((60 / bpmChange.bpm) * (1000 / bpmChange.stepsPerBeat)));
 	}
 
+	public static function getMeasuresInChangeIndex(measureTime:Float, index:Int = 0):Int {
+		if (bpmChangeMap.length < 2) return bpmChangeMap.length - 1;
+		else if (bpmChangeMap[index = CoolUtil.boundInt(index, 0, bpmChangeMap.length - 1)].measureTime > measureTime) {
+			while (--index > 0) if (measureTime > bpmChangeMap[index].measureTime) return index;
+			return 0;
+		}
+		else {
+			for (i in index...bpmChangeMap.length) if (bpmChangeMap[i].measureTime > measureTime) return i - 1;
+			return bpmChangeMap.length - 1;
+		}
+	}
+
+	public static function getTimeWithIndexInBPM(time:Float, index:Int):Float {
+		var bpmChange = bpmChangeMap[index];
+		if (bpmChange.continuous && time < bpmChange.endSongTime && index > 0) {
+			var prevBPM = bpmChangeMap[index - 1].bpm;
+			if (time <= bpmChange.songTime) return prevBPM;
+
+			var ratio = (time - bpmChange.songTime) / (bpmChange.endSongTime - bpmChange.songTime);
+			return Math.pow(prevBPM, 1 - ratio) * Math.pow(bpmChange.bpm, ratio);
+		}
+		return bpmChange.bpm;
+	}
+
+	public static function getStepsWithIndexInBPM(stepTime:Float, index:Int):Float {
+		var bpmChange = bpmChangeMap[index];
+		if (bpmChange.continuous && index > 0) {
+			var prevBPM = bpmChangeMap[index - 1].bpm;
+			if (stepTime <= bpmChange.stepTime) return prevBPM;
+
+			var endStepTime = bpmChange.stepTime + (bpmChange.endSongTime - bpmChange.songTime) * (bpmChange.bpm - prevBPM) / Math.log(bpmChange.bpm / prevBPM) / 15000;
+			if (stepTime < endStepTime) return FlxMath.remapToRange(stepTime, bpmChange.stepTime, endStepTime, prevBPM, bpmChange.bpm);
+		}
+		return bpmChange.bpm;
+	}
+
+	public static function getTimeInBPM(time:Float):Float {
+		if (bpmChangeMap.length == 0) return 100;
+		return getTimeWithIndexInBPM(time, getTimeInChangeIndex(time));
+	}
+
+	public static function getTimeWithBPMInSteps(time:Float, index:Int, bpm:Float):Float {
+		var bpmChange = bpmChangeMap[index];
+		if (bpmChange.continuous && time > bpmChange.songTime && index > 0) {
+			var prevBPM = bpmChangeMap[index - 1].bpm;
+			if (time > bpmChange.endSongTime)
+				return bpmChange.stepTime + (((bpmChange.endSongTime - bpmChange.songTime) * (bpmChange.bpm - prevBPM))
+					/ Math.log(bpmChange.bpm / prevBPM) + (time - bpmChange.endSongTime) * bpm) / 15000;
+			else
+				return bpmChange.stepTime + (time - bpmChange.songTime) * (bpm - prevBPM) / Math.log(bpm / prevBPM) / 15000;
+		}
+		else {
+			return bpmChange.stepTime + (time - bpmChange.songTime) / (15000 / bpm);
+		}
+	}
+
+	public static function getTimeInBeats(time:Float, from:Int = 0):Float {
+		var index = getTimeInChangeIndex(time, from);
+		if (index == -1) return time / (60000 / 100);
+		else if (index == 0) return time / (15000 / bpmChangeMap[index].bpm) / bpmChangeMap[index].stepsPerBeat;
+		else {
+			var change = bpmChangeMap[index];
+			return change.beatTime + (getTimeWithBPMInSteps(time, index, getTimeWithIndexInBPM(time, index)) - change.stepTime) / change.stepsPerBeat;
+		}
+	}
+
+	public static function getTimeInSteps(time:Float, from:Int = 0):Float {
+		var index = getTimeInChangeIndex(time, from);
+		return index < 1 ? time / (15000 / getTimeInBPM(time)) : getTimeWithBPMInSteps(time, index, getTimeWithIndexInBPM(time, index));
+	}
+
+	@:noCompletion
+	@:haxe.warning("-WDeprecated")
+	public static inline function getStepForTime(time:Float):Float return getTimeInSteps(time);
+
+	public static function getStepsWithBPMInTime(stepTime:Float, index:Int, bpm:Float):Float {
+		var bpmChange = bpmChangeMap[index];
+		if (bpmChange.continuous && stepTime > bpmChange.stepTime && index > 0) {
+			var prevBPM = bpmChangeMap[index - 1].bpm;
+			var time = bpmChange.songTime + (stepTime - bpmChange.stepTime) / (bpm - prevBPM) * Math.log(bpm / prevBPM) * 15000;
+			if (time > bpmChange.endSongTime)
+				return (15000 * (stepTime - bpmChange.stepTime) - ((bpmChange.endSongTime - bpmChange.songTime) * (bpm - prevBPM))
+					/ Math.log(bpm / prevBPM)) / bpm + bpmChange.endSongTime;
+			else
+				return time;
+		}
+		else {
+			return bpmChange.songTime + (stepTime - bpmChange.stepTime) * (15000 / bpm);
+		}
+	}
+
+	public static function getBeatsInTime(beatTime:Float, from:Int = 0):Float {
+		var index = getStepsInChangeIndex(beatTime, from);
+		if (index == -1) return beatTime * (60000 / 100);
+		else if (index == 0) return beatTime * (15000 / bpmChangeMap[index].bpm) * bpmChangeMap[index].stepsPerBeat;
+		else {
+			var change = bpmChangeMap[index];
+			var stepTime = change.stepTime + (beatTime - change.beatTime) * change.stepsPerBeat;
+			return getStepsWithBPMInTime(stepTime, index, getStepsWithIndexInBPM(stepTime, index));
+		}
+	}
+
+	public static function getStepsInTime(stepTime:Float, from:Int = 0):Float {
+		var index = getStepsInChangeIndex(stepTime, from);
+		return index < 1 ? stepTime * (15000 / bpmChangeMap[index].bpm) : getStepsWithBPMInTime(stepTime, index, getStepsWithIndexInBPM(stepTime, index));
+	}
+
+	@:noCompletion
+	@:haxe.warning("-WDeprecated")
+	public static inline function getTimeForStep(steps:Float):Float return getStepsInTime(steps);
 
 	public static inline function getMeasureLength()
 		return stepsPerBeat * beatsPerMeasure;
 
 	public static inline function getMeasuresLength() {
 		if (FlxG.sound.music == null) return 0.0;
-		return getStepForTime(FlxG.sound.music.length) / getMeasureLength();
+		var length = FlxG.sound.music.length;
+		var index = getTimeInChangeIndex(length, bpmChangeMap.length - 1);
+		var change = bpmChangeMap[index];
+		return change.measureTime + (getTimeInBeats(length, index) - change.beatTime) / change.beatsPerMeasure;
 	}
-}
+}

source/funkin/backend/utils/CoolUtil.hx

@@ -403,7 +403,7 @@ class CoolUtil
 			}
 
 			var bpm:Null<Float> = Std.parseFloat(musicInfo["BPM"]).getDefault(DefaultBPM);
-			Conductor.changeBPM(bpm, beatsPerMeasure, stepsPerBeat);
+			Conductor.changeBPM(bpm, beatsPerMeasure, floorInt(stepsPerBeat));
 		} else
 			Conductor.changeBPM(DefaultBPM);
 	}
@@ -740,6 +740,15 @@ class CoolUtil
 	@:noUsing public static inline function maxInt(p1:Int, p2:Int)
 		return p1 < p2 ? p2 : p1;
 
+	/**
+	 * Equivalent of `Math.min`, except doesn't require a Int -> Float -> Int conversion.
+	 * @param p1
+	 * @param p2
+	 * @return return p1 > p2 ? p2 : p1
+	 */
+	@:noUsing public static inline function minInt(p1:Int, p2:Int)
+		return p1 > p2 ? p2 : p1;
+
 	/**
 	 * Equivalent of `Math.floor`, except doesn't require a Int -> Float -> Int conversion.
 	 * @param e Value to get the floor of.
@@ -781,6 +790,36 @@ class CoolUtil
 		return file.file;
 	}
 
+	public static inline function bound(Value:Float, Min:Float, Max:Float):Float {
+		#if cpp
+		var _hx_tmp1:Float = Value;
+		var _hx_tmp2:Float = Min;
+		var _hx_tmp3:Float = Max;
+		return untyped __cpp__("((({0}) < ({1})) ? ({1}) : (({0}) > ({2})) ? ({2}) : ({0}))", _hx_tmp1, _hx_tmp2, _hx_tmp3);
+		#else
+		return (Value < Min) ? Min : (Value > Max) ? Max : Value;
+		#end
+	}
+
+	public static inline function boundInt(Value:Int, Min:Int, Max:Int):Int {
+		#if cpp
+		var _hx_tmp1:Int = Value;
+		var _hx_tmp2:Int = Min;
+		var _hx_tmp3:Int = Max;
+		return untyped __cpp__("((({0}) < ({1})) ? ({1}) : (({0}) > ({2})) ? ({2}) : ({0}))", _hx_tmp1, _hx_tmp2, _hx_tmp3);
+		#else
+		return (Value < Min) ? Min : (Value > Max) ? Max : Value;
+		#end
+	}
+
+	public static inline function boolToInt(b:Bool):Int {
+		#if cpp
+		return untyped __cpp__("(({0}) ? 1 : 0)", b);
+		#else
+		return b ? 1 : 0;
+		#end
+	}
+
 	/**
 	 * Converts a string of "1..3,5,7..9,8..5" into an array of numbers like [1,2,3,5,7,8,9,8,7,6,5]
 	 * @param input String to parse

source/funkin/game/PlayState.hx

@@ -1018,8 +1018,6 @@ class PlayState extends MusicBeatState
 
 		camZoomingInterval = cast songData.meta.beatsPerMeasure.getDefault(4);
 
-		Conductor.changeBPM(songData.meta.bpm, cast songData.meta.beatsPerMeasure.getDefault(4), cast songData.meta.stepsPerBeat.getDefault(4));
-
 		curSong = songData.meta.name.toLowerCase();
 
 		inst = FlxG.sound.load(Paths.inst(SONG.meta.name, difficulty));