/// <summary>
/// Adds a gameplayModifier to our list, getting rid of any incompatible mods that are currently in there.
/// </summary>
public static void AddMod(ModIdentifier modIdentifier)
{
IGameplayModifier gameplayModifier;
// Set the newMod based on the ModType that is coming in
switch (modIdentifier)
{
case ModIdentifier.Autoplay:
gameplayModifier = new ModAutoplay();
break;
default:
return;
}
// Remove incompatible mods.
var incompatibleMods = CurrentModifiersList.FindAll(x => x.IncompatibleMods.Contains(gameplayModifier.ModIdentifier));
incompatibleMods.ForEach(x => RemoveMod(x.ModIdentifier));
// Remove the mod if it's already on.
var alreadyOnMod = CurrentModifiersList.Find(x => x.ModIdentifier == gameplayModifier.ModIdentifier);
if (alreadyOnMod != null)
{
CurrentModifiersList.Remove(alreadyOnMod);
}
// Add The Mod
CurrentModifiersList.Add(gameplayModifier);
gameplayModifier.InitializeMod();
ModsChanged?.Invoke(typeof(ModManager), new ModsChangedEventArgs(Mods));
Logger.Log($"Added mod: {gameplayModifier.ModIdentifier}.", LogLevel.Info);
}
/// <summary>
/// Ctor -
/// </summary>
/// <param name="map"></param>
/// <param name="mods"></param>
public ScoreProcessor(Qua map, ModIdentifier mods)
{
Map = map;
Mods = mods;
Stats = new List <HitStat>();
InitializeMods();
}
/// <summary>
/// Ctor -
/// Create fresh replay
/// </summary>
/// <param name="mode"></param>
/// <param name="name"></param>
/// <param name="mods"></param>
/// <param name="md5"></param>
public Replay(GameMode mode, string name, ModIdentifier mods, string md5)
{
PlayerName = name;
Mode = mode;
Mods = mods;
MapMd5 = md5;
Frames = new List <ReplayFrame>();
}
/// <summary>
/// Ctor -
/// </summary>
/// <param name="map"></param>
/// <param name="mods"></param>
/// <param name="windows"></param>
public ScoreProcessor(Qua map, ModIdentifier mods, JudgementWindows windows = null)
{
Map = map;
Mods = mods;
Stats = new List <HitStat>();
InitializeJudgementWindows(windows);
InitializeMods();
}
public void Set(UninstallModOptions other)
{
if (other != null)
{
m_ApiVersion = ModsInterface.UninstallmodApiLatest;
LocalUserId = other.LocalUserId;
Mod = other.Mod;
}
}
public void CanParseModIdentifier()
{
var id = new ModIdentifier("my-org", "my-mod", "1.0.0");
Assert.True(id.Validate());
Assert.Equal("my-org", id.OwnerSlug);
Assert.Equal("my-mod", id.ModSlug);
Assert.Equal("1.0.0", id.Version);
}
internal void Set(UninstallModCallbackInfoInternal?other)
{
if (other != null)
{
ResultCode = other.Value.ResultCode;
LocalUserId = other.Value.LocalUserId;
ClientData = other.Value.ClientData;
Mod = other.Value.Mod;
}
}
public void Set(ModIdentifier other)
{
if (other != null)
{
m_ApiVersion = ModsInterface.ModIdentifierApiLatest;
NamespaceId = other.NamespaceId;
ItemId = other.ItemId;
ArtifactId = other.ArtifactId;
Title = other.Title;
Version = other.Version;
}
}
private async Task <Stream> GetModImportStream(ModIdentifier packageId)
{
var allMods = await _client.ModListClient.GetModsAsync(null, null);
var foundMod = allMods.SingleOrDefault(m => m.Owner.Slug == packageId.OwnerSlug && m.Slug == packageId.ModSlug);
var foundVersion = foundMod?.Versions.SingleOrDefault(v => v.VersionNumber == packageId.Version);
if (foundVersion == null)
{
return(null);
}
return(await _client.HttpClient.GetStreamAsync(foundVersion.FileUrl));
}
/// <summary>
/// Solves the difficulty of the map and returns the data for it.
/// </summary>
/// <param name="mods"></param>
/// <returns></returns>
public DifficultyProcessor SolveDifficulty(ModIdentifier mods = ModIdentifier.None)
{
switch (Mode)
{
case GameMode.Keys4:
return(new DifficultyProcessorKeys(this, new StrainConstantsKeys(), mods));
case GameMode.Keys7:
return(new DifficultyProcessorKeys(this, new StrainConstantsKeys(), mods));
default:
throw new InvalidEnumArgumentException();
}
}
/// <summary>
/// </summary>
/// <param name="args"></param>
public CalcDiffCommand(string[] args) : base(args)
{
var path = args[1];
if (path.EndsWith(".qua"))
{
Map = Qua.Parse(path);
}
else if (path.EndsWith(".osu"))
{
Map = new OsuBeatmap(path).ToQua();
}
Mods = (ModIdentifier)Enum.Parse(typeof(ModIdentifier), args[2]);
}
/// <summary>
/// Removes a gameplayModifier from our GameBase
/// </summary>
public static void RemoveMod(ModIdentifier modIdentifier)
{
try
{
// Try to find the removed gameplayModifier in the list
var removedMod = CurrentModifiersList.Find(x => x.ModIdentifier == modIdentifier);
// Remove the Mod
CurrentModifiersList.Remove(removedMod);
ModsChanged?.Invoke(typeof(ModManager), new ModsChangedEventArgs(Mods));
Logger.Log($"Removed mod: {removedMod.ModIdentifier}.", LogLevel.Info);
}
catch (Exception e)
{
Logger.Log(e);
}
}
/// <summary>
/// Solves the difficulty of a .qua file
/// </summary>
/// <param name="map"></param>
/// <param name="constants"></param>
/// <param name="mods"></param>
/// <param name="detailedSolve"></param>
public DifficultyProcessorKeys(Qua map, StrainConstants constants, ModIdentifier mods = ModIdentifier.None, bool detailedSolve = false) : base(map, constants, mods)
{
// Cast the current Strain Constants Property to the correct type.
StrainConstants = (StrainConstantsKeys)constants;
// Don't bother calculating map difficulty if there's less than 2 hit objects
if (map.HitObjects.Count < 2)
{
return;
}
// Solve for difficulty
CalculateDifficulty(mods);
// If detailed solving is enabled, expand calculation
if (detailedSolve)
{
// ComputeNoteDensityData();
ComputeForPatternFlags();
}
}
/// <summary>
/// Calculate difficulty of a map with given rate
/// </summary>
/// <param name="rate"></param>
public void CalculateDifficulty(ModIdentifier mods)
{
// If map does not exist, ignore calculation.
if (Map == null)
{
return;
}
// Get song rate from selected mods
var rate = ModHelper.GetRateFromMods(mods);
// Compute for overall difficulty
switch (Map.Mode)
{
case (GameMode.Keys4):
OverallDifficulty = ComputeForOverallDifficulty(rate);
break;
case (GameMode.Keys7):
OverallDifficulty = (ComputeForOverallDifficulty(rate, Hand.Left) + ComputeForOverallDifficulty(rate, Hand.Right)) / 2;
break;
}
}
/// <summary>
/// Adds all modifiers from a mod enum combo
/// </summary>
public static void AddModsFromIdentifiers(ModIdentifier mods)
{
// Remove all the current mods that we have on.
ModManager.RemoveAllMods();
for (var i = 0; i <= Math.Log((long)mods, 2); i++)
{
var mod = (ModIdentifier)((long)Math.Pow(2, i));
if (!mods.HasFlag(mod))
{
continue;
}
try
{
ModManager.AddMod(mod);
}
catch (Exception e)
{
Logger.Error(e, LogType.Runtime);
}
}
}
/// <summary>
/// Applies mods to the map.
/// </summary>
/// <param name="mods">a list of mods to apply</param>
public void ApplyMods(ModIdentifier mods)
{
if (mods.HasFlag(ModIdentifier.NoLongNotes))
{
ReplaceLongNotesWithRegularNotes();
}
if (mods.HasFlag(ModIdentifier.Inverse))
{
ApplyInverse();
}
// FullLN is NLN followed by Inverse.
if (mods.HasFlag(ModIdentifier.FullLN))
{
ReplaceLongNotesWithRegularNotes();
ApplyInverse();
}
if (mods.HasFlag(ModIdentifier.Mirror))
{
MirrorHitObjects();
}
}
/// <summary> /// Checks if a gameplayModifier is currently activated. /// </summary> /// <param name="modIdentifier"></param> /// <returns></returns> public static bool IsActivated(ModIdentifier modIdentifier) => CurrentModifiersList.Exists(x => x.ModIdentifier == modIdentifier);
/// <summary>
/// For multiplayer
/// </summary>
/// <param name="map"></param>
/// <param name="mods"></param>
/// <param name="multiplayerProcessor"></param>
public ScoreProcessor(Qua map, ModIdentifier mods, ScoreProcessorMultiplayer multiplayerProcessor) : this(map, mods)
{
MultiplayerProcessor = multiplayerProcessor;
MultiplayerProcessor.Processor = this;
}
/// <inheritdoc />
/// <summary>
/// Ctor
/// </summary>
/// <param name="screen"></param>
/// <param name="type"></param>
/// <param name="username"></param>
/// <param name="judgements"></param>
/// <param name="avatar"></param>
/// <param name="mods"></param>
/// <param name="score"></param>
/// <exception cref="T:System.ComponentModel.InvalidEnumArgumentException"></exception>
internal ScoreboardUser(GameplayScreen screen, ScoreboardUserType type, string username, List <Judgement> judgements, Texture2D avatar, ModIdentifier mods, Score score = null)
{
Screen = screen;
LocalScore = score;
Judgements = judgements;
UsernameRaw = username;
RatingProcessor = new RatingProcessorKeys(MapManager.Selected.Value.DifficultyFromMods(mods));
Type = type;
Size = new ScalableVector2(260, 50);
// Set position initially to offscreen
X = -Width - 10;
// The alpha of the tect - determined by the scoreboard user type.
float textAlpha;
// Set props based on the type of scoreboard user this is.
switch (Type)
{
case ScoreboardUserType.Self:
Image = SkinManager.Skin.Scoreboard;
Alpha = 1f;
textAlpha = 1f;
break;
case ScoreboardUserType.Other:
Image = SkinManager.Skin.ScoreboardOther;
Alpha = 0.75f;
textAlpha = 0.65f;
break;
default:
throw new ArgumentOutOfRangeException();
}
switch (Screen.Map.Mode)
{
case GameMode.Keys4:
case GameMode.Keys7:
Processor = Type == ScoreboardUserType.Other ? new ScoreProcessorKeys(Screen.Map, mods) : Screen.Ruleset.ScoreProcessor;
break;
default:
throw new InvalidEnumArgumentException();
}
// Create avatar
Avatar = new Sprite()
{
Parent = this,
Size = new ScalableVector2(Height, Height),
Alignment = Alignment.MidLeft,
Image = avatar,
};
if (Type != ScoreboardUserType.Self)
{
if (LocalScore != null && LocalScore.IsOnline)
{
// Check to see if we have a Steam avatar for this user cached.
if (SteamManager.UserAvatars.ContainsKey((ulong)LocalScore.SteamId))
{
Avatar.Image = SteamManager.UserAvatars[(ulong)LocalScore.SteamId];
}
else
{
Avatar.Alpha = 0;
Avatar.Image = UserInterface.UnknownAvatar;
// Otherwise we need to request for it.
SteamManager.SteamUserAvatarLoaded += OnAvatarLoaded;
SteamManager.SendAvatarRetrievalRequest((ulong)LocalScore.SteamId);
}
}
else
{
Avatar.Image = UserInterface.UnknownAvatar;
}
}
// Create username text.
Username = new SpriteText(Fonts.Exo2Bold, GetUsernameFormatted(), 13)
{
Parent = this,
Alignment = Alignment.TopLeft,
Alpha = textAlpha,
X = Avatar.Width + 10,
};
// Create score text.
Score = new SpriteTextBitmap(FontsBitmap.AllerRegular, "0.00")
{
Parent = this,
Alignment = Alignment.TopLeft,
Alpha = textAlpha,
Y = Username.Y + Username.Height + 2,
X = Username.X,
FontSize = 18
};
// Create score text.
Combo = new SpriteTextBitmap(FontsBitmap.AllerRegular, $"{Processor.Combo:N0}x")
{
Parent = this,
Alignment = Alignment.MidRight,
Alpha = textAlpha,
FontSize = 18,
X = -5
};
}
/// <summary>
/// For multiplayer
/// </summary>
/// <param name="map"></param>
/// <param name="mods"></param>
/// <param name="multiplayerProcessor"></param>
/// <param name="windows"></param>
public ScoreProcessor(Qua map, ModIdentifier mods, ScoreProcessorMultiplayer multiplayerProcessor, JudgementWindows windows = null)
: this(map, mods, windows)
{
MultiplayerProcessor = multiplayerProcessor;
MultiplayerProcessor.Processor = this;
}
/// <summary> /// Constructor /// </summary> /// <param name="map"></param> public DifficultyProcessor(Qua map, StrainConstants constants, ModIdentifier mods = ModIdentifier.None) => Map = map;
/// <inheritdoc />
/// <summary>
/// </summary>
/// <param name="map"></param>
/// <param name="mods"></param>
/// <param name="multiplayer"></param>
/// <param name="windows"></param>
public ScoreProcessorKeys(Qua map, ModIdentifier mods, ScoreProcessorMultiplayer multiplayer, JudgementWindows windows = null) : base(map, mods, multiplayer, windows)
{
TotalJudgements = GetTotalJudgementCount();
SummedScore = CalculateSummedScore();
InitializeHealthWeighting();
}
public ModsChangedEventArgs(ModIdentifier mods) => Mods = mods;
/// <summary>
/// </summary>
/// <param name="args"></param>
public CalcFolderCommand(string[] args) : base(args)
{
BaseFolder = args[1];
Mods = (ModIdentifier)Enum.Parse(typeof(ModIdentifier), args[2]);
}
/// <summary>
/// Closes the dialog.
/// </summary>
public void Close(bool changeMods = true)
{
if (isClosing)
{
return;
}
if (OnlineManager.CurrentGame != null && changeMods)
{
if (ModsWhenDialogOpen != ModManager.Mods)
{
var diffRating = OnlineManager.CurrentGame.DifficultyRating;
// Only update the difficulty rating when closing if the selected map is still the same.
// If the user switches maps, but changes modifiers, it'll be incorrect.
if (MapManager.Selected.Value != null && MapManager.Selected.Value.Md5Checksum == OnlineManager.CurrentGame.MapMd5)
{
diffRating = MapManager.Selected.Value.DifficultyFromMods(ModManager.Mods);
}
var rateNow = ModHelper.GetRateFromMods(ModManager.Mods);
// Change the global mods of the game
var rateMod = (long)ModHelper.GetModsFromRate(rateNow);
if (rateMod == -1)
{
rateMod = 0;
}
var activeModsWithoutRate = (long)ModManager.Mods - rateMod;
ModIdentifier hostOnlyMods = 0L;
var onlyHostChangeableMods = ModManager.CurrentModifiersList.FindAll(x => x.OnlyMultiplayerHostCanCanChange);
if (onlyHostChangeableMods.Count != 0)
{
onlyHostChangeableMods.ForEach(x =>
{
// ReSharper disable once AccessToModifiedClosure
activeModsWithoutRate -= (long)x.ModIdentifier;
hostOnlyMods |= x.ModIdentifier;
});
}
if (activeModsWithoutRate == -1)
{
activeModsWithoutRate = 0;
}
// If we're on regular free mod mode, when we change the rate,
// ReSharper disable once CompareOfFloatsByEqualityOperator
if (OnlineManager.CurrentGame.FreeModType == MultiplayerFreeModType.Regular &&
(ModHelper.GetRateFromMods(ModsWhenDialogOpen) != rateNow || hostOnlyMods != 0) &&
OnlineManager.CurrentGame.Host == OnlineManager.Self.OnlineUser)
{
OnlineManager.Client?.MultiplayerChangeGameModifiers(rateMod + (long)hostOnlyMods, diffRating);
// Change the mods of ourselves minus the mods rate (gets all other activated modes)
OnlineManager.Client?.MultiplayerChangePlayerModifiers(activeModsWithoutRate);
}
// Free mod is enabled, but we haven't done any rate changing, so just
// enable player modifiers for us
else if (OnlineManager.CurrentGame.FreeModType != MultiplayerFreeModType.None)
{
// Free Mod + Free Rate
if (OnlineManager.CurrentGame.FreeModType.HasFlag(MultiplayerFreeModType.Regular) &&
OnlineManager.CurrentGame.FreeModType.HasFlag(MultiplayerFreeModType.Rate))
{
if (OnlineManager.CurrentGame.Host == OnlineManager.Self.OnlineUser)
{
OnlineManager.Client?.MultiplayerChangeGameModifiers((long)hostOnlyMods, diffRating);
}
OnlineManager.Client?.MultiplayerChangePlayerModifiers((long)ModManager.Mods);
}
// Either Free Mod OR Free Rate
else
{
switch (OnlineManager.CurrentGame.FreeModType)
{
case MultiplayerFreeModType.Regular:
OnlineManager.Client?.MultiplayerChangePlayerModifiers(activeModsWithoutRate);
if (OnlineManager.CurrentGame.Host == OnlineManager.Self.OnlineUser)
{
OnlineManager.Client?.MultiplayerChangeGameModifiers(rateMod + (long)hostOnlyMods, diffRating);
}
break;
case MultiplayerFreeModType.Rate:
OnlineManager.Client?.MultiplayerChangePlayerModifiers((long)ModHelper.GetModsFromRate(rateNow));
if (OnlineManager.CurrentGame.Host == OnlineManager.Self.OnlineUser)
{
OnlineManager.Client?.MultiplayerChangeGameModifiers(activeModsWithoutRate + (long)hostOnlyMods, diffRating);
}
break;
}
}
}
// We're host & free mod isn't enabled, so change the global game mods
else if (OnlineManager.CurrentGame.Host == OnlineManager.Self.OnlineUser)
{
OnlineManager.Client?.MultiplayerChangeGameModifiers((long)ModManager.Mods, diffRating);
}
}
}
isClosing = true;
InterfaceContainer.Animations.Clear();
InterfaceContainer.Animations.Add(new Animation(AnimationProperty.Y, Easing.OutQuint, InterfaceContainer.Y, InterfaceContainer.Height, 600));
ThreadScheduler.RunAfter(() => DialogManager.Dismiss(this), 450);
}
/// <summary>
/// Gets the audio rate from selected mods.
/// </summary>
/// <param name="mods"></param>
/// <returns></returns>
public static float GetRateFromMods(ModIdentifier mods)
{
// The rate of the audio.
var rate = 1.0f;
// Map mods to rate.
if (mods.HasFlag(ModIdentifier.None))
{
rate = 1.0f;
}
else if (mods.HasFlag(ModIdentifier.Speed05X))
{
rate = 0.5f;
}
else if (mods.HasFlag(ModIdentifier.Speed055X))
{
rate = 0.55f;
}
else if (mods.HasFlag(ModIdentifier.Speed06X))
{
rate = 0.6f;
}
else if (mods.HasFlag(ModIdentifier.Speed065X))
{
rate = 0.65f;
}
else if (mods.HasFlag(ModIdentifier.Speed07X))
{
rate = 0.7f;
}
else if (mods.HasFlag(ModIdentifier.Speed075X))
{
rate = 0.75f;
}
else if (mods.HasFlag(ModIdentifier.Speed08X))
{
rate = 0.8f;
}
else if (mods.HasFlag(ModIdentifier.Speed085X))
{
rate = 0.85f;
}
else if (mods.HasFlag(ModIdentifier.Speed09X))
{
rate = 0.9f;
}
else if (mods.HasFlag(ModIdentifier.Speed095X))
{
rate = 0.95f;
}
else if (mods.HasFlag(ModIdentifier.Speed11X))
{
rate = 1.1f;
}
else if (mods.HasFlag(ModIdentifier.Speed12X))
{
rate = 1.2f;
}
else if (mods.HasFlag(ModIdentifier.Speed13X))
{
rate = 1.3f;
}
else if (mods.HasFlag(ModIdentifier.Speed14X))
{
rate = 1.4f;
}
else if (mods.HasFlag(ModIdentifier.Speed15X))
{
rate = 1.5f;
}
else if (mods.HasFlag(ModIdentifier.Speed16X))
{
rate = 1.6f;
}
else if (mods.HasFlag(ModIdentifier.Speed17X))
{
rate = 1.7f;
}
else if (mods.HasFlag(ModIdentifier.Speed18X))
{
rate = 1.8f;
}
else if (mods.HasFlag(ModIdentifier.Speed19X))
{
rate = 1.9f;
}
else if (mods.HasFlag(ModIdentifier.Speed20X))
{
rate = 2.0f;
}
return(rate);
}
public double DifficultyFromMods(ModIdentifier mods)
{
throw new NotImplementedException();
}
/// <summary>
/// Retrieve the map's difficulty rating from given mods
/// </summary>
/// <returns></returns>
public double DifficultyFromMods(ModIdentifier mods)
{
if (mods.HasFlag(ModIdentifier.Speed05X))
{
return(Difficulty05X);
}
if (mods.HasFlag(ModIdentifier.Speed055X))
{
return(Difficulty055X);
}
if (mods.HasFlag(ModIdentifier.Speed06X))
{
return(Difficulty06X);
}
if (mods.HasFlag(ModIdentifier.Speed065X))
{
return(Difficulty065X);
}
if (mods.HasFlag(ModIdentifier.Speed07X))
{
return(Difficulty07X);
}
if (mods.HasFlag(ModIdentifier.Speed075X))
{
return(Difficulty075X);
}
if (mods.HasFlag(ModIdentifier.Speed08X))
{
return(Difficulty08X);
}
if (mods.HasFlag(ModIdentifier.Speed085X))
{
return(Difficulty085X);
}
if (mods.HasFlag(ModIdentifier.Speed09X))
{
return(Difficulty09X);
}
if (mods.HasFlag(ModIdentifier.Speed095X))
{
return(Difficulty095X);
}
if (mods.HasFlag(ModIdentifier.Speed11X))
{
return(Difficulty11X);
}
if (mods.HasFlag(ModIdentifier.Speed12X))
{
return(Difficulty12X);
}
if (mods.HasFlag(ModIdentifier.Speed13X))
{
return(Difficulty13X);
}
if (mods.HasFlag(ModIdentifier.Speed14X))
{
return(Difficulty14X);
}
if (mods.HasFlag(ModIdentifier.Speed15X))
{
return(Difficulty15X);
}
if (mods.HasFlag(ModIdentifier.Speed16X))
{
return(Difficulty16X);
}
if (mods.HasFlag(ModIdentifier.Speed17X))
{
return(Difficulty17X);
}
if (mods.HasFlag(ModIdentifier.Speed18X))
{
return(Difficulty18X);
}
if (mods.HasFlag(ModIdentifier.Speed19X))
{
return(Difficulty19X);
}
if (mods.HasFlag(ModIdentifier.Speed20X))
{
return(Difficulty20X);
}
return(Difficulty10X);
}
/// <summary>
/// Adds a gameplayModifier to our list, getting rid of any incompatible mods that are currently in there.
/// Also, specifying a speed, if need-be. That is only "required" if passing in ModIdentifier.ManiaModSpeed
/// </summary>
public static void AddMod(ModIdentifier modIdentifier)
{
IGameplayModifier gameplayModifier;
// Set the newMod based on the ModType that is coming in
switch (modIdentifier)
{
case ModIdentifier.Speed05X:
case ModIdentifier.Speed06X:
case ModIdentifier.Speed07X:
case ModIdentifier.Speed08X:
case ModIdentifier.Speed09X:
case ModIdentifier.Speed11X:
case ModIdentifier.Speed12X:
case ModIdentifier.Speed13X:
case ModIdentifier.Speed14X:
case ModIdentifier.Speed15X:
case ModIdentifier.Speed16X:
case ModIdentifier.Speed17X:
case ModIdentifier.Speed18X:
case ModIdentifier.Speed19X:
case ModIdentifier.Speed20X:
gameplayModifier = new ModSpeed(modIdentifier);
break;
case ModIdentifier.NoSliderVelocity:
gameplayModifier = new ModNoSliderVelocities();
break;
case ModIdentifier.Strict:
gameplayModifier = new ModStrict();
break;
case ModIdentifier.Chill:
gameplayModifier = new ModChill();
break;
case ModIdentifier.Autoplay:
gameplayModifier = new ModAutoplay();
break;
case ModIdentifier.Paused:
gameplayModifier = new ModPaused();
break;
case ModIdentifier.NoFail:
gameplayModifier = new ModNoFail();
break;
case ModIdentifier.NoLongNotes:
gameplayModifier = new ModNoLongNotes();
break;
default:
return;
}
// Remove incompatible mods.
var incompatibleMods = CurrentModifiersList.FindAll(x => x.IncompatibleMods.Contains(gameplayModifier.ModIdentifier));
incompatibleMods.ForEach(x => RemoveMod(x.ModIdentifier));
// Remove the mod if it's already on.
var alreadyOnMod = CurrentModifiersList.Find(x => x.ModIdentifier == gameplayModifier.ModIdentifier);
if (alreadyOnMod != null)
{
CurrentModifiersList.Remove(alreadyOnMod);
}
// Add The Mod
CurrentModifiersList.Add(gameplayModifier);
gameplayModifier.InitializeMod();
ModsChanged?.Invoke(typeof(ModManager), new ModsChangedEventArgs(Mods));
Logger.Debug($"Added mod: {gameplayModifier.ModIdentifier}.", LogType.Runtime, false);
}
/// <summary>
///
/// </summary>
/// <param name="mods"></param>
/// <returns></returns>
public static string GetModsString(ModIdentifier mods)
{
if (mods <= 0)
{
return("None");
}
var modStrings = new List <string>();
foreach (ModIdentifier mod in Enum.GetValues(typeof(ModIdentifier)))
{
if (!mods.HasFlag(mod))
{
continue;
}
switch (mod)
{
case ModIdentifier.NoSliderVelocity:
modStrings.Add("NSV");
break;
case ModIdentifier.Speed05X:
modStrings.Add("0.5x");
break;
case ModIdentifier.Speed055X:
modStrings.Add("0.55x");
break;
case ModIdentifier.Speed06X:
modStrings.Add("0.6x");
break;
case ModIdentifier.Speed065X:
modStrings.Add("0.65x");
break;
case ModIdentifier.Speed07X:
modStrings.Add("0.7x");
break;
case ModIdentifier.Speed075X:
modStrings.Add("0.75x");
break;
case ModIdentifier.Speed08X:
modStrings.Add("0.8x");
break;
case ModIdentifier.Speed085X:
modStrings.Add("0.85x");
break;
case ModIdentifier.Speed09X:
modStrings.Add("0.9x");
break;
case ModIdentifier.Speed095X:
modStrings.Add("0.95x");
break;
case ModIdentifier.Speed11X:
modStrings.Add("1.1x");
break;
case ModIdentifier.Speed12X:
modStrings.Add("1.2x");
break;
case ModIdentifier.Speed13X:
modStrings.Add("1.3x");
break;
case ModIdentifier.Speed14X:
modStrings.Add("1.4x");
break;
case ModIdentifier.Speed15X:
modStrings.Add("1.5x");
break;
case ModIdentifier.Speed16X:
modStrings.Add("1.6x");
break;
case ModIdentifier.Speed17X:
modStrings.Add("1.7x");
break;
case ModIdentifier.Speed18X:
modStrings.Add("1.8x");
break;
case ModIdentifier.Speed19X:
modStrings.Add("1.9x");
break;
case ModIdentifier.Speed20X:
modStrings.Add("2.0x");
break;
case ModIdentifier.Strict:
modStrings.Add("ST");
break;
case ModIdentifier.Chill:
modStrings.Add("CH");
break;
case ModIdentifier.NoPause:
modStrings.Add("NP");
break;
case ModIdentifier.Autoplay:
modStrings.Add("AP");
break;
case ModIdentifier.Paused:
modStrings.Add("PS");
break;
case ModIdentifier.NoFail:
modStrings.Add("NF");
break;
case ModIdentifier.NoLongNotes:
modStrings.Add("NLN");
break;
case ModIdentifier.Randomize:
modStrings.Add("RND");
break;
case ModIdentifier.Inverse:
modStrings.Add("IV");
break;
case ModIdentifier.FullLN:
modStrings.Add("FLN");
break;
case ModIdentifier.Mirror:
modStrings.Add("MR");
break;
default:
throw new ArgumentOutOfRangeException($"Short string for ModIdentifier: {mod} does not exist.");
}
}
return(string.Join(", ", modStrings));
}
