/// <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(IContentPack contentPack, InvariantDictionary <ConfigField> config, IModHelper modHelper)
{
// save if settings valid
if (config.Any())
{
InvariantDictionary <string> data = new(config.ToDictionary(p => p.Key, p => string.Join(", ", p.Value.Value)));
contentPack.WriteJsonFile(this.Filename, data);
}
// delete if no settings
else
{
FileInfo file = new(Path.Combine(contentPack.GetFullPath(this.Filename)));
if (file.Exists)
{
file.Delete();
}
}
}
/// <summary>Get the current values.</summary>
/// <param name="input">The input argument, if applicable.</param>
public IEnumerable <string> GetValues(string input)
{
RecolorTokenArguments inputData = RecolorTokenArguments.Parse(input);
IContentPack contentPack = Utility.GetContentPackFromModInfo(helper_.ModRegistry.Get(inputData.ContentPackName));
// ATTENTION: In order to load files we just generated we need at least ContentPatcher 1.18.3 .
string generatedFilePath = GenerateFilePath(inputData);
string generatedFilePathAbsolute = Path.Combine(contentPack.DirectoryPath, generatedFilePath);
if (!(inputData.Equals(previousInputData_)))
{
mustUpdateContext_ = true;
previousInputData_ = inputData;
monitor_.Log($"Content pack {contentPack.Manifest.UniqueID} requests recoloring of {inputData.AssetName}.");
monitor_.Log($"Recolor with {inputData.MaskPath} and {Utility.ColorToHtml(inputData.BlendColor)}, flip mode {inputData.FlipMode}, brightness {inputData.Brightness}");
// Check versions: If version of SDV or content pack changed we have to delete generated images.
string contentPackVersion = contentPack.Manifest.Version.ToString();
string generatedDirectoryPathAbsolute = Path.Combine(contentPack.DirectoryPath, "generated");
var versions = contentPack.ReadJsonFile <Dictionary <string, string> >("generated/versions.json") ?? new Dictionary <string, string>();
if (!versions.TryGetValue("StardewValley", out string stardewVersion) || stardewVersion != Game1.version)
{
versions["StardewValley"] = Game1.version;
monitor_.Log($"Version of StardewValley changed from {stardewVersion ?? "(null)"} to {Game1.version}, deleting generated files.");
if (Directory.Exists(generatedDirectoryPathAbsolute))
{
Directory.Delete(generatedDirectoryPathAbsolute, true);
}
contentPack.WriteJsonFile("generated/versions.json", versions);
}
if (!versions.TryGetValue(contentPack.Manifest.UniqueID, out string modVersion) || modVersion != contentPackVersion)
{
versions[contentPack.Manifest.UniqueID] = contentPackVersion;
monitor_.Log($"Version of content pack {contentPack.Manifest.UniqueID} changed from {modVersion ?? "(null)"} to {contentPackVersion}, deleting generated files.");
if (Directory.Exists(generatedDirectoryPathAbsolute))
{
Directory.Delete(generatedDirectoryPathAbsolute, true);
}
contentPack.WriteJsonFile("generated/versions.json", versions);
}
// Skip actions if file was found.
if (File.Exists(generatedFilePathAbsolute))
{
monitor_.Log($"Found existing file {generatedFilePathAbsolute}, returning relative path {generatedFilePath}");
helper_.Content.InvalidateCache(inputData.AssetName);
}
else
{
try {
// "gamecontent" means loading from game folder. Don't dispose an asset source!
Texture2D source;
if (inputData.SourcePath.ToLowerInvariant() == "gamecontent")
{
// ATTENTION: Game content requires special attention because the loaded assets modify themselves over time:
// Game content contains vanilla assets only when game is loaded, otherwise the assets are already patched.
// Luma desaturation and recoloring don't change brightness so they can be applied multiple times
// without bad effects but changing brightness multiple times changes colors over time.
// A way to prevent that is caching them in files once and using the cached versions as a base for modifications.
string generatedBasePath = Path.Combine("generated", $"{inputData.AssetName}_gamecontent.png");
string generatedBasePathAbsolute = Path.Combine(contentPack.DirectoryPath, generatedBasePath);
Directory.CreateDirectory(Path.GetDirectoryName(generatedBasePathAbsolute));
if (File.Exists(generatedBasePathAbsolute))
{
using (FileStream fs = new FileStream(generatedBasePathAbsolute, FileMode.Open)) {
source = Texture2D.FromStream(Game1.graphics.GraphicsDevice, fs);
}
monitor_.Log($"Loading asset {inputData.AssetName} from existing cache file {generatedBasePathAbsolute}");
}
else
{
source = helper_.Content.Load <Texture2D>(inputData.AssetName, ContentSource.GameContent);
using (FileStream fs = new FileStream(generatedBasePathAbsolute, FileMode.Create)) {
source.SaveAsPng(fs, source.Width, source.Height);
fs.Close();
}
monitor_.Log($"Saving asset {inputData.AssetName} in cache file {generatedBasePathAbsolute}");
}
}
else
{
source = contentPack.LoadAsset <Texture2D>(inputData.SourcePath);
}
Texture2D mask = inputData.MaskPath.ToLowerInvariant() != "none"
? contentPack.LoadAsset <Texture2D>(inputData.MaskPath)
: null;
using (Texture2D extracted = ExtractSubImage(source, mask, inputData.DesaturationMode, inputData.Brightness))
using (Texture2D blended = ColorBlend(extracted, inputData.BlendColor))
using (Texture2D flipped = FlipImage(source, blended, inputData.FlipMode)) {
Directory.CreateDirectory(Path.GetDirectoryName(generatedFilePathAbsolute));
using (FileStream fs = new FileStream(generatedFilePathAbsolute, FileMode.Create)) {
flipped.SaveAsPng(fs, flipped.Width, flipped.Height);
fs.Close();
}
}
monitor_.Log($"Generated file {generatedFilePathAbsolute}, returning relative path {generatedFilePath}");
helper_.Content.InvalidateCache(inputData.AssetName);
}
catch (ContentLoadException) {
// Asset is not available, return its name to prevent game from crashing.
monitor_.Log($"Ignoring unavailable asset {inputData.AssetName}. If this was caused by patch reload you can ignore it, the next 10min update cycle should do a proper reload.", LogLevel.Info);
generatedFilePath = inputData.AssetName;
}
}
}
yield return(generatedFilePath);
}
/// <summary>Checks whether a config file should be used with the currently loaded farm.</summary>
/// <param name="config">The FarmConfig to be checked.</param>
/// <returns>True if the file should be used with the current farm; false otherwise.</returns>
public static bool CheckFileConditions(FarmConfig config, IContentPack pack, IModHelper helper)
{
Monitor.Log("Checking file conditions...", LogLevel.Trace);
//check "reset main data folder" flag
//NOTE: it's preferable to do this as the first step; it's intended to be a one-off cleaning process, rather than a conditional effect
if (config.File_Conditions.ResetMainDataFolder && MConfig.EnableContentPackFileChanges) //if "reset" is true and file changes are enabled
{
if (pack != null) //if this is part of a content pack
{
//attempt to load the content pack's global save data
ContentPackSaveData packSave = null;
try
{
packSave = pack.ReadJsonFile <ContentPackSaveData>(Path.Combine("data", "ContentPackSaveData.save")); //load the content pack's global save data (null if it doesn't exist)
}
catch (Exception ex)
{
Monitor.Log($"Warning: This content pack's save data could not be parsed correctly: {pack.Manifest.Name}", LogLevel.Warn);
Monitor.Log($"Affected file: data/ContentPackSaveData.save", LogLevel.Warn);
Monitor.Log($"Please delete the file and/or contact the mod's developer.", LogLevel.Warn);
Monitor.Log($"The content pack will be skipped until this issue is fixed. The auto-generated error message is displayed below:", LogLevel.Warn);
Monitor.Log($"----------", LogLevel.Warn);
Monitor.Log($"{ex.Message}", LogLevel.Warn);
return(false); //disable this content pack's config, since it may require this process to function
}
if (packSave == null) //no global save data exists for this content pack
{
packSave = new ContentPackSaveData();
}
if (!packSave.MainDataFolderReset) //if this content pack has NOT reset the main data folder yet
{
Monitor.Log($"ResetMainDataFolder requested by content pack: {pack.Manifest.Name}", LogLevel.Debug);
string dataPath = Path.Combine(helper.DirectoryPath, "data"); //the path to this mod's data folder
DirectoryInfo dataFolder = new DirectoryInfo(dataPath); //an object representing this mod's data directory
if (dataFolder.Exists) //the data folder exists
{
Monitor.Log("Attempting to archive data folder...", LogLevel.Trace);
try
{
string archivePath = Path.Combine(helper.DirectoryPath, "data", "archive", DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"));
DirectoryInfo archiveFolder = Directory.CreateDirectory(archivePath); //create a timestamped archive folder
foreach (FileInfo file in dataFolder.GetFiles()) //for each file in dataFolder
{
file.MoveTo(Path.Combine(archiveFolder.FullName, file.Name)); //move each file to archiveFolder
}
}
catch (Exception ex)
{
Monitor.Log($"Warning: This content pack attempted to archive Farm Type Manager's data folder but failed: {pack.Manifest.Name}", LogLevel.Warn);
Monitor.Log($"Please report this issue to Farm Type Manager's developer. This might also be fixed by manually removing your FarmTypeManager/data/ files.", LogLevel.Warn);
Monitor.Log($"The content pack will be skipped until this issue is fixed. The auto-generated error message is displayed below:", LogLevel.Warn);
Monitor.Log($"----------", LogLevel.Warn);
Monitor.Log($"{ex.Message}", LogLevel.Warn);
return(false); //disable this content pack's config, since it may require this process to function
}
}
else //the data folder doesn't exist
{
Monitor.Log("Data folder not found; assuming it was deleted or not yet generated.", LogLevel.Trace);
}
packSave.MainDataFolderReset = true; //update save data
}
pack.WriteJsonFile(Path.Combine("data", "ContentPackSaveData.save"), packSave); //update the content pack's global save data file
Monitor.Log("Data folder archive successful.", LogLevel.Trace);
}
else //if this is NOT part of a content pack
{
Monitor.Log("This farm's config file has ResetMainDataFolder = true, but this setting only works for content packs.", LogLevel.Info);
}
}
//check farm type
if (config.File_Conditions.FarmTypes != null && config.File_Conditions.FarmTypes.Length > 0)
{
Monitor.Log("Farm type condition(s) found. Checking...", LogLevel.Trace);
bool validType = false;
foreach (string type in config.File_Conditions.FarmTypes) //for each listed farm type
{
if (type.Equals("All", StringComparison.OrdinalIgnoreCase) || type.Equals("Any", StringComparison.OrdinalIgnoreCase)) //if "all" or "any" is listed
{
validType = true;
break; //skip the rest of these checks
}
switch (Game1.whichFarm) //compare to the current farm type
{
case (int)Utility.FarmTypes.Standard:
if (type.Equals("Standard", StringComparison.OrdinalIgnoreCase) || type.Equals("Default", StringComparison.OrdinalIgnoreCase) || type.Equals("Normal", StringComparison.OrdinalIgnoreCase))
{
validType = true;
}
break;
case (int)Utility.FarmTypes.Riverland:
if (type.Equals("Riverland", StringComparison.OrdinalIgnoreCase) || type.Equals("Fishing", StringComparison.OrdinalIgnoreCase) || type.Equals("Fish", StringComparison.OrdinalIgnoreCase))
{
validType = true;
}
break;
case (int)Utility.FarmTypes.Forest:
if (type.Equals("Forest", StringComparison.OrdinalIgnoreCase) || type.Equals("Foraging", StringComparison.OrdinalIgnoreCase) || type.Equals("Forage", StringComparison.OrdinalIgnoreCase) || type.Equals("Woodland", StringComparison.OrdinalIgnoreCase))
{
validType = true;
}
break;
case (int)Utility.FarmTypes.Hilltop:
if (type.Equals("Hill-top", StringComparison.OrdinalIgnoreCase) || type.Equals("Hilltop", StringComparison.OrdinalIgnoreCase) || type.Equals("Mining", StringComparison.OrdinalIgnoreCase) || type.Equals("Mine", StringComparison.OrdinalIgnoreCase))
{
validType = true;
}
break;
case (int)Utility.FarmTypes.Wilderness:
if (type.Equals("Wilderness", StringComparison.OrdinalIgnoreCase) || type.Equals("Combat", StringComparison.OrdinalIgnoreCase) || type.Equals("Monster", StringComparison.OrdinalIgnoreCase))
{
validType = true;
}
break;
}
if (validType) //if a valid weather condition was listed
{
break; //skip the rest of these checks
}
}
if (validType) //if a valid farm type was listed
{
Monitor.Log("Farm type matched a setting. File allowed.", LogLevel.Trace);
}
else
{
Monitor.Log("Farm type did NOT match any settings. File disabled.", LogLevel.Trace);
return(false); //prevent config use
}
}
//check farmer name
if (config.File_Conditions.FarmerNames != null && config.File_Conditions.FarmerNames.Length > 0)
{
Monitor.Log("Farmer name condition(s) found. Checking...", LogLevel.Trace);
bool validName = false;
foreach (string name in config.File_Conditions.FarmerNames) //for each listed name
{
if (name.Equals(Game1.player.Name, StringComparison.OrdinalIgnoreCase)) //if the name matches the current player's
{
validName = true;
break; //skip the rest of these checks
}
}
if (validName) //if a valid farmer name was listed
{
Monitor.Log("Farmer name matched a setting. File allowed.", LogLevel.Trace);
}
else
{
Monitor.Log("Farmer name did NOT match any settings. File disabled.", LogLevel.Trace);
return(false); //prevent config use
}
}
//check save file names (technically the save folder name)
if (config.File_Conditions.SaveFileNames != null && config.File_Conditions.SaveFileNames.Length > 0)
{
Monitor.Log("Save file name condition(s) found. Checking...", LogLevel.Trace);
bool validSave = false;
foreach (string saveName in config.File_Conditions.SaveFileNames) //for each listed save name
{
if (saveName.Equals(Constants.SaveFolderName, StringComparison.OrdinalIgnoreCase)) //if the name matches the current player's save folder name
{
validSave = true;
break; //skip the rest of these checks
}
}
if (validSave) //if a valid save name was listed
{
Monitor.Log("Save file name matched a setting. File allowed.", LogLevel.Trace);
}
else
{
Monitor.Log("Save file name did NOT match any settings. File disabled.", LogLevel.Trace);
return(false); //prevent config use
}
}
//check whether other mods exist
if (config.File_Conditions.OtherMods != null && config.File_Conditions.OtherMods.Count > 0)
{
Monitor.Log("Other mod condition(s) found. Checking...", LogLevel.Trace);
bool validMods = true; //whether all entries are accurate (true by default, unlike most other settings)
foreach (KeyValuePair <string, bool> entry in config.File_Conditions.OtherMods) //for each mod entry in OtherMods
{
bool validEntry = !(entry.Value); //whether the current entry is accurate (starts false if the mod should exist; starts true if the mod should NOT exist)
foreach (IModInfo mod in helper.ModRegistry.GetAll()) //for each mod currently loaded by SMAPI
{
if (entry.Value == true) //if the mod should exist
{
if (entry.Key.Equals(mod.Manifest.UniqueID, StringComparison.OrdinalIgnoreCase)) //if this mod's UniqueID matches the OtherMods entry
{
validEntry = true; //this entry is valid
break; //skip the rest of these checks
}
}
else //if the mod should NOT exist
{
if (entry.Key.Equals(mod.Manifest.UniqueID, StringComparison.OrdinalIgnoreCase)) //if this mod's UniqueID matches the OtherMods entry
{
validEntry = false; //this entry is invalid
break; //skip the rest of these checks
}
}
}
if (validEntry) //if the current mod entry is valid
{
Monitor.Log($"Mod check successful: \"{entry.Key}\" {(entry.Value ? "does exist" : "does not exist")}.", LogLevel.Trace);
}
else //if the current mod entry is NOT valid
{
Monitor.Log($"Mod check failed: \"{entry.Key}\" {(entry.Value ? "does not exist" : "does exist")}.", LogLevel.Trace);
validMods = false;
break; //skip the rest of these checks
}
}
if (validMods) //if all mod entries in the list are valid
{
Monitor.Log("The OtherMods list matches the player's mods. File allowed.", LogLevel.Trace);
}
else //if any entries were NOT valid
{
Monitor.Log("The OtherMods list does NOT match the player's mods. File disabled.", LogLevel.Trace);
return(false); //prevent config use
}
}
return(true); //all checks were successful; config should be used
}
/// <summary>Checks whether a config file should be used with the currently loaded farm.</summary>
/// <param name="config">The FarmConfig to be checked.</param>
/// <param name="pack">The content pack associated with this file, if any.</param>
/// <returns>True if the file should be used with the current farm; false otherwise.</returns>
public static bool CheckFileConditions(FarmConfig config, IContentPack pack)
{
Monitor.Log("Checking file conditions...", LogLevel.Trace);
//check "reset main data folder" flag
//NOTE: it's preferable to do this as the first step; it's intended to be a one-off cleaning process, rather than a conditional effect
if (config.File_Conditions.ResetMainDataFolder && MConfig.EnableContentPackFileChanges) //if "reset" is true and file changes are enabled
{
if (pack != null) //if this is part of a content pack
{
//attempt to load the content pack's global save data
ContentPackSaveData packSave = null;
try
{
packSave = pack.ReadJsonFile <ContentPackSaveData>(Path.Combine("data", "ContentPackSaveData.save")); //load the content pack's global save data (null if it doesn't exist)
}
catch (Exception ex)
{
Monitor.Log($"Warning: This content pack's save data could not be parsed correctly: {pack.Manifest.Name}", LogLevel.Warn);
Monitor.Log($"Affected file: data/ContentPackSaveData.save", LogLevel.Warn);
Monitor.Log($"Please delete the file and/or contact the mod's developer.", LogLevel.Warn);
Monitor.Log($"The content pack will be skipped until this issue is fixed. The auto-generated error message is displayed below:", LogLevel.Warn);
Monitor.Log($"----------", LogLevel.Warn);
Monitor.Log($"{ex.Message}", LogLevel.Warn);
return(false); //disable this content pack's config, since it may require this process to function
}
if (packSave == null) //no global save data exists for this content pack
{
packSave = new ContentPackSaveData();
}
if (!packSave.MainDataFolderReset) //if this content pack has NOT reset the main data folder yet
{
Monitor.Log($"ResetMainDataFolder requested by content pack: {pack.Manifest.Name}", LogLevel.Debug);
string dataPath = Path.Combine(Helper.DirectoryPath, "data"); //the path to this mod's data folder
DirectoryInfo dataFolder = new DirectoryInfo(dataPath); //an object representing this mod's data directory
if (dataFolder.Exists) //the data folder exists
{
Monitor.Log("Attempting to archive data folder...", LogLevel.Trace);
try
{
string archivePath = Path.Combine(Helper.DirectoryPath, "data", "archive", DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss"));
DirectoryInfo archiveFolder = Directory.CreateDirectory(archivePath); //create a timestamped archive folder
foreach (FileInfo file in dataFolder.GetFiles()) //for each file in dataFolder
{
file.MoveTo(Path.Combine(archiveFolder.FullName, file.Name)); //move each file to archiveFolder
}
}
catch (Exception ex)
{
Monitor.Log($"Warning: This content pack attempted to archive Farm Type Manager's data folder but failed: {pack.Manifest.Name}", LogLevel.Warn);
Monitor.Log($"Please report this issue to Farm Type Manager's developer. This might also be fixed by manually removing your FarmTypeManager/data/ files.", LogLevel.Warn);
Monitor.Log($"The content pack will be skipped until this issue is fixed. The auto-generated error message is displayed below:", LogLevel.Warn);
Monitor.Log($"----------", LogLevel.Warn);
Monitor.Log($"{ex.Message}", LogLevel.Warn);
return(false); //disable this content pack's config, since it may require this process to function
}
}
else //the data folder doesn't exist
{
Monitor.Log("Data folder not found; assuming it was deleted or not yet generated.", LogLevel.Trace);
}
packSave.MainDataFolderReset = true; //update save data
}
pack.WriteJsonFile(Path.Combine("data", "ContentPackSaveData.save"), packSave); //update the content pack's global save data file
Monitor.Log("Data folder archive successful.", LogLevel.Trace);
}
else //if this is NOT part of a content pack
{
Monitor.Log("This farm's config file has ResetMainDataFolder = true, but this setting only works for content packs.", LogLevel.Info);
}
}
//check farm type
if (config.File_Conditions.FarmTypes != null && config.File_Conditions.FarmTypes.Length > 0)
{
Monitor.Log("Farm type condition(s) found. Checking...", LogLevel.Trace);
bool validType = false;
foreach (object obj in config.File_Conditions.FarmTypes) //for each listed farm type
{
int type = -1;
//parse the farm type object into an integer (int type)
if (obj is long || obj is int) //if the object is a readable integer
{
type = Convert.ToInt32(obj); //convert it to a 32-bit integer and use it
}
else if (obj is string name) //if the object is a string, cast it as one
{
if (name.Equals("All", StringComparison.OrdinalIgnoreCase) || name.Equals("Any", StringComparison.OrdinalIgnoreCase)) //if this is "all" or "any"
{
validType = true;
break; //skip checking the rest of the farm types
}
else if (Enum.TryParse(name, true, out FarmTypes farmType)) //if this name can be parsed into a FarmTypes enum
{
type = (int)farmType; //use it as an integer
}
else //if this is a string, but not a recognized value
{
if (int.TryParse(name, out int parsed)) //if this string can be parsed as an integer
{
type = parsed; //use the parsed value
}
else //if this string cannot be parsed
{
Monitor.Log($"This setting in the Farm Types list could not be parsed: {name}", LogLevel.Debug);
Monitor.Log($"The setting will be ignored. If it's intended to be a custom farm type, please use its ID number instead of its name.", LogLevel.Debug);
continue; //skip to the next farm type condition
}
}
}
if (type == Game1.whichFarm) //if the parsed type matches the current farm type
{
validType = true;
break; //skip checking the rest of the farm types
}
else if (Game1.whichFarm == 200) //if this may be a MTN farm type, handle compatibility (based on MTN 2.1.0-beta8)
{
//if MTN is installed, use reflection to access its "whichFarm" equivalent
try
{
IModInfo modInfo = Helper.ModRegistry.Get("SgtPickles.MTN"); // get MTN info (null if it's not installed)
if (modInfo == null) //if MTN isn't installed
{
continue; //skip to the next farm type check
}
object mod = modInfo.GetType().GetProperty("Mod", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)?.GetValue(modInfo); //get MTN's Mod instance
if (mod == null) //if it couldn't be accessed
{
continue; //skip to the next farm type check
}
object customManager = mod.GetType().GetProperty("CustomManager", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)?.GetValue(mod); //get CustomManager instance
if (customManager == null) //if it couldn't be accessed
{
continue; //skip to the next farm type check
}
object loadedFarm = customManager.GetType().GetProperty("LoadedFarm", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)?.GetValue(customManager); //get LoadedFarm instance
if (loadedFarm == null) //if it couldn't be accessed
{
continue; //skip to the next farm type check
}
int farmID = (int)loadedFarm.GetType().GetProperty("ID", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public)?.GetValue(loadedFarm); //get the loaded farm's ID
if (type == farmID) //if MTN's custom farm ID matches the parsed type
{
Monitor.VerboseLog($"Farm type matches the loaded MTN farm type's ID: {type}");
validType = true;
break; //skip checking the rest of the farm types
}
}
catch (Exception) //if any exception is thrown while accessing MTN
{
Monitor.Log($"Error encountered while trying to check MTN farm type. This check may be obsolete or require updates.", LogLevel.Trace);
continue; //skip to the next farm type check
}
}
}
if (validType) //if a valid farm type was listed
{
Monitor.Log("Farm type matched a setting. File allowed.", LogLevel.Trace);
}
else
{
Monitor.Log("Farm type did NOT match any settings. File disabled.", LogLevel.Trace);
return(false); //prevent config use
}
}
//check farmer name
if (config.File_Conditions.FarmerNames != null && config.File_Conditions.FarmerNames.Length > 0)
{
Monitor.Log("Farmer name condition(s) found. Checking...", LogLevel.Trace);
bool validName = false;
foreach (string name in config.File_Conditions.FarmerNames) //for each listed name
{
if (name.Equals(Game1.player.Name, StringComparison.OrdinalIgnoreCase)) //if the name matches the current player's
{
validName = true;
break; //skip the rest of these checks
}
}
if (validName) //if a valid farmer name was listed
{
Monitor.Log("Farmer name matched a setting. File allowed.", LogLevel.Trace);
}
else
{
Monitor.Log("Farmer name did NOT match any settings. File disabled.", LogLevel.Trace);
return(false); //prevent config use
}
}
//check save file names (technically the save folder name)
if (config.File_Conditions.SaveFileNames != null && config.File_Conditions.SaveFileNames.Length > 0)
{
Monitor.Log("Save file name condition(s) found. Checking...", LogLevel.Trace);
bool validSave = false;
foreach (string saveName in config.File_Conditions.SaveFileNames) //for each listed save name
{
if (saveName.Equals(Constants.SaveFolderName, StringComparison.OrdinalIgnoreCase)) //if the name matches the current player's save folder name
{
validSave = true;
break; //skip the rest of these checks
}
}
if (validSave) //if a valid save name was listed
{
Monitor.Log("Save file name matched a setting. File allowed.", LogLevel.Trace);
}
else
{
Monitor.Log("Save file name did NOT match any settings. File disabled.", LogLevel.Trace);
return(false); //prevent config use
}
}
//check whether other mods exist
if (config.File_Conditions.OtherMods != null && config.File_Conditions.OtherMods.Count > 0)
{
Monitor.Log("Other mod condition(s) found. Checking...", LogLevel.Trace);
bool validMods = true; //whether all entries are accurate (true by default, unlike most other settings)
foreach (KeyValuePair <string, bool> entry in config.File_Conditions.OtherMods) //for each mod entry in OtherMods
{
bool validEntry = !(entry.Value); //whether the current entry is accurate (starts false if the mod should exist; starts true if the mod should NOT exist)
foreach (IModInfo mod in Helper.ModRegistry.GetAll()) //for each mod currently loaded by SMAPI
{
if (entry.Value == true) //if the mod should exist
{
if (entry.Key.Equals(mod.Manifest.UniqueID, StringComparison.OrdinalIgnoreCase)) //if this mod's UniqueID matches the OtherMods entry
{
validEntry = true; //this entry is valid
break; //skip the rest of these checks
}
}
else //if the mod should NOT exist
{
if (entry.Key.Equals(mod.Manifest.UniqueID, StringComparison.OrdinalIgnoreCase)) //if this mod's UniqueID matches the OtherMods entry
{
validEntry = false; //this entry is invalid
break; //skip the rest of these checks
}
}
}
if (validEntry) //if the current mod entry is valid
{
Monitor.Log($"Mod check successful: \"{entry.Key}\" {(entry.Value ? "does exist" : "does not exist")}.", LogLevel.Trace);
}
else //if the current mod entry is NOT valid
{
Monitor.Log($"Mod check failed: \"{entry.Key}\" {(entry.Value ? "does not exist" : "does exist")}.", LogLevel.Trace);
validMods = false;
break; //skip the rest of these checks
}
}
if (validMods) //if all mod entries in the list are valid
{
Monitor.Log("The OtherMods list matches the player's mods. File allowed.", LogLevel.Trace);
}
else //if any entries were NOT valid
{
Monitor.Log("The OtherMods list does NOT match the player's mods. File disabled.", LogLevel.Trace);
return(false); //prevent config use
}
}
return(true); //all checks were successful; config should be used
}