public void TestModIsNotCompatibleWithItself()
{
var mod = new Mock <CustomMod1>();
Assert.That(ModUtils.CheckCompatibleSet(new[] { mod.Object, mod.Object }, out var invalid), Is.False);
Assert.That(invalid, Is.EquivalentTo(new[] { mod.Object }));
}
private static bool validateMods(MultiplayerRoom room, IEnumerable <APIMod> proposedMods, [NotNullWhen(false)] out IEnumerable <APIMod>?validMods)
{
bool proposedWereValid = true;
proposedWereValid &= populateValidModsForRuleset(room.Settings.RulesetID, proposedMods, out var valid);
// check allowed by room
foreach (var mod in valid.ToList())
{
if (room.Settings.AllowedMods.All(m => m.Acronym != mod.Acronym))
{
valid.Remove(mod);
proposedWereValid = false;
}
}
// check valid as combination
if (!ModUtils.CheckCompatibleSet(valid, out var invalid))
{
proposedWereValid = false;
foreach (var mod in invalid)
{
valid.Remove(mod);
}
}
validMods = valid.Select(m => new APIMod(m));
return(proposedWereValid);
}
public void TestAllMultiModsFromRulesetAreIncompatible(Type rulesetType)
{
var ruleset = (Ruleset)Activator.CreateInstance(rulesetType);
Assert.That(ruleset, Is.Not.Null);
var allMultiMods = getMultiMods(ruleset);
Assert.Multiple(() =>
{
foreach (var multiMod in allMultiMods)
{
int modCount = multiMod.Mods.Length;
for (int i = 0; i < modCount; ++i)
{
// indexing from i + 1 ensures that only pairs of different mods are checked, and are checked only once
// (indexing from 0 would check each pair twice, and also check each mod against itself).
for (int j = i + 1; j < modCount; ++j)
{
var firstMod = multiMod.Mods[i];
var secondMod = multiMod.Mods[j];
Assert.That(
ModUtils.CheckCompatibleSet(new[] { firstMod, secondMod }), Is.False,
$"{firstMod.Name} ({firstMod.Acronym}) and {secondMod.Name} ({secondMod.Acronym}) should be incompatible.");
}
}
}
});
}
public void TestModIsCompatibleByItselfWithIncompatibleInterface()
{
var mod = new Mock <CustomMod1>();
mod.Setup(m => m.IncompatibleMods).Returns(new[] { typeof(IModCompatibilitySpecification) });
Assert.That(ModUtils.CheckCompatibleSet(new[] { mod.Object }));
}
private static void ensureSettingsModsValid(MultiplayerRoomSettings settings)
{
// check against ruleset
if (!populateValidModsForRuleset(settings.RulesetID, settings.RequiredMods, out var requiredMods))
{
var invalidRequiredAcronyms = string.Join(',', settings.RequiredMods.Where(m => requiredMods.All(valid => valid.Acronym != m.Acronym)).Select(m => m.Acronym));
throw new InvalidStateException($"Invalid mods were selected for specified ruleset: {invalidRequiredAcronyms}");
}
if (!populateValidModsForRuleset(settings.RulesetID, settings.AllowedMods, out var allowedMods))
{
var invalidAllowedAcronyms = string.Join(',', settings.AllowedMods.Where(m => allowedMods.All(valid => valid.Acronym != m.Acronym)).Select(m => m.Acronym));
throw new InvalidStateException($"Invalid mods were selected for specified ruleset: {invalidAllowedAcronyms}");
}
if (!ModUtils.CheckCompatibleSet(requiredMods, out var invalid))
{
throw new InvalidStateException($"Invalid combination of required mods: {string.Join(',', invalid.Select(m => m.Acronym))}");
}
// check aggregate combinations with each allowed mod individually.
foreach (var allowedMod in allowedMods)
{
if (!ModUtils.CheckCompatibleSet(requiredMods.Concat(new[] { allowedMod }), out invalid))
{
throw new InvalidStateException($"Invalid combination of required and allowed mods: {string.Join(',', invalid.Select(m => m.Acronym))}");
}
}
}
public void TestCompatibleMods()
{
var mod1 = new Mock <CustomMod1>();
var mod2 = new Mock <CustomMod2>();
// Test both orderings.
Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod1.Object, mod2.Object }), Is.True);
Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod2.Object, mod1.Object }), Is.True);
}
public void TestIncompatibleThroughTopLevel()
{
var mod1 = new Mock <CustomMod1>();
var mod2 = new Mock <CustomMod2>();
mod1.Setup(m => m.IncompatibleMods).Returns(new[] { mod2.Object.GetType() });
// Test both orderings.
Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod1.Object, mod2.Object }), Is.False);
Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod2.Object, mod1.Object }), Is.False);
}
public void TestIncompatibleThroughInterface()
{
var mod1 = new Mock <CustomMod1>();
var mod2 = new Mock <CustomMod2>();
mod1.Setup(m => m.IncompatibleMods).Returns(new[] { typeof(IModCompatibilitySpecification) });
mod2.Setup(m => m.IncompatibleMods).Returns(new[] { typeof(IModCompatibilitySpecification) });
// Test both orderings.
Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod1.Object, mod2.Object }), Is.False);
Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod2.Object, mod1.Object }), Is.False);
}
protected override bool OnStart()
{
if (playerLoader != null)
{
return(false);
}
modsAtGameplayStart = Mods.Value;
// Ctrl+Enter should start map with autoplay enabled.
if (GetContainingInputManager().CurrentState?.Keyboard.ControlPressed == true)
{
var autoInstance = getAutoplayMod();
if (autoInstance == null)
{
notifications?.Post(new SimpleNotification
{
Text = "The current ruleset doesn't have an autoplay mod avalaible!"
});
return(false);
}
var mods = Mods.Value.Append(autoInstance).ToArray();
if (!ModUtils.CheckCompatibleSet(mods, out var invalid))
{
mods = mods.Except(invalid).Append(autoInstance).ToArray();
}
Mods.Value = mods;
}
SampleConfirm?.Play();
this.Push(playerLoader = new PlayerLoader(createPlayer));
return(true);
Player createPlayer()
{
var replayGeneratingMod = Mods.Value.OfType <ICreateReplayData>().FirstOrDefault();
if (replayGeneratingMod != null)
{
return(new ReplayPlayer((beatmap, mods) => replayGeneratingMod.CreateScoreFromReplayData(beatmap, mods)));
}
return(new SoloPlayer());
}
}
public void TestTopLevelIncompatibleWithMultiMod()
{
// The nested mod.
var mod1 = new Mock <CustomMod1>();
var multiMod = new MultiMod(new MultiMod(mod1.Object));
var mod2 = new Mock <CustomMod2>();
mod2.Setup(m => m.IncompatibleMods).Returns(new[] { typeof(CustomMod1) });
// Test both orderings.
Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { multiMod, mod2.Object }), Is.False);
Assert.That(ModUtils.CheckCompatibleSet(new Mod[] { mod2.Object, multiMod }), Is.False);
}
private void updateCompatibility()
{
var m = SelectedMod ?? Mods.First();
bool isIncompatible = false;
if (selectedMods.Value.Count > 0 && !selectedMods.Value.Contains(m))
{
isIncompatible = !ModUtils.CheckCompatibleSet(selectedMods.Value.Append(m));
}
if (isIncompatible)
{
incompatibleIcon.Show();
}
else
{
incompatibleIcon.Hide();
}
}
protected override IReadOnlyList <Mod> ComputeNewModsFromSelection(IReadOnlyList <Mod> oldSelection, IReadOnlyList <Mod> newSelection)
{
var addedMods = newSelection.Except(oldSelection);
var removedMods = oldSelection.Except(newSelection);
IEnumerable <Mod> modsAfterRemoval = newSelection.Except(removedMods).ToList();
// the preference is that all new mods should override potential incompatible old mods.
// in general that's a bit difficult to compute if more than one mod is added at a time,
// so be conservative and just remove all mods that aren't compatible with any one added mod.
foreach (var addedMod in addedMods)
{
if (!ModUtils.CheckCompatibleSet(modsAfterRemoval.Append(addedMod), out var invalidMods))
{
modsAfterRemoval = modsAfterRemoval.Except(invalidMods);
}
modsAfterRemoval = modsAfterRemoval.Append(addedMod).ToList();
}
return(modsAfterRemoval.ToList());
}
private bool checkCompatibleFreeMod(Mod mod) => Mods.Value.All(m => m.Acronym != mod.Acronym) && // Mod must not be contained in the required mods. ModUtils.CheckCompatibleSet(Mods.Value.Append(mod).ToArray()); // Mod must be compatible with all the required mods.
private void load(OverlayColourProvider overlayColourProvider)
{
InternalChildren = new Drawable[]
{
new Box
{
RelativeSizeAxes = Axes.Both,
Colour = overlayColourProvider.Background6,
},
new OsuScrollContainer(Direction.Horizontal)
{
RelativeSizeAxes = Axes.Both,
Children = new Drawable[]
{
new FillFlowContainer
{
Name = "Scene library",
AutoSizeAxes = Axes.X,
RelativeSizeAxes = Axes.Y,
Spacing = new Vector2(padding),
Padding = new MarginPadding(padding),
Direction = FillDirection.Horizontal,
Children = new Drawable[]
{
new OsuSpriteText
{
Text = "Scene library",
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft,
Margin = new MarginPadding(10),
},
new SceneButton
{
Text = "Song Select",
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft,
Action = () => performer?.PerformFromScreen(screen =>
{
if (screen is SongSelect)
{
return;
}
screen.Push(new PlaySongSelect());
}, new[] { typeof(SongSelect) })
},
new SceneButton
{
Text = "Gameplay",
Anchor = Anchor.CentreLeft,
Origin = Anchor.CentreLeft,
Action = () => performer?.PerformFromScreen(screen =>
{
if (screen is Player)
{
return;
}
var replayGeneratingMod = ruleset.Value.CreateInstance().GetAutoplayMod();
if (!ModUtils.CheckCompatibleSet(mods.Value.Append(replayGeneratingMod), out var invalid))
{
mods.Value = mods.Value.Except(invalid).ToArray();
}
if (replayGeneratingMod != null)
{
screen.Push(new PlayerLoader(() => new ReplayPlayer((beatmap, mods) => replayGeneratingMod.CreateScoreFromReplayData(beatmap, mods))));
}
}, new[] { typeof(Player), typeof(SongSelect) })
},
}
},
}
}
};
}
private void updateIncompatibility()
{
incompatible.Value = selectedMods.Value.Count > 0 &&
selectedMods.Value.All(selected => selected.GetType() != Mod.GetType()) &&
!ModUtils.CheckCompatibleSet(selectedMods.Value.Append(Mod));
}
private void updateIncompatibility()
{
incompatible.Value = selectedMods.Value.Count > 0 && !selectedMods.Value.Contains(Mod) && !ModUtils.CheckCompatibleSet(selectedMods.Value.Append(Mod));
}
public void TestModIsCompatibleByItself()
{
var mod = new Mock <CustomMod1>();
Assert.That(ModUtils.CheckCompatibleSet(new[] { mod.Object }));
}
