/// <summary> /// Creates a new class for the tag block and returns a MutationCodeCreator who's root namespace is the new class. /// </summary> /// <param name="blockName">Name of the block definition.</param> /// <param name="blockAttribute">Tag block definition attribute for the block.</param> /// <returns>A new MutationCodeCreator for the child namespace.</returns> public MutationCodeCreator CreateTagBlockClass(string blockName, CodeAttributeDeclaration attribute) { // This method is here in case I decide to change the functionality of tag block definitions. // For now they are created the same as a tag group. MutationCodeCreator codeCreator = CreateTagGroupClass(blockName, attribute); // Add a region directive to the tag block. codeCreator.CodeClass.StartDirectives.Add(new CodeRegionDirective(CodeRegionMode.Start, blockName)); codeCreator.CodeClass.EndDirectives.Add(new CodeRegionDirective(CodeRegionMode.End, string.Empty)); // Return the new code creator for the tag block. return(codeCreator); }
public void CreateTagLayout(GuerillaReader reader, MutationCodeScope parentScope) { // Our child code creator for the tag group/block. MutationCodeCreator childCodeCreator = null; // Check if this tag block is a tag group. if (this.TagBlockDefinition.IsTagGroup == true) { // Get the tag group that points to this tag block definition. tag_group tagGroup = reader.TagGroups.First(tag => tag.definition_address == this.TagBlockDefinition.s_tag_block_definition.address); // Compute the size of the definition. int definitionSize = TagLayoutValidator.ComputeMutationDefinitionSize(reader, tagGroup.Definition.TagFields[tagGroup.Definition.GetFieldSetIndexClosestToH2Xbox()]); // Check if the tag group has a parent tag group it inherits from. if (tagGroup.ParentGroupTag != string.Empty) { // Get the parent tag group object. tag_group parentTagGroup = reader.TagGroups.First(tag => tag.GroupTag.Equals(tagGroup.ParentGroupTag) == true); // Now find the code scope for the parent tag layout. MutationCodeScope parentTagScope = parentScope.Types.Values.First(scope => scope.DefinitionAddress == parentTagGroup.definition_address); // Create a new tag group class. childCodeCreator = this.CodeCreator.CreateTagGroupClass(this.TypeName, TagGroupDefinitionAttribute.CreateAttributeDeclaration(tagGroup, definitionSize), parentTagScope.Namespace); } else { // Create a new tag group class. childCodeCreator = this.CodeCreator.CreateTagGroupClass(this.TypeName, TagGroupDefinitionAttribute.CreateAttributeDeclaration(tagGroup, definitionSize)); } } else { // Compute the size of the definition. int definitionSize = TagLayoutValidator.ComputeMutationDefinitionSize(reader, this.TagBlockDefinition.TagFields[this.TagBlockDefinition.GetFieldSetIndexClosestToH2Xbox()]); // Create a new tag block class. childCodeCreator = this.CodeCreator.CreateTagBlockClass(this.TypeName, TagBlockDefinitionAttribute.CreateAttributeDeclaration(this.TagBlockDefinition, definitionSize)); } // Process the tag block definition. ProcessTagBlockDefinition(reader, this.TagBlockDefinition, childCodeCreator, this.CodeScope, parentScope); }
/// <summary> /// Creates a new class for the tag group and returns a MutationCodeCreator who's root namespace is the new class. /// </summary> /// <param name="className">Name of the class definition.</param> /// <param name="blockAttribute">Tag block definition attribute for the block.</param> /// <param name="baseType">Name of the base type if this class inherits another type.</param> /// <returns>A new MutationCodeCreator for the child namespace.</returns> public MutationCodeCreator CreateTagGroupClass(string className, CodeAttributeDeclaration blockAttribute, string baseType = TagBlockDefinitionBaseType) { // Create a new code creator instance. MutationCodeCreator codeCreator = new MutationCodeCreator(); // Create the class code type declaration. codeCreator.CodeClass = new CodeTypeDeclaration(className); codeCreator.CodeClass.IsClass = true; codeCreator.CodeClass.BaseTypes.Add(new CodeTypeReference(baseType)); // Add the block attribute to the class declaration. codeCreator.CodeClass.CustomAttributes.Add(blockAttribute); // Add the new tag group class to our namespace. this.CodeNamespace.Types.Add(codeCreator.CodeClass); // Return the new code creator. return(codeCreator); }
public MutationTagLayoutCreator(TagBlockDefinition tagBlockDefinition) { // Initialize fields. this.TagBlockDefinition = tagBlockDefinition; this.CodeCreator = new MutationCodeCreator(); }
private void ProcessFields(List <tag_field> fields, GuerillaReader reader, MutationCodeCreator blockCodeCreator, MutationCodeScope blockCodeScope, MutationCodeScope parentScope) { // Loop through all of the fields in the collection. for (int i = 0; i < fields.Count; i++) { // Create a new field and add it to the scope for this block. string displayName, units, tooltip; EditorMarkUpFlags markupFlags; string fieldName = blockCodeScope.CreateCodeSafeFieldName(fields[i].type, fields[i].Name, out displayName, out units, out tooltip, out markupFlags); // Create an attribute collection for any attributes we might add to the field. CodeAttributeDeclarationCollection attributeCollection = new CodeAttributeDeclarationCollection(); // Make sure at least one of the required fields for a UI markup attribute is valid. if (markupFlags != EditorMarkUpFlags.None || displayName != string.Empty || units != string.Empty || tooltip != string.Empty) { // Create the UI markup attribute using the information provided. attributeCollection.Add(EditorMarkUpAttribute.CreateAttributeDeclaration(flags: markupFlags, displayName: displayName, unitsSpecifier: units, tooltipText: tooltip)); } // Handle each field accordingly. switch (fields[i].type) { case field_type._field_char_enum: case field_type._field_enum: case field_type._field_long_enum: { // Cast the field to a enum_definition struct. enum_definition enumDefinition = (enum_definition)fields[i]; // Check if there is an existing code scope for this enum type. MutationCodeScope enumScope = blockCodeScope.FindExistingCodeScope(enumDefinition.definition_address); if (enumScope == null) { // Create a new code scope for the enum type. enumScope = blockCodeScope.CreateCodeScopeForType(enumDefinition.Name, enumDefinition.definition_address, MutationCodeScopeType.Enum); // Create a new enum in the block definition for this field. blockCodeCreator.AddEnumOrBitmask(enumScope, enumDefinition); } // Add a field to the block definition for this enum type. blockCodeCreator.AddCustomTypedField(fields[i].type, fieldName, enumScope.Namespace, attributeCollection); break; } case field_type._field_byte_flags: case field_type._field_word_flags: case field_type._field_long_flags: { // Cast the field to a enum_definition struct. enum_definition enumDefinition = (enum_definition)fields[i]; // Check if there is an existing code scope for this bitmask type. MutationCodeScope bitmaskScope = blockCodeScope.FindExistingCodeScope(enumDefinition.definition_address); if (bitmaskScope == null) { // Create a new code scope for the bitmask type. bitmaskScope = blockCodeScope.CreateCodeScopeForType(enumDefinition.Name, enumDefinition.definition_address, MutationCodeScopeType.Bitmask); // Create a new bitmask in the block definition for this field. blockCodeCreator.AddEnumOrBitmask(bitmaskScope, enumDefinition); } // Add a field to the block definition for this bitmask type. blockCodeCreator.AddCustomTypedField(fields[i].type, fieldName, bitmaskScope.Namespace, attributeCollection); break; } case field_type._field_block: { // Get the definition struct from the field address. TagBlockDefinition tagBlockDefinition = reader.TagBlockDefinitions[fields[i].definition_address]; // Check if the tag block definition already exists in the parent code scope. MutationCodeScope tagBlockScope = parentScope.FindExistingCodeScope(tagBlockDefinition.s_tag_block_definition.address); if (tagBlockScope == null) { // Create a new code scope for the tag block definition. tagBlockScope = parentScope.CreateCodeScopeForType(tagBlockDefinition.s_tag_block_definition.Name, tagBlockDefinition.s_tag_block_definition.address, MutationCodeScopeType.TagBlock); // Compute the size of the definition. int definitionSize = TagLayoutValidator.ComputeMutationDefinitionSize(reader, tagBlockDefinition.TagFields[tagBlockDefinition.GetFieldSetIndexClosestToH2Xbox()]); // Create a new class for the tag block definition. MutationCodeCreator childBlockCodeCreator = this.CodeCreator.CreateTagBlockClass(tagBlockScope.Namespace, TagBlockDefinitionAttribute.CreateAttributeDeclaration(tagBlockDefinition, definitionSize)); // Process the tag block definition. ProcessTagBlockDefinition(reader, tagBlockDefinition, childBlockCodeCreator, tagBlockScope, parentScope); } // Create a field for the tag block. blockCodeCreator.AddTagBlockField(fieldName, tagBlockScope.Namespace, attributeCollection); break; } case field_type._field_struct: { // Cast the field to a tag_struct_definition. tag_struct_definition tagStruct = (tag_struct_definition)fields[i]; // Get the definition struct from the field address. TagBlockDefinition tagBlockDefinition = reader.TagBlockDefinitions[tagStruct.block_definition_address]; // Check if the tag block definition already exists in the parent code scope. MutationCodeScope tagBlockScope = parentScope.FindExistingCodeScope(tagBlockDefinition.s_tag_block_definition.address); if (tagBlockScope == null) { // Create a new code scope for the tag block definition. tagBlockScope = parentScope.CreateCodeScopeForType(tagBlockDefinition.s_tag_block_definition.Name, tagBlockDefinition.s_tag_block_definition.address, MutationCodeScopeType.Struct); // Compute the size of the definition. int definitionSize = TagLayoutValidator.ComputeMutationDefinitionSize(reader, tagBlockDefinition.TagFields[tagBlockDefinition.GetFieldSetIndexClosestToH2Xbox()]); // Create a new class for the tag block definition. MutationCodeCreator childBlockCodeCreator = this.CodeCreator.CreateTagBlockClass(tagBlockScope.Namespace, TagBlockDefinitionAttribute.CreateAttributeDeclaration(tagBlockDefinition, definitionSize)); // Process the tag block definition. ProcessTagBlockDefinition(reader, tagBlockDefinition, childBlockCodeCreator, tagBlockScope, parentScope); } // Build the tag block definition attribute for the field. attributeCollection.Add(TagStructAttribute.CreateAttributeDeclaration()); // Create a field for the tag block. blockCodeCreator.AddCustomTypedField(field_type._field_struct, fieldName, tagBlockScope.Namespace, attributeCollection); break; } case field_type._field_tag_reference: { // Cast the field to a tag_reference_definition definition. tag_reference_definition tagRegDefinition = (tag_reference_definition)fields[i]; // Build the tag reference attribute for the field. attributeCollection.Add(TagReferenceAttribute.CreateAttributeDeclaration(tagRegDefinition)); // Add the field with the group tag filter attribute. blockCodeCreator.AddField(fields[i].type, fieldName, attributeCollection); break; } case field_type._field_pad: case field_type._field_skip: case field_type._field_useless_pad: { // Build the padding attribute for the field. attributeCollection.Add(PaddingAttribute.CreateAttributeDeclaration(fields[i].type, fields[i].definition_address)); // Add the field with the padding attribute. blockCodeCreator.AddPaddingField(fieldName, fields[i].definition_address, attributeCollection); break; } case field_type._field_explanation: { // Cast the field to a explanation_definition. explaination_definition explanation = (explaination_definition)fields[i]; // Create a field for the explanation block. blockCodeCreator.AddExplanationField(fieldName, explanation.Name, explanation.Explaination); break; } case field_type._field_array_start: { // Build a list of fields inside of the array. List <tag_field> arrayFields = CreateArrayFieldList(fields, i); // Loop for the length of the array and process the fields. for (int x = 0; x < fields[i].definition_address; x++) { // Process the array fields. ProcessFields(arrayFields, reader, blockCodeCreator, blockCodeScope, parentScope); } // Skip the fields we just processed and the array terminator. i += arrayFields.Count + 1; break; } case field_type._field_data: { // Cast the field to a tag_dat_definition. tag_data_definition tagData = (tag_data_definition)fields[i]; // Create a tag data attribute for this field. attributeCollection.Add(TagDataAttribute.CreateAttributeDeclaration(tagData)); // Add the field to the collection. blockCodeCreator.AddField(fields[i].type, fieldName, attributeCollection); break; } case field_type._field_custom: break; case field_type._field_terminator: break; default: { // Check if the value type dictionary contains this field type. if (MutationCodeCreator.ValueTypeDictionary.Keys.Contains(fields[i].type) == false) { break; } // Add the field to the collection. blockCodeCreator.AddField(fields[i].type, fieldName, attributeCollection); break; } } } }
private void ProcessTagBlockDefinition(GuerillaReader reader, TagBlockDefinition blockDefinition, MutationCodeCreator blockCodeCreator, MutationCodeScope blockCodeScope, MutationCodeScope parentScope) { // Get the field set index that most closely resembles halo 2 xbox layout. int fieldSetIndex = blockDefinition.GetFieldSetIndexClosestToH2Xbox(); // Process all of the fields in the field_set. ProcessFields(blockDefinition.TagFields[fieldSetIndex], reader, blockCodeCreator, blockCodeScope, parentScope); }