Custom configuration for each game #632
@ -42,52 +42,33 @@ namespace Ryujinx.Ava
|
||||
|
|
||||
List<string> arguments = CommandLineState.Arguments.ToList();
|
||||
string executableDirectory = AppDomain.CurrentDomain.BaseDirectory;
|
||||
|
||||
// On macOS we perform the update at relaunch.
|
||||
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
if (OperatingSystem.IsMacOS())
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
var dialogTask = taskDialog.ShowAsync(true);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
await Task.Delay(500);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
// Find the process name.
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
string ryuName = Path.GetFileName(Environment.ProcessPath) ?? string.Empty;
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
// Fallback if the executable could not be found.
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
if (ryuName.Length == 0 || !Path.Exists(Path.Combine(executableDirectory, ryuName)))
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
{
|
||||
string baseBundlePath = Path.GetFullPath(Path.Combine(executableDirectory, "..", ".."));
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
string newBundlePath = Path.Combine(_updateDir, "Ryujinx.app");
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
string updaterScriptPath = Path.Combine(newBundlePath, "Contents", "Resources", "updater.sh");
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
string currentPid = Environment.ProcessId.ToString();
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
arguments.InsertRange(0, new List<string> { updaterScriptPath, baseBundlePath, newBundlePath, currentPid });
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
Process.Start("/bin/bash", arguments);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
ryuName = OperatingSystem.IsWindows() ? "Ryujinx.exe" : "Ryujinx";
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
}
|
||||
else
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
ProcessStartInfo processStart = new(ryuName)
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
{
|
||||
var dialogTask = taskDialog.ShowAsync(true);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
await Task.Delay(500);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
UseShellExecute = true,
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
WorkingDirectory = executableDirectory,
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
};
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
// Find the process name.
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
string ryuName = Path.GetFileName(Environment.ProcessPath) ?? string.Empty;
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
// Some operating systems can see the renamed executable, so strip off the .ryuold if found.
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
if (ryuName.EndsWith(".ryuold"))
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
{
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
ryuName = ryuName[..^7];
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
}
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
// Fallback if the executable could not be found.
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
if (ryuName.Length == 0 || !Path.Exists(Path.Combine(executableDirectory, ryuName)))
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
{
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
ryuName = OperatingSystem.IsWindows() ? "Ryujinx.exe" : "Ryujinx";
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
}
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
ProcessStartInfo processStart = new(ryuName)
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
{
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
UseShellExecute = true,
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
WorkingDirectory = executableDirectory,
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
};
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
foreach (var arg in args)
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
{
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
processStart.ArgumentList.Add(arg);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
}
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
processStart.ArgumentList.Add(gamePath);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
Process.Start(processStart);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
foreach (var arg in args)
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
{
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
processStart.ArgumentList.Add(arg);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
}
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
processStart.ArgumentList.Add(gamePath);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
Process.Start(processStart);
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
Environment.Exit(0);
|
||||
}
|
||||
}
|
||||
|
||||
|
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
This is a rebooter, not an updater; the update stuff should probably get removed(?) This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
There is no need to delete it. At least I made it so that it works in this code It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts. I just decided not to rework the updater class, but to make a new class for rebooting There is no need to delete it. At least I made it so that it works in this code
```
public bool InitializeUserConfig(ApplicationData application)
{
BackendThreading backendThreadingValue = ConfigurationState.Instance.Graphics.BackendThreading.Value;
string BackendThreadingInit = Program.BackendThreadingArg;
if (BackendThreadingInit is null)
{
BackendThreadingInit = ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString();
}
// If a configuration is found in the "/games/xxxxxxxxxxxxxx" folder, the program will load the user setting.
string idGame = application.IdBaseString;
if (ConfigurationFileFormat.TryLoad(Program.GetDirGameUserConfig(idGame), out ConfigurationFileFormat configurationFileFormat))
{
// Loads the user configuration, having previously changed the global configuration to the user configuration
ConfigurationState.Instance.Load(configurationFileFormat, Program.GetDirGameUserConfig(idGame, true, true), idGame);
}
// Code where conditions will be executed after loading user configuration
if (ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString() != BackendThreadingInit)
{
List<string> Arguments = new List<string>
{
"--bt", ConfigurationState.Instance.Graphics.BackendThreading.Value.ToString(), // BackendThreading
//"-i", application.IdBaseString
};
Rebooter.RebootAppWithGame(application.Path, Arguments);
return true;
}
return false;
}
```
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
|
||||
Loading…
x
Reference in New Issue
Block a user
This is a rebooter, not an updater; the update stuff should probably get removed(?)
This is a rebooter, not an updater; the update stuff should probably get removed(?)
There is no need to delete it. At least I made it so that it works in this code
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting
There is no need to delete it. At least I made it so that it works in this code
It reboots the emulator if the graphics stream for running the game in the user configuration differs from the one loaded when the emulator starts.
I just decided not to rework the updater class, but to make a new class for rebooting