Mirrors/UWUVCI-AIO-WPF
2
0
Fork 0
mirror of https://github.com/stuff-by-3-random-dudes/UWUVCI-AIO-WPF synced 2024-09-20 13:51:55 +00:00
Code Issues Projects Releases Packages Wiki Activity
UWUVCI-AIO-WPF/UWUVCI AIO WPF/Classes/Injection.cs
ZestyTS c766431d31 Fixed file names, and order
2022-01-10 15:17:27 -08:00

2825 lines
127 KiB
C#
Raw Blame History

using GameBaseClassLibrary;
using GMWare.M2.MArchive;
using NAudio.Wave;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.IO.Compression;
using System.Linq;
using System.Net;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Forms;
using System.Windows.Media.Imaging;
using System.Windows.Threading;
using System.Xml;
using UWUVCI_AIO_WPF.Classes;
using UWUVCI_AIO_WPF.Properties;
using UWUVCI_AIO_WPF.UI.Windows;
using MessageBox = System.Windows.MessageBox;
namespace UWUVCI_AIO_WPF
{
public static class StringExtensions
{
public static string ToHex(this string input)
{
StringBuilder sb = new StringBuilder();
foreach (char c in input)
sb.AppendFormat("{0:X2}", (int)c);
return sb.ToString().Trim();
}
}
internal static class Injection
{
[DllImport("User32.dll")]
static extern int SetForegroundWindow(IntPtr point);
[DllImport("user32.dll")]
public static extern int SendMessage(
int hWnd, // handle to destination window
uint Msg, // message
long wParam, // first message parameter
long lParam // second message parameter
);
[return: MarshalAs(UnmanagedType.Bool)]
[DllImport("user32.dll", SetLastError = true)]
static extern bool PostMessage(IntPtr hWnd, int Msg, System.Windows.Forms.Keys wParam, int lParam);
private static Int32 WM_KEYUP = 0x101;
private static readonly string tempPath = Path.Combine(Directory.GetCurrentDirectory(),"bin", "temp");
private static readonly string baseRomPath = Path.Combine(tempPath, "baserom");
private static readonly string imgPath = Path.Combine(tempPath, "img");
private static readonly string toolsPath = Path.Combine(Directory.GetCurrentDirectory(),"bin", "Tools");
static string code = null;
static MainViewModel mvvm;
/*
* GameConsole: Can either be NDS, N64, GBA, NES, SNES or TG16
* baseRom = Name of the BaseRom, which is the folder name too (example: Super Metroid EU will be saved at the BaseRom path under the folder SMetroidEU, so the BaseRom is in this case SMetroidEU).
* customBasePath = Path to the custom Base. Is null if no custom base is used.
* injectRomPath = Path to the Rom to be injected into the Base Game.
* bootImages = String array containing the paths for
* bootTvTex: PNG or TGA (PNG gets converted to TGA using UPNG). Needs to be in the dimensions 1280x720 and have a bit depth of 24. If null, the original BootImage will be used.
* bootDrcTex: PNG or TGA (PNG gets converted to TGA using UPNG). Needs to be in the dimensions 854x480 and have a bit depth of 24. If null, the original BootImage will be used.
* iconTex: PNG or TGA (PNG gets converted to TGA using UPNG). Needs to be in the dimensions 128x128 and have a bit depth of 32. If null, the original BootImage will be used.
* bootLogoTex: PNG or TGA (PNG gets converted to TGA using UPNG). Needs to be in the dimensions 170x42 and have a bit depth of 32. If null, the original BootImage will be used.
* gameName = The name of the final game to be entered into the .xml files.
* iniPath = Only used for N64. Path to the INI configuration. If "blank", a blank ini will be used.
* darkRemoval = Only used for N64. Indicates whether the dark filter should be removed.
*/
static List<int> fiind(this byte[] buffer, byte[] pattern, int startIndex)
{
List<int> positions = new List<int>();
int i = Array.IndexOf<byte>(buffer, pattern[0], startIndex);
while (i >= 0 && i <= buffer.Length - pattern.Length)
{
byte[] segment = new byte[pattern.Length];
Buffer.BlockCopy(buffer, i, segment, 0, pattern.Length);
if (segment.SequenceEqual<byte>(pattern))
positions.Add(i);
i = Array.IndexOf<byte>(buffer, pattern[0], i + 1);
}
return positions;
}
static void PokePatch(string rom)
{
byte[] search = { 0xD0, 0x88, 0x8D, 0x83, 0x42 };
byte[] test;
test = new byte[new FileInfo(rom).Length];
using (var fs = new FileStream(rom,
FileMode.Open,
FileAccess.ReadWrite))
{
try
{
fs.Read(test, 0, test.Length - 1);
var l = fiind(test, search, 0);
byte[] check = new byte[4];
fs.Seek(l[0] + 5, SeekOrigin.Begin);
fs.Read(check, 0, 4);
fs.Seek(0, SeekOrigin.Begin);
if (check[3] != 0x24)
{
fs.Seek(l[0] + 5, SeekOrigin.Begin);
fs.Write(new byte[] { 0x00, 0x00, 0x00, 0x00 }, 0, 4);
}
else
{
fs.Seek(l[0] + 5, SeekOrigin.Begin);
fs.Write(new byte[] { 0x00, 0x00, 0x00 }, 0, 3);
}
check = new byte[4];
fs.Seek(l[1] + 5, SeekOrigin.Begin);
fs.Read(check, 0, 4);
fs.Seek(0, SeekOrigin.Begin);
if (check[3] != 0x24)
{
fs.Seek(l[1] + 5, SeekOrigin.Begin);
fs.Write(new byte[] { 0x00, 0x00, 0x00, 0x00 }, 0, 4);
}
else
{
fs.Seek(l[1] + 5, SeekOrigin.Begin);
fs.Write(new byte[] { 0x00, 0x00, 0x00 }, 0, 3);
}
}
catch (Exception )
{
}
fs.Close();
}
}
private static string FormatBytes(long bytes)
{
string[] Suffix = { "B", "KB", "MB", "GB", "TB" };
int i;
double dblSByte = bytes;
for (i = 0; i < Suffix.Length && bytes >= 1024; i++, bytes /= 1024)
{
dblSByte = bytes / 1024.0;
}
return String.Format("{0:0.##} {1}", dblSByte, Suffix[i]);
}
[STAThread]
public static bool Inject(GameConfig Configuration, string RomPath, MainViewModel mvm, bool force)
{
mvm.failed = false;
DispatcherTimer timer = new DispatcherTimer();
timer.Interval = TimeSpan.FromSeconds(1);
timer.Tick += tick;
Clean();
long freeSpaceInBytes = 0;
if (!mvm.saveworkaround)
{
try
{
long gamesize = new FileInfo(RomPath).Length;
var drive = new DriveInfo(tempPath);
done = true;
freeSpaceInBytes = drive.AvailableFreeSpace;
}
catch(Exception e)
{
mvm.saveworkaround = true;
}
}
long neededspace = 0;
mvvm = mvm;
Directory.CreateDirectory(tempPath);
mvm.msg = "Checking Tools...";
mvm.InjcttoolCheck();
mvm.Progress = 5;
mvm.msg = "Copying Base...";
try
{
if (!mvm.saveworkaround && (Configuration.Console == GameConsoles.WII || Configuration.Console == GameConsoles.GCN))
{
if (mvm.GC)
{
neededspace = 10000000000;
}
else
{
neededspace = 15000000000;
}
if (freeSpaceInBytes < neededspace)
{
throw new Exception("12G");
}
}
if(Configuration.BaseRom == null || Configuration.BaseRom.Name == null)
{
throw new Exception("BASE");
}
if (Configuration.BaseRom.Name != "Custom")
{
//Normal Base functionality here
CopyBase($"{Configuration.BaseRom.Name.Replace(":", "")} [{Configuration.BaseRom.Region.ToString()}]", null);
}
else
{
//Custom Base Functionality here
CopyBase($"Custom", Configuration.CBasePath);
}
if(!Directory.Exists(Path.Combine(baseRomPath, "code")) || !Directory.Exists(Path.Combine(baseRomPath, "content")) || !Directory.Exists(Path.Combine(baseRomPath, "meta")))
{
throw new Exception("MISSINGF");
}
mvm.Progress = 10;
mvm.msg = "Injecting ROM...";
if (mvm.GC)
{
RunSpecificInjection(Configuration, GameConsoles.GCN, RomPath, force, mvm);
}
else
{
RunSpecificInjection(Configuration, Configuration.Console, RomPath, force, mvm);
}
mvm.msg = "Editing XML...";
EditXML(Configuration.GameName, mvm.Index, code);
mvm.Progress = 90;
mvm.msg = "Changing Images...";
Images(Configuration);
if (File.Exists(mvm.BootSound))
{
mvm.Progress = 95;
mvm.msg = "Adding BootSound...";
bootsound(mvm.BootSound);
}
mvm.Progress = 100;
code = null;
return true;
}catch(Exception e)
{
mvm.Progress = 100;
code = null;
if(e.Message == "Failed this shit")
{
Clean();
return false;
}
if (e.Message == "MISSINGF")
{
MessageBox.Show("Injection Failed because there are base files missing. \nPlease redownload the base, or redump if you used a custom base! ", "Injection Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (e.Message.Contains("Images")){
MessageBox.Show("Injection Failed due to wrong BitDepth, please check if your Files are in a different bitdepth than 32bit or 24bit", "Injection Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (e.Message.Contains("Size"))
{
MessageBox.Show("Injection Failed due to Image Issues.Please check if your Images are made using following Information:\n\niconTex: \nDimensions: 128x128\nBitDepth: 32\n\nbootDrcTex: \nDimensions: 854x480\nBitDepth: 24\n\nbootTvTex: \nDimensions: 1280x720\nBitDepth: 24\n\nbootLogoTex: \nDimensions: 170x42\nBitDepth: 32", "Injection Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (e.Message.Contains("retro"))
{
MessageBox.Show("The ROM you want to Inject is to big for selected Base!\nPlease try again with different Base", "Injection Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (e.Message.Contains("BASE"))
{
MessageBox.Show("If you import a config you NEED to reselect a base", "Injection Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (e.Message.Contains("WII"))
{
MessageBox.Show( $"{e.Message.Replace("WII", "")}\nPlease make sure that your ROM isn't flawed and that you have atleast 12 GB of free Storage left.", "Injection Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
else if (e.Message.Contains("12G"))
{
MessageBox.Show($" Please make sure to have atleast {FormatBytes(15000000000)} of storage left on the drive where you stored the Injector.", "Injection Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}else if (e.Message.Contains("nkit"))
{
MessageBox.Show($"There is an issue with your NKIT.\nPlease try the original ISO, or redump your game and try again with that dump.", "Injection Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
MessageBox.Show("Injection Failed due to unknown circumstances, please contact us on the UWUVCI discord", "Injection Failed", MessageBoxButton.OK, MessageBoxImage.Error);
}
Clean();
return false;
}
finally
{
mvm.Index = -1;
mvm.LR = false;
mvm.msg = "";
}
}
private static bool done = false;
private static void tick(object sender, EventArgs e)
{
if (!done)
{
mvvm.failed = true;
}
throw new Exception("Failed this shit");
}
public static void SendKey(IntPtr hWnd, System.Windows.Forms.Keys key)
{
PostMessage(hWnd, WM_KEYUP, key, 0);
}
static void bootsound(string sound)
{
string btsndPath = Path.Combine(baseRomPath, "meta", "bootSound.btsnd");
FileInfo soundFile = new FileInfo(sound);
if(soundFile.Extension.Contains("mp3") || soundFile.Extension.Contains("wav"))
{
// Convert input file to 6 second .wav
using (Process sox = new Process())
{
sox.StartInfo.UseShellExecute = false;
sox.StartInfo.CreateNoWindow = true;
sox.StartInfo.FileName = Path.Combine(toolsPath, "sox.exe");
sox.StartInfo.Arguments = $"\"{sound}\" -b 16 \"{Path.Combine(tempPath, "bootSound.wav")}\" channels 2 rate 48k trim 0 6";
sox.Start();
sox.WaitForExit();
}
//convert to btsnd
wav2btsnd(Path.Combine(tempPath, "bootSound.wav"), btsndPath);
File.Delete(Path.Combine(tempPath, "bootSound.wav"));
}
else
{
//Copy BootSound to location
File.Delete(btsndPath);
File.Copy(sound, btsndPath);
}
}
private static void wav2btsnd(string inputWav, string outputBtsnd)
{
// credits to the original creator of wav2btsnd for the general logic
byte[] buffer = File.ReadAllBytes(inputWav);
using (FileStream output = new FileStream(outputBtsnd, FileMode.OpenOrCreate))
using (BinaryWriter writer = new BinaryWriter(output))
{
writer.Write(new byte[] {0x0, 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0});
for (int i = 0x2C; i < buffer.Length; i += 2)
{
writer.Write(new[] {buffer[i+1], buffer[i]});
}
}
}
static void timer_Tick(object sender, EventArgs e)
{
if(mvvm.Progress < 50)
{
mvvm.Progress += 1;
}
}
private static void RunSpecificInjection(GameConfig cfg, GameConsoles console, string RomPath, bool force, MainViewModel mvm)
{
switch (console)
{
case GameConsoles.NDS:
NDS(RomPath);
break;
case GameConsoles.N64:
N64(RomPath, cfg.N64Stuff);
break;
case GameConsoles.GBA:
GBA(RomPath, cfg.GBAStuff);
break;
case GameConsoles.NES:
NESSNES(RomPath);
break;
case GameConsoles.SNES:
NESSNES(RemoveHeader(RomPath));
break;
case GameConsoles.TG16:
TG16(RomPath);
break;
case GameConsoles.MSX:
MSX(RomPath);
break;
case GameConsoles.WII:
if (RomPath.ToLower().EndsWith(".dol"))
{
WiiHomebrew(RomPath, mvm);
}else if (RomPath.ToLower().EndsWith(".wad"))
{
WiiForwarder(RomPath, mvm);
}
else
{
WII(RomPath, mvm);
}
break;
case GameConsoles.GCN:
GC(RomPath, mvm, force);
break;
}
}
private static string ByteArrayToString(byte[] arr)
{
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
return enc.GetString(arr);
}
private static void WiiForwarder(string romPath, MainViewModel mvm)
{
string savedir = Directory.GetCurrentDirectory();
mvvm.msg = "Extracting Forwarder Base...";
if (Directory.Exists(Path.Combine(tempPath, "TempBase"))) Directory.Delete(Path.Combine(tempPath, "TempBase"), true);
Directory.CreateDirectory(Path.Combine(tempPath, "TempBase"));
using (Process zip = new Process())
{
if (!mvm.debug)
{
zip.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
zip.StartInfo.FileName = Path.Combine(toolsPath, "7za.exe");
zip.StartInfo.Arguments = $"x \"{Path.Combine(toolsPath, "BASE.zip")}\" -o\"{Path.Combine(tempPath)}\"";
zip.Start();
zip.WaitForExit();
}
DirectoryCopy(Path.Combine(tempPath, "BASE"), Path.Combine(tempPath, "TempBase"), true);
mvvm.Progress = 20;
mvvm.msg = "Setting up Forwarder...";
byte[] test = new byte[4];
using (FileStream fs = new FileStream(romPath, FileMode.Open))
{
fs.Seek(0xC20, SeekOrigin.Begin);
fs.Read(test, 0, 4);
fs.Close();
}
string[] id = { ByteArrayToString(test) };
File.WriteAllLines(Path.Combine(tempPath, "TempBase", "files","title.txt"), id);
mvm.Progress = 30;
mvm.msg = "Copying Forwarder...";
File.Copy(Path.Combine(toolsPath, "forwarder.dol"), Path.Combine(tempPath, "TempBase", "sys", "main.dol"));
mvm.Progress = 40;
mvvm.msg = "Creating Injectable file...";
using (Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
wit.StartInfo.Arguments = $"copy \"{Path.Combine(tempPath, "TempBase")}\" --DEST \"{Path.Combine(tempPath, "game.iso")}\" -ovv --links --iso";
wit.Start();
wit.WaitForExit();
}
Thread.Sleep(6000);
if (!File.Exists(Path.Combine(tempPath, "game.iso")))
{
Console.Clear();
throw new Exception("WIIAn error occured while Creating the ISO");
}
Directory.Delete(Path.Combine(tempPath, "TempBase"), true);
romPath = Path.Combine(tempPath, "game.iso");
mvvm.Progress = 50;
mvm.msg = "Replacing TIK and TMD...";
using (Process extract = new Process())
{
if (!mvm.debug)
{
extract.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
extract.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
extract.StartInfo.Arguments = $"extract \"{Path.Combine(tempPath, "game.iso")}\" --psel data --files +tmd.bin --files +ticket.bin --DEST \"{Path.Combine(tempPath, "TIKTMD")}\" -vv1";
extract.Start();
extract.WaitForExit();
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "code"), "rvlt.*"))
{
File.Delete(sFile);
}
File.Copy(Path.Combine(tempPath, "TIKTMD", "tmd.bin"), Path.Combine(baseRomPath, "code", "rvlt.tmd"));
File.Copy(Path.Combine(tempPath, "TIKTMD", "ticket.bin"), Path.Combine(baseRomPath, "code", "rvlt.tik"));
Directory.Delete(Path.Combine(tempPath, "TIKTMD"), true);
}
mvm.Progress = 60;
mvm.msg = "Injecting ROM...";
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "content"), "*.nfs"))
{
File.Delete(sFile);
}
File.Move(Path.Combine(tempPath, "game.iso"), Path.Combine(baseRomPath, "content", "game.iso"));
File.Copy(Path.Combine(toolsPath, "nfs2iso2nfs.exe"), Path.Combine(baseRomPath, "content", "nfs2iso2nfs.exe"));
Directory.SetCurrentDirectory(Path.Combine(baseRomPath, "content"));
using (Process iso2nfs = new Process())
{
if (!mvm.debug)
{
iso2nfs.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
iso2nfs.StartInfo.FileName = "nfs2iso2nfs.exe";
string extra = "";
if (mvm.Index == 2)
{
extra = "-horizontal ";
}
if (mvm.Index == 3) { extra = "-wiimote "; }
if (mvm.Index == 4) { extra = "-instantcc "; }
if (mvm.Index == 5) { extra = "-nocc "; }
if (mvm.LR) { extra += "-lrpatch "; }
iso2nfs.StartInfo.Arguments = $"-enc -homebrew {extra}-iso game.iso";
iso2nfs.Start();
iso2nfs.WaitForExit();
File.Delete("nfs2iso2nfs.exe");
File.Delete("game.iso");
}
Directory.SetCurrentDirectory(savedir);
mvm.Progress = 80;
}
private static void WiiHomebrew(string romPath, MainViewModel mvm)
{
string savedir = Directory.GetCurrentDirectory();
mvvm.msg = "Extracting Homebrew Base...";
if (Directory.Exists(Path.Combine(tempPath, "TempBase"))) Directory.Delete(Path.Combine(tempPath, "TempBase"), true);
Directory.CreateDirectory(Path.Combine(tempPath, "TempBase"));
using (Process zip = new Process())
{
if (!mvm.debug)
{
zip.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
zip.StartInfo.FileName = Path.Combine(toolsPath, "7za.exe");
zip.StartInfo.Arguments = $"x \"{Path.Combine(toolsPath, "BASE.zip")}\" -o\"{Path.Combine(tempPath)}\"";
zip.Start();
zip.WaitForExit();
}
DirectoryCopy(Path.Combine(tempPath, "BASE"), Path.Combine(tempPath, "TempBase"), true);
mvvm.Progress = 20;
mvvm.msg = "Injecting DOL...";
File.Copy(romPath, Path.Combine(tempPath, "TempBase", "sys", "main.dol"));
mvm.Progress = 30;
mvvm.msg = "Creating Injectable file...";
using (Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
wit.StartInfo.Arguments = $"copy \"{Path.Combine(tempPath, "TempBase")}\" --DEST \"{Path.Combine(tempPath, "game.iso")}\" -ovv --links --iso";
wit.Start();
wit.WaitForExit();
}
Thread.Sleep(6000);
if (!File.Exists(Path.Combine(tempPath, "game.iso")))
{
Console.Clear();
throw new Exception("WIIAn error occured while Creating the ISO");
}
Directory.Delete(Path.Combine(tempPath, "TempBase"), true);
romPath = Path.Combine(tempPath, "game.iso");
mvvm.Progress = 50;
mvm.msg = "Replacing TIK and TMD...";
using (Process extract = new Process())
{
if (!mvm.debug)
{
extract.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
extract.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
extract.StartInfo.Arguments = $"extract \"{Path.Combine(tempPath, "game.iso")}\" --psel data --files +tmd.bin --files +ticket.bin --DEST \"{Path.Combine(tempPath, "TIKTMD")}\" -vv1";
extract.Start();
extract.WaitForExit();
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "code"), "rvlt.*"))
{
File.Delete(sFile);
}
File.Copy(Path.Combine(tempPath, "TIKTMD", "tmd.bin"), Path.Combine(baseRomPath, "code", "rvlt.tmd"));
File.Copy(Path.Combine(tempPath, "TIKTMD", "ticket.bin"), Path.Combine(baseRomPath, "code", "rvlt.tik"));
Directory.Delete(Path.Combine(tempPath, "TIKTMD"), true);
}
mvm.Progress = 60;
mvm.msg = "Injecting ROM...";
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "content"), "*.nfs"))
{
File.Delete(sFile);
}
File.Move(Path.Combine(tempPath, "game.iso"), Path.Combine(baseRomPath, "content", "game.iso"));
File.Copy(Path.Combine(toolsPath, "nfs2iso2nfs.exe"), Path.Combine(baseRomPath, "content", "nfs2iso2nfs.exe"));
Directory.SetCurrentDirectory(Path.Combine(baseRomPath, "content"));
using (Process iso2nfs = new Process())
{
if (!mvm.debug)
{
iso2nfs.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
iso2nfs.StartInfo.FileName = "nfs2iso2nfs.exe";
string pass = "-passthrough ";
if(mvm.passtrough != true)
{
pass = "";
}
iso2nfs.StartInfo.Arguments = $"-enc -homebrew {pass}-iso game.iso";
iso2nfs.Start();
iso2nfs.WaitForExit();
File.Delete("nfs2iso2nfs.exe");
File.Delete("game.iso");
}
Directory.SetCurrentDirectory(savedir);
mvm.Progress = 80;
}
private static void WII(string romPath, MainViewModel mvm)
{
string savedir = Directory.GetCurrentDirectory();
if (mvm.NKITFLAG || romPath.Contains("nkit"))
{
using (Process toiso = new Process())
{
mvm.msg = "Converting NKIT to ISO";
if (!mvm.debug)
{
toiso.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
// toiso.StartInfo.CreateNoWindow = true;
}
toiso.StartInfo.FileName = Path.Combine(toolsPath, "ConvertToIso.exe");
toiso.StartInfo.Arguments = $"\"{romPath}\"";
toiso.Start();
toiso.WaitForExit();
if(!File.Exists(Path.Combine(toolsPath, "out.iso")))
{
throw new Exception("nkit");
}
File.Move(Path.Combine(toolsPath, "out.iso"), Path.Combine(tempPath, "pre.iso"));
mvm.Progress = 15;
}
}
else
{
if (new FileInfo(romPath).Extension.Contains("wbfs"))
{
mvm.msg = "Converting WBFS to ISO...";
using (Process toiso = new Process())
{
if (!mvm.debug)
{
toiso.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
// toiso.StartInfo.CreateNoWindow = true;
}
toiso.StartInfo.FileName = Path.Combine(toolsPath, "wbfs_file.exe");
toiso.StartInfo.Arguments = $"\"{romPath}\" convert \"{Path.Combine(tempPath, "pre.iso")}\" -t";
toiso.Start();
toiso.WaitForExit();
mvm.Progress = 15;
}
}
else if (new FileInfo(romPath).Extension.Contains("iso"))
{
mvm.msg = "Copying ROM...";
File.Copy(romPath, Path.Combine(tempPath, "pre.iso"));
mvm.Progress = 15;
}
}
//GET ROMCODE and change it
mvm.msg = "Trying to change the Manual...";
//READ FIRST 4 BYTES
byte[] chars = new byte[4];
FileStream fstrm = new FileStream(Path.Combine(tempPath, "pre.iso"), FileMode.Open);
fstrm.Read(chars, 0, 4);
fstrm.Close();
string procod = ByteArrayToString(chars);
string neededformanual = procod.ToHex();
string metaXml = Path.Combine(baseRomPath, "meta", "meta.xml");
XmlDocument doc = new XmlDocument();
doc.Load(metaXml);
doc.SelectSingleNode("menu/reserved_flag2").InnerText = neededformanual;
doc.Save(metaXml);
//edit emta.xml
mvm.Progress = 20;
if (!mvm.donttrim)
{
if (mvm.regionfrii)
{
if (mvm.regionfriius)
{
using (FileStream fs = new FileStream(Path.Combine(tempPath, "pre.iso"), FileMode.Open))
{
fs.Seek(0x4E003, SeekOrigin.Begin);
fs.Write(new byte[] { 0x01 },0,1);
fs.Seek(0x4E010, SeekOrigin.Begin);
fs.Write(new byte[] { 0x80, 0x06, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 },0,16);
fs.Close();
}
}
else if(mvm.regionfriijp)
{
using (FileStream fs = new FileStream(Path.Combine(tempPath, "pre.iso"), FileMode.Open))
{
fs.Seek(0x4E003, SeekOrigin.Begin);
fs.Write(new byte[] { 0x00 }, 0, 1);
fs.Seek(0x4E010, SeekOrigin.Begin);
fs.Write(new byte[] { 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 },0, 16);
fs.Close();
}
}
else
{
using (FileStream fs = new FileStream(Path.Combine(tempPath, "pre.iso"), FileMode.Open))
{
fs.Seek(0x4E003, SeekOrigin.Begin);
fs.Write(new byte[] { 0x02 }, 0, 1);
fs.Seek(0x4E010, SeekOrigin.Begin);
fs.Write(new byte[] { 0x80, 0x80, 0x80, 0x00, 0x03, 0x03, 0x04, 0x03, 0x00, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80 }, 0, 16);
fs.Close();
}
}
}
using (Process trimm = new Process())
{
if (!mvm.debug)
{
trimm.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
mvm.msg = "Trimming ROM...";
trimm.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
trimm.StartInfo.Arguments = $"extract \"{Path.Combine(tempPath, "pre.iso")}\" --DEST \"{Path.Combine(tempPath, "TEMP")}\" --psel data -vv1";
trimm.Start();
trimm.WaitForExit();
mvm.Progress = 30;
}
if (mvm.Index == 4)
{
mvvm.msg = "Patching ROM (Force CC)...";
Console.WriteLine("Patching the ROM to force Classic Controller input");
using (Process tik = new Process())
{
tik.StartInfo.FileName = Path.Combine(toolsPath, "GetExtTypePatcher.exe");
tik.StartInfo.Arguments = $"\"{Path.Combine(tempPath, "TEMP", "sys", "main.dol")}\" -nc";
tik.StartInfo.UseShellExecute = false;
tik.StartInfo.CreateNoWindow = true;
tik.StartInfo.RedirectStandardOutput = true;
tik.StartInfo.RedirectStandardInput = true;
tik.Start();
Thread.Sleep(2000);
tik.StandardInput.WriteLine();
tik.WaitForExit();
mvm.Progress = 35;
}
}
if (mvm.jppatch)
{
mvm.msg = "Language Patching ROM...";
using (BinaryWriter writer = new BinaryWriter(new FileStream(Path.Combine(tempPath, "TEMP", "sys", "main.dol"), FileMode.Open)))
{
byte[] stuff = new byte[] { 0x38, 0x60};
writer.Seek(0x4CBDAC, SeekOrigin.Begin);
writer.Write(stuff);
writer.Seek(0x4CBDAF, SeekOrigin.Begin);
stuff = new byte[] { 0x00 };
writer.Write(stuff);
writer.Close();
}
mvm.Progress = 37;
}
if (mvm.Patch)
{
mvm.msg = "Video Patching ROM...";
using (Process vmc = new Process())
{
File.Copy(Path.Combine(toolsPath, "wii-vmc.exe"), Path.Combine(tempPath, "TEMP", "sys", "wii-vmc.exe"));
Directory.SetCurrentDirectory(Path.Combine(tempPath, "TEMP", "sys"));
vmc.StartInfo.FileName = "wii-vmc.exe";
vmc.StartInfo.Arguments = "main.dol";
vmc.StartInfo.UseShellExecute = false;
vmc.StartInfo.CreateNoWindow = true;
vmc.StartInfo.RedirectStandardOutput = true;
vmc.StartInfo.RedirectStandardInput = true;
vmc.Start();
Thread.Sleep(1000);
vmc.StandardInput.WriteLine("a");
Thread.Sleep(2000);
if (mvm.toPal) vmc.StandardInput.WriteLine("1");
else vmc.StandardInput.WriteLine("2");
Thread.Sleep(2000);
vmc.StandardInput.WriteLine();
vmc.WaitForExit();
File.Delete("wii-vmc.exe");
Directory.SetCurrentDirectory(savedir);
mvm.Progress = 40;
}
}
mvm.msg = "Creating ISO from trimmed ROM...";
using (Process repack = new Process())
{
if (!mvm.debug)
{
repack.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
repack.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
repack.StartInfo.Arguments = $"copy \"{Path.Combine(tempPath, "TEMP")}\" --DEST \"{Path.Combine(tempPath, "game.iso")}\" -ovv --links --iso";
repack.Start();
repack.WaitForExit();
Directory.Delete(Path.Combine(tempPath, "TEMP"), true);
File.Delete(Path.Combine(tempPath, "pre.iso"));
}
}
else
{
if(mvm.Index == 4 || mvm.Patch)
{
using (Process trimm = new Process())
{
if (!mvm.debug)
{
trimm.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
mvm.msg = "Trimming ROM...";
trimm.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
trimm.StartInfo.Arguments = $"extract \"{Path.Combine(tempPath, "pre.iso")}\" --DEST \"{Path.Combine(tempPath, "TEMP")}\" --psel WHOLE -vv1";
trimm.Start();
trimm.WaitForExit();
mvm.Progress = 30;
}
if (mvm.Index == 4)
{
mvvm.msg = "Patching ROM (Force CC)...";
Console.WriteLine("Patching the ROM to force Classic Controller input");
using (Process tik = new Process())
{
tik.StartInfo.FileName = Path.Combine(toolsPath, "GetExtTypePatcher.exe");
tik.StartInfo.Arguments = $"\"{Path.Combine(tempPath, "TEMP","DATA", "sys", "main.dol")}\" -nc";
tik.StartInfo.UseShellExecute = false;
tik.StartInfo.CreateNoWindow = true;
tik.StartInfo.RedirectStandardOutput = true;
tik.StartInfo.RedirectStandardInput = true;
tik.Start();
Thread.Sleep(2000);
tik.StandardInput.WriteLine();
tik.WaitForExit();
mvm.Progress = 35;
}
}
if (mvm.Patch)
{
mvm.msg = "Video Patching ROM...";
using (Process vmc = new Process())
{
File.Copy(Path.Combine(toolsPath, "wii-vmc.exe"), Path.Combine(tempPath, "TEMP", "DATA", "sys", "wii-vmc.exe"));
Directory.SetCurrentDirectory(Path.Combine(tempPath, "TEMP", "DATA", "sys"));
vmc.StartInfo.FileName = "wii-vmc.exe";
vmc.StartInfo.Arguments = "main.dol";
vmc.StartInfo.UseShellExecute = false;
vmc.StartInfo.CreateNoWindow = true;
vmc.StartInfo.RedirectStandardOutput = true;
vmc.StartInfo.RedirectStandardInput = true;
vmc.Start();
Thread.Sleep(1000);
vmc.StandardInput.WriteLine("a");
Thread.Sleep(2000);
if (mvm.toPal) vmc.StandardInput.WriteLine("1");
else vmc.StandardInput.WriteLine("2");
Thread.Sleep(2000);
vmc.StandardInput.WriteLine();
vmc.WaitForExit();
File.Delete("wii-vmc.exe");
Directory.SetCurrentDirectory(savedir);
mvm.Progress = 40;
}
}
mvm.msg = "Creating ISO from patched ROM...";
using (Process repack = new Process())
{
if (!mvm.debug)
{
repack.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
repack.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
repack.StartInfo.Arguments = $"copy \"{Path.Combine(tempPath, "TEMP")}\" --DEST \"{Path.Combine(tempPath, "game.iso")}\" -ovv --psel WHOLE --iso";
repack.Start();
repack.WaitForExit();
Directory.Delete(Path.Combine(tempPath, "TEMP"), true);
File.Delete(Path.Combine(tempPath, "pre.iso"));
}
}
else
{
File.Move(Path.Combine(tempPath, "pre.iso"), Path.Combine(tempPath, "game.iso"));
}
}
mvm.Progress = 50;
mvm.msg = "Replacing TIK and TMD...";
using (Process extract = new Process())
{
if (!mvm.debug)
{
extract.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
extract.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
extract.StartInfo.Arguments = $"extract \"{Path.Combine(tempPath, "game.iso")}\" --psel data --files +tmd.bin --files +ticket.bin --DEST \"{Path.Combine(tempPath, "TIKTMD")}\" -vv1";
extract.Start();
extract.WaitForExit();
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "code"), "rvlt.*"))
{
File.Delete(sFile);
}
File.Copy(Path.Combine(tempPath, "TIKTMD", "tmd.bin"), Path.Combine(baseRomPath, "code", "rvlt.tmd"));
File.Copy(Path.Combine(tempPath, "TIKTMD", "ticket.bin"), Path.Combine(baseRomPath, "code", "rvlt.tik"));
Directory.Delete(Path.Combine(tempPath, "TIKTMD"), true);
}
mvm.Progress = 60;
mvm.msg = "Injecting ROM...";
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "content"), "*.nfs"))
{
File.Delete(sFile);
}
File.Move(Path.Combine(tempPath, "game.iso"), Path.Combine(baseRomPath, "content", "game.iso"));
File.Copy(Path.Combine(toolsPath, "nfs2iso2nfs.exe"), Path.Combine(baseRomPath, "content", "nfs2iso2nfs.exe"));
Directory.SetCurrentDirectory(Path.Combine(baseRomPath, "content"));
using (Process iso2nfs = new Process())
{
if (!mvm.debug)
{
iso2nfs.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
iso2nfs.StartInfo.FileName = "nfs2iso2nfs.exe";
string extra = "";
if (mvm.Index == 2)
{
extra = "-horizontal ";
}
if (mvm.Index == 3) { extra = "-wiimote "; }
if (mvm.Index == 4) { extra = "-instantcc "; }
if (mvm.Index == 5) { extra = "-nocc "; }
if (mvm.LR) { extra += "-lrpatch "; }
iso2nfs.StartInfo.Arguments = $"-enc {extra}-iso game.iso";
iso2nfs.Start();
iso2nfs.WaitForExit();
File.Delete("nfs2iso2nfs.exe");
File.Delete("game.iso");
}
Directory.SetCurrentDirectory(savedir);
mvm.Progress = 80;
}
private static void GC(string romPath, MainViewModel mvm, bool force)
{
string savedir = Directory.GetCurrentDirectory();
mvvm.msg = "Extracting Nintendont Base...";
if (Directory.Exists(Path.Combine(tempPath, "TempBase"))) Directory.Delete(Path.Combine(tempPath, "TempBase"), true);
Directory.CreateDirectory(Path.Combine(tempPath, "TempBase"));
using (Process zip = new Process()){
if (!mvm.debug)
{
zip.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
zip.StartInfo.FileName = Path.Combine(toolsPath, "7za.exe");
zip.StartInfo.Arguments = $"x \"{Path.Combine(toolsPath, "BASE.zip")}\" -o\"{Path.Combine(tempPath)}\"";
zip.Start();
zip.WaitForExit();
}
DirectoryCopy(Path.Combine(tempPath, "BASE"), Path.Combine(tempPath, "TempBase"), true);
mvvm.Progress = 20;
mvvm.msg = "Applying Nintendont";
if (force)
{
mvvm.msg += " force 4:3...";
File.Copy(Path.Combine(toolsPath, "nintendont_force.dol"), Path.Combine(tempPath, "TempBase", "sys", "main.dol"));
}
else
{
mvvm.msg += "...";
File.Copy(Path.Combine(toolsPath, "nintendont.dol"), Path.Combine(tempPath, "TempBase", "sys", "main.dol"));
}
mvm.Progress = 40;
mvvm.msg = "Injecting GameCube Game into NintendontBase...";
if (mvm.donttrim)
{
if (romPath.ToLower().Contains("nkit.iso"))
{
using (Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "ConvertToIso.exe");
wit.StartInfo.Arguments = $"\"{romPath}\"";
wit.Start();
wit.WaitForExit();
if (!File.Exists(Path.Combine(toolsPath, "out.iso")))
{
throw new Exception("nkit");
}
File.Move(Path.Combine(toolsPath, "out.iso"), Path.Combine(tempPath, "TempBase", "files", "game.iso"));
}
}
else
{
if (romPath.ToLower().Contains("gcz"))
{
//Convert to nkit.iso
using (Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "ConvertToIso.exe");
wit.StartInfo.Arguments = $"\"{romPath}\"";
wit.Start();
wit.WaitForExit();
if (!File.Exists(Path.Combine(toolsPath, "out.iso")))
{
throw new Exception("nkit");
}
File.Move(Path.Combine(toolsPath, "out.iso"), Path.Combine(tempPath, "TempBase", "files", "game.iso"));
}
}
else
{
File.Copy(romPath, Path.Combine(tempPath, "TempBase", "files", "game.iso"));
}
}
}
else
{
if (romPath.ToLower().Contains("iso") || romPath.ToLower().Contains("gcm"))
{
//convert to nkit
using (Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "ConvertToNKit.exe");
wit.StartInfo.Arguments = $"\"{romPath}\"";
wit.Start();
wit.WaitForExit();
if (!File.Exists(Path.Combine(toolsPath, "out.nkit.iso")))
{
throw new Exception("nkit");
}
File.Move(Path.Combine(toolsPath, "out.nkit.iso"), Path.Combine(tempPath, "TempBase", "files", "game.iso"));
}
}
else
{
if (romPath.ToLower().Contains("gcz"))
{
//Convert to nkit.iso
using (Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "ConvertToNKit.exe");
wit.StartInfo.Arguments = $"\"{romPath}\"";
wit.Start();
wit.WaitForExit();
if (!File.Exists(Path.Combine(toolsPath, "out.nkit.iso")))
{
throw new Exception("nkit");
}
File.Move(Path.Combine(toolsPath, "out.nkit.iso"), Path.Combine(tempPath, "TempBase", "files", "game.iso"));
}
}
else
{
File.Copy(romPath, Path.Combine(tempPath, "TempBase", "files", "game.iso"));
}
}
}
if (mvm.gc2rom != "" && File.Exists(mvm.gc2rom))
{
if (mvm.donttrim)
{
if (mvm.gc2rom.Contains("nkit"))
{
using (Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "ConvertToIso.exe");
wit.StartInfo.Arguments = $"\"{mvm.gc2rom}\"";
wit.Start();
wit.WaitForExit();
if (!File.Exists(Path.Combine(toolsPath, "out(Disc 1).iso")))
{
throw new Exception("nkit");
}
File.Move(Path.Combine(toolsPath, "out(Disc 1).iso"), Path.Combine(tempPath, "TempBase", "files", "disc2.iso"));
}
}
else
{
File.Copy(mvm.gc2rom, Path.Combine(tempPath, "TempBase", "files", "disc2.iso"));
}
}
else{
if (mvm.gc2rom.ToLower().Contains("iso") || mvm.gc2rom.ToLower().Contains("gcm"))
{
//convert to nkit
using (Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "ConvertToNKit.exe");
wit.StartInfo.Arguments = $"\"{mvm.gc2rom}\"";
wit.Start();
wit.WaitForExit();
if (!File.Exists(Path.Combine(toolsPath, "out(Disc 1).nkit.iso")))
{
throw new Exception("nkit");
}
File.Move(Path.Combine(toolsPath, "out(Disc 1).nkit.iso"), Path.Combine(tempPath, "TempBase", "files", "disc2.iso"));
}
}
else
{
if (romPath.ToLower().Contains("gcz"))
{
//Convert to nkit.iso
using (Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "ConvertToNKit.exe");
wit.StartInfo.Arguments = $"\"{romPath}\"";
wit.Start();
wit.WaitForExit();
if (!File.Exists(Path.Combine(toolsPath, "out(Disc 1).nkit.iso")))
{
throw new Exception("nkit");
}
File.Move(Path.Combine(toolsPath, "out(Disc 1).nkit.iso"), Path.Combine(tempPath, "TempBase", "files", "disc2.iso"));
}
}
else
{
File.Copy(romPath, Path.Combine(tempPath, "TempBase", "files", "disc2.iso"));
}
}
}
}
using(Process wit = new Process())
{
if (!mvm.debug)
{
wit.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
wit.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
wit.StartInfo.Arguments = $"copy \"{Path.Combine(tempPath, "TempBase")}\" --DEST \"{Path.Combine(tempPath, "game.iso")}\" -ovv --links --iso";
wit.Start();
wit.WaitForExit();
}
Thread.Sleep(6000);
if (!File.Exists(Path.Combine(tempPath, "game.iso")))
{
Console.Clear();
throw new Exception("WIIAn error occured while Creating the ISO");
}
Directory.Delete(Path.Combine(tempPath, "TempBase"), true);
romPath = Path.Combine(tempPath, "game.iso");
mvvm.Progress = 50;
mvm.msg = "Replacing TIK and TMD...";
using (Process extract = new Process())
{
if (!mvm.debug)
{
extract.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
extract.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
extract.StartInfo.Arguments = $"extract \"{Path.Combine(tempPath, "game.iso")}\" --psel data --files +tmd.bin --files +ticket.bin --DEST \"{Path.Combine(tempPath, "TIKTMD")}\" -vv1";
extract.Start();
extract.WaitForExit();
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "code"), "rvlt.*"))
{
File.Delete(sFile);
}
File.Copy(Path.Combine(tempPath, "TIKTMD", "tmd.bin"), Path.Combine(baseRomPath, "code", "rvlt.tmd"));
File.Copy(Path.Combine(tempPath, "TIKTMD", "ticket.bin"), Path.Combine(baseRomPath, "code", "rvlt.tik"));
Directory.Delete(Path.Combine(tempPath, "TIKTMD"), true);
}
mvm.Progress = 60;
mvm.msg = "Injecting ROM...";
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "content"), "*.nfs"))
{
File.Delete(sFile);
}
File.Move(Path.Combine(tempPath, "game.iso"), Path.Combine(baseRomPath, "content", "game.iso"));
File.Copy(Path.Combine(toolsPath, "nfs2iso2nfs.exe"), Path.Combine(baseRomPath, "content", "nfs2iso2nfs.exe"));
Directory.SetCurrentDirectory(Path.Combine(baseRomPath, "content"));
using (Process iso2nfs = new Process())
{
if (!mvm.debug)
{
iso2nfs.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
}
iso2nfs.StartInfo.FileName = "nfs2iso2nfs.exe";
iso2nfs.StartInfo.Arguments = $"-enc -homebrew -passthrough -iso game.iso";
iso2nfs.Start();
iso2nfs.WaitForExit();
File.Delete("nfs2iso2nfs.exe");
File.Delete("game.iso");
}
Directory.SetCurrentDirectory(savedir);
mvm.Progress = 80;
}
private static void WIIold(string romPath, MainViewModel mvm, bool force)
{
mvvm.msg = "Removing unnecessary Files...";
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "content"), "*.nfs"))
{
File.Delete(sFile);
}
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "meta"), "*.jpg"))
{
File.Delete(sFile);
}
foreach (string sFile in Directory.GetFiles(Path.Combine(baseRomPath, "meta"), "*.bfma"))
{
File.Delete(sFile);
}
if (File.Exists(Path.Combine(baseRomPath, "code", "rvlt.tmd"))) File.Delete(Path.Combine(baseRomPath, "code", "rvlt.tmd"));
if (File.Exists(Path.Combine(baseRomPath, "code", "rvlt.tik"))) File.Delete(Path.Combine(baseRomPath, "code", "rvlt.tik"));
mvvm.Progress = 15;
Console.WriteLine("Finished removing Files");
using (Process tik = new Process())
{
if (!mvm.debug)
{
tik.StartInfo.UseShellExecute = false;
tik.StartInfo.CreateNoWindow = true;
}
if (!mvm.GC)
{
if (new FileInfo(romPath).Extension.Contains("wbfs"))
{
mvvm.msg = "Converting WBFS to ISO...";
Console.WriteLine("Converting WBFS to ISO...");
tik.StartInfo.FileName = Path.Combine(toolsPath, "wbfs_file.exe");
tik.StartInfo.Arguments = $"\"{romPath}\" convert \"{Path.Combine(tempPath, "pre.iso")}\"";
tik.Start();
tik.WaitForExit();
if (!File.Exists(Path.Combine(tempPath, "pre.iso")))
{
throw new Exception("WIIAn error occured while converting WBFS to ISO");
}
if (File.Exists(Path.Combine(tempPath, "rom.wbfs"))) { File.Delete(Path.Combine(tempPath, "rom.wbfs")); }
romPath = Path.Combine(tempPath, "pre.iso");
Console.WriteLine("Finished Conversion");
mvvm.Progress = 20;
}
tik.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
mvvm.msg = "Trimming ROM...";
Console.WriteLine("Trimming ROM...");
tik.StartInfo.Arguments = $"extract \"{romPath}\" --DEST \"{Path.Combine(tempPath, "IsoExt")}\" --psel data -vv1";
tik.Start();
tik.WaitForExit();
if (!Directory.Exists(Path.Combine(tempPath, "IsoExt")))
{
throw new Exception("WIIAn error occured while trimming the ROM");
}
mvvm.Progress = 40;
Console.WriteLine("Finished trimming");
if (mvm.Index == 4)
{
mvvm.msg = "Patching ROM (Force CC)...";
Console.WriteLine("Patching the ROM to force Classic Controller input");
tik.StartInfo.FileName = Path.Combine(toolsPath, "GetExtTypePatcher.exe");
tik.StartInfo.Arguments = $"\"{Path.Combine(tempPath, "IsoExt", "sys", "main.dol")}\"";
tik.Start();
tik.WaitForExit();
tik.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
mvvm.Progress = 45;
}
if (mvm.Patch)
{
mvvm.msg = "Video Patching ROM...";
using (Process process = new Process())
{
process.StartInfo.FileName = Path.Combine(toolsPath,"wii-vmc.exe");
process.StartInfo.Arguments = $"\"{Path.Combine(tempPath, "IsoExt", "sys", "main.dol")}\"";
//process.StartInfo.RedirectStandardInput = true;
// process.StartInfo.UseShellExecute = false;
// process.StartInfo.CreateNoWindow = true;
process.Start();
/* Thread.Sleep(2000);
process.StandardInput.WriteLine("a");
Thread.Sleep(2000);
if (mvm.toPal)
{
process.StandardInput.WriteLine("1");
}
else
{
process.StandardInput.WriteLine("2");
}
Thread.Sleep(2000);
process.StandardInput.WriteLine();
*/
process.WaitForExit();
}
mvvm.Progress = 50;
}
mvvm.msg = "Creating ISO from trimmed ROM...";
Console.WriteLine("Creating ISO from trimmed ROM...");
tik.StartInfo.Arguments = $"copy \"{Path.Combine(tempPath, "IsoExt")}\" --DEST \"{Path.Combine(tempPath, "game.iso")}\" -ovv --links --iso";
tik.Start();
tik.WaitForExit();
if (!File.Exists(Path.Combine(tempPath, "game.iso")))
{
throw new Exception("WIIAn error occured while Creating the ISO");
}
romPath = Path.Combine(tempPath, "game.iso");
mvvm.Progress = 60;
}
else
{
mvvm.msg = "Extracting Nintendont Base...";
if (Directory.Exists(Path.Combine(tempPath, "TempBase"))) Directory.Delete(Path.Combine(tempPath, "TempBase"), true);
Directory.CreateDirectory(Path.Combine(tempPath, "TempBase"));
tik.StartInfo.FileName = Path.Combine(toolsPath, "7za.exe");
tik.StartInfo.Arguments = $"x \"{Path.Combine(toolsPath, "BASE.zip")}\" -o\"{Path.Combine(tempPath)}\"";
tik.Start();
tik.WaitForExit();
DirectoryCopy(Path.Combine(tempPath, "BASE"), Path.Combine(tempPath, "TempBase"), true);
mvvm.Progress = 30;
mvvm.msg = "Applying Nintendont";
if (force)
{
mvvm.msg += " force 4:3...";
File.Copy(Path.Combine(toolsPath, "nintendont_force.dol"), Path.Combine(tempPath, "TempBase", "sys", "main.dol"));
}
else
{
mvvm.msg += "...";
File.Copy(Path.Combine(toolsPath, "nintendont.dol"), Path.Combine(tempPath, "TempBase", "sys", "main.dol"));
}
mvm.Progress = 40;
mvvm.msg = "Injecting GameCube Game into NintendontBase...";
File.Copy(romPath, Path.Combine(tempPath, "TempBase", "files", "game.iso"));
Thread.Sleep(6000);
tik.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
tik.StartInfo.Arguments = $"copy \"{Path.Combine(tempPath, "TempBase")}\" --DEST \"{Path.Combine(tempPath, "game.iso")}\" -ovv --links --iso";
tik.Start();
tik.WaitForExit();
Thread.Sleep(6000);
if (!File.Exists(Path.Combine(tempPath, "game.iso")))
{
Console.Clear();
throw new Exception("WIIAn error occured while Creating the ISO");
}
romPath = Path.Combine(tempPath, "game.iso");
mvvm.Progress = 60;
}
mvvm.msg = "Extracting Ticket and TMD from ISO...";
tik.StartInfo.FileName = Path.Combine(toolsPath, "wit.exe");
tik.StartInfo.Arguments = $"extract \"{romPath}\" --psel data --files +tmd.bin --files +ticket.bin --dest \"{Path.Combine(tempPath, "tik")}\" -vv1";
tik.Start();
tik.WaitForExit();
if (!Directory.Exists(Path.Combine(tempPath, "tik")) || !File.Exists(Path.Combine(tempPath, "tik", "tmd.bin")) || !File.Exists(Path.Combine(tempPath, "tik", "ticket.bin")))
{
throw new Exception("WIIAn error occured while extracting the Ticket and TMD");
}
Console.WriteLine("Finished extracting");
mvvm.Progress = 65;
mvvm.msg = "Copying TIK and TMD...";
Console.WriteLine("Copying TIK and TMD...");
if (File.Exists(Path.Combine(baseRomPath, "code", "rvlt.tmd"))) { File.Delete(Path.Combine(baseRomPath, "code", "rvlt.tmd")); }
File.Copy(Path.Combine(tempPath, "tik", "tmd.bin"), Path.Combine(baseRomPath, "code", "rvlt.tmd"));
if (File.Exists(Path.Combine(baseRomPath, "code", "rvlt.tik"))) { File.Delete(Path.Combine(baseRomPath, "code", "rvlt.tik")); }
File.Copy(Path.Combine(tempPath, "tik", "ticket.bin"), Path.Combine(baseRomPath, "code", "rvlt.tik"));
if (!File.Exists(Path.Combine(baseRomPath, "code", "rvlt.tik")) || !File.Exists(Path.Combine(baseRomPath, "code", "rvlt.tmd")))
{
Console.Clear();
throw new Exception("WIIAn error occured while copying the Ticket and TMD");
}
Console.WriteLine("Finished Copying");
mvvm.Progress = 70;
Thread.Sleep(6000);
mvvm.msg = "Injecting ROM...";
Console.WriteLine("Converting Game to NFS format...");
string olddir = Directory.GetCurrentDirectory();
Directory.SetCurrentDirectory(Path.Combine(baseRomPath, "content"));
tik.StartInfo.FileName = Path.Combine(toolsPath, "nfs2iso2nfs.exe");
if (!mvm.GC)
{
string extra = "";
if (mvm.Index == 2)
{
extra = "-horizontal ";
}
if (mvm.Index == 3) { extra = "-wiimote "; }
if (mvm.Index == 4) { extra = "-instantcc "; }
if (mvm.Index == 5) { extra = "-nocc "; }
if (mvm.LR) { extra += "-lrpatch "; }
Console.WriteLine(extra);
Console.ReadLine();
tik.StartInfo.Arguments = $"-enc {extra}-iso \"{romPath}\"";
}
else
{
tik.StartInfo.Arguments = $"-enc -homebrew -passthrough -iso \"{romPath}\"";
}
tik.Start();
tik.WaitForExit();
Console.WriteLine("Finished Conversion");
mvvm.Progress = 80;
Directory.SetCurrentDirectory(olddir);
}
}
public static void MSX(string injectRomPath)
{
mvvm.msg = "Reading Header from Base...";
byte[] test = new byte[0x580B3];
using (var fs = new FileStream(Path.Combine(baseRomPath, "content" , "msx", "msx.pkg"),
FileMode.Open,
FileAccess.ReadWrite))
{
fs.Read(test, 0, 0x580B3);
fs.Close();
File.Delete(Path.Combine(baseRomPath, "content", "msx", "msx.pkg"));
}
mvvm.Progress = 20;
mvvm.msg = "Creating new PKG with read Header...";
using (var fs = new FileStream(Path.Combine(baseRomPath, "content", "msx", "msx.pkg"),
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
{
fs.Write(test, 0, 0x580B3);
fs.Close();
}
mvvm.Progress = 30;
mvvm.msg = "Reading ROM content...";
using (var fs = new FileStream(injectRomPath,
FileMode.OpenOrCreate,
FileAccess.ReadWrite))
{
test = new byte[fs.Length];
fs.Read(test, 0, test.Length - 1);
}
mvvm.Progress = 50;
mvvm.msg = "Injecting ROM into new PKG...";
using (var fs = new FileStream(Path.Combine(baseRomPath, "content", "msx", "msx.pkg"),
FileMode.Append))
{
fs.Write(test, 0, test.Length);
}
mvvm.Progress = 80;
}
public static void DeleteDirectory(string path)
{
foreach (string directory in Directory.GetDirectories(path))
{
DeleteDirectory(directory);
}
try
{
Thread.Sleep(0);
Directory.Delete(path, true);
}
catch (IOException)
{
Directory.Delete(path, true);
}
catch (UnauthorizedAccessException)
{
Directory.Delete(path, true);
}
}
public static void Clean()
{
if (Directory.Exists(tempPath))
{
DeleteDirectory(tempPath);
}
}
[STAThread]
public static void Loadiine(string gameName)
{
if (gameName == null || gameName == string.Empty) gameName = "NoName";
gameName = gameName.Replace("|", " ");
Regex reg = new Regex("[^a-zA-Z0-9 é -]");
//string outputPath = Path.Combine(Properties.Settings.Default.InjectionPath, gameName);
string outputPath = Path.Combine(Properties.Settings.Default.OutPath, $"[LOADIINE]{reg.Replace(gameName,"")} [{mvvm.prodcode}]");
mvvm.foldername = $"[LOADIINE]{reg.Replace(gameName, "")} [{mvvm.prodcode}]";
int i = 0;
while (Directory.Exists(outputPath))
{
outputPath = Path.Combine(Properties.Settings.Default.OutPath, $"[LOADIINE]{reg.Replace(gameName, "")} [{mvvm.prodcode}]_{i}");
mvvm.foldername = $"[LOADIINE]{reg.Replace(gameName, "")} [{mvvm.prodcode}]_{i}";
i++;
}
DirectoryCopy(baseRomPath,outputPath, true);
Custom_Message cm = new Custom_Message("Injection Complete", $"To Open the Location of the Inject press Open Folder.\nIf you want the inject to be put on your SD now, press Copy to SD.", Settings.Default.OutPath);
try
{
cm.Owner = mvvm.mw;
}catch(Exception )
{
}
cm.ShowDialog();
Clean();
}
[STAThread]
public static void Packing(string gameName, MainViewModel mvm)
{
mvm.msg = "Checking Tools...";
mvm.InjcttoolCheck();
mvm.Progress = 20;
mvm.msg = "Creating Outputfolder...";
Regex reg = new Regex("[^a-zA-Z0-9 -]");
if (gameName == null || gameName == string.Empty) gameName = "NoName";
//string outputPath = Path.Combine(Properties.Settings.Default.InjectionPath, gameName);
string outputPath = Path.Combine(Properties.Settings.Default.OutPath, $"[WUP]{reg.Replace(gameName,"").Replace("|", " ")}");
outputPath = outputPath.Replace("|", " ");
mvvm.foldername = $"[WUP]{reg.Replace(gameName, "").Replace("|"," ")}";
int i = 0;
while (Directory.Exists(outputPath))
{
outputPath = Path.Combine(Properties.Settings.Default.OutPath, $"[WUP]{reg.Replace(gameName,"").Replace("|", " ")}_{i}");
mvvm.foldername = $"[WUP]{reg.Replace(gameName, "").Replace("|", " ")}_{i}";
i++;
}
var oldpath = Directory.GetCurrentDirectory();
mvm.Progress = 40;
mvm.msg = "Packing...";
try
{
Directory.Delete(Environment.GetEnvironmentVariable("LocalAppData") + @"\temp\.net\CNUSPACKER", true);
}
catch { }
using (Process cnuspacker = new Process())
{
if (!mvm.debug)
{
cnuspacker.StartInfo.UseShellExecute = false;
cnuspacker.StartInfo.CreateNoWindow = true;
}
if (Environment.Is64BitOperatingSystem)
{
cnuspacker.StartInfo.FileName = Path.Combine(toolsPath, "CNUSPACKER.exe");
cnuspacker.StartInfo.Arguments = $"-in \"{baseRomPath}\" -out \"{outputPath}\" -encryptKeyWith {Properties.Settings.Default.Ckey}";
}
else
{
cnuspacker.StartInfo.FileName = "java";
cnuspacker.StartInfo.Arguments = $"-jar \"{Path.Combine(toolsPath, "NUSPacker.jar")}\" -in \"{baseRomPath}\" -out \"{outputPath}\" -encryptKeyWith {Properties.Settings.Default.Ckey}";
}
cnuspacker.Start();
cnuspacker.WaitForExit();
Directory.SetCurrentDirectory(oldpath);
}
mvm.Progress = 90;
mvm.msg = "Cleaning...";
Clean();
mvm.Progress = 100;
mvm.msg = "";
}
public static void Download(MainViewModel mvm)
{
mvm.InjcttoolCheck();
GameBases b = mvm.getBasefromName(mvm.SelectedBaseAsString);
//GetKeyOfBase
TKeys key = mvm.getTkey(b);
if (mvm.GameConfiguration.Console == GameConsoles.WII || mvm.GameConfiguration.Console == GameConsoles.GCN)
{
using (Process zip = new Process())
{
if (Directory.Exists(tempPath)) Directory.Delete(tempPath, true);
Directory.CreateDirectory(tempPath);
using (Process download = new Process())
{
if (!mvm.debug)
{
download.StartInfo.UseShellExecute = false;
download.StartInfo.CreateNoWindow = true;
}
download.StartInfo.FileName = Path.Combine(toolsPath, "WiiUDownloader.exe");
download.StartInfo.Arguments = $"{b.Tid} {key.Tkey} \"{Path.Combine(tempPath, "download")}\"";
download.Start();
download.WaitForExit();
}
mvm.Progress = 75;
using (Process decrypt = new Process())
{
if (!mvm.debug)
{
decrypt.StartInfo.UseShellExecute = false;
decrypt.StartInfo.CreateNoWindow = true;
}
decrypt.StartInfo.FileName = Path.Combine(toolsPath, "Cdecrypt.exe");
decrypt.StartInfo.Arguments = $"{Properties.Settings.Default.Ckey} \"{Path.Combine(tempPath, "download")}\" \"{Path.Combine(Properties.Settings.Default.BasePath, $"{b.Name.Replace(":", "")} [{b.Region.ToString()}]")}\"";
decrypt.Start();
decrypt.WaitForExit();
}
mvm.Progress += 10;
foreach (string sFile in Directory.GetFiles(Path.Combine(Properties.Settings.Default.BasePath, $"{b.Name.Replace(":", "")} [{b.Region.ToString()}]", "content"), "*.nfs"))
{
File.Delete(sFile);
}
/* File.Delete(Path.Combine(Properties.Settings.Default.BasePath, $"{b.Name.Replace(":", "")} [{b.Region.ToString()}]", "code", "fw.img"));
File.Delete(Path.Combine(Properties.Settings.Default.BasePath, $"{b.Name.Replace(":", "")} [{b.Region.ToString()}]", "code", "fw.tmd"));
if (Directory.Exists(Path.Combine(toolsPath, "IKVM"))) { Directory.Delete(Path.Combine(toolsPath, "IKVM"), true); }
if (!mvm.debug)
{
zip.StartInfo.UseShellExecute = false;
zip.StartInfo.CreateNoWindow = true;
}
zip.StartInfo.FileName = Path.Combine(toolsPath, "7za.exe");
zip.StartInfo.Arguments = $"x \"{Path.Combine(toolsPath, "IKVM.zip")}\" -o\"{Path.Combine(toolsPath, "IKVM")}\"";
zip.Start();
zip.WaitForExit();
mvm.Progress += 10;
string[] JNUSToolConfig = { "http://ccs.cdn.wup.shop.nintendo.net/ccs/download", Properties.Settings.Default.Ckey };
string savedir = Directory.GetCurrentDirectory();
File.WriteAllLines(Path.Combine(toolsPath, "IKVM", "config"), JNUSToolConfig);
Directory.SetCurrentDirectory(Path.Combine(toolsPath, "IKVM"));
zip.StartInfo.FileName = "JNUSTool.exe";
zip.StartInfo.Arguments = $"{b.Tid} {key.Tkey} -file /code/fw.img";
zip.Start();
zip.WaitForExit();
zip.StartInfo.Arguments = $"{b.Tid} {key.Tkey} -file /code/fw.tmd";
zip.Start();
zip.WaitForExit();
Directory.SetCurrentDirectory(savedir);
var directories = Directory.GetDirectories(Path.Combine(toolsPath, "IKVM"));
string name = "";
foreach (var s in directories)
{
if (s.Contains(b.Name))
{
var split = s.Split('\\');
name = split[split.Length - 1];
}
}
File.Copy(Path.Combine(toolsPath, "IKVM", name, "code", "fw.img"), Path.Combine(Properties.Settings.Default.BasePath, $"{b.Name.Replace(":", "")} [{b.Region.ToString()}]", "code", "fw.img"));
File.Copy(Path.Combine(toolsPath, "IKVM", name, "code", "fw.tmd"), Path.Combine(Properties.Settings.Default.BasePath, $"{b.Name.Replace(":", "")} [{b.Region.ToString()}]", "code", "fw.tmd"));
Directory.Delete(Path.Combine(toolsPath, "IKVM"), true);*/
mvm.Progress += 15;
}
}
else
{
if (Directory.Exists(tempPath)) Directory.Delete(tempPath, true);
Directory.CreateDirectory(tempPath);
using (Process download = new Process())
{
if (!mvm.debug)
{
download.StartInfo.UseShellExecute = false;
download.StartInfo.CreateNoWindow = true;
}
download.StartInfo.FileName = Path.Combine(toolsPath, "WiiUDownloader.exe");
download.StartInfo.Arguments = $"{b.Tid} {key.Tkey} \"{Path.Combine(tempPath, "download")}\"";
download.Start();
download.WaitForExit();
}
mvm.Progress = 75;
using (Process decrypt = new Process())
{
if (!mvm.debug)
{
decrypt.StartInfo.UseShellExecute = false;
decrypt.StartInfo.CreateNoWindow = true;
}
decrypt.StartInfo.FileName = Path.Combine(toolsPath, "Cdecrypt.exe");
decrypt.StartInfo.Arguments = $"{Properties.Settings.Default.Ckey} \"{Path.Combine(tempPath, "download")}\" \"{Path.Combine(Properties.Settings.Default.BasePath, $"{b.Name.Replace(":", "")} [{b.Region.ToString()}]")}\"";
decrypt.Start();
decrypt.WaitForExit();
}
mvm.Progress = 100;
}
//GetCurrentSelectedBase
}
public static string ExtractBase(string path, GameConsoles console)
{
if(!Directory.Exists(Path.Combine(Properties.Settings.Default.BasePath, "CustomBases")))
{
Directory.CreateDirectory(Path.Combine(Properties.Settings.Default.BasePath, "CustomBases"));
}
string outputPath = Path.Combine(Properties.Settings.Default.BasePath, "CustomBases", $"[{console.ToString()}] Custom");
int i = 0;
while (Directory.Exists(outputPath))
{
outputPath = Path.Combine(Properties.Settings.Default.BasePath, $"[{console.ToString()}] Custom_{i}");
i++;
}
using (Process decrypt = new Process())
{
decrypt.StartInfo.UseShellExecute = false;
decrypt.StartInfo.CreateNoWindow = true;
decrypt.StartInfo.FileName = Path.Combine(toolsPath, "Cdecrypt.exe");
decrypt.StartInfo.Arguments = $"{Properties.Settings.Default.Ckey} \"{path}\" \"{outputPath}";
decrypt.Start();
decrypt.WaitForExit();
}
return outputPath;
}
// This function changes TitleID, ProductCode and GameName in app.xml (ID) and meta.xml (ID, ProductCode, Name)
private static void EditXML(string gameNameOr, int index, string code)
{
string gameName = string.Empty;
if(gameNameOr != null || !String.IsNullOrWhiteSpace(gameNameOr))
{
gameName = gameNameOr;
if (gameName.Contains('|'))
{
var split = gameName.Split('|');
gameName = split[0] + "," + split[1];
}
}
string metaXml = Path.Combine(baseRomPath, "meta", "meta.xml");
string appXml = Path.Combine(baseRomPath, "code", "app.xml");
Random random = new Random();
string ID = $"{random.Next(0x3000, 0x10000):X4}{random.Next(0x3000, 0x10000):X4}";
string ID2 = $"{random.Next(0x3000, 0x10000):X4}";
mvvm.prodcode = ID2;
XmlDocument doc = new XmlDocument();
try
{
doc.Load(metaXml);
if (gameName != null && gameName != string.Empty)
{
doc.SelectSingleNode("menu/longname_ja").InnerText = gameName.Replace(",", "\n" );
doc.SelectSingleNode("menu/longname_en").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_fr").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_de").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_it").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_es").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_zhs").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_ko").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_nl").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_pt").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_ru").InnerText = gameName.Replace(",", "\n");
doc.SelectSingleNode("menu/longname_zht").InnerText = gameName.Replace(",", "\n");
}
/* if(code != null)
{
doc.SelectSingleNode("menu/product_code").InnerText = $"WUP-N-{code}";
}
else
{*/
doc.SelectSingleNode("menu/product_code").InnerText = $"WUP-N-{ID2}";
//}
if (index > 0)
{
doc.SelectSingleNode("menu/drc_use").InnerText = "65537";
}
doc.SelectSingleNode("menu/title_id").InnerText = $"00050002{ID}";
doc.SelectSingleNode("menu/group_id").InnerText = $"0000{ID2}";
if (gameName != null && gameName != string.Empty)
{
doc.SelectSingleNode("menu/shortname_ja").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_fr").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_de").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_en").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_it").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_es").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_zhs").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_ko").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_nl").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_pt").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_ru").InnerText = gameName.Split(',')[0];
doc.SelectSingleNode("menu/shortname_zht").InnerText = gameName.Split(',')[0];
}
doc.Save(metaXml);
}
catch (NullReferenceException)
{
}
try
{
doc.Load(appXml);
doc.SelectSingleNode("app/title_id").InnerText = $"00050002{ID}";
//doc.SelectSingleNode("app/title_id").InnerText = $"0005000247414645";
doc.SelectSingleNode("app/group_id").InnerText = $"0000{ID2}";
doc.Save(appXml);
}
catch (NullReferenceException)
{
}
}
//This function copies the custom or normal Base to the working directory
private static void CopyBase(string baserom, string customPath)
{
if (Directory.Exists(baseRomPath)) // sanity check
{
Directory.Delete(baseRomPath, true);
}
if (baserom == "Custom")
{
DirectoryCopy(customPath, baseRomPath, true);
}
else
{
DirectoryCopy(Path.Combine(Properties.Settings.Default.BasePath, baserom), baseRomPath, true);
}
}
private static void TG16(string injectRomPath)
{
//checking if folder
if (Directory.Exists(injectRomPath))
{
DirectoryCopy(injectRomPath, "test", true);
//TurboGrafCD
using (Process TurboInject = new Process())
{
mvvm.msg = "Creating TurboCD Pkg...";
TurboInject.StartInfo.UseShellExecute = false;
TurboInject.StartInfo.CreateNoWindow = true;
TurboInject.StartInfo.FileName = Path.Combine(toolsPath, "BuildTurboCDPcePkg.exe");
TurboInject.StartInfo.Arguments = $"test";
TurboInject.Start();
TurboInject.WaitForExit();
mvvm.Progress = 70;
}
Directory.Delete("test", true);
}
else
{
//creating pkg file including the TG16 rom
using (Process TurboInject = new Process())
{
mvvm.msg = "Creating Turbo16 Pkg...";
TurboInject.StartInfo.UseShellExecute = false;
TurboInject.StartInfo.CreateNoWindow = true;
TurboInject.StartInfo.FileName = Path.Combine(toolsPath, "BuildPcePkg.exe");
TurboInject.StartInfo.Arguments = $"\"{injectRomPath}\"";
TurboInject.Start();
TurboInject.WaitForExit();
mvvm.Progress = 70;
}
}
mvvm.msg = "Injecting ROM...";
//replacing tg16 rom
File.Delete(Path.Combine(baseRomPath, "content", "pceemu", "pce.pkg"));
File.Copy("pce.pkg", Path.Combine(baseRomPath, "content", "pceemu", "pce.pkg"));
File.Delete("pce.pkg");
mvvm.Progress = 80;
}
private static void NESSNES(string injectRomPath)
{
string rpxFile = Directory.GetFiles(Path.Combine(baseRomPath, "code"), "*.rpx")[0]; //To get the RPX path where the NES/SNES rom needs to be Injected in
mvvm.msg = "Decompressing RPX...";
RPXdecomp(rpxFile); //Decompresses the RPX to be able to write the game into it
mvvm.Progress = 20;
if (mvvm.pixelperfect)
{
using (Process retroinject = new Process())
{
mvvm.msg = "Applying Pixel Perfect Patches...";
retroinject.StartInfo.UseShellExecute = false;
retroinject.StartInfo.CreateNoWindow = true;
retroinject.StartInfo.RedirectStandardOutput = true;
retroinject.StartInfo.RedirectStandardError = true;
retroinject.StartInfo.FileName = Path.Combine(toolsPath, "ChangeAspectRatio.exe");
retroinject.StartInfo.Arguments = $"\"{rpxFile}\"";
retroinject.Start();
retroinject.WaitForExit();
mvvm.Progress = 30;
}
}
using (Process retroinject = new Process())
{
mvvm.msg = "Injecting ROM...";
retroinject.StartInfo.UseShellExecute = false;
retroinject.StartInfo.CreateNoWindow = true;
retroinject.StartInfo.RedirectStandardOutput = true;
retroinject.StartInfo.RedirectStandardError = true;
retroinject.StartInfo.FileName = Path.Combine(toolsPath, "retroinject.exe");
retroinject.StartInfo.Arguments = $"\"{rpxFile}\" \"{injectRomPath}\" \"{rpxFile}\"";
retroinject.Start();
retroinject.WaitForExit();
mvvm.Progress = 70;
var s = retroinject.StandardOutput.ReadToEnd();
var e = retroinject.StandardError.ReadToEnd();
if (e.Contains("is too large") || s.Contains("is too large"))
{
mvvm.Progress = 100;
throw new Exception("retro");
}
}
mvvm.msg = "Compressing RPX...";
RPXcomp(rpxFile); //Compresses the RPX
mvvm.Progress = 80;
}
private static void GBA(string injectRomPath, N64Conf config)
{
bool delete = false;
if(!new FileInfo(injectRomPath).Extension.Contains("gba"))
{
//it's a GBC or GB rom so it needs to be copied into goomba.gba and then padded to 32Mb (16 would work too but just ot be save)
using (Process goomba = new Process())
{
mvvm.msg = "Injecting GB/GBC ROM into goomba...";
goomba.StartInfo.UseShellExecute = false;
goomba.StartInfo.CreateNoWindow = true;
goomba.StartInfo.FileName = "cmd.exe";
goomba.StartInfo.Arguments = $"/c copy /b \"{Path.Combine(toolsPath, "goomba.gba")}\"+\"{injectRomPath}\" \"{Path.Combine(toolsPath, "goombamenu.gba")}\"";
goomba.Start();
goomba.WaitForExit();
mvvm.Progress = 20;
}
mvvm.msg = "Padding goomba ROM...";
//padding
byte[] rom = new byte[33554432];
FileStream fs = new FileStream(Path.Combine(toolsPath, "goombamenu.gba"), FileMode.Open);
fs.Read(rom, 0, (int)fs.Length);
fs.Close();
File.WriteAllBytes(Path.Combine(toolsPath, "goombaPadded.gba"), rom);
Console.ReadLine();
injectRomPath = Path.Combine(toolsPath, "goombaPadded.gba");
delete = true;
mvvm.Progress = 40;
}
if (mvvm.PokePatch)
{
mvvm.msg = "Applying PokePatch";
File.Copy(injectRomPath, Path.Combine(tempPath, "rom.gba"));
injectRomPath = Path.Combine(tempPath, "rom.gba");
PokePatch(injectRomPath);
delete = true;
mvvm.PokePatch = false;
mvvm.Progress = 40;
}
var allDataPath = Path.Combine(baseRomPath, "content", "alldata.psb.m");
if (config.DarkFilter == false)
{
//my dumb af way to ensure everything starts fresh and doesn't throw an error
try
{
Directory.Delete(Directory.GetCurrentDirectory() + @"\psbout", true);
}
catch { }
try
{
File.Delete(Directory.GetCurrentDirectory() + @"\mod_alldata.psb.m");
}
catch { }
try
{
File.Delete(Directory.GetCurrentDirectory() + @"\mod_alldata.bin");
}
catch { }
var packer = new MArchivePacker(new ZlibCodec(), "MX8wgGEJ2+M47", 80);
AllDataPacker.UnpackFiles(allDataPath, "psbout", packer);
var lastModDirect = new DirectoryInfo("psbout").GetDirectories().OrderByDescending(d => d.LastWriteTimeUtc).LastOrDefault();
packer.DecompressFile(Directory.GetCurrentDirectory() + @"\psbout\" + lastModDirect + @"\config\title_prof.psb.m");
packer.CompressFile(Directory.GetCurrentDirectory() + @"\psbout\" + lastModDirect + @"\config\title_prof.psb");
AllDataPacker.Build("psbout", "mod_alldata", packer);
allDataPath = Directory.GetCurrentDirectory() + @"\mod_alldata.psb.m";
}
var outputAllDataPath = Path.Combine(baseRomPath, "content", "alldata.psb.m");
using (Process psb = new Process())
{
mvvm.msg = "Injecting ROM...";
psb.StartInfo.UseShellExecute = false;
psb.StartInfo.CreateNoWindow = true;
psb.StartInfo.FileName = Path.Combine(toolsPath, "psb.exe");
psb.StartInfo.Arguments = $"\"{allDataPath}\" \"{injectRomPath}\" \"{outputAllDataPath}\"";
psb.Start();
psb.WaitForExit();
mvvm.Progress = 80;
}
if (delete)
{
File.Delete(injectRomPath);
if(File.Exists(Path.Combine(toolsPath, "goombamenu.gba")))File.Delete(Path.Combine(toolsPath, "goombamenu.gba"));
}
}
private static void DownloadSysTitle(MainViewModel mvm)
{
if (mvm.SysKeyset() && mvm.SysKey1set())
{
using (Process download = new Process())
{
download.StartInfo.FileName = Path.Combine(toolsPath, "WiiUDownloader.exe");
download.StartInfo.Arguments = $"0005001010004001 {Properties.Settings.Default.SysKey} \"{Path.Combine(tempPath, "download")}\"";
download.Start();
download.WaitForExit();
}
using (Process decrypt = new Process())
{
decrypt.StartInfo.FileName = Path.Combine(toolsPath, "Cdecrypt.exe");
decrypt.StartInfo.Arguments = $"{Properties.Settings.Default.Ckey} \"{Path.Combine(tempPath, "download")}\" \"{Path.Combine(Properties.Settings.Default.BasePath, $"vwiisys")}\"";
decrypt.Start();
decrypt.WaitForExit();
}
using (Process download = new Process())
{
Directory.Delete(Path.Combine(tempPath, "download"), true);
download.StartInfo.FileName = Path.Combine(toolsPath, "WiiUDownloader.exe");
download.StartInfo.Arguments = $"0005001010004000 {Properties.Settings.Default.SysKey1} \"{Path.Combine(tempPath, "download")}\"";
download.Start();
download.WaitForExit();
}
using (Process decrypt = new Process())
{
decrypt.StartInfo.FileName = Path.Combine(toolsPath, "Cdecrypt.exe");
decrypt.StartInfo.Arguments = $"{Properties.Settings.Default.Ckey} \"{Path.Combine(tempPath, "download")}\" \"{Path.Combine(tempPath, "tempd")}\"";
decrypt.Start();
decrypt.WaitForExit();
File.Copy(Path.Combine(tempPath, "tempd", "code", "font.bin"), Path.Combine(Properties.Settings.Default.BasePath, $"vwiisys", "code", "font.bin"));
File.Copy(Path.Combine(tempPath, "tempd", "code", "deint.txt"), Path.Combine(Properties.Settings.Default.BasePath, $"vwiisys", "code", "deint.txt"));
File.Delete(Path.Combine(Properties.Settings.Default.BasePath, $"vwiisys", "code", "app.xml"));
}
}
}
private static void NDS(string injectRomPath)
{
string RomName = string.Empty;
using (Process getRomName = new Process())
{
mvvm.msg = "Getting BaseRom Name...";
getRomName.StartInfo.UseShellExecute = false;
getRomName.StartInfo.CreateNoWindow = false;
getRomName.StartInfo.RedirectStandardOutput = true;
getRomName.StartInfo.FileName = "cmd.exe";
Console.WriteLine(Directory.GetCurrentDirectory());
//getRomName.StartInfo.Arguments = $"/c \"Tools\\7za.exe\" l \"temp\\baserom\\content\\0010\\rom.zip\" | findstr \"WUP\"";
getRomName.StartInfo.Arguments = "/c bin\\Tools\\7za.exe l bin\\temp\\baserom\\content\\0010\\rom.zip | findstr WUP";
getRomName.Start();
getRomName.WaitForExit();
var s = getRomName.StandardOutput.ReadToEnd();
var split = s.Split(' ');
RomName = split[split.Length - 1].Replace("\r\n", "");
mvvm.Progress = 15;
}
using (Process RomEdit = new Process())
{
mvvm.msg = "Removing BaseRom...";
RomEdit.StartInfo.UseShellExecute = false;
RomEdit.StartInfo.CreateNoWindow = true;
RomEdit.StartInfo.RedirectStandardOutput = true;
RomEdit.StartInfo.FileName = Path.Combine(toolsPath, "7za.exe");
//d Path.Combine(baseRomPath, "content", "0010", "rom.zip")
RomEdit.StartInfo.Arguments = $"d bin\\temp\\baserom\\content\\0010\\rom.zip";
RomEdit.Start();
RomEdit.WaitForExit();
mvvm.Progress = 40;
mvvm.msg = "Injecting ROM...";
File.Copy(injectRomPath, $"{RomName}");
RomEdit.StartInfo.Arguments = $"u bin\\temp\\baserom\\content\\0010\\rom.zip {RomName}";
RomEdit.Start();
RomEdit.WaitForExit();
mvvm.Progress = 80;
}
File.Delete(RomName);
}
private static void N64(string injectRomPath, N64Conf config)
{
string mainRomPath = Directory.GetFiles(Path.Combine(baseRomPath, "content", "rom"))[0];
string mainIni = Path.Combine(baseRomPath, "content", "config", $"{Path.GetFileName(mainRomPath)}.ini");
using (Process n64convert = new Process())
{
mvvm.msg = "Injecting ROM...";
n64convert.StartInfo.UseShellExecute = false;
n64convert.StartInfo.CreateNoWindow = true;
n64convert.StartInfo.FileName = Path.Combine(toolsPath, "N64Converter.exe");
n64convert.StartInfo.Arguments = $"\"{injectRomPath}\" \"{mainRomPath}\"";
n64convert.Start();
n64convert.WaitForExit();
mvvm.Progress = 60;
}
if (config.WideScreen || config.DarkFilter)
{
using (var fileStream = File.Open(Path.Combine(baseRomPath, "content", "FrameLayout.arc"), FileMode.Open))
{
uint offset = 0;
uint size = 0;
byte[] offsetB = new byte[4];
byte[] sizeB = new byte[4];
byte[] nameB = new byte[0x18];
var header = new byte[4];
byte[] oneOut = BitConverter.GetBytes((float)1);
byte[] zeroOut = BitConverter.GetBytes((float)0);
byte darkFilter = (byte)(config.DarkFilter ? 0 : 1);
byte[] wideScreen = config.WideScreen ? new byte[] { 0x44, 0xF0, 0, 0 } : new byte[] { 0x44, 0xB4, 0, 0 };
fileStream.Read(header, 0, 4);
if (header[0] == 'S' && header[1] == 'A' && header[2] == 'R' && header[3] == 'C')
{
fileStream.Position = 0x0C;
fileStream.Read(offsetB, 0, 4);
offset = (uint)(offsetB[0] << 24 | offsetB[1] << 16 | offsetB[2] << 8 | offsetB[3]);
fileStream.Position = 0x38;
fileStream.Read(offsetB, 0, 4);
offset += (uint)(offsetB[0] << 24 | offsetB[1] << 16 | offsetB[2] << 8 | offsetB[3]);
fileStream.Position = offset;
fileStream.Read(header, 0, 4);
if (header[0] == 'F' && header[1] == 'L' && header[2] == 'Y' && header[3] == 'T')
{
fileStream.Position = offset + 0x04;
fileStream.Read(offsetB, 0, 4);
offsetB[0] = 0;
offsetB[1] = 0;
offset += (uint)(offsetB[0] << 24 | offsetB[1] << 16 | offsetB[2] << 8 | offsetB[3]);
fileStream.Position = offset;
while (true)
{
fileStream.Read(header, 0, 4);
fileStream.Read(sizeB, 0, 4);
size = (uint)(sizeB[0] << 24 | sizeB[1] << 16 | sizeB[2] << 8 | sizeB[3]);
if (header[0] == 'p' && header[1] == 'i' && header[2] == 'c' && header[3] == '1')
{
fileStream.Position = offset + 0x0C;
fileStream.Read(nameB, 0, 0x18);
int count = Array.IndexOf(nameB, (byte)0);
string name = Encoding.ASCII.GetString(nameB, 0, count);
if (name == "frame")
{
fileStream.Position = offset + 0x2C;
fileStream.WriteByte(zeroOut[3]);
fileStream.WriteByte(zeroOut[2]);
fileStream.WriteByte(zeroOut[1]);
fileStream.WriteByte(zeroOut[0]);
fileStream.Position = offset + 0x30;//TranslationX
fileStream.WriteByte(zeroOut[3]);
fileStream.WriteByte(zeroOut[2]);
fileStream.WriteByte(zeroOut[1]);
fileStream.WriteByte(zeroOut[0]);
fileStream.Position = offset + 0x44;//ScaleX
fileStream.WriteByte(oneOut[3]);
fileStream.WriteByte(oneOut[2]);
fileStream.WriteByte(oneOut[1]);
fileStream.WriteByte(oneOut[0]);
fileStream.Position = offset + 0x48;//ScaleY
fileStream.WriteByte(oneOut[3]);
fileStream.WriteByte(oneOut[2]);
fileStream.WriteByte(oneOut[1]);
fileStream.WriteByte(oneOut[0]);
fileStream.Position = offset + 0x4C;//Widescreen
fileStream.Write(wideScreen, 0, 4);
}
else if (name == "frame_mask")
{
fileStream.Position = offset + 0x08;//Dark filter
fileStream.WriteByte(darkFilter);
}
else if (name == "power_save_bg")
{
//This means we finished frame_mask and frame edits so we can end the loop
break;
}
offset += size;
fileStream.Position = offset;
}
else if (offset + size >= fileStream.Length)
{
//do nothing
}
else
{
offset += size;
fileStream.Position = offset;
}
}
}
}
fileStream.Close();
}
mvvm.Progress = 70;
}
mvvm.msg = "Copying INI...";
if(config.INIBin == null)
{
if (config.INIPath == null)
{
File.Delete(mainIni);
File.Copy(Path.Combine(toolsPath, "blank.ini"), mainIni);
}
else
{
File.Delete(mainIni);
File.Copy(config.INIPath, mainIni);
}
}
else
{
ReadFileFromBin(config.INIBin, "custom.ini");
File.Delete(mainIni);
File.Move("custom.ini", mainIni);
}
mvvm.Progress = 80;
}
//Compressed or decompresses the RPX using wiiurpxtool
private static void RPXdecomp(string rpxpath)
{
using (Process rpxtool = new Process())
{
rpxtool.StartInfo.UseShellExecute = false;
rpxtool.StartInfo.CreateNoWindow = true;
rpxtool.StartInfo.FileName = Path.Combine(toolsPath, "wiiurpxtool.exe");
rpxtool.StartInfo.Arguments = $"-d \"{rpxpath}\"";
rpxtool.Start();
rpxtool.WaitForExit();
}
}
private static void RPXcomp(string rpxpath)
{
using (Process rpxtool = new Process())
{
rpxtool.StartInfo.UseShellExecute = false;
rpxtool.StartInfo.CreateNoWindow = true;
rpxtool.StartInfo.FileName = Path.Combine(toolsPath, "wiiurpxtool.exe");
rpxtool.StartInfo.Arguments = $"-c \"{rpxpath}\"";
rpxtool.Start();
rpxtool.WaitForExit();
}
}
private static void ReadFileFromBin(byte[] bin, string output)
{
File.WriteAllBytes(output, bin);
}
private static void Images(GameConfig config)
{
bool usetemp = false;
bool readbin = false;
try
{
//is an image embedded? yes => export them and check for issues
//no => using path
if (Directory.Exists(imgPath)) // sanity check
{
Directory.Delete(imgPath, true);
}
Directory.CreateDirectory(imgPath);
//ICON
List<bool> Images = new List<bool>();
if (config.TGAIco.ImgBin == null)
{
//use path
if (config.TGAIco.ImgPath != null)
{
Images.Add(true);
CopyAndConvertImage(config.TGAIco.ImgPath, Path.Combine(imgPath), false, 128,128,32, "iconTex.tga");
}
else
{
if(File.Exists(Path.Combine(toolsPath, "iconTex.tga")))
{
CopyAndConvertImage(Path.Combine(toolsPath, "iconTex.tga"), Path.Combine(imgPath), false, 128, 128, 32, "iconTex.tga");
Images.Add(true);
}
else
{
Images.Add(false);
}
}
}
else
{
ReadFileFromBin(config.TGAIco.ImgBin, $"iconTex.{config.TGAIco.extension}");
CopyAndConvertImage($"iconTex.{config.TGAIco.extension}", Path.Combine(imgPath), true, 128, 128, 32, "iconTex.tga");
Images.Add(true);
}
if (config.TGATv.ImgBin == null)
{
//use path
if (config.TGATv.ImgPath != null)
{
Images.Add(true);
CopyAndConvertImage(config.TGATv.ImgPath, Path.Combine(imgPath), false, 1280, 720, 24, "bootTvTex.tga");
config.TGATv.ImgPath = Path.Combine(imgPath, "bootTvTex.tga");
}
else
{
if (File.Exists(Path.Combine(toolsPath, "bootTvTex.png")))
{
CopyAndConvertImage(Path.Combine(toolsPath, "bootTvTex.png"), Path.Combine(imgPath), false, 1280, 720, 24, "bootTvTex.tga");
usetemp = true;
Images.Add(true);
}
else
{
Images.Add(false);
}
}
}
else
{
ReadFileFromBin(config.TGATv.ImgBin, $"bootTvTex.{config.TGATv.extension}");
CopyAndConvertImage($"bootTvTex.{config.TGATv.extension}", Path.Combine(imgPath), true, 1280, 720, 24, "bootTvTex.tga");
config.TGATv.ImgPath = Path.Combine(imgPath, "bootTvTex.tga");
Images.Add(true);
readbin = true;
}
//Drc
if (config.TGADrc.ImgBin == null)
{
//use path
if (config.TGADrc.ImgPath != null)
{
Images.Add(true);
CopyAndConvertImage(config.TGADrc.ImgPath, Path.Combine(imgPath), false, 854,480,24, "bootDrcTex.tga");
}
else
{
if (Images[1])
{
using(Process conv = new Process())
{
if (!mvvm.debug)
{
conv.StartInfo.UseShellExecute = false;
conv.StartInfo.CreateNoWindow = true;
}
if (usetemp)
{
File.Copy(Path.Combine(toolsPath, "bootTvTex.png"), Path.Combine(tempPath, "bootDrcTex.png"));
}
else
{
conv.StartInfo.FileName = Path.Combine(toolsPath, "tga2png.exe");
if (!readbin)
{
conv.StartInfo.Arguments = $"-i \"{config.TGATv.ImgPath}\" -o \"{Path.Combine(tempPath)}\"";
}
else
{
if (config.TGATv.extension.Contains("tga"))
{
ReadFileFromBin(config.TGATv.ImgBin, $"bootTvTex.{config.TGATv.extension}");
conv.StartInfo.Arguments = $"-i \"bootTvTex.{config.TGATv.extension}\" -o \"{Path.Combine(tempPath)}\"";
}
else
{
ReadFileFromBin(config.TGATv.ImgBin, Path.Combine(tempPath, "bootTvTex.png"));
}
}
if (!readbin || config.TGATv.extension.Contains("tga"))
{
conv.Start();
conv.WaitForExit();
}
File.Copy(Path.Combine(tempPath, "bootTvTex.png"), Path.Combine(tempPath, "bootDrcTex.png"));
if(File.Exists(Path.Combine(tempPath, "bootTvTex.png"))) File.Delete(Path.Combine(tempPath, "bootTvTex.png"));
if (File.Exists($"bootTvTex.{config.TGATv.extension}")) File.Delete($"bootTvTex.{config.TGATv.extension}");
}
CopyAndConvertImage(Path.Combine(tempPath, "bootDrcTex.png"), Path.Combine(imgPath), false, 854, 480, 24, "bootDrcTex.tga");
Images.Add(true);
}
}
else
{
Images.Add(false);
}
}
}
else
{
ReadFileFromBin(config.TGADrc.ImgBin, $"bootDrcTex.{config.TGADrc.extension}");
CopyAndConvertImage($"bootDrcTex.{config.TGADrc.extension}", Path.Combine(imgPath), true,854,480,24, "bootDrcTex.tga");
Images.Add(true);
}
//tv
//logo
if (config.TGALog.ImgBin == null)
{
//use path
if (config.TGALog.ImgPath != null)
{
Images.Add(true);
CopyAndConvertImage(config.TGALog.ImgPath, Path.Combine(imgPath), false, 170,42,32, "bootLogoTex.tga");
}
else
{
Images.Add(false);
}
}
else
{
ReadFileFromBin(config.TGALog.ImgBin, $"bootLogoTex.{config.TGALog.extension}");
CopyAndConvertImage($"bootLogoTex.{config.TGALog.extension}", Path.Combine(imgPath), true, 170, 42, 32, "bootLogoTex.tga");
Images.Add(true);
}
//Fixing Images + Injecting them
if (Images[0] || Images[1] || Images[2] || Images[3])
{
using (Process checkIfIssue = new Process())
{
checkIfIssue.StartInfo.UseShellExecute = false;
checkIfIssue.StartInfo.CreateNoWindow = false;
checkIfIssue.StartInfo.RedirectStandardOutput = true;
checkIfIssue.StartInfo.RedirectStandardError = true;
checkIfIssue.StartInfo.FileName = $"{Path.Combine(toolsPath,"tga_verify.exe")}";
Console.WriteLine(Directory.GetCurrentDirectory());
checkIfIssue.StartInfo.Arguments = $"\"{imgPath}\"";
checkIfIssue.Start();
checkIfIssue.WaitForExit();
var s = checkIfIssue.StandardOutput.ReadToEnd();
if (s.Contains("width") || s.Contains("height") || s.Contains("depth"))
{
throw new Exception("Size");
}
var e = checkIfIssue.StandardError.ReadToEnd();
if (e.Contains("width") || e.Contains("height") || e.Contains("depth"))
{
throw new Exception("Size");
}
if (e.Contains("TRUEVISION") || s.Contains("TRUEVISION"))
{
checkIfIssue.StartInfo.UseShellExecute = false;
checkIfIssue.StartInfo.CreateNoWindow = false;
checkIfIssue.StartInfo.RedirectStandardOutput = true;
checkIfIssue.StartInfo.RedirectStandardError = true;
checkIfIssue.StartInfo.FileName = $"{Path.Combine(toolsPath, "tga_verify.exe")}";
Console.WriteLine(Directory.GetCurrentDirectory());
checkIfIssue.StartInfo.Arguments = $"--fixup \"{imgPath}\"";
checkIfIssue.Start();
checkIfIssue.WaitForExit();
}
// Console.ReadLine();
}
if (Images[1])
{
File.Delete(Path.Combine(baseRomPath, "meta", "bootTvTex.tga"));
File.Move(Path.Combine(imgPath, "bootTvTex.tga"), Path.Combine(baseRomPath, "meta", "bootTvTex.tga"));
}
if (Images[2])
{
File.Delete(Path.Combine(baseRomPath, "meta", "bootDrcTex.tga"));
File.Move(Path.Combine(imgPath, "bootDrcTex.tga"), Path.Combine(baseRomPath, "meta", "bootDrcTex.tga"));
}
if (Images[0])
{
File.Delete(Path.Combine(baseRomPath, "meta", "iconTex.tga"));
File.Move(Path.Combine(imgPath, "iconTex.tga"), Path.Combine(baseRomPath, "meta", "iconTex.tga"));
}
if (Images[3])
{
File.Delete(Path.Combine(baseRomPath, "meta", "bootLogoTex.tga"));
File.Move(Path.Combine(imgPath, "bootLogoTex.tga"), Path.Combine(baseRomPath, "meta", "bootLogoTex.tga"));
}
}
}
catch(Exception e)
{
if (e.Message.Contains("Size"))
{
throw e;
}
throw new Exception("Images");
}
}
private static void CopyAndConvertImage(string inputPath, string outputPath, bool delete, int widht, int height, int bit, string newname)
{
if (inputPath.EndsWith(".tga"))
{
File.Copy(inputPath, Path.Combine(outputPath,newname));
}
else
{
using (Process png2tga = new Process())
{
png2tga.StartInfo.UseShellExecute = false;
png2tga.StartInfo.CreateNoWindow = true;
var extension = new FileInfo(inputPath).Extension;
if (extension.Contains("png"))
{
png2tga.StartInfo.FileName = Path.Combine(toolsPath, "png2tga.exe");
}else if (extension.Contains("jpg") || extension.Contains("jpeg"))
{
png2tga.StartInfo.FileName = Path.Combine(toolsPath, "jpg2tga.exe");
}else if (extension.Contains("bmp"))
{
png2tga.StartInfo.FileName = Path.Combine(toolsPath, "bmp2tga.exe");
}
png2tga.StartInfo.Arguments = $"-i \"{inputPath}\" -o \"{outputPath}\" --width={widht} --height={height} --tga-bpp={bit} --tga-compression=none";
png2tga.Start();
png2tga.WaitForExit();
}
string name = Path.GetFileNameWithoutExtension(inputPath);
if(File.Exists(Path.Combine(outputPath , name + ".tga")))
{
File.Move(Path.Combine(outputPath, name + ".tga"), Path.Combine(outputPath, newname));
}
}
if (delete)
{
File.Delete(inputPath);
}
}
private static string RemoveHeader(string filePath)
{
// logic taken from snesROMUtil
using (FileStream inStream = new FileStream(filePath, FileMode.Open))
{
byte[] header = new byte[512];
inStream.Read(header, 0, 512);
string string1 = BitConverter.ToString(header, 8, 3);
string string2 = Encoding.ASCII.GetString(header, 0, 11);
string string3 = BitConverter.ToString(header, 30, 16);
if (string1 != "AA-BB-04" && string2 != "GAME DOCTOR" && string3 != "00-00-00-00-00-00-00-00-00-00-00-00-00-00-00-00")
return filePath;
string newFilePath = Path.Combine(tempPath, Path.GetFileName(filePath));
using (FileStream outStream = new FileStream(newFilePath, FileMode.OpenOrCreate))
{
inStream.CopyTo(outStream);
}
return newFilePath;
}
}
public static void DirectoryCopy(string sourceDirName, string destDirName, bool copySubDirs)
{
// Get the subdirectories for the specified directory.
DirectoryInfo dir = new DirectoryInfo(sourceDirName);
if (!dir.Exists)
{
throw new DirectoryNotFoundException($"Source directory does not exist or could not be found: {sourceDirName}");
}
// If the destination directory doesn't exist, create it.
if (!Directory.Exists(destDirName))
{
Directory.CreateDirectory(destDirName);
}
// Get the files in the directory and copy them to the new location.
foreach (FileInfo file in dir.EnumerateFiles())
{
file.CopyTo(Path.Combine(destDirName, file.Name), false);
}
// If copying subdirectories, copy them and their contents to new location.
if (copySubDirs)
{
foreach (DirectoryInfo subdir in dir.EnumerateDirectories())
{
DirectoryCopy(subdir.FullName, Path.Combine(destDirName, subdir.Name), copySubDirs);
}
}
}
}
}
Reference in a new issue View git blame Copy permalink