public static Dictionary <string, string> SaveSettingsToCrate(Modder mod, string path, bool fullSettings)
{
Dictionary <string, string> Assets = new Dictionary <string, string>();
string tempPath = ModLoaderGlobals.BaseDirectory + @"\" + ModLoaderGlobals.TempName;
string assetsPath = tempPath + @"\" + ModLoaderGlobals.ModAssetsFolderName + @"\";
List <string> LineList = new List <string>();
LineList.Add(string.Format("{0} {1} {2}", CommentSymbol, ModLoaderGlobals.ProgramVersion, "Auto-Generated Settings File"));
foreach (ModPropertyBase prop in mod.Props)
{
if (fullSettings || (!fullSettings && prop.HasChanged))
{
string text = "";
if (prop is ModPropExternalResourceBase ext)
{
Assets.Add(assetsPath + ext.CodeName + ext.AssetExtension, ext.CodeName + ext.AssetExtension);
ext.ResourceToFile(assetsPath + ext.CodeName + ext.AssetExtension);
ext.ResourcePath = ModLoaderGlobals.ModAssetsFolderName + @"\" + ext.CodeName + ext.AssetExtension;
}
prop.Serialize(ref text);
LineList.Add(text);
}
}
File.WriteAllLines(path, LineList);
return(Assets);
}
public ModCrateMakerForm(Modder inmod, Game ingame, string outpath)
{
InitializeComponent();
mod = inmod;
Game = ingame;
path = outpath;
button_save.Text = ModLoaderText.ModCrateMaker_Button_Save;
button_browse.Text = ModLoaderText.ModCrateMaker_Button_Browse;
button_cancel.Text = ModLoaderText.ModCrateMaker_Button_Cancel;
label_name.Text = ModLoaderText.ModCrateMaker_Label_Name;
label_author.Text = ModLoaderText.ModCrateMaker_Label_Author;
label_description.Text = ModLoaderText.ModCrateMaker_Label_Description;
label_version.Text = ModLoaderText.ModCrateMaker_Label_Version;
label_icon.Text = ModLoaderText.ModCrateMaker_Label_Icon;
Text = ModLoaderText.ModCrateMakerTitle;
crate = new ModCrate();
textBox_author.Text = crate.Author;
textBox_description.Text = crate.Desc;
textBox_name.Text = crate.Name;
textBox_version.Text = crate.Version;
crate.HasIcon = false;
crate.TargetGame = Game.ShortName;
crate.HasSettings = true;
crate.IsFolder = false;
}
public void ResetGameSpecific(bool ClearGameText = false)
{
Modder = null;
Pipeline = null;
SupportedMods = new List <ModCrate>();
ResetGameEvent.Invoke(this, new EventValueArgs <bool>(ClearGameText));
}
/// <summary>
/// Saves the given Mod Crate using the given Modder to given path.
/// </summary>
public static void SaveSimpleCrateToFile(Modder mod, string path, ModCrate crate)
{
string tempPath = ModLoaderGlobals.BaseDirectory + @"\" + ModLoaderGlobals.TempName;
string assetsPath = tempPath + @"\" + ModLoaderGlobals.ModAssetsFolderName + @"\";
Directory.CreateDirectory(tempPath);
Directory.CreateDirectory(assetsPath);
List <string> LineList_Info = new List <string>();
LineList_Info.Add(string.Format("{0}{1}{2}", Prop_Name, Separator, crate.Name));
LineList_Info.Add(string.Format("{0}{1}{2}", Prop_Desc, Separator, crate.Desc));
LineList_Info.Add(string.Format("{0}{1}{2}", Prop_Author, Separator, crate.Author));
LineList_Info.Add(string.Format("{0}{1}{2}", Prop_Version, Separator, crate.Version));
LineList_Info.Add(string.Format("{0}{1}{2}", Prop_CML_Version, Separator, crate.CML_Version));
LineList_Info.Add(string.Format("{0}{1}{2}", Prop_Game, Separator, crate.TargetGame));
File.WriteAllLines(Path.Combine(tempPath, InfoFileName), LineList_Info);
Dictionary <string, string> Assets = SaveSettingsToCrate(mod, Path.Combine(tempPath, SettingsFileName), false);
if (crate.HasIcon)
{
File.Copy(crate.IconPath, Path.Combine(tempPath, IconFileName));
//crate.Icon.Save(Path.Combine(ModLoaderGlobals.BaseDirectory, IconFileName));
}
string zipFolderName = ModLoaderGlobals.ModAssetsFolderName + @"\";
using (FileStream fileStream = new FileStream(path, FileMode.Create))
{
using (ZipArchive zip = new ZipArchive(fileStream, ZipArchiveMode.Create))
{
zip.CreateEntryFromFile(Path.Combine(tempPath, InfoFileName), InfoFileName);
zip.CreateEntryFromFile(Path.Combine(tempPath, SettingsFileName), SettingsFileName);
if (crate.HasIcon)
{
zip.CreateEntryFromFile(Path.Combine(tempPath, IconFileName), IconFileName);
}
if (Assets.Count > 0)
{
zip.CreateEntry(zipFolderName);
foreach (KeyValuePair <string, string> pair in Assets)
{
zip.CreateEntryFromFile(pair.Key, zipFolderName + pair.Value);
}
}
}
}
//cleanup
Directory.Delete(tempPath, true);
}
/// <summary>
/// Detects console and game from the given full path using cached ModPipeline and Game lists.
/// </summary>
public void DetectGame(string inputPath)
{
bool directoryMode = IO_Common.PathIsFolder(inputPath);
Modder = null;
Pipeline = null;
GamePreloaded = false;
SupportedMods = new List <ModCrate>();
bool ConsoleDetected = false;
string regionID;
uint regionNumber;
DeleteTempFiles(TempPath);
try
{
foreach (KeyValuePair <ModPipelineInfo, Type> pair in SupportedConsoles)
{
Pipeline = (ModPipeline)Activator.CreateInstance(pair.Value);
bool DetectResult = Pipeline.Detect(directoryMode, inputPath, out regionID, out regionNumber);
if (DetectResult)
{
ConsoleDetected = true;
SetGameType(regionID, pair.Key.Console, regionNumber);
break;
}
DeleteTempFiles(TempPath);
}
}
catch (Exception ex)
{
Console.WriteLine("Detect Error: " + ex.Message);
UpdateProcessMessage(ModLoaderText.Error_UnableToOpenGame);
ResetGameSpecific(false);
return;
}
DeleteTempFiles(TempPath);
SetProcessStartAllow.Invoke(this, new EventValueArgs <bool>(ConsoleDetected));
if (!ConsoleDetected)
{
ResetGameSpecific(false);
UpdateProcessMessage(ModLoaderText.Error_UnknownGameROM);
}
}
/// <summary>
/// De-serializes mod properties in activated Mod Crates into the given Modder
/// </summary>
public static void InstallCrateSettings(List <ModCrate> SupportedMods, Modder modder)
{
for (int mod = 0; mod < SupportedMods.Count; mod++)
{
if (SupportedMods[mod].IsActivated && SupportedMods[mod].HasSettings)
{
foreach (ModPropertyBase prop in modder.Props)
{
if (SupportedMods[mod].Settings.ContainsKey(prop.CodeName) && !prop.HasChanged) // Manual mod menu changes override mod crates
{
prop.DeSerialize(SupportedMods[mod].Settings[prop.CodeName], SupportedMods[mod]);
prop.HasChanged = true;
}
}
}
}
}
/// <summary>
/// Takes the given Modder's mod properties and saves them into a valid settings text file at the given path. (if fullSettings is false - only saves altered properties)
/// </summary>
public static void SaveSettingsToFile(Modder mod, string path, bool fullSettings)
{
List <string> LineList = new List <string>();
LineList.Add(string.Format("{0} {1} {2}", CommentSymbol, ModLoaderGlobals.ProgramVersion, "Auto-Generated Settings File"));
foreach (ModPropertyBase prop in mod.Props)
{
if (fullSettings || (!fullSettings && prop.HasChanged))
{
string text = "";
prop.Serialize(ref text);
LineList.Add(text);
}
}
File.WriteAllLines(path, LineList);
}
public ModMenuForm(ModLoaderForm parent, Modder modder, Game g)
{
InitializeComponent();
button1.Text = ModLoaderText.ModMenu_Button_Confirm;
button2.Text = ModLoaderText.ModMenu_Button_SaveAs;
button3.Text = ModLoaderText.ModMenu_Button_Load;
button4.Text = ModLoaderText.ModMenu_Button_ResetToDefault;
button5.Text = ModLoaderText.ModMenu_Button_Publish;
button_modbit.Text = ModLoaderText.ModMenu_Label_ModBit;
Text = ModLoaderText.ModMenuTitle;
mod = modder;
Game = g;
parentForm = parent;
//todo: generate Mod Bit
GenerateUI();
}
void CacheSupportedGames(Assembly[] assemblies)
{
SupportedGames = new Dictionary <Game, Assembly>();
foreach (Assembly assembly in assemblies)
{
foreach (Type type in assembly.GetTypes())
{
if (type.IsAbstract || !typeof(Modder).IsAssignableFrom(type)) // only get non-abstract modders
{
continue;
}
Modder modder = (Modder)Activator.CreateInstance(type);
Game game = modder.Game;
game.ModderClass = type;
SupportedGames.Add(game, assembly);
}
}
}
/// <summary>
/// Loads mod properties from given Settings file or Mod Crate at given path into the given Modder
/// </summary>
public static void LoadSettingsFromFile(Modder mod, string path)
{
FileInfo file = new FileInfo(path);
bool isModCrate = file.Extension.ToLower() == ".zip";
Dictionary <string, string> Settings = new Dictionary <string, string>();
//zip handling
if (isModCrate)
{
using (ZipArchive archive = ZipFile.OpenRead(file.FullName))
{
foreach (ZipArchiveEntry entry in archive.Entries)
{
if (entry.FullName.EndsWith(".txt", StringComparison.OrdinalIgnoreCase))
{
if (entry.Name.ToLower() == SettingsFileName)
{
using (StreamReader fileStream = new StreamReader(entry.Open(), true))
{
string line;
while ((line = fileStream.ReadLine()) != null)
{
if (line[0] != CommentSymbol)
{
string[] setting = line.Split(Separator);
Settings[setting[0]] = setting[1];
}
}
}
}
}
}
}
}
else
{
using (StreamReader fileStream = new StreamReader(path, true))
{
string line;
while ((line = fileStream.ReadLine()) != null)
{
if (line[0] != CommentSymbol)
{
string[] setting = line.Split(Separator);
if (setting.Length > 1)
{
Settings[setting[0]] = setting[1];
}
}
}
}
}
if (Settings.Count == 0)
{
//MessageBox.Show(ModLoaderText.ModMenuLoad_Error);
return;
}
ModCrate crate = null;
if (isModCrate)
{
crate = LoadMetadata(file);
}
foreach (ModPropertyBase prop in mod.Props)
{
if (Settings.ContainsKey(prop.CodeName))
{
prop.DeSerialize(Settings[prop.CodeName], crate);
prop.HasChanged = true;
}
}
}
void SetGameType(string serial, ConsoleMode console, uint RegionID)
{
bool RegionNotSupported = true;
RegionCode TargetRegion = new RegionCode();
Modder = null;
SupportedMods = new List <ModCrate>();
if (SupportedGames.Count <= 0)
{
Console.WriteLine("ERROR: No games supported!");
return;
}
foreach (KeyValuePair <Game, Assembly> pair in SupportedGames)
{
Game game = pair.Key;
if (!game.Consoles.Contains(console))
{
continue;
}
RegionCode[] codelist;
if (game.RegionID.ContainsKey(console))
{
codelist = game.RegionID[console];
}
else
{
codelist = null;
Console.WriteLine("ERROR: Missing RegionID for game " + game.Name);
}
foreach (var r in codelist)
{
if (serial.Contains(r.Name))
{
if (console == ConsoleMode.XBOX && RegionID != r.RegionNumber)
{
RegionNotSupported = true;
}
else
{
RegionNotSupported = false;
Modder = (Modder)Activator.CreateInstance(game.ModderClass);
Game = game;
TargetRegion = r;
break;
}
}
}
if (RegionNotSupported)
{
foreach (var r in codelist)
{
if (serial.Contains(r.Name))
{
Modder = (Modder)Activator.CreateInstance(game.ModderClass);
Game = game;
TargetRegion = r;
break;
}
}
}
if (Modder != null)
{
Modder.assembly = pair.Value;
Modder.ConsolePipeline = Pipeline;
Modder.GameRegion = TargetRegion;
break;
}
}
string cons_mod = "";
switch (console)
{
default: cons_mod = console.ToString(); break;
case ConsoleMode.Undefined: cons_mod = "(" + ModLoaderText.UnknownConsole + ")"; break;
}
string region_mod = "(" + ModLoaderText.UnknownRegion + ")";
if (!RegionNotSupported)
{
switch (TargetRegion.Region)
{
case RegionType.NTSC_J: region_mod = "NTSC-J"; break;
case RegionType.NTSC_U: region_mod = "NTSC-U"; break;
case RegionType.PAL: region_mod = "PAL"; break;
case RegionType.Global: region_mod = ""; break;
default: region_mod = "(" + ModLoaderText.UnknownRegion + ")"; break;
}
}
// UI stuff
if (Modder == null)
{
LayoutChangeUnsupported.Invoke(this, new EventValueArgs <string>(cons_mod));
}
else
{
Modder.PopulateProperties();
LayoutChangeSupported.Invoke(this, new EventGameDetails(Game, cons_mod, region_mod));
}
}
