Пример #1
0
        public WeatherDefinition(TagDefinition TagDef, EndianReader br) : base(TagDef)
        {
            // Add New Stream
            base.AddStream("WeatherRaw");

            // Weather
            for (int i = 0; i < ((TagBlock)base.Owner[0]).BlockCount; i++)
            {
                // Get Values
                int Offset = (int)((TagBlock)base.Owner[0])[i][15].GetValue();
                int Size   = (int)((TagBlock)base.Owner[0])[i][16].GetValue();

                // Double Check
                if ((Offset & 0xC0000000) == 0 && (Offset & 0x3FFFFFFF) > 0 && Size > 0)
                {
                    // Write new Offset
                    Offset &= 0x3FFFFFFF;
                    ((TagBlock)base.Owner[0])[i][15].SetValue((int)base["WeatherRaw"].Length);

                    // Write Raw
                    br.BaseStream.Position = Offset;
                    byte[] Buffer = br.ReadBytes(Size);
                    base["WeatherRaw"].Write(Buffer, 0, Buffer.Length);

                    // Write Padding
                    int Padding = 512 - ((int)base["WeatherRaw"].Length % 512);
                    if (Padding != 512)
                    {
                        base["WeatherRaw"].Write(new byte[Padding], 0, Padding);
                    }
                }
            }
        }
Пример #2
0
 /// <summary>
 /// Unsubscribes from a tag.
 /// </summary>
 /// <param name="tag">The tag.</param>
 private void UnsubscribeTag(TagDefinition tag)
 {
     _subscribedTags.TryRemove(tag.Id, out var _);
     if (_subscriptions.TryRemove(tag.Id, out var subscription))
     {
         subscription.Dispose();
     }
 }
Пример #3
0
        protected override Task <TagDefinition> UpdateTag(ClaimsPrincipal identity, TagDefinition tag, TagSettings update, string description, CancellationToken cancellationToken)
        {
            if (!_tags.ContainsKey(tag.Id))
            {
                throw new ArgumentException("Tag is not registered.", nameof(tag));
            }

            return(base.UpdateTag(identity, tag, update, description, cancellationToken));
        }
Пример #4
0
 /// <summary>
 /// Updates a tag.
 /// </summary>
 /// <param name="identity">The identity of the caller.</param>
 /// <param name="tag">The tag to update.</param>
 /// <param name="update">The updated tag definition.</param>
 /// <param name="description">A description of the change.</param>
 /// <param name="cancellationToken">The cancellation token for the request.</param>
 /// <returns>
 /// The updated tag definition.
 /// </returns>
 async Task <TagDefinition> IHistorian.UpdateTag(ClaimsPrincipal identity, TagDefinition tag, TagSettings update, string description, CancellationToken cancellationToken)
 {
     ThrowIfDisposed();
     if (tag.Historian != this)
     {
         throw new ArgumentException(Resources.Error_CannotOperateOnTagsOwnedByAnotherHistorian, nameof(tag));
     }
     return(await UpdateTag(identity, tag, update, description, cancellationToken).ConfigureAwait(false));
 }
Пример #5
0
        /// <summary>
        /// Saves updated tag definitions to Redis.
        /// </summary>
        /// <param name="updated">The updated tag definition.</param>
        private static void TagUpdated(TagDefinition updated)
        {
            var redisTag = updated as RedisTagDefinition;

            if (redisTag == null)
            {
                return;
            }

            redisTag._historian.RunBackgroundTask(ct => redisTag.Save(ct));
        }
Пример #6
0
        private void DisplayTag(TagDefinition tag, string prefix = "", int width = 0)
        {
            string strippedTagKind = tag.Kind.ToString().Replace("TYPE_", "");

            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.Write(prefix);
            Console.Write("{0,1}", tag.Name, -width);
            Console.ResetColor();
            Console.Write(": " + tag.Description + " (kind: " + strippedTagKind);
            Console.WriteLine(" | unit: " + tag.Unit + ")");
        }
Пример #7
0
        public bool Contains(TagDefinition def)
        {
            int num = TagDefinitions.Length;

            for (int i = 0; i < num; i++)
            {
                if (TagDefinitions[i].Tag == def.Tag)
                {
                    return(true);
                }
            }
            return(false);
        }
