public override bool Execute(List <string> args)
        {
            if (args.Count != 2)
            {
                return(false);
            }
            var outDir = args[1];
            ITagLayoutWriter writer;

            switch (args[0])
            {
            case "csharp":
                writer = new CSharpClassWriter(_stringIds, outDir);
                break;

            case "cpp":
                writer = new CppStructWriter(_stringIds, outDir);
                break;

            default:
                return(false);
            }
            Directory.CreateDirectory(outDir);
            var count = 0;

            using (var stream = _fileInfo.OpenRead())
            {
                foreach (var tagClass in _cache.TagClasses)
                {
                    TagLayoutGuess layout  = null;
                    HaloTag        lastTag = null;
                    foreach (var tag in _cache.Tags.FindAllByClass(tagClass))
                    {
                        Console.Write("Analyzing ");
                        TagPrinter.PrintTagShort(tag);

                        lastTag = tag;
                        var analyzer  = new TagAnalyzer(_cache, tag);
                        var data      = _cache.ExtractTag(stream, tag);
                        var tagLayout = analyzer.Analyze(data);
                        if (layout != null)
                        {
                            layout.Merge(tagLayout);
                        }
                        else
                        {
                            layout = tagLayout;
                        }
                    }
                    if (layout != null && lastTag != null)
                    {
                        Console.WriteLine("Writing {0} layout", tagClass);
                        LayoutGuessWriter.Write(lastTag, layout, writer);
                        count++;
                    }
                }
            }
            Console.WriteLine("Successfully generated {0} layouts!", count);
            return(true);
        }
        private bool ExecuteAddRemove(TagInstance tag, List <string> args)
        {
            if (args.Count < 3)
            {
                return(false);
            }
            var dependencies = args.Skip(2).Select(a => ArgumentParser.ParseTagIndex(_cache, a)).ToList();

            if (dependencies.Count == 0 || dependencies.Any(d => d == null))
            {
                return(false);
            }
            using (var stream = _info.OpenCacheReadWrite())
            {
                var data = _cache.ExtractTag(stream, tag);
                if (args[0] == "add")
                {
                    foreach (var dependency in dependencies)
                    {
                        if (data.Dependencies.Add(dependency.Index))
                        {
                            Console.WriteLine("Added dependency on tag {0:X8}.", dependency.Index);
                        }
                        else
                        {
                            Console.Error.WriteLine("Tag {0:X8} already depends on tag {1:X8}.", tag.Index,
                                                    dependency.Index);
                        }
                    }
                }
                else
                {
                    foreach (var dependency in dependencies)
                    {
                        if (data.Dependencies.Remove(dependency.Index))
                        {
                            Console.WriteLine("Removed dependency on tag {0:X8}.", dependency.Index);
                        }
                        else
                        {
                            Console.Error.WriteLine("Tag {0:X8} does not depend on tag {1:X8}.", tag.Index,
                                                    dependency.Index);
                        }
                    }
                }
                _cache.SetTagData(stream, tag, data);
            }
            return(true);
        }
示例#3
0
        public override bool Execute(List <string> args)
        {
            if (args.Count != 2 && args.Count != 3)
            {
                return(false);
            }
            var tag = ArgumentParser.ParseTagIndex(_cache, args[0]);

            if (tag == null)
            {
                return(false);
            }
            var file = args[1];
            var full = false;

            if (args.Count == 3)
            {
                if (args[2] == "full")
                {
                    full = true;
                }
                else
                {
                    return(false);
                }
            }

            byte[] data;
            using (var stream = _fileInfo.OpenRead())
                data = full ? _cache.ExtractTagWithHeader(stream, tag) : _cache.ExtractTag(stream, tag);
            using (var outStream = File.Open(file, FileMode.Create, FileAccess.Write))
            {
                outStream.Write(data, 0, data.Length);
                Console.WriteLine("Wrote 0x{0:X} bytes to {1}.", outStream.Position, file);
                Console.WriteLine("The tag's main struct will be at offset 0x{0:X}.", tag.MainStructOffset);
            }
            return(true);
        }
        public override bool Execute(List <string> args)
        {
            if (args.Count != 2)
            {
                return(false);
            }
            var             type   = args[0];
            var             outDir = args[1];
            TagLayoutWriter writer;

            switch (type)
            {
            case "csharp":
                writer = new CSharpLayoutWriter();
                break;

            case "cpp":
                writer = new CppLayoutWriter();
                break;

            default:
                return(false);
            }
            Directory.CreateDirectory(outDir);
            var count = 0;

            using (var stream = _info.OpenCacheRead())
            {
                foreach (var groupTag in _cache.Tags.NonNull().Select(t => t.Group.Tag).Distinct())
                {
                    TagLayoutGuess layout  = null;
                    TagInstance    lastTag = null;
                    foreach (var tag in _cache.Tags.FindAllInGroup(groupTag))
                    {
                        Console.Write("Analyzing ");
                        TagPrinter.PrintTagShort(tag);

                        lastTag = tag;
                        var analyzer  = new TagAnalyzer(_cache);
                        var data      = _cache.ExtractTag(stream, tag);
                        var tagLayout = analyzer.Analyze(data);
                        if (layout != null)
                        {
                            layout.Merge(tagLayout);
                        }
                        else
                        {
                            layout = tagLayout;
                        }
                    }
                    if (layout != null && lastTag != null)
                    {
                        Console.WriteLine("Writing {0} layout", groupTag);
                        var name      = _info.StringIds.GetString(lastTag.Group.Name);
                        var tagLayout = LayoutGuessFinalizer.MakeLayout(layout, name, groupTag);
                        var path      = Path.Combine(outDir, writer.GetSuggestedFileName(tagLayout));
                        writer.WriteLayout(tagLayout, path);
                        count++;
                    }
                }
            }
            Console.WriteLine("Successfully generated {0} layouts!", count);
            return(true);
        }