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); }