public void BeatTime_OperatorAdd()
{
var left = new BeatTime(140, 70, 600);
var right = new BeatTime(140, 20, -310);
var zeroBpmLeft = new BeatTime(0, 4, 100);
var zeroBpmRight = new BeatTime(0, 28, -300);
{
var result = left + right;
Assert.AreEqual(140, result.bpm);
Assert.AreEqual(90, result.quarterBeatCount);
Assert.AreEqual(290, result.offset);
}
{
var result = left + zeroBpmRight;
Assert.AreEqual(left.TimeSpan, result.TimeSpan);
Assert.AreEqual(left.bpm, result.bpm);
}
{
var result = zeroBpmLeft + right;
Assert.AreEqual(right.TimeSpan, result.TimeSpan);
Assert.AreEqual(right.bpm, result.bpm);
}
{
var result = zeroBpmLeft + zeroBpmRight;
Assert.AreEqual(32, result.quarterBeatCount);
Assert.AreEqual(-200, result.offset);
Assert.AreEqual(0, result.bpm);
}
}
public void BeatTime_OperatorSub()
{
var left = new BeatTime(140, 70, 600);
var right = new BeatTime(140, 20, -310);
var zeroBpmLeft = new BeatTime(0, 4, 100);
var zeroBpmRight = new BeatTime(0, 28, -300);
{
var result = left - right;
Assert.AreEqual(140, result.bpm);
Assert.AreEqual(50, result.quarterBeatCount);
Assert.AreEqual(910, result.offset);
}
{
var result = zeroBpmLeft - right;
Assert.AreEqual(right.TimeSpan.Negate(), result.TimeSpan);
Assert.AreEqual(right.bpm, result.bpm);
}
{
var result = zeroBpmLeft - zeroBpmRight;
Assert.AreEqual(-24, result.quarterBeatCount);
Assert.AreEqual(400, result.offset);
Assert.AreEqual(0, result.bpm);
}
{
var result = left - zeroBpmRight;
Assert.AreEqual(left.TimeSpan, result.TimeSpan);
Assert.AreEqual(left.bpm, result.bpm);
}
}
public void Start()
{
if (Pause.current)
{
// Get a component reference to StartButton attached to this object, store in startScript variable
m_StartScript = GameObject.Find("Canvas").GetComponent <StartOptions>();
}
Camera.main.orthographicSize = cameraSize;
m_receivers = transform.GetComponentsInChildren <Receiver>();
RemoveEmitters();
GenerateEmitters();
// SetPipelineHUD();
goldTime = new BeatTime(goldTime.hours, goldTime.minutes, goldTime.seconds);
silverTime = new BeatTime(silverTime.hours, silverTime.minutes, silverTime.seconds);
bronzeTime = new BeatTime(bronzeTime.hours, bronzeTime.minutes, bronzeTime.seconds);
m_TimerToCongratulate = 0;
m_PlayerTime = 0;
// Analytics
Analytics.CustomEvent("usersInLevel", new Dictionary <string, object>()
{
{ "level", whatIsPuzzle }
});
}
void OnDisable()
{
// Singleton class logic. There should be only one instance that updates static values.
if (instance == this)
{
instance = null;
}
}
public void BeatTime_Milliseconds()
{
var beatTime = new BeatTime(60, 4, 111);
var result = beatTime.Milliseconds;
Assert.AreEqual(1111, result);
}
public void BeatTime_DefaultValue()
{
var beatTime = new BeatTime();
Assert.AreEqual(0, beatTime.quarterBeatCount);
Assert.AreEqual(0, beatTime.offset);
Assert.AreEqual(TimeSpan.Zero, beatTime.TimeSpan);
Assert.AreEqual(0, beatTime.Milliseconds);
}
public void BeatTime_AddOffset()
{
var beatTime = new BeatTime(11, 18, 1);
var result = beatTime.AddOffset(-7);
Assert.AreEqual(-6, result.offset);
Assert.AreEqual(1, beatTime.offset, "BeatTime should be immutable!");
}
public void PlayHitEffect(float stopBeat)
{
if (particles == null)
{
return;
}
particles.Play();
particleStopTime = BeatTime.timeOnBeat(stopBeat);
}
public void BeatTime_AddQuarterBeats()
{
var beatTime = new BeatTime(11, 18, 1);
var result = beatTime.AddQuarterBeats(3);
var result2 = beatTime.AddQuarterBeats(-25);
Assert.AreEqual(21, result.quarterBeatCount);
Assert.AreEqual(1, result.offset);
Assert.AreEqual(-7, result2.quarterBeatCount);
Assert.AreEqual(18, beatTime.quarterBeatCount, "BeatTime should be immutable!");
}
public bool IsLessThanOrEquals(BeatTime beatTime)
{
int compare = m_TimeSpan.CompareTo(beatTime.Span);
if (compare <= 0)
{
return(true);
}
else
{
return(false);
}
}
public void EndLoad(int millisecondsOffset = 0, int quarterBeatsOffset = 0)
{
var beatTimeOffset = new BeatTime(_beatTimer.Bpm, quarterBeatsOffset, millisecondsOffset);
DoAfterUpdate(() =>
{
if (!IsRunning || !IsGameTimePaused)
{
return;
}
_speedrunStopwatch.Resume((int)beatTimeOffset.Milliseconds);
_beatTimer.ResumeTimer(millisecondsOffset, quarterBeatsOffset);
});
}
public void BeatTime_InvalidDifferentBpmOperations()
{
var left = new BeatTime(50, 70, 600);
var right = new BeatTime(140, 20, -310);
Assert.ThrowsException <ArgumentException>(() =>
{
var result = left + right;
});
Assert.ThrowsException <ArgumentException>(() =>
{
var result = left - right;
});
}
public void PlaySynchronized(int trackNum, float beginBeat, float endBeat = float.PositiveInfinity)
{
if (trackNum < 0 || trackNum >= playableTracks.Length)
{
return;
}
double beginTime = BeatTime.timeOnBeat(beginBeat);
double endTime = float.IsInfinity(endBeat) ? float.PositiveInfinity : BeatTime.timeOnBeat(endBeat);
double length = endTime - beginTime;
AudioSource track = playableTracks[trackNum];
track.volume = volumePlaySynchronized;
double bgmTime = BeatTime.audioTime;
if (beginTime > bgmTime)
{
track.SetScheduledEndTime(0);
double beginDspTime = BeatTime.dspTime + (beginTime - bgmTime);
if (isSynchronized && track.isPlaying)
{
track.SetScheduledEndTime(beginDspTime + length);
}
else
{
track.time = (float)beginTime;
track.PlayScheduled(beginDspTime);
track.SetScheduledEndTime(beginDspTime + length);
}
}
else
{
track.SetScheduledEndTime(0);
if (!track.isPlaying)
{
track.Play();
}
if (!isSynchronized)
{
track.time = (float)BeatTime.audioTime;
}
track.SetScheduledEndTime(BeatTime.dspTime + length);
}
isSynchronized = true;
}
// Update is called once per frame
void Update()
{
float deltaTime = Time.deltaTime;
for (int i = 0; i < maxRippleCount; ++i)
{
ripplePositions[i] += deltaTime * rippleSpeed;
}
int currBeat = BeatTime.numBeat;
if (currBeat >= 0 && currBeat != lastBeat)
{
if (currBeat == lastBeat + 1 && currBeat % beatPerRipple == 0)
{
AddRipple((float)(BeatTime.audioTime - BeatTime.timeOnBeat(currBeat)));
}
lastBeat = currBeat;
}
material.SetFloatArray("_RipplePositions", ripplePositions);
}
/// <summary>
/// Offsets relative to the last beat
/// </summary>
/// <param name="millisecondsOffset"></param>
/// <param name="quarterBeatsOffset"></param>
public void StartTimer(int millisecondsOffset = 0, int quarterBeatsOffset = 0)
{
var beatTime = new BeatTime(_beatTimer.Bpm, quarterBeatsOffset, millisecondsOffset);
DoAfterUpdate(() =>
{
if (IsRunning)
{
return;
}
ResetTimer();
_speedrunStopwatch.Start((int)beatTime.Milliseconds);
_beatTimer.StartTimer(millisecondsOffset, quarterBeatsOffset);
RunLog.StartDate = _speedrunStopwatch.StartDate + beatTime.TimeSpan;
if (LiveSplitSyncEnabled)
{
_liveSplitSync.Start();
}
});
}
public void PlayNow(int trackNum, float beginBeat, float endBeat)
{
if (trackNum < 0 || trackNum >= playableTracks.Length)
{
return;
}
double beginTime = BeatTime.timeOnBeat(beginBeat);
double endTime = BeatTime.timeOnBeat(endBeat);
double length = endTime - beginTime;
AudioSource track = playableTracks[trackNum];
track.volume = volumePlayNow;
track.SetScheduledEndTime(0);
track.time = (float)beginTime;
track.Play();
track.SetScheduledEndTime(BeatTime.dspTime + length);
isSynchronized = false;
}
void Update()
{
// Singleton class logic. Checks if last instance is disabled/removed and replace it
if (BeatTime.instance == null)
{
BeatTime.instance = this;
}
var currAudioTime = beatProvider.GetAudioTime();
var currBeat = beatProvider.GetBeatFromTime(currAudioTime);
// Static update. Only the singleton instance do this.
if (BeatTime.instance == this)
{
BeatTime.deltaAudioTime = currAudioTime - BeatTime.audioTime;
BeatTime.audioTime = currAudioTime;
BeatTime.beat = currBeat;
BeatTime.deltaBeat = currBeat - m_lastBeat;
BeatTime.numBeat = currBeat < 0 ? -1 : (int)Math.Floor(currBeat);
BeatTime.subBeat = currBeat - BeatTime.numBeat;
if (m_lastNumBeat != BeatTime.numBeat)
{
BeatTime.lastBeatTime = m_lastNumBeat < 0 ? double.MinValue : beatProvider.GetTimeFromBeat(currBeat);
BeatTime.nextBeatTime = beatProvider.GetTimeFromBeat(BeatTime.numBeat + 1);
}
BeatTime.timeFromLastBeat = BeatTime.audioTime - BeatTime.lastBeatTime;
BeatTime.timeTillNextBeat = BeatTime.nextBeatTime - BeatTime.audioTime;
BeatTime.accumulatedBeat += deltaBeat;
}
// Update benchmark data
m_lastAudioTime = currAudioTime;
m_lastBeat = currBeat;
m_lastNumBeat = BeatTime.numBeat;
}
/// <summary>
/// Offsets relative to the last beat
/// </summary>
/// <param name="millisecondsOffset"></param>
/// <param name="quarterBeatsOffset"></param>
public void Split(int millisecondsOffset = 0, int quarterbeatsOffset = 0)
{
// if the split is on beat, the beatTimer might not have ticked yet (onBeat eventhandler not called yet)
// so delay until LateUpdate
DoAfterUpdate(() =>
{
if (!IsRunning)
{
return;
}
if (IsGameTimePaused)
{
millisecondsOffset = 0;
quarterbeatsOffset = 0;
}
var offset = new BeatTime(_beatTimer.Bpm, quarterbeatsOffset, millisecondsOffset);
var splitBeatTime = _beatTimer.Time + offset;
var timeStr = Utils.FormatTime(splitBeatTime.TimeSpan, 3);
var stopwatchTime = _speedrunStopwatch.GameTime + offset.TimeSpan;
var stopwatchTimeStr = Utils.FormatTime(stopwatchTime, 3);
var splitTimeStr = $"Split at {timeStr} / {splitBeatTime}";
var offsetStr = millisecondsOffset != 0 || quarterbeatsOffset != 0
? $" ({offset} offset)"
: string.Empty;
Debug.Log($"{splitTimeStr}{offsetStr}\n(stopwatch: {stopwatchTimeStr})\n"
+ DebugBeatListener.DebugStr);
if (LiveSplitSyncEnabled)
{
_liveSplitSync.Split(splitBeatTime.TimeSpan);
}
});
}
public int CompareTo(BeatTime beatTime)
{
return(m_TimeSpan.CompareTo(beatTime.Span));
}
public SpeedrunTime(TimeSpan realTime, BeatTime gameTime)
: this(realTime, gameTime.TimeSpan)
{
GameBeatTime = gameTime;
}
public SpeedrunTime(TimeSpan realTime, TimeSpan gameTime)
{
RealTime = realTime;
GameTime = gameTime;
GameBeatTime = new BeatTime();
}
private void Update(EvaluationContext context)
{
var beatTime = BeatTime.IsConnected
? BeatTime.GetValue(context)
: (float)EvaluationContext.BeatTime;
var frequency = Frequency.GetValue(context);
var intensity = Intensity.GetValue(context);
float v = 0;
// Off
if (frequency == 0)
{
v = 0;
}
else if (frequency < 0.1)
{
v = 1 / 16f;
}
else if (frequency < 0.2)
{
v = 1 / 8f;
}
else if (frequency < 0.3)
{
v = 1 / 4f;
}
else if (frequency < 0.5)
{
v = 1;
}
else if (frequency < 0.7)
{
v = 2;
}
else if (frequency < 0.90)
{
v = 4;
}
else
{
v = 16;
}
v *= Speed.GetValue(context);
Result.Value = (1 - (beatTime * v) % 1) * intensity;
int beatCounter = (int)(beatTime * v);
Counter.Value = beatCounter;
var wasBang = Counter.Value > _lastBeatCounter;
_lastBeatCounter = beatCounter;
// Only ping updates on actual changes
if (wasBang != _lastBang)
{
Bang.Value = wasBang;
_lastBang = wasBang;
}
}
