Exemple #1
0
        public static void Main(string[] args)
        {
            App     app     = new App();
            Program program = new Program();

            app.SetCurrentCulture();

            program.SetExtractValues();

            CommandLineApplication commandLineApplication = new CommandLineApplication(true)
            {
                Description = "Extract Heroes of the Storm game data into XML and JSON format",
            };

            commandLineApplication.HelpOption("-?|-h|--help");
            commandLineApplication.VersionOption("-v|--version", $"Heroes Data Parser ({App.Version})");

            ListCommand.Add(commandLineApplication).SetCommand();
            ReadCommand.Add(commandLineApplication).SetCommand();
            ExtractCommand.Add(commandLineApplication).SetCommand();
            ImageCommand.Add(commandLineApplication).SetCommand();
            QuickCompareCommand.Add(commandLineApplication).SetCommand();
            V4ConvertCommand.Add(commandLineApplication).SetCommand();

            CommandArgument storagePathArgument = commandLineApplication.Argument("storage-path", "The 'Heroes of the Storm' directory or an already extracted 'mods' directory.");

            CommandOption setOutputDirectoryOption    = commandLineApplication.Option("-o|--output-directory <FILEPATH>", "Sets the output directory.", CommandOptionType.SingleValue);
            CommandOption setDescriptionOption        = commandLineApplication.Option("-d|--description <VALUE>", "Sets the description output type (0 - 6) - Default: 0.", CommandOptionType.SingleValue);
            CommandOption extractDataFilesOption      = commandLineApplication.Option("-e|--extract-data <VALUE>", $"Extracts data files - Default: herodata.", CommandOptionType.MultipleValue);
            CommandOption extractImageFilesOption     = commandLineApplication.Option("-i|--extract-images <VALUE>", $"Extracts image files, only available using the Heroes of the Storm game directory.", CommandOptionType.MultipleValue);
            CommandOption setGameStringLocalizations  = commandLineApplication.Option("-l|--localization <LOCALE>", "Sets the gamestring localization(s) - Default: enUS.", CommandOptionType.MultipleValue);
            CommandOption setBuildOption              = commandLineApplication.Option("-b|--build <NUMBER>", "Sets the override build file(s).", CommandOptionType.SingleValue);
            CommandOption setMaxDegreeParallismOption = commandLineApplication.Option("-t|--threads <NUMBER>", "Limits the maximum amount of threads to use.", CommandOptionType.SingleValue);

            CommandOption xmlOutputOption          = commandLineApplication.Option("--xml", "Creates xml output.", CommandOptionType.NoValue);
            CommandOption jsonOutputOption         = commandLineApplication.Option("--json", "Creates json output.", CommandOptionType.NoValue);
            CommandOption setFileSplitOption       = commandLineApplication.Option("--file-split", "Splits the XML and JSON file(s) into multiple files.", CommandOptionType.NoValue);
            CommandOption localizedTextOption      = commandLineApplication.Option("--localized-text", "Extracts localized gamestrings from the XML and JSON file(s) into a text file.", CommandOptionType.NoValue);
            CommandOption minifyOption             = commandLineApplication.Option("--minify", "Creates .min file(s) along with current output file(s).", CommandOptionType.NoValue);
            CommandOption validationWarningsOption = commandLineApplication.Option("--warnings", "Displays all validation warnings.", CommandOptionType.NoValue);

            commandLineApplication.OnExecute(() =>
            {
                App.Defaults = false;

                if (extractImageFilesOption.HasValue() && !extractDataFilesOption.HasValue())
                {
                    return(InvalidCommand("You need to set the -e|--extract-data option"));
                }

                if (!string.IsNullOrWhiteSpace(storagePathArgument.Value))
                {
                    App.StoragePath = storagePathArgument.Value;
                }

                if (setMaxDegreeParallismOption.HasValue() && int.TryParse(setMaxDegreeParallismOption.Value(), out int result))
                {
                    App.MaxParallelism = result;
                }

                if (setDescriptionOption.HasValue() && Enum.TryParse(setDescriptionOption.Value(), out DescriptionType resultType))
                {
                    App.DescriptionType = resultType;
                }

                if (setBuildOption.HasValue() && int.TryParse(setBuildOption.Value(), out result))
                {
                    App.OverrideBuild = result;
                }

                if (setOutputDirectoryOption.HasValue())
                {
                    App.OutputDirectory = setOutputDirectoryOption.Value();
                }
                else
                {
                    App.OutputDirectory = Path.Combine(program.AssemblyPath, "output");
                }

                // data file extraction
                if (extractDataFilesOption.HasValue())
                {
                    if (extractDataFilesOption.Values.Exists(x => x.Equals("ALL", StringComparison.OrdinalIgnoreCase)))
                    {
                        App.ExtractDataOption = ExtractDataOption.All;
                    }
                    else
                    {
                        foreach (ExtractDataOption extractDataOption in Enum.GetValues(typeof(ExtractDataOption)))
                        {
                            if (extractDataOption == ExtractDataOption.None || extractDataOption == ExtractDataOption.All)
                            {
                                continue;
                            }

                            if (program.ExtractDataValues.TryGetValue(extractDataOption, out List <string> values))
                            {
                                if (extractDataFilesOption.Values.Intersect(values, StringComparer.OrdinalIgnoreCase).Any())
                                {
                                    App.ExtractDataOption |= extractDataOption;
                                }
                            }
                        }
                    }

                    // none is default as defined in App
                    if (App.ExtractDataOption != ExtractDataOption.None)
                    {
                        App.ExtractDataOption &= ~ExtractDataOption.None;
                    }
                }
                else
                {
                    App.ExtractDataOption = ExtractDataOption.HeroData;
                }

                // image file extraction
                if (extractImageFilesOption.HasValue() && !string.IsNullOrEmpty(storagePathArgument.Value))
                {
                    if (extractImageFilesOption.Values.Exists(x => x.Equals("ALL", StringComparison.OrdinalIgnoreCase)))
                    {
                        App.ExtractFileOption = ExtractImageOption.All;
                    }
                    else if (extractImageFilesOption.Values.Exists(x => x.Equals("ALL-SPLIT", StringComparison.OrdinalIgnoreCase) || x.Equals("ALLSPLIT", StringComparison.OrdinalIgnoreCase)))
                    {
                        App.ExtractFileOption = ExtractImageOption.AllSplit;
                    }
                    else
                    {
                        foreach (ExtractImageOption extractFileOption in Enum.GetValues(typeof(ExtractImageOption)))
                        {
                            if (extractFileOption == ExtractImageOption.None || extractFileOption == ExtractImageOption.All)
                            {
                                continue;
                            }

                            if (program.ExtractImageValues.TryGetValue(extractFileOption, out List <string> values))
                            {
                                if (extractImageFilesOption.Values.Intersect(values, StringComparer.OrdinalIgnoreCase).Any())
                                {
                                    App.ExtractFileOption |= extractFileOption;
                                }
                            }
                        }
                    }

                    // none is default as defined in App
                    if (App.ExtractFileOption != ExtractImageOption.None)
                    {
                        App.ExtractFileOption &= ~ExtractImageOption.None;
                    }
                }

                if (setGameStringLocalizations.HasValue())
                {
                    IEnumerable <string> localizations = new List <string>();

                    if (setGameStringLocalizations.Values.Exists(x => x.Equals("ALL", StringComparison.OrdinalIgnoreCase)))
                    {
                        localizations = Enum.GetNames(typeof(Localization));
                    }
                    else
                    {
                        localizations = setGameStringLocalizations.Values;
                    }

                    foreach (string locale in localizations)
                    {
                        if (Enum.TryParse(locale, true, out Localization localization))
                        {
                            app.Localizations.Add(localization);
                        }
                        else
                        {
                            Console.ForegroundColor = ConsoleColor.Red;
                            Console.WriteLine($"Unknown localization - {locale}");
                        }
                    }

                    Console.ResetColor();
                    Console.WriteLine();
                }
                else
                {
                    app.Localizations.Add(Localization.ENUS);
                }

                App.CreateXml  = xmlOutputOption.HasValue();
                App.CreateJson = jsonOutputOption.HasValue();

                // if both not set, default to both true
                if (!xmlOutputOption.HasValue() && !jsonOutputOption.HasValue())
                {
                    App.CreateXml  = true;
                    App.CreateJson = true;
                }

                App.ShowValidationWarnings = validationWarningsOption.HasValue();
                App.IsFileSplit            = setFileSplitOption.HasValue();
                App.IsLocalizedText        = localizedTextOption.HasValue();
                App.CreateMinFiles         = minifyOption.HasValue();
                app.Run();
                Console.ResetColor();

                return(0);
            });

            if (args != null && args.Length > 0)
            {
                try
                {
                    commandLineApplication.Execute(args);
                }
                catch (CommandParsingException)
                {
                    return;
                }
            }
            else // defaults
            {
                App.Defaults = true;
                app.Run();
            }

            Console.ResetColor();
        }