/// <summary> /// Creates the update script on disk. /// </summary> /// <returns>ProcessStartInfo for the update script.</returns> public static ProcessStartInfo CreateUpdateScript() { try { var updateScriptPath = GetUpdateScriptPath(); var updateScriptSource = GetUpdateScriptSource(); File.WriteAllText(updateScriptPath, updateScriptSource); if (PlatformHelpers.IsRunningOnUnix()) { var chmod = Process.Start("chmod", $"+x {updateScriptPath}"); chmod?.WaitForExit(); } var updateShellProcess = new ProcessStartInfo { FileName = updateScriptPath, UseShellExecute = false, RedirectStandardOutput = false, CreateNoWindow = true, WindowStyle = ProcessWindowStyle.Normal }; return(updateShellProcess); } catch (IOException ioex) { Log.Warn("Failed to create update script (IOException): " + ioex.Message); return(null); } }
public void ResponderWorkerScheduler_many_MinThreads_created_but_should_be_idle() { if (PlatformHelpers.IsLinux()) { Assert.Inconclusive("This test is not designed to run on Linux"); } var minThreads = Environment.ProcessorCount * 4; using (var scheduler = new ResponderWorkerScheduler(minThreads, minThreads)) { Assert.AreEqual(minThreads, scheduler.CurrentWorkerThreadCount); var timeout = TimeSpan.FromSeconds(5); var started = DateTime.UtcNow; double oldTime; var time = Process.GetCurrentProcess().TotalProcessorTime.TotalMilliseconds; do { oldTime = time; Thread.Sleep(1000); time = Process.GetCurrentProcess().TotalProcessorTime.TotalMilliseconds; if (DateTime.UtcNow - started > timeout) { Assert.Fail("Worker threads should be idle, when no worker is added"); } } while (time - oldTime > 100); Assert.Pass(); } }
/// <summary> /// Registers all the assemblies - looks for ExportService attributes /// </summary> private void RegisterAssemblyTypes() { var assemblies = PlatformHelpers.GetAssemblies(); foreach (var asm in assemblies) { try { var attributes = asm.GetCustomAttributes <ExportServiceAttribute>().ToList(); // Look for assembly level attributes. foreach (var att in attributes.Where(a => !a.IsFallback)) { Add(att.ContractType, att.ServiceType); } // Register fall back services if no other service is in place. foreach (var att in attributes.Where(a => a.IsFallback)) { if (!this.Exists(att.ContractType)) { Add(att.ContractType, att.ServiceType); } } } catch { // Skip. } } }
public static void LoadTags(Models.Project project, ICacheFile cacheFile, string projectDirectory, Trie stringIdTrie) { var tagsDirectory = Path.Combine(projectDirectory, project.Properties.TagsFolder); if (!Directory.Exists(tagsDirectory)) { Directory.CreateDirectory(tagsDirectory); } // Generate Tag List var tags = cacheFile.Tags .Where(tag => tag != null && tag.Class != null && tag.MetaLocation != null) .Select(tag => { var className = CharConstant.ToString(tag.Class.Magic).Trim(); var name = cacheFile.FileNames.GetTagName(tag); if (string.IsNullOrWhiteSpace(name)) { name = tag.Index.ToString(); } var directory = tagsDirectory; var tagFileName = $"{name}.{className}"; var indexOfSeparator = tagFileName.LastIndexOf('\\'); if (indexOfSeparator > -1) { directory = Path .Combine(tagsDirectory, tagFileName.Remove(indexOfSeparator)) .Replace('\\', Path.DirectorySeparatorChar); tagFileName = tagFileName.Remove(0, indexOfSeparator + 1); } return(new TagEntry(tag, className, name, tagFileName, directory)); }); // Extract Tag Data foreach (var tag in tags) { // Create Directory if (!Directory.Exists(tag.Directory)) { Directory.CreateDirectory(tag.Directory); } using (var reader = XmlReader.Create($"data/plugins/halo3/{PlatformHelpers.EscapePath(tag.ClassName)}.xml")) { var pluginVisitor = new JsonPluginVisitor(tags, stringIdTrie, cacheFile.MetaArea); JsonPluginLoader.LoadPlugin(reader, pluginVisitor); File.WriteAllText(tag.FullPath, JsonConvert.SerializeObject(pluginVisitor.TagData, Formatting.Indented, new JsonSerializerSettings { TypeNameHandling = TypeNameHandling.Auto })); } } }
/// <summary> /// Gets the name of the embedded update script. /// </summary> private static string GetUpdateScriptPath() { if (PlatformHelpers.IsRunningOnUnix()) { return(Path.Combine(Path.GetTempPath(), "launchpad_update.sh")); } return(Path.Combine(Path.GetTempPath(), "launchpad_update.bat")); }
private void OnTriggerExit(Collider other) { if (other.gameObject.layer == Constants.PlayerLayer) { PlatformHelpers.WaitForPlatformExit = false; PlatformHelpers.IgnorePlayerPlatform(false, "OnTriggerExit"); GameObject.Find("Player").GetComponent <Player>().SetParentPlatform(); } }
/// <summary> /// Attempts to parse an entry from a raw input. /// The input is expected to be in [path]:[hash]:[size] format. Note that the file path is case sensitive, /// but the hash is not. /// </summary> /// <returns><c>true</c>, if the input was successfully parse, <c>false</c> otherwise.</returns> /// <param name="rawInput">Raw input.</param> /// <param name="inEntry">The resulting entry.</param> public static bool TryParse(string rawInput, out ManifestEntry inEntry) { // Clear out the entry for the new data inEntry = new ManifestEntry(); if (string.IsNullOrEmpty(rawInput)) { return(false); } var cleanInput = rawInput.RemoveLineSeparatorsAndNulls(); // Split the string into its three components - file, hash and size var entryElements = cleanInput.Split(':'); // If we have three elements (which we should always have), set them in the provided entry if (entryElements.Length != 3) { return(false); } // Sanitize the manifest path, converting \ to / on unix and / to \ on Windows. if (PlatformHelpers.IsRunningOnUnix()) { inEntry.RelativePath = entryElements[0].Replace('\\', '/'); } else { inEntry.RelativePath = entryElements[0].Replace('/', '\\'); } // Hashes must be exactly 32 characters if (entryElements[1].Length != 32) { return(false); } // Set the hash to the second element inEntry.Hash = entryElements[1]; // Attempt to parse the final element as a long-type byte count. if (!long.TryParse(entryElements[2], out var parsedSize)) { // Oops. The parsing failed, so this entry is invalid. return(false); } // Negative sizes are not allowed if (parsedSize < 0) { return(false); } inEntry.Size = parsedSize; return(true); }
/// <summary> /// Gets the name of the embedded update script. /// </summary> private static string GetUpdateScriptResourceName() { if (PlatformHelpers.IsRunningOnUnix()) { return("Launchpad.Launcher.Resources.launchpad_update.sh"); } else { return("Launchpad.Launcher.Resources.launchpad_update.bat"); } }
/// <summary> /// Gets the name of the embedded update script. /// </summary> private static string GetUpdateScriptPath() { if (PlatformHelpers.IsRunningOnUnix()) { return($@"{Path.GetTempPath()}launchpad_update.sh"); } else { return($@"{Path.GetTempPath()}launchpad_update.bat"); } }
/// <summary> /// The main entry point for the application. /// </summary> private static void Main() { // Bind any unhandled exceptions in the main thread so that they are logged. AppDomain.CurrentDomain.UnhandledException += OnUnhandledException; // Set correct working directory for compatibility with double-clicking Directory.SetCurrentDirectory(DirectoryHelpers.GetLocalLauncherDirectory()); if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { Environment.SetEnvironmentVariable("GTK_EXE_PREFIX", Directory.GetCurrentDirectory()); Environment.SetEnvironmentVariable("GTK_DATA_PREFIX", Directory.GetCurrentDirectory()); Environment.SetEnvironmentVariable("GSETTINGS_SCHEMA_DIR", "share\\glib-2.0\\schemas\\"); } Log.Info($"\n\n\n"); Log.Info($"----------------------------------------------------------------------------"); Log.Info($"Launching Youcanevent launcher {System.DateTime.Now}"); Log.Info($"Launchpad v{LocalVersionService.GetLocalLauncherVersion()} starting..."); var systemBitness = Environment.Is64BitOperatingSystem ? "x64" : "x86"; var processBitness = Environment.Is64BitProcess ? "64-bit" : "32-bit"; Log.Info($"Current platform: {PlatformHelpers.GetCurrentPlatform()} ({systemBitness} platform, {processBitness} process)"); Log.Info("Initializing UI..."); // Bind any unhandled exceptions in the GTK UI so that they are logged. ExceptionManager.UnhandledException += OnGLibUnhandledException; // Run the GTK UI Gtk.Application.Init(); var win = MainWindow.Create(); win.Show(); Timeout.Add ( 50, () => { Task.Factory.StartNew ( () => win.InitializeAsync(), CancellationToken.None, TaskCreationOptions.DenyChildAttach, TaskScheduler.FromCurrentSynchronizationContext() ); return(false); } ); Gtk.Application.Run(); }
/// <summary> /// This method uses an internal object to gather the list of ViewModels based /// on the ExportViewModel attribute. /// </summary> /// <returns></returns> private void Initialize() { var assemblies = PlatformHelpers.GetAssemblies(); foreach (var asm in assemblies) { foreach (var att in asm.GetCustomAttributes <ExportViewModelAttribute>()) { Add(att.Key, att.ViewModelType); } } }
/// <summary> /// Initializes a new instance of the <see cref="Changelog"/> class. /// </summary> /// <param name="parentContainer">The parent GTK container where the changelog should be added.</param> public Changelog(Container parentContainer) { if (!PlatformHelpers.IsRunningOnUnix()) { this.WindowsBrowser = new WindowsBrowser(parentContainer); this.WidgetHandle = this.WindowsBrowser.WidgetHandle; this.WindowsBrowser.Browser.Navigating += OnWindowsBrowserNavigating; } else { this.UnixBrowser = new WebView(); this.WidgetHandle = this.UnixBrowser; this.UnixBrowser.NavigationRequested += OnUnixBrowserNavigating; parentContainer.Add(this.WidgetHandle); } }
IEnumerator TheBrekPlatform() { if (transform.GetComponent <TrafficLight>() == null) { transform.gameObject.AddComponent <TrafficLight>(); } //Debug.Log("TheBrekPlatform " + transform.name); isBreakingProcess = true; transform.GetComponent <TrafficLight>().SetColor("y"); yield return(new WaitForSeconds(timeBeforeBreak)); PlatformHelpers.HidAndTrigger(true, transform.gameObject); yield return(new WaitForSeconds(createAfter)); PlatformHelpers.HidAndTrigger(false, transform.gameObject); transform.GetComponent <TrafficLight>().SetColor("w"); isBreakingProcess = false; }
private static async Task Main() { // Bind any unhandled exceptions in the main thread so that they are logged. AppDomain.CurrentDomain.UnhandledException += OnUnhandledException; log4net.Config.XmlConfigurator.Configure(); Log.Info("----------------"); Log.Info($"Launchpad v{LocalVersionService.GetLocalLauncherVersion()} starting..."); Log.Info($"Current platform: {PlatformHelpers.GetCurrentPlatform()} ({(Environment.Is64BitOperatingSystem ? "x64" : "x86")})"); // Set correct working directory for compatibility with double-clicking Directory.SetCurrentDirectory(DirectoryHelpers.GetLocalLauncherDirectory()); Log.Info("Initializing UI..."); // Bind any unhandled exceptions in the GTK UI so that they are logged. ExceptionManager.UnhandledException += OnGLibUnhandledException; // Run the GTK UI Gtk.Application.Init(); SynchronizationContext.SetSynchronizationContext(new GLibSynchronizationContext()); var win = new MainWindow(); win.Show(); Timeout.Add ( 50, () => { win.InitializeAsync(); return(false); } ); Gtk.Application.Run(); }
/// <summary> /// Handles switching between different functionalities depending on what is visible on the button to the user, such as /// * Installing /// * Updating /// * Repairing /// * Launching /// </summary> /// <param name="sender">The sender.</param> /// <param name="e">Empty arguments.</param> private void OnMainButtonClicked(object sender, EventArgs e) { // Drop out if the current platform isn't available on the server if (!this.Checks.IsPlatformAvailable(this.Configuration.SystemTarget)) { this.StatusLabel.Text = LocalizationCatalog.GetString("The server does not provide the game for the selected platform."); this.MainProgressBar.Text = string.Empty; Log.Info ( $"The server does not provide files for platform \"{PlatformHelpers.GetCurrentPlatform()}\". " + "A .provides file must be present in the platforms' root directory." ); SetLauncherMode(ELauncherMode.Inactive, false); return; } // else, run the relevant function switch (this.Mode) { case ELauncherMode.Repair: { // Repair the game asynchronously SetLauncherMode(ELauncherMode.Repair, true); this.Game.VerifyGame(); break; } case ELauncherMode.Install: { // Install the game asynchronously SetLauncherMode(ELauncherMode.Install, true); this.Game.InstallGame(); break; } case ELauncherMode.Update: { if (this.Checks.IsLauncherOutdated()) { // Update the launcher asynchronously SetLauncherMode(ELauncherMode.Update, true); this.Launcher.UpdateLauncher(); } else { // Update the game asynchronously SetLauncherMode(ELauncherMode.Update, true); this.Game.UpdateGame(); } break; } case ELauncherMode.Launch: { this.StatusLabel.Text = LocalizationCatalog.GetString("Idle"); this.MainProgressBar.Text = string.Empty; SetLauncherMode(ELauncherMode.Launch, true); this.Game.LaunchGame(); break; } default: { Log.Warn("The main button was pressed with an invalid active mode. No functionality has been defined for this mode."); break; } } }
/// <summary> /// Initializes the UI of the launcher, performing varying checks against the patching server. /// </summary> /// <returns>A task that must be awaited.</returns> public Task InitializeAsync() { if (this.IsInitialized) { return(Task.CompletedTask); } // First of all, check if we can connect to the patching service. if (!this.Checks.CanPatch()) { var dialog = new MessageDialog ( this, DialogFlags.Modal, MessageType.Warning, ButtonsType.Ok, LocalizationCatalog.GetString("Failed to connect to the patch server. Please check your settings.") ); dialog.Run(); dialog.Destroy(); this.StatusLabel.Text = LocalizationCatalog.GetString("Could not connect to server."); this.MenuRepairItem.Sensitive = false; } else { LoadBanner(); LoadChangelog(); // If we can connect, proceed with the rest of our checks. if (ChecksHandler.IsInitialStartup()) { DisplayInitialStartupDialog(); } // If the launcher does not need an update at this point, we can continue checks for the game if (!this.Checks.IsLauncherOutdated()) { if (!this.Checks.IsPlatformAvailable(this.Configuration.SystemTarget)) { Log.Info ( $"The server does not provide files for platform \"{PlatformHelpers.GetCurrentPlatform()}\". " + "A .provides file must be present in the platforms' root directory." ); SetLauncherMode(ELauncherMode.Inactive, false); } else { if (!this.Checks.IsGameInstalled()) { // If the game is not installed, offer to install it Log.Info("The game has not yet been installed."); SetLauncherMode(ELauncherMode.Install, false); // Since the game has not yet been installed, disallow manual repairs this.MenuRepairItem.Sensitive = false; // and reinstalls this.MenuReinstallItem.Sensitive = false; } else { // If the game is installed (which it should be at this point), check if it needs to be updated if (this.Checks.IsGameOutdated()) { // If it does, offer to update it Log.Info("The game is outdated."); SetLauncherMode(ELauncherMode.Update, false); } else { // All checks passed, so we can offer to launch the game. Log.Info("All checks passed. Game can be launched."); SetLauncherMode(ELauncherMode.Launch, false); } } } } else { // The launcher was outdated. Log.Info($"The launcher is outdated. \n\tLocal version: {this.LocalVersionService.GetLocalLauncherVersion()}"); SetLauncherMode(ELauncherMode.Update, false); } } this.IsInitialized = true; return(Task.CompletedTask); }
public void OnMoveDown(Vector3 dir) { //Debug.Log("OnMove Down"); rb.AddForce(dir * speed); PlatformHelpers.IgnorePlayerPlatform(true, "OnMoveDown", true); }
/// <summary> /// Installs the dependencies. /// </summary> protected override void InstallDependencies() { try { var executable = Path.Combine(DirectoryHelpers.GetLocalGameDirectory(), "Engine/Extras/Redist/en-us/UE4PrereqSetup_x64.exe"); Log.Info($"executable {executable}"); if (!File.Exists(executable)) { throw new FileNotFoundException($"Game executable at path (\"{executable}\") not found."); } var executableDir = Path.GetDirectoryName(executable) ?? DirectoryHelpers.GetLocalLauncherDirectory(); // Do not move the argument assignment inside the gameStartInfo initializer. // It causes a TargetInvocationException crash through black magic. var gameStartInfo = new ProcessStartInfo { FileName = executable, Arguments = string.Empty, WorkingDirectory = executableDir }; Log.Info($"Launching game. \n\tExecutable path: {gameStartInfo.FileName}"); var gameProcess = new Process { StartInfo = gameStartInfo, EnableRaisingEvents = true }; gameProcess.Exited += (sender, args) => { if (gameProcess.ExitCode != 0) { Log.Info ( $"The game exited with an exit code of {gameProcess.ExitCode}. " + "There may have been issues during runtime, or the game may not have started at all." ); } // Manual disposing gameProcess.Dispose(); }; // Make sure the game executable is flagged as such on Unix if (PlatformHelpers.IsRunningOnUnix()) { Process.Start("chmod", $"+x {gameStartInfo.FileName}"); } gameProcess.Start(); } catch (FileNotFoundException fex) { Log.Warn($"Dependencies installation failed (FileNotFoundException): {fex.Message}"); Log.Warn("Check for the UE4 installation."); } catch (IOException ioex) { Log.Warn($"Dependencies installation failed (IOException): {ioex.Message}"); } }
public static IAppQuery XamlParent(this IAppQuery query, string controlName) { return(query.Parent(PlatformHelpers.On(iOS: () => controlName.Replace(".", "_"), Android: () => GetAndroidName(controlName)))); }
/// <summary> /// Launches the game. /// </summary> public void LaunchGame() { try { var executable = Path.Combine(DirectoryHelpers.GetLocalGameDirectory(), Configuration.ExecutablePath); if (!File.Exists(executable)) { throw new FileNotFoundException($"Game executable at path (\"{executable}\") not found."); } var executableDir = Path.GetDirectoryName(executable) ?? DirectoryHelpers.GetLocalLauncherDirectory(); // Do not move the argument assignment inside the gameStartInfo initializer. // It causes a TargetInvocationException crash through black magic. var gameArguments = string.Join(" ", this.GameArgumentService.GetGameArguments()); var gameStartInfo = new ProcessStartInfo { FileName = executable, Arguments = gameArguments, WorkingDirectory = executableDir }; Log.Info($"Launching game. \n\tExecutable path: {gameStartInfo.FileName}"); var gameProcess = new Process { StartInfo = gameStartInfo, EnableRaisingEvents = true }; gameProcess.Exited += (sender, args) => { if (gameProcess.ExitCode != 0) { Log.Info ( $"The game exited with an exit code of {gameProcess.ExitCode}. " + "There may have been issues during runtime, or the game may not have started at all." ); } OnGameExited(gameProcess.ExitCode); // Manual disposing gameProcess.Dispose(); }; // Make sure the game executable is flagged as such on Unix if (PlatformHelpers.IsRunningOnUnix()) { Process.Start("chmod", $"+x {gameStartInfo.FileName}"); } gameProcess.Start(); } catch (FileNotFoundException fex) { Log.Warn($"Game launch failed (FileNotFoundException): {fex.Message}"); Log.Warn("If the game executable is there, try overriding the executable name in the configuration file."); OnGameLaunchFailed(); } catch (IOException ioex) { Log.Warn($"Game launch failed (IOException): {ioex.Message}"); OnGameLaunchFailed(); } }
public void OnMoveUp(Vector3 dir) { //Debug.Log("OnMove Up"); PlatformHelpers.IgnorePlayerPlatform(true, "OnMoveUp"); rb.AddForce(dir * speed * upMoveKoef); }