Пример #8
0
        private CachedTagInstance ConvertCachedTagInstance(ModPackageExtended modPack, CachedTagInstance modTag)
        {
            // Determine if tag requires conversion
            if (modPack.Tags.Index[modTag.Index] == null)
            {
                return(CacheContext.TagCache.Index[modTag.Index]);   // references an HO tag
            }
            else
            {
                // tag has already been converted
                if (TagMapping.ContainsKey(modTag.Index))
                {
                    return(CacheContext.TagCache.Index[TagMapping[modTag.Index]]);   // get the matching tag in the destination package
                }
                else
                {
                    CachedTagInstance newTag;
                    if (modTag.Index <= MagicNumber)
                    {
                        newTag = CacheContext.GetTag(modTag.Index);
                    }
                    else if (!CacheContext.TryGetTag($"{modTag.Name}.{modTag.Group}", out newTag))
                    {
                        newTag      = CacheContext.TagCache.AllocateTag(modTag.Group);
                        newTag.Name = modTag.Name;
                    }

                    TagMapping.Add(modTag.Index, newTag.Index);
                    var definitionType = TagDefinition.Find(modTag.Group.Tag);
                    var tagDefinition  = CacheContext.Deserialize(new ModPackageTagSerializationContext(modPack.TagsStream, CacheContext, modPack, modTag), definitionType);
                    tagDefinition = ConvertData(modPack, tagDefinition);

                    if (definitionType == typeof(ForgeGlobalsDefinition))
                    {
                        tagDefinition = ConvertForgeGlobals((ForgeGlobalsDefinition)tagDefinition);
                    }
                    else if (definitionType == typeof(Scenario))
                    {
                        tagDefinition = ConvertScenario(modPack, (Scenario)tagDefinition);
                    }
                    CacheContext.Serialize(CacheStream, newTag, tagDefinition);

                    foreach (var resourcePointer in modTag.ResourcePointerOffsets)
                    {
                        newTag.AddResourceOffset(resourcePointer);
                    }
                    return(newTag);
                }
            }
        }
Пример #9
0
        private TagDefinition[] BuildTagDefinitions()
        {
            List <TagDefinition> tags = new List <TagDefinition>();

            foreach (TagBuilder builder in _tagBuilders)
            {
                TagDefinition td = new TagDefinition
                {
                    Id          = builder.Id,
                    DisplayName = builder.DisplayName,
                    Handler     = BuildTagHandler(builder.TagHandler)
                };
                tags.Add(td);
            }
            return(tags.ToArray());
        }
Пример #10
0
        public ITageService GetTagService(TagDefinition tagDefinition)
        {
            switch (tagDefinition.Handler.StepHandlerType)
            {
            case StepHandlerTypeEnum.IoC:
                return(new IocTagService(tagDefinition, _iocTagServiceProvider));

            case StepHandlerTypeEnum.Script:
                return(new ScriptTagService(tagDefinition));

            case StepHandlerTypeEnum.Service:
            case StepHandlerTypeEnum.None:
                return(new EmptyTagService(tagDefinition.Id, tagDefinition.DisplayName));

            default:
                throw new ArgumentException($"Invalid or unsupported Step Handler type:{tagDefinition.Handler.StepHandlerType}");
            }
        }
Пример #11
0
        /// <summary>
        /// Updates a tag.
        /// </summary>
        /// <param name="identity">The identity of the caller.</param>
        /// <param name="tag">The tag to update.</param>
        /// <param name="update">The updated tag definition.</param>
        /// <param name="description">The change description</param>
        /// <param name="cancellationToken">The cancellation token for the request.</param>
        /// <returns>
        /// The updated tag definition.
        /// </returns>
        protected override Task <TagDefinition> UpdateTag(ClaimsPrincipal identity, TagDefinition tag, TagSettings update, string description, CancellationToken cancellationToken)
        {
            if (tag == null)
            {
                throw new ArgumentNullException(nameof(tag));
            }
            if (update == null)
            {
                throw new ArgumentNullException(nameof(update));
            }

            if (!_tags.ContainsKey(tag.Id))
            {
                throw new ArgumentException(Resources.Error_InvalidTagId, nameof(tag));
            }

            return(base.UpdateTag(identity, tag, update, description, cancellationToken));
        }
