static string[] GetVPKFileList(string VPKPath) { string arguments = $"l \"{VPKPath}\""; var p = new Process { StartInfo = new ProcessStartInfo { WorkingDirectory = Path.GetDirectoryName(vpk), FileName = vpk, Arguments = arguments, UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardError = true, CreateNoWindow = true, } }; p.Start(); string output = p.StandardOutput.ReadToEnd(); string errOutput = p.StandardError.ReadToEnd(); if (verbose) { CompilePalLogger.Log(errOutput); } p.WaitForExit(); char[] delims = new[] { '\r', '\n' }; return(output.Split(delims, StringSplitOptions.RemoveEmptyEntries)); }
private void AddMapButton_Click(object sender, RoutedEventArgs e) { var dialog = new OpenFileDialog(); if (GameConfigurationManager.GameConfiguration.SDKMapFolder != null) { dialog.InitialDirectory = GameConfigurationManager.GameConfiguration.SDKMapFolder; } dialog.Multiselect = true; dialog.Filter = "Map files (*.vmf;*.vmm)|*.vmf;*.vmm"; try { dialog.ShowDialog(); } catch { CompilePalLogger.LogDebug($"AddMapButton dialog failed to open, falling back to {Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments)}"); // if dialog fails to open it's possible its initial directory is in a non existant folder or something dialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments); dialog.ShowDialog(); } foreach (var file in dialog.FileNames) { CompilingManager.MapFiles.Add(file); } }
static void PackFileList(CompileContext context, string outputFile) { if (File.Exists(context.BSPFile)) { if (File.Exists(context.BSPFile + ".unpacked")) { CompilePalLogger.LogLineDebug($"Deleting: {context.BSPFile}.unpacked"); File.Delete(context.BSPFile + ".unpacked"); } CompilePalLogger.LogLineDebug($"Copying {context.BSPFile} to {context.BSPFile}.unpacked"); File.Copy(context.BSPFile, context.BSPFile + ".unpacked"); } CompilePalLogger.LogLine("Running bspzip..."); PackBSP(outputFile); // don't copy if vmf directory is also the output directory if (bspPath != context.BSPFile) { if (File.Exists(context.BSPFile)) { CompilePalLogger.LogLineDebug($"Deleting: {context.BSPFile}"); File.Delete(context.BSPFile); } CompilePalLogger.LogLine("Copying packed bsp to vmf folder..."); CompilePalLogger.LogLineDebug($"Copying {bspPath} to {context.BSPFile}"); File.Copy(bspPath, context.BSPFile); } }
private void ProcessOnOutputDataReceived(object sender, DataReceivedEventArgs e) { if (e.Data != null) { CompilePalLogger.LogLine(e.Data); } }
public static void CancelCompile() { try { compileThread.Abort(); } catch { } IsCompiling = false; foreach (var compileProcess in ConfigurationManager.CompileProcesses.Where(cP => cP.Process != null)) { try { compileProcess.Cancel(); compileProcess.Process.Kill(); CompilePalLogger.LogLineColor("Killed {0}.", Brushes.OrangeRed, compileProcess.Metadata.Name); } catch (InvalidOperationException) { } catch (Exception e) { ExceptionHandler.LogException(e); } } ProgressManager.SetProgress(0); CompilePalLogger.LogLineColor("Compile forcefully ended.", Brushes.OrangeRed); postCompile(null); }
static void UnpackBSP(string unpackDir) { // unpacks the pak file and extracts it to a temp location /* info: vbsp.exe creates files in the pak file that may have * dependencies that are not listed anywhere else, as is the * case for water materials. We use this method to extract the * pak file to a temp folder and read the dependencies of its files. */ string arguments = "-extractfiles \"$bspold\" \"$dir\""; arguments = arguments.Replace("$bspold", bspPath); arguments = arguments.Replace("$dir", unpackDir); var startInfo = new ProcessStartInfo(bspZip, arguments); startInfo.UseShellExecute = false; startInfo.CreateNoWindow = true; startInfo.RedirectStandardOutput = true; startInfo.EnvironmentVariables["VPROJECT"] = gameFolder; var p = new Process { StartInfo = startInfo }; p.Start(); string output = p.StandardOutput.ReadToEnd(); if (verbose) { CompilePalLogger.Log(output); } p.WaitForExit(); }
private void ProcessOnErrorDataReceived(object sender, DataReceivedEventArgs e) { if (e.Data != null) { CompilePalLogger.LogLineColor(e.Data, Error.GetSeverityBrush(4)); } }
static void ThreadedCheck() { try { CompilePalLogger.LogLine("Fetching update information..."); var c = new WebClient(); string newVersion = c.DownloadString(new Uri(UpdateURL)); LatestVersion = int.Parse(newVersion); if (CurrentVersion < LatestVersion) { MainWindow.ActiveDispatcher.Invoke(OnUpdateFound); CompilePalLogger.LogLine("Updater found that Compile Pal is outdated."); } else { CompilePalLogger.LogLine("Updater found that Compile Pal is up to date."); } ProgressManager.SetProgress(ProgressManager.Progress); } catch (WebException e) { CompilePalLogger.LogLine("Failed to find update information as an error was returned:"); CompilePalLogger.LogLine(e.ToString()); } }
public static List <GameConfiguration> Parse(string filename) { var lines = File.ReadAllLines(filename); var gameInfos = new List <GameConfiguration>(); var data = new KV.FileData(filename); foreach (KV.DataBlock gamedb in data.headnode.GetFirstByName(new [] { "\"Configs\"", "\"GameConfig.txt\"" }).GetFirstByName("\"Games\"").subBlocks) { string binfolder = Path.GetDirectoryName(filename); KV.DataBlock hdb = gamedb.GetFirstByName("\"Hammer\""); CompilePalLogger.LogLine($"Gamedb: {gamedb}"); GameConfiguration game = new GameConfiguration { Name = gamedb.name.Replace("\"", ""), BinFolder = binfolder, GameFolder = GetFullPath(gamedb.TryGetStringValue("GameDir"), binfolder), GameEXE = GetFullPath(hdb.TryGetStringValue("GameExe"), binfolder), SDKMapFolder = GetFullPath(hdb.TryGetStringValue("MapDir"), binfolder), VBSP = GetFullPath(hdb.TryGetStringValue("BSP"), binfolder), VVIS = GetFullPath(hdb.TryGetStringValue("Vis"), binfolder), VRAD = GetFullPath(hdb.TryGetStringValue("Light"), binfolder), MapFolder = GetFullPath(hdb.TryGetStringValue("BSPDir"), binfolder) }; gameInfos.Add(game); } return(gameInfos); }
private static void postCompile(List <Error> errors) { CompilePalLogger.LogLineColor(string.Format("'{0}' compile finished in {1}", ConfigurationManager.CurrentPreset, compileTimeStopwatch.Elapsed.ToString(@"hh\:mm\:ss")), Brushes.ForestGreen); if (errors != null && errors.Any()) { int maxSeverity = errors.Max(s => s.Severity); var severityBrush = Error.GetSeverityBrush(maxSeverity); CompilePalLogger.LogLineColor("{0} errors/warnings logged:", severityBrush, errors.Count); int i = 0; foreach (var error in errors) { i++; string errorText = string.Format("({0}) - ({1})", i, Error.GetSeverityText(error.Severity)) + Environment.NewLine; CompilePalLogger.LogCompileError(errorText, error); if (error.Severity >= 3) { AnalyticsManager.CompileError(); } } } OnFinish(); compileTimeStopwatch.Reset(); IsCompiling = false; }
public void FetchHDRLevels() { CompilePalLogger.LogLine("Detecting HDR levels..."); var startInfo = new ProcessStartInfo(vbspInfo, "\"" + bspFile + "\""); startInfo.UseShellExecute = false; startInfo.CreateNoWindow = true; startInfo.RedirectStandardOutput = true; var p = new Process { StartInfo = startInfo }; p.Start(); string output = p.StandardOutput.ReadToEnd(); if (p.ExitCode != 0) { CompilePalLogger.LogLine("Could not read HDR levels, defaulting to one."); } else { Regex re = new Regex(@"^LDR\sworldlights\s+.*", RegexOptions.IgnoreCase | RegexOptions.Multiline); string LDRStats = re.Match(output).Value.Trim(); re = new Regex(@"^HDR\sworldlights\s+.*", RegexOptions.IgnoreCase | RegexOptions.Multiline); string HDRStats = re.Match(output).Value.Trim(); LDR = !LDRStats.Contains(" 0/"); HDR = !HDRStats.Contains(" 0/"); } }
static void PackBSP() { string arguments = "-addlist \"$bspnew\" \"$list\" \"$bspold\""; arguments = arguments.Replace("$bspnew", bspPath); arguments = arguments.Replace("$bspold", bspPath); arguments = arguments.Replace("$list", "files.txt"); var startInfo = new ProcessStartInfo(bspZip, arguments); startInfo.UseShellExecute = false; startInfo.RedirectStandardOutput = true; startInfo.CreateNoWindow = true; startInfo.EnvironmentVariables["VPROJECT"] = gameFolder; var p = new Process { StartInfo = startInfo }; p.Start(); string output = p.StandardOutput.ReadToEnd(); if (verbose) { CompilePalLogger.Log(output); } p.WaitForExit(); }
public static void Init() { if (File.Exists(mapFiles)) { var list = JsonConvert.DeserializeObject <List <object> >(File.ReadAllText(mapFiles)); var mapList = new List <Map>(); // make this backwards compatible by allowing plain string values in maplist array (old format) foreach (var item in list) { if (item is string mapFile) { mapList.Add(new Map(mapFile)); } else if (item is JObject obj) { mapList.Add(obj.ToObject <Map>()); } else { CompilePalLogger.LogDebug($"Failed to load item from mapfiles: {item}"); } } CompilingManager.MapFiles = new TrulyObservableCollection <Map>(mapList); } CompilingManager.MapFiles.CollectionChanged += delegate { File.WriteAllText(mapFiles, JsonConvert.SerializeObject(CompilingManager.MapFiles, Formatting.Indented)); }; }
private void readOutput() { char[] buffer = new char[256]; Task <int> read = null; while (true) { if (read == null) { read = Process.StandardOutput.ReadAsync(buffer, 0, buffer.Length); } read.Wait(100); // an arbitray timeout if (read.IsCompleted) { if (read.Result > 0) { string text = new string(buffer, 0, read.Result); CompilePalLogger.ProgressiveLog(text); read = null; // ok, this task completed so we need to create a new one continue; } // got -1, process ended break; } } Process.WaitForExit(); }
static void ThreadedCheck() { try { CompilePalLogger.LogLine("Fetching update information..."); ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; var c = new WebClient(); string newVersion = GetValidVersionString(c.DownloadString(new Uri(isPrerelease ? LatestPrereleaseVersionURL : LatestVersionURL))); latestVersion = Version.Parse(newVersion); if (currentVersion < latestVersion) { MainWindow.ActiveDispatcher.Invoke(OnUpdateFound); CompilePalLogger.LogLine("Updater found that Compile Pal Multi is outdated."); } else { CompilePalLogger.LogLine("Updater found that Compile Pal Multi is up to date."); } ProgressManager.SetProgress(ProgressManager.Progress); } catch (WebException e) { CompilePalLogger.LogLine("Failed to find update information as an error was returned:"); CompilePalLogger.LogLine(e.ToString()); } }
public CompileProcess(string name) { string jsonMetadata = Path.Combine(ParameterFolder, name, "meta.json"); if (File.Exists(jsonMetadata)) { Metadata = JsonConvert.DeserializeObject <CompileMetadata>(File.ReadAllText(jsonMetadata)); CompilePalLogger.LogLine("Loaded JSON metadata {0} from {1} at order {2}", Metadata.Name, jsonMetadata, Metadata.Order); } else { string legacyMetadata = Path.Combine(ParameterFolder, name + ".meta"); if (File.Exists(legacyMetadata)) { Metadata = LoadLegacyData(legacyMetadata); Directory.CreateDirectory(Path.Combine(ParameterFolder, name)); File.WriteAllText(jsonMetadata, JsonConvert.SerializeObject(Metadata, Formatting.Indented)); CompilePalLogger.LogLine("Loaded CSV metadata {0} from {1} at order {2}, converted to JSON successfully.", Metadata.Name, legacyMetadata, Metadata.Order); } else { throw new FileNotFoundException("The metadata file for " + name + " could not be found."); } } ParameterList = ConfigurationManager.GetParameters(Metadata.Name, Metadata.DoRun); }
static void PackVPK(string targetVPK, string responseFile, string searchPath) { string arguments = $"a \"{targetVPK}\" \"@{responseFile}\""; var p = new Process { StartInfo = new ProcessStartInfo { WorkingDirectory = searchPath, FileName = vpk, Arguments = arguments, UseShellExecute = false, RedirectStandardOutput = true, RedirectStandardError = true, CreateNoWindow = true, } }; //p.StartInfo.EnvironmentVariables["VPROJECT"] = gameFolder; p.Start(); string output = p.StandardOutput.ReadToEnd(); string errOutput = p.StandardError.ReadToEnd(); if (verbose) { CompilePalLogger.Log(output); CompilePalLogger.Log(errOutput); } p.WaitForExit(); }
private static void CompileThreaded() { try { ProgressManager.SetProgress(0); var compileErrors = new List <Error>(); foreach (string mapFile in MapFiles) { CompilePalLogger.LogLine(string.Format("Starting compilation of {0}", mapFile)); foreach (var compileProcess in ConfigurationManager.CompileProcesses.Where(c => c.DoRun)) { compileProcess.Run(GameConfigurationManager.BuildContext(mapFile)); if (compileProcess is CompileExecutable) { var executable = compileProcess as CompileExecutable; compileErrors.AddRange(executable.CompileErrors); } ProgressManager.Progress += (1d / ConfigurationManager.CompileProcesses.Count(c => c.DoRun)) / MapFiles.Count; } } MainWindow.ActiveDispatcher.Invoke(() => postCompile(compileErrors)); } catch (ThreadAbortException) { ProgressManager.ErrorProgress(); } }
public static void LogException(Exception e, bool crash = true) { if (!Directory.Exists(CompilePalPath.Directory + "CrashLogs")) { Directory.CreateDirectory(CompilePalPath.Directory + "CrashLogs"); } CompilePalLogger.LogLine("An exception was caught by the ExceptionHandler:"); CompilePalLogger.LogLine(e.ToString()); if (e.InnerException != null) { CompilePalLogger.LogLine(e.InnerException.ToString()); } try { AnalyticsManager.Error();//risky, but /interesting/ } catch (Exception) {} if (crash) { string crashLogName = DateTime.Now.ToString("s").Replace(":", "-"); File.WriteAllText(Path.Combine("CrashLogs", crashLogName + ".txt"), e.ToString() + e.InnerException ?? ""); Thread.Sleep(2000); Environment.Exit(0); } }
private static void AssemblePresets() { if (!Directory.Exists(PresetsFolder)) { Directory.CreateDirectory(PresetsFolder); } //get a list of presets from the directories in the preset folder var presets = Directory.GetDirectories(PresetsFolder); //clear old lists KnownPresets.Clear(); foreach (var process in CompileProcesses) { process.PresetDictionary.Clear(); } foreach (string presetPath in presets) { string preset = Path.GetFileName(presetPath); foreach (var process in CompileProcesses) { string file = Path.Combine(presetPath, process.PresetFile); if (File.Exists(file)) { process.PresetDictionary.Add(preset, new ObservableCollection <ConfigItem>()); //read the list of preset parameters var lines = File.ReadAllLines(file); foreach (var line in lines) { var item = ParsePresetLine(line); if (process.ParameterList.Any(c => c.Parameter == item.Parameter)) { //remove .clone if you are a m*******t and wish to enter the object oriented version of hell var equivalentItem = (ConfigItem)process.ParameterList.FirstOrDefault(c => c.Parameter == item.Parameter).Clone(); equivalentItem.Value = item.Value; //Copy extra information stored for custom programs if (item.Parameter == "program") { equivalentItem.Value2 = item.Value2; equivalentItem.Warning = item.Warning; } process.PresetDictionary[preset].Add(equivalentItem); } } } } CompilePalLogger.LogLine("Added preset {0} for processes {1}", preset, string.Join(", ", CompileProcesses)); CurrentPreset = preset; KnownPresets.Add(preset); } }
public override void Run(CompileContext context) { CompilePalLogger.LogLine("\nCompilePal - Nav Generator"); mapname = System.IO.Path.GetFileName(context.BSPFile).Replace(".bsp", ""); mapnav = context.CopyLocation.Replace(".bsp", ".nav"); mapcfg = context.Configuration.GameFolder + "/cfg/" + mapname + ".cfg"; mapCFGBackup = context.Configuration.GameFolder + "/cfg/" + mapname + "_cpalbackup.cfg"; hidden = GetParameterString().Contains("-hidden"); string args = "-game \"" + context.Configuration.GameFolder + "\" -windowed -novid -nosound +sv_cheats 1 +map " + mapname; if (hidden) { args += " -noborder -x 4000 -y 2000"; } var startInfo = new ProcessStartInfo(context.Configuration.GameEXE, args); startInfo.UseShellExecute = false; startInfo.CreateNoWindow = false; CompilePalLogger.LogLine("Generating..."); if (File.Exists(mapcfg)) { if (File.Exists(mapCFGBackup)) { System.IO.File.Delete(mapCFGBackup); } System.IO.File.Move(mapcfg, mapCFGBackup); } System.IO.File.Create(mapcfg).Dispose(); TextWriter tw = new StreamWriter(mapcfg); tw.WriteLine("nav_generate"); tw.Close(); Process = new Process { StartInfo = startInfo }; Process.Start(); FileSystemWatcher fw = new FileSystemWatcher(); fw.Path = System.IO.Path.GetDirectoryName(mapnav); fw.Filter = "*.nav"; fw.NotifyFilter = NotifyFilters.LastAccess | NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName; fw.Changed += new FileSystemEventHandler(fileSystemWatcher_NavCreated); fw.Created += new FileSystemEventHandler(fileSystemWatcher_NavCreated); fw.EnableRaisingEvents = true; Process.WaitForExit(); fw.Dispose(); cleanUp(); CompilePalLogger.LogLine("nav file complete!"); }
private static void CompileThreaded() { try { ProgressManager.SetProgress(0); var mapErrors = new List <MapErrors>(); foreach (string mapFile in MapFiles) { string cleanMapName = Path.GetFileNameWithoutExtension(mapFile); var compileErrors = new List <Error>(); CompilePalLogger.LogLine($"Starting compilation of {cleanMapName}"); //Update the grid so we have the most up to date order OrderManager.UpdateOrder(); GameConfigurationManager.BackupCurrentContext(); foreach (var compileProcess in OrderManager.CurrentOrder) { currentCompileProcess = compileProcess; compileProcess.Run(GameConfigurationManager.BuildContext(mapFile)); if (compileProcess is CompileExecutable executable) { compileErrors.AddRange(executable.CompileErrors); //Portal 2 cannot work with leaks, stop compiling if we do get a leak. if (GameConfigurationManager.GameConfiguration.Name == "Portal 2") { if (executable.Name == "VBSP" && executable.CompileErrors.Count > 0) { //we have a VBSP error, aka a leak -> stop compiling; break; } } } ProgressManager.Progress += (1d / ConfigurationManager.CompileProcesses.Count(c => c.Metadata.DoRun && c.PresetDictionary.ContainsKey(ConfigurationManager.CurrentPreset))) / MapFiles.Count; } mapErrors.Add(new MapErrors { MapName = cleanMapName, Errors = compileErrors }); GameConfigurationManager.RestoreCurrentContext(); } MainWindow.ActiveDispatcher.Invoke(() => postCompile(mapErrors)); } catch (ThreadAbortException) { ProgressManager.ErrorProgress(); } }
public override void Run(CompileContext context) { vbspInfo = context.Configuration.VBSPInfo; bspFile = context.CopyLocation; CompileErrors = new List <Error>(); try { CompilePalLogger.LogLine("\nCompilePalMulti - Cubemap Generator"); if (!File.Exists(context.CopyLocation)) { throw new FileNotFoundException(); } hidden = GetParameterString().Contains("-hidden"); FetchHDRLevels(); string mapname = System.IO.Path.GetFileName(context.CopyLocation).Replace(".bsp", ""); string args = "-steam -game \"" + context.Configuration.GameFolder + "\" -windowed -novid -nosound +mat_specular 0 %HDRevel% +map " + mapname + " -buildcubemaps"; if (hidden) { args += " -noborder -x 4000 -y 2000"; } if (HDR && LDR) { CompilePalLogger.LogLine("Map requires two sets of cubemaps"); CompilePalLogger.LogLine("Compiling LDR cubemaps..."); RunCubemaps(context.Configuration.GameEXE, args.Replace("%HDRevel%", "+mat_hdr_level 0")); CompilePalLogger.LogLine("Compiling HDR cubemaps..."); RunCubemaps(context.Configuration.GameEXE, args.Replace("%HDRevel%", "+mat_hdr_level 2")); } else { CompilePalLogger.LogLine("Map requires one set of cubemaps"); CompilePalLogger.LogLine("Compiling cubemaps..."); RunCubemaps(context.Configuration.GameEXE, args.Replace("%HDRevel%", "")); } CompilePalLogger.LogLine("Cubemaps compiled"); } catch (FileNotFoundException) { CompilePalLogger.LogCompileError($"Could not find file: {context.CopyLocation}", new Error($"Could not find file: {context.CopyLocation}", ErrorSeverity.Error)); } catch (Exception exception) { CompilePalLogger.LogLine("Something broke:"); CompilePalLogger.LogCompileError($"{exception}\n", new Error(exception.ToString(), "CompilePalMulti Internal Error", ErrorSeverity.FatalError)); } }
public override void Run(CompileContext context) { try { bspZip = context.Configuration.BSPZip; gameFolder = context.Configuration.GameFolder; bspPath = context.BSPFile; Keys.vmtTextureKeyWords = File.ReadAllLines(System.IO.Path.Combine(keysFolder, "texturekeys.txt")).ToList(); Keys.vmtMaterialKeyWords = File.ReadAllLines(System.IO.Path.Combine(keysFolder, "materialkeys.txt")).ToList(); Keys.vmfSoundKeys = File.ReadAllLines(System.IO.Path.Combine(keysFolder, "vmfsoundkeys.txt")).ToList(); Keys.vmfMaterialKeys = File.ReadAllLines(System.IO.Path.Combine(keysFolder, "vmfmaterialkeys.txt")).ToList(); Keys.vmfModelKeys = File.ReadAllLines(System.IO.Path.Combine(keysFolder, "vmfmodelkeys.txt")).ToList(); CompilePalLogger.LogLine("Finding sources of game content..."); GetSourceDirectories(gameFolder); CompilePalLogger.LogLine("Reading BSP..."); BSP map = new BSP(new FileInfo(bspPath)); AssetUtils.findBspUtilityFiles(map, sourceDirectories); string unpackDir = System.IO.Path.GetTempPath() + Guid.NewGuid(); UnpackBSP(unpackDir); AssetUtils.findBspPakDependencies(map, unpackDir); CompilePalLogger.LogLine("Initializing pak file..."); PakFile pakfile = new PakFile(map, sourceDirectories); CompilePalLogger.LogLine("Writing file list..."); pakfile.OutputToFile(); CompilePalLogger.LogLine("Running bspzip..."); PackBSP(); CompilePalLogger.LogLine("Finished packing!"); CompilePalLogger.LogLine("---------------------"); CompilePalLogger.LogLine(pakfile.vmtcount + " materials added"); CompilePalLogger.LogLine(pakfile.mdlcount + " models added"); CompilePalLogger.LogLine(pakfile.pcfcount + " particle files added"); CompilePalLogger.LogLine(pakfile.sndcount + " sounds added"); CompilePalLogger.LogLine("Nav file: " + (map.nav.Key != default(string) ? "yes" : "no")); CompilePalLogger.LogLine("Soundscape: " + (map.soundscape.Key != default(string) ? "yes" : "no")); CompilePalLogger.LogLine("Soundscript: " + (map.soundscript.Key != default(string) ? "yes" : "no")); CompilePalLogger.LogLine("Detail File: " + (map.detail.Key != default(string) ? "yes" : "no")); CompilePalLogger.LogLine("Particle Manifest: " + (map.particleManifest.Key != default(string) ? "yes" : "no")); CompilePalLogger.LogLine("---------------------"); } catch (Exception exception) { CompilePalLogger.LogLine("Something broke:"); CompilePalLogger.LogLine(exception.ToString()); } }
private static void postCompile(List <MapErrors> errors) { CompilePalLogger.LogLineColor( $"\n'{ConfigurationManager.CurrentPreset}' compile finished in {compileTimeStopwatch.Elapsed.ToString(@"hh\:mm\:ss")}", Brushes.ForestGreen); if (errors != null && errors.Any()) { int numErrors = errors.Sum(e => e.Errors.Count); int maxSeverity = errors.Max(e => e.Errors.Any() ? e.Errors.Max(e2 => e2.Severity) : 0); CompilePalLogger.LogLineColor("{0} errors/warnings logged:", Error.GetSeverityBrush(maxSeverity), numErrors); foreach (var map in errors) { CompilePalLogger.Log(" "); if (!map.Errors.Any()) { CompilePalLogger.LogLineColor("No errors/warnings logged for {0}", Error.GetSeverityBrush(0), map.MapName); continue; } int mapMaxSeverity = map.Errors.Max(e => e.Severity); CompilePalLogger.LogLineColor("{0} errors/warnings logged for {1}:", Error.GetSeverityBrush(mapMaxSeverity), map.Errors.Count, map.MapName); var distinctErrors = map.Errors.GroupBy(e => e.ID); foreach (var errorList in distinctErrors) { var error = errorList.First(); string errorText = $"{errorList.Count()}x: {error.SeverityText}: {error.ShortDescription}"; CompilePalLogger.Log(" ● "); CompilePalLogger.LogCompileError(errorText, error); CompilePalLogger.LogLine(); if (error.Severity >= 3) { AnalyticsManager.CompileError(); } } } } OnFinish(); compileTimeStopwatch.Reset(); IsCompiling = false; // Tells windows it's now okay to enter sleep NativeMethods.SetThreadExecutionState(NativeMethods.ES_CONTINUOUS); }
private void readOutput() { char[] buffer = new char[256]; Task <int> read = null; while (true) { if (read == null) { read = Process.StandardOutput.ReadAsync(buffer, 0, buffer.Length); } read.Wait(100); // an arbitray timeout if (read.IsCompleted) { if (read.Result > 0) { string text = new string(buffer, 0, read.Result); var error = GetError(text); if (error != null) { if (error.Severity == 5) { CompilePalLogger.LogLineColor("An error cancelled the compile.", Brushes.Red); ProgressManager.ErrorProgress(); return; } CompilePalLogger.LogCompileError(text, error); CompileErrors.Add(error); } else { CompilePalLogger.Log(text); } read = null; // ok, this task completed so we need to create a new one continue; } // got -1, process ended break; } } Process.WaitForExit(); }
private void ProcessOnOutputDataReceived(object sender, DataReceivedEventArgs e) { if (e.Data != null) { if (e.Data.StartsWith("COMPILE_PAL_SET")) { GameConfigurationManager.ModifyCurrentContext(e.Data); } else { CompilePalLogger.LogLine(e.Data); } } }
private static void DeleteNav(string mapname, string gamefolder) { List <string> navdirs = BSPPack.BSPPack.GetSourceDirectories(gamefolder, false); foreach (string source in navdirs) { string externalPath = source + "/maps/" + mapname + ".nav"; if (File.Exists(externalPath)) { CompilePalLogger.LogLine("Deleting existing nav file."); File.Delete(externalPath); } } }
public static void StartCompile() { AnalyticsManager.Compile(); IsCompiling = true; compileTimeStopwatch.Start(); OnClear(); CompilePalLogger.LogLine(string.Format("Starting a '{0}' compile.", ConfigurationManager.CurrentPreset)); compileThread = new Thread(CompileThreaded); compileThread.Start(); }
public override void Run(CompileContext context) { string copyDestination = context.CopyLocation; string copySource = context.BSPFile; try { File.Copy(copySource, copyDestination, true); CompilePalLogger.LogLine("File {0} copied to {1}", System.IO.Path.GetFileName(copySource), System.IO.Path.GetDirectoryName(copyDestination)); } catch { CompilePalLogger.LogLine("File {0} failed to be copied to {1}", copySource, copyDestination); } }