1
0
mirror of https://github.com/ppy/osu.git synced 2024-12-16 22:22:54 +08:00
osu-lazer/osu.Game.Rulesets.Osu/Mods/OsuModRandom.cs

166 lines
7.3 KiB
C#
Raw Normal View History

2021-04-25 06:39:36 +08:00
// Copyright (c) ppy Pty Ltd <contact@ppy.sh>. Licensed under the MIT Licence.
// See the LICENCE file in the repository root for full licence text.
using System;
using System.Collections.Generic;
using System.Linq;
using osu.Framework.Bindables;
2022-08-11 04:09:11 +08:00
using osu.Framework.Localisation;
2021-04-28 04:19:04 +08:00
using osu.Framework.Utils;
2021-04-25 06:39:36 +08:00
using osu.Game.Beatmaps;
using osu.Game.Configuration;
using osu.Game.Overlays.Settings;
2021-04-25 06:39:36 +08:00
using osu.Game.Rulesets.Mods;
using osu.Game.Rulesets.Objects;
using osu.Game.Rulesets.Osu.Beatmaps;
2022-06-20 05:03:41 +08:00
using osu.Game.Rulesets.Osu.Objects;
2021-04-25 06:39:36 +08:00
using osu.Game.Rulesets.Osu.UI;
using osu.Game.Rulesets.Osu.Utils;
2021-04-25 06:39:36 +08:00
namespace osu.Game.Rulesets.Osu.Mods
{
/// <summary>
/// Mod that randomises the positions of the <see cref="HitObject"/>s
/// </summary>
public class OsuModRandom : ModRandom, IApplicableToBeatmap
2021-04-25 06:39:36 +08:00
{
2022-08-11 04:09:11 +08:00
public override LocalisableString Description => "It never gets boring!";
2022-11-01 18:47:20 +08:00
public override Type[] IncompatibleMods => base.IncompatibleMods.Append(typeof(OsuModTargetPractice)).ToArray();
2022-04-28 11:15:04 +08:00
[SettingSource("Angle sharpness", "How sharp angles should be", SettingControlType = typeof(SettingsSlider<float>))]
2022-09-26 03:49:22 +08:00
public BindableFloat AngleSharpness { get; } = new BindableFloat(7)
{
MinValue = 1,
MaxValue = 10,
Precision = 0.1f
};
2022-06-20 05:03:41 +08:00
private static readonly float playfield_diagonal = OsuPlayfield.BASE_SIZE.LengthFast;
private Random random = null!;
public void ApplyToBeatmap(IBeatmap beatmap)
2021-04-25 06:39:36 +08:00
{
if (beatmap is not OsuBeatmap osuBeatmap)
return;
Seed.Value ??= RNG.Next();
random = new Random((int)Seed.Value);
var positionInfos = OsuHitObjectGenerationUtils.GeneratePositionInfos(osuBeatmap.HitObjects);
// Offsets the angles of all hit objects in a "section" by the same amount.
float sectionOffset = 0;
// Whether the angles are positive or negative (clockwise or counter-clockwise flow).
2022-06-19 19:07:10 +08:00
bool flowDirection = false;
2022-06-19 19:07:10 +08:00
for (int i = 0; i < positionInfos.Count; i++)
{
2022-08-15 01:02:29 +08:00
if (shouldStartNewSection(osuBeatmap, positionInfos, i))
{
sectionOffset = getRandomOffset(0.0008f);
2022-07-27 01:07:25 +08:00
flowDirection = !flowDirection;
2022-06-19 19:07:10 +08:00
}
2022-12-07 07:40:18 +08:00
if (positionInfos[i].HitObject is Slider slider && random.NextDouble() < 0.5)
{
OsuHitObjectGenerationUtils.FlipSliderInPlaceHorizontally(slider);
2022-12-07 07:40:18 +08:00
}
2022-06-19 19:07:10 +08:00
if (i == 0)
{
positionInfos[i].DistanceFromPrevious = (float)(random.NextDouble() * OsuPlayfield.BASE_SIZE.Y / 2);
positionInfos[i].RelativeAngle = (float)(random.NextDouble() * 2 * Math.PI - Math.PI);
}
else
{
// Offsets only the angle of the current hit object if a flow change occurs.
2022-06-19 19:07:10 +08:00
float flowChangeOffset = 0;
// Offsets only the angle of the current hit object.
float oneTimeOffset = getRandomOffset(0.002f);
2022-06-19 19:07:10 +08:00
2022-08-15 01:02:29 +08:00
if (shouldApplyFlowChange(positionInfos, i))
2022-06-19 19:07:10 +08:00
{
flowChangeOffset = getRandomOffset(0.002f);
2022-06-20 05:03:41 +08:00
flowDirection = !flowDirection;
2022-07-27 01:07:25 +08:00
}
2022-06-19 19:07:10 +08:00
float totalOffset =
// sectionOffset and oneTimeOffset should mainly affect patterns with large spacing.
(sectionOffset + oneTimeOffset) * positionInfos[i].DistanceFromPrevious +
// flowChangeOffset should mainly affect streams.
flowChangeOffset * (playfield_diagonal - positionInfos[i].DistanceFromPrevious);
positionInfos[i].RelativeAngle = getRelativeTargetAngle(positionInfos[i].DistanceFromPrevious, totalOffset, flowDirection);
}
}
osuBeatmap.HitObjects = OsuHitObjectGenerationUtils.RepositionHitObjects(positionInfos);
}
2022-06-20 05:03:41 +08:00
private float getRandomOffset(float stdDev)
{
2022-09-21 05:13:38 +08:00
// Range: [0.5, 2]
// Higher angle sharpness -> lower multiplier
2022-09-21 05:11:38 +08:00
float customMultiplier = (1.5f * AngleSharpness.MaxValue - AngleSharpness.Value) / (1.5f * AngleSharpness.MaxValue - AngleSharpness.Default);
return OsuHitObjectGenerationUtils.RandomGaussian(random, 0, stdDev * customMultiplier);
}
2022-06-20 05:03:41 +08:00
/// <param name="targetDistance">The target distance between the previous and the current <see cref="OsuHitObject"/>.</param>
/// <param name="offset">The angle (in rad) by which the target angle should be offset.</param>
/// <param name="flowDirection">Whether the relative angle should be positive or negative.</param>
private float getRelativeTargetAngle(float targetDistance, float offset, bool flowDirection)
2022-06-20 05:03:41 +08:00
{
2022-09-21 05:13:38 +08:00
// Range: [0.1, 1]
float angleSharpness = AngleSharpness.Value / AngleSharpness.MaxValue;
2022-09-21 05:13:38 +08:00
// Range: [0, 0.9]
float angleWideness = 1 - angleSharpness;
2022-09-21 05:13:38 +08:00
// Range: [-60, 30]
float customOffsetX = angleSharpness * 100 - 70;
2022-09-21 05:13:38 +08:00
// Range: [-0.075, 0.15]
float customOffsetY = angleWideness * 0.25f - 0.075f;
targetDistance += customOffsetX;
float angle = (float)(2.16 / (1 + 200 * Math.Exp(0.036 * (targetDistance - 310 + customOffsetX))) + 0.5);
angle += offset + customOffsetY;
2022-06-20 05:03:41 +08:00
float relativeAngle = (float)Math.PI - angle;
2022-06-20 05:03:41 +08:00
return flowDirection ? -relativeAngle : relativeAngle;
}
/// <returns>Whether a new section should be started at the current <see cref="OsuHitObject"/>.</returns>
2022-08-15 01:02:29 +08:00
private bool shouldStartNewSection(OsuBeatmap beatmap, IReadOnlyList<OsuHitObjectGenerationUtils.ObjectPositionInfo> positionInfos, int i)
{
if (i == 0)
return true;
// Exclude new-combo-spam and 1-2-combos.
bool previousObjectStartedCombo = positionInfos[Math.Max(0, i - 2)].HitObject.IndexInCurrentCombo > 1 &&
positionInfos[i - 1].HitObject.NewCombo;
bool previousObjectWasOnDownbeat = OsuHitObjectGenerationUtils.IsHitObjectOnBeat(beatmap, positionInfos[i - 1].HitObject, true);
bool previousObjectWasOnBeat = OsuHitObjectGenerationUtils.IsHitObjectOnBeat(beatmap, positionInfos[i - 1].HitObject);
return (previousObjectStartedCombo && random.NextDouble() < 0.6f) ||
2022-08-15 01:02:29 +08:00
previousObjectWasOnDownbeat ||
(previousObjectWasOnBeat && random.NextDouble() < 0.4f);
2022-08-15 01:02:29 +08:00
}
/// <returns>Whether a flow change should be applied at the current <see cref="OsuHitObject"/>.</returns>
2022-08-15 01:02:29 +08:00
private bool shouldApplyFlowChange(IReadOnlyList<OsuHitObjectGenerationUtils.ObjectPositionInfo> positionInfos, int i)
{
// Exclude new-combo-spam and 1-2-combos.
bool previousObjectStartedCombo = positionInfos[Math.Max(0, i - 2)].HitObject.IndexInCurrentCombo > 1 &&
positionInfos[i - 1].HitObject.NewCombo;
return previousObjectStartedCombo && random.NextDouble() < 0.6f;
2022-08-15 01:02:29 +08:00
}
}
2021-04-25 06:39:36 +08:00
}