Пример #12
0
        private void ConvertMutationPlugins(object sender, DoWorkEventArgs e)
        {
            // Cast the sender object to a background worker.
            BackgroundWorker worker = sender as BackgroundWorker;

            // Update the status label.
            worker.ReportProgress(0, "Initializing...");

            // Initialize the mutation plugin repository.
            HaloPlugins.Halo2Xbox h2xPlugins = new HaloPlugins.Halo2Xbox();

            // Loop through all of the plugins and process each one.
            for (int i = 0; i < h2xPlugins.TagExtensions.Length; i++)
            {
                // Create an instance of the current plugin definition.
                TagDefinition definition = h2xPlugins.CreateInstance(h2xPlugins.TagExtensions[i]);
            }
        }
Пример #13
0
        private void buttonX1_Click(object sender, EventArgs e)
        {
            OpenFileDialog ofd = new OpenFileDialog();

            ofd.Filter = "Halo 2 Tags (*.*)|*.*";
            if (Global.Application.Instance.IsProjectOpen != false)
            {
                ofd.InitialDirectory = Global.Application.Instance.Project.TagFolder;
            }
            if (ofd.ShowDialog() == DialogResult.OK)
            {
                // Open tag
                EndianReader br = new EndianReader(IO.Endianness.Little, new FileStream(ofd.FileName, FileMode.Open, FileAccess.Read, FileShare.Read));

                // Get Ext
                string        ext    = ofd.FileName.Substring(ofd.FileName.LastIndexOf(".") + 1);
                TagDefinition tagdef = EngineManager.Engines[Global.Application.Instance.Project.Engine].CreateInstance(ext);

                // Read
                tagdef.Read(br);

                // Close
                br.Close();

                // See if tag belongs to this project
                if (!Global.Application.Instance.Project.Tags.Contains(tagdef.AbsolutePath))
                {
                    // Ask to add
                    if (MessageBox.Show("Mutation has detected this tag does not belong to the opened project.\r\nWould you like to add it to the project?", "Add tag to project", MessageBoxButtons.YesNo) == DialogResult.Yes)
                    {
                        // Add
                        MessageBox.Show("This feature has not yet been enabled in Mutation.\r\nPlease wait for a new build.", "Future feature");
                        return;
                    }
                }
                else
                {
                    Reference           = tagdef.AbsolutePath;
                    this.textEdit1.Text = Reference;
                    textEdit1.ForeColor = Color.RoyalBlue;
                }
            }
        }
Пример #14
0
        /// <summary>
        /// Creates a new <see cref="TagDefinitionDto"/> object from the specified <see cref="TagDefinition"/>.
        /// </summary>
        /// <param name="tagDefinition">The tag definition to copy from.</param>
        /// <exception cref="ArgumentNullException"><paramref name="tagDefinition"/> is <see langword="null"/>.</exception>
        internal static TagDefinitionDto ToTagDefinitionDto(this TagDefinition tagDefinition)
        {
            if (tagDefinition == null)
            {
                throw new ArgumentNullException(nameof(tagDefinition));
            }

            return(new TagDefinitionDto()
            {
                Id = tagDefinition.Id,
                Name = tagDefinition.Name,
                Description = tagDefinition.Description,
                Units = tagDefinition.Units,
                DataType = tagDefinition.DataType.ToString(),
                StateSet = tagDefinition.DataType == TagDataType.State
                    ? tagDefinition.StateSet
                    : null
            });
        }
