public static uint[] GetParentTree(StructuredDataInfo info, InstanceNew instanceJSON)
{
//if (info.BrokenInstances.Contains(instanceJSON.m_hash)) return new uint[0];
if (instanceJSON.ParentHash2 == 0)
{
return(new uint[0]);
}
uint[] parents = new[] { instanceJSON.ParentHash2 }.Concat(GetParentTree(info, info.Instances[instanceJSON.ParentHash2])).ToArray();
return(parents);
}
public static uint[] GetParentTree(StructuredDataInfo info, STUInstanceJSON instanceJSON)
{
if (info.BrokenInstances.Contains(instanceJSON.Hash))
{
return(new uint[0]);
}
if (instanceJSON.Parent == 0)
{
return(new uint[0]);
}
uint[] parents = new[] { instanceJSON.Parent }.Concat(GetParentTree(info, info.Instances[instanceJSON.Parent])).ToArray();
return(parents);
}
public ModeResult Run(string[] args)
{
if (args.Length < 2)
{
Console.Out.WriteLine("Missing required arg: \"output\"");
return(ModeResult.Fail);
}
string dataDirectory;
if (args.Length >= 2)
{
dataDirectory = args[1];
}
else
{
dataDirectory = StructuredDataInfo.GetDefaultDirectory();
}
_info = new StructuredDataInfo(dataDirectory);
CRC32 crc32 = new CRC32();
foreach (KeyValuePair <uint, string> instance in _info.KnownInstances)
{
//if (instance.Value.StartsWith("STUStatescript")) {
if (instance.Value.StartsWith("M"))
{
continue;
}
string mirrorType = instance.Value.Replace("STU", "M");
if (!mirrorType.StartsWith("M"))
{
continue;
}
uint hash = BitConverter.ToUInt32(crc32.ComputeHash(Encoding.ASCII.GetBytes(mirrorType.ToLowerInvariant())), 0);
if (_info.Instances.ContainsKey(hash))
{
Console.Out.WriteLine($"{hash:X8}, {mirrorType}");
}
//}
}
return(ModeResult.Success);
}
public static void WriteInstancesFile(StructuredDataInfo info, string output, uint[] allowedBases)
{
using (StreamWriter writer = new StreamWriter(output)) {
foreach (KeyValuePair <uint, STUInstanceJSON> hashPair in info.Instances)
{
if (allowedBases != null)
{
uint[] parents = GetParentTree(info, hashPair.Value);
bool any = parents.Any(allowedBases.Contains);
if (!any)
{
continue;
}
}
writer.WriteLine($"{hashPair.Key:X8}");
}
}
}
public ModeResult Run(string[] args)
{
string output = args[1];
Directory.CreateDirectory(output);
string dataPath = StructuredDataInfo.GetDefaultDirectory();
if (args.Length >= 3)
{
dataPath = args[2];
}
StructuredDataInfo info = new StructuredDataInfo(dataPath);
WriteFile(info.KnownEnums, Path.Combine(output, "KnownEnums.csv"));
WriteFile(info.KnownInstances, Path.Combine(output, "KnownTypes.csv"));
WriteFile(info.KnownFields, Path.Combine(output, "KnownFields.csv"));
return(ModeResult.Success);
}
public ModeResult Run(string[] args)
{
var asm = typeof(TankLib.STU.teStructuredData).Assembly;
var knownEnums = asm.GetTypes().Where(x => x.IsEnum && x.GetCustomAttribute <STUEnumAttribute>() != null).ToDictionary(x => x.GetCustomAttribute <STUEnumAttribute>().Hash, GetEnumDict);
var dataDirectory = args.Length >= 2 ? args[1] : StructuredDataInfo.GetDefaultDirectory();
var _info = new StructuredDataInfo(dataDirectory);
string[] extraData = args.Skip(2).ToArray();
foreach (string extra in extraData)
{
_info.LoadExtra(extra);
}
using (Stream file = File.OpenWrite(Path.Combine(dataDirectory, "KnownEnumNames.gen.csv")))
using (TextWriter writer = new StreamWriter(file)) {
writer.WriteLine("Hash, Name");
foreach (var entry in _info.Enums)
{
if (!knownEnums.ContainsKey(entry.Key) || knownEnums.Count <= 0)
{
continue;
}
var reverseDictionary = ToDictionarySafe(entry.Value.Values, x => x.Value, y => y.Hash);
foreach (var pair in reverseDictionary)
{
if (knownEnums[entry.Key].ContainsKey(pair.Key))
{
writer.WriteLine($"{pair.Value:X8}, {knownEnums[entry.Key][pair.Key]}");
}
}
}
}
return(ModeResult.Success);
}
public ModeResult Run(string[] args)
{
string output = args[1];
Directory.CreateDirectory(output);
string dataPath = StructuredDataInfo.GetDefaultDirectory();
if (args.Length >= 3)
{
dataPath = args[2];
}
StructuredDataInfo info = new StructuredDataInfo(dataPath);
WriteInstancesFile(info, Path.Combine(output, "instances.txt"), null);
WriteFieldsFile(info.Instances, Path.Combine(output, "fields.txt"));
WriteInstancesFile(info, Path.Combine(output, "stustatescriptstate_hashes.txt"), new [] { 0xA7213568u });
WriteInstancesFile(info, Path.Combine(output, "stuentitycomponent_hashes.txt"), new [] { 0xE46F5A44u });
WriteInstancesFile(info, Path.Combine(output, "stuunlock_hashes.txt"), new [] { 0x624B9A14u });
return(ModeResult.Success);
}
public ModeResult Run(string[] args)
{
if (args.Length < 2)
{
Console.Out.WriteLine("Missing required arg: \"output\"");
return(ModeResult.Fail);
}
string outDirectory = args[1];
string dataDirectory;
if (args.Length >= 3)
{
dataDirectory = args[2];
}
else
{
dataDirectory = StructuredDataInfo.GetDefaultDirectory();
}
string[] extraData = args.Skip(3).ToArray();
_info = new StructuredDataInfo(dataDirectory);
foreach (string extra in extraData)
{
_info.LoadExtra(extra);
}
const string stuTypeNamespace = "TankLib.STU.Types";
const string stuEnumNamespace = "TankLib.STU.Types.Enums";
if (!Directory.Exists(outDirectory))
{
Directory.CreateDirectory(outDirectory);
}
string generatedDirectory = Path.Combine(outDirectory, "Generated");
string generatedEnumsDirectory = Path.Combine(outDirectory, "Generated", "Enums");
var genericTypeFile = new FileWriter(Path.Combine(generatedDirectory, "Misc.cs"), stuTypeNamespace);
var genericEnumsFile = new FileWriter(Path.Combine(generatedEnumsDirectory, "Misc.cs"), stuEnumNamespace);
List <FileWriter> extraFileWriters = new List <FileWriter>();
Directory.CreateDirectory(generatedDirectory);
Directory.CreateDirectory(generatedEnumsDirectory);
void Build(ClassBuilder classBuilder, bool isEnum)
{
FileWriter fileWriter = isEnum ? genericEnumsFile : genericTypeFile;
if (classBuilder.HasRealName)
{
fileWriter = new FileWriter(Path.Combine(isEnum ? generatedEnumsDirectory : generatedDirectory, classBuilder.Name + ".cs"), isEnum ? stuEnumNamespace : stuTypeNamespace);
extraFileWriters.Add(fileWriter);
}
classBuilder.Build(fileWriter);
}
Dictionary <uint, FieldNew> enumFields = new Dictionary <uint, FieldNew>();
foreach (KeyValuePair <uint, InstanceNew> instance in _info.Instances.OrderBy(x => x.Value.Hash2))
{
//if (_info.BrokenInstances.Contains(instance.Key)) {
// continue;
//}
//if (instance.Key == 0x440233A5) { // for generating the mirror types with oldhash
// continue;
//}
if (_info.GetInstanceName(instance.Key) == "teStructuredData")
{
continue;
}
if (instance.Key == 0x2BB2C217)
{
continue; // references mirror data. todo: handle better
}
var tree = DumpHashes.GetParentTree(_info, instance.Value);
if (tree.Contains(0x54D6A5F9u))
{
continue; // ignore MirrorData (thx tim)
}
InstanceBuilder instanceBuilder = new InstanceBuilder(_info, instance.Value);
Build(instanceBuilder, false);
foreach (var field in instance.Value.m_fields)
{
if (field.m_serializationType != 8 && field.m_serializationType != 9)
{
continue;
}
var enumType = field.TypeHash2;
if (!enumFields.ContainsKey(enumType))
{
enumFields[enumType] = field;
}
}
}
foreach (KeyValuePair <uint, EnumNew> enumData in _info.Enums.OrderBy(x => x.Value.Hash2))
{
FieldNew field;
if (!enumFields.TryGetValue(enumData.Key, out field))
{
field = new FieldNew {
m_typeHash = enumData.Key.ToString("X8"),
m_size = 4
};
Logger.Warn("Enum", $"Enum {enumData.Value.Hash2:X8} is not referenced by a field");
}
EnumBuilder enumBuilder = new EnumBuilder(_info, field);
Build(enumBuilder, true);
}
genericTypeFile.Finish();
genericEnumsFile.Finish();
foreach (FileWriter writer in extraFileWriters)
{
writer.Finish();
}
return(ModeResult.Success);
}
public ModeResult Run(string[] args)
{
if (args.Length < 2)
{
Console.Out.WriteLine("Missing required arg: \"output\"");
return(ModeResult.Fail);
}
string outDirectory = args[1];
string dataDirectory;
if (args.Length >= 3)
{
dataDirectory = args[2];
}
else
{
dataDirectory = StructuredDataInfo.GetDefaultDirectory();
}
string[] extraData = args.Skip(3).ToArray();
_info = new StructuredDataInfo(dataDirectory);
foreach (string extra in extraData)
{
_info.LoadExtra(extra);
}
BuilderConfig instanceBuilderConfig = new BuilderConfig {
Namespace = "TankLib.STU.Types"
};
BuilderConfig enumBuilderConfig = new BuilderConfig {
Namespace = "TankLib.STU.Types.Enums"
};
string generatedDirectory = Path.Combine(outDirectory, "Generated");
string generatedEnumsDirectory = Path.Combine(outDirectory, "Generated", "Enums");
Directory.CreateDirectory(generatedDirectory);
Directory.CreateDirectory(generatedEnumsDirectory);
Dictionary <string, STUFieldJSON> enumFields = new Dictionary <string, STUFieldJSON>();
foreach (KeyValuePair <uint, STUInstanceJSON> instance in _info.Instances)
{
if (_info.BrokenInstances.Contains(instance.Key))
{
continue;
}
//if (instance.Key == 0x440233A5) { // for generating the mirror types with oldhash
// continue;
//}
InstanceBuilder instanceBuilder = new InstanceBuilder(instanceBuilderConfig, _info, instance.Value);
BuildAndWriteCSharp(instanceBuilder, generatedDirectory);
foreach (var field in instance.Value.Fields)
{
if (field.SerializationType != 8 && field.SerializationType != 9)
{
continue;
}
if (!enumFields.ContainsKey(field.Type))
{
enumFields[field.Type] = field;
EnumBuilder enumBuilder = new EnumBuilder(enumBuilderConfig, _info, field);
BuildAndWriteCSharp(enumBuilder, generatedEnumsDirectory);
}
}
}
return(ModeResult.Success);
}
