UWUVCI-AIO-WPF/UWUVCI AIO WPF/Models/MainViewModel.cs

3004 lines
111 KiB
C#
Raw Normal View History

using GameBaseClassLibrary;
using System;
2020-03-01 15:07:22 +00:00
using System.Collections.Generic;
using System.Configuration;
using System.IO;
2020-04-06 19:30:31 +00:00
using System.IO.Compression;
2020-03-01 15:07:22 +00:00
using System.Linq;
using System.Net;
2020-04-06 19:30:31 +00:00
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;
2020-03-01 15:07:22 +00:00
using System.Text;
using System.Threading.Tasks;
2020-04-06 19:30:31 +00:00
using System.Windows.Controls;
using System.Windows.Forms;
using UWUVCI_AIO_WPF.Classes;
using UWUVCI_AIO_WPF.Properties;
using UWUVCI_AIO_WPF.UI;
using UWUVCI_AIO_WPF.UI.Frames.InjectFrames.Bases;
2020-04-06 19:30:31 +00:00
using UWUVCI_AIO_WPF.UI.Frames.InjectFrames.Configurations;
using UWUVCI_AIO_WPF.UI.Windows;
using AutoUpdaterDotNET;
2020-04-17 16:02:45 +00:00
using System.Threading;
using System.Windows.Threading;
using System.Diagnostics;
2020-04-20 09:31:26 +00:00
using Microsoft.WindowsAPICodePack.Dialogs;
2020-04-21 19:52:52 +00:00
using System.Text.RegularExpressions;
2020-04-25 06:40:38 +00:00
using MaterialDesignThemes.Wpf;
2020-04-30 15:01:41 +00:00
using NAudio.Wave;
using System.Timers;
using NAudio.Utils;
2020-03-01 15:07:22 +00:00
namespace UWUVCI_AIO_WPF
{
public class MainViewModel : BaseModel
2020-03-01 15:07:22 +00:00
{
//public GameConfig GameConfiguration { get; set; }
2020-03-01 16:15:54 +00:00
private GameConfig gameConfiguration = new GameConfig();
2020-03-01 15:07:22 +00:00
public bool addi = false;
2020-03-01 15:07:22 +00:00
public GameConfig GameConfiguration
{
get { return gameConfiguration; }
set
{
gameConfiguration = value;
OnPropertyChanged();
}
}
2020-03-01 16:15:54 +00:00
private string romPath;
public string RomPath
{
get { return romPath; }
set { romPath = value;
OnPropertyChanged();
}
}
2020-03-01 15:07:22 +00:00
private GameBases gbTemp;
public GameBases GbTemp
{
get { return gbTemp; }
set { gbTemp = value; }
}
private string selectedBaseAsString;
public string SelectedBaseAsString
{
get { return selectedBaseAsString; }
set { selectedBaseAsString = value; }
}
private List<string> lGameBasesString = new List<string>();
public List<string> LGameBasesString
{
get { return lGameBasesString; }
set
{
lGameBasesString = value;
OnPropertyChanged();
}
}
private bool pathsSet { get; set; } = false;
public bool PathsSet
{
get { return pathsSet; }
set
{
pathsSet = value;
OnPropertyChanged();
}
}
2020-03-01 15:07:22 +00:00
private string baseStore;
public string BaseStore
{
get { return baseStore; }
set { baseStore = value;
OnPropertyChanged();
}
}
private string injectStore;
public string InjectStore
{
get { return injectStore; }
set { injectStore = value;
OnPropertyChanged();
}
}
private bool injected = false;
public bool Injected
{
get { return injected; }
set { injected = value;
OnPropertyChanged();
}
}
2020-04-06 19:30:31 +00:00
private Page thing;
public Page Thing
{
get { return thing; }
set { thing = value; }
}
public int OldIndex { get; set; }
public bool RomSet { get; set; }
private List<GameBases> lBases = new List<GameBases>();
public List<GameBases> LBases
{
get { return lBases; }
set { lBases = value;
OnPropertyChanged();
}
}
private int progress = 0;
public int Progress
{
get { return progress ; }
set { progress = value;
OnPropertyChanged();
}
}
public BaseContainerFrame bcf = null;
#region TKLIST
private List<GameBases> lNDS = new List<GameBases>();
public List<GameBases> LNDS
{
get { return lNDS; }
set { lNDS = value; OnPropertyChanged(); }
}
private List<GameBases> lN64 = new List<GameBases>();
public List<GameBases> LN64
{
get { return lN64; }
set { lN64 = value; OnPropertyChanged(); }
}
private List<GameBases> lNES = new List<GameBases>();
2020-04-06 19:30:31 +00:00
public List<GameBases> LNES
{
get { return lNES; }
set { lNES = value; OnPropertyChanged(); }
}
private List<GameBases> lGBA = new List<GameBases>();
public List<GameBases> LGBA
{
get { return lGBA; }
set { lGBA = value; OnPropertyChanged(); }
}
private List<GameBases> lSNES = new List<GameBases>();
public List<GameBases> LSNES
{
get { return lSNES; }
set { lSNES = value; OnPropertyChanged(); }
}
private List<GameBases> lTG16 = new List<GameBases>();
public List<GameBases> LTG16
{
get { return lTG16; }
set { lTG16 = value; OnPropertyChanged(); }
}
2020-04-07 01:09:05 +00:00
private List<GameBases> lMSX = new List<GameBases>();
public List<GameBases> LMSX
{
get { return lMSX; }
set { lMSX = value; OnPropertyChanged(); }
}
2020-04-16 04:41:25 +00:00
private List<GameBases> lWii = new List<GameBases>();
2020-04-07 01:09:05 +00:00
2020-05-06 21:53:52 +00:00
public void IsIsoNkit()
{
using (var fs = new FileStream(RomPath,
FileMode.Open,
FileAccess.ReadWrite))
{
byte[] procode = new byte[4];
fs.Seek(0x200, SeekOrigin.Begin);
fs.Read(procode, 0, 4);
var s = ByteArrayToString(procode);
fs.Close();
if (s.ToLower().Contains("nkit"))
{
NKITFLAG = true;
}
else
{
NKITFLAG = false;
}
}
}
2020-04-16 04:41:25 +00:00
public List<GameBases> LWII
{
get { return lWii; }
set { lWii = value; OnPropertyChanged(); }
}
2020-04-07 01:09:05 +00:00
private List<GameBases> ltemp = new List<GameBases>();
public List<GameBases> Ltemp
{
get { return ltemp; }
set { ltemp = value; OnPropertyChanged(); }
}
#endregion
public bool BaseDownloaded { get; set; } = false;
private bool canInject = false;
public bool CanInject
{
get { return canInject; }
set { canInject = value;
OnPropertyChanged();
}
}
2020-04-06 19:30:31 +00:00
private string cBasePath;
public string CBasePath
{
get { return cBasePath; }
set { cBasePath = value;
OnPropertyChanged();
}
}
2020-04-16 04:41:25 +00:00
public int Index = -1;
public bool LR = false;
public bool GC = false;
public bool debug = false;
public string doing = "";
public bool Patch = false;
public bool toPal = false;
private string Msg;
2020-04-19 17:36:03 +00:00
private string Gc2rom = "";
public string gc2rom
{
get { return Gc2rom; }
set { Gc2rom = value;
OnPropertyChanged();
}
}
public string msg
{
get { return Msg; }
set { Msg = value;
OnPropertyChanged();
}
}
2020-04-25 06:40:38 +00:00
private string bootsound;
public string BootSound
{
get { return bootsound; }
set { bootsound = value;
OnPropertyChanged();
}
}
2020-04-21 02:05:19 +00:00
public System.Windows.Controls.ListViewItem curr = null;
2020-04-19 17:36:03 +00:00
private bool ckeys;
public bool Ckeys
{
get { return ckeys; }
set { ckeys = value;
OnPropertyChanged();
}
}
2020-04-06 19:30:31 +00:00
2020-05-06 21:53:52 +00:00
public bool NKITFLAG { get; set; } = false;
public MainWindow mw;
private CustomBaseFrame cb = null;
DispatcherTimer timer = new DispatcherTimer();
2020-04-21 02:05:19 +00:00
public bool PokePatch = false;
public void Update(bool button)
{
2020-04-19 17:36:03 +00:00
if (CheckForInternetConnection())
{
2020-04-19 17:36:03 +00:00
System.Reflection.Assembly assembly = System.Reflection.Assembly.GetExecutingAssembly();
FileVersionInfo fvi = FileVersionInfo.GetVersionInfo(assembly.Location);
string version = fvi.FileVersion;
AutoUpdater.Start("https://raw.githubusercontent.com/Hotbrawl20/testing/master/update.xml");
if (Properties.Settings.Default.UpgradeRequired)
{
2020-04-19 17:36:03 +00:00
Properties.Settings.Default.Upgrade();
Properties.Settings.Default.UpgradeRequired = false;
Properties.Settings.Default.Save();
}
2020-04-19 17:36:03 +00:00
if (button && Convert.ToInt32(version.Split('.')[3]) >= GetNewVersion())
{
Custom_Message cm = new Custom_Message("No Updates available", "You are currently using the newest version of UWUVCI AIO");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-04-19 17:36:03 +00:00
}
}
2020-04-19 17:36:03 +00:00
}
private int GetNewVersion()
{
try
{
WebRequest request;
//get download link from uwuvciapi
request = WebRequest.Create("https://uwuvciapi.azurewebsites.net/GetVersionNum");
var response = request.GetResponse();
using (Stream dataStream = response.GetResponseStream())
{
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader(dataStream);
// Read the content.
string responseFromServer = reader.ReadToEnd();
// Display the content.
return Convert.ToInt32(responseFromServer);
}
}
catch (Exception)
{
return 100000;
}
}
2020-04-25 06:40:38 +00:00
public bool ConfirmRiffWave(string path)
{
using (var reader = new BinaryReader(File.OpenRead(path)))
{
reader.BaseStream.Position = 0x00;
long WAVHeader1 = reader.ReadInt32();
reader.BaseStream.Position = 0x08;
long WAVHeader2 = reader.ReadInt32();
if (WAVHeader1 == 1179011410 & WAVHeader2 == 1163280727)
{
return true;
}
else
{
return false;
}
}
}
public void OpenDialog(string title, string msg)
2020-03-01 15:07:22 +00:00
{
Custom_Message cm = new Custom_Message(title, msg);
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-04-17 16:02:45 +00:00
}
public MainViewModel()
{
//if (Directory.Exists(@"Tools")) Directory.Delete(@"Tools", true);
if (Directory.Exists(@"bases")) Directory.Delete(@"bases", true);
if (Directory.Exists(@"temp")) Directory.Delete(@"temp", true);
if (Directory.Exists(@"keys"))
{
if(Directory.Exists(@"bin\keys")) Directory.Delete(@"bin\keys", true);
Injection.DirectoryCopy("keys", "bin/keys", true);
Directory.Delete("keys", true);
}
if (!Directory.Exists("InjectedGames")) Directory.CreateDirectory("InjectedGames");
if (!Directory.Exists("SourceFiles")) Directory.CreateDirectory("SourceFiles");
if (!Directory.Exists("bin\\BaseGames")) Directory.CreateDirectory("bin\\BaseGames");
if(Properties.Settings.Default.OutPath == "" || Properties.Settings.Default.OutPath == null)
{
Settings.Default.OutPath = Path.Combine(Directory.GetCurrentDirectory(), "InjectedGames");
}
if(Settings.Default.BasePath == "" || Properties.Settings.Default.BasePath == null)
{
Settings.Default.BasePath = Path.Combine(Directory.GetCurrentDirectory(), "bin", "BaseGames");
}
Settings.Default.Save();
ArePathsSet();
Update(false);
toolCheck();
BaseCheck();
2020-04-06 19:30:31 +00:00
2020-03-01 15:07:22 +00:00
GameConfiguration = new GameConfig();
2020-04-06 19:30:31 +00:00
if (!ValidatePathsStillExist() && Settings.Default.SetBaseOnce && Settings.Default.SetOutOnce)
{
2020-05-06 21:53:52 +00:00
Custom_Message cm = new Custom_Message("Issue", "One of your added Paths seems to not exist anymore.\nThe Tool is now using it's default Paths\nPlease check the paths in the Path menu!");
try
{
cm.Owner = mw;
}catch(Exception e)
{
}
cm.ShowDialog();
}
UpdatePathSet();
GetAllBases();
}
public string turbocd()
{
2020-04-25 06:40:38 +00:00
string ret = string.Empty;
2020-04-25 06:40:38 +00:00
Custom_Message cm = new Custom_Message("Information", "Please put a TurboGrafX CD ROM into a folder and select said folder.\n\nThe Folder should atleast contain:\nEXACTLY ONE *.hcd file\nOne or more *.ogg files\nOne or More *.bin files\n\nNot doing so will result in a faulty Inject. You have been warned!");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-04-17 16:02:45 +00:00
2020-04-20 09:31:26 +00:00
using (var dialog = new CommonOpenFileDialog())
{
2020-04-20 09:31:26 +00:00
dialog.IsFolderPicker = true;
CommonFileDialogResult result = dialog.ShowDialog();
if (result == CommonFileDialogResult.Ok)
{
try
{
2020-04-20 09:31:26 +00:00
if (DirectoryIsEmpty(dialog.FileName))
{
cm = new Custom_Message("Issue", "The folder is Empty. Please choose another folder");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
}
else
{
2020-04-20 09:31:26 +00:00
if (Directory.GetDirectories(dialog.FileName).Length > 0)
{
cm = new Custom_Message("Issue", "This folder mustn't contain any subfolders.");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-04-17 16:02:45 +00:00
}
else
{
//WUP
2020-04-20 09:31:26 +00:00
if (Directory.GetFiles(dialog.FileName, "*.hcd").Length == 1 && Directory.GetFiles(dialog.FileName, "*.ogg").Length > 0 && Directory.GetFiles(dialog.FileName, "*.bin").Length > 0)
{
2020-04-20 09:31:26 +00:00
ret = dialog.FileName;
}
else
{
cm = new Custom_Message("Issue", "This Folder does not contain needed minimum of Files");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
}
}
}
}
catch (Exception)
{
}
}
}
return ret;
}
2020-04-21 02:05:19 +00:00
public GameConfig saveconf = null;
public void resetCBASE()
{
2020-04-06 19:30:31 +00:00
if (cb != null) cb.Reset();
}
public void removeCBASE()
{
cb = null;
}
2020-04-06 19:30:31 +00:00
public void setThing(Page T)
{
Thing = T;
}
public void SetCBASE(CustomBaseFrame cbs)
{
cb = cbs;
}
public void setMW(MainWindow mwi)
{
mw = mwi;
}
2020-04-25 06:40:38 +00:00
2020-04-06 19:30:31 +00:00
public void ExportFile()
{
2020-04-21 02:05:19 +00:00
string drcp = null;
string tvcp = null;
string iccp = null;
string lgcp = null;
string incp = null;
if(GameConfiguration.TGADrc.ImgPath != null || GameConfiguration.TGADrc.ImgPath == "") drcp = String.Copy(GameConfiguration.TGADrc.ImgPath);
if (GameConfiguration.TGATv.ImgPath != null || GameConfiguration.TGATv.ImgPath == "") tvcp = String.Copy(GameConfiguration.TGATv.ImgPath);
if (GameConfiguration.TGAIco.ImgPath != null || GameConfiguration.TGAIco.ImgPath == "") iccp = String.Copy(GameConfiguration.TGAIco.ImgPath);
if (GameConfiguration.TGALog.ImgPath != null || GameConfiguration.TGALog.ImgPath == "") lgcp = String.Copy(GameConfiguration.TGALog.ImgPath);
if (GameConfiguration.N64Stuff.INIPath != null || GameConfiguration.N64Stuff.INIPath == "") incp = String.Copy(GameConfiguration.N64Stuff.INIPath);
2020-04-06 19:30:31 +00:00
ReadImagesIntoConfig();
if (GameConfiguration.Console == GameConsoles.N64)
{
ReadIniIntoConfig();
}
2020-04-20 09:31:26 +00:00
GameConfig backup = GameConfiguration;
if (test == GameConsoles.GCN) backup.Console = GameConsoles.GCN;
if(GameConfiguration.TGADrc.ImgBin != null && GameConfiguration.TGADrc.ImgBin.Length > 0) backup.TGADrc.ImgPath = "Added via Config";
if (GameConfiguration.TGATv.ImgBin != null && GameConfiguration.TGATv.ImgBin.Length > 0) backup.TGATv.ImgPath = "Added via Config";
if (GameConfiguration.TGALog.ImgBin != null && GameConfiguration.TGALog.ImgBin.Length > 0) backup.TGALog.ImgPath = "Added via Config";
if (GameConfiguration.TGAIco.ImgBin != null && GameConfiguration.TGAIco.ImgBin.Length > 0) backup.TGAIco.ImgPath = "Added via Config";
if (GameConfiguration.N64Stuff.INIBin != null && GameConfiguration.N64Stuff.INIBin.Length > 0) backup.N64Stuff.INIPath = "Added via Config";
if (GameConfiguration.GameName == "" || GameConfiguration.GameName == null) backup.GameName = "NoName";
2020-04-06 19:30:31 +00:00
CheckAndFixConfigFolder();
2020-04-20 09:31:26 +00:00
string outputPath = $@"configs\[{backup.Console.ToString()}]{backup.GameName}.uwuvci";
int i = 1;
while (File.Exists(outputPath))
{
2020-04-20 09:31:26 +00:00
outputPath = $@"configs\[{backup.Console.ToString()}]{backup.GameName}_{i}.uwuvci";
i++;
}
Stream createConfigStream = new FileStream(outputPath, FileMode.Create, FileAccess.Write);
2020-04-06 19:30:31 +00:00
GZipStream compressedStream = new GZipStream(createConfigStream, CompressionMode.Compress);
IFormatter formatter = new BinaryFormatter();
2020-04-20 09:31:26 +00:00
formatter.Serialize(compressedStream, backup);
2020-04-06 19:30:31 +00:00
compressedStream.Close();
createConfigStream.Close();
Custom_Message cm = new Custom_Message("Export success", "The Config was successfully exported.\nClick the Open Folder Button to open the Location where the Config is stored.", Path.Combine(Directory.GetCurrentDirectory(), outputPath));
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-04-21 02:05:19 +00:00
GameConfiguration.TGADrc.ImgPath = drcp;
GameConfiguration.TGATv.ImgPath = tvcp;
GameConfiguration.TGAIco.ImgPath = iccp;
GameConfiguration.TGALog.ImgPath = lgcp;
GameConfiguration.TGADrc.ImgBin = null;
GameConfiguration.TGATv.ImgBin = null;
GameConfiguration.TGAIco.ImgBin = null;
GameConfiguration.TGALog.ImgBin = null;
if (incp != null)
{
GameConfiguration.N64Stuff.INIBin = null;
GameConfiguration.N64Stuff.INIPath = incp;
}
/*if (GameConfiguration.Console == GameConsoles.N64)
2020-04-20 09:31:26 +00:00
{
(thing as N64Config).reset();
}
else if (gameConfiguration.Console == GameConsoles.TG16)
{
(thing as TurboGrafX).reset();
}
else if (gameConfiguration.Console == GameConsoles.WII && test != GameConsoles.GCN)
{
(thing as WiiConfig).reset();
}
else if (test == GameConsoles.GCN)
{
(thing as GCConfig).reset();
}
else
{
try
{
(thing as OtherConfigs).reset();
}
catch (Exception e)
{
(thing as GCConfig).reset();
}
2020-04-21 02:05:19 +00:00
}*/
}
2020-04-06 19:30:31 +00:00
public void ImportConfig(string configPath)
{
FileInfo fn = new FileInfo(configPath);
if (fn.Extension.Contains("uwuvci"))
{
FileStream inputConfigStream = new FileStream(configPath, FileMode.Open, FileAccess.Read);
GZipStream decompressedConfigStream = new GZipStream(inputConfigStream, CompressionMode.Decompress);
IFormatter formatter = new BinaryFormatter();
GameConfiguration = (GameConfig)formatter.Deserialize(decompressedConfigStream);
}
if(GameConfiguration.Console == GameConsoles.N64)
{
(thing as N64Config).getInfoFromConfig();
}
2020-04-20 00:35:31 +00:00
else if(gameConfiguration.Console == GameConsoles.TG16)
{
(thing as TurboGrafX).getInfoFromConfig();
}else if(gameConfiguration.Console == GameConsoles.WII && test != GameConsoles.GCN)
{
(thing as WiiConfig).getInfoFromConfig();
}else if (test == GameConsoles.GCN)
{
(thing as GCConfig).getInfoFromConfig();
2020-04-21 02:05:19 +00:00
}else if(gameConfiguration.Console == GameConsoles.GBA)
{
(thing as GBA).getInfoFromConfig();
2020-04-20 00:35:31 +00:00
}
2020-04-06 19:30:31 +00:00
else
{
2020-04-20 00:35:31 +00:00
try
{
(thing as OtherConfigs).getInfoFromConfig();
}
catch(Exception e)
{
(thing as GCConfig).getInfoFromConfig();
}
2020-04-06 19:30:31 +00:00
}
}
public void ReadImagesIntoConfig()
{
ReadFileAsBin(GameConfiguration, GameConfiguration.TGAIco.ImgPath, 1);
ReadFileAsBin(GameConfiguration, GameConfiguration.TGADrc.ImgPath, 2);
ReadFileAsBin(GameConfiguration, GameConfiguration.TGATv.ImgPath, 3);
ReadFileAsBin(GameConfiguration, GameConfiguration.TGALog.ImgPath, 4);
}
public void ReadIniIntoConfig()
{
ReadFileAsBin(GameConfiguration, GameConfiguration.N64Stuff.INIPath, 5);
}
private void ReadFileAsBin(GameConfig file, string FilePath, int scase)
{
if(FilePath != null)
{
try
{
var filedata = new FileStream(FilePath, FileMode.Open);
var len = (int)filedata.Length;
switch (scase)
{
case 1:
file.TGAIco.ImgBin = new byte[len];
filedata.Read(file.TGAIco.ImgBin, 0, len);
break;
case 2:
file.TGADrc.ImgBin = new byte[len];
filedata.Read(file.TGADrc.ImgBin, 0, len);
break;
case 3:
file.TGATv.ImgBin = new byte[len];
filedata.Read(file.TGATv.ImgBin, 0, len);
break;
case 4:
file.TGALog.ImgBin = new byte[len];
filedata.Read(file.TGALog.ImgBin, 0, len);
break;
case 5:
file.N64Stuff.INIBin = new byte[len];
filedata.Read(file.N64Stuff.INIBin, 0, len);
break;
}
filedata.Close();
}
catch (Exception)
{
switch (scase)
{
case 1:
file.TGAIco.ImgBin = null;
break;
case 2:
file.TGADrc.ImgBin = null;
break;
case 3:
file.TGATv.ImgBin = null;
break;
case 4:
file.TGALog.ImgBin = null;
break;
case 5:
file.N64Stuff.INIBin = null;
break;
}
}
}
}
2020-05-04 16:20:21 +00:00
public bool donttrim = false;
2020-04-06 19:30:31 +00:00
private static void CheckAndFixConfigFolder()
{
if (!Directory.Exists(@"configs"))
{
Directory.CreateDirectory(@"configs");
}
}
public void Pack(bool loadiine)
{
2020-04-19 17:36:03 +00:00
ValidatePathsStillExist();
if (loadiine)
{
Injection.Loadiine(GameConfiguration.GameName);
//
}
else
{
if(gameConfiguration.GameName != null)
{
Regex reg = new Regex("[^a-zA-Z0-9 é -]");
gameConfiguration.GameName = reg.Replace(gameConfiguration.GameName, "");
}
Task.Run(() => { Injection.Packing(GameConfiguration.GameName, this); });
2020-04-17 17:15:27 +00:00
DownloadWait dw = new DownloadWait("Packing Inject - Please Wait", "", this);
try
{
2020-04-30 15:01:41 +00:00
dw.changeOwner(mw);
2020-04-17 17:15:27 +00:00
}
catch (Exception) { }
dw.ShowDialog();
2020-04-20 00:35:31 +00:00
Progress = 0;
string extra = "";
if (GameConfiguration.Console == GameConsoles.WII) extra = "\nSome games cannot reboot into the WiiU Menu. Shut down via the GamePad.\nIf Stuck in a BlackScreen, you need to unplug your WiiU.";
2020-05-04 16:20:21 +00:00
if (GC) extra = "\nMake sure to have Nintendon't + config on your SD.\nYou can add them by pressing the \"Nintendon't Config\" button or using the \"Start Nintendont Config Tool\" button under Settings.";
2020-04-19 17:36:03 +00:00
gc2rom = "";
Custom_Message cm = new Custom_Message("Injection Complete", $"It's recommended to install onto USB to avoid brick risks.{extra}\nConfig will stay filled, choose a Console again to clear it!\nTo Open the Location of the Inject press Open Folder.", Settings.Default.OutPath);
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
}
LGameBasesString.Clear();
CanInject = false;
RomSet = false;
RomPath = null;
Injected = false;
GameConfiguration.CBasePath = null;
2020-04-16 04:41:25 +00:00
GC = false;
2020-04-25 06:40:38 +00:00
bootsound = "";
2020-05-06 21:53:52 +00:00
NKITFLAG = false;
2020-05-07 07:49:36 +00:00
CBasePath = null;
2020-04-20 00:35:31 +00:00
if(Directory.Exists(Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo"))) Directory.Delete(Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo"), true);
}
DownloadWait Injectwait;
2020-04-17 16:02:45 +00:00
public void runInjectThread(bool force)
{
timer.Interval = TimeSpan.FromSeconds(1);
timer.Tick += timer_Tick2;
timer.Start();
2020-04-17 16:02:45 +00:00
var thread = new Thread(() =>
{
Injectwait =new DownloadWait("Injecting Game - Please Wait", "", this);
try
{
2020-04-30 15:01:41 +00:00
Injectwait.changeOwner(mw);
}
catch (Exception) { }
Injectwait.Topmost = true;
Injectwait.ShowDialog();
});
2020-04-17 16:02:45 +00:00
thread.SetApartmentState(ApartmentState.STA);
thread.Start();
2020-04-17 16:02:45 +00:00
}
2020-04-17 16:02:45 +00:00
public void Inject(bool force)
{
2020-04-19 17:36:03 +00:00
ValidatePathsStillExist();
/* var task = new Task(() => runInjectThread(true));
task.Start();*/
Task.Run(() =>
2020-04-17 17:15:27 +00:00
{
if (Injection.Inject(GameConfiguration, RomPath, this, force)) Injected = true;
else Injected = false;
});
2020-04-19 17:36:03 +00:00
DownloadWait dw = new DownloadWait("Injecting Game - Please Wait", "", this);
try
{
2020-04-30 15:01:41 +00:00
dw.changeOwner(mw);
}
catch(Exception e) { }
2020-04-19 17:36:03 +00:00
dw.ShowDialog();
Progress = 0;
if (Injected)
{
Custom_Message cm = new Custom_Message("Finished Injection Part", "Injection Finished, please choose how you want to export the Inject next.");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
}
}
private void BaseCheck()
{
if (Directory.Exists(@"bin\bases"))
{
var test = GetMissingVCBs();
if (test.Count > 0)
{
2020-04-19 17:36:03 +00:00
if (CheckForInternetConnection())
{
Progress = 0;
Task.Run(() =>
{
double stuff = 100 / test.Count;
foreach (string s in test)
{
DownloadBase(s, this);
Progress += Convert.ToInt32(stuff);
}
Progress = 100;
});
DownloadWait dw = new DownloadWait("Downloading needed Data - Please Wait", "", this);
try
{
2020-04-30 15:01:41 +00:00
dw.changeOwner(mw);
2020-04-19 17:36:03 +00:00
}
catch (Exception) { }
dw.ShowDialog();
BaseCheck();
}
else
{
Custom_Message dw = new Custom_Message("No Internet connection", "You have files missing, which need to be downloaded but you dont have an Internet Connection.\nThe Program will now terminate");
try
{
dw.Owner = mw;
}
catch (Exception) { }
dw.ShowDialog();
Environment.Exit(1);
}
}
}
else
{
if (CheckForInternetConnection())
{
Directory.CreateDirectory(@"bin\bases");
var test = GetMissingVCBs();
Progress = 0;
Task.Run(() =>
{
double stuff = 100 / test.Count;
foreach (string s in test)
{
DownloadBase(s, this);
Progress += Convert.ToInt32(stuff);
}
Progress = 100;
});
2020-04-17 17:15:27 +00:00
DownloadWait dw = new DownloadWait("Downloading needed Data - Please Wait", "", this);
try
{
2020-04-30 15:01:41 +00:00
dw.changeOwner(mw);
2020-04-17 17:15:27 +00:00
}
catch (Exception) { }
dw.ShowDialog();
2020-04-19 17:36:03 +00:00
Progress = 0;
BaseCheck();
}
2020-04-19 17:36:03 +00:00
else
{
Custom_Message dw = new Custom_Message("No Internet connection", "You have files missing, which need to be downloaded but you dont have an Internet Connection.\nThe Program will now terminate");
try
{
dw.Owner = mw;
}
catch (Exception) { }
dw.ShowDialog();
Environment.Exit(1);
}
}
2020-04-19 17:36:03 +00:00
}
public void UpdateTools()
{
if (CheckForInternetConnection())
{
string[] bases = ToolCheck.ToolNames;
Task.Run(() =>
{
2020-04-19 17:36:03 +00:00
Progress = 0;
double l = 100 / bases.Length;
foreach (string s in bases)
{
2020-04-19 17:36:03 +00:00
DeleteTool(s);
DownloadTool(s, this);
Progress += Convert.ToInt32(l);
}
Progress = 100;
});
2020-04-19 17:36:03 +00:00
DownloadWait dw = new DownloadWait("Updating Tools - Please Wait", "", this);
2020-04-17 17:15:27 +00:00
try
{
2020-04-30 15:01:41 +00:00
dw.changeOwner(mw);
2020-04-17 17:15:27 +00:00
}
2020-04-19 17:36:03 +00:00
catch (Exception)
{
2020-04-19 17:36:03 +00:00
}
dw.ShowDialog();
Custom_Message cm = new Custom_Message("Finished Update", "Finished Updating Tools! Restarting UWUVCI AIO");
try
{
2020-04-19 17:36:03 +00:00
cm.Owner = mw;
}
2020-04-19 17:36:03 +00:00
catch (Exception) { }
cm.ShowDialog();
System.Diagnostics.Process.Start(System.Windows.Application.ResourceAssembly.Location);
Environment.Exit(0);
}
2020-04-19 17:36:03 +00:00
}
2020-04-17 16:02:45 +00:00
public void ResetTKQuest()
{
Custom_Message cm = new Custom_Message("Resetting TitleKeys", "This Option will reset all entered TitleKeys meaning you will need to reenter them again!\nDo you still wish to continue?");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
cm.Close();
2020-04-17 16:02:45 +00:00
}
public void ResetTitleKeys()
{
File.Delete("bin/keys/gba.vck");
File.Delete("bin/keys/nds.vck");
File.Delete("bin/keys/nes.vck");
File.Delete("bin/keys/n64.vck");
File.Delete("bin/keys/msx.vck");
File.Delete("bin/keys/tg16.vck");
File.Delete("bin/keys/snes.vck");
File.Delete("bin/keys/wii.vck");
Custom_Message cm = new Custom_Message("Reset Successful", "The TitleKeys are now reset.\nThe Program will now restart.");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
mw.Close();
System.Diagnostics.Process.Start(System.Windows.Application.ResourceAssembly.Location);
Environment.Exit(0);
}
public void UpdateBases()
{
2020-04-19 17:36:03 +00:00
if (CheckForInternetConnection())
2020-04-17 17:15:27 +00:00
{
2020-04-19 17:36:03 +00:00
string[] bases = { "bases.vcbnds", "bases.vcbn64", "bases.vcbgba", "bases.vcbsnes", "bases.vcbnes", "bases.vcbtg16", "bases.vcbmsx", "bases.vcbwii" };
Task.Run(() => {
Progress = 0;
double l = 100 / bases.Length;
foreach (string s in bases)
{
DeleteBase(s);
DownloadBase(s, this);
GameConsoles g = new GameConsoles();
if (s.Contains("nds")) g = GameConsoles.NDS;
if (s.Contains("nes")) g = GameConsoles.NES;
if (s.Contains("snes")) g = GameConsoles.SNES;
if (s.Contains("n64")) g = GameConsoles.N64;
if (s.Contains("gba")) g = GameConsoles.GBA;
if (s.Contains("tg16")) g = GameConsoles.TG16;
if (s.Contains("msx")) g = GameConsoles.MSX;
if (s.Contains("wii")) g = GameConsoles.WII;
UpdateKeyFile(VCBTool.ReadBasesFromVCB($@"bin/bases/{s}"), g);
Progress += Convert.ToInt32(l);
}
Progress = 100;
});
DownloadWait dw = new DownloadWait("Updating Base Files - Please Wait", "", this);
try
{
2020-04-30 15:01:41 +00:00
dw.changeOwner(mw);
2020-04-19 17:36:03 +00:00
}
catch (Exception)
{
2020-04-17 17:15:27 +00:00
2020-04-19 17:36:03 +00:00
}
dw.ShowDialog();
Custom_Message cm = new Custom_Message("Finished Updating", "Finished Updating Bases! Restarting UWUVCI AIO");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
System.Diagnostics.Process.Start(System.Windows.Application.ResourceAssembly.Location);
Environment.Exit(0);
2020-04-17 17:15:27 +00:00
}
}
2020-04-16 04:41:25 +00:00
public bool checkSysKey(string key)
{
if(key.GetHashCode() == -589797700)
{
Properties.Settings.Default.SysKey = key;
Properties.Settings.Default.Save();
return true;
}
return false;
}
public bool SysKey1set()
{
return checkSysKey1(Properties.Settings.Default.SysKey1);
}
public bool checkSysKey1(string key)
{
if (key.GetHashCode() == -1230232583)
{
Properties.Settings.Default.SysKey1 = key;
Properties.Settings.Default.Save();
return true;
}
return false;
}
public bool SysKeyset()
{
return checkSysKey(Properties.Settings.Default.SysKey);
}
2020-04-06 19:30:31 +00:00
public bool GetConsoleOfConfig(string configPath, GameConsoles console)
{
FileInfo fn = new FileInfo(configPath);
if (fn.Extension.Contains("uwuvci"))
{
FileStream inputConfigStream = new FileStream(configPath, FileMode.Open, FileAccess.Read);
GZipStream decompressedConfigStream = new GZipStream(inputConfigStream, CompressionMode.Decompress);
IFormatter formatter = new BinaryFormatter();
GameConfig check = (GameConfig)formatter.Deserialize(decompressedConfigStream);
if (check.Console == console) return true;
}
return false;
}
public void selectConfig(GameConsoles console)
2020-04-06 19:30:31 +00:00
{
string ret = string.Empty;
using (var dialog = new System.Windows.Forms.OpenFileDialog())
{
2020-04-30 15:01:41 +00:00
dialog.InitialDirectory = Path.Combine(Directory.GetCurrentDirectory(), "configs");
2020-04-06 19:30:31 +00:00
dialog.Filter = "UWUVCI Config (*.uwuvci) | *.uwuvci";
DialogResult res = dialog.ShowDialog();
if (res == DialogResult.OK)
{
ret = dialog.FileName;
if (GetConsoleOfConfig(ret, console))
{
ImportConfig(ret);
Custom_Message cm = new Custom_Message("Import Complete", "Importing of Config completed.\nPlease reselect a Base!");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
}
else
{
Custom_Message cm = new Custom_Message("Import Failed", $"The config you are trying to import is not made for {console.ToString()} Injections. \nPlease choose a config made for these kind of Injections or choose a different kind of Injection");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
}
2020-04-06 19:30:31 +00:00
}
}
}
private bool RemoteFileExists(string url)
{
try
{
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
request.Method = "HEAD";
HttpWebResponse response = request.GetResponse() as HttpWebResponse;
response.Close();
return (response.StatusCode == HttpStatusCode.OK);
}
catch
{
return false;
}
2020-04-06 19:30:31 +00:00
}
public string GetFilePath(bool ROM, bool INI)
{
Custom_Message cm;
string ret = string.Empty;
2020-04-25 06:40:38 +00:00
if (ROM && !INI)
{
switch (GameConfiguration.Console)
{
case GameConsoles.NDS:
2020-05-07 07:49:36 +00:00
cm = new Custom_Message("Information", "You can only inject NDS ROMs that are not DSi Enhanced (example for not working: Pokémon Black & White)\n\nIf attempting to inject a DSi Enhanced ROM, we will not give you any support with fixing said injection. ");
try
{
cm.Owner = mw;
}
catch (Exception) { }
2020-05-07 07:49:36 +00:00
if (!Properties.Settings.Default.ndsw)
{
cm.ShowDialog();
}
break;
case GameConsoles.SNES:
2020-05-07 07:49:36 +00:00
cm = new Custom_Message("Information", "You can only inject SNES ROMs that are not using any Co-Processors (example for not working: Star Fox)\n\nIf attempting to inject a ROM in need of a Co-Processor, we will not give you any support with fixing said injection. ");
try
{
cm.Owner = mw;
}
catch (Exception) { }
2020-05-07 07:49:36 +00:00
if (!Properties.Settings.Default.snesw)
{
cm.ShowDialog();
}
2020-04-17 16:02:45 +00:00
break;
}
}
using (var dialog = new System.Windows.Forms.OpenFileDialog())
{
if (ROM)
{
2020-04-25 06:40:38 +00:00
if (INI)
{
dialog.Filter = "BootSound Files (*.mp3; *.wav; *.btsnd) | *.mp3;*.wav;*.btsnd";
}
else if (GC)
{
dialog.Filter = "GCN ROM (*.iso; *.gcm) | *.iso; *.gcm";
}
else
{
switch (GameConfiguration.Console)
{
case GameConsoles.NDS:
dialog.Filter = "Nintendo DS ROM (*.nds; *.srl) | *.nds;*.srl";
break;
case GameConsoles.N64:
dialog.Filter = "Nintendo 64 ROM (*.n64; *.v64; *.z64) | *.n64;*.v64;*.z64";
break;
case GameConsoles.GBA:
dialog.Filter = "GameBoy Series ROM (*.gba;*.gbc;*.gb) | *.gba;*.gbc;*.gb";
break;
case GameConsoles.NES:
dialog.Filter = "Nintendo Entertainment System ROM (*.nes) | *.nes";
break;
case GameConsoles.SNES:
dialog.Filter = "Super Nintendo Entertainment System ROM (*.sfc; *.smc) | *.sfc;*.smc";
break;
case GameConsoles.TG16:
dialog.Filter = "TurboGrafX-16 ROM (*.pce) | *.pce";
break;
case GameConsoles.MSX:
dialog.Filter = "MSX/MSX2 ROM (*.ROM) | *.ROM";
break;
case GameConsoles.WII:
if(test == GameConsoles.GCN)
{
dialog.Filter = "GCN ROM (*.iso; *.gcm) | *.iso; *.gcm";
}
else
{
2020-05-06 21:53:52 +00:00
dialog.Filter = "Wii ROM (*.iso; *.wbfs; *.nkit.iso; *.nkit.gcz) | *.iso; *.wbfs; *.nkit.iso; *.nkit.gcz";
}
break;
case GameConsoles.GCN:
2020-05-06 21:53:52 +00:00
dialog.Filter = "GCN ROM (*.iso; *.gcm; *.nkit.iso; *.nkit.gcz) | *.iso; *.gcm; *.nkit.iso; *.nkit.gcz";
break;
}
}
}
else if(!INI)
{
2020-04-25 06:40:38 +00:00
dialog.Filter = "BootImages (*.png; *.jpg; *.bmp; *.tga) | *.png;*.jpg;*.bmp;*.tga";
}
2020-04-25 06:40:38 +00:00
else if(INI)
{
dialog.Filter = "N64 VC Configuration (*.ini) | *.ini";
}
if (Directory.Exists("SourceFiles"))
{
dialog.InitialDirectory = "SourceFiles";
}
DialogResult res = dialog.ShowDialog();
if(res == DialogResult.OK)
{
2020-05-06 21:53:52 +00:00
if (dialog.FileName.ToLower().Contains(".gcz"))
{
Custom_Message cm1 = new Custom_Message("Information", "Using a GameCube GCZ Nkit for a Wii Inject or vice versa will break things.\nYou will not be able to grab the BootImages or GameName using this type of ROM. ");
try
{
cm1.Owner = mw;
}catch(Exception e)
{
}
2020-05-07 07:49:36 +00:00
if (!Properties.Settings.Default.gczw)
{
cm1.ShowDialog();
}
2020-05-06 21:53:52 +00:00
}
ret = dialog.FileName;
}
2020-05-06 21:53:52 +00:00
else
{
if (dialog.Filter.Contains("BootImages") || dialog.Filter.Contains("BootSound"))
{
ret = "";
}
}
}
return ret;
}
public GameConsoles test;
private static void CopyBase(string console)
{
File.Copy(console, $@"bin\bases\{console}");
File.Delete(console);
}
private static void DeleteTool(string tool)
{
File.Delete($@"bin\Tools\{tool}");
}
private static void DeleteBase(string console)
{
File.Delete($@"bin\bases\{console}");
}
public static List<string> GetMissingVCBs()
{
List<string> ret = new List<string>();
string path = @"bin\bases\bases.vcb";
if (!File.Exists(path + "nds"))
{
ret.Add(path + "nds");
}
if (!File.Exists(path + "nes"))
{
ret.Add(path + "nes");
}
if (!File.Exists(path + "n64"))
{
ret.Add(path + "n64");
}
if (!File.Exists(path + "snes"))
{
ret.Add(path + "snes");
}
if (!File.Exists(path + "gba"))
{
ret.Add(path + "gba");
}
if (!File.Exists(path + "tg16"))
{
ret.Add(path + "tg16");
}
2020-04-07 01:09:05 +00:00
if (!File.Exists(path + "msx"))
{
ret.Add(path + "msx");
}
2020-04-16 04:41:25 +00:00
if (!File.Exists(path + "wii"))
{
ret.Add(path + "wii");
}
return ret;
}
public static void DownloadBase(string name, MainViewModel mvm)
{
string olddir = Directory.GetCurrentDirectory();
try
{
string basePath = $@"bin\bases\";
Directory.SetCurrentDirectory(basePath);
using (var client = new WebClient())
{
var fixname = name.Split('\\');
client.DownloadFile(getDownloadLink(name, false), fixname[fixname.Length -1]);
}
}catch(Exception e)
{
Console.WriteLine(e.Message);
Custom_Message cm = new Custom_Message("Error 005: \"Unable to Download VCB Base\"", "There was an Error downloading the VCB Base File.\nThe Programm will now terminate.");
try
{
cm.Owner = mvm.mw;
}
catch (Exception) { }
cm.ShowDialog();
Environment.Exit(1);
}
Directory.SetCurrentDirectory(olddir);
}
public static void DownloadTool(string name, MainViewModel mvm)
{
string olddir = Directory.GetCurrentDirectory();
try
{
string basePath = $@"bin\Tools\";
Directory.SetCurrentDirectory(basePath);
using (var client = new WebClient())
{
client.DownloadFile(getDownloadLink(name, true), name);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Custom_Message cm = new Custom_Message("Error 006: \"Unable to Download Tool\"", "There was an Error downloading the Tool.\nThe Programm will now terminate.");
try
{
cm.Owner = mvm.mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-04-17 16:02:45 +00:00
Environment.Exit(1);
}
Directory.SetCurrentDirectory(olddir);
}
private static string getDownloadLink(string toolname, bool tool)
{
try
{
WebRequest request;
//get download link from uwuvciapi
if (tool)
{
request = WebRequest.Create("https://uwuvciapi.azurewebsites.net/GetToolLink?tool=" + toolname);
}
else
{
request = WebRequest.Create("https://uwuvciapi.azurewebsites.net/GetVcbLink?vcb=" + toolname);
}
var response = request.GetResponse();
using (Stream dataStream = response.GetResponseStream())
{
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader(dataStream);
// Read the content.
string responseFromServer = reader.ReadToEnd();
// Display the content.
return responseFromServer;
}
}
catch (Exception)
{
return null;
}
}
public void InjcttoolCheck()
{
if (ToolCheck.DoesToolsFolderExist())
{
List<MissingTool> missingTools = new List<MissingTool>();
missingTools = ToolCheck.CheckForMissingTools();
if (missingTools.Count > 0)
{
foreach (MissingTool m in missingTools)
{
DownloadTool(m.Name,this);
}
InjcttoolCheck();
}
}
else
{
string path = $@"{Directory.GetCurrentDirectory()}bin\\Tools";
Directory.CreateDirectory($@"{Directory.GetCurrentDirectory()}bin\\Tools");
InjcttoolCheck();
}
}
2020-04-17 17:15:27 +00:00
private void ThreadDownload(List<MissingTool> missingTools)
{
2020-04-17 17:15:27 +00:00
var thread = new Thread(() =>
{
double l = 100 / missingTools.Count;
2020-04-17 17:15:27 +00:00
foreach (MissingTool m in missingTools)
{
DownloadTool(m.Name,this);
2020-04-17 17:15:27 +00:00
Progress += Convert.ToInt32(l);
}
Progress = 100;
});
thread.SetApartmentState(ApartmentState.STA);
2020-04-17 17:15:27 +00:00
thread.Start();
}
private void timer_Tick2(object sender, EventArgs e)
{
if (Progress == 100)
{
Injectwait.Close();
2020-04-19 17:36:03 +00:00
timer.Stop();
Progress = 0;
}
}
private void toolCheck()
{
if (ToolCheck.DoesToolsFolderExist())
{
List<MissingTool> missingTools = new List<MissingTool>();
missingTools = ToolCheck.CheckForMissingTools();
2020-04-17 17:15:27 +00:00
if(missingTools.Count > 0)
{
2020-04-19 17:36:03 +00:00
if (CheckForInternetConnection())
{
Task.Run(() => ThreadDownload(missingTools));
2020-04-30 15:01:41 +00:00
DownloadWait dw = new DownloadWait("Downloading Tools - Please Wait", "", this);
try
{
dw.changeOwner(mw);
}
catch (Exception)
{
}
dw.ShowDialog();
2020-04-19 17:36:03 +00:00
Thread.Sleep(200);
//Download Tools
Progress = 0;
toolCheck();
2020-04-19 17:36:03 +00:00
}
else
{
Custom_Message dw = new Custom_Message("No Internet connection", "You have files missing, which need to be downloaded but you dont have an Internet Connection.\nThe Program will now terminate");
try
{
dw.Owner = mw;
}
catch (Exception) { }
dw.ShowDialog();
Environment.Exit(1);
}
}
}
else
{
Directory.CreateDirectory("bin/Tools");
toolCheck();
}
}
public void UpdatePathSet()
{
PathsSet = Settings.Default.PathsSet;
if(BaseStore != Settings.Default.BasePath)
{
BaseStore = Settings.Default.BasePath;
}
if (InjectStore != Settings.Default.BasePath)
{
InjectStore = Settings.Default.OutPath;
}
}
public bool ValidatePathsStillExist()
{
bool ret = false;
bool basep = false;
try
{
if (Directory.Exists(Settings.Default.BasePath))
{
basep = true;
}
else
{
2020-04-19 17:36:03 +00:00
if (!Directory.Exists(Path.Combine(Directory.GetCurrentDirectory(), "bin","BaseGames"))) Directory.CreateDirectory(Path.Combine(Directory.GetCurrentDirectory(), "bin", "BaseGames"));
Settings.Default.BasePath = Path.Combine(Directory.GetCurrentDirectory(), "bin", "BaseGames");
Settings.Default.PathsSet = true;
Settings.Default.Save();
}
if (Directory.Exists(Settings.Default.OutPath))
{
if (basep)
{
ret = true;
}
}
else
{
2020-04-19 17:36:03 +00:00
if (!Directory.Exists(Path.Combine(Directory.GetCurrentDirectory(), "InjectedGames"))) Directory.CreateDirectory(Path.Combine(Directory.GetCurrentDirectory(), "InjectedGames"));
Settings.Default.OutPath = Path.Combine(Directory.GetCurrentDirectory(), "InjectedGames");
Settings.Default.PathsSet = true;
Settings.Default.Save();
}
}
catch (Exception)
{
ret = false;
}
return ret;
2020-03-01 15:07:22 +00:00
}
public void GetBases(GameConsoles Console)
{
List<GameBases> lTemp = new List<GameBases>();
string vcbpath = $@"bin/bases/bases.vcb{Console.ToString().ToLower()}";
lTemp = VCBTool.ReadBasesFromVCB(vcbpath);
LBases.Clear();
GameBases custom = new GameBases();
custom.Name = "Custom";
custom.Region = Regions.EU;
LBases.Add(custom);
foreach(GameBases gb in lTemp)
{
LBases.Add(gb);
}
lGameBasesString.Clear();
foreach(GameBases gb in LBases)
{
LGameBasesString.Add($"{gb.Name} {gb.Region}");
}
}
public GameBases getBasefromName(string Name)
{
string NameWORegion = Name.Remove(Name.Length - 3, 3);
string Region = Name.Remove(0, Name.Length - 2);
foreach(GameBases b in LNDS)
{
if(b.Name == NameWORegion && b.Region.ToString() == Region)
{
return b;
}
}
foreach (GameBases b in LN64)
{
if (b.Name == NameWORegion && b.Region.ToString() == Region)
{
return b;
}
}
foreach (GameBases b in LNES)
{
if (b.Name == NameWORegion && b.Region.ToString() == Region)
{
return b;
}
}
foreach (GameBases b in LSNES)
{
if (b.Name == NameWORegion && b.Region.ToString() == Region)
{
return b;
}
}
foreach (GameBases b in LGBA)
{
if (b.Name == NameWORegion && b.Region.ToString() == Region)
{
return b;
}
}
foreach (GameBases b in LTG16)
{
if (b.Name == NameWORegion && b.Region.ToString() == Region)
{
return b;
}
}
2020-04-07 01:09:05 +00:00
foreach (GameBases b in LMSX)
{
if (b.Name == NameWORegion && b.Region.ToString() == Region)
{
return b;
}
}
2020-04-16 04:41:25 +00:00
foreach (GameBases b in LWII)
{
if (b.Name == NameWORegion && b.Region.ToString() == Region)
{
return b;
}
}
return null;
}
private void GetAllBases()
{
LN64.Clear();
LNDS.Clear();
LNES.Clear();
LSNES.Clear();
LGBA.Clear();
LTG16.Clear();
2020-04-16 04:41:25 +00:00
LMSX.Clear();
LWII.Clear();
lNDS = VCBTool.ReadBasesFromVCB($@"bin/bases/bases.vcbnds");
lNES = VCBTool.ReadBasesFromVCB($@"bin/bases/bases.vcbnes");
lSNES = VCBTool.ReadBasesFromVCB($@"bin/bases/bases.vcbsnes");
lN64 = VCBTool.ReadBasesFromVCB($@"bin/bases/bases.vcbn64");
lGBA = VCBTool.ReadBasesFromVCB($@"bin/bases/bases.vcbgba");
lTG16 = VCBTool.ReadBasesFromVCB($@"bin/bases/bases.vcbtg16");
lMSX = VCBTool.ReadBasesFromVCB($@"bin/bases/bases.vcbmsx");
lWii = VCBTool.ReadBasesFromVCB($@"bin/bases/bases.vcbwii");
CreateSettingIfNotExist(lNDS, GameConsoles.NDS);
CreateSettingIfNotExist(lNES, GameConsoles.NES);
CreateSettingIfNotExist(lSNES, GameConsoles.SNES);
CreateSettingIfNotExist(lGBA, GameConsoles.GBA);
CreateSettingIfNotExist(lN64, GameConsoles.N64);
CreateSettingIfNotExist(lTG16, GameConsoles.TG16);
2020-04-07 01:09:05 +00:00
CreateSettingIfNotExist(lMSX, GameConsoles.MSX);
2020-04-16 04:41:25 +00:00
CreateSettingIfNotExist(lWii, GameConsoles.WII);
}
private void CreateSettingIfNotExist(List<GameBases> l, GameConsoles console)
{
string file = $@"bin\keys\{console.ToString().ToLower()}.vck";
if (!File.Exists(file))
{
List<TKeys> temp = new List<TKeys>();
foreach(GameBases gb in l)
{
TKeys tempkey = new TKeys();
tempkey.Base = gb;
temp.Add(tempkey);
}
KeyFile.ExportFile(temp, console);
}
}
private void UpdateKeyFile(List<GameBases> l, GameConsoles console)
{
string file = $@"bin\keys\{console.ToString().ToLower()}.vck";
if (File.Exists(file))
{
List<TKeys> keys = KeyFile.ReadBasesFromKeyFile($@"bin\keys\{console.ToString().ToLower()}.vck");
List <TKeys> newTK = new List<TKeys>();
foreach(GameBases gb in l)
{
bool inOld = false;
foreach(TKeys tk in keys)
{
if(gb.Name == tk.Base.Name && gb.Region == tk.Base.Region)
{
newTK.Add(tk);
inOld = true;
}
if (inOld) break;
}
if (!inOld)
{
TKeys tkn = new TKeys();
tkn.Base = gb;
tkn.Tkey = null;
newTK.Add(tkn);
}
}
File.Delete($@"bin\keys\{console.ToString().ToLower()}.vck");
KeyFile.ExportFile(newTK, console);
}
}
public void getTempList(GameConsoles console)
{
switch (console)
{
case GameConsoles.NDS:
Ltemp = LNDS;
break;
case GameConsoles.N64:
Ltemp = LN64;
break;
case GameConsoles.GBA:
Ltemp = LGBA;
break;
case GameConsoles.NES:
Ltemp = LNES;
break;
case GameConsoles.SNES:
Ltemp = LSNES;
break;
case GameConsoles.TG16:
Ltemp = LTG16;
break;
2020-04-07 01:09:05 +00:00
case GameConsoles.MSX:
Ltemp = LMSX;
break;
2020-04-16 04:41:25 +00:00
case GameConsoles.WII:
Ltemp = LWII;
break;
}
}
public void EnterKey(bool ck)
{
EnterKey ek = new EnterKey(ck);
2020-04-19 17:36:03 +00:00
try
{
ek.Owner = mw;
}catch(Exception e) { }
ek.ShowDialog();
}
public bool checkcKey(string key)
{
if (1274359530 == key.ToLower().GetHashCode())
{
Settings.Default.Ckey = key.ToLower();
2020-04-19 17:36:03 +00:00
ckeys = true;
Settings.Default.Save();
return true;
}
2020-04-19 17:36:03 +00:00
ckeys = false;
return false;
}
public bool isCkeySet()
{
if (Settings.Default.Ckey.ToLower().GetHashCode() == 1274359530)
{
2020-04-19 17:36:03 +00:00
ckeys = true;
return true;
}
else
{
2020-04-19 17:36:03 +00:00
ckeys = false;
return false;
}
}
2020-03-23 23:18:36 +00:00
public bool checkKey(string key)
{
if(GbTemp.KeyHash == key.ToLower().GetHashCode())
{
UpdateKeyInFile(key, $@"bin\keys\{GetConsoleOfBase(gbTemp).ToString().ToLower()}.vck", GbTemp, GetConsoleOfBase(gbTemp));
2020-03-23 23:18:36 +00:00
return true;
}
2020-03-23 23:18:36 +00:00
return false;
}
public void UpdateKeyInFile(string key, string file, GameBases Base, GameConsoles console)
{
if (File.Exists(file))
{
var temp = KeyFile.ReadBasesFromKeyFile(file);
foreach(TKeys t in temp)
{
if(t.Base.Name == Base.Name && t.Base.Region == Base.Region)
{
t.Tkey = key;
}
}
File.Delete(file);
KeyFile.ExportFile(temp, console);
}
}
public bool isKeySet(GameBases bases)
{
var temp = KeyFile.ReadBasesFromKeyFile($@"bin\keys\{GetConsoleOfBase(bases).ToString().ToLower()}.vck");
foreach(TKeys t in temp)
{
if(t.Base.Name == bases.Name && t.Base.Region == bases.Region)
{
if(t.Tkey != null)
{
return true;
}
}
}
return false;
}
public void ImageWarning()
{
Custom_Message cm = new Custom_Message("Image Warning", "Images need to either be in a Bit Depth of 32bit or 24bit. \nIf using Tools like paint.net do not choose the Auto function.");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
}
2020-04-17 16:02:45 +00:00
public bool choosefolder = false;
public bool CBaseConvertInfo()
{
bool ret = false;
Custom_Message cm = new Custom_Message("NUS Custom Base", "You seem to have added a NUS format Custom Base.\nDo you want it to be converted to be used with the Injector?");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-04-17 16:02:45 +00:00
if (choosefolder)
{
ret = true;
2020-04-17 16:02:45 +00:00
choosefolder = false;
}
return ret;
}
public TKeys getTkey(GameBases bases)
{
var temp = KeyFile.ReadBasesFromKeyFile($@"bin\keys\{GetConsoleOfBase(bases).ToString().ToLower()}.vck");
foreach (TKeys t in temp)
{
if (t.Base.Name == bases.Name && t.Base.Region == bases.Region)
{
if (t.Tkey != null)
{
return t;
}
}
}
return null;
}
public void ThreadDOwn()
{
}
public void Download()
{
2020-04-19 17:36:03 +00:00
ValidatePathsStillExist();
if (CheckForInternetConnection())
2020-04-17 17:15:27 +00:00
{
2020-04-19 17:36:03 +00:00
Task.Run(() => { Injection.Download(this); });
DownloadWait dw = new DownloadWait("Downloading Base - Please Wait", "", this);
try
{
2020-04-30 15:01:41 +00:00
dw.changeOwner(mw);
2020-04-19 17:36:03 +00:00
}
catch (Exception) { }
dw.ShowDialog();
Progress = 0;
2020-04-17 17:15:27 +00:00
}
2020-04-19 17:36:03 +00:00
}
public GameConsoles GetConsoleOfBase(GameBases gb)
{
GameConsoles ret = new GameConsoles();
bool cont = false;
foreach(GameBases b in lNDS)
{
if(b.Name == gb.Name && b.Region == gb.Region)
{
ret = GameConsoles.NDS;
cont = true;
}
}
if (!cont)
{
foreach (GameBases b in lN64)
{
if (b.Name == gb.Name && b.Region == gb.Region)
{
ret = GameConsoles.N64;
cont = true;
}
}
}
if (!cont)
{
foreach (GameBases b in lNES)
{
if (b.Name == gb.Name && b.Region == gb.Region)
{
ret = GameConsoles.NES;
cont = true;
}
}
}
if (!cont)
{
foreach (GameBases b in lSNES)
{ if(b.Name == gb.Name && b.Region == gb.Region)
{
ret = GameConsoles.SNES;
cont = true;
}
}
}
if (!cont)
{
foreach (GameBases b in lGBA)
{
if (b.Name == gb.Name && b.Region == gb.Region)
{
ret = GameConsoles.GBA;
cont = true;
}
}
}
if (!cont)
{
foreach (GameBases b in lTG16)
{
if (b.Name == gb.Name && b.Region == gb.Region)
{
ret = GameConsoles.TG16;
cont = true;
}
}
}
2020-04-07 01:09:05 +00:00
if (!cont)
{
foreach (GameBases b in lMSX)
{
if (b.Name == gb.Name && b.Region == gb.Region)
{
ret = GameConsoles.MSX;
cont = true;
}
}
}
2020-04-16 04:41:25 +00:00
if (!cont)
{
foreach (GameBases b in lWii)
{
if (b.Name == gb.Name && b.Region == gb.Region)
{
ret = GameConsoles.WII;
cont = true;
}
}
}
return ret;
}
public List<bool> getInfoOfBase(GameBases gb)
{
List<bool> info = new List<bool>();
if (Directory.Exists($@"{Settings.Default.BasePath}\{gb.Name.Replace(":","")} [{gb.Region}]"))
{
info.Add(true);
}
else
{
info.Add(false);
}
if (isKeySet(gb))
{
info.Add(true);
}
else
{
info.Add(false);
}
if (isCkeySet())
{
info.Add(true);
}
else
{
info.Add(false);
}
return info;
}
2020-04-17 16:02:45 +00:00
public void SetInjectPath()
{
2020-04-20 09:31:26 +00:00
using (var dialog = new CommonOpenFileDialog())
{
2020-04-20 09:31:26 +00:00
dialog.IsFolderPicker = true;
CommonFileDialogResult result = dialog.ShowDialog();
if(result == CommonFileDialogResult.Ok)
{
try
{
2020-04-20 09:31:26 +00:00
if (DirectoryIsEmpty(dialog.FileName))
{
2020-04-20 09:31:26 +00:00
Settings.Default.OutPath = dialog.FileName;
Settings.Default.SetOutOnce = true;
Settings.Default.Save();
UpdatePathSet();
}
else
{
Custom_Message cm = new Custom_Message("Information", "Folder contains Files or Subfolders, do you really want to use this folder as the Inject Folder?");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-04-17 16:02:45 +00:00
if (choosefolder)
{
2020-04-17 16:02:45 +00:00
choosefolder = false;
2020-04-20 09:31:26 +00:00
Settings.Default.OutPath = dialog.FileName;
Settings.Default.SetOutOnce = true;
Settings.Default.Save();
UpdatePathSet();
2020-04-17 16:02:45 +00:00
}
else
{
SetInjectPath();
}
}
}catch(Exception e)
{
Console.WriteLine(e.Message);
Custom_Message cm = new Custom_Message("Error", "An Error occured, please try again!");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
}
}
}
ArePathsSet();
}
public void SetBasePath()
{
2020-04-20 09:31:26 +00:00
using (var dialog = new CommonOpenFileDialog())
{
2020-04-20 09:31:26 +00:00
dialog.IsFolderPicker = true;
CommonFileDialogResult result = dialog.ShowDialog();
if (result == CommonFileDialogResult.Ok)
{
try
{
2020-04-20 09:31:26 +00:00
if (DirectoryIsEmpty(dialog.FileName))
{
2020-04-20 09:31:26 +00:00
Settings.Default.BasePath = dialog.FileName;
Settings.Default.SetBaseOnce = true;
Settings.Default.Save();
UpdatePathSet();
}
else
{
2020-04-20 09:31:26 +00:00
Custom_Message cm = new Custom_Message("Information", "Folder contains Files or Subfolders, do you really want to use this folder as the Bases Folder?");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-04-17 16:02:45 +00:00
if (choosefolder)
{
2020-04-17 16:02:45 +00:00
choosefolder = false;
2020-04-20 09:31:26 +00:00
Settings.Default.BasePath = dialog.FileName;
Settings.Default.SetBaseOnce = true;
Settings.Default.Save();
UpdatePathSet();
2020-04-20 09:31:26 +00:00
}
else
{
2020-04-20 09:31:26 +00:00
SetInjectPath();
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
Custom_Message cm = new Custom_Message("Error", "An Error occured, please try again!");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
}
}
}
ArePathsSet();
}
public void ArePathsSet()
{
if (ValidatePathsStillExist())
{
Settings.Default.PathsSet = true;
Settings.Default.Save();
}
UpdatePathSet();
}
public bool DirectoryIsEmpty(string path)
{
int fileCount = Directory.GetFiles(path).Length;
if (fileCount > 0)
{
return false;
}
string[] dirs = Directory.GetDirectories(path);
foreach (string dir in dirs)
{
if (!DirectoryIsEmpty(dir))
{
return false;
}
}
return true;
}
2020-04-21 20:54:32 +00:00
public void getBootIMGGBA(string rom)
2020-04-17 01:51:56 +00:00
{
2020-04-21 19:52:52 +00:00
string linkbase = "https://raw.githubusercontent.com/Flumpster/UWUVCI-Images/master/";
string repoid = "";
2020-04-21 20:54:32 +00:00
string SystemType = "gba/";
2020-04-21 19:52:52 +00:00
IMG_Message img = null;
using (var fs = new FileStream(rom,
FileMode.Open,
FileAccess.Read))
{
2020-04-21 20:54:32 +00:00
byte[] procode = new byte[4];
fs.Seek(0xAC, SeekOrigin.Begin);
fs.Read(procode, 0, 4);
2020-04-21 19:52:52 +00:00
repoid = ByteArrayToString(procode);
Regex rgx = new Regex("[^a-zA-Z0-9 -]");
repoid = rgx.Replace(repoid, "");
Console.WriteLine("prodcode before scramble: " + repoid);
fs.Close();
Console.WriteLine("prodcode after scramble: " + repoid);
}
2020-05-06 21:53:52 +00:00
List<string> repoids = new List<string>();
2020-05-04 16:20:21 +00:00
string[] ext = { "png"};
2020-04-21 19:52:52 +00:00
if (CheckForInternetConnectionWOWarning())
{
2020-05-06 21:53:52 +00:00
repoids.Add(SystemType + repoid);
repoids.Add(SystemType + repoid.Substring(0, 3) + "E");
repoids.Add(SystemType + repoid.Substring(0, 3) + "P");
repoids.Add(SystemType + repoid.Substring(0, 3) + "J");
foreach (var e in ext)
2020-04-21 19:52:52 +00:00
{
if (RemoteFileExists(linkbase + SystemType + repoid + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog();
break;
2020-04-21 19:52:52 +00:00
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "E" + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
repoid = repoid.Substring(0, 3) + "E";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog();
break;
2020-04-21 19:52:52 +00:00
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "P" + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
repoid = repoid.Substring(0, 3) + "P";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}g", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog();
break;
2020-04-21 19:52:52 +00:00
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "J" + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
repoid = repoid.Substring(0, 3) + "J";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog();
break;
2020-04-21 19:52:52 +00:00
}
}
2020-04-21 20:54:32 +00:00
2020-05-06 21:53:52 +00:00
checkForAdditionalFiles(GameConsoles.GBA, repoids);
2020-04-21 20:54:32 +00:00
}
}
public void getBootIMGNDS(string rom)
{
string linkbase = "https://raw.githubusercontent.com/Flumpster/UWUVCI-Images/master/";
string repoid = "";
string SystemType = "nds/";
IMG_Message img = null;
using (var fs = new FileStream(rom,
FileMode.Open,
FileAccess.Read))
{
byte[] procode = new byte[4];
fs.Seek(0xC, SeekOrigin.Begin);
fs.Read(procode, 0, 4);
repoid = ByteArrayToString(procode);
Regex rgx = new Regex("[^a-zA-Z0-9 -]");
repoid = rgx.Replace(repoid, "");
Console.WriteLine("prodcode before scramble: " + repoid);
fs.Close();
Console.WriteLine("prodcode after scramble: " + repoid);
}
2020-05-04 16:20:21 +00:00
string[] ext = { "png" };
2020-05-06 21:53:52 +00:00
List<string> repoids = new List<string>();
2020-04-21 20:54:32 +00:00
if (CheckForInternetConnectionWOWarning())
{
2020-05-06 21:53:52 +00:00
repoids.Add(SystemType + repoid);
repoids.Add(SystemType + repoid.Substring(0, 3) + "E");
repoids.Add(SystemType + repoid.Substring(0, 3) + "P");
repoids.Add(SystemType + repoid.Substring(0, 3) + "J");
foreach (var e in ext)
2020-04-21 19:52:52 +00:00
{
if (RemoteFileExists(linkbase + SystemType + repoid + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
2020-04-21 19:52:52 +00:00
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "E" + $"/iconTex.png") == true)
2020-04-21 19:52:52 +00:00
{
repoid = repoid.Substring(0, 3) + "E";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
2020-04-21 19:52:52 +00:00
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "P" + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
repoid = repoid.Substring(0, 3) + "P";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + "/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
2020-04-21 19:52:52 +00:00
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "J" + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
repoid = repoid.Substring(0, 3) + "J";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
2020-04-21 19:52:52 +00:00
}
}
2020-05-06 21:53:52 +00:00
checkForAdditionalFiles(GameConsoles.NDS, repoids);
2020-04-21 19:52:52 +00:00
}
}
public void getBootIMGN64(string rom)
{
string linkbase = "https://raw.githubusercontent.com/Flumpster/UWUVCI-Images/master/";
string repoid = "";
string SystemType = "n64/";
IMG_Message img = null;
2020-05-06 21:53:52 +00:00
List<string> repoids = new List<string>();
2020-04-21 19:52:52 +00:00
using (var fs = new FileStream(rom,
FileMode.Open,
FileAccess.Read))
{
byte[] procode = new byte[6];
fs.Seek(0x3A, SeekOrigin.Begin);
fs.Read(procode, 0, 6);
repoid = ByteArrayToString(procode);
Regex rgx = new Regex("[^a-zA-Z0-9 -]");
repoid = rgx.Replace(repoid, "");
Console.WriteLine("prodcode before scramble: "+repoid);
fs.Close();
Console.WriteLine("prodcode after scramble: "+repoid);
}
bool found = false;
2020-05-04 16:20:21 +00:00
string[] ext = { "png" };
2020-04-21 19:52:52 +00:00
if (CheckForInternetConnectionWOWarning())
{
2020-05-06 21:53:52 +00:00
repoids.Add(SystemType + repoid);
repoids.Add(SystemType + new string(new char[] { repoid[0], repoid[2], repoid[1], repoid[3] }));
foreach (var e in ext)
2020-04-21 19:52:52 +00:00
{
if (RemoteFileExists(linkbase + SystemType + repoid + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
2020-04-21 19:52:52 +00:00
try
{
img.Owner = mw;
}
catch (Exception) { }
found = true;
img.ShowDialog(); break;
2020-04-21 19:52:52 +00:00
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "E" + $"/iconTex.png") == true)
2020-04-21 19:52:52 +00:00
{
repoid = repoid.Substring(0, 3) + "E";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
2020-04-21 19:52:52 +00:00
try
{
img.Owner = mw;
}
catch (Exception) { }
found = true;
img.ShowDialog(); break;
2020-04-21 19:52:52 +00:00
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "P" + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
repoid = repoid.Substring(0, 3) + "P";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
2020-04-21 19:52:52 +00:00
try
{
img.Owner = mw;
}
catch (Exception) { }
found = true;
img.ShowDialog(); break;
2020-04-21 19:52:52 +00:00
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "J" + $"/iconTex.{e}") == true)
2020-04-21 19:52:52 +00:00
{
repoid = repoid.Substring(0, 3) + "J";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
2020-04-21 19:52:52 +00:00
try
{
img.Owner = mw;
}
catch (Exception) { }
found = true;
img.ShowDialog(); break;
}
else
{
repoid = new string(new char[] { repoid[0], repoid[2], repoid[1], repoid[3] });
if (RemoteFileExists(linkbase + SystemType + repoid + $"/iconTex.{e}") == true)
{
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "E" + $"/iconTex.png") == true)
{
repoid = repoid.Substring(0, 3) + "E";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
found = true;
img.ShowDialog(); break;
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "P" + $"/iconTex.png") == true)
{
repoid = repoid.Substring(0, 3) + "P";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.png", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "J" + "/iconTex.png") == true)
{
repoid = repoid.Substring(0, 3) + "J";
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
found = true;
img.ShowDialog(); break;
}
2020-04-21 19:52:52 +00:00
}
}
2020-05-06 21:53:52 +00:00
checkForAdditionalFiles(GameConsoles.N64, repoids);
2020-04-21 19:52:52 +00:00
2020-05-06 21:53:52 +00:00
2020-04-21 19:52:52 +00:00
}
}
private string ByteArrayToString(byte[] arr)
{
System.Text.ASCIIEncoding enc = new System.Text.ASCIIEncoding();
return enc.GetString(arr);
}
public string getInternalWIIGCNName(string OpenGame, bool gc)
{
//string linkbase = "https://raw.githubusercontent.com/Flumpster/wiivc-bis/master/";
string linkbase = "https://raw.githubusercontent.com/Flumpster/UWUVCI-Images/master/";
2020-04-17 01:51:56 +00:00
string ret = "";
2020-04-17 16:02:45 +00:00
try
2020-04-17 01:51:56 +00:00
{
2020-04-17 16:02:45 +00:00
using (var reader = new BinaryReader(File.OpenRead(OpenGame)))
2020-04-17 01:51:56 +00:00
{
string TempString = "";
2020-04-21 19:52:52 +00:00
string SystemType = "wii/";
if (gc)
{
2020-04-21 19:52:52 +00:00
SystemType = "gcn/";
}
IMG_Message img;
2020-04-17 16:02:45 +00:00
reader.BaseStream.Position = 0x00;
char TempChar;
//WBFS Check
2020-05-04 16:20:21 +00:00
string[] ext = { "png" };
2020-05-06 21:53:52 +00:00
List<string> repoids = new List<string>();
2020-04-17 16:02:45 +00:00
if (new FileInfo(OpenGame).Extension.Contains("wbfs")) //Performs actions if the header indicates a WBFS file
{
2020-04-17 01:51:56 +00:00
2020-04-17 16:02:45 +00:00
reader.BaseStream.Position = 0x200;
reader.BaseStream.Position = 0x218;
reader.BaseStream.Position = 0x220;
while ((int)(TempChar = reader.ReadChar()) != 0) ret = ret + TempChar;
reader.BaseStream.Position = 0x200;
while ((int)(TempChar = reader.ReadChar()) != 0) TempString = TempString + TempChar;
string repoid = TempString;
2020-04-21 19:52:52 +00:00
if (CheckForInternetConnectionWOWarning())
{
2020-05-06 21:53:52 +00:00
repoids.Add(SystemType + repoid);
repoids.Add(SystemType + repoid.Substring(0, 3) + "E" + repoid.Substring(4, 2));
repoids.Add(SystemType + repoid.Substring(0, 3) + "P" + repoid.Substring(4, 2));
repoids.Add(SystemType + repoid.Substring(0, 3) + "J" + repoid.Substring(4, 2));
foreach (var e in ext)
{
if (RemoteFileExists(linkbase + SystemType + repoid + $"/iconTex.{e}") == true)
{
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "E" + repoid.Substring(4, 2) + $"/iconTex.{e}") == true)
{
repoid = repoid.Substring(0, 3) + "E" + repoid.Substring(4, 2);
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "P" + repoid.Substring(4, 2) + $"/iconTex.{e}") == true)
{
repoid = repoid.Substring(0, 3) + "P" + repoid.Substring(4, 2);
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "J" + repoid.Substring(4, 2) + $"/iconTex.{e}") == true)
{
repoid = repoid.Substring(0, 3) + "J" + repoid.Substring(4, 2);
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
}
2020-05-06 21:53:52 +00:00
if (test == GameConsoles.GCN)
{
checkForAdditionalFiles(GameConsoles.GCN, repoids);
}
else
{
checkForAdditionalFiles(GameConsoles.WII, repoids);
}
}
2020-04-17 16:02:45 +00:00
}
else
{
2020-05-06 21:53:52 +00:00
2020-04-17 01:51:56 +00:00
string repoid = "";
2020-04-17 01:51:56 +00:00
reader.BaseStream.Position = 0x18;
2020-04-17 16:02:45 +00:00
2020-04-17 01:51:56 +00:00
reader.BaseStream.Position = 0x20;
while ((int)(TempChar = reader.ReadChar()) != 0) ret = ret + TempChar;
reader.BaseStream.Position = 0x00;
while ((int)(TempChar = reader.ReadChar()) != 0) TempString = TempString + TempChar;
repoid = TempString;
if (CheckForInternetConnectionWOWarning())
{
2020-05-06 21:53:52 +00:00
repoids.Add(SystemType + repoid);
repoids.Add(SystemType + repoid.Substring(0, 3) + "E" + repoid.Substring(4, 2));
repoids.Add(SystemType + repoid.Substring(0, 3) + "P" + repoid.Substring(4, 2));
repoids.Add(SystemType + repoid.Substring(0, 3) + "J" + repoid.Substring(4, 2));
foreach (var e in ext)
{
2020-05-06 21:53:52 +00:00
if (RemoteFileExists(linkbase + SystemType + repoid + $"/iconTex.{e}") == true)
{
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "E" + repoid.Substring(4, 2) + $"/iconTex.{e}") == true)
{
repoid = repoid.Substring(0, 3) + "E" + repoid.Substring(4, 2);
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "P" + repoid.Substring(4, 2) + $"/iconTex.{e}") == true)
{
repoid = repoid.Substring(0, 3) + "P" + repoid.Substring(4, 2);
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
else if (RemoteFileExists(linkbase + SystemType + repoid.Substring(0, 3) + "J" + repoid.Substring(4, 2) + $"/iconTex.{e}") == true)
{
repoid = repoid.Substring(0, 3) + "J" + repoid.Substring(4, 2);
img = new IMG_Message(linkbase + SystemType + repoid + $"/iconTex.{e}", linkbase + SystemType + repoid + $"/bootTvTex.{e}", SystemType + repoid);
try
{
img.Owner = mw;
}
catch (Exception) { }
img.ShowDialog(); break;
}
}
2020-05-06 21:53:52 +00:00
if(test == GameConsoles.GCN)
{
checkForAdditionalFiles(GameConsoles.GCN, repoids);
}
else
{
checkForAdditionalFiles(GameConsoles.WII, repoids);
}
}
2020-04-17 16:02:45 +00:00
}
2020-04-17 01:51:56 +00:00
}
2020-04-17 16:02:45 +00:00
}catch(Exception e)
{
Custom_Message cm = new Custom_Message("Unknown ROM", "It seems that you inserted an unknown ROM as a Wii or GameCube game.\nIt is not recommended continuing with said ROM!");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
2020-05-06 21:53:52 +00:00
2020-04-17 01:51:56 +00:00
}
2020-04-17 16:02:45 +00:00
2020-04-17 01:51:56 +00:00
return ret;
}
2020-04-19 17:36:03 +00:00
public bool CheckForInternetConnection()
{
try
{
using (var client = new WebClient())
using (client.OpenRead("http://google.com/generate_204"))
return true;
}
catch
{
Custom_Message cm = new Custom_Message("No Internet Connection", "To Download Tools, Bases or required Files you need to be connected to the Internet");
try
{
cm.Owner = mw;
}
catch (Exception) { }
cm.ShowDialog();
return false;
}
}
public bool CheckForInternetConnectionWOWarning()
{
try
{
using (var client = new WebClient())
using (client.OpenRead("http://google.com/generate_204"))
return true;
}
catch
{
return false;
}
}
2020-05-06 21:53:52 +00:00
private void checkForAdditionalFiles(GameConsoles console, List<string> repoids)
{
if (!Directory.Exists(System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo")))
{
Directory.CreateDirectory(System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo"));
}
bool ini = false;
bool btsnd = false;
string inip = "";
string btsndp = "";
string exten = "";
string linkbase = "https://raw.githubusercontent.com/Flumpster/UWUVCI-Images/master/";
if (console == GameConsoles.N64)
{
foreach(string repoid in repoids)
{
if (RemoteFileExists(linkbase + repoid + "/game.ini"))
{
ini = true;
inip = linkbase + repoid + "/game.ini";
break;
}
}
}
string[] ext = { "btsnd" };
foreach (var e in ext)
{ foreach(string repoid in repoids)
{
if (RemoteFileExists(linkbase + repoid + "/BootSound." + e))
{
btsnd = true;
btsndp = linkbase + repoid + "/BootSound." + e;
exten = e;
break;
}
if (btsnd)
{
break;
}
}
}
if (ini || btsnd)
{
string extra = "There are more additional files found. Do you want to download those?";
if (ini && !btsnd) { extra = "There is an additional INI file available for download. Do you want to download it?"; }
if (!ini && btsnd) { extra = "There is an additional BootSound file available for download. Do you want to download it?"; }
if (ini && btsnd) { extra = "There is an adittional INI and BootSound file available for download. Do you want to download those?"; }
Custom_Message cm = new Custom_Message("Found additional Files", extra);
try
{
cm.Owner = mw;
}
catch (Exception)
{
}
cm.ShowDialog();
if (addi)
{
var client = new WebClient();
if (ini)
{
client.DownloadFile(inip, System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", "game.ini"));
(Thing as N64Config).ini.Text = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", "game.ini");
GameConfiguration.N64Stuff.INIPath = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", "game.ini");
}
if (btsnd)
{
client.DownloadFile(btsndp, System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", $"bootSound.{exten}"));
BootSound = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", $"bootSound.{exten}");
switch (console)
{
case GameConsoles.NDS:
(Thing as OtherConfigs).sound.Text = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", $"bootSound.{exten}");
break;
case GameConsoles.GBA:
(Thing as GBA).sound.Text = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", $"bootSound.{exten}");
break;
case GameConsoles.N64:
(Thing as N64Config).sound.Text = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", $"bootSound.{exten}");
break;
case GameConsoles.WII:
if (test == GameConsoles.GCN)
{
(Thing as GCConfig).sound.Text = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", $"bootSound.{exten}");
}
else
{
(Thing as WiiConfig).sound.Text = System.IO.Path.Combine(Directory.GetCurrentDirectory(), "bin", "repo", $"bootSound.{exten}");
}
break;
}
}
addi = false;
}
}
}
public string GetURL(string console)
{
WebRequest request;
//get download link from uwuvciapi
request = WebRequest.Create("https://uwuvciapi.azurewebsites.net/GetURL?cns=" + console.ToLower());
2020-05-01 18:10:51 +00:00
var response = request.GetResponse();
using (Stream dataStream = response.GetResponseStream())
{
// Open the stream using a StreamReader for easy access.
StreamReader reader = new StreamReader(dataStream);
// Read the content.
string responseFromServer = reader.ReadToEnd();
// Display the content.
return responseFromServer;
}
}
2020-04-30 15:01:41 +00:00
WaveOutEvent waveOutEvent = new WaveOutEvent();
AudioFileReader audioFileReader;
public System.Timers.Timer t;
public void PlaySound()
{
Task ts = new Task(() =>
{
try
{
t = new System.Timers.Timer(200);
t.Elapsed += isDone;
audioFileReader = new AudioFileReader(BootSound);
waveOutEvent.Init(audioFileReader);
t.Start();
Console.WriteLine("Playing file..");
waveOutEvent.Play();
}
catch (Exception)
{
}
});
ts.Start();
}
public void isDoneMW()
{
try
{
if(waveOutEvent != null && audioFileReader != null)
{
waveOutEvent.Stop();
waveOutEvent.Dispose();
audioFileReader.Dispose();
t.Stop();
}
}
catch (Exception)
{
}
}
public void isDone(Object source, ElapsedEventArgs e)
{
try
{
if(waveOutEvent.PlaybackState == PlaybackState.Stopped)
{
waveOutEvent.Dispose();
audioFileReader.Dispose();
t.Stop();
}
if (waveOutEvent.GetPositionTimeSpan() > TimeSpan.FromSeconds(6))
{
waveOutEvent.Stop();
waveOutEvent.Dispose();
audioFileReader.Dispose();
t.Stop();
}
}
catch (Exception)
{
}
}
2020-03-01 15:07:22 +00:00
}
}