Пример #15
0
        private bool GetShader(
            Mutex mutex,
            Stream stream,
            CachedTagInstance instance,
            IEnumerable <int> shader_rmdfs_ids,
            out RenderMethod rm_shader_definition,
            out Type rm_shader_type,
            out TagSerializationContext rm_shader_context,
            out string rmdf_name
            )
        {
            // get shader
            rm_shader_definition = null;
            rm_shader_type       = null;
            rm_shader_context    = null;
            rmdf_name            = null;
            {
                stream.Position   = 0;
                rm_shader_context = new TagSerializationContext(stream, CacheContext, instance);

                // if there is no dependency on the rmsh, early exit

                if (shader_rmdfs_ids != null && !rm_shader_context.Tag.Dependencies.Intersect(shader_rmdfs_ids).Any())
                {
                    mutex.ReleaseMutex();
                    return(true);
                }
                rm_shader_type       = TagDefinition.Find(rm_shader_context.Tag.Group.Tag);
                rm_shader_definition = CacheContext.Deserializer.Deserialize(rm_shader_context, rm_shader_type) as RenderMethod;
                // double check to make sure this is the correct render method definition
                if (shader_rmdfs_ids != null && !shader_rmdfs_ids.Contains(rm_shader_definition.BaseRenderMethod.Index))
                {
                    mutex.ReleaseMutex();
                    return(true);
                }

                var rmdf_index = rm_shader_definition.BaseRenderMethod.Index;
                rmdf_name = CacheContext.GetTag(rmdf_index)?.Name ?? rmdf_index.ToString("X");
            }

            return(false);
        }
Пример #16
0
        public override object Execute(List <string> args)
        {
            if (args.Count != 1)
            {
                return(false);
            }

            var destDir = new DirectoryInfo(args[0]);

            if (!destDir.Exists)
            {
                destDir.Create();
            }

            foreach (var entry in TagGroup.Instances)
            {
                if (entry.Key.Value == -1)
                {
                    continue;
                }

                var tagGroupName     = CacheContext.GetString(entry.Value.Name).ToSnakeCase();
                var tagStructureInfo = TagStructure.GetTagStructureInfo(TagDefinition.Find(entry.Key), CacheContext.Version);

                foreach (var type in tagStructureInfo.Types.Reverse <Type>())
                {
                    var info = type.GetCustomAttributes <TagStructureAttribute>(false).Where(attr =>
                                                                                             CacheVersionDetection.IsBetween(CacheContext.Version, attr.MinVersion, attr.MaxVersion)).First();

                    if (info.Name == null)
                    {
                        Console.WriteLine($"WARNING: {type.FullName} has no tag structure name defined!");
                        continue;
                    }

                    ExportType(type, new FileInfo(Path.Combine(destDir.FullName, $"{info.Name}.hpp")));
                }
            }

            return(true);
        }
Пример #17
0
        public static bool TryParseGroupTag(GameCache cache, string name, out Tag result)
        {
            if (TagDefinition.TryFind(name, out var type))
            {
                var attribute = TagStructure.GetTagStructureAttribute(type);
                result = new Tag(attribute.Tag);
                return(true);
            }

            foreach (var pair in TagGroup.Instances)
            {
                if (name == cache.StringTable.GetString(pair.Value.Name))
                {
                    result = pair.Value.Tag;
                    return(true);
                }
            }

            result = Tag.Null;
            return(name == "none" || name == "null");
        }
Пример #18
0
        private void CopyTagNames(Stream cacheStream, CachedTagInstance edTag, CacheFile.IndexItem blamTag)
        {
            if (CopiedTags.ContainsKey(blamTag.GroupTag))
            {
                foreach (var name in CopiedTags[blamTag.GroupTag])
                {
                    if (name == blamTag.Name)
                    {
                        return;
                    }
                }
            }
            else
            {
                CopiedTags[blamTag.GroupTag] = new List <string>();
            }

            CopiedTags[blamTag.GroupTag].Add(blamTag.Name);

            var edDef   = CacheContext.Deserialize(cacheStream, edTag);
            var blamDef = BlamCache.Deserializer.Deserialize(
                new CacheSerializationContext(ref BlamCache, blamTag),
                TagDefinition.Find(blamTag.GroupTag));

            var edInfo   = TagStructure.GetTagStructureInfo(edDef.GetType(), CacheContext.Version);
            var blamInfo = TagStructure.GetTagStructureInfo(blamDef.GetType(), BlamCache.Version);

            var oldName = edTag.Name;

            edTag.Name = blamTag.Name;

            if (edTag.Name != oldName)
            {
                NewNameCount++;
            }

            CopyTagNames(cacheStream, edDef, edInfo, blamDef, blamInfo);
        }
