예제 #1
0
        /// <summary>Load config values from the content pack.</summary>
        /// <param name="contentPack">The content pack whose config file to read.</param>
        /// <param name="config">The config schema.</param>
        /// <param name="logWarning">The callback to invoke on each validation warning, passed the field name and reason respectively.</param>
        private void LoadConfigValues(ManagedContentPack contentPack, InvariantDictionary <ConfigField> config, Action <string, string> logWarning)
        {
            if (!config.Any())
            {
                return;
            }

            // read raw config
            InvariantDictionary <InvariantHashSet> configValues = new InvariantDictionary <InvariantHashSet>(
                from entry in (contentPack.ReadJsonFile <InvariantDictionary <string> >(this.Filename) ?? new InvariantDictionary <string>())
                let key                         = entry.Key.Trim()
                                      let value = this.ParseCommaDelimitedField(entry.Value)
                                                  select new KeyValuePair <string, InvariantHashSet>(key, value)
                );

            // remove invalid values
            foreach (string key in configValues.Keys.ExceptIgnoreCase(config.Keys).ToArray())
            {
                logWarning(key, "no such field supported by this content pack.");
                configValues.Remove(key);
            }

            // inject default values
            foreach (string key in config.Keys)
            {
                ConfigField field = config[key];
                if (!configValues.TryGetValue(key, out InvariantHashSet values) || (!field.AllowBlank && !values.Any()))
                {
                    configValues[key] = field.DefaultValues;
                }
            }

            // parse each field
            foreach (string key in config.Keys)
            {
                // set value
                ConfigField field = config[key];
                field.Value = configValues[key];

                // validate allow-multiple
                if (!field.AllowMultiple && field.Value.Count > 1)
                {
                    logWarning(key, "field only allows a single value.");
                    field.Value = field.DefaultValues;
                    continue;
                }

                // validate allow-values
                if (field.AllowValues.Any())
                {
                    string[] invalidValues = field.Value.ExceptIgnoreCase(field.AllowValues).ToArray();
                    if (invalidValues.Any())
                    {
                        logWarning(key,
                                   $"found invalid values ({string.Join(", ", invalidValues)}), expected: {string.Join(", ", field.AllowValues)}.");
                        field.Value = field.DefaultValues;
                    }
                }
            }
        }
예제 #2
0
        /// <summary>Read the configuration file for a content pack.</summary>
        /// <param name="contentPack">The content pack.</param>
        /// <param name="rawSchema">The raw config schema from the mod's <c>content.json</c>.</param>
        public InvariantDictionary <ConfigField> Read(ManagedContentPack contentPack, InvariantDictionary <ConfigSchemaFieldConfig> rawSchema)
        {
            InvariantDictionary <ConfigField> config = this.LoadConfigSchema(rawSchema, logWarning: (field, reason) => this.LogWarning(contentPack, $"{nameof(ContentConfig.ConfigSchema)} field '{field}'", reason));

            this.LoadConfigValues(contentPack, config, logWarning: (field, reason) => this.LogWarning(contentPack, $"{this.Filename} > {field}", reason));
            return(config);
        }
예제 #3
0
        /// <summary>Get the tokens which are defined for a specific content pack. This returns a reference to the list, which can be held for a live view of the tokens. If the content pack isn't currently tracked, this will add it.</summary>
        /// <param name="pack">The content pack to manage.</param>
        public ModTokenContext TrackLocalTokens(ManagedContentPack pack)
        {
            string scope = pack.Manifest.UniqueID;

            if (!this.LocalTokens.TryGetValue(pack.Pack, out ModTokenContext localTokens))
            {
                this.LocalTokens[pack.Pack] = localTokens = new ModTokenContext(scope, this);
                foreach (IValueProvider valueProvider in this.GetLocalValueProviders(pack))
                {
                    localTokens.AddLocalToken(new Token(valueProvider, scope));
                }
            }

            return(localTokens);
        }
예제 #4
0
        /// <summary>Save the configuration file for a content pack.</summary>
        /// <param name="contentPack">The content pack.</param>
        /// <param name="config">The configuration to save.</param>
        /// <param name="modHelper">The mod helper through which to save the file.</param>
        public void Save(ManagedContentPack contentPack, InvariantDictionary <ConfigField> config, IModHelper modHelper)
        {
            string configPath = contentPack.GetFullPath(this.Filename);

            // save if settings valid
            if (config.Any())
            {
                InvariantDictionary <string> data = new InvariantDictionary <string>(config.ToDictionary(p => p.Key, p => string.Join(", ", p.Value.Value)));
                modHelper.WriteJsonFile(configPath, data);
            }

            // delete if no settings
            else if (File.Exists(configPath))
            {
                File.Delete(configPath);
            }
        }
예제 #5
0
        /// <summary>Save the configuration file for a content pack.</summary>
        /// <param name="contentPack">The content pack.</param>
        /// <param name="config">The configuration to save.</param>
        /// <param name="modHelper">The mod helper through which to save the file.</param>
        public void Save(ManagedContentPack contentPack, InvariantDictionary <ConfigField> config, IModHelper modHelper)
        {
            // save if settings valid
            if (config.Any())
            {
                InvariantDictionary <string> data = new InvariantDictionary <string>(config.ToDictionary(p => p.Key, p => string.Join(", ", p.Value.Value)));
                contentPack.WriteJsonFile(this.Filename, data);
            }

            // delete if no settings
            else
            {
                FileInfo file = new FileInfo(Path.Combine(contentPack.GetFullPath(this.Filename)));
                if (file.Exists)
                {
                    file.Delete();
                }
            }
        }
예제 #6
0
        /// <summary>Get the local value providers with which to initialize a local context.</summary>
        /// <param name="contentPack">The content pack for which to get tokens.</param>
        private IEnumerable <IValueProvider> GetLocalValueProviders(ManagedContentPack contentPack)
        {
            yield return(new HasFileValueProvider(contentPack.HasFile));

            yield return(new TranslationValueProvider(contentPack.Pack.Translation));
        }
예제 #7
0
        /// <summary>Get the local value providers with which to initialize a local context.</summary>
        /// <param name="contentPack">The content pack for which to get tokens.</param>
        private IEnumerable <IValueProvider> GetLocalValueProviders(ManagedContentPack contentPack)
        {
            yield return(new HasFileValueProvider(contentPack.HasFile));

            yield return(new RandomValueProvider()); // per-pack for more reproducible selection when troubleshooting
        }
예제 #8
0
 /*********
 ** Public methods
 *********/
 /// <summary>Construct an instance.</summary>
 /// <param name="contentPack">The managed content pack instance.</param>
 /// <param name="content">The raw content configuration for this content pack.</param>
 /// <param name="migrator">The migrations to apply for the content pack version.</param>
 public RawContentPack(ManagedContentPack contentPack, ContentConfig content, IMigration migrator)
 {
     this.ManagedPack = contentPack;
     this.Content     = content;
     this.Migrator    = migrator;
 }