Beispiel #1
0
        private void buttonSaveAs_Click(object sender, EventArgs e)
        {
            if (saveFileDialog.ShowDialog() == DialogResult.OK)
            {
                myPackage.Description = textBoxDesc.Text;

                try
                {
                    myPackage.Save(saveFileDialog.FileName, null);
                }
                catch (Exception ex)
                {
                    FormMain.Instance.ErrorMessage(ex.Message);
                }
            }
        }
        public override object Execute(List <string> args)
        {
            if (args.Count < 1 || args.Count > 7)
            {
                return(false);
            }

            string packageName;
            string line = null;

            //
            // Parse input options
            //
            while (args.Count != 1)
            {
                var arg = args[0].ToLower();
                switch (arg)
                {
                case "tagfile":
                    Options |= ExportOptions.TagFile;
                    break;

                case "taglist":
                    Options |= ExportOptions.TagList;
                    break;

                case "tagbounds":
                    Options |= ExportOptions.TagBounds;
                    break;

                case "mapfiles":
                case "mapfile":
                    Options |= ExportOptions.MapFiles;
                    break;

                case "campaignfile":
                    Options |= ExportOptions.CampaignFile;
                    break;

                case "fontpackage":
                case "fontpackagefile":
                    Options |= ExportOptions.FontPackage;
                    break;

                case "files":
                    Options |= ExportOptions.Files;
                    break;

                default:
                    Console.WriteLine($"Invalid argument: {arg}");
                    break;
                }
                args.RemoveAt(0);
            }

            packageName = args[0];

            ModPackage = new ModPackage();

            //
            // Process options and create mod package
            //

            // assign everything to the first cache for now

            var tagStream = ModPackage.TagCachesStreams[0];

            ModPackage.CacheNames.Add("default");

            ModPackage.TagCaches[0] = new TagCacheHaloOnline(tagStream, new Dictionary <int, string>());
            ModPackage.Resources    = new ResourceCacheHaloOnline(CacheVersion.HaloOnline106708, ModPackage.ResourcesStream);

            CreateDescription();

            var tagIndices = new HashSet <int>();

            if (Options.HasFlag(ExportOptions.TagBounds))
            {
                int?fromIndex = -1;
                int?toIndex   = CacheContext.TagCache.NonNull().Last().Index;

                Console.WriteLine("Please specify the start index to be used:");
                string input = line = Console.ReadLine().TrimStart().TrimEnd();
                if (CacheContext.TryGetTag(input, out var fromInstance) && fromInstance != null)
                {
                    fromIndex = fromInstance.Index;
                }

                if (fromIndex != -1)
                {
                    Console.WriteLine("Please specify the end index to be used (press enter to skip):");
                    input = Console.ReadLine().TrimStart().TrimEnd();
                    if (input != "")
                    {
                        if (CacheContext.TryGetTag(input, out var toInstance) && fromInstance != null)
                        {
                            toIndex = toInstance.Index;
                        }
                        else
                        {
                            Console.WriteLine($"Invalid end index");
                            return(false);
                        }
                    }
                }
                else
                {
                    Console.WriteLine($"Invalid start index");
                    return(false);
                }

                // add tags to list
                foreach (var entry in Enumerable.Range(fromIndex.Value, toIndex.Value - fromIndex.Value + 1))
                {
                    if (!tagIndices.Contains(entry) && CacheContext.TagCache.GetTag(entry) != null)
                    {
                        tagIndices.Add(entry);
                    }
                }
            }

            if (Options.HasFlag(ExportOptions.TagFile))
            {
                Console.WriteLine("Enter the name of the tag list file (csv): ");
                string tagFile = Console.ReadLine().Trim();

                using (var tagListStream = File.Open(tagFile, FileMode.Open, FileAccess.Read))
                {
                    var reader = new StreamReader(tagListStream);

                    while (!reader.EndOfStream)
                    {
                        var tagName = reader.ReadLine();
                        if (CacheContext.TryGetTag(tagName, out var instance) && instance != null)
                        {
                            if (!tagIndices.Contains(instance.Index))
                            {
                                tagIndices.Add(instance.Index);
                            }
                            else
                            {
                                Console.WriteLine($"Falied to find  tag {tagName}");
                            }
                        }
                    }

                    reader.Close();
                }
            }

            if (Options.HasFlag(ExportOptions.TagList))
            {
                Console.WriteLine("Please specify the tags to be used (enter an empty line to finish):");

                while ((line = Console.ReadLine().TrimStart().TrimEnd()) != "")
                {
                    if (CacheContext.TryGetTag(line, out var instance) && instance != null && !tagIndices.Contains(instance.Index))
                    {
                        tagIndices.Add(instance.Index);
                    }
                }
            }

            if (Options.HasFlag(ExportOptions.MapFiles))
            {
                var mapFileNames = new HashSet <string>();

                Console.WriteLine("Please specify the .map files to be used (enter an empty line to finish):");

                while ((line = Console.ReadLine().TrimStart().TrimEnd()) != "")
                {
                    if (!File.Exists(line))
                    {
                        Console.WriteLine($"File {line} does not exist. Please enter a valid map file");
                        continue;
                    }
                    else
                    {
                        var mapFile = new FileInfo(line);
                        if (mapFile.Extension != ".map")
                        {
                            Console.WriteLine($"File {line} is not a map file.");
                            continue;
                        }

                        if (!mapFileNames.Contains(mapFile.FullName))
                        {
                            mapFileNames.Add(mapFile.FullName);
                        }
                    }
                }
                AddMaps(mapFileNames);
            }

            if (Options.HasFlag(ExportOptions.CampaignFile))
            {
                Console.WriteLine("Please specify the .campaign file to be used:");
                while (true)
                {
                    string campaignFileName = Console.ReadLine().TrimStart().TrimEnd();
                    if (!File.Exists(campaignFileName))
                    {
                        Console.WriteLine($"File {line} does not exist.");
                    }
                    else
                    {
                        var file = new FileInfo(campaignFileName);
                        if (file.Extension != ".campaign")
                        {
                            Console.WriteLine($"File {line} is not a campaign file.");
                            continue;
                        }
                        else
                        {
                            AddCampaignMap(file);
                            break;
                        }
                    }
                }
            }

            if (Options.HasFlag(ExportOptions.FontPackage))
            {
                Console.WriteLine("Using fonts\\font_package.bin");
                AddFontPackage();
            }

            if (Options.HasFlag(ExportOptions.Files))
            {
                Console.WriteLine("Please specify the directory containing the extra files to be added:");
                var directory = new DirectoryInfo(Console.ReadLine());
                if (!directory.Exists)
                {
                    Console.WriteLine($"ERROR: Directory does not exist.");
                    return(true);
                }

                AddFiles(directory);
            }

            //
            // Use the tag list collected to create new mod package
            //

            Console.WriteLine("Building...");

            AddStringIds();
            AddTags(tagIndices);

            ModPackage.Save(new FileInfo(packageName));

            Console.WriteLine("Done!");

            return(true);
        }