private void LoadContentPacks(IEnumerable <RawContentPack> contentPacks)
{
// load content packs
ConfigFileHandler configFileHandler = new ConfigFileHandler(this.ConfigFileName, this.ParseCommaDelimitedField, (pack, label, reason) => this.Monitor.Log($"Ignored {pack.Manifest.Name} > {label}: {reason}", LogLevel.Warn));
foreach (RawContentPack current in contentPacks)
{
this.Monitor.VerboseLog($"Loading content pack '{current.Manifest.Name}'...");
try
{
ContentConfig content = current.Content;
// load tokens
ModTokenContext modContext = this.TokenManager.TrackLocalTokens(current.ManagedPack.Pack);
{
// load config.json
InvariantDictionary <ConfigField> config = configFileHandler.Read(current.ManagedPack, content.ConfigSchema, current.Content.Format);
configFileHandler.Save(current.ManagedPack, config, this.Helper);
if (config.Any())
{
this.Monitor.VerboseLog($" found config.json with {config.Count} fields...");
}
// load config tokens
foreach (KeyValuePair <string, ConfigField> pair in config)
{
ConfigField field = pair.Value;
modContext.Add(new ImmutableToken(pair.Key, field.Value, scope: current.Manifest.UniqueID, allowedValues: field.AllowValues, canHaveMultipleValues: field.AllowMultiple));
}
// load dynamic tokens
foreach (DynamicTokenConfig entry in content.DynamicTokens ?? new DynamicTokenConfig[0])
{
void LogSkip(string reason) => this.Monitor.Log($"Ignored {current.Manifest.Name} > dynamic token '{entry.Name}': {reason}", LogLevel.Warn);
// validate token key
if (string.IsNullOrWhiteSpace(entry.Name))
{
LogSkip("the token name can't be empty.");
continue;
}
if (entry.Name.Contains(InternalConstants.InputArgSeparator))
{
LogSkip($"the token name can't have an input argument ({InternalConstants.InputArgSeparator} character).");
continue;
}
if (Enum.TryParse <ConditionType>(entry.Name, true, out _))
{
LogSkip("the token name is already used by a global token.");
continue;
}
if (config.ContainsKey(entry.Name))
{
LogSkip("the token name is already used by a config token.");
continue;
}
// parse values
ITokenString values;
if (!string.IsNullOrWhiteSpace(entry.Value))
{
if (!this.TryParseStringTokens(entry.Value, modContext, current.Migrator, out string valueError, out values))
{
LogSkip($"the token value is invalid: {valueError}");
continue;
}
}
else
{
values = new LiteralString("");
}
// parse conditions
IList <Condition> conditions;
{
if (!this.TryParseConditions(entry.When, modContext, current.Migrator, out conditions, out string conditionError))
{
this.Monitor.Log($"Ignored {current.Manifest.Name} > '{entry.Name}' token: its {nameof(DynamicTokenConfig.When)} field is invalid: {conditionError}.", LogLevel.Warn);
continue;
}
}
// add token
modContext.Add(new DynamicTokenValue(entry.Name, values, conditions));
}
}
// load patches
IContext patchTokenContext = new SinglePatchContext(current.Manifest.UniqueID, parentContext: modContext); // make patch tokens available to patches
content.Changes = this.SplitPatches(content.Changes).ToArray();
this.NamePatches(current.ManagedPack, content.Changes);
foreach (PatchConfig patch in content.Changes)
{
this.Monitor.VerboseLog($" loading {patch.LogName}...");
this.LoadPatch(current.ManagedPack, patch, patchTokenContext, current.Migrator, logSkip: reasonPhrase => this.Monitor.Log($"Ignored {patch.LogName}: {reasonPhrase}", LogLevel.Warn));
}
}
catch (Exception ex)
{
this.Monitor.Log($"Error loading content pack '{current.Manifest.Name}'. Technical details:\n{ex}", LogLevel.Error);
continue;
}
}
}
private void LoadContentPacks(IEnumerable <RawContentPack> contentPacks)
{
// load content packs
ConfigFileHandler configFileHandler = new ConfigFileHandler(this.ConfigFileName, this.ParseCommaDelimitedField, (pack, label, reason) => this.Monitor.Log($"Ignored {pack.Manifest.Name} > {label}: {reason}"));
foreach (RawContentPack current in contentPacks)
{
this.Monitor.VerboseLog($"Loading content pack '{current.Manifest.Name}'...");
try
{
ContentConfig content = current.Content;
// load tokens
ModTokenContext tokenContext = this.TokenManager.TrackLocalTokens(current.ManagedPack.Pack);
{
// load config.json
InvariantDictionary <ConfigField> config = configFileHandler.Read(current.ManagedPack, content.ConfigSchema);
configFileHandler.Save(current.ManagedPack, config, this.Helper);
if (config.Any())
{
this.Monitor.VerboseLog($" found config.json with {config.Count} fields...");
}
// load config tokens
foreach (KeyValuePair <string, ConfigField> pair in config)
{
ConfigField field = pair.Value;
tokenContext.Add(new ImmutableToken(pair.Key, field.Value, allowedValues: field.AllowValues, canHaveMultipleValues: field.AllowMultiple));
}
// load dynamic tokens
foreach (DynamicTokenConfig entry in content.DynamicTokens ?? new DynamicTokenConfig[0])
{
void LogSkip(string reason) => this.Monitor.Log($"Ignored {current.Manifest.Name} > dynamic token '{entry.Name}': {reason}", LogLevel.Warn);
// validate token key
if (!TokenName.TryParse(entry.Name, out TokenName name))
{
LogSkip("the name could not be parsed as a token key.");
continue;
}
if (name.HasSubkey())
{
LogSkip("the token name cannot contain a subkey (:).");
continue;
}
if (name.TryGetConditionType(out ConditionType conflictingType))
{
LogSkip($"conflicts with global token '{conflictingType}'.");
continue;
}
if (config.ContainsKey(name.Key))
{
LogSkip($"conflicts with player config token '{conflictingType}'.");
continue;
}
// parse values
InvariantHashSet values = entry.Value != null?this.ParseCommaDelimitedField(entry.Value) : new InvariantHashSet();
// parse conditions
ConditionDictionary conditions;
{
if (!this.TryParseConditions(entry.When, tokenContext, current.Migrator, out conditions, out string error))
{
this.Monitor.Log($"Ignored {current.Manifest.Name} > '{entry.Name}' token: its {nameof(DynamicTokenConfig.When)} field is invalid: {error}.", LogLevel.Warn);
continue;
}
}
// add token
tokenContext.Add(new DynamicTokenValue(name, values, conditions));
}
}
// load patches
content.Changes = this.SplitPatches(content.Changes).ToArray();
this.NamePatches(current.ManagedPack, content.Changes);
foreach (PatchConfig patch in content.Changes)
{
this.Monitor.VerboseLog($" loading {patch.LogName}...");
this.LoadPatch(current.ManagedPack, patch, tokenContext, current.Migrator, logSkip: reasonPhrase => this.Monitor.Log($"Ignored {patch.LogName}: {reasonPhrase}", LogLevel.Warn));
}
}
catch (Exception ex)
{
this.Monitor.Log($"Error loading content pack '{current.Manifest.Name}'. Technical details:\n{ex}", LogLevel.Error);
continue;
}
}
}
private void LoadContentPacks()
{
ConfigFileHandler configFileHandler = new ConfigFileHandler(this.ConfigFileName, this.PatchManager.ParseCommaDelimitedField, (pack, label, reason) => this.Monitor.Log($"Ignored {pack.Manifest.Name} > {label}: {reason}"));
foreach (IContentPack pack in this.Helper.GetContentPacks())
{
this.VerboseLog($"Loading content pack '{pack.Manifest.Name}'...");
try
{
// read changes file
ContentConfig content = pack.ReadJsonFile <ContentConfig>(this.PatchFileName);
if (content == null)
{
this.Monitor.Log($"Ignored content pack '{pack.Manifest.Name}' because it has no {this.PatchFileName} file.", LogLevel.Error);
continue;
}
if (content.Format == null || content.Changes == null)
{
this.Monitor.Log($"Ignored content pack '{pack.Manifest.Name}' because it doesn't specify the required {nameof(ContentConfig.Format)} or {nameof(ContentConfig.Changes)} fields.", LogLevel.Error);
continue;
}
// validate version
if (!this.SupportedFormatVersions.Contains(content.Format.ToString()))
{
this.Monitor.Log($"Ignored content pack '{pack.Manifest.Name}' because it uses unsupported format {content.Format} (supported version: {string.Join(", ", this.SupportedFormatVersions)}).", LogLevel.Error);
continue;
}
// load config.json
InvariantDictionary <ConfigField> config = configFileHandler.Read(pack, content.ConfigSchema);
configFileHandler.Save(pack, config, this.Helper);
if (config.Any())
{
this.VerboseLog($" found config.json with {config.Count} fields...");
}
// validate features
if (content.Format.IsOlderThan("1.3"))
{
if (config.Any())
{
this.Monitor.Log($"Loading content pack '{pack.Manifest.Name}' failed. It specifies format version {content.Format}, but uses the {nameof(ContentConfig.ConfigSchema)} field added in 1.3.", LogLevel.Error);
continue;
}
if (content.Changes.Any(p => p.FromFile != null && p.FromFile.Contains("{{")))
{
this.Monitor.Log($"Loading content pack '{pack.Manifest.Name}' failed. It specifies format version {content.Format}, but uses the {{{{token}}}} feature added in 1.3.", LogLevel.Error);
continue;
}
if (content.Changes.Any(p => p.When != null && p.When.Any()))
{
this.Monitor.Log($"Loading content pack '{pack.Manifest.Name}' failed. It specifies format version {content.Format}, but uses the condition feature ({nameof(ContentConfig.Changes)}.{nameof(PatchConfig.When)} field) added in 1.3.", LogLevel.Error);
continue;
}
}
// load patches
this.NamePatches(pack, content.Changes);
foreach (PatchConfig patch in content.Changes)
{
this.VerboseLog($" loading {patch.LogName}...");
this.LoadPatch(pack, patch, config, logSkip: reasonPhrase => this.Monitor.Log($"Ignored {patch.LogName}: {reasonPhrase}", LogLevel.Warn));
}
}
catch (Exception ex)
{
this.Monitor.Log($"Error loading content pack '{pack.Manifest.Name}'. Technical details:\n{ex}", LogLevel.Error);
}
}
}
