public Character(Database db, DNA dna, GTime time, int id) : this(db)
{
List <Gene> genes = dna.Genes;
this.CID = id;
this.BirthTime = time;
this.Dead = false;
this.DueDate = new GTime(true);
this.IsSingle = true;
this.Dna = dna;
// Gene Pair 1
int gone = genes[0].ToInt() % 2;
int gtwo = genes[1].ToInt() % 2;
if (gone + gtwo == 1)
{
this.Gender = true;
}
else if (gone + gtwo == 0)
{
this.Gender = false;
}
else
{
Console.WriteLine("{0} has two y chromosomes", id);
}
this.Fname = NDB.GenFname(this.Gender);
this.Lname = NDB.GenLname();
}
/// <summary>
/// Initialize with buffer and basic info about the FS
/// </summary>
/// <param name="buffer"></param>
/// <param name="name"></param>
/// <param name="directory"></param>
public RDB(Span <byte> buffer, string name, string directory)
{
Name = name;
Header = MemoryMarshal.Read <RDBHeader>(buffer);
RDBDirectory = directory;
DataDirectory = buffer.Slice(SizeHelper.SizeOf <RDBHeader>(), Header.HeaderSize - SizeHelper.SizeOf <RDBHeader>()).ReadString() ?? string.Empty;
Directory = Path.Combine(directory, DataDirectory);
var offset = Header.HeaderSize;
for (var i = 0; i < Header.Count; ++i)
{
var(entry, typeblob, data) = ReadRDBEntry(buffer.Slice(offset));
var fileEntry = entry.GetValueOrDefault();
offset += (int)fileEntry.EntrySize.Align(4);
Entries.Add((fileEntry, typeblob, DecodeOffset(((Span <byte>)data).ReadString() ?? "0")));
KTIDToEntryId[fileEntry.FileKTID] = i;
}
if (!KTIDToEntryId.TryGetValue(Header.NameDatabaseKTID, out var nameDatabaseId))
{
return;
}
var nameBuffer = ReadEntry(nameDatabaseId);
if (nameBuffer.Length == 0)
{
return;
}
NameDatabase = new NDB(nameBuffer.Span);
}
public static void Main(string[] args)
{
Logger.PrintVersion("Nyotengu");
var flags = CommandLineFlags.ParseFlags <FilelistFlags>(CommandLineFlags.PrintHelp, args);
if (flags == null || string.IsNullOrWhiteSpace(flags.GameDir))
{
return;
}
Logger.Info("Nyotengu", "Generating filename list...");
var nyotengu = new Cethleann.ManagedFS.Nyotengu(flags);
nyotengu.LoadFileList(flags.FileList, flags.GameId);
foreach (var rdb in Directory.GetFiles(flags.GameDir, "*.rdb"))
{
nyotengu.AddDataFS(rdb);
}
nyotengu.SaveGeneratedFileList(null, flags.GameId);
Logger.Info("Nyotengu", "Generating KTID property list...");
var propertyList = Cethleann.ManagedFS.Nyotengu.LoadKTIDFileListEx(null, "PropertyList");
foreach (var rdb in nyotengu.RDBs)
{
for (var i = 0; i < rdb.Entries.Count; ++i)
{
var entry = rdb.GetEntry(i);
if (entry.FileKTID == rdb.Header.NameDatabaseKTID)
{
continue;
}
if (entry.TypeInfoKTID != 0xbf6b52c7)
{
continue;
}
var namedb = new NDB(rdb.ReadEntry(i).Span);
foreach (var(_, strings) in namedb.Entries)
{
if (strings[1].Length == 0)
{
continue;
}
propertyList[RDB.Hash(strings[1])] = ("TypeInfo", strings[1]);
foreach (var str in strings.Skip(2))
{
propertyList[RDB.Hash(str)] = ("Property", str);
}
}
}
}
Cethleann.ManagedFS.Nyotengu.SaveGeneratedFileList(propertyList, null, "DEBUG");
}
private static void HashNDB(Span <byte> buffer, Dictionary <KTIDReference, string> typeInfo, Dictionary <KTIDReference, string> extra, DatabaseFlags flags)
{
var name = new NDB(buffer);
foreach (var(_, strings) in name.Entries)
{
typeInfo[RDB.Hash(strings[1])] = strings[1];
foreach (var str in strings.Skip(2))
{
extra[RDB.Hash(str)] = str;
}
}
}
private static void NDBFilelist(Span <byte> buffer, string ns, DatabaseFlags?flags, Dictionary <KTIDReference, string> filelist)
{
var name = new NDB(buffer);
foreach (var(entry, _) in name.Entries)
{
if (filelist.ContainsKey(entry.KTID))
{
continue;
}
var filename = name.NameMap[entry.KTID];
Console.WriteLine($"{ns},{entry.KTID:x8},{filename}");
}
}
private static void ProcessNDB(Span <byte> buffer, DatabaseFlags flags)
{
var name = new NDB(buffer);
foreach (var(entry, strings) in name.Entries)
{
var filename = name.NameMap[entry.KTID];
var text = $"{entry.KTID:x8},{RDB.Hash(strings[0]):x8},{strings.ElementAt(0)},{filename},{RDB.Hash(strings[1]):x8},{strings[1]}";
if (strings.Length > 2)
{
text += string.Join(string.Empty, strings.Skip(2));
}
Console.WriteLine(text);
}
}
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);
}
private static void ProcessOBJDB(Span <byte> buffer, Dictionary <KTIDReference, string> ndbFiles, Dictionary <KTIDReference, string> filelist, Dictionary <KTIDReference, string> propertyList, HashSet <KTIDReference> filters, DatabaseFlags flags, HashSet <KTIDReference> missingProperties)
{
var db = new OBJDB(buffer);
var ndb = new NDB();
if (ndbFiles.TryGetValue(db.Header.NameKTID, out var ndbPath))
{
ndb = new NDB(File.ReadAllBytes(ndbPath));
}
foreach (var(ktid, (entry, properties)) in db.Entries)
{
if (filters.Count != 0 && !filters.Contains(entry.TypeInfoKTID))
{
continue;
}
var lines = new List <string>
{
$"KTID: {GetKTIDNameValue(ktid, flags.ShowKTIDs, ndb, filelist, propertyList)}",
$"TypeInfo: {GetKTIDNameValue(entry.TypeInfoKTID, flags.ShowKTIDs, ndb, filelist, propertyList)}",
$"Parent: {GetKTIDNameValue(entry.ParentKTID, flags.ShowKTIDs, ndb, filelist, propertyList)}"
};
foreach (var(property, values) in properties)
{
if (flags.CreateMissingList && !HasKTIDNameValue(property.PropertyKTID, ndb, propertyList))
{
missingProperties.Add(property.PropertyKTID);
}
lines.Add($"{property.TypeId} {GetKTIDNameValue(property.PropertyKTID, flags.ShowKTIDs, ndb, propertyList)}: {(values.Length == 0 ? "NULL" : string.Join(", ", values.Select(x => property.TypeId == OBJDBPropertyType.UInt32 && x != null ? GetKTIDNameValue((uint) x, flags.ShowKTIDs, ndb, filelist, propertyList) : x?.ToString() ?? "NULL")))}");
}
foreach (var line in lines)
{
Console.Out.WriteLine(line);
}
Console.Out.WriteLine();
}
}
private static void Main(string[] args)
{
Logger.PrintVersion("Nyotengu");
var flags = CommandLineFlags.ParseFlags <KTIDFlags>(CommandLineFlags.PrintHelp, args);
if (flags == null)
{
return;
}
var ndb = new NDB();
if (!string.IsNullOrEmpty(flags.NDBPath) && File.Exists(flags.NDBPath))
{
ndb = new NDB(File.ReadAllBytes(flags.NDBPath));
}
var objdb = new OBJDB(File.ReadAllBytes(flags.OBJDBPath));
var filelist = Cethleann.ManagedFS.Nyotengu.LoadKTIDFileList(flags.FileList, flags.GameId);
var textureSection = new ResourceSectionHeader
{
Magic = DataType.TextureGroup,
Version = 0x30303630
};
var textureHeader = new TextureGroupHeader
{
System = objdb.Header.System
};
foreach (var ktid in flags.Paths)
{
if (!File.Exists(ktid))
{
continue;
}
var ktidgroup = new KTIDTextureSet(File.ReadAllBytes(ktid));
var ktidsystem = ktidgroup.Textures.Select(x => objdb.Entries.TryGetValue(x, out var tuple) ? tuple : default).ToArray();
public string RevsDiff(NDB.NouchDB db, RemoteDB remoteDB, DocInfo[] docInfo)
{
var result = "[";
Dictionary<string,string> docList = new Dictionary<string,string>();
for (int f = 0; f < docInfo.Length; f++ )
{
DocInfo remoteDoc = docInfo[f];
long revision = Convert.ToInt64(remoteDoc.Revision.Split('-')[0]);
Node localDoc = db.GetDocInfo(remoteDoc.ID);
if (localDoc == null)
{
if (Convert.ToInt64(localDoc.currentVersion) < revision)
{
if (!docList.ContainsKey(remoteDoc.ID))
{
docList.Add(remoteDoc.ID,"");
}
}
}
else
{
if (!docList.ContainsKey(remoteDoc.ID))
{
docList.Add(remoteDoc.ID, "");
}
}
}
return JsonMapper.ToJson(docList.Keys);
}
private static bool HasKTIDNameValue(KTIDReference ktid, NDB ndb, params Dictionary <KTIDReference, string>[] filelists) => ktid.GetName(ndb, filelists) == null;
public Character(Database db, Character dad, Character mom, GTime time, int id) : this(db, new DNA(dad.Dna.Miosis(), mom.Dna.Miosis()), time, id)
{
this.Fname = NDB.GenFname(this.Gender);
this.Lname = dad.Lname;
}
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}");
}