Пример #19
0
        //public TagEditorPage(string Class)
        //{
        //    //Suspend Layout
        //    this.SuspendLayout();

        //    // Set Fields
        //    saved = false;

        //    // Load tagdef
        //    plugin = EngineManager.Engines[Global.Application.Instance.Project.Engine].CreateInstance(Class);

        //    // Create Panel
        //    Panel panel = new Panel();
        //    panel.SuspendLayout();
        //    panel.Dock = DockStyle.Fill;
        //    panel.AutoScroll = true;
        //    panel.AutoSize = true;
        //    panel.BackColor = Color.FromKnownColor(KnownColor.Control);

        //    // Load into panel
        //    LoadIntoPanel();

        //    // Update Tab
        //    this.Text = "New_Tag." + plugin.CompiledClass + "*";
        //    panel.ResumeLayout();
        //    this.Controls.Add(panel);

        //    //Resume
        //    this.ResumeLayout();
        //}

        public void Open(string Location)
        {
            // Open the tag
            this.path = Location;
            EndianReader br = new EndianReader(Endianness.Little, new FileStream(Location, FileMode.Open, FileAccess.ReadWrite, FileShare.ReadWrite));

            // Create tag def
            string Ext = Location.Substring(Location.LastIndexOf(".") + 1);

            plugin = EngineManager.Engines[Global.Application.Instance.Project.Engine].CreateInstance(Ext);

            // Read
            plugin.Read(br);

            // Close
            br.Close();

            // Load into panel
            LoadIntoPanel();

            // Set the tab name.
            this.Text = Location.Substring(Location.LastIndexOf("\\") + 1);
        }
Пример #20
0
        public BitmapDefinition(TagDefinition TagDef, EndianReader br) : base(TagDef)
        {
            // Create a new stream
            base.AddStream("BitmapRaw");

            // Bitmaps
            for (int i = 0; i < ((TagBlock)base.Owner[20]).BlockCount; i++)
            {
                // 3 LODS
                for (int x = 0; x < 3; x++)
                {
                    // Get Values
                    int Offset = (int)((TagBlock)base.Owner[20])[i][12 + x].GetValue();
                    int Size   = (int)((TagBlock)base.Owner[20])[i][18 + x].GetValue();

                    // Double Check
                    if ((Offset & 0xC0000000) == 0 && (Offset & 0x3FFFFFFF) > 0 && Size > 0)
                    {
                        // Write new Offset
                        Offset &= 0x3FFFFFFF;
                        ((TagBlock)base.Owner[20])[i][12 + x].SetValue((int)base["BitmapRaw"].Length);

                        // Write Raw
                        br.BaseStream.Position = Offset;
                        byte[] Buffer = br.ReadBytes(Size);
                        base["BitmapRaw"].Write(Buffer, 0, Buffer.Length);

                        // Write Padding
                        int Padding = 512 - ((int)base["BitmapRaw"].Length % 512);
                        if (Padding != 512)
                        {
                            base["BitmapRaw"].Write(new byte[Padding], 0, Padding);
                        }
                    }
                }
            }
        }
Пример #21
0
        public void GetRMDF_IDs(string template_name, out IEnumerable <int> shader_rmdfs_ids, out Type template_type)
        {
            template_type    = null;
            shader_rmdfs_ids = null;

            IEnumerable <CachedTagInstance> shader_rmdfs = null;

            switch (template_name)
            {
            case "shader_templates":
            case "shader_template":
                template_type = typeof(Shader);
                //shader_rmdfs = CacheContext.TagNames.Where(item => item.Value == @"shaders\shader").Select(item => CacheContext.GetTag(item.Key)).ToList();
                break;

            case "cortana_templates":
            case "cortana_template":
                template_type = typeof(ShaderCortana);
                //shader_rmdfs = CacheContext.TagNames.Where(item => item.Value == @"shaders\cortana").Select(item => CacheContext.GetTag(item.Key)).ToList();
                break;

            case null:
            case "*":
                break;

            default:
                Console.WriteLine("Invalid template_type");
                break;
            }
            if (shader_rmdfs != null)
            {
                shader_rmdfs     = shader_rmdfs.Where(rmdf => TagDefinition.Find(rmdf.Group.Tag) == typeof(RenderMethodDefinition));
                shader_rmdfs_ids = shader_rmdfs.Select(rmdf => rmdf.Index);
                shader_rmdfs_ids = new int[] { shader_rmdfs_ids.FirstOrDefault() };
            }
        }
