private static IEnumerable <TableFieldDescriptor> LoadInteral(TableHeader header, BinaryReader reader)
{
reader.BaseStream.Seek(TableHeader.Size + header.FieldDescriptionOffset, SeekOrigin.Begin);
for (var x = 0; x < header.FieldDescriptionCount; x++)
{
var next = LoadSingle(reader);
yield return(next);
}
}
public static WildstarTableRow Load(TableHeader header, List <TableFieldDescriptor> descriptors, int rowNumber,
BinaryReader reader)
{
List <WildstarTableColumn> columns = new List <WildstarTableColumn>();
foreach (var column in descriptors)
{
var dataColumn = WildstarTableColumn.Load(header, rowNumber, column, reader);
columns.Add(dataColumn);
}
return(new WildstarTableRow
{
Columns = columns
});
}
public static TableHeader FromReader(BinaryReader reader)
{
var magic = reader.ReadUInt32();
if (magic != ExpectedMagic)
{
throw new InvalidDataException($"Expecting signature {ExpectedMagic:X8}, but got {magic:X8}");
}
var ret = new TableHeader
{
Magic = magic,
Version = reader.ReadInt32(),
TableNameLength = reader.ReadInt64(),
Unknown1 = reader.ReadInt64(),
RecordSize = reader.ReadInt64(),
FieldDescriptionCount = reader.ReadInt64(),
FieldDescriptionOffset = reader.ReadInt64(),
EntryCount = reader.ReadInt64(),
EntryBlockSize = reader.ReadInt64(),
EntryBlockOffset = reader.ReadInt64(),
MaxEntry = reader.ReadInt64(),
IdLookupOffset = reader.ReadInt64(),
Unknown2 = reader.ReadInt64()
};
// We don't want the null character, hence the -1.
ret.TableName = Encoding.Unicode.GetString(reader.ReadBytes(((int)ret.TableNameLength - 1) * 2));
//uint64 offset = mFieldDescs.size() * sizeof(FieldDescEntry) + mHeader.ofsFieldDesc + 0x60;
//if (offset % 16)
//{
// offset += 16 - (offset % 16);
//}
ret.DataOffset = (ret.FieldDescriptionCount * TableFieldDescriptor.Size) + Size + ret.FieldDescriptionOffset;
if (ret.DataOffset % 16 != 0)
{
ret.DataOffset += 16 - (ret.DataOffset % 16);
}
return(ret);
}
public static WildstarTableColumn Load(TableHeader header, int rowNumber, TableFieldDescriptor column, BinaryReader reader)
{
var ret = new WildstarTableColumn();
var offset = TableHeader.Size + (header.RecordSize * rowNumber) + header.EntryBlockOffset + column.RowOffset;
reader.BaseStream.Seek(offset, SeekOrigin.Begin);
switch (column.FieldType)
{
case FieldType.Bool:
var val = reader.ReadUInt32();
ret.Value = val != 0;
break;
case FieldType.Float:
ret.Value = reader.ReadSingle();
break;
case FieldType.UInt32:
ret.Value = reader.ReadUInt32();
break;
case FieldType.UInt64:
ret.Value = reader.ReadUInt64();
break;
case FieldType.StringTableOffset:
// wat?
//var data =
//var entryOffset = data & 0x00000000FFFFFFFF;
var lowOffset = reader.ReadUInt32();
var highOffset = reader.ReadUInt32();
if (lowOffset > 0)
{
highOffset = lowOffset;
//var nextByte = reader.ReadInt32();
}
// TODO
var stringTableOffset = header.EntryBlockOffset + TableHeader.Size + (long)highOffset;
if (stringTableOffset < reader.BaseStream.Length)
{
reader.BaseStream.Seek(stringTableOffset, SeekOrigin.Begin);
using (
var stringReader = new StreamReader(reader.BaseStream, Encoding.Unicode, false, 1024, true))
{
StringBuilder valueBuilder = new StringBuilder();
while (true)
{
var next = stringReader.Read();
if (next == 0 || next == -1)
{
break;
}
valueBuilder.Append((char)next);
}
ret.Value = valueBuilder.ToString();
}
}
else
{
ret.Value = null;
}
break;
}
return(ret);
}
private TableHeader LoadHeader()
{
using (var binaryReader = new BinaryReader(_stream, Encoding.Unicode, true))
return(TableHeader.FromReader(binaryReader));
}
