/// <summary>
/// Attempt to retrieve a KTID file
/// </summary>
/// <param name="instance"></param>
/// <param name="ndb"></param>
/// <param name="nameLists"></param>
/// <returns></returns>
public static string?GetName(this KTIDReference instance, RDBINFO ndb, params Dictionary <KTIDReference, string>[] nameLists)
{
if (instance == 0)
{
return("NULL");
}
if (ndb.HashMap.TryGetValue(instance, out var name) && !string.IsNullOrWhiteSpace(name))
{
return(name);
}
return(nameLists.Any(nameList => nameList.TryGetValue(instance, out name) && !string.IsNullOrWhiteSpace(name)) ? name : null);
}
/// <summary>
/// Parse from Buffer
/// </summary>
/// <param name="buffer"></param>
public KTIDTextureSet(Span <byte> buffer)
{
var data = MemoryMarshal.Cast <byte, KTIDReference>(buffer);
Textures = new KTIDReference[buffer.Length / 0x8];
for (var i = 0; i < data.Length; i += 2)
{
var index = data[i];
var ktid = data[i + 1];
Textures[index] = ktid;
}
}
/// <summary>
/// Read a KTID File list
/// </summary>
/// <param name="filename"></param>
/// <param name="game"></param>
/// <returns></returns>
public static Dictionary <KTIDReference, string> LoadKTIDFileList(string?filename = null, string game = "")
{
var loc = ManagedFSHelper.GetFileListLocation(filename, game, "rdb");
var csv = ManagedFSHelper.GetFileList(loc, 3);
var fileList = new Dictionary <KTIDReference, string>();
foreach (var(key, value) in csv.Select(x => (key: KTIDReference.Parse(x[1].ToLower(), NumberStyles.HexNumber), value: x[2])))
{
fileList[key] = value;
}
return(fileList);
}
private static string GetKTIDNameValue(KTIDReference ktid, bool ignoreNames, NDB ndb, params Dictionary <KTIDReference, string>[] filelists)
{
var name = ktid.GetName(ndb, filelists);
if (name == null)
{
name = $"KTID {ktid:x8}";
}
else if (ignoreNames)
{
name = $"{name} (KTID {ktid:x8})";
}
return(name);
}
/// <summary>
/// Read entry via KTID
/// </summary>
/// <param name="ktid"></param>
/// <returns></returns>
public Memory <byte> ReadEntry(KTIDReference ktid)
{
foreach (var rdb in RDBs)
{
for (var i = 0; i < rdb.Entries.Count; i++)
{
var(entry, _, _) = rdb.Entries[i];
if (entry.FileKTID == ktid)
{
return(ReadEntry(i));
}
}
}
return(Memory <byte> .Empty);
}
private static void Main(string[] args)
{
Logger.PrintVersion("Nyotengu");
var flags = CommandLineFlags.ParseFlags <DatabaseFlags>(CommandLineFlags.PrintHelp, args);
if (flags == null)
{
return;
}
var files = new HashSet <string>();
foreach (var path in flags.Paths)
{
if (File.Exists(path))
{
files.Add(path);
}
if (!Directory.Exists(path))
{
continue;
}
foreach (var file in Directory.GetFiles(path))
{
files.Add(file);
}
}
var ndbFiles = new Dictionary <KTIDReference, string>();
if (flags.NDBPaths != null)
{
foreach (var nameFile in flags.NDBPaths.Where(Directory.Exists).SelectMany(Directory.GetFiles).Union(flags.NDBPaths.Where(File.Exists)))
{
ndbFiles[RDB.Hash(Path.GetFileName(nameFile))] = nameFile;
if (KTIDReference.TryParse(Path.GetFileNameWithoutExtension(nameFile), NumberStyles.HexNumber, null, out var hashedName))
{
ndbFiles[hashedName] = nameFile;
}
}
}
var filelist = Cethleann.ManagedFS.Nyotengu.LoadKTIDFileListShared(flags.FileList, flags.GameId);
var propertyList = Cethleann.ManagedFS.Nyotengu.LoadKTIDFileList(null, "PropertyList");
var filters = flags.TypeInfoFilter?.Split(',').Select(x => RDB.Hash(x.Trim())).ToHashSet() ?? new HashSet <KTIDReference>();
var typeHashes = new Dictionary <KTIDReference, string>();
var extraHashes = new Dictionary <KTIDReference, string>();
var missingProperties = new HashSet <KTIDReference>();
foreach (var file in files)
{
Logger.Log(ConsoleSwatch.XTermColor.White, true, Console.Error, "Nyotengu", "INFO", file);
Span <byte> buffer = File.ReadAllBytes(file);
// ReSharper disable once SwitchStatementHandlesSomeKnownEnumValuesWithDefault
switch (buffer.GetDataType())
{
case DataType.OBJDB:
{
ProcessOBJDB(buffer, ndbFiles, filelist, propertyList, filters, flags, missingProperties);
break;
}
case DataType.NDB:
{
if (flags.HashTypes || flags.HashExtra)
{
HashNDB(buffer, typeHashes, extraHashes, flags);
}
else if (flags.CreateFilelist)
{
NDBFilelist(buffer, Path.GetFileNameWithoutExtension(Path.GetFileNameWithoutExtension(file)), flags, filelist);
}
else
{
ProcessNDB(buffer, flags);
}
break;
}
default:
Logger.Error("Nyotengu", $"Format for {file} is unknown!");
break;
}
}
if (flags.HashTypes)
{
foreach (var(hash, text) in typeHashes.OrderBy(x => x.Key))
{
Console.WriteLine($"TypeInfo,{hash:x8},{text}");
}
}
if (flags.HashExtra)
{
foreach (var(hash, text) in extraHashes.OrderBy(x => x.Key))
{
Console.WriteLine($"Property,{hash:x8},{text}");
}
}
// ReSharper disable once InvertIf
if (flags.CreateMissingList)
{
var location = ManagedFSHelper.GetFileListLocation(null, "MissingProperties", "rdb");
using var file = File.Open(location, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read);
file.Seek(0, SeekOrigin.End);
using var writer = new StreamWriter(file, Encoding.UTF8);
foreach (var hash in missingProperties)
{
writer.WriteLine($"Property,{hash:x8},");
}
}
}
private static bool HasKTIDNameValue(KTIDReference ktid, NDB ndb, params Dictionary <KTIDReference, string>[] filelists) => ktid.GetName(ndb, filelists) == null;
private static void Main(string[] args)
{
Logger.PrintVersion("Nyotengu");
var flags = CommandLineFlags.ParseFlags <AnimationGraphFlags>(CommandLineFlags.PrintHelp, args);
if (flags == null)
{
return;
}
var objdbNdb = new NDB();
var singletonNdb = new NDB();
if (!string.IsNullOrEmpty(flags.OBJDBNDBPath) && File.Exists(flags.OBJDBNDBPath))
{
objdbNdb = new NDB(File.ReadAllBytes(flags.OBJDBNDBPath));
}
if (!string.IsNullOrEmpty(flags.SingletonDBNDBPath) && File.Exists(flags.SingletonDBNDBPath))
{
singletonNdb = new NDB(File.ReadAllBytes(flags.SingletonDBNDBPath));
}
// ReSharper disable InconsistentNaming
var CE1DB = new OBJDB(File.ReadAllBytes(flags.OBJDBPath));
var CE1Singleton = new OBJDB(File.ReadAllBytes(flags.SingletonPath));
// ReSharper restore InconsistentNaming
var filelist = Cethleann.ManagedFS.Nyotengu.LoadKTIDFileList(flags.FileList, flags.GameId);
var animationFiles = new Dictionary <KTIDReference, string>();
foreach (var directory in flags.AnimationDirectories ?? new HashSet <string?>())
{
if (directory == null || !Directory.Exists(directory))
{
continue;
}
foreach (var file in Directory.GetFiles(directory))
{
var basename = Path.GetFileNameWithoutExtension(file);
if (basename.Length != 8 || !KTIDReference.TryParse(basename, out var reference))
{
reference = RDB.Hash(file, "G1A");
}
animationFiles[reference] = file;
}
}
var typeKTID = RDB.Hash("TypeInfo::Object::MotorCharacterSetting");
foreach (var entry in CE1DB.Entries.Select(x => x.Value).Where(entry => entry.Record.TypeInfoKTID == typeKTID))
{
var(_, values) = entry.GetProperty("CharacterModelNameHash");
if (values == null)
{
continue;
}
var(_, actions) = entry.GetProperty("CharacterActionObjectNameHashArray");
if (actions == null || actions.Length == 0)
{
continue;
}
var nameHashes = values.Where(x => x != null).Select(x => new KTIDReference(x)).ToArray();
if (!nameHashes.Any(x => flags.Hashes.Contains(x)))
{
continue;
}
Logger.Info("ANIM", $"Found Character Settings: {string.Join(", ", nameHashes.Select(x => GetKTIDNameValue(x, false, objdbNdb, filelist)))}");
var done = new HashSet <KTIDReference>();
foreach (var actionHash in actions.Select(x => new KTIDReference(x)))
{
if (!CE1Singleton.Entries.TryGetValue(actionHash, out var player))
{
Logger.Error("ANIM", $"Can't find animation player settings for {GetKTIDNameValue(actionHash, false, singletonNdb, filelist)}");
continue;
}
var properties = player.GetProperties("AnimationDataObjectNameHashArray", "SrcAnimationDataObjectNameHash", "DstAnimationDataObjectNameHash", "FCurveAnimationDataObjectNameHash");
var animationDataHashes = properties.SelectMany(x => x.values ?? Array.Empty <object?>()).ToArray();
var ktidHashes = animationDataHashes.Where(x => x != null).Select(x => new KTIDReference(x)).ToArray();
foreach (var animationDataHash in ktidHashes)
{
if (!CE1Singleton.Entries.TryGetValue(animationDataHash, out var animationData))
{
Logger.Error("ANIM", $"Can't find animation data for {GetKTIDNameValue(animationDataHash, false, singletonNdb, filelist)}");
continue;
}
var(_, animationHashes) = animationData.GetProperty("G1AFileResourceHash");
if (animationHashes == null)
{
Logger.Error("ANIM", $"Can't find animation references for {GetKTIDNameValue(animationDataHash, false, singletonNdb, filelist)}");
continue;
}
foreach (var animationHashActual in animationHashes.Where(x => x != null).Select(x => new KTIDReference(x)))
{
if (!done.Add(animationHashActual))
{
continue;
}
Logger.Info("ANIM", GetKTIDNameValue(animationHashActual, false, singletonNdb, filelist));
if (string.IsNullOrWhiteSpace(flags.Output) || !animationFiles.TryGetValue(animationHashActual, out var path))
{
continue;
}
if (!Directory.Exists(flags.Output))
{
Directory.CreateDirectory(flags.Output);
}
File.Copy(path, Path.Combine(flags.Output, Path.GetFileName(path)), true);
}
}
}
Console.WriteLine();
}
}
private static string GetKTIDNameValue(KTIDReference ktid, bool ignoreNames, NDB ndb, params Dictionary <KTIDReference, string>[] filelists)
{
var name = $"{ktid:x8}";
return(ignoreNames ? name : $"{ktid.GetName(ndb, filelists) ?? name}");
}
/// <summary> /// Load a referenced KTID file /// </summary> /// <param name="instance"></param> /// <param name="nyotengu"></param> /// <returns></returns> public static Memory <byte> Dereference(this KTIDReference instance, Nyotengu nyotengu) => nyotengu.ReadEntry(instance.KTID);
/// <summary> /// Load a referenced KTID structure. /// </summary> /// <param name="instance"></param> /// <param name="db"></param> /// <returns></returns> public static OBJDBStructure?Dereference(this KTIDReference instance, OBJDB db) => db.Entries.TryGetValue(instance.KTID, out var ktidInstance) ? ktidInstance : default;