Пример #22
0
 public object Deserialize(Stream stream, CachedTagGen2 instance) =>
 Deserialize(new Gen2SerializationContext(stream, this, instance), TagDefinition.Find(instance.Group.Tag));
Пример #23
0
 public override object Deserialize(Stream stream, CachedTag instance) =>
 Deserialize(new Gen1SerializationContext(stream, this, (CachedTagGen1)instance), TagDefinition.Find(instance.Group.Tag));
Пример #24
0
        public override object Execute(List <string> args)
        {
            if (args.Count < 1 || args.Count > 2)
            {
                return(false);
            }

begin:
            var groupTagString = args[0];

            if (groupTagString.Length > 4)
            {
                Console.WriteLine($"ERROR: Invalid group tag: {groupTagString}");
                return(true);
            }

            if (!Cache.TryParseGroupTag(groupTagString, out var groupTag))
            {
                var chars = new char[] { ' ', ' ', ' ', ' ' };

                for (var i = 0; i < chars.Length; i++)
                {
                    chars[i] = groupTagString[i];
                }

                groupTag = new Tag(new string(chars));
            }

            if (!TagGroup.Instances.ContainsKey(groupTag))
            {
                Console.WriteLine($"ERROR: No tag group definition for group tag '{groupTag}'!");
                Console.Write($"(BE CAREFUL WITH THIS!!!) Define '{groupTag}' tag group? [y/n]: ");

                var answer = Console.ReadLine().ToLower();

                if (answer != "y" && answer != "yes")
                {
                    return(true);
                }

                Console.WriteLine("Enter the tag group specification in the following format");
                Console.WriteLine("<group tag> [parent group tag] [grandparent group tag] <group name>:");
                Console.WriteLine();
                Console.Write($"{groupTag} specification> ");

                answer = Console.ReadLine();

                var groupArgs = ArgumentParser.ParseCommand(answer, out string redirect);

                switch (groupArgs.Count)
                {
                case 2: new TagGroup(new Tag(groupArgs[0]), Tag.Null, Tag.Null, Cache.StringTable.GetStringId(groupArgs[1])); break;

                case 3: new TagGroup(new Tag(groupArgs[0]), new Tag(groupArgs[1]), Tag.Null, Cache.StringTable.GetStringId(groupArgs[2])); break;

                case 4: new TagGroup(new Tag(groupArgs[0]), new Tag(groupArgs[1]), new Tag(groupArgs[2]), Cache.StringTable.GetStringId(groupArgs[3])); break;

                default: return(false);
                }

                goto begin;
            }

            CachedTag instance = null;

            TagGroup.Instances.TryGetValue(groupTag, out var tagGroup);

            using (var stream = Cache.OpenCacheReadWrite())
            {
                if (args.Count == 2)
                {
                    var tagIndex = -1;

                    if (!Cache.TryGetCachedTag(args[1], out instance))
                    {
                        if (args[1].StartsWith("0x"))
                        {
                            tagIndex = Convert.ToInt32(args[1], 16);
                        }
                        else
                        {
                            return(false);
                        }
                    }
                    else
                    {
                        tagIndex = instance.Index;
                    }

                    while (tagIndex >= Cache.TagCache.Count)
                    {
                        Cache.TagCache.AllocateTag(TagGroup.None);
                    }

                    if (tagIndex < Cache.TagCache.Count)
                    {
                        if (Cache.TagCacheGenHO.Tags[tagIndex] != null)
                        {
                            var oldInstance = Cache.TagCacheGenHO.Tags[tagIndex];
                            Cache.TagCacheGenHO.Tags[tagIndex] = null;
                            Cache.TagCacheGenHO.SetTagDataRaw(stream, oldInstance, new byte[] { });
                        }

                        instance = Cache.TagCache.CreateCachedTag(tagIndex, TagGroup.Instances[groupTag]);
                        Cache.TagCacheGenHO.Tags[tagIndex] = (CachedTagHaloOnline)instance;
                    }
                }

                if (instance == null)
                {
                    instance = Cache.TagCache.AllocateTag(TagGroup.Instances[groupTag]);
                }

                Cache.Serialize(stream, instance, Activator.CreateInstance(TagDefinition.Find(groupTag)));
            }

            var tagName = instance.Name ?? $"0x{instance.Index:X4}";

            Console.WriteLine($"[Index: 0x{instance.Index:X4}] {tagName}.{Cache.StringTable.GetString(instance.Group.Name)}");
            return(true);
        }
