public void SetCSLock(bool locked)
 {
     CsIsLocked = locked;
     if (!locked)
     {
         NewBeatmap.CircleSize = OriginalBeatmap.CircleSize;
         BeatmapModified?.Invoke(this, EventArgs.Empty);
     }
     ControlsModified?.Invoke(this, EventArgs.Empty);
 }
 public void SetHPLock(bool locked)
 {
     HpIsLocked = locked;
     if (!locked)
     {
         NewBeatmap.HPDrainRate = OriginalBeatmap.HPDrainRate;
         BeatmapModified?.Invoke(this, EventArgs.Empty);
     }
     ControlsModified?.Invoke(this, EventArgs.Empty);
 }
 public void SetODLock(bool locked)
 {
     OdIsLocked = locked;
     if (OdIsLocked)
     {
         ScaleOD = false;
     }
     else
     {
         SetScaleOD(true);
     }
     ControlsModified?.Invoke(this, EventArgs.Empty);
 }
 public void SetARLock(bool locked)
 {
     ArIsLocked = locked;
     if (ArIsLocked)
     {
         ScaleAR = false;
     }
     else
     {
         SetScaleAR(true);
     }
     ControlsModified?.Invoke(this, EventArgs.Empty);
 }
        public void SetOD(float value)
        {
            if (State != EditorState.READY)
            {
                return;
            }

            NewBeatmap.OverallDifficulty = value;
            if (OdIsLocked)
            {
                lockedOD = value;
            }

            ScaleOD = false;
            BeatmapModified?.Invoke(this, EventArgs.Empty);
            ControlsModified?.Invoke(this, EventArgs.Empty);
        }
        public void SetScaleOD(bool value)
        {
            ScaleOD = value;

            if (State == EditorState.NOT_READY)
            {
                return;
            }

            if (ScaleOD)
            {
                NewBeatmap.OverallDifficulty = DifficultyCalculator.CalculateMultipliedOD(OriginalBeatmap, BpmMultiplier);
                BeatmapModified?.Invoke(this, EventArgs.Empty);
            }
            ArIsLocked = false;
            ControlsModified?.Invoke(this, EventArgs.Empty);
        }
        public void SetAR(float value)
        {
            if (State != EditorState.READY)
            {
                return;
            }

            NewBeatmap.ApproachRate = value;
            if (ArIsLocked)
            {
                lockedAR = value;
            }

            ScaleAR = false;
            BeatmapModified?.Invoke(this, EventArgs.Empty);
            ControlsModified?.Invoke(this, EventArgs.Empty);
        }
 public void ResetBeatmap()
 {
     NewBeatmap.HPDrainRate       = OriginalBeatmap.HPDrainRate;
     NewBeatmap.CircleSize        = OriginalBeatmap.CircleSize;
     NewBeatmap.ApproachRate      = OriginalBeatmap.ApproachRate;
     NewBeatmap.OverallDifficulty = OriginalBeatmap.OverallDifficulty;
     HpIsLocked    = false;
     CsIsLocked    = false;
     ArIsLocked    = false;
     OdIsLocked    = false;
     ScaleAR       = true;
     ScaleOD       = true;
     BpmMultiplier = 1.0f;
     ModifyBeatmapTiming(OriginalBeatmap, NewBeatmap, 1.0f);
     RequestDiffCalc();
     ControlsModified?.Invoke(this, EventArgs.Empty);
     BeatmapModified?.Invoke(this, EventArgs.Empty);
 }
Beispiel #9
0
        private async void ServiceBeatmapChangeRequest()
        {
            // acquire mutually exclusive entry into this method
            serviceBeatmapRequestLocked = true;

            Beatmap candidateOriginalBeatmap = null, candidateNewBeatmap = null;

            while (completedBeatmapRequest == null || completedBeatmapRequest.RequestNumber != mapChangeRequests.Last().RequestNumber)
            {
                completedBeatmapRequest  = mapChangeRequests.Last();
                candidateOriginalBeatmap = await Task.Run(() => LoadBeatmap(mapChangeRequests.Last().Name));

                if (candidateOriginalBeatmap != null)
                {
                    candidateNewBeatmap = new Beatmap(candidateOriginalBeatmap);
                }

                // if a new request came in, invalidate candidate beatmap and service the new request
            }

            // no new requests, we can commit to using this beatmap
            OriginalBeatmap = candidateOriginalBeatmap;
            NewBeatmap      = candidateNewBeatmap;
            if (OriginalBeatmap == null)
            {
                SetState(EditorState.NOT_READY);
                NotReadyReason = BadBeatmapReason.ERROR_LOADING_BEATMAP;
                BeatmapSwitched?.Invoke(this, EventArgs.Empty);
            }
            else
            {
                if (OriginalBeatmap.HitObjectCount == 0)
                {
                    SetState(EditorState.NOT_READY);
                    NotReadyReason = BadBeatmapReason.EMPTY_MAP;
                    BeatmapSwitched?.Invoke(this, EventArgs.Empty);
                }
                else
                {
                    // Apply multiplier
                    if (BpmIsLocked)
                    {
                        SetBpm(lockedBpm);
                    }
                    NewBeatmap.SetRate(BpmRate);

                    // Apply bpm scaled settings
                    if (ScaleAR)
                    {
                        NewBeatmap.ApproachRate = DifficultyCalculator.CalculateMultipliedAR(candidateOriginalBeatmap, BpmRate);
                    }
                    if (ScaleOD)
                    {
                        NewBeatmap.OverallDifficulty = DifficultyCalculator.CalculateMultipliedOD(candidateOriginalBeatmap, BpmRate);
                    }

                    // Apply locked settings to new map
                    if (HpIsLocked)
                    {
                        NewBeatmap.HPDrainRate = lockedHP;
                    }
                    if (CsIsLocked)
                    {
                        NewBeatmap.CircleSize = lockedCS;
                    }
                    if (ArIsLocked)
                    {
                        NewBeatmap.ApproachRate = lockedAR;
                    }
                    if (OdIsLocked)
                    {
                        NewBeatmap.OverallDifficulty = lockedOD;
                    }

                    // Apply Hardrock
                    if (ForceHardrockCirclesize)
                    {
                        NewBeatmap.CircleSize = OriginalBeatmap.CircleSize * 1.3M;
                    }

                    SetState(EditorState.READY);
                    RequestDiffCalc();
                    BeatmapSwitched?.Invoke(this, EventArgs.Empty);
                    BeatmapModified?.Invoke(this, EventArgs.Empty);
                }
            }
            ControlsModified?.Invoke(this, EventArgs.Empty);
            serviceBeatmapRequestLocked = false;
        }
Beispiel #10
0
 public void ForceEventControlsModified() => ControlsModified?.Invoke(this, EventArgs.Empty);
 public void ToggleChangePitchSetting()
 {
     ChangePitch = !ChangePitch;
     ControlsModified?.Invoke(this, EventArgs.Empty);
 }