protected override IEnumerable <TaikoHitObject> ConvertHitObject(HitObject obj, IBeatmap beatmap) { // Old osu! used hit sounding to determine various hit type information IList <HitSampleInfo> samples = obj.Samples; bool strong = samples.Any(s => s.Name == HitSampleInfo.HIT_FINISH); switch (obj) { case IHasDistance distanceData: { // Number of spans of the object - one for the initial length and for each repeat int spans = (obj as IHasRepeats)?.SpanCount() ?? 1; TimingControlPoint timingPoint = beatmap.ControlPointInfo.TimingPointAt(obj.StartTime); DifficultyControlPoint difficultyPoint = beatmap.ControlPointInfo.DifficultyPointAt(obj.StartTime); double speedAdjustment = difficultyPoint.SpeedMultiplier; double speedAdjustedBeatLength = timingPoint.BeatLength / speedAdjustment; // The true distance, accounting for any repeats. This ends up being the drum roll distance later double distance = distanceData.Distance * spans * LEGACY_VELOCITY_MULTIPLIER; // The velocity of the taiko hit object - calculated as the velocity of a drum roll double taikoVelocity = taiko_base_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier / speedAdjustedBeatLength; // The duration of the taiko hit object double taikoDuration = distance / taikoVelocity; // The velocity of the osu! hit object - calculated as the velocity of a slider double osuVelocity = osu_base_scoring_distance * beatmap.BeatmapInfo.BaseDifficulty.SliderMultiplier / speedAdjustedBeatLength; // The duration of the osu! hit object double osuDuration = distance / osuVelocity; // osu-stable always uses the speed-adjusted beatlength to determine the velocities, but // only uses it for tick rate if beatmap version < 8 if (beatmap.BeatmapInfo.BeatmapVersion >= 8) { speedAdjustedBeatLength *= speedAdjustment; } // If the drum roll is to be split into hit circles, assume the ticks are 1/8 spaced within the duration of one beat double tickSpacing = Math.Min(speedAdjustedBeatLength / beatmap.BeatmapInfo.BaseDifficulty.SliderTickRate, taikoDuration / spans); if (!isForCurrentRuleset && tickSpacing > 0 && osuDuration < 2 * speedAdjustedBeatLength) { List <IList <HitSampleInfo> > allSamples = obj is IHasCurve curveData ? curveData.NodeSamples : new List <IList <HitSampleInfo> >(new[] { samples }); int i = 0; for (double j = obj.StartTime; j <= obj.StartTime + taikoDuration + tickSpacing / 8; j += tickSpacing) { IList <HitSampleInfo> currentSamples = allSamples[i]; bool isRim = currentSamples.Any(s => s.Name == HitSampleInfo.HIT_CLAP || s.Name == HitSampleInfo.HIT_WHISTLE); strong = currentSamples.Any(s => s.Name == HitSampleInfo.HIT_FINISH); yield return(new Hit { StartTime = j, Type = isRim ? HitType.Rim : HitType.Centre, Samples = currentSamples, IsStrong = strong }); i = (i + 1) % allSamples.Count; } } else { yield return(new DrumRoll { StartTime = obj.StartTime, Samples = obj.Samples, IsStrong = strong, Duration = taikoDuration, TickRate = beatmap.BeatmapInfo.BaseDifficulty.SliderTickRate == 3 ? 3 : 4 }); } break; } case IHasEndTime endTimeData: { double hitMultiplier = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty, 3, 5, 7.5) * swell_hit_multiplier; yield return(new Swell { StartTime = obj.StartTime, Samples = obj.Samples, Duration = endTimeData.Duration, RequiredHits = (int)Math.Max(1, endTimeData.Duration / 1000 * hitMultiplier) }); break; } default: { bool isRim = samples.Any(s => s.Name == HitSampleInfo.HIT_CLAP || s.Name == HitSampleInfo.HIT_WHISTLE); yield return(new Hit { StartTime = obj.StartTime, Type = isRim ? HitType.Rim : HitType.Centre, Samples = obj.Samples, IsStrong = strong }); break; } } }
public override void ApplyDefaults(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty) { base.ApplyDefaults(controlPointInfo, difficulty); Scale = 1.0f - 0.7f * (difficulty.CircleSize - 5) / 5; }
/// <summary> /// Transfer initial settings from the beatmap to settings. /// </summary> /// <param name="difficulty">The beatmap's initial values.</param> protected virtual void TransferSettings(BeatmapDifficulty difficulty) { TransferSetting(DrainRate, difficulty.DrainRate); TransferSetting(OverallDifficulty, difficulty.OverallDifficulty); }
private void songDetail_didPressPlayButtonEvent(IBeatmapLevel level, BeatmapCharacteristicSO characteristic, BeatmapDifficulty difficulty) { _lastPlayedBeatmapLevel = level; _lastPlayedCharacteristic = characteristic; _lastPlayedDifficulty = difficulty; var playerData = Resources.FindObjectsOfTypeAll <PlayerDataModel>().First().playerData; var playerSettings = playerData.playerSpecificSettings; //Override defaults if we have forced options enabled if (_currentParameters.PlayerSettings.Options != PlayerOptions.None) { playerSettings = new PlayerSpecificSettings( _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.LeftHanded), _currentParameters.PlayerSettings.PlayerHeight, _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.AutoPlayerHeight), _currentParameters.PlayerSettings.SfxVolume, _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.ReduceDebris), _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.NoHud), _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.NoFailEffects), _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.AdvancedHud), _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.AutoRestart), _currentParameters.PlayerSettings.SaberTrailIntensity, _currentParameters.PlayerSettings.NoteJumpStartBeatOffset, _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.HideNoteSpawnEffect), _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.AdaptiveSfx), _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.StaticLights) ? EnvironmentEffectsFilterPreset.NoEffects : EnvironmentEffectsFilterPreset.AllEffects, _currentParameters.PlayerSettings.Options.HasFlag(PlayerOptions.StaticLights) ? EnvironmentEffectsFilterPreset.NoEffects : EnvironmentEffectsFilterPreset.AllEffects ); } var songSpeed = GameplayModifiers.SongSpeed.Normal; if (_currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.SlowSong)) { songSpeed = GameplayModifiers.SongSpeed.Slower; } if (_currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.FastSong)) { songSpeed = GameplayModifiers.SongSpeed.Faster; } if (_currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.SuperFastSong)) { songSpeed = GameplayModifiers.SongSpeed.SuperFast; } var gameplayModifiers = new GameplayModifiers( _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.DemoNoFail), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.DemoNoObstacles), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.BatteryEnergy) ? GameplayModifiers.EnergyType.Battery : GameplayModifiers.EnergyType.Bar, _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.NoFail), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.InstaFail), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.FailOnClash), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.NoObstacles) ? GameplayModifiers.EnabledObstacleType.NoObstacles : GameplayModifiers.EnabledObstacleType.All, _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.NoBombs), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.FastNotes), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.StrictAngles), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.DisappearingArrows), songSpeed, _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.NoArrows), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.GhostNotes), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.ProMode), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.ZenMode), _currentParameters.GameplayModifiers.Options.HasFlag(GameOptions.SmallCubes) ); var colorScheme = playerData.colorSchemesSettings.overrideDefaultColors ? playerData.colorSchemesSettings.GetSelectedColorScheme() : null; //Disable scores if we need to if (((QualifierEvent.EventSettings)Event.Flags).HasFlag(QualifierEvent.EventSettings.DisableScoresaberSubmission)) { BS_Utils.Gameplay.ScoreSubmission.DisableSubmission(SharedConstructs.Name); } SongUtils.PlaySong(level, characteristic, difficulty, playerData.overrideEnvironmentSettings, colorScheme, gameplayModifiers, playerSettings, SongFinished); }
public PreviewBeatmapPacket Init(string levelId, string songName, string songSubName, string songAuthorName, string levelAuthorName, string characteristic, BeatmapDifficulty difficulty) { this.levelId = levelId; this.songName = songName; this.songSubName = songSubName; this.songAuthorName = songAuthorName; this.levelAuthorName = levelAuthorName; this.characteristic = characteristic; this.difficulty = difficulty; return(this); }
/// <summary> /// Apply all custom settings to the provided beatmap. /// </summary> /// <param name="difficulty">The beatmap to have settings applied.</param> protected virtual void ApplySettings(BeatmapDifficulty difficulty) { ApplySetting(DrainRate, dr => difficulty.DrainRate = dr); ApplySetting(OverallDifficulty, od => difficulty.OverallDifficulty = od); }
protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty) { base.ApplyDefaultsToSelf(controlPointInfo, difficulty); TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime); tickSpacing = timingPoint.BeatLength / difficulty.SliderTickRate; }
public AiReportDifficultyOneObject(BeatmapDifficulty difficulty, string condition, HitObjectBase h1, GameMode Mode = GameMode.All) : base(h1, null, Severity.Info, difficulty + " criteria: " + condition,0) { }
/// <summary> /// Apply all custom settings to the provided beatmap. /// </summary> /// <param name="difficulty">The beatmap to have settings applied.</param> protected virtual void ApplySettings(BeatmapDifficulty difficulty) { difficulty.DrainRate = DrainRate.Value; difficulty.OverallDifficulty = OverallDifficulty.Value; }
public CatchPlayfield(BeatmapDifficulty difficulty) { this.difficulty = difficulty; }
/// <summary> /// Transfer initial settings from the beatmap to settings. /// </summary> /// <param name="difficulty">The beatmap's initial values.</param> protected virtual void TransferSettings(BeatmapDifficulty difficulty) { DrainRate.Value = DrainRate.Default = difficulty.DrainRate; OverallDifficulty.Value = OverallDifficulty.Default = difficulty.OverallDifficulty; }
public void ReadFromDifficulty(BeatmapDifficulty difficulty) { }
protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double clockRate) { var hitObjects = beatmap.HitObjects as List <OsuHitObject>; double mapLength = 0; if (beatmap.HitObjects.Count > 0) { mapLength = (beatmap.HitObjects.Last().StartTime - beatmap.HitObjects.First().StartTime) / 1000 / clockRate; } double preemptNoClockRate = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450); var noteDensities = NoteDensity.CalculateNoteDensities(hitObjects, preemptNoClockRate); // Tap var tapAttributes = Tap.CalculateTapAttributes(hitObjects, clockRate); // Finger Control double fingerControlDiff = FingerControl.CalculateFingerControlDiff(hitObjects, clockRate); // Aim var aimAttributes = Aim.CalculateAimAttributes(hitObjects, clockRate, tapAttributes.StrainHistory, noteDensities); double tapSr = tap_multiplier * Math.Pow(tapAttributes.TapDifficulty, sr_exponent); double aimSr = aim_multiplier * Math.Pow(aimAttributes.FcProbabilityThroughput, sr_exponent); double fingerControlSr = finger_control_multiplier * Math.Pow(fingerControlDiff, sr_exponent); double sr = Mean.PowerMean(new[] { tapSr, aimSr, fingerControlSr }, 7) * 1.131; HitWindows hitWindows = new OsuHitWindows(); hitWindows.SetDifficulty(beatmap.BeatmapInfo.BaseDifficulty.OverallDifficulty); // Todo: These int casts are temporary to achieve 1:1 results with osu!stable, and should be removed in the future double hitWindowGreat = (int)(hitWindows.WindowFor(HitResult.Great)) / clockRate; double preempt = (int)BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / clockRate; int maxCombo = beatmap.HitObjects.Count; // Add the ticks + tail of the slider. 1 is subtracted because the head circle would be counted twice (once for the slider itself in the line above) maxCombo += beatmap.HitObjects.OfType <Slider>().Sum(s => s.NestedHitObjects.Count - 1); return(new OsuDifficultyAttributes { StarRating = sr, Mods = mods, Length = mapLength, TapSr = tapSr, TapDiff = tapAttributes.TapDifficulty, StreamNoteCount = tapAttributes.StreamNoteCount, MashTapDiff = tapAttributes.MashedTapDifficulty, FingerControlSr = fingerControlSr, FingerControlDiff = fingerControlDiff, AimSr = aimSr, AimDiff = aimAttributes.FcProbabilityThroughput, AimHiddenFactor = aimAttributes.HiddenFactor, ComboTps = aimAttributes.ComboThroughputs, MissTps = aimAttributes.MissThroughputs, MissCounts = aimAttributes.MissCounts, CheeseNoteCount = aimAttributes.CheeseNoteCount, CheeseLevels = aimAttributes.CheeseLevels, CheeseFactors = aimAttributes.CheeseFactors, ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5, OverallDifficulty = (80 - hitWindowGreat) / 6, MaxCombo = maxCombo }); }
protected override DifficultyAttributes Calculate(IBeatmap beatmap, Mod[] mods, double timeRate) { if (!beatmap.HitObjects.Any()) { return(new OsuDifficultyAttributes(mods, 0)); } OsuDifficultyBeatmap difficultyBeatmap = new OsuDifficultyBeatmap(beatmap.HitObjects.Cast <OsuHitObject>().ToList(), timeRate); Skill[] skills = { new Aim(), new Speed() }; double sectionLength = section_length * timeRate; // The first object doesn't generate a strain, so we begin with an incremented section end double currentSectionEnd = 2 * sectionLength; foreach (OsuDifficultyHitObject h in difficultyBeatmap) { while (h.BaseObject.StartTime > currentSectionEnd) { foreach (Skill s in skills) { s.SaveCurrentPeak(); s.StartNewSectionFrom(currentSectionEnd); } currentSectionEnd += sectionLength; } foreach (Skill s in skills) { s.Process(h); } } double aimRating = Math.Sqrt(skills[0].DifficultyValue()) * difficulty_multiplier; double speedRating = Math.Sqrt(skills[1].DifficultyValue()) * difficulty_multiplier; double starRating = aimRating + speedRating + Math.Abs(aimRating - speedRating) / 2; // Todo: These int casts are temporary to achieve 1:1 results with osu!stable, and should be removed in the future double hitWindowGreat = (int)(beatmap.HitObjects.First().HitWindows.Great / 2) / timeRate; double preempt = (int)BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450) / timeRate; int maxCombo = beatmap.HitObjects.Count(); // Add the ticks + tail of the slider. 1 is subtracted because the head circle would be counted twice (once for the slider itself in the line above) maxCombo += beatmap.HitObjects.OfType <Slider>().Sum(s => s.NestedHitObjects.Count - 1); return(new OsuDifficultyAttributes(mods, starRating) { AimStrain = aimRating, SpeedStrain = speedRating, ApproachRate = preempt > 1200 ? (1800 - preempt) / 120 : (1200 - preempt) / 150 + 5, OverallDifficulty = (80 - hitWindowGreat) / 6, MaxCombo = maxCombo }); }
public DrawableCatchRuleset(Ruleset ruleset, WorkingBeatmap beatmap) : base(ruleset, beatmap) { Direction.Value = ScrollingDirection.Down; TimeRange.Value = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.ApproachRate, 1800, 1200, 450); }
public AiReportDifficultyOneObject(BeatmapDifficulty difficulty, string condition, HitObjectBase h1) : base(h1,h1.StartTime, null, Severity.Info, difficulty + " criteria: " + condition,0) { }
public void ApplyToDifficulty(BeatmapDifficulty difficulty) { // Decrease AR to increase preempt time difficulty.ApproachRate *= 0.5f; }
protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty) { base.ApplyDefaultsToSelf(controlPointInfo, difficulty); double offset; if (SpanIndex > 0) { // Adding 200 to include the offset stable used. // This is so on repeats ticks don't appear too late to be visually processed by the player. offset = 200; } else { offset = TimeFadeIn * 0.66f; } TimePreempt = (StartTime - SpanStartTime) / 2 + offset; }
public void StartLevel(IPreviewBeatmapLevel song, BeatmapCharacteristicSO characteristic, BeatmapDifficulty difficulty, GameplayModifiers modifiers) { if (connected && networkClient != null) { #if DEBUG Plugin.log.Info("Starting level..."); #endif NetOutgoingMessage outMsg = networkClient.CreateMessage(); outMsg.Write((byte)CommandType.StartLevel); new LevelOptionsInfo(difficulty, modifiers, characteristic.serializedName).AddToMessage(outMsg); SongInfo selectedSong = new SongInfo(song); selectedSong.songDuration = selectedSong.songDuration / modifiers.songSpeedMul; selectedSong.AddToMessage(outMsg); networkClient.SendMessage(outMsg, NetDeliveryMethod.ReliableOrdered, 0); } }
public PreviewBeatmapPacket FromPreview(PreviewBeatmapStub preview, string characteristic, BeatmapDifficulty difficulty) { this.levelId = preview.levelID; this.songName = preview.songName; this.songSubName = preview.songSubName; this.songAuthorName = preview.songAuthorName; this.levelAuthorName = preview.levelAuthorName; this.characteristic = characteristic; this.difficulty = difficulty; return(this); }
//Returns the next-highest difficulty to the one provided private static IDifficultyBeatmap GetHigherDifficulty(IDifficultyBeatmap[] availableMaps, BeatmapDifficulty difficulty, BeatmapCharacteristicSO characteristic) { var ret = availableMaps.SkipWhile(x => x.difficulty < difficulty).FirstOrDefault(); if (ret is CustomLevel.CustomDifficultyBeatmap) { var extras = Collections.RetrieveExtraSongData(ret.level.levelID); var requirements = extras?.difficulties.First(x => x.difficulty == ret.difficulty).additionalDifficultyData.requirements; Logger.Debug($"{ret.level.songName} is a custom level, checking for requirements on {ret.difficulty}..."); if ( (requirements?.Count() > 0) && (!requirements?.ToList().All(x => Collections.capabilities.Contains(x)) ?? false) ) { ret = null; } Logger.Debug((ret == null ? "Requirement not met." : "Requirement met!")); } return(ret); }
public void ApplyToDifficulty(BeatmapDifficulty difficulty) => ApplySettings(difficulty);
private void assertOk(List <HitObject> hitObjects, BeatmapDifficulty beatmapDifficulty) { Assert.That(check.Run(getContext(hitObjects, beatmapDifficulty)), Is.Empty); }
protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty) { base.ApplyDefaultsToSelf(controlPointInfo, difficulty); TimingControlPoint timingPoint = controlPointInfo.TimingPointAt(StartTime); DifficultyControlPoint difficultyPoint = controlPointInfo.DifficultyPointAt(StartTime); double scoringDistance = base_scoring_distance * difficulty.SliderMultiplier * difficultyPoint.SpeedMultiplier; Velocity = scoringDistance / timingPoint.BeatLength; TickDistance = scoringDistance / difficulty.SliderTickRate; }
public void Setup() { check = new CheckTooShortSpinners(); difficulty = new BeatmapDifficulty(); }
public TestCatcherArea(BeatmapDifficulty beatmapDifficulty) : base(beatmapDifficulty) { }
//Returns the closest difficulty to the one provided, preferring lower difficulties first if any exist public static IDifficultyBeatmap GetClosestDifficultyPreferLower(IBeatmapLevel level, BeatmapDifficulty difficulty, BeatmapCharacteristicSO characteristic = null) { //First, look at the characteristic parameter. If there's something useful in there, we try to use it, but fall back to Standard var desiredCharacteristic = level.beatmapLevelData.difficultyBeatmapSets.FirstOrDefault(x => x.beatmapCharacteristic.serializedName == (characteristic?.serializedName ?? "Standard")) ?? level.beatmapLevelData.difficultyBeatmapSets.First(); IDifficultyBeatmap[] availableMaps = level .beatmapLevelData .difficultyBeatmapSets .FirstOrDefault(x => x.beatmapCharacteristic.serializedName == desiredCharacteristic.beatmapCharacteristic.serializedName) .difficultyBeatmaps .OrderBy(x => x.difficulty) .ToArray(); IDifficultyBeatmap ret = availableMaps.FirstOrDefault(x => x.difficulty == difficulty); if (ret is CustomDifficultyBeatmap) { var extras = Collections.RetrieveExtraSongData(ret.level.levelID); var requirements = extras?._difficulties.First(x => x._difficulty == ret.difficulty).additionalDifficultyData._requirements; if ( (requirements?.Count() > 0) && (!requirements?.ToList().All(x => Collections.capabilities.Contains(x)) ?? false) ) { ret = null; } } if (ret == null) { ret = GetLowerDifficulty(availableMaps, difficulty, desiredCharacteristic.beatmapCharacteristic); } if (ret == null) { ret = GetHigherDifficulty(availableMaps, difficulty, desiredCharacteristic.beatmapCharacteristic); } return(ret); }
protected override void ApplyDefaultsToSelf(ControlPointInfo controlPointInfo, BeatmapDifficulty difficulty) { base.ApplyDefaultsToSelf(controlPointInfo, difficulty); SpinsRequired = 1; }
//Returns the next-highest difficulty to the one provided private static IDifficultyBeatmap GetHigherDifficulty(IDifficultyBeatmap[] availableMaps, BeatmapDifficulty difficulty, BeatmapCharacteristicSO characteristic) { var ret = availableMaps.SkipWhile(x => x.difficulty < difficulty).FirstOrDefault(); if (ret is CustomDifficultyBeatmap) { var extras = Collections.RetrieveExtraSongData(ret.level.levelID); var requirements = extras?._difficulties.First(x => x._difficulty == ret.difficulty).additionalDifficultyData._requirements; if ( (requirements?.Count() > 0) && (!requirements?.ToList().All(x => Collections.capabilities.Contains(x)) ?? false) ) { ret = null; } } return(ret); }
protected override void ApplyBeatmap(Beatmap <TaikoHitObject> beatmap) { base.ApplyBeatmap(beatmap); hpMultiplier = 1 / (object_count_factor * beatmap.HitObjects.FindAll(o => o is Hit).Count *BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.DrainRate, 0.5, 0.75, 0.98)); hpMissMultiplier = BeatmapDifficulty.DifficultyRange(beatmap.BeatmapInfo.BaseDifficulty.DrainRate, 0.0018, 0.0075, 0.0120); }
public static async void PlaySong(IPreviewBeatmapLevel level, BeatmapCharacteristicSO characteristic, BeatmapDifficulty difficulty, PlaySong packet) { flow = (SoloFreePlayFlowCoordinator)Resources.FindObjectsOfTypeAll <MainFlowCoordinator>().First().GetField("_soloFreePlayFlowCoordinator"); Action <IBeatmapLevel> SongLoaded = (loadedLevel) => { Logger.Debug("G"); MenuTransitionsHelper _menuSceneSetupData = Resources.FindObjectsOfTypeAll <MenuTransitionsHelper>().First(); IDifficultyBeatmap diffbeatmap = loadedLevel.beatmapLevelData.GetDifficultyBeatmap(characteristic, difficulty); Logger.Debug("L"); GameplaySetupViewController gameplaySetupViewController = (GameplaySetupViewController)typeof(SinglePlayerLevelSelectionFlowCoordinator).GetField("_gameplaySetupViewController", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(flow); Logger.Debug("D"); OverrideEnvironmentSettings environmentSettings = gameplaySetupViewController.environmentOverrideSettings; ColorScheme scheme = gameplaySetupViewController.colorSchemesSettings.GetSelectedColorScheme(); //GameplayModifiers modifiers = gameplaySetupViewController.gameplayModifiers; PlayerSpecificSettings settings = gameplaySetupViewController.playerSettings; //TODO: re add modifier customizability PracticeSettings practiceSettings = ConvertPractice(packet.practiceSettings); GameplayModifiers modifiers = ConvertModifiers(packet.gameplayModifiers, gameplaySetupViewController.gameplayModifiers); Logger.Debug(diffbeatmap.level.levelID + " " + scheme.colorSchemeId); _menuSceneSetupData.StartStandardLevel( "Solo", diffbeatmap, diffbeatmap.level, environmentSettings, scheme, modifiers, settings, practiceSettings, "Menu", false, null, new Action <StandardLevelScenesTransitionSetupDataSO, LevelCompletionResults>((StandardLevelScenesTransitionSetupDataSO q, LevelCompletionResults r) => { }) ); }; if (flow == null || flow.gameObject == null || !flow.gameObject.activeInHierarchy) { Button button = Resources.FindObjectsOfTypeAll <Button>().Where(x => x != null && x.name == "SoloButton").First(); button.onClick.Invoke(); } if ((level is PreviewBeatmapLevelSO && await HasDLCLevel(level.levelID)) || level is CustomPreviewBeatmapLevel) { Logger.Debug("Loading DLC/Custom level..."); var result = await GetLevelFromPreview(level); if (!(result?.isError == true)) { SongLoaded(result?.beatmapLevel); return; } Logger.Debug("You Suck Idiot"); } else if (level is BeatmapLevelSO) { Logger.Debug("Reading OST data without songloader..."); SongLoaded(level as IBeatmapLevel); } else { Logger.Debug($"Skipping unowned DLC ({level.songName})"); } }
public AiReportDifficulty(BeatmapDifficulty difficulty, string condition) : base(Severity.Info,difficulty + " criteria: " + condition) { }
public static IDifficultyBeatmap GetDifficultyBeatmap(this IBeatmapLevel level, BeatmapCharacteristicSO characteristic, BeatmapDifficulty difficulty, bool strictDifficulty = false) { IDifficultyBeatmapSet difficultySet = null; if (characteristic == null) { difficultySet = level.beatmapLevelData.difficultyBeatmapSets.FirstOrDefault(); } else { difficultySet = level.beatmapLevelData.difficultyBeatmapSets.FirstOrDefault(x => x.beatmapCharacteristic == characteristic); if (difficultySet == null) { difficultySet = level.beatmapLevelData.difficultyBeatmapSets.FirstOrDefault(); } } if (difficultySet == null) { Plugin.log.Error("Unable to find any difficulty set!"); return(null); } IDifficultyBeatmap beatmap = difficultySet.difficultyBeatmaps.FirstOrDefault(x => x.difficulty == difficulty); if (beatmap == null && !strictDifficulty) { int index = GetClosestDifficultyIndex(difficultySet.difficultyBeatmaps, difficulty); if (index >= 0) { return(difficultySet.difficultyBeatmaps[index]); } else { Plugin.log.Error("Unable to find difficulty!"); return(null); } } else { return(beatmap); } }
public AiReportDifficultyTwoObjects(BeatmapDifficulty difficulty, string condition, HitObjectBase h1, HitObjectBase h2) : base(h1, h2, null, Severity.Info, difficulty + " criteria: " + condition, 0) { }
// Token: 0x06001A7C RID: 6780 // RVA: 0x000819F0 File Offset: 0x0007FBF0 private void method_2() { double num = Class466.Current.method_14(); if (num < 2.0) { this.beatmapDifficulty_0 = BeatmapDifficulty.Easy; return; } if (num < 3.5) { this.beatmapDifficulty_0 = BeatmapDifficulty.Normal; return; } if (num < 4.5) { this.beatmapDifficulty_0 = BeatmapDifficulty.Hard; return; } if (num < 5.0) { this.beatmapDifficulty_0 = BeatmapDifficulty.Insane; return; } this.beatmapDifficulty_0 = BeatmapDifficulty.Expert; }