string FormatEnum(ref tag_field field, List <string> options, Type baseType, ActionRef <int> incrementMethod, bool isFlags = false)
{
StringWriter stringWriter = new StringWriter();
Dictionary <string, int> optionDictionary = new Dictionary <string, int>();
var baseTypeString = FormatTypeReference(baseType);
if (isFlags)
{
stringWriter.WriteLine("[Flags]");
}
stringWriter.WriteLine(string.Format("public enum {0} : {1}", ToTypeName(field.Name), baseTypeString));
stringWriter.WriteLine('{');
var index = isFlags ? 1 : 0;
foreach (string option in options)
{
if (option != string.Empty)
{
stringWriter.WriteLine("{0} = {1},", ProcessFieldName(ToTypeName(option), optionDictionary), index);
}
incrementMethod(ref index);
}
stringWriter.WriteLine("}");
return(stringWriter.ToString());
}
public static T ReadFieldDefinition <T>(this BinaryReader reader, tag_field field) where T : IReadDefinition, new()
{
// Seek to the tag_block_definition address.
reader.BaseStream.Position = field.definition - Guerilla.BaseAddress;
return(ReadFieldDefinition <T>(reader));
}
string GetBinaryReaderMethodName(tag_field field)
{
var method = (from m in Methods
where m.Key == valueTypeDictionary[field.type]
where m.Value.ToLower().Contains(valueTypeDictionary[field.type].Name.Split('.').Last().ToLower())
select m).First();
return(method.Value);
}
private void WriteTagBlockIndex(XmlWriter writer, tag_field field)
{
writer.WriteStartElement("byte");
writer.WriteAttributeString("name", field.Name + "-index?");
writer.WriteEndElement();
writer.WriteStartElement("byte");
writer.WriteAttributeString("name", field.Name + "-data?");
writer.WriteEndElement();
}
private void ProcessArrayFields(TagBlockDefinition definition, XmlWriter writer, IList <tag_field> fields,
ref tag_field field, ref int i, ref int offset)
{
var name = field.Name;
++i; //move past field_type._field_array_start
for (int index = 0; index < field.definition; ++index)
{
int startindex = i;
ProcessFields(definition, writer, fields, ref startindex, ref offset);
}
++i; // move past field_type._field_array_end
}
void WritePaddingField(StringWriter writer, ref tag_field field, Dictionary <string, int> fieldNames, out string fieldName, int paddingLength, bool isSkip = false)
{
var postFix = ProcessFieldName(ToMemberName(field.Name), fieldNames);
var token = "invalidName_";
postFix = postFix.Contains(token) ? postFix.Remove(postFix.IndexOf(token), token.Length) : postFix;
var paddingType = (isSkip ? "skip" : "padding");
fieldName = paddingType + postFix;
var fieldType = "byte";
writer.WriteLine(@"#region {0}", paddingType);
WriteFieldValArray(writer, paddingLength, fieldName, fieldType, true);
writer.WriteLine(@"#endregion");
}
public static List <tag_field> ReadFields(this BinaryReader reader)
{
var fields = new List <tag_field>();
var field = new tag_field();
do
{
long currentAddress = reader.BaseStream.Position;
field = reader.ReadFieldDefinition <tag_field>();
fields.Add(field);
// Seek to the next tag_field.
reader.BaseStream.Position = currentAddress + 16;
} while (field.type != field_type._field_terminator);
return(fields);
}
private void WriteField(XmlWriter writer, tag_field field, int fieldOffset)
{
var count = 0;
string[] postfixes;
var typeString = FormatTypeString(ref field, out count, out postfixes).ToLower();
var fieldName = field.Name == string.Empty ? field.group_tag.ToString() : field.Name;
if (count > 1)
{
for (int i = 0; i < count; ++i)
{
WriteField(writer, typeString, fieldName + ":" + postfixes[i], fieldOffset);
}
}
else
{
WriteField(writer, typeString, fieldName, fieldOffset);
}
}
public static int CalculateSizeOfField(tag_field field)
{
switch (field.type)
{
case field_type._field_struct:
{
tag_struct_definition struct_definition = (tag_struct_definition)field.Definition;
TagBlockDefinition blockDefinition = struct_definition.Definition;
return(CalculateSizeOfFieldSet(blockDefinition.LatestFieldSet.Fields));
}
case field_type._field_skip:
case field_type._field_pad:
return(field.definition);
default:
return(GetFieldSize(field.type));
}
}
private void WriteEnumElement(XmlWriter writer, ref tag_field field, int fieldOffset, List <string> options,
Type baseType, ActionRef <int> incrementMethod, bool isFlags = false)
{
Dictionary <string, int> optionDictionary = new Dictionary <string, int>();
var baseTypeString = FormatEnumReference(baseType, isFlags);
string name, description;
SplitNameDescription(field.Name, out name, out description);
writer.WriteStartElement(baseTypeString);
writer.WriteAttributeString("name", Format(name));
if (!string.IsNullOrEmpty(description))
{
writer.WriteAttributeString("description", description);
}
writer.WriteAttributeString("offset", fieldOffset.ToString());
var index = isFlags ? 0 : 0;
foreach (string option in options)
{
if (option != string.Empty)
{
SplitNameDescription(option, out name, out description);
writer.WriteStartElement("option");
writer.WriteAttributeString("name", Format(name));
if (!string.IsNullOrEmpty(description))
{
writer.WriteAttributeString("description", description);
}
writer.WriteAttributeString("value", index.ToString());
writer.WriteEndElement();
}
incrementMethod(ref index);
}
writer.WriteEndElement();
}
string ReadEnum(ref tag_field field)
{
switch (field.type)
{
case field_type._field_byte_flags:
return(FormatEnum(ref field, field.Definition.Options, typeof(byte), new ActionRef <int>(IncrementFlags), true));
case field_type._field_word_flags:
return(FormatEnum(ref field, field.Definition.Options, typeof(short), new ActionRef <int>(IncrementFlags), true));
case field_type._field_long_flags:
return(FormatEnum(ref field, field.Definition.Options, typeof(int), new ActionRef <int>(IncrementFlags), true));
case field_type._field_char_enum:
return(FormatEnum(ref field, field.Definition.Options, typeof(byte), new ActionRef <int>(IncrementEnum)));
case field_type._field_enum:
return(FormatEnum(ref field, field.Definition.Options, typeof(short), new ActionRef <int>(IncrementEnum)));
case field_type._field_long_enum:
return(FormatEnum(ref field, field.Definition.Options, typeof(int), new ActionRef <int>(IncrementEnum)));
}
throw new InvalidDataException();
}
void WriteFieldValArray(StringWriter writer, ref tag_field field, Dictionary <string, int> fieldNames, out string fieldName, out string fieldType, int arrayLength, bool isSkip = false)
{
fieldName = ProcessFieldName(ToMemberName(field.Name), fieldNames);
fieldType = ToTypeName(field.Name);
WriteFieldValArray(writer, arrayLength, fieldName, fieldType);
}
private void WriteField(StringWriter writer, tag_field field, Dictionary<string, int> fieldNames, out string fieldName, out string fieldType, string attributeString = "")
{
fieldType = FormatTypeString(ref field);
fieldName = ProcessFieldName(ToMemberName(field.Name), fieldNames);
WriteField(writer, fieldType, fieldName, attributeString);
}
private string ReadEnum(ref tag_field field)
{
switch (field.type)
{
case field_type._field_byte_flags:
return FormatEnum(ref field, field.Definition.Options, typeof(byte), new ActionRef<int>(IncrementFlags), true);
case field_type._field_word_flags:
return FormatEnum(ref field, field.Definition.Options, typeof(short), new ActionRef<int>(IncrementFlags), true);
case field_type._field_long_flags:
return FormatEnum(ref field, field.Definition.Options, typeof(int), new ActionRef<int>(IncrementFlags), true);
case field_type._field_char_enum:
return FormatEnum(ref field, field.Definition.Options, typeof(byte), new ActionRef<int>(IncrementEnum));
case field_type._field_enum:
return FormatEnum(ref field, field.Definition.Options, typeof(short), new ActionRef<int>(IncrementEnum));
case field_type._field_long_enum:
return FormatEnum(ref field, field.Definition.Options, typeof(int), new ActionRef<int>(IncrementEnum));
}
throw new InvalidDataException();
}
protected virtual string ResolveFieldName(ref tag_field field, string fallbackFieldName)
{
var fieldName = ToMemberName(field.Name);
return fieldName == "invalidName_" ? fallbackFieldName : fieldName;
}
private void ProcessArrayFields(IList<tag_field> fields, ElementArray elementArray, ref tag_field field, ref int i, ref int offset)
{
var name = field.Name;
++i; //move past field_type._field_array_start
for (int index = 0; index < field.definition; ++index)
{
int startindex = i;
ProcessFields(fields, elementArray, ref startindex, ref offset);
}
++i; // move past field_type._field_array_end
}
private void WriteTagBlockIndex(XmlWriter writer, tag_field field)
{
writer.WriteStartElement("byte");
writer.WriteAttributeString("name", field.Name + "-index?");
writer.WriteEndElement();
writer.WriteStartElement("byte");
writer.WriteAttributeString("name", field.Name + "-data?");
writer.WriteEndElement();
}
private void WriteEnumElement(XmlWriter writer, ref tag_field field, int fieldOffset, List<string> options, Type baseType, ActionRef<int> incrementMethod, bool isFlags = false)
{
Dictionary<string, int> optionDictionary = new Dictionary<string, int>();
var baseTypeString = FormatEnumReference(baseType, isFlags);
string name, description;
SplitNameDescription(field.Name, out name, out description);
writer.WriteStartElement(baseTypeString);
writer.WriteAttributeString("name", Format(name));
if (!string.IsNullOrEmpty(description))
writer.WriteAttributeString("description", description);
writer.WriteAttributeString("offset", fieldOffset.ToString());
var index = isFlags ? 0 : 0;
foreach (string option in options)
{
if (option != string.Empty)
{
SplitNameDescription(option, out name, out description);
writer.WriteStartElement("option");
writer.WriteAttributeString("name", Format(name));
if (!string.IsNullOrEmpty(description))
writer.WriteAttributeString("description", description);
writer.WriteAttributeString("value", index.ToString());
writer.WriteEndElement();
}
incrementMethod(ref index);
}
writer.WriteEndElement();
}
protected override string FormatTypeString(ref tag_field field)
{
var csType = valueTypeDictionary[field.type];
return FormatTypeReference(csType);
}
private string FormatTypeString(ref tag_field field, out int count, out string[] postfixes)
{
var type = valueTypeDictionary[field.type];
count = type.Item2;
postfixes = new string[count];
var typeName = FormatTypeReference(type.Item1);
switch (field.type)
{
case field_type._field_angle_bounds:
case field_type._field_real_fraction_bounds:
case field_type._field_short_bounds:
case field_type._field_real_bounds:
{
postfixes = new string[] { "min", "max" };
} break;
case field_type._field_argb_color:
case field_type._field_real_argb_color:
{
postfixes = new string[] { "alpha", "red", "green", "blue" };
} break;
case field_type._field_real_rgb_color:
case field_type._field_rgb_color:
{
postfixes = new string[] { "red", "green", "blue" };
} break;
case field_type._field_real_vector_3d:
case field_type._field_real_point_3d:
{
postfixes = new string[] { "x", "y", "z" };
} break;
case field_type._field_real_point_2d:
case field_type._field_real_vector_2d:
case field_type._field_point_2d:
{
postfixes = new string[] { "x", "y", };
} break;
case field_type._field_real_euler_angles_2d:
{
postfixes = new string[] { "pitch", "roll" };
} break;
case field_type._field_real_euler_angles_3d:
{
postfixes = new string[] { "pitch", "roll", "yaw" };
} break;
case field_type._field_real_quaternion:
{
postfixes = new string[] { "i", "j", "k", "w" };
} break;
default: break;
}
return typeName;
}
private void WriteEnumElement(XmlWriter writer, enum_definition enumDefinition, ref tag_field field, int fieldOffset)
{
switch (field.type)
{
case field_type._field_byte_flags:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(byte), new ActionRef<int>(IncrementFlags), true);
break;
case field_type._field_word_flags:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(short), new ActionRef<int>(IncrementFlags), true);
break;
case field_type._field_long_flags:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(int), new ActionRef<int>(IncrementFlags), true);
break;
case field_type._field_char_enum:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(byte), new ActionRef<int>(IncrementEnum));
break;
case field_type._field_enum:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(short), new ActionRef<int>(IncrementEnum));
break;
case field_type._field_long_enum:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(int), new ActionRef<int>(IncrementEnum));
break;
}
}
protected override string ResolveFieldName(ref tag_field field, string fallbackFieldName)
{
var fieldName = ToMemberName(field.Name);
return fieldName == string.Empty ? fallbackFieldName : fieldName;
}
private void ProcessArrayFields(tag_block_definition definition, XmlWriter writer, IList<tag_field> fields, ref tag_field field, ref int i, ref int offset)
{
var name = field.Name;
++i; //move past field_type._field_array_start
for (int index = 0; index < field.definition; ++index)
{
int startindex = i;
ProcessFields(definition, writer, fields, ref startindex, ref offset);
}
++i; // move past field_type._field_array_end
}
private void WriteField(XmlWriter writer, tag_field field, int fieldOffset)
{
var count = 0;
string[] postfixes;
var typeString = FormatTypeString(ref field, out count, out postfixes).ToLower();
var fieldName = field.Name == string.Empty ? field.group_tag.ToString() : field.Name;
if (count > 1)
{
for (int i = 0; i < count; ++i)
{
WriteField(writer, typeString, fieldName + ":" + postfixes[i], fieldOffset);
}
}
else
{
WriteField(writer, typeString, fieldName, fieldOffset);
}
}
void WriteField(StringWriter writer, tag_field field, Dictionary <string, int> fieldNames, out string fieldName, out string fieldType, string attributeString = "")
{
fieldType = FormatTypeString(ref field);
fieldName = ProcessFieldName(ToMemberName(field.Name), fieldNames);
WriteField(writer, fieldType, fieldName, attributeString);
}
private void WritePaddingField(StringWriter writer, ref tag_field field, Dictionary<string, int> fieldNames, out string fieldName, int paddingLength, bool isSkip = false)
{
var postFix = ProcessFieldName(ToMemberName(field.Name), fieldNames);
var token = "invalidName_";
postFix = postFix.Contains(token) ? postFix.Remove(postFix.IndexOf(token), token.Length) : postFix;
var paddingType = (isSkip ? "skip" : "padding");
fieldName = paddingType + postFix;
var fieldType = "byte";
writer.WriteLine(@"#region {0}", paddingType);
WriteFieldValArray(writer, paddingLength, fieldName, fieldType, true);
writer.WriteLine(@"#endregion");
}
protected override string FormatTypeString(ref tag_field field)
{
var csType = valueTypeDictionary[field.type];
return(FormatTypeReference(csType));
}
public static List <tag_field> ReadFieldSet(this BinaryReader reader, ref TagBlockDefinition definition, out tag_field_set field_set)
{
field_set = new tag_field_set();
if (definition.Name == "sound_block")
{
definition.field_sets_address = 0x957870;
//definition.field_set_latest_address = 0x906178;
field_set.version.fields_address = 0x906178;
field_set.version.index = 0;
field_set.version.upgrade_proc = 0;
field_set.version.size_of = -1;
field_set.size = 172;
field_set.alignment_bit = 0;
field_set.parent_version_index = -1;
field_set.fields_address = 0x906178;
field_set.size_string_address = 0x00795330;
field_set.size_string = "sizeof(sound_definition)";
}
else
{
// We are going to use the latest tag_field_set for right now.
if (definition.Name == "animation_pool_block")
{
reader.BaseStream.Position = definition.field_sets_address + ((definition.field_set_count - 2) * 76) - Guerilla.BaseAddress;
}
else if (definition.Name == "decorator_cache_block_data_block")
{
reader.BaseStream.Position = definition.field_sets_address + ((definition.field_set_count - 1) * 76) - Guerilla.BaseAddress;
}
else
{
reader.BaseStream.Position = definition.field_set_latest_address - Guerilla.BaseAddress;
}
field_set = reader.ReadFieldDefinition <tag_field_set>();
}
// Seek to the field set address.
reader.BaseStream.Position = field_set.fields_address - Guerilla.BaseAddress;
var fields = new List <tag_field>();
var field = new tag_field();
do
{
long currentAddress = reader.BaseStream.Position;
field = reader.ReadFieldDefinition <tag_field>();
fields.Add(field);
// Seek to the next tag_field.
reader.BaseStream.Position = currentAddress + 16;// sizeof(tag_field);
}while (field.type != field_type._field_terminator);
var blockName = definition.Name;
var methods = (from method in Assembly.GetExecutingAssembly().GetTypes().SelectMany(x => x.GetMethods(BindingFlags.NonPublic | BindingFlags.Static))
where method.IsDefined(typeof(GuerillaPreProcessMethodAttribute), false)
from attribute in method.GetCustomAttributes(typeof(GuerillaPreProcessMethodAttribute), false)
where (attribute as GuerillaPreProcessMethodAttribute).BlockName == blockName
select method).ToArray();
if (methods.Count() > 0)
{
methods[0].Invoke(null, new object[] { reader, fields });
}
return(fields);
}
private void WriteFieldValArray(StringWriter writer, ref tag_field field, Dictionary<string, int> fieldNames, out string fieldName, out string fieldType, int arrayLength, bool isSkip = false)
{
fieldName = ProcessFieldName(ToMemberName(field.Name), fieldNames);
fieldType = ToTypeName(field.Name);
WriteFieldValArray(writer, arrayLength, fieldName, fieldType);
}
private string FormatEnum(ref tag_field field, List<string> options, Type baseType, ActionRef<int> incrementMethod, bool isFlags = false)
{
StringWriter stringWriter = new StringWriter();
Dictionary<string, int> optionDictionary = new Dictionary<string, int>();
var baseTypeString = FormatTypeReference(baseType);
if (isFlags)
stringWriter.WriteLine("[Flags]");
stringWriter.WriteLine(string.Format("public enum {0} : {1}", ToTypeName(field.Name), baseTypeString));
stringWriter.WriteLine('{');
var index = isFlags ? 1 : 0;
foreach (string option in options)
{
if (option != string.Empty)
{
stringWriter.WriteLine("{0} = {1},", ProcessFieldName(ToTypeName(option), optionDictionary), index);
}
incrementMethod(ref index);
}
stringWriter.WriteLine("}");
return stringWriter.ToString();
}
private void WritePaddingField(StringWriter writer, ref tag_field field, Dictionary<string, int> fieldNames, out string fieldName, bool isSkip = false)
{
WritePaddingField(writer, ref field, fieldNames, out fieldName, field.definition, isSkip);
}
protected virtual string FormatTypeString(ref tag_field field)
{
return(field.type.ToString());
}
private string GetBinaryReaderMethod(tag_field field)
{
var method = (from m in Methods
where m.Key == valueTypeDictionary[field.type]
where m.Value.ToLower().Contains(valueTypeDictionary[field.type].Name.Split('.').Last().ToLower())
select m).First();
return method.Value;
}
private void WriteEnumElement(XmlWriter writer, enum_definition enumDefinition, ref tag_field field, int fieldOffset)
{
switch (field.type)
{
case field_type._field_byte_flags:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(byte), new ActionRef <int>(IncrementFlags), true);
break;
case field_type._field_word_flags:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(short), new ActionRef <int>(IncrementFlags), true);
break;
case field_type._field_long_flags:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(int), new ActionRef <int>(IncrementFlags), true);
break;
case field_type._field_char_enum:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(byte), new ActionRef <int>(IncrementEnum));
break;
case field_type._field_enum:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(short), new ActionRef <int>(IncrementEnum));
break;
case field_type._field_long_enum:
WriteEnumElement(writer, ref field, fieldOffset, enumDefinition.Options, typeof(int), new ActionRef <int>(IncrementEnum));
break;
}
}
public static int CalculateSizeOfField(tag_field field)
{
switch (field.type)
{
case field_type._field_struct:
{
tag_struct_definition struct_definition = (tag_struct_definition)field.Definition;
tag_block_definition blockDefinition = struct_definition.Definition;
return CalculateSizeOfFieldSet(blockDefinition.LatestFieldSet.Fields);
}
case field_type._field_skip:
case field_type._field_pad:
return field.definition;
default:
return GetFieldSize(field.type);
}
}
void WritePaddingField(StringWriter writer, ref tag_field field, Dictionary <string, int> fieldNames, out string fieldName, bool isSkip = false)
{
WritePaddingField(writer, ref field, fieldNames, out fieldName, field.definition, isSkip);
}
protected virtual string FormatTypeString(ref tag_field field)
{
return field.type.ToString();
}
private void ProcessArrayFields(tag_block_definition definition, Dictionary<string, string> structDictionary,
StringWriter writer, List<tag_field> fields, ref tag_field field, ref int fieldIndex, Dictionary<string, int> fieldNames,
out string fieldName, out string fieldType)
{
fieldName = ToTypeName(field.Name);
writer.WriteLine("public struct {0}", fieldName);
writer.WriteLine("{");
var name = field.Name;
++fieldIndex;
string fieldDefinitions, constructorBody;
ProcessFields(definition, structDictionary, writer, fields, ref fieldIndex, out fieldDefinitions, out constructorBody);
writer.WriteLine("public {0}(BinaryReader binaryReader)", fieldName);
writer.WriteLine("{");
writer.Write(constructorBody);
writer.WriteLine("}");
writer.WriteLine("}");
WriteFieldValArray(writer, ref field, fieldNames, out fieldName, out fieldType, field.definition);
}
protected virtual string ResolveFieldName(ref tag_field field, string fallbackFieldName)
{
var fieldName = ToMemberName(field.Name);
return(fieldName == "invalidName_" ? fallbackFieldName : fieldName);
}
protected override string ResolveFieldName(ref tag_field field, string fallbackFieldName)
{
var fieldName = ToMemberName(field.Name);
return(fieldName == string.Empty ? fallbackFieldName : fieldName);
}
private void ProcessArrayFields(IList <tag_field> fields, ElementArray elementArray, ref tag_field field, ref int i, ref int offset)
{
var name = field.Name;
++i; //move past field_type._field_array_start
for (int index = 0; index < field.definition; ++index)
{
int startindex = i;
ProcessFields(fields, elementArray, ref startindex, ref offset);
}
++i; // move past field_type._field_array_end
}
private string FormatTypeString(ref tag_field field, out int count, out string[] postfixes)
{
var type = valueTypeDictionary[field.type];
count = type.Item2;
postfixes = new string[count];
var typeName = FormatTypeReference(type.Item1);
switch (field.type)
{
case field_type._field_angle_bounds:
case field_type._field_real_fraction_bounds:
case field_type._field_short_bounds:
case field_type._field_real_bounds:
{
postfixes = new string[] { "min", "max" };
} break;
case field_type._field_argb_color:
case field_type._field_real_argb_color:
{
postfixes = new string[] { "alpha", "red", "green", "blue" };
} break;
case field_type._field_real_rgb_color:
case field_type._field_rgb_color:
{
postfixes = new string[] { "red", "green", "blue" };
} break;
case field_type._field_real_vector_3d:
case field_type._field_real_point_3d:
{
postfixes = new string[] { "x", "y", "z" };
} break;
case field_type._field_real_point_2d:
case field_type._field_real_vector_2d:
case field_type._field_point_2d:
{
postfixes = new string[] { "x", "y", };
} break;
case field_type._field_real_euler_angles_2d:
{
postfixes = new string[] { "pitch", "roll" };
} break;
case field_type._field_real_euler_angles_3d:
{
postfixes = new string[] { "pitch", "roll", "yaw" };
} break;
case field_type._field_real_quaternion:
{
postfixes = new string[] { "i", "j", "k", "w" };
} break;
default: break;
}
return(typeName);
}
