public void Serialize(DataStorage.FileHeader header, Stream output)
{
output.WriteStringU32(this.Name);
output.WriteValueU32(this.Unk1);
output.WriteValueS32(this.Data.Length);
output.Write(this.Data, 0, this.Data.Length);
}
public void Serialize(DataStorage.FileHeader header, Stream output)
{
output.WriteStringU32(this.Tag);
if (header.Version >= 3)
{
output.WriteValueU8((byte)(this.Unk1 ? 1 : 0));
}
output.WriteStringU32(this.Name);
if (header.Version >= 2)
{
output.WriteValueU8((byte)(this.Unk3 ? 1 : 0));
}
if (this.Unk3 == false)
{
XmlResource0.Serialize(output, this.Content);
}
else
{
XmlResource1.Serialize(output, this.Content);
}
}
public void Serialize(DataStorage.FileHeader header, Stream output)
{
output.WriteStringU16(this.Path);
output.WriteValueS32(this.Scripts.Count);
foreach (var script in this.Scripts)
{
script.Serialize(header, output);
}
}
public void Serialize(DataStorage.FileHeader header, Stream output)
{
output.WriteValueU64(this.NameHash);
output.WriteValueU8(this.Unknown8);
if (header.Version == 2)
{
output.WriteValueU8(this.Unknown9);
}
output.Write(this.Data, 0, this.Data.Length);
}
public void Deserialize(DataStorage.FileHeader header, Stream input)
{
uint count = input.ReadValueU32();
this.Tables.Clear();
for (uint i = 0; i < count; i++)
{
var table = new TableData();
table.Deserialize(header, input);
this.Tables.Add(table);
}
}
public void Deserialize(DataStorage.FileHeader header, Stream input)
{
this.Path = input.ReadStringU16();
var count = input.ReadValueU32();
this.Scripts.Clear();
for (uint i = 0; i < count; i++)
{
var script = new ScriptData();
script.Deserialize(header, input);
this.Scripts.Add(script);
}
}
public void Deserialize(DataStorage.FileHeader header, Stream input)
{
this.NameHash = input.ReadValueU64();
this.Unknown8 = input.ReadValueU8();
this.Unknown9 = header.Version == 2 ? input.ReadValueU8() : (byte)0;
if (this.Unknown9 != 0 && this.Unknown9 != 1)
{
throw new InvalidOperationException();
}
this.Data = new byte[input.Length - input.Position];
input.Read(this.Data, 0, this.Data.Length);
}
public void Deserialize(DataStorage.FileHeader header, Stream input)
{
if (header.Version == 2)
{
this.NameHash = input.ReadValueU64();
this.DataHash = input.ReadValueU64();
}
this.Name = input.ReadStringU16();
var size = input.ReadValueU32();
this.Data = new byte[size];
input.Read(this.Data, 0, this.Data.Length);
}
public void Serialize(DataStorage.FileHeader header, Stream output)
{
if (header.Version == 2)
{
this.NameHash = FNV.Hash64(this.Name);
this.DataHash = FNV.Hash64(this.Data, 0, this.Data.Length);
output.WriteValueU64(this.NameHash);
output.WriteValueU64(this.DataHash);
}
output.WriteStringU16(this.Name);
output.WriteValueS32(this.Data.Length);
output.Write(this.Data, 0, this.Data.Length);
}
public void Deserialize(DataStorage.FileHeader header, Stream input)
{
input.Seek(input.Position + 6, SeekOrigin.Begin);
this.Name = input.ReadStringU32();
this.Unk1 = input.ReadValueU32();
if (this.Unk1 != 1)
{
throw new InvalidOperationException();
}
uint size = input.ReadValueU32();
this.Data = new byte[size];
input.Read(this.Data, 0, this.Data.Length);
}
public void Deserialize(DataStorage.FileHeader header, Stream input)
{
this.Tag = input.ReadStringU32();
this.Unk1 = (header.Version >= 3) ? (input.ReadValueU8() != 0) : true;
this.Name = input.ReadStringU32();
this.Unk3 = (header.Version >= 2) ? (input.ReadValueU8() != 0) : false;
if (this.Unk3 == false)
{
this.Content = XmlResource0.Deserialize(input);
}
else
{
this.Content = XmlResource1.Deserialize(input);
}
}
public void Serialize(DataStorage.FileHeader header, Stream input)
{
throw new NotImplementedException();
}
public void Deserialize(DataStorage.FileHeader header, Stream input)
{
this.NameHash = input.ReadValueU64();
this.Name = input.ReadStringU16();
if (header.Version >= 2)
{
throw new NotSupportedException();
}
else
{
var columnCount = input.ReadValueU16();
var unk1 = input.ReadValueU32();
var unk2 = input.ReadValueU32();
var rowSize = input.ReadValueU32();
var rowCount = input.ReadValueU32();
var data = input.ReadToMemoryStream(rowSize * rowCount);
this.Columns = new List<ColumnDefinition>();
for (uint i = 0; i < columnCount; i++)
{
this.Columns.Add(new ColumnDefinition()
{
NameHash = input.ReadValueU32(),
Type = (ColumnType)input.ReadValueU8(),
Unknown2 = input.ReadValueU8(),
Unknown3 = input.ReadValueU16(),
});
}
input = null;
this.Rows.Clear();
for (uint i = 0; i < rowCount; i++)
{
var row = new RowData();
data.Seek(i * rowSize, SeekOrigin.Begin);
foreach (var column in this.Columns)
{
if ((byte)column.Type > 163)
{
throw new FormatException();
}
switch (column.Type)
{
case ColumnType.Boolean:
{
var value = data.ReadValueU32();
if (value != 0 && value != 1)
{
throw new FormatException();
}
row.Columns.Add(value != 0);
break;
}
case ColumnType.Float32:
{
var value = data.ReadValueF32();
row.Columns.Add(value);
break;
}
case ColumnType.Signed32:
{
var value = data.ReadValueS32();
row.Columns.Add(value);
break;
}
case ColumnType.Unsigned32:
{
var value = data.ReadValueU32();
row.Columns.Add(value);
break;
}
case ColumnType.Hash32:
{
var value = data.ReadValueU32();
row.Columns.Add(value);
break;
}
case ColumnType.Hash64:
{
var value = data.ReadValueU64();
row.Columns.Add(value);
break;
}
case ColumnType.String8:
{
string value = data.ReadString(8, true);
row.Columns.Add(value);
break;
}
case ColumnType.String16:
{
string value = data.ReadString(16, true);
row.Columns.Add(value);
break;
}
case ColumnType.String32:
{
string value = data.ReadString(32, true);
row.Columns.Add(value);
break;
}
case ColumnType.String64:
{
string value = data.ReadString(64, true);
row.Columns.Add(value);
break;
}
case ColumnType.Color:
{
float r = data.ReadValueF32();
float g = data.ReadValueF32();
float b = data.ReadValueF32();
// TODO: de-stupidize this
row.Columns.Add(string.Format("{0}, {1}, {2}", r, g, b));
break;
}
case ColumnType.Hash64AndString32:
{
var hash = data.ReadValueU64();
string value = data.ReadString(32, true);
row.Columns.Add(value);
break;
}
default:
{
throw new FormatException();
}
}
}
this.Rows.Add(row);
}
}
}