Пример #25
0
 /// <summary>
 /// Gets whether the given tag's generator should be used for a secondary (or substitute) text block.
 /// </summary>
 /// <param name="definition">The tag to inspect.</param>
 /// <returns>True if the tag's generator should be used as a secondary generator.</returns>
 public override bool ShouldCreateSecondaryGroup(TagDefinition definition)
 {
     return(new string[] { "elif", "else" }.Contains(definition.Name));
 }
Пример #26
0
 /// <summary>
 /// Updates a tag.
 /// </summary>
 /// <param name="identity">The identity of the caller.</param>
 /// <param name="tag">The tag to update.</param>
 /// <param name="update">The updated tag definition.</param>
 /// <param name="description">A description of the change.</param>
 /// <param name="cancellationToken">The cancellation token for the request.</param>
 /// <returns>
 /// The updated tag definition.
 /// </returns>
 protected virtual Task <TagDefinition> UpdateTag(ClaimsPrincipal identity, TagDefinition tag, TagSettings update, string description, CancellationToken cancellationToken)
 {
     tag.Update(update, identity, description);
     return(Task.FromResult(tag));
 }
Пример #27
0
 /// <summary>
 /// IoC Service constructor
 /// </summary>
 public IocTagService(TagDefinition tagDef, Func <string, ITageService> iocTagServiceProvider)
 {
     _service    = iocTagServiceProvider(tagDef.Handler.IocName);
     Name        = _service.Name;
     DisplayName = _service.DisplayName;
 }
Пример #28
0
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="tagDefinition"></param>
 public ScriptTagService(TagDefinition tagDefinition)
 {
     Name        = tagDefinition.Id;
     DisplayName = tagDefinition.DisplayName;
     _sc         = new CsScriptRuntimeGeneric <string[]>(tagDefinition.Handler.Script);
 }
Пример #29
0
        public override object Execute(List <string> args)
        {
            if (args.Count < 2)
            {
                return(false);
            }
            var outputPath = args[0];

            // Load each file and do version detection
            var infos = new List <HaloOnlineCacheContext>();

            foreach (var path in args.Skip(1))
            {
                Console.WriteLine("Loading {0}...", path);

                // Load the cache file
                var cacheContext = new HaloOnlineCacheContext(new FileInfo(path).Directory);
                infos.Add(cacheContext);
            }

            var result = new TagVersionMap();

            using (var baseStream = CacheContext.OpenTagCacheRead())
            {
                // Get the scenario tags for this cache
                Console.WriteLine("Finding base scenario tags...");
                var baseScenarios = FindScenarios(CacheContext, baseStream);
                var baseVersion   = CacheContext.Version;
                var baseTagData   = new Dictionary <int, object>();
                foreach (var scenario in baseScenarios)
                {
                    baseTagData[scenario.Tag.Index] = scenario.Data;
                }

                // Now compare with each of the other caches
                foreach (var info in infos)
                {
                    using (var stream = info.OpenTagCacheRead())
                    {
                        Console.WriteLine("Finding scenario tags in {0}...", info.TagCacheFile.FullName);

                        // Get the scenario tags and connect them to the base tags
                        var scenarios     = FindScenarios(info, stream);
                        var tagsToCompare = new Queue <QueuedTag>();
                        for (var i = 0; i < scenarios.Count; i++)
                        {
                            tagsToCompare.Enqueue(scenarios[i]);
                            if (i < baseScenarios.Count)
                            {
                                result.Add(baseVersion, baseScenarios[i].Tag.Index, info.Version, scenarios[i].Tag.Index);
                            }
                        }

                        // Process each tag in the queue, enqueuing all of its dependencies as well
                        while (tagsToCompare.Count > 0)
                        {
                            // Get the tag and its data
                            var tag = tagsToCompare.Dequeue();
                            TagPrinter.PrintTagShort(tag.Tag);
                            var data = tag.Data;
                            if (data == null)
                            {
                                // No data yet - deserialize it
                                var context = new TagSerializationContext(stream, info, tag.Tag);
                                var type    = TagDefinition.Find(tag.Tag.Group.Tag);
                                data = info.Deserializer.Deserialize(context, type);
                            }

                            // Now get the data for the base tag
                            var baseTag = result.Translate(info.Version, tag.Tag.Index, baseVersion);
                            if (baseTag == -1 || CacheContext.TagCache.Index[baseTag].Group.Tag != tag.Tag.Group.Tag)
                            {
                                continue;
                            }
                            if (!baseTagData.TryGetValue(baseTag, out object baseData))
                            {
                                // No data yet - deserialize it
                                var context = new TagSerializationContext(baseStream, CacheContext, CacheContext.TagCache.Index[baseTag]);
                                var type    = TagDefinition.Find(tag.Tag.Group.Tag);
                                baseData             = CacheContext.Deserializer.Deserialize(context, type);
                                baseTagData[baseTag] = baseData;
                            }

                            // Compare the two blocks
                            CompareBlocks(baseData, baseVersion, data, info.Version, result, tagsToCompare);
                        }
                    }
                }
            }

            // Write out the CSV
            Console.WriteLine("Writing results...");
            using (var writer = new StreamWriter(File.Open(outputPath, FileMode.Create, FileAccess.Write)))
                result.WriteCsv(writer);

            Console.WriteLine("Done!");
            return(true);
        }
