/// <summary> /// Gets all items with given trait /// <para>Possible traits:</para> /// <para>item_type: weapon, armor, ghost_hologram, boost, emote, finisher, currency, engram, shader, emblem, consumable, light_subclass, ghost, /// weapon_ornament, ship, vehicle, aura, dark_subclass, bounty</para> /// <para>armor_type: head, chest, arms, legs, class</para> /// <para>weapon_type: rocket_launcher, sniper_rifle, grenade_launcher, pulse_rifle, shotgun, auto_rifle, sidearm, bow, fusion_rifle, machinegun, /// trace_rifle, hand_cannon, scout_rifle, submachinegun, sword, linear_fusion_rifle</para> /// <para>foundry: suros, fotc, hakke, omolon, veist, field_forged, tex_mechanica, daito</para> /// <para>faction: new_monarchy, trials, vanguard, iron_banner, crucible, dead_orbit, future_war_cult, gambit, mamba, commando</para> /// <para>inventory_filtering: quest, bounty, featured</para> /// <para>quest: new_light, seasonal, playlists, past, exotic, current_release</para> /// <para>mamba_role: collector, defender, invader, killer</para> /// </summary> /// <param name="trait">Item trait to search for</param> /// <returns></returns> public List <DestinyInventoryItemDefinition> GetItemsWithTrait(DestinyLocales locale, string trait) { return(_localisedRepositories[locale].Search <DestinyInventoryItemDefinition>(DefinitionsEnum.DestinyInventoryItemDefinition, x => { var traits = (x as DestinyInventoryItemDefinition).TraitIds; if (traits == null) { return false; } else { return traits.Contains(trait); } }).ToList()); }
public static string LocaleToString(this DestinyLocales locale) { return(locale switch { DestinyLocales.EN => "en", DestinyLocales.RU => "ru", DestinyLocales.DE => "de", DestinyLocales.ES => "es", DestinyLocales.ES_MX => "es-mx", DestinyLocales.FR => "fr", DestinyLocales.IT => "it", DestinyLocales.JA => "ja", DestinyLocales.KO => "ko", DestinyLocales.PL => "pl", DestinyLocales.PT_BR => "pt-br", DestinyLocales.ZH_CHS => "zh-chs", DestinyLocales.ZH_CHT => "zh-cht", _ => throw new Exception("Wrong locale."), });
internal DefinitionHashPointer(uint?hash, DefinitionsEnum type, DestinyLocales locale, T def = default, ILocalisedDestinyDefinitionRepositories repo = null) { if (def != null) { m_value = def; Exists = true; } Hash = hash; DefinitionEnumType = type; if (repo != null) { _repository = repo; } else { _repository = StaticUnityContainer.GetDestinyDefinitionRepositories(); } Locale = locale; }
public string FetchJSONFromDB(DestinyLocales locale, DefinitionsEnum definitionType, uint hash) { if (!_assemblyData.DefinitionsToTypeMapping[definitionType].AttributeData.Sources.HasFlag(Attributes.DefinitionSources.SQLite)) { throw new Exception("This definition type isn't present in SQLite database."); } var manifest = StaticUnityContainer.GetManifestUpdateHandler().CurrentManifest; var mobileWorldContentPathsLocalePath = Path.GetFileName(manifest.MobileWorldContentPaths[locale.LocaleToString()]); var connectionString = @$ "Data Source={_configs.Settings.VersionsRepositoryPath}\\{manifest.Version}\\MobileWorldContent\\{locale.LocaleToString()}\\{mobileWorldContentPathsLocalePath}; Version=3;"; string result = string.Empty; using (SQLiteConnection connection = new SQLiteConnection(connectionString)) { connection.Open(); string query = $"SELECT * FROM {definitionType.ToString()} WHERE id={hash.ToInt32()}"; SQLiteCommand command = new SQLiteCommand { Connection = connection, CommandText = query }; try { var reader = command.ExecuteReader(); while (reader.Read()) { var byteArray = (byte[])reader["json"]; result = Encoding.UTF8.GetString(byteArray, 0, byteArray.Length); } } catch (Exception e) { _logger.Log(e.Message, LogType.Error); } connection.Close(); } return(result); }
/// <summary> /// Class .ctor /// </summary> /// <param name="locale">Locale for this repository</param> internal DestinyDefinitionsRepository(DestinyLocales locale, IDefinitionAssemblyData assemblyData, IConfigurationService configuration, ILogger logger) { _assemblyData = assemblyData; _config = configuration; _logger = logger; Locale = locale; _loadRules = _assemblyData.DefinitionsToTypeMapping .Where(x => !_config.Settings.ExcludedDefinitions.Contains(x.Key)) .Where(x => x.Value.AttributeData.Sources.HasFlag(_config.Settings.PreferredLoadSource)) .ToDictionary(x => x.Key, x => _config.Settings.PreferredLoadSource); if (_config.Settings.SpecifiedLoadSources.Count > 0) { foreach (var source in _config.Settings.SpecifiedLoadSources) { var definitionAssemblyRules = _assemblyData.DefinitionsToTypeMapping[source.Key]; if (definitionAssemblyRules.AttributeData.Sources.HasFlag(source.Value)) { if (!_loadRules.TryAdd(source.Key, source.Value)) { _loadRules[source.Key] = source.Value; } } } } int definitionsLoaded = _loadRules.Count; int concurrencyLevel = _config.Settings.AppConcurrencyLevel; _logger.Log($"Initializing definitions repository with settings: Locale: {Locale}, Concurrency level: {concurrencyLevel}, Capacity: {definitionsLoaded}", LogType.Debug); _definitionRepositories = new ConcurrentDictionary <DefinitionsEnum, DestinyDefinitionTypeRepository>( concurrencyLevel: concurrencyLevel, capacity: definitionsLoaded); }
public IEnumerable <T> GetAll <T>(DestinyLocales locale = DestinyLocales.EN) where T : IDestinyDefinition { return(_localisedRepositories[locale].GetAll <T>(_assemblyData.TypeToEnumMapping[typeof(T)])); }
public IEnumerable <T> GetAll <T>(DefinitionsEnum definitionType, DestinyLocales locale) where T : IDestinyDefinition { return(_localisedRepositories[locale].GetAll <T>(definitionType)); }
public IEnumerable <T> Search <T>(DefinitionsEnum definitionType, DestinyLocales locale, Func <IDestinyDefinition, bool> predicate) where T : IDestinyDefinition { return(_localisedRepositories[locale].Search <T>(definitionType, predicate)); }
public bool TryGetDestinyDefinition <T>(DefinitionsEnum definitionType, uint key, DestinyLocales locale, out T definition) where T : IDestinyDefinition { return(_localisedRepositories[locale].TryGetDefinition(definitionType, key, out definition)); }
public void AddDefinitionToCache(DefinitionsEnum definitionType, IDestinyDefinition defValue, DestinyLocales locale) { _localisedRepositories[locale].AddDefinition(definitionType, defValue); }
public void SetLocaleContext(DestinyLocales locale) { _currentLocaleLoadContext = locale; }
public List <DestinyActivityDefinition> SearchActivitiesByName(DestinyLocales locale, string name) { return(_localisedRepositories[locale] .Search <DestinyActivityDefinition>(DefinitionsEnum.DestinyActivityDefinition, x => (x as DestinyActivityDefinition).DisplayProperties.Name.Contains(name, StringComparison.OrdinalIgnoreCase)) .ToList()); }
public List <DestinyInventoryItemDefinition> GetSacks(DestinyLocales locale) { return(_localisedRepositories[locale] .Search <DestinyInventoryItemDefinition>(DefinitionsEnum.DestinyInventoryItemDefinition, x => (x as DestinyInventoryItemDefinition).Sack != null) .ToList()); }
public static Dictionary <DestinyItemCategoryDefinition, List <DestinyInventoryItemDefinition> > GetItemsCategorized(this ILocalisedDestinyDefinitionRepositories repo, DestinyLocales locale) { var result = new Dictionary <DestinyItemCategoryDefinition, List <DestinyInventoryItemDefinition> >(); foreach (var category in repo.GetAll <DestinyItemCategoryDefinition>(locale)) { List <DestinyInventoryItemDefinition> categorizedItems = new List <DestinyInventoryItemDefinition>(); result.Add(category, categorizedItems); } foreach (var item in repo.GetAll <DestinyInventoryItemDefinition>(locale)) { foreach (var category in item.ItemCategories) { result[category.Value].Add(item); } } return(result); }