private Dictionary <string, object> ReadDictionary(Stream input, ValueTag tag, Type objectType)
{
if (objectType != typeof(object) && objectType != typeof(Dictionary <string, object>))
{
throw new ArgumentException("objectType");
}
var length = input.ReadPackedValueUInt32();
var basePosition = input.Position;
var endPosition = basePosition + length;
if (endPosition > input.Length)
{
throw new EndOfStreamException();
}
var propertyTag = new ValueTag(input.ReadValueU8());
var instance = new Dictionary <string, object>();
while (propertyTag.Type != ValueType.Invalid)
{
var propertyName = input.ReadStringZ(Encoding.UTF8);
var propertyValue = this.ReadValue(input, propertyTag, typeof(object));
instance.Add(propertyName, propertyValue);
propertyTag = new ValueTag(input.ReadValueU8());
}
if (input.Position != endPosition)
{
throw new FormatException();
}
return(instance);
}
private void ReadOfs3(Stream s, Ofs3Data file)
{
file.StartOffset = s.Position;
file.Signature = s.ReadValueU32(Endianness);
file.HeaderSize = s.ReadValueU32(Endianness);
file.Type = s.ReadValueU16(Endianness);
file.Padding = s.ReadValueU8();
file.SubType = s.ReadValueU8();
file.Size = s.ReadValueU32(Endianness);
file.FileCount = s.ReadValueU32(Endianness);
file.FilesInfo = new FileInfo[file.FileCount];
for (var i = 0; i < file.FileCount; i++)
{
var offset = s.ReadValueU32(Endianness) + file.HeaderSize;
var size = s.ReadValueU32(Endianness);
var t = new FileInfo {
Offset = offset, Size = size
};
file.FilesInfo[i] = t;
}
file.Files = new Ofs3Data[file.FileCount];
for (var i = 0; i < file.FileCount; i++)
{
file.Files[i] = new Ofs3Data();
var offset = file.FilesInfo[i].Offset;
s.Seek(offset + file.StartOffset, SeekOrigin.Begin);
ReadFile(s, file.Files[i]);
}
}
private static object DeserializeNodeEntry(Stream input)
{
children = new List <object>();
var name_ = input.ReadStringU8(3); // File path
input.Seek(1, SeekOrigin.Current); // 0 terminator of string
input.Seek(18, SeekOrigin.Current); // 0 terminator of string
var node = new NodeEntry();
var nodeType = input.ReadValueU8();
var subNotes = input.ReadValueU8();
if (nodeType == 4)
{
byte[] unkBytes = new byte[6];
input.Read(unkBytes, 0, unkBytes.Length);
byte[] stringArr = new byte[255];
bool read = true;
char index = (char)0;
while (read)
{
byte[] reader = new byte[1];
input.Read(reader, 0, 1);
read = reader[0] != 0;
stringArr[index] = reader[0];
if (index == 0 && !read)
{
read = true;
}
if (index == 1 && !read)
{
break;
}
index++;
}
var name = Encoding.ASCII.GetString(stringArr);
name = name.Trim('\0');
name = name.Replace("\0", "");
nodeType = input.ReadValueU8();
subNotes = input.ReadValueU8();
if (nodeType == 4)
{
DeserializeNodeEntryInternal(node, input);
}
}
foreach (var child in children)
{
node.Children.Add((NodeEntry)child);
}
return(node);
}
public static TextureHeader Read(Stream input)
{
const Endian endian = Endian.Little;
TextureHeader instance;
instance.Unknown00 = input.ReadValueU32(endian);
instance.Unknown04 = input.ReadValueU32(endian);
instance.Type = (TextureType)input.ReadValueU32(endian);
instance.Format = (TextureFormat)input.ReadValueU32(endian);
instance.Unknown10 = input.ReadValueU32(endian);
instance.Unknown14 = input.ReadValueU16(endian);
instance.Width = input.ReadValueU16(endian);
instance.Height = input.ReadValueU16(endian);
instance.Depth = input.ReadValueU16(endian);
instance.Unknown1C = input.ReadValueU16(endian);
instance.MipCount = input.ReadValueU8();
instance.FirstMipIndex = input.ReadValueU8();
instance.DataChunkId = input.ReadValueGuid(Endian.Big);
instance.MipSizes = new uint[15];
for (int i = 0; i < 15; i++)
{
instance.MipSizes[i] = input.ReadValueU32(endian);
}
instance.TotalSize = input.ReadValueU32(endian);
instance.Unknown70 = input.ReadBytes(16);
instance.Unknown80 = input.ReadValueU32(endian);
instance.Unknown84 = input.ReadString(16, true, Encoding.UTF8);
return(instance);
}
public void Deserialize(Stream input)
{
if (input.ReadValueU8() != 0)
{
throw new FormatException("not an xml resource file");
}
var endian = Endian.Little;
this.Unknown1 = input.ReadValueU8();
var stringTableSize = ReadValuePackedU32(input, endian);
var totalNodeCount = ReadValuePackedU32(input, endian);
var totalAttributeCount = ReadValuePackedU32(input, endian);
uint actualNodeCount = 1, actualAttributeCount = 0;
this.Root = new Node();
this.Root.Deserialize(
input, ref actualNodeCount, ref actualAttributeCount, endian);
if (actualNodeCount != totalNodeCount ||
actualAttributeCount != totalAttributeCount)
{
throw new FormatException("count mismatch");
}
var stringTableData = new byte[stringTableSize];
input.Read(stringTableData, 0, stringTableData.Length);
var stringTable = new StringTable();
stringTable.Deserialize(stringTableData);
this.Root.ReadStringTable(stringTable);
}
public void Deserialize(Stream input, short version)
{
input.ReadValueU32(false);
input.ReadValueU64(false);
input.ReadValueU8();
input.ReadValueU32(false);
input.ReadValueU8();
input.ReadValueU32(false);
new U007E2000().Deserialize(input);
new U007E2000().Deserialize(input);
new U007E2000().Deserialize(input);
new U007E4350().Deserialize(input);
new U007E2000().Deserialize(input);
input.ReadValueU32(false);
input.ReadValueU32(false);
input.ReadValueU32(false);
input.ReadValueU32(false);
input.ReadValueU32(true);
input.ReadValueU32(true);
input.ReadValueU64(false);
if (version >= 2)
{
input.ReadValueU8();
}
}
public static int ReadValueEncodedS32(this Stream stream)
{
var op = stream.ReadValueU8();
uint value = (byte)(op & 0x3F);
if ((op & 0x40) != 0)
{
int shift = 6;
byte extra;
do
{
if (shift > 27)
{
throw new InvalidOperationException();
}
extra = stream.ReadValueU8();
value |= (uint)(extra & 0x7F) << shift;
shift += 7;
}while ((extra & 0x80) != 0);
}
if ((op & 0x80) != 0)
{
return(-(int)value);
}
return((int)value);
}
public void Deserialize(ushort version, Stream input, Endian endian)
{
this.Tag = input.ReadStringU32(endian);
this.Unk1 = version >= 3 ? input.ReadValueU8() != 0 : true;
this.Name = input.ReadStringU32(endian);
this.Unk3 = version >= 2 ? input.ReadValueU8() != 0 : false;
if (Name == "/config/ai/battle/eval_shoottarget/shootchain_precombat")
{
Console.Write("st");
}
// Super hacky solution to unpack XMLs with xml:xsi etc.
if (this.Unk3 == false)
{
long currentPositon = input.Position;
try
{
this.Content = XmlResource0.Deserialize(input, endian);
}
catch (Exception ex)
{
input.Position = currentPositon;
Console.WriteLine(ex.Message);
bFailedToDecompile = true;
}
}
else
{
this.Content = XmlResource1.Deserialize(input, endian);
}
}
public static byte[] ReadRLE(this Stream stream, int size, int count, bool encodedLengths)
{
var data = new byte[count * size];
for (int stage = 0; stage < size; stage++)
{
int offset = stage;
int left = count;
while (left > 0)
{
int repeat = stream.ReadValueU8();
if (encodedLengths == true && repeat == 0)
{
repeat = stream.ReadValueU8() << 8;
repeat |= stream.ReadValueU8();
}
left -= repeat;
var value = stream.ReadValueU8();
for (; repeat > 0; offset += size)
{
data[offset] = value;
repeat--;
}
}
}
return(data);
}
private static void ConvertDictionary(Stream input, ValueTag tag, JsonWriter writer)
{
var length = input.ReadPackedValueUInt32();
var basePosition = input.Position;
var endPosition = basePosition + length;
if (endPosition > input.Length)
{
throw new EndOfStreamException();
}
writer.WriteStartObject();
var propertyTag = new ValueTag(input.ReadValueU8());
while (propertyTag.Type != ValueType.Invalid)
{
var propertyName = input.ReadStringZ(Encoding.UTF8);
writer.WritePropertyName(propertyName);
ConvertValue(input, propertyTag, writer);
propertyTag = new ValueTag(input.ReadValueU8());
}
writer.WriteEndObject();
if (input.Position != endPosition)
{
throw new FormatException();
}
}
private static void ConvertArray(Stream input, ValueTag tag, JsonWriter writer)
{
var length = input.ReadPackedValueUInt32();
var basePosition = input.Position;
var endPosition = basePosition + length;
if (endPosition > input.Length)
{
throw new EndOfStreamException();
}
writer.WriteStartArray();
var elementTag = new ValueTag(input.ReadValueU8());
if (elementTag.Type != ValueType.Invalid)
{
do
{
ConvertValue(input, elementTag, writer);
elementTag = new ValueTag(input.ReadValueU8());
}while (elementTag.Type != ValueType.Invalid);
}
writer.WriteEndArray();
if (input.Position != endPosition)
{
throw new FormatException();
}
}
public const uint Signature = 0x6C7A4555; // 'zlEU'
public static BlockReaderStream FromStream(Stream baseStream, Endian endian)
{
var instance = new BlockReaderStream(baseStream);
var magic = baseStream.ReadValueU32(endian);
var alignment = baseStream.ReadValueU32(endian);
var flags = baseStream.ReadValueU8();
if (magic != Signature || /*alignment != 0x4000 ||*/ flags != 4)
{
throw new InvalidOperationException();
}
long virtualOffset = 0;
while (true)
{
uint size = baseStream.ReadValueU32(endian);
bool isCompressed = baseStream.ReadValueU8() != 0;
if (size == 0)
{
break;
}
if (isCompressed == true)
{
var compressedBlockHeader = CompressedBlockHeader.Read(baseStream, endian);
if (compressedBlockHeader.Unknown04 != 32 ||
compressedBlockHeader.Unknown08 != 81920 ||
compressedBlockHeader.Unknown0C != 135200769 ||
compressedBlockHeader.Unknown14 != 0 ||
compressedBlockHeader.Unknown18 != 0 ||
compressedBlockHeader.Unknown1C != 0)
{
throw new InvalidOperationException();
}
if (size - 32 != compressedBlockHeader.CompressedSize)
{
throw new InvalidOperationException();
}
instance.AddCompressedBlock(virtualOffset,
compressedBlockHeader.UncompressedSize,
baseStream.Position,
compressedBlockHeader.CompressedSize);
baseStream.Seek(compressedBlockHeader.CompressedSize, SeekOrigin.Current);
}
else
{
instance.AddUncompressedBlock(virtualOffset, size, baseStream.Position);
baseStream.Seek(size, SeekOrigin.Current);
}
virtualOffset += alignment;
}
return(instance);
}
public void Read(Stream input, Endian endian = Endian.Little)
{
RoadGraphRoadToJunctionEdgeMappingCount = input.ReadValueU16(endian);
RoadGraphEdgeCount = input.ReadValueU16(endian);
for (int i = 0; i < RoadGraphEdgeCount; i++)
{
RoadGraphEdges.Add(new Tuple <ushort, ushort>(input.ReadValueU16(endian), input.ReadValueU16(endian)));
}
ushort roadCount = input.ReadValueU16(endian);
for (int i = 0; i < roadCount; i++)
{
var road = new RoadDefinitionDe();
road.Read(input, endian);
Roads.Add(road);
}
for (int i = 0; i < RoadGraphEdgeCount; i++)
{
var costMapping = new CostMapEntryDe();
costMapping.Read(input, endian);
CostMap.Add(costMapping);
}
byte magic0 = input.ReadValueU8();
byte magic1 = input.ReadValueU8();
byte magic2 = input.ReadValueU8();
byte magic3 = input.ReadValueU8();
if (magic0 != 0x11 && magic1 != 0x11 && magic2 != 0x11 && magic3 != 0)
{
throw new IOException($"Unexpected magic values ({magic0}, {magic1}, {magic2}, {magic3})");
}
ushort splineCount = input.ReadValueU16(endian);
for (int i = 0; i < splineCount; i++)
{
var spline = new RoadSplineDe();
spline.Read(input, endian);
Splines.Add(spline);
}
for (int i = 0; i < roadCount * 2; i++)
{
RoadToCrossroadMapping.Add(input.ReadValueU16(endian));
}
ushort crossroadCount = input.ReadValueU16(endian);
for (int i = 0; i < crossroadCount; i++)
{
var crossroad = new CrossroadDe();
crossroad.Read(input, endian);
Crossroads.Add(crossroad);
}
}
private static object DeserializeNodeEntryInternal(NodeEntry previousNode, Stream input)
{
var node = new NodeEntry()
{
Name = "undefined",
};
byte[] unkBytes = new byte[6];
input.Read(unkBytes, 0, unkBytes.Length);
byte[] stringArr = new byte[255];
bool read = true;
char index = (char)0;
while (read)
{
byte[] reader = new byte[1];
input.Read(reader, 0, 1);
read = reader[0] != 0;
stringArr[index] = reader[0];
if (index == 0 && !read)
{
read = true;
}
if (index == 1 && !read)
{
break;
}
index++;
}
var name = Encoding.ASCII.GetString(stringArr);
name = name.Trim('\0');
name = name.Replace("\0", "");
node.Name = name;
var nodeType = input.ReadValueU8();
var subNotes = input.ReadValueU8();
if (nodeType == 4)
{
DeserializeNodeEntryInternal(node, input);
}
double num;
if (double.TryParse(name, out num) || name.Contains(":"))
{
previousNode.Value = new DataValue(DataType.String, name);
}
else
{
children.Add(node);
}
return(node);
}
public void Read(Stream input, Endian endian = Endian.Little)
{
From = input.ReadValueF32(endian);
Distance = input.ReadValueF32(endian);
_rangeFlagType = (RangeFlagType)input.ReadValueU8();
Unkn3 = input.ReadValueU8();
Unkn5 = input.ReadValueF32(endian);
_indexAndUnkn4 = input.ReadValueU16(endian);
}
public void Deserialize(Stream input, Endian endian)
{
this.DataOffset = input.ReadValueU32(endian);
this.Unknown04 = input.ReadValueU32(endian);
if (this.Unknown04 != 0)
{
throw new FormatException();
}
this.Width = input.ReadValueU16(endian);
this.Height = input.ReadValueU16(endian);
var format = input.ReadValueU16(endian);
if (Enum.IsDefined(typeof(PixelFormat), format) == false)
{
throw new FormatException("unknown pixel format");
}
this.Format = (PixelFormat)format;
this.Unknown0E = input.ReadValueU16(endian);
this.Unknown10 = input.ReadValueU16(endian);
this.Unknown12 = input.ReadValueU16(endian);
this.FrameCount = input.ReadValueU16(endian);
this.Flags = (TextureFlags)input.ReadValueU16(endian);
// name pointer
// unknown runtime value
for (int offset = 0x18; offset <= 0x1C; offset += 0x04)
{
var runtime = input.ReadValueU32(endian);
if (runtime != 0)
{
throw new FormatException("non-zero runtime values");
}
}
this.Unknown20 = input.ReadValueU16();
this.Delay = input.ReadValueU8(); // seems to be related to FrameCount - timing related?
this.Levels = input.ReadValueU8(); // refer to MSDN on IDirect3DDevice9::CreateTexture
this.DataSize = input.ReadValueU32(endian);
if (this.Unknown20 != 0)
{
throw new InvalidOperationException();
}
for (int offset = 0x28; offset <= 0x44; offset += 0x04)
{
var runtime = input.ReadValueU32(endian);
if (runtime != 0)
{
throw new FormatException("non-zero runtime values");
}
}
}
public void Deserialize(Stream input, Endian endian, StringTable strings)
{
this.Name = strings.ReadString(input, endian);
this.Type = strings.ReadString(input, endian);
var childCount = input.ReadValueU16(endian);
var unknown08 = input.ReadValueU8();
var baselineOffset = input.ReadValueU32(endian);
var overrideCount = input.ReadValueU8();
if (overrideCount > 0)
{
var infos = new List <KeyValuePair <string, uint> >();
for (byte i = 0; i < overrideCount; i++)
{
var name = strings.ReadString(input, endian);
var offset = input.ReadValueU32(endian);
infos.Add(new KeyValuePair <string, uint>(
name, offset));
}
foreach (var info in infos)
{
if (input.Position != info.Value)
{
throw new FormatException();
}
if (this.Overrides.ContainsKey(info.Key) == true)
{
throw new FormatException();
}
var OVERRIDE = new PropertyList();
OVERRIDE.Deserialize(input, endian, strings);
this.Overrides.Add(info.Key, OVERRIDE);
}
}
if (baselineOffset != input.Position)
{
throw new FormatException();
}
this.Baseline = new PropertyList();
this.Baseline.Deserialize(input, endian, strings);
for (ushort i = 0; i < childCount; i++)
{
var element = new Object();
element.Deserialize(input, endian, strings);
this.Children.Add(element);
}
}
public static UnitAssignedSkill Read(Stream input, Endian endian)
{
UnitAssignedSkill instance;
instance.Id = input.ReadValueU16(endian);
instance.Rank = input.ReadValueU8();
instance.Unknown = input.ReadValueU8();
instance.Experience = input.ReadValueU16(endian);
return(instance);
}
public void Deserialize(Stream input, Endian endian)
{
this.Name = input.ReadStringU16(0x40, Encoding.ASCII, endian);
this.Type = input.ReadValueU8();
this.Allocator = input.ReadValueU8();
this.Unknown3 = input.ReadValueU8();
this.Unknown4 = input.ReadValueU8();
this.HeaderSize = input.ReadValueS32(endian);
this.DataSize = input.ReadValueS32(endian);
}
public void Deserialize(Stream input, Endian endian)
{
this.Name = input.ReadStringU16(0x40, Encoding.ASCII, endian);
this.Type = input.ReadValueU8();
this.Allocator = input.ReadValueU8();
this.Flags = (PrimitiveFlags)input.ReadValueU8();
this.SplitIndex = input.ReadValueU8();
this.CPUSize = input.ReadValueS32(endian);
this.GPUSize = input.ReadValueS32(endian);
this.Unknown7 = input.ReadValueU8();
}
public void Read(Stream input, Endian endian = Endian.Little)
{
FromRoadGraphEdgeIndex = input.ReadValueU16(endian);
FromLaneIndex = input.ReadValueU8();
ToRoadGraphEdgeIndex = input.ReadValueU16(endian);
ToLaneIndex = input.ReadValueU8();
Unkn4 = input.ReadValueU8();
Unkn6 = input.ReadValueU8();
Unkn8 = input.ReadValueU16(endian);
Spline.Read(input, endian);
}
public void Deserialize(Stream input)
{
int count = input.ReadValueS32(false);
for (int i = 0; i < count; i++)
{
input.ReadValueU8();
input.ReadValueU8();
input.ReadValueU64(false);
new U00821D60().Deserialize(input);
}
}
public void Deserialize(ushort version, Stream input, Endian endian)
{
this.NameHash = input.ReadValueU64(endian);
this.Name = input.ReadStringU16(endian);
if (version >= 2)
{
input.ReadBytes(18);
}
var columnCount = input.ReadValueU16(endian);
Unk1 = input.ReadValueU32(endian);
Unk2 = input.ReadValueU32(endian);
var rowSize = input.ReadValueU32(endian);
var rowCount = input.ReadValueU32(endian);
var data = input.ReadToMemoryStream((int)(rowSize * rowCount));
Data = data.ReadBytes((int)data.Length);
this.Columns = new List <Column>();
for (uint i = 0; i < columnCount; i++)
{
this.Columns.Add(new Column()
{
NameHash = input.ReadValueU32(endian),
Type = (ColumnType)input.ReadValueU8(),
Unknown2 = input.ReadValueU8(),
Unknown3 = input.ReadValueU16(endian),
});
}
this.Rows.Clear();
for (uint i = 0; i < rowCount; i++)
{
var row = new Row();
data.Seek(i * rowSize, SeekOrigin.Begin);
foreach (var column in this.Columns)
{
if ((byte)column.Type > 163)
{
throw new FormatException();
}
object DeserializedObject = column.DeserializeType(data, endian);
row.Values.Add(DeserializedObject);
}
this.Rows.Add(row);
}
}
public void Read(Stream input, Endian endian = Endian.Little)
{
Width = input.ReadValueF32(endian);
_laneTypeAndFlags = input.ReadValueU8();
byte someZero = input.ReadValueU8();
if (someZero != 0)
{
throw new IOException($"Unexpected non-zero someZero value {someZero}");
}
CenterOffset = input.ReadValueU16(endian);
_rangeFlags.Read(input, endian);
}
public void Deserialize(ushort version, Stream input, Endian endian)
{
this.NameHash = input.ReadValueU64(endian);
this.Unknown8 = input.ReadValueU8();
this.Unknown9 = version == 2 ? input.ReadValueU8() : (byte)0;
if (this.Unknown9 != 0 && this.Unknown9 != 1)
{
throw new InvalidOperationException();
}
this.Data = input.ReadBytes((uint)(input.Length - input.Position));
}
public void Deserialize(ushort version, Stream input, Endian endian)
{
this.NameHash = input.ReadValueU64(endian);
this.Unknown8 = input.ReadValueU8();
if (version == 2)
{
this.HasMIP = input.ReadValueU8();
}
this.Data = input.ReadBytes((int)(input.Length - input.Position));
Log.WriteLine("Unpacking: " + ToString());
}
public void Deserialize(Stream input, short version)
{
input.ReadValueU32(false);
input.ReadValueU32(false);
input.ReadStringASCIIZ();
input.ReadValueU32(false);
input.ReadValueU8();
input.ReadValueU32(false);
new U007E6A30().Deserialize(input);
new U007E2000().Deserialize(input);
input.ReadValueU32(false);
new U007E2000().Deserialize(input);
new U007E2000().Deserialize(input);
new U007E2000().Deserialize(input);
input.ReadValueU32(false);
input.ReadValueU32(false);
input.ReadValueU32(false);
input.ReadValueU32(false);
input.ReadValueU32(false);
input.ReadValueU32(false);
new U007E4350().Deserialize(input);
input.ReadValueU32(true);
input.ReadValueU32(true);
input.ReadValueU32(true);
new U007E2000().Deserialize(input);
input.ReadValueU32(false);
new U007E9D10().Deserialize(input);
input.ReadValueU64(false);
input.ReadValueU64(false);
input.ReadValueU64(false);
input.ReadValueU32(true);
input.ReadValueU32(true);
new U007E6910().Deserialize(input);
input.ReadValueU8();
input.ReadValueU32(false);
}
public static DefinitionHeader Read(Stream input, Endian endian)
{
DefinitionHeader instance;
instance.NameIndex = input.ReadValueU32(endian);
instance.ParentIndex = input.ReadValueU32(endian);
instance.DataOffset = input.ReadValueU32(endian);
instance.DataSize = input.ReadValueU32(endian);
instance.Type = (DefinitionType)input.ReadValueU8();
instance.Unknown11 = input.ReadValueU8();
instance.Unknown12 = input.ReadValueU8();
instance.Unknown13 = input.ReadValueU8();
return(instance);
}
public void Deserialize(ushort version, Stream input, Endian endian)
{
this.NameHash = input.ReadValueU64(endian);
this.Unknown8 = input.ReadValueU8();
this.HasMIP = input.ReadValueU8();
//if (this.HasMIP != 0 && this.HasMIP != 1)
//{
// throw new InvalidOperationException();
//}
this.Data = input.ReadBytes((int)(input.Length - input.Position));
Log.WriteLine("Unpacking: " + ToString());
}
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(Stream input)
{
var magic = input.ReadValueU32(Endian.Little);
if (magic != 0x434F4E44 && // COND
magic.Swap() != 0x434F4E44)
{
throw new FormatException();
}
var endian = magic == 0x434F4E44 ? Endian.Little : Endian.Big;
var version = input.ReadValueU32(endian);
if (version != 1)
{
throw new FormatException();
}
this.Version = version;
var unknown08 = input.ReadValueU16(endian);
var count = input.ReadValueU16(endian);
var ids = new int[count];
var offsets = new uint[count];
for (ushort i = 0; i < count; i++)
{
ids[i] = input.ReadValueS32(endian);
offsets[i] = input.ReadValueU32(endian);
}
for (ushort i = 0; i < count; i++)
{
var id = ids[i];
var offset = offsets[i];
input.Seek(offset, SeekOrigin.Begin);
var flags = input.ReadValueU8();
var valueType = (Conditionals.ValueType)((flags & 0x0F) >> 0);
var opType = (Conditionals.OpType)((flags & 0xF0) >> 4);
if (valueType == Conditionals.ValueType.Bool)
{
switch (opType)
{
default:
{
throw new NotSupportedException();
}
}
}
}
//throw new NotImplementedException();
this.Endian = endian;
}
public static object Deserialize(Stream input, FieldType type, bool littleEndian)
{
switch (type)
{
case FieldType.UInt8: return input.ReadValueU8();
case FieldType.Int8: return input.ReadValueS8();
case FieldType.UInt16: return input.ReadValueU16(littleEndian);
case FieldType.Int16: return input.ReadValueS16(littleEndian);
case FieldType.UInt32: return input.ReadValueU32(littleEndian);
case FieldType.Int32: return input.ReadValueS32(littleEndian);
case FieldType.UInt64: return input.ReadValueU64(littleEndian);
case FieldType.Int64: return input.ReadValueS64(littleEndian);
case FieldType.Single: return input.ReadValueF32(littleEndian);
case FieldType.Double: return input.ReadValueF64(littleEndian);
case FieldType.Vector3:
{
var value = new Builtins.Vector3();
value.Deserialize(input, littleEndian);
return value;
}
case FieldType.Vector4:
{
var value = new Builtins.Vector4();
value.Deserialize(input, littleEndian);
return value;
}
case FieldType.Quaternion:
{
var value = new Builtins.Quaternion();
value.Deserialize(input, littleEndian);
return value;
}
case FieldType.String:
{
throw new NotSupportedException("cannot deserialize strings via Builtin");
}
case FieldType.Color:
{
var value = new Builtins.Color();
value.Deserialize(input, littleEndian);
return value;
}
case FieldType.Matrix4x4:
{
var value = new Builtins.Matrix4x4();
value.Deserialize(input, littleEndian);
return value;
}
}
throw new NotSupportedException("unsupported builtin type");
}
private void ReadBytecode(Stream input, FunctionDefinition funcDef)
{
funcDef.Instructions = new List<IInstruction>();
funcDef.InstructionOffsets = new List<int>();
var unencodedByteCodeLength = input.ReadValueEncodedS32();
int read;
for (read = 0; read < unencodedByteCodeLength;)
{
funcDef.InstructionOffsets.Add(read);
var op = input.ReadValueU8();
var opcode = (Script.Opcode) op;
read++;
Script.IInstruction instruction = null;
switch (opcode)
{
case Script.Opcode.OP_Target:
{
instruction = new Target();
break;
}
case Script.Opcode.OP_ShortConst:
{
instruction = new ShortConst();
break;
}
case Script.Opcode.OP_IntConst:
{
instruction = new IntConst();
break;
}
case Script.Opcode.OP_FloatConst:
{
instruction = new FloatConst();
break;
}
case Script.Opcode.OP_StringConst:
{
instruction = new StringConst(this);
break;
}
case Script.Opcode.OP_VirtualFunc:
{
instruction = new VirtualFunc(this);
break;
}
case Script.Opcode.OP_Context:
case Script.Opcode.OP_SwitchLabel:
{
instruction = new U16U16(opcode);
break;
}
case Script.Opcode.OP_Assign:
case Script.Opcode.OP_JumpIfFalse:
case Script.Opcode.OP_Jump:
case Script.Opcode.OP_Skip:
{
instruction = new U16(opcode);
break;
}
case Script.Opcode.OP_LocalVar:
case Script.Opcode.OP_ObjectVar:
case Script.Opcode.OP_ParamVar:
case Script.Opcode.OP_StructMember:
{
instruction = new TypeMember(opcode, this);
break;
}
case Script.Opcode.OP_Switch:
{
instruction = new Switch();
break;
}
case Script.Opcode.OP_Constructor:
{
instruction = new Constructor(this);
break;
}
case Script.Opcode.OP_TestEqual:
case Script.Opcode.OP_EnumToInt:
case Script.Opcode.OP_ArrayPushBack:
case Script.Opcode.OP_ArraySize:
case Script.Opcode.OP_ArrayElement:
case Script.Opcode.OP_New:
case Script.Opcode.OP_ArrayClear:
case Script.Opcode.OP_DynamicCast:
case Script.Opcode.OP_ArrayContainsFast:
case Script.Opcode.OP_ArrayRemoveFast:
case Script.Opcode.OP_TestNotEqual:
case Script.Opcode.OP_ArrayErase:
case Script.Opcode.OP_EnumToString:
case Script.Opcode.OP_ArrayContains:
case Script.Opcode.OP_ArrayResize:
case Script.Opcode.OP_ArrayInsert:
case Script.Opcode.OP_ArrayGrow:
case Script.Opcode.OP_ArrayFindFirstFast:
case Script.Opcode.OP_ArrayLast:
case Script.Opcode.OP_ArrayRemove:
case Script.Opcode.OP_SaveValue:
{
instruction = new TypeRef(opcode, this);
break;
}
case Script.Opcode.OP_NameConst:
{
instruction = new NameConst(Strings);
break;
}
case Script.Opcode.OP_FinalFunc:
{
instruction = new FinalFunc(this);
break;
}
case Script.Opcode.OP_EntryFunc:
case Script.Opcode.OP_SavePoint:
{
instruction = new U16S32(opcode, this);
break;
}
case Script.Opcode.OP_Nop:
case Script.Opcode.OP_ParamEnd:
case Script.Opcode.OP_IntZero:
case Script.Opcode.OP_IntOne:
case Script.Opcode.OP_BoolFalse:
case Script.Opcode.OP_BoolTrue:
case Script.Opcode.OP_Return:
case Script.Opcode.OP_GetServer:
case Script.Opcode.OP_GetCamera:
case Script.Opcode.OP_NameToString:
case Script.Opcode.OP_GetPlayer:
case Script.Opcode.OP_IntToFloat:
case Script.Opcode.OP_This:
case Script.Opcode.OP_Null:
case Script.Opcode.OP_GetGame:
case Script.Opcode.OP_ObjectToBool:
case Script.Opcode.OP_IntToString:
case Script.Opcode.OP_FloatToString:
case Script.Opcode.OP_IntToByte:
case Script.Opcode.OP_ObjectToString:
case Script.Opcode.OP_SwitchDefault:
case Script.Opcode.OP_BoolToString:
case Script.Opcode.OP_GetHud:
case Script.Opcode.OP_FloatToInt:
case Script.Opcode.OP_NameToBool:
case Script.Opcode.OP_Parent:
case Script.Opcode.OP_IntToBool:
case Script.Opcode.OP_ByteToInt:
case Script.Opcode.OP_FloatToBool:
case Script.Opcode.OP_ByteToFloat:
case Script.Opcode.OP_StringToBool:
case Script.Opcode.OP_SavePointEnd:
case Script.Opcode.OP_StringToInt:
case Script.Opcode.OP_GetSound:
{
instruction = new Simple(opcode);
break;
}
default:
{
throw new NotImplementedException("unhandled " + opcode.ToString());
}
}
read += instruction.Deserialize(input);
funcDef.Instructions.Add(instruction);
}
if (read != unencodedByteCodeLength)
{
throw new InvalidOperationException();
}
}
public void Deserialize(Stream input)
{
this.Instructions.Clear();
var basePosition = input.Position;
if (input.ReadString(8, Encoding.ASCII) != "NCS V1.0")
{
throw new FormatException();
}
else if (input.ReadValueU8() != 0x42)
{
throw new FormatException();
}
var size = input.ReadValueU32(false);
if (basePosition + size > input.Length)
{
throw new InvalidOperationException();
}
var code = new byte[size - 13];
if (input.Read(code, 0, code.Length) != code.Length)
{
throw new FormatException();
}
var count = CountInstructions(code);
var offsets = new int[count];
int offset;
offset = 0;
for (int i = 0; offset >= 0 && offset < code.Length; i++)
{
offsets[i] = offset;
offset += GetInstructionSize(code, offset);
}
if (offset != code.Length)
{
throw new InvalidOperationException();
}
var state = new State(offsets);
offset = 0;
var instructions = new List<Script.IInstruction>();
for (int i = 0; offset >= 0 && offset < code.Length; i++)
{
if (code[offset + 0] > 58)
{
throw new InvalidOperationException("invalid opcode");
}
var op = (Script.Opcode)code[offset + 0];
var type = (Script.OperandType)code[offset + 1];
var instruction = Script.OpcodeHandlerCache
.CreateInstruction(op);
instruction.Decode(code, ref offset, type, state);
instructions.Add(instruction);
}
this.Instructions.AddRange(instructions);
}
public void Deserialize(Stream input, Endian endianness)
{
this.DataSize = input.ReadValueU32(endianness);
var type = input.ReadValueU8();
if (ValidSectionTypes.ContainsKey(type) == false)
{
throw new FormatException("unknown section type");
}
this.Type = (SectionType)type;
this.Unknown05 = input.ReadValueU8();
this.Unknown06 = input.ReadValueU16(endianness);
this.Flags = input.ReadValueU32(endianness);
this.Id = input.ReadValueU32(endianness);
this.Unknown10 = input.ReadValueU32(endianness);
}
public void Deserialize(Stream input)
{
var magic = input.ReadValueU32(Endian.Little);
if (magic != 0x53464152 && // SFAR
magic.Swap() != 0x53464152)
{
throw new FormatException();
}
var endian = magic == 0x53464152 ? Endian.Little : Endian.Big;
var version = input.ReadValueU32(endian);
if (version != 0x00010000)
{
throw new FormatException();
}
var dataOffset = input.ReadValueU32(endian);
var fileTableOffset = input.ReadValueU32(endian);
var fileTableCount = input.ReadValueU32(endian);
var blockSizeTableOffset = input.ReadValueU32(endian);
this.MaximumBlockSize = input.ReadValueU32(endian);
this.CompressionScheme = input
.ReadValueEnum<SFXArchive.CompressionScheme>(endian);
if (fileTableOffset != 0x20)
{
throw new FormatException();
}
if (this.MaximumBlockSize != 0x010000)
{
throw new FormatException();
}
/*
if (this.CompressionScheme != SFXArchive.CompressionScheme.None &&
this.CompressionScheme != SFXArchive.CompressionScheme.LZMA &&
this.CompressionScheme != SFXArchive.CompressionScheme.LZX)
{
throw new FormatException();
}
*/
input.Seek(blockSizeTableOffset, SeekOrigin.Begin);
var blockSizeTableSize = dataOffset - fileTableOffset;
var blockSizeTableCount = blockSizeTableSize / 2;
this.BlockSizes.Clear();
for (uint i = 0; i < blockSizeTableCount; i++)
{
this.BlockSizes.Add(input.ReadValueU16(endian));
}
input.Seek(fileTableOffset, SeekOrigin.Begin);
for (uint i = 0; i < fileTableCount; i++)
{
// ReSharper disable UseObjectOrCollectionInitializer
var entry = new SFXArchive.Entry();
// ReSharper restore UseObjectOrCollectionInitializer
entry.NameHash = input.ReadFileNameHash();
entry.BlockSizeIndex = input.ReadValueS32(endian);
entry.UncompressedSize = input.ReadValueU32(endian);
entry.UncompressedSize |= ((long)input.ReadValueU8()) << 32;
entry.Offset = input.ReadValueU32(endian);
entry.Offset |= ((long)input.ReadValueU8()) << 32;
this.Entries.Add(entry);
}
}
public void Deserialize(Stream input)
{
var magic = input.ReadValueU32(Endian.Little);
if (magic != 0x53464152 && // SFAR
magic.Swap() != 0x53464152)
{
throw new FormatException();
}
var endian = magic == 0x53464152 ? Endian.Little : Endian.Big;
var version = input.ReadValueU32(endian);
if (version != 0x00010000)
{
throw new FormatException();
}
var dataOffset = input.ReadValueU32(endian);
bool firstDataOffset = true;
uint minDataOffset = dataOffset;
//Console.WriteLine("Data Offset: {0:X8}",dataOffset);
var fileTableOffset = input.ReadValueU32(endian);
//Console.WriteLine("File Table Offset: {0:X8}",fileTableOffset);
var fileTableCount = input.ReadValueU32(endian);
//Console.WriteLine("File Table Count: {0:X8}",fileTableCount);
var blockSizeTableOffset = input.ReadValueU32(endian);
//Console.WriteLine("Block Size Table Offset: {0:X8}",blockSizeTableOffset);
this.MaximumBlockSize = input.ReadValueU32(endian);
this.CompressionScheme = input
.ReadValueEnum<SFXArchive.CompressionScheme>(endian);
if (fileTableOffset != 0x20)
{
throw new FormatException();
}
if (this.MaximumBlockSize != 0x010000)
{
throw new FormatException();
}
/*
if (this.CompressionScheme != SFXArchive.CompressionScheme.None &&
this.CompressionScheme != SFXArchive.CompressionScheme.LZMA &&
this.CompressionScheme != SFXArchive.CompressionScheme.LZX)
{
throw new FormatException();
}
*/
input.Seek(fileTableOffset, SeekOrigin.Begin);
for (uint i = 0; i < fileTableCount; i++)
{
// ReSharper disable UseObjectOrCollectionInitializer
var entry = new SFXArchive.Entry();
entry.entryOffset = input.Position;
// ReSharper restore UseObjectOrCollectionInitializer
entry.nameHash = input.ReadFileNameHash();
//Console.WriteLine("FileNameHash: {0}",entry.NameHash.ToString());
entry.blockSizeIndex = input.ReadValueS32(endian);
//Console.WriteLine("Begin position: {0:X8}",input.Position);
entry.uncompressedSize = input.ReadValueU32(endian);
entry.uncompressedSize |= ((long)input.ReadValueU8()) << 32;
//Console.WriteLine(" End position: {0:X8}",input.Position);
entry.dataOffset = input.ReadValueU32(endian);
entry.dataOffset |= ((long)input.ReadValueU8()) << 32;
if(firstDataOffset)
{
minDataOffset = (uint)entry.dataOffset;
firstDataOffset = false;
}
else
{
if(minDataOffset > entry.dataOffset)
minDataOffset = (uint)entry.dataOffset;
}
//if(entry.NameHash.Equals (fileNameListNameHash))Console.WriteLine("Offset: {0:X10}, UncSize {1:X10}",entry.Offset,entry.UncompressedSize);
this.Entries.Add(entry);
}
if(minDataOffset > dataOffset)
dataOffset = minDataOffset;
input.Seek(blockSizeTableOffset, SeekOrigin.Begin);
var blockSizeTableSize = dataOffset - blockSizeTableOffset;
var blockSizeTableCount = blockSizeTableSize / 2;
//ushort aux;
//Console.WriteLine("dataOffset: {0:X8}\nfileTableOffset: {1:X8}\nBlockSizeTableSize: {2:X8}\nblockSizeTableOffset: {3:X8}", dataOffset,fileTableOffset,blockSizeTableSize,blockSizeTableOffset);
this.BlockSizes.Clear();
//Console.WriteLine("initial position: {0:X8}",input.Position);
//Console.WriteLine("blockSizeTableCount: {0}",blockSizeTableCount);
for (uint i = 0; i < blockSizeTableCount; i++)
{
this.BlockSizes.Add(input.ReadValueU16(endian));
}
//Console.WriteLine("final position: {0:X8}",input.Position);
//Console.WriteLine("number of repetitions: {0}",blockSizeTableCount);
//var fileNameListNameHash = new FileNameHash(
// new byte[] { 0xB5, 0x50, 0x19, 0xCB, 0xF9, 0xD3, 0xDA, 0x65, 0xD5, 0x5B, 0x32, 0x1C, 0x00, 0x19, 0x69, 0x7C, });
}
public void Deserialize(Stream input)
{
if (input.ReadValueU32() != 0x39444350)
{
throw new FormatException();
}
this.Format = input.ReadValueEnum<PCD9.Format>();
var dataSize = input.ReadValueU32();
this.Unknown0C = input.ReadValueU32();
this.Width = input.ReadValueU16();
this.Height = input.ReadValueU16();
this.BPP = input.ReadValueU8();
var mipMapCount = 1 + input.ReadValueU8();
this.Unknown16 = input.ReadValueU16();
if ((this.Unknown16 & 0x8000) != 0)
{
throw new NotSupportedException();
this.unknownFlag = true;
}
this.Mipmaps.Clear();
using (var data = input.ReadToMemoryStream(dataSize))
{
var mipWidth = this.Width;
var mipHeight = this.Height;
for (int i = 0; i < mipMapCount; i++)
{
if (mipWidth == 0)
{
mipWidth = 1;
}
if (mipHeight == 0)
{
mipHeight = 1;
}
int size;
switch (this.Format)
{
case PCD9.Format.A8R8G8B8:
{
size = mipWidth * mipHeight * 4;
break;
}
case PCD9.Format.DXT1:
case PCD9.Format.DXT3:
case PCD9.Format.DXT5:
{
int blockCount = ((mipWidth + 3) / 4) * ((mipHeight + 3) / 4);
int blockSize = this.Format == PCD9.Format.DXT1 ? 8 : 16;
size = blockCount * blockSize;
break;
}
default:
{
throw new NotSupportedException();
}
}
var buffer = new byte[size];
if (data.Read(buffer, 0, buffer.Length) != buffer.Length)
{
throw new EndOfStreamException();
}
this.Mipmaps.Add(new PCD9.Mipmap()
{
Width = mipWidth,
Height = mipHeight,
Data = buffer,
});
mipWidth >>= 1;
mipHeight >>= 1;
}
if (data.Position != data.Length)
{
throw new InvalidOperationException();
}
}
}