Пример #30
0
        public override object Execute(List <string> args)
        {
            if (args.Count != 2)
            {
                return(false);
            }

            var groupTagInput = args[0];
            var blamTagName   = args[1];
            var groupTag      = Tag.Null;

            if (TagDefinition.Exists(groupTagInput))
            {
                groupTag = new Tag(groupTagInput);
            }
            else
            {
                foreach (var tagGroup in BlamCache.IndexItems.ClassList)
                {
                    if (groupTagInput == BlamCache.Strings.GetItemByID(tagGroup.StringID))
                    {
                        var chars = new char[4] {
                            ' ', ' ', ' ', ' '
                        };

                        for (var i = 0; i < 4; i++)
                        {
                            chars[i] = tagGroup.ClassCode[i];
                        }

                        groupTag = new Tag(new string(chars));
                        break;
                    }
                }
            }

            CacheFile.IndexItem tag = null;

            foreach (var blamTag in BlamCache.IndexItems)
            {
                if ((blamTag.GroupTag == groupTag.ToString()) && (blamTagName == "*" || blamTag.Name == blamTagName))
                {
                    tag = blamTag;
                    break;
                }
            }

            if (tag == null)
            {
                throw new Exception();
            }

            var tagName = $"(0x{tag.ID:X8}) {tag.Name.Substring(tag.Name.LastIndexOf('\\') + 1)}";

            var tagType    = TagDefinition.Find(groupTag);
            var definition = (TagStructure)BlamCache.Deserializer.Deserialize(new CacheSerializationContext(ref BlamCache, tag), tagType);
            var structure  = definition.GetTagStructureInfo(BlamCache.Version);

            var oldContext = ContextStack.Context;

            var commandContext = new CommandContext(ContextStack.Context, string.Format("{0}.{1}", tagName, groupTagInput));

            commandContext.AddCommand(new ListFieldsCommand(BlamCache, structure, definition));
            commandContext.AddCommand(new EditBlockCommand(ContextStack, BlamCache, tag, definition));
            commandContext.AddCommand(new CopyBlockElementsCommand(ContextStack, BlamCache, tag, structure, definition));
            commandContext.AddCommand(new Editing.ExitToCommand(ContextStack));
            ContextStack.Push(commandContext);

            Console.WriteLine($"Tag {tagName}.{groupTagInput} has been opened for editing.");
            Console.WriteLine("New commands are now available. Enter \"help\" to view them.");
            Console.WriteLine("Use \"exit\" to return to {0}.", oldContext.Name);

            return(true);
        }