osukey/osu.Game/Beatmaps/Beatmap.cs

// Copyright (c) 2007-2017 ppy Pty Ltd <contact@ppy.sh>.
// Licensed under the MIT Licence - https://raw.githubusercontent.com/ppy/osu/master/LICENCE

using OpenTK.Graphics;
using osu.Game.Beatmaps.Timing;
using osu.Game.Database;
using osu.Game.Modes;
using osu.Game.Modes.Objects;
using System.Collections.Generic;
using System.Linq;

namespace osu.Game.Beatmaps
{
    public class BeatmapBase
    {
        private BeatmapBase original;

        public BeatmapBase(BeatmapBase original = null)
        {
            this.original = original;
        }

        private BeatmapInfo beatmapInfo;
        public BeatmapInfo BeatmapInfo
        {
            get { return beatmapInfo ?? original?.BeatmapInfo; }
            set { beatmapInfo = value; }
        }

        private List<ControlPoint> controlPoints;
        public List<ControlPoint> ControlPoints
        {
            get { return controlPoints ?? original?.ControlPoints; }
            set { controlPoints = value; }
        }

        private List<Color4> comboColors;
        public List<Color4> ComboColors
        {
            get { return comboColors ?? original?.ComboColors; }
            set { comboColors = value; }
        }

        public BeatmapMetadata Metadata => BeatmapInfo?.Metadata ?? BeatmapInfo?.BeatmapSet?.Metadata;
    }

    /// <summary>
    /// A generic beatmap that does not contain HitObjects.
    /// </summary>
    public class Beatmap<T> : BeatmapBase
        where T : HitObject
    {
        public List<T> HitObjects;

        public Beatmap(BeatmapBase original = null)
            : base(original)
        {
        }

        public double BPMMaximum => 60000 / (ControlPoints?.Where(c => c.BeatLength != 0).OrderBy(c => c.BeatLength).FirstOrDefault() ?? ControlPoint.Default).BeatLength;
        public double BPMMinimum => 60000 / (ControlPoints?.Where(c => c.BeatLength != 0).OrderByDescending(c => c.BeatLength).FirstOrDefault() ?? ControlPoint.Default).BeatLength;
        public double BPMMode => BPMAt(ControlPoints.Where(c => c.BeatLength != 0).GroupBy(c => c.BeatLength).OrderByDescending(grp => grp.Count()).First().First().Time);

        public double BPMAt(double time)
        {
            return 60000 / BeatLengthAt(time);
        }

        public double BeatLengthAt(double time)
        {
            ControlPoint overridePoint;
            ControlPoint timingPoint = TimingPointAt(time, out overridePoint);
            return timingPoint.BeatLength;
        }

        public ControlPoint TimingPointAt(double time, out ControlPoint overridePoint)
        {
            overridePoint = null;

            ControlPoint timingPoint = null;
            foreach (var controlPoint in ControlPoints)
            {
                // Some beatmaps have the first timingPoint (accidentally) start after the first HitObject(s).
                // This null check makes it so that the first ControlPoint that makes a timing change is used as
                // the timingPoint for those HitObject(s).
                if (controlPoint.Time <= time || timingPoint == null)
                {
                    if (controlPoint.TimingChange)
                    {
                        timingPoint = controlPoint;
                        overridePoint = null;
                    }
                    else overridePoint = controlPoint;
                }
                else break;
            }

            return timingPoint ?? ControlPoint.Default;
        }
    }

    public class Beatmap : Beatmap<HitObject>
    {
        public Beatmap(BeatmapBase original = null)
            : base(original)
        {
        }

        public double CalculateStarDifficulty() => Ruleset.GetRuleset(BeatmapInfo.Mode).CreateDifficultyCalculator(this).Calculate();

        public Beatmap<T> ConvertTo<T>() where T : HitObject
        {
            return Ruleset.GetRuleset(BeatmapInfo.Mode).CreateBeatmapConverter<T>().Convert(this);
        }
    }
}