private List <Ruleset> getRulesets()
{
var rulesetsToProcess = new List <Ruleset>();
foreach (string file in Directory.GetFiles(AppDomain.CurrentDomain.BaseDirectory, $"{ruleset_library_prefix}.*.dll"))
{
try
{
var assembly = Assembly.LoadFrom(file);
Type type = assembly.GetTypes().First(t => t.IsPublic && t.IsSubclassOf(typeof(Ruleset)));
rulesetsToProcess.Add((Ruleset)Activator.CreateInstance(type, (RulesetInfo)null));
}
catch
{
reporter.Error($"Failed to load ruleset ({file})");
}
}
if (Rulesets != null)
{
rulesetsToProcess.RemoveAll(r => Rulesets.All(u => u != r.RulesetInfo.ID));
}
return(rulesetsToProcess);
}
private async Task <PlaylistItem> createPlaylistItem(MultiplayerPlaylistItem item, bool populateBeatmapImmediately)
{
var ruleset = Rulesets.GetRuleset(item.RulesetID);
Debug.Assert(ruleset != null);
var rulesetInstance = ruleset.CreateInstance();
var playlistItem = new PlaylistItem
{
ID = item.ID,
BeatmapID = item.BeatmapID,
OwnerID = item.OwnerID,
Ruleset = { Value = ruleset },
Expired = item.Expired,
PlaylistOrder = item.PlaylistOrder,
PlayedAt = item.PlayedAt
};
playlistItem.RequiredMods.AddRange(item.RequiredMods.Select(m => m.ToMod(rulesetInstance)));
playlistItem.AllowedMods.AddRange(item.AllowedMods.Select(m => m.ToMod(rulesetInstance)));
if (populateBeatmapImmediately)
{
playlistItem.Beatmap.Value = await GetAPIBeatmap(item.BeatmapID).ConfigureAwait(false);
}
return(playlistItem);
}
private async Task <PlaylistItem> createPlaylistItem(MultiplayerPlaylistItem item)
{
var set = await GetOnlineBeatmapSet(item.BeatmapID).ConfigureAwait(false);
// The incoming response is deserialised without circular reference handling currently.
// Because we require using metadata from this instance, populate the nested beatmaps' sets manually here.
foreach (var b in set.Beatmaps)
{
b.BeatmapSet = set;
}
var beatmap = set.Beatmaps.Single(b => b.OnlineID == item.BeatmapID);
beatmap.Checksum = item.BeatmapChecksum;
var ruleset = Rulesets.GetRuleset(item.RulesetID);
var rulesetInstance = ruleset.CreateInstance();
var playlistItem = new PlaylistItem
{
ID = item.ID,
OwnerID = item.OwnerID,
Beatmap = { Value = beatmap },
Ruleset = { Value = ruleset },
Expired = item.Expired
};
playlistItem.RequiredMods.AddRange(item.RequiredMods.Select(m => m.ToMod(rulesetInstance)));
playlistItem.AllowedMods.AddRange(item.AllowedMods.Select(m => m.ToMod(rulesetInstance)));
return(playlistItem);
}
// Sets reference scripts and creates a transparent morphBot that will be moved or activated/deactivated depending on mouse position.
private void Awake()
{
rulesets = GetComponent <Rulesets>();
functions = GetComponent <Functions>();
main = GetComponent <Main>();
morphBotHover = Instantiate(morphBotHoverRef, new Vector3(0, 0, 0), Quaternion.identity);
morphBotHover.name = "MorphBot Highlight";
}
// Sets all the script reference variables for later use.
private void Awake()
{
selection = GetComponent <Selection>();
rulesets = GetComponent <Rulesets>();
functions = GetComponent <Functions>();
pathfinding = GetComponent <Pathfinding>();
main = GetComponent <Main>();
}
protected override void UpdateItems(List <APILegacyScoreInfo> items)
{
foreach (var item in items)
{
item.Ruleset = Rulesets.GetRuleset(item.RulesetID);
}
base.UpdateItems(items);
}
public GenerationWizard()
{
BindingContext = this;
InitializeComponent();
GenerationConfiguration.PropertyChanged += (a, b) =>
{
Generate.IsEnabled = GenerationConfiguration.ConfigurationComplete;
};
var list = Ruleset.GetSupportRulesets();
foreach (var item in list)
{
Rulesets.Add(item);
}
}
protected override void ShowMore()
{
base.ShowMore();
request = new GetUserScoresRequest(User.Value.Id, type, VisiblePages++ *ItemsPerPage);
request.Success += scores => Schedule(() =>
{
foreach (var s in scores)
{
s.Ruleset = Rulesets.GetRuleset(s.RulesetID);
}
if (!scores.Any() && VisiblePages == 1)
{
ShowMoreButton.Hide();
ShowMoreLoading.Hide();
MissingText.Show();
return;
}
IEnumerable <DrawableProfileScore> drawableScores;
switch (type)
{
default:
drawableScores = scores.Select(score => new DrawablePerformanceScore(score, includeWeight ? Math.Pow(0.95, ItemsContainer.Count) : (double?)null));
break;
case ScoreType.Recent:
drawableScores = scores.Select(score => new DrawableTotalScore(score));
break;
}
LoadComponentsAsync(drawableScores, s =>
{
MissingText.Hide();
ShowMoreButton.FadeTo(scores.Count == ItemsPerPage ? 1 : 0);
ShowMoreLoading.Hide();
ItemsContainer.AddRange(s);
});
});
Api.Queue(request);
}
protected override void ShowMore()
{
base.ShowMore();
var req = new GetUserScoresRequest(User.Value.Id, type, VisiblePages++ *ItemsPerPage);
req.Success += scores =>
{
foreach (var s in scores)
{
s.ApplyRuleset(Rulesets.GetRuleset(s.OnlineRulesetID));
}
ShowMoreButton.FadeTo(scores.Count == ItemsPerPage ? 1 : 0);
ShowMoreLoading.Hide();
if (!scores.Any() && VisiblePages == 1)
{
MissingText.Show();
return;
}
MissingText.Hide();
foreach (APIScore score in scores)
{
DrawableProfileScore drawableScore;
switch (type)
{
default:
drawableScore = new DrawablePerformanceScore(score, includeWeight ? Math.Pow(0.95, ItemsContainer.Count) : (double?)null);
break;
case ScoreType.Recent:
drawableScore = new DrawableTotalScore(score);
break;
}
ItemsContainer.Add(drawableScore);
}
};
Api.Queue(req);
}
private void updatePlaylist(MultiplayerRoomSettings settings, BeatmapSetInfo beatmapSet)
{
if (Room == null || !Room.Settings.Equals(settings))
{
return;
}
Debug.Assert(apiRoom != null);
var beatmap = beatmapSet.Beatmaps.Single(b => b.OnlineBeatmapID == settings.BeatmapID);
beatmap.MD5Hash = settings.BeatmapChecksum;
var ruleset = Rulesets.GetRuleset(settings.RulesetID).CreateInstance();
var mods = settings.RequiredMods.Select(m => m.ToMod(ruleset));
var allowedMods = settings.AllowedMods.Select(m => m.ToMod(ruleset));
// Try to retrieve the existing playlist item from the API room.
var playlistItem = apiRoom.Playlist.FirstOrDefault(i => i.ID == settings.PlaylistItemId);
if (playlistItem != null)
{
updateItem(playlistItem);
}
else
{
// An existing playlist item does not exist, so append a new one.
updateItem(playlistItem = new PlaylistItem());
apiRoom.Playlist.Add(playlistItem);
}
CurrentMatchPlayingItem.Value = playlistItem;
void updateItem(PlaylistItem item)
{
item.ID = settings.PlaylistItemId == 0 ? defaultPlaylistItemId : settings.PlaylistItemId;
item.Beatmap.Value = beatmap;
item.Ruleset.Value = ruleset.RulesetInfo;
item.RequiredMods.Clear();
item.RequiredMods.AddRange(mods);
item.AllowedMods.Clear();
item.AllowedMods.AddRange(allowedMods);
}
}
public static bool AddRuleset(Session session, string deviceName)
{
if (Rulesets.FirstOrDefault(x => x.RulesetName.Equals(session.SessionName)) == null)
{
var newRuleset = new Ruleset(session, deviceName, Rulesets.Count);
Rulesets.Add(newRuleset);
if (RulesetsTableMgr.AddRuleset(newRuleset))
{
Logger.AddLogEntry(LogCategory.INFO, "Added Ruleset: " + session.SessionName);
return(true);
}
else
{
return(false);
}
}
return(false);
}
private PlaylistItem createPlaylistItem(MultiplayerPlaylistItem item)
{
var ruleset = Rulesets.GetRuleset(item.RulesetID);
Debug.Assert(ruleset != null);
var rulesetInstance = ruleset.CreateInstance();
var playlistItem = new PlaylistItem
{
ID = item.ID,
BeatmapID = item.BeatmapID,
OwnerID = item.OwnerID,
Ruleset = { Value = ruleset },
Expired = item.Expired,
PlaylistOrder = item.PlaylistOrder,
PlayedAt = item.PlayedAt
};
playlistItem.RequiredMods.AddRange(item.RequiredMods.Select(m => m.ToMod(rulesetInstance)));
playlistItem.AllowedMods.AddRange(item.AllowedMods.Select(m => m.ToMod(rulesetInstance)));
return(playlistItem);
}
public static Ruleset GetRuleset(string rulesetName)
{
return(Rulesets.FirstOrDefault(x => x.RulesetName.Equals(rulesetName)));
}
public BaseRuleset getRule(Rulesets r) {
return rulesetDictionary[(int)r];
}
public ValidationError[] Validate(Rulesets ruleSets)
{
// do validate
}
private void GetObjects(string document, string file, TranslateRule globalTranslate, TranslateRule playerTranslate, bool isRoot)
{
// If this file was already loaded, don't load it again.
if (Imported.Contains(file))
{
return;
}
Imported.Add(file);
Diagnostics.AddFile(file);
// Get the ruleset.
RulesetNode ruleset = GetRuleset(file, document);
Rulesets.Add(file, ruleset);
if (ruleset != null && !Diagnostics.ContainsErrors())
{
if (isRoot)
{
VarCollection = new VarCollection(ruleset.UseGlobalVar, ruleset.UsePlayerVar, ruleset.UseBuilderVar);
Root = new ScopeGroup(VarCollection);
}
// Get the defined types
foreach (var definedType in ruleset.DefinedTypes)
{
try
{
if (DefinedTypes.Any(type => type.Name == definedType.Name))
{
throw SyntaxErrorException.NameAlreadyDefined(definedType.Location);
}
DefinedTypes.Add(DefinedType.GetDefinedType(definedType));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the user methods.
for (int i = 0; i < ruleset.UserMethods.Length; i++)
{
try
{
UserMethods.Add(new UserMethod(Root, ruleset.UserMethods[i]));
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the rules
RuleNodes.AddRange(ruleset.Rules);
List <string> importedFiles = new List <string>();
foreach (ImportObjectNode importObject in ruleset.ObjectImports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importObject.File, file, importObject.Location);
if (!importer.AlreadyImported)
{
importedFiles.Add(importer.ResultingPath);
string content = importer.GetFile();
switch (importer.FileType)
{
case ".obj":
Model newModel = Model.ImportObj(content);
new ModelVar(importObject.Name, Root, importObject, newModel);
break;
}
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Check the imported files.
foreach (ImportNode importNode in ruleset.Imports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importNode.File, file, importNode.Location);
if (!importer.AlreadyImported)
{
string content = File.ReadAllText(importer.ResultingPath);
GetObjects(content, importer.ResultingPath, globalTranslate, playerTranslate, false);
importedFiles.Add(importer.ResultingPath);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
// Get the variables
foreach (var definedVar in ruleset.DefinedVars)
{
try
{
IndexedVar var;
if (definedVar.UseVar == null)
{
var = VarCollection.AssignVar(Root, definedVar.VariableName, definedVar.IsGlobal, definedVar);
}
else
{
var = VarCollection.AssignVar(
Root,
definedVar.VariableName,
definedVar.IsGlobal,
definedVar.UseVar.Variable,
definedVar.UseVar.Index,
definedVar
);
}
if (definedVar.Type != null)
{
var.Type = GetDefinedType(definedVar.Type, definedVar.Location);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
}
}
// Sets reference script variables
private void Awake()
{
main = GetComponent <Main>();
rulesets = GetComponent <Rulesets>();
}
private void GetRulesets(string document, string file, bool isRoot, ImportedFile cache)
{
string absolute = new Uri(file).AbsolutePath;
// If this file was already loaded, don't load it again.
if (Imported.Contains(absolute))
{
return;
}
Imported.Add(absolute);
Diagnostics.AddFile(file);
// Get the ruleset.
RulesetNode ruleset;
if (cache == null)
{
ruleset = GetRuleset(file, document);
}
else if (cache.Update() || cache.Cache == null)
{
ruleset = GetRuleset(file, cache.Content);
cache.Cache = ruleset;
}
else
{
ruleset = (RulesetNode)cache.Cache;
}
Rulesets.Add(file, ruleset);
// Get the imported files.
if (ruleset != null && !Diagnostics.ContainsErrors())
{
ReservedGlobalIDs.AddRange(ruleset.ReservedGlobalIDs);
ReservedPlayerIDs.AddRange(ruleset.ReservedPlayerIDs);
if (ruleset.ReservedGlobal != null)
{
ReservedGlobalIDs.AddRange(ruleset.ReservedGlobal.ReservedIDs);
ReservedGlobalNames.AddRange(ruleset.ReservedGlobal.ReservedNames);
}
if (ruleset.ReservedPlayer != null)
{
ReservedPlayerIDs.AddRange(ruleset.ReservedPlayer.ReservedIDs);
ReservedPlayerNames.AddRange(ruleset.ReservedPlayer.ReservedNames);
}
List <string> importedFiles = new List <string>();
foreach (ImportNode importNode in ruleset.Imports)
{
try
{
Importer importer = new Importer(Diagnostics, importedFiles, importNode.File, file, importNode.Location);
if (!importer.AlreadyImported)
{
GetRulesets(null, importer.ResultingPath, false, importer.FileData);
importedFiles.Add(importer.ResultingPath);
}
}
catch (SyntaxErrorException ex)
{
Diagnostics.Error(ex);
}
}
}
}
protected override void LoadComplete()
{
base.LoadComplete();
User.BindValueChanged(u => SetDefaultRuleset(Rulesets.GetRuleset(u.NewValue?.PlayMode ?? "osu")), true);
}