/// <summary>Load one patch from a content pack's <c>content.json</c> file.</summary>
/// <param name="pack">The content pack being loaded.</param>
/// <param name="entry">The change to load.</param>
/// <param name="tokenContext">The tokens available for this content pack.</param>
/// <param name="migrator">The migrator which validates and migrates content pack data.</param>
/// <param name="logSkip">The callback to invoke with the error reason if loading it fails.</param>
private bool LoadPatch(ManagedContentPack pack, PatchConfig entry, IContext tokenContext, IMigration migrator, Action <string> logSkip)
{
bool TrackSkip(string reason, bool warn = true)
{
this.PatchManager.AddPermanentlyDisabled(new DisabledPatch(entry.LogName, entry.Action, entry.Target, pack, reason));
if (warn)
{
logSkip(reason);
}
return(false);
}
try
{
// normalise patch fields
if (entry.When == null)
{
entry.When = new InvariantDictionary <string>();
}
// parse action
if (!Enum.TryParse(entry.Action, true, out PatchType action))
{
return(TrackSkip(string.IsNullOrWhiteSpace(entry.Action)
? $"must set the {nameof(PatchConfig.Action)} field."
: $"invalid {nameof(PatchConfig.Action)} value '{entry.Action}', expected one of: {string.Join(", ", Enum.GetNames(typeof(PatchType)))}."
));
}
// parse target asset
TokenString assetName;
{
if (string.IsNullOrWhiteSpace(entry.Target))
{
return(TrackSkip($"must set the {nameof(PatchConfig.Target)} field."));
}
if (!this.TryParseTokenString(entry.Target, tokenContext, migrator, out string error, out assetName))
{
return(TrackSkip($"the {nameof(PatchConfig.Target)} is invalid: {error}"));
}
}
// parse 'enabled'
bool enabled = true;
{
if (entry.Enabled != null && !this.TryParseEnabled(entry.Enabled, tokenContext, migrator, out string error, out enabled))
{
return(TrackSkip($"invalid {nameof(PatchConfig.Enabled)} value '{entry.Enabled}': {error}"));
}
}
// parse conditions
ConditionDictionary conditions;
{
if (!this.TryParseConditions(entry.When, tokenContext, migrator, out conditions, out string error))
{
return(TrackSkip($"the {nameof(PatchConfig.When)} field is invalid: {error}."));
}
}
// get patch instance
IPatch patch;
switch (action)
{
// load asset
case PatchType.Load:
{
// init patch
if (!this.TryPrepareLocalAsset(pack, entry.FromFile, tokenContext, migrator, out string error, out TokenString fromAsset))
{
return(TrackSkip(error));
}
patch = new LoadPatch(entry.LogName, pack, assetName, conditions, fromAsset, this.Helper.Content.NormaliseAssetName);
}
break;
// edit data
case PatchType.EditData:
{
// validate
if (entry.Entries == null && entry.Fields == null)
{
return(TrackSkip($"either {nameof(PatchConfig.Entries)} or {nameof(PatchConfig.Fields)} must be specified for a '{action}' change."));
}
if (entry.Entries != null && entry.Entries.Any(p => p.Value != null && p.Value.Trim() == ""))
{
return(TrackSkip($"the {nameof(PatchConfig.Entries)} can't contain empty values."));
}
if (entry.Fields != null && entry.Fields.Any(p => p.Value == null || p.Value.Any(n => n.Value == null)))
{
return(TrackSkip($"the {nameof(PatchConfig.Fields)} can't contain empty values."));
}
// parse entries
List <EditDataPatchRecord> entries = new List <EditDataPatchRecord>();
if (entry.Entries != null)
{
foreach (KeyValuePair <string, string> pair in entry.Entries)
{
if (!this.TryParseTokenString(pair.Key, tokenContext, migrator, out string keyError, out TokenString key))
{
return(TrackSkip($"{nameof(PatchConfig.Entries)} > '{key}' key is invalid: {keyError}."));
}
if (!this.TryParseTokenString(pair.Value, tokenContext, migrator, out string error, out TokenString value))
{
return(TrackSkip($"{nameof(PatchConfig.Entries)} > '{key}' value is invalid: {error}."));
}
entries.Add(new EditDataPatchRecord(key, value));
}
}
// parse fields
List <EditDataPatchField> fields = new List <EditDataPatchField>();
if (entry.Fields != null)
{
foreach (KeyValuePair <string, IDictionary <int, string> > recordPair in entry.Fields)
{
if (!this.TryParseTokenString(recordPair.Key, tokenContext, migrator, out string keyError, out TokenString key))
{
return(TrackSkip($"{nameof(PatchConfig.Fields)} > entry {recordPair.Key} is invalid: {keyError}."));
}
foreach (var fieldPair in recordPair.Value)
{
int field = fieldPair.Key;
if (!this.TryParseTokenString(fieldPair.Value, tokenContext, migrator, out string valueError, out TokenString value))
{
return(TrackSkip($"{nameof(PatchConfig.Fields)} > entry {recordPair.Key} > field {field} is invalid: {valueError}."));
}
if (value.Raw?.Contains("/") == true)
{
return(TrackSkip($"{nameof(PatchConfig.Fields)} > entry {recordPair.Key} > field {field} is invalid: value can't contain field delimiter character '/'."));
}
fields.Add(new EditDataPatchField(key, field, value));
}
}
}
// save
patch = new EditDataPatch(entry.LogName, pack, assetName, conditions, entries, fields, this.Monitor, this.Helper.Content.NormaliseAssetName);
}
break;
// edit image
case PatchType.EditImage:
{
// read patch mode
PatchMode patchMode = PatchMode.Replace;
if (!string.IsNullOrWhiteSpace(entry.PatchMode) && !Enum.TryParse(entry.PatchMode, true, out patchMode))
{
return(TrackSkip($"the {nameof(PatchConfig.PatchMode)} is invalid. Expected one of these values: [{string.Join(", ", Enum.GetNames(typeof(PatchMode)))}]."));
}
// save
if (!this.TryPrepareLocalAsset(pack, entry.FromFile, tokenContext, migrator, out string error, out TokenString fromAsset))
{
return(TrackSkip(error));
}
patch = new EditImagePatch(entry.LogName, pack, assetName, conditions, fromAsset, entry.FromArea, entry.ToArea, patchMode, this.Monitor, this.Helper.Content.NormaliseAssetName);
}
break;
default:
return(TrackSkip($"unsupported patch type '{action}'."));
}
// skip if not enabled
// note: we process the patch even if it's disabled, so any errors are caught by the modder instead of only failing after the patch is enabled.
if (!enabled)
{
return(TrackSkip($"{nameof(PatchConfig.Enabled)} is false.", warn: false));
}
// save patch
this.PatchManager.Add(patch);
return(true);
}
catch (Exception ex)
{
return(TrackSkip($"error reading info. Technical details:\n{ex}"));
}
}
/// <summary>Load one patch from a content pack's <c>content.json</c> file.</summary>
/// <param name="pack">The content pack being loaded.</param>
/// <param name="entry">The change to load.</param>
/// <param name="config">The content pack's config values.</param>
/// <param name="logSkip">The callback to invoke with the error reason if loading it fails.</param>
private bool LoadPatch(IContentPack pack, PatchConfig entry, InvariantDictionary <ConfigField> config, Action <string> logSkip)
{
bool TrackSkip(string reason, bool warn = true)
{
this.PatchManager.AddPermanentlyDisabled(new DisabledPatch(entry.LogName, entry.Action, entry.Target, pack, reason));
if (warn)
{
logSkip(reason);
}
return(false);
}
try
{
// normalise patch fields
if (entry.When == null)
{
entry.When = new InvariantDictionary <string>();
}
// parse action
if (!Enum.TryParse(entry.Action, true, out PatchType action))
{
return(TrackSkip(string.IsNullOrWhiteSpace(entry.Action)
? $"must set the {nameof(PatchConfig.Action)} field."
: $"invalid {nameof(PatchConfig.Action)} value '{entry.Action}', expected one of: {string.Join(", ", Enum.GetNames(typeof(PatchType)))}."
));
}
// parse target asset
TokenString assetName;
{
if (string.IsNullOrWhiteSpace(entry.Target))
{
return(TrackSkip($"must set the {nameof(PatchConfig.Target)} field."));
}
if (!this.TryParseTokenString(entry.Target, config, out string error, out TokenStringBuilder builder))
{
return(TrackSkip($"the {nameof(PatchConfig.Target)} is invalid: {error}"));
}
assetName = builder.Build();
}
// parse 'enabled'
bool enabled = true;
{
if (entry.Enabled != null && !this.TryParseBoolean(entry.Enabled, config, out string error, out enabled))
{
return(TrackSkip($"invalid {nameof(PatchConfig.Enabled)} value '{entry.Enabled}': {error}"));
}
}
// apply config
foreach (string key in config.Keys)
{
if (entry.When.TryGetValue(key, out string values))
{
InvariantHashSet expected = this.PatchManager.ParseCommaDelimitedField(values);
if (!expected.Intersect(config[key].Value).Any())
{
return(TrackSkip($"disabled: config field '{key}' must have one of '{string.Join(", ", expected)}', but found '{string.Join(", ", config[key].Value)}'.", warn: false));
}
entry.When.Remove(key);
}
}
// parse conditions
ConditionDictionary conditions;
{
if (!this.PatchManager.TryParseConditions(entry.When, out conditions, out string error))
{
return(TrackSkip($"the {nameof(PatchConfig.When)} field is invalid: {error}."));
}
}
// get patch instance
IPatch patch;
switch (action)
{
// load asset
case PatchType.Load:
{
// init patch
if (!this.TryPrepareLocalAsset(pack, entry.FromFile, config, conditions, out string error, out TokenString fromAsset, checkOnly: !enabled))
{
return(TrackSkip(error));
}
patch = new LoadPatch(entry.LogName, this.AssetLoader, pack, assetName, conditions, fromAsset, this.Helper.Content.NormaliseAssetName);
// detect conflicting loaders
if (enabled)
{
InvariantDictionary <IPatch> conflicts = this.PatchManager.GetConflictingLoaders(patch);
if (conflicts.Any())
{
IEnumerable <string> conflictNames = (from conflict in conflicts
orderby conflict.Key
select $"'{conflict.Value.LogName}' already loads {conflict.Key}");
return(TrackSkip(
$"{nameof(entry.Target)} '{patch.TokenableAssetName.Raw}' conflicts with other load patches ({string.Join(", ", conflictNames)}). Each file can only be loaded by one patch, unless their conditions can never overlap."));
}
}
}
break;
// edit data
case PatchType.EditData:
{
// validate
if (entry.Entries == null && entry.Fields == null)
{
return(TrackSkip($"either {nameof(PatchConfig.Entries)} or {nameof(PatchConfig.Fields)} must be specified for a '{action}' change."));
}
if (entry.Entries != null && entry.Entries.Any(p => string.IsNullOrWhiteSpace(p.Value)))
{
return(TrackSkip($"the {nameof(PatchConfig.Entries)} can't contain empty values."));
}
if (entry.Fields != null && entry.Fields.Any(p => p.Value == null || p.Value.Any(n => n.Value == null)))
{
return(TrackSkip($"the {nameof(PatchConfig.Fields)} can't contain empty values."));
}
// save
patch = new EditDataPatch(entry.LogName, this.AssetLoader, pack, assetName, conditions, entry.Entries, entry.Fields, this.Monitor, this.Helper.Content.NormaliseAssetName);
}
break;
// edit image
case PatchType.EditImage:
{
// read patch mode
PatchMode patchMode = PatchMode.Replace;
if (!string.IsNullOrWhiteSpace(entry.PatchMode) && !Enum.TryParse(entry.PatchMode, true, out patchMode))
{
return(TrackSkip($"the {nameof(PatchConfig.PatchMode)} is invalid. Expected one of these values: [{string.Join(", ", Enum.GetNames(typeof(PatchMode)))}]."));
}
// save
if (!this.TryPrepareLocalAsset(pack, entry.FromFile, config, conditions, out string error, out TokenString fromAsset, checkOnly: !enabled))
{
return(TrackSkip(error));
}
patch = new EditImagePatch(entry.LogName, this.AssetLoader, pack, assetName, conditions, fromAsset, entry.FromArea, entry.ToArea, patchMode, this.Monitor, this.Helper.Content.NormaliseAssetName);
}
break;
default:
return(TrackSkip($"unsupported patch type '{action}'."));
}
// only apply patch when its tokens are available
HashSet <ConditionKey> tokensUsed = new HashSet <ConditionKey>(patch.GetTokensUsed());
foreach (ConditionKey key in tokensUsed)
{
if (!patch.Conditions.ContainsKey(key))
{
patch.Conditions.Add(key, patch.Conditions.GetValidValues(key));
}
}
// skip if not enabled
// note: we process the patch even if it's disabled, so any errors are caught by the modder instead of only failing after the patch is enabled.
if (!enabled)
{
return(TrackSkip($"{nameof(PatchConfig.Enabled)} is false.", warn: false));
}
// save patch
this.PatchManager.Add(patch);
return(true);
}
catch (Exception ex)
{
return(TrackSkip($"error reading info. Technical details:\n{ex}"));
}
}
/// <summary>Load one patch from a content pack's <c>content.json</c> file.</summary>
/// <param name="pack">The content pack being loaded.</param>
/// <param name="entry">The change to load.</param>
/// <param name="tokenContext">The tokens available for this content pack.</param>
/// <param name="migrator">The migrator which validates and migrates content pack data.</param>
/// <param name="logSkip">The callback to invoke with the error reason if loading it fails.</param>
private bool LoadPatch(ManagedContentPack pack, PatchConfig entry, IContext tokenContext, IMigration migrator, Action <string> logSkip)
{
bool TrackSkip(string reason, bool warn = true)
{
reason = reason.TrimEnd('.', ' ');
this.PatchManager.AddPermanentlyDisabled(new DisabledPatch(entry.LogName, entry.Action, entry.Target, pack, reason));
if (warn)
{
logSkip(reason + '.');
}
return(false);
}
try
{
// normalise patch fields
if (entry.When == null)
{
entry.When = new InvariantDictionary <string>();
}
// parse action
if (!Enum.TryParse(entry.Action, true, out PatchType action))
{
return(TrackSkip(string.IsNullOrWhiteSpace(entry.Action)
? $"must set the {nameof(PatchConfig.Action)} field"
: $"invalid {nameof(PatchConfig.Action)} value '{entry.Action}', expected one of: {string.Join(", ", Enum.GetNames(typeof(PatchType)))}"
));
}
// parse target asset
ITokenString assetName;
{
if (string.IsNullOrWhiteSpace(entry.Target))
{
return(TrackSkip($"must set the {nameof(PatchConfig.Target)} field"));
}
if (!this.TryParseStringTokens(entry.Target, tokenContext, migrator, out string error, out assetName))
{
return(TrackSkip($"the {nameof(PatchConfig.Target)} is invalid: {error}"));
}
}
// parse 'enabled'
bool enabled = true;
{
if (entry.Enabled != null && !this.TryParseEnabled(entry.Enabled, tokenContext, migrator, out string error, out enabled))
{
return(TrackSkip($"invalid {nameof(PatchConfig.Enabled)} value '{entry.Enabled}': {error}"));
}
}
// parse conditions
IList <Condition> conditions;
{
if (!this.TryParseConditions(entry.When, tokenContext, migrator, out conditions, out string error))
{
return(TrackSkip($"the {nameof(PatchConfig.When)} field is invalid: {error}"));
}
}
// get patch instance
IPatch patch;
switch (action)
{
// load asset
case PatchType.Load:
{
// init patch
if (!this.TryPrepareLocalAsset(pack, entry.FromFile, tokenContext, migrator, out string error, out ITokenString fromAsset))
{
return(TrackSkip(error));
}
patch = new LoadPatch(entry.LogName, pack, assetName, conditions, fromAsset, this.Helper.Content.NormaliseAssetName);
}
break;
// edit data
case PatchType.EditData:
{
// validate
if (entry.Entries == null && entry.Fields == null && entry.MoveEntries == null)
{
return(TrackSkip($"one of {nameof(PatchConfig.Entries)}, {nameof(PatchConfig.Fields)}, or {nameof(PatchConfig.MoveEntries)} must be specified for an '{action}' change"));
}
// parse entries
List <EditDataPatchRecord> entries = new List <EditDataPatchRecord>();
if (entry.Entries != null)
{
foreach (KeyValuePair <string, JToken> pair in entry.Entries)
{
if (!this.TryParseStringTokens(pair.Key, tokenContext, migrator, out string keyError, out ITokenString key))
{
return(TrackSkip($"{nameof(PatchConfig.Entries)} > '{key}' key is invalid: {keyError}"));
}
if (!this.TryParseJsonTokens(pair.Value, tokenContext, migrator, out string error, out TokenisableJToken value))
{
return(TrackSkip($"{nameof(PatchConfig.Entries)} > '{key}' value is invalid: {error}"));
}
entries.Add(new EditDataPatchRecord(key, value));
}
}
// parse fields
List <EditDataPatchField> fields = new List <EditDataPatchField>();
if (entry.Fields != null)
{
foreach (KeyValuePair <string, IDictionary <string, JToken> > recordPair in entry.Fields)
{
// parse entry key
if (!this.TryParseStringTokens(recordPair.Key, tokenContext, migrator, out string keyError, out ITokenString key))
{
return(TrackSkip($"{nameof(PatchConfig.Fields)} > entry {recordPair.Key} is invalid: {keyError}"));
}
// parse fields
foreach (var fieldPair in recordPair.Value)
{
// parse field key
if (!this.TryParseStringTokens(fieldPair.Key, tokenContext, migrator, out string fieldError, out ITokenString fieldKey))
{
return(TrackSkip($"{nameof(PatchConfig.Fields)} > entry {recordPair.Key} > field {fieldPair.Key} key is invalid: {fieldError}"));
}
// parse value
if (!this.TryParseJsonTokens(fieldPair.Value, tokenContext, migrator, out string valueError, out TokenisableJToken value))
{
return(TrackSkip($"{nameof(PatchConfig.Fields)} > entry {recordPair.Key} > field {fieldKey} is invalid: {valueError}"));
}
if (value?.Value is JValue jValue && jValue.Value <string>()?.Contains("/") == true)
{
return(TrackSkip($"{nameof(PatchConfig.Fields)} > entry {recordPair.Key} > field {fieldKey} is invalid: value can't contain field delimiter character '/'"));
}
fields.Add(new EditDataPatchField(key, fieldKey, value));
}
}
}
// parse move entries
List <EditDataPatchMoveRecord> moveEntries = new List <EditDataPatchMoveRecord>();
if (entry.MoveEntries != null)
{
foreach (PatchMoveEntryConfig moveEntry in entry.MoveEntries)
{
// validate
string[] targets = new[] { moveEntry.BeforeID, moveEntry.AfterID, moveEntry.ToPosition };
if (string.IsNullOrWhiteSpace(moveEntry.ID))
{
return(TrackSkip($"{nameof(PatchConfig.MoveEntries)} > move entry is invalid: must specify an {nameof(PatchMoveEntryConfig.ID)} value"));
}
if (targets.All(string.IsNullOrWhiteSpace))
{
return(TrackSkip($"{nameof(PatchConfig.MoveEntries)} > entry '{moveEntry.ID}' is invalid: must specify one of {nameof(PatchMoveEntryConfig.ToPosition)}, {nameof(PatchMoveEntryConfig.BeforeID)}, or {nameof(PatchMoveEntryConfig.AfterID)}"));
}
if (targets.Count(p => !string.IsNullOrWhiteSpace(p)) > 1)
{
return(TrackSkip($"{nameof(PatchConfig.MoveEntries)} > entry '{moveEntry.ID}' is invalid: must specify only one of {nameof(PatchMoveEntryConfig.ToPosition)}, {nameof(PatchMoveEntryConfig.BeforeID)}, and {nameof(PatchMoveEntryConfig.AfterID)}"));
}
// parse IDs
if (!this.TryParseStringTokens(moveEntry.ID, tokenContext, migrator, out string idError, out ITokenString moveId))
{
return(TrackSkip($"{nameof(PatchConfig.MoveEntries)} > entry '{moveEntry.ID}' > {nameof(PatchMoveEntryConfig.ID)} is invalid: {idError}"));
}
if (!this.TryParseStringTokens(moveEntry.BeforeID, tokenContext, migrator, out string beforeIdError, out ITokenString beforeId))
{
return(TrackSkip($"{nameof(PatchConfig.MoveEntries)} > entry '{moveEntry.ID}' > {nameof(PatchMoveEntryConfig.BeforeID)} is invalid: {beforeIdError}"));
}
if (!this.TryParseStringTokens(moveEntry.AfterID, tokenContext, migrator, out string afterIdError, out ITokenString afterId))
{
return(TrackSkip($"{nameof(PatchConfig.MoveEntries)} > entry '{moveEntry.ID}' > {nameof(PatchMoveEntryConfig.AfterID)} is invalid: {afterIdError}"));
}
// parse position
MoveEntryPosition toPosition = MoveEntryPosition.None;
if (!string.IsNullOrWhiteSpace(moveEntry.ToPosition) && (!Enum.TryParse(moveEntry.ToPosition, true, out toPosition) || toPosition == MoveEntryPosition.None))
{
return(TrackSkip($"{nameof(PatchConfig.MoveEntries)} > entry '{moveEntry.ID}' > {nameof(PatchMoveEntryConfig.ToPosition)} is invalid: must be one of {nameof(MoveEntryPosition.Bottom)} or {nameof(MoveEntryPosition.Top)}"));
}
// create move entry
moveEntries.Add(new EditDataPatchMoveRecord(moveId, beforeId, afterId, toPosition));
}
}
// save
patch = new EditDataPatch(entry.LogName, pack, assetName, conditions, entries, fields, moveEntries, this.Monitor, this.Helper.Content.NormaliseAssetName);
}
break;
// edit image
case PatchType.EditImage:
{
// read patch mode
PatchMode patchMode = PatchMode.Replace;
if (!string.IsNullOrWhiteSpace(entry.PatchMode) && !Enum.TryParse(entry.PatchMode, true, out patchMode))
{
return(TrackSkip($"the {nameof(PatchConfig.PatchMode)} is invalid. Expected one of these values: [{string.Join(", ", Enum.GetNames(typeof(PatchMode)))}]"));
}
// save
if (!this.TryPrepareLocalAsset(pack, entry.FromFile, tokenContext, migrator, out string error, out ITokenString fromAsset))
{
return(TrackSkip(error));
}
patch = new EditImagePatch(entry.LogName, pack, assetName, conditions, fromAsset, entry.FromArea, entry.ToArea, patchMode, this.Monitor, this.Helper.Content.NormaliseAssetName);
}
break;
// edit map
case PatchType.EditMap:
{
// read map asset
if (!this.TryPrepareLocalAsset(pack, entry.FromFile, tokenContext, migrator, out string error, out ITokenString fromAsset))
{
return(TrackSkip(error));
}
// validate
if (entry.ToArea == Rectangle.Empty)
{
return(TrackSkip($"must specify {nameof(entry.ToArea)} (use \"Action\": \"Load\" if you want to replace the whole map file)"));
}
// save
patch = new EditMapPatch(entry.LogName, pack, assetName, conditions, fromAsset, entry.FromArea, entry.ToArea, this.Monitor, this.Helper.Content.NormaliseAssetName);
}
break;
default:
return(TrackSkip($"unsupported patch type '{action}'"));
}
// skip if not enabled
// note: we process the patch even if it's disabled, so any errors are caught by the modder instead of only failing after the patch is enabled.
if (!enabled)
{
return(TrackSkip($"{nameof(PatchConfig.Enabled)} is false", warn: false));
}
// save patch
this.PatchManager.Add(patch);
return(true);
}
catch (Exception ex)
{
return(TrackSkip($"error reading info. Technical details:\n{ex}"));
}
}
/*********
** Private methods
*********/
/// <summary>Load the loaders and patchers from all registered content packs.</summary>
private void LoadContentPacks()
{
foreach (IContentPack pack in this.Helper.GetContentPacks())
{
// read config
ContentConfig config = pack.ReadJsonFile <ContentConfig>(this.PatchFileName);
if (config == null)
{
this.Monitor.Log($"Ignored content pack '{pack.Manifest.Name}' because it has no {this.PatchFileName} file.", LogLevel.Warn);
continue;
}
if (config.Format == null || config.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.Warn);
continue;
}
if (config.Format.ToString() != "1.0")
{
this.Monitor.Log($"Ignored content pack '{pack.Manifest.Name}' because it uses unsupported format {config.Format} (supported version: 1.0).", LogLevel.Warn);
continue;
}
// load patches
int i = 0;
foreach (PatchConfig entry in config.Changes)
{
i++;
void LogSkip(string reasonPhrase) => this.Monitor.Log($"Ignored {pack.Manifest.Name} > entry #{i}: {reasonPhrase}", LogLevel.Warn);
try
{
// skip if disabled
if (!entry.Enabled)
{
continue;
}
// read action
string action = entry.Action?.Trim().ToLower();
if (string.IsNullOrWhiteSpace(action))
{
LogSkip($"must set the {nameof(PatchConfig.Action)} field.");
continue;
}
// read target asset
string assetName = !string.IsNullOrWhiteSpace(entry.Target)
? this.Helper.Content.NormaliseAssetName(entry.Target)
: null;
if (assetName == null)
{
LogSkip($"must set the {nameof(PatchConfig.Target)} field.");
continue;
}
// read source asset
string localAsset = !string.IsNullOrWhiteSpace(entry.FromFile)
? this.Helper.Content.NormaliseAssetName(entry.FromFile)
: null;
if (localAsset == null && (action == "load" || action == "editimage"))
{
LogSkip($"must set the {nameof(PatchConfig.FromFile)} field for a '{action}' patch.");
continue;
}
if (localAsset != null && !this.AssetLoader.AssetExists(pack, localAsset))
{
LogSkip($"the {nameof(PatchConfig.FromFile)} field specifies a file that doesn't exist: {localAsset}.");
continue;
}
// read locale
string locale = !string.IsNullOrWhiteSpace(entry.Locale)
? entry.Locale.Trim().ToLower()
: null;
// parse for type
switch (action)
{
// load asset
case "load":
{
// check for conflicting loaders
if (this.Loaders.TryGetValue(assetName, out IList <LoadPatch> loaders))
{
// can't add for all locales if any loaders already registered
if (locale == null)
{
string[] localesLoadedBy = loaders.Select(p => $"{p.ContentPack.Manifest.Name}").ToArray();
LogSkip($"the {assetName} file is already being loaded by '{string.Join("', '", localesLoadedBy)}'. Each file can only be loaded once.");
continue;
}
// can't add if already loaded for all locales
{
LoadPatch globalPatch = loaders.FirstOrDefault(p => p.Locale == null);
if (globalPatch != null)
{
LogSkip($"the {assetName} file is already being loaded by {(pack == globalPatch.ContentPack ? "this content pack" : $"the '{globalPatch.ContentPack.Manifest.Name}' content pack")}. Each file can only be loaded once.");
continue;
}
}
// can't add if already loaded for selected locale
{
LoadPatch localePatch = loaders.FirstOrDefault(p => p.Locale != null && p.Locale.Equals(locale, StringComparison.CurrentCultureIgnoreCase));
if (localePatch != null)
{
LogSkip($"the {assetName} file is already being loaded for the {locale} locale by {(pack == localePatch.ContentPack ? "this content pack" : $"the '{localePatch.ContentPack.Manifest.Name}' content pack")}. Each file can only be loaded once per locale.");
