internal void Read(BinaryReader reader)
{
reader.BaseStream.Position = Offset + 12;
Unknowns.ReadInt32s(reader, 1);
Unknowns.ReadInt16s(reader, 2);
Unknowns.ReadInt32s(reader, 1);
if (Format != null)
{
int length = DataLength;
if (Format.Header != null)
{
Header = new MissionTableHeader(this, Format.Header, reader);
length -= Format.Header.Size;
}
if (length % Format.Row.Size != 0)
{
throw new InvalidDataException();
}
int count = length / Format.Row.Size;
for (int index = 0; index < count; index++)
{
new MissionRow(this, Format.Row, reader);
}
}
}
internal Point(Table table, int index, AssetLoader loader)
: base(table, index)
{
BinaryReader reader = loader.Reader;
long start = reader.BaseStream.Position;
loader.Expect(HeaderLength);
loader.ExpectZeroes(4, 1); // Probably type, always zero.
loader.Expect(index); // Zero-based index of the row with this type.
Subtype = reader.ReadInt32();
Position = new Vector3f(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
Rotation = Angle3.Degrees(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
int unknown1Offset = reader.ReadInt32(); // Offset to Unknown1 from start of row.
int unknown2Offset = reader.ReadInt32(); // Offset to Unknown2 from start of row (Unknown1Offset + 4).
int unknown3Offset = reader.ReadInt32(); // Offset to Unknown3 from start of row, or 0 if none (Unknown2Offset + 4).
int unknown4Offset = reader.ReadInt32(); // Offset to Unknown3 from start of row (Unknown2Offset + 4 or Unknown3Offset + 12).
loader.ExpectZeroes(4, 1);
Name = reader.ReadStringz(EncodingShiftJis);
reader.BaseStream.Position = start + unknown1Offset;
loader.ExpectZeroes(4, 2); // Unknown1 and Unknown2
if (unknown3Offset != 0)
{
Unknowns.ReadSingles(reader, 3);
}
Unknowns.ReadInt32s(reader, 1); // -1 or values like 1002000 for events.
var errors = loader.Errors;
}
internal MessageItem(Message message, int index, AssetLoader loader)
: base(loader)
{
BinaryReader reader = loader.Reader;
Message = message;
Index = index;
switch (message.MajorVersion)
{
case 3:
Noun = reader.ReadByte();
Verb = reader.ReadByte();
Condition = reader.ReadByte();
Sequence = reader.ReadByte();
Talker = reader.ReadByte();
Offset = reader.ReadUInt16();
Unknowns.ReadBytes(reader, 3);
break;
case 4:
case 5:
Noun = reader.ReadByte();
Verb = reader.ReadByte();
Condition = reader.ReadByte();
Sequence = reader.ReadByte();
Talker = reader.ReadByte();
Offset = reader.ReadUInt16();
Unknowns.ReadBytes(reader, 4);
break;
default:
throw new NotImplementedException();
}
}
internal TextureArchiveRecord(TextureArchive archive, BinaryReader reader, ByteOrder order)
: base(archive, "")
{
Offset = reader.ReadInt32(order);
Size = reader.ReadInt32(order);
if (Archive.Platform == DSPlatform.PS3)
{
int format = reader.ReadInt16(order);
Id = reader.ReadInt16(order);
Ps3Dimensions = new Vector2i(reader.ReadUInt16(order), reader.ReadUInt16(order));
switch (format)
{
case 0: Ps3Format = Glare.Graphics.Formats.DXT1; break;
case 0x0500: Ps3Format = Glare.Graphics.Formats.DXT5; break;
case 0x0900: Ps3Format = Glare.Graphics.Formats.Vector4nb; break;
default: throw new NotSupportedException(string.Format("PS3 format 0x{0:X4} (dimensions {1}, data size {2}) is not known.", format, Ps3Dimensions, Size));
}
Unknowns.ReadInt32s(reader, 1);
reader.RequireZeroes(4);
}
else
{
Id = reader.ReadInt32(order);
}
Name = reader.ReadStringzAtUInt32(order, Alexandria.Engines.DarkSouls.Archive.ShiftJis);
reader.RequireZeroes(4);
}
internal Message(AssetLoader loader)
: base(loader)
{
using (BinaryReader reader = loader.Reader) {
Version = (MessageVersion)reader.ReadInt32();
int fileLength, addonOffset = -1;
int count;
Codex <MessageItem> items = new Codex <MessageItem>();
Items = items;
switch (MajorVersion)
{
case 3:
fileLength = reader.ReadUInt16() + 6;
count = reader.ReadUInt16();
break;
case 4:
addonOffset = reader.ReadUInt16() + 6;
Unknowns.ReadInt16s(reader, 1);
count = reader.ReadUInt16();
break;
case 5:
addonOffset = reader.ReadInt32() + 6;
count = reader.ReadUInt16();
break;
default:
throw new NotImplementedException("Unimplemented version " + Version);
}
for (int index = 0; index < count; index++)
{
MessageItem item = new MessageItem(this, index, loader);
items.Add(item);
AddChild(item);
}
foreach (MessageItem item in items)
{
item.ReadText(reader);
}
if (addonOffset >= 0)
{
reader.BaseStream.Position = addonOffset;
foreach (MessageItem item in items)
{
item.ReadAddOn(reader);
}
}
}
}
internal BiffArchiveRecord(BiffArchive archive, int index, AssetLoader loader)
: base(archive, index)
{
BinaryReader reader = loader.Reader;
Id = reader.ReadInt32();
Offset = reader.ReadUInt32();
Size = reader.ReadInt32();
Type = (BiffArchiveRecordType)reader.ReadUInt16();
Unknowns.ReadInt16s(reader, 1);
}
internal Picture(AssetLoader loader)
: base(loader)
{
BinaryReader reader = loader.Reader;
ushort check = reader.ReadUInt16();
Codex <PictureInstruction> instructions = new Codex <PictureInstruction>();
Codex <PictureCel> cels = new Codex <PictureCel>();
if (check == 0x0E) // VGA picture
{
int celCount = reader.ReadUInt16();
Unknowns.ReadInt16s(reader, 1); // 0x2A
int paletteOffset = reader.ReadInt32();
Dimensions = new Vector2i(reader.ReadUInt16(), reader.ReadUInt16());
reader.BaseStream.Position = paletteOffset;
Palette = new Palette(loader);
AddChild(Palette);
for (int celIndex = 0; celIndex < celCount; celIndex++)
{
PictureCel cel = new PictureCel(this, celIndex, loader);
cels.Add(cel);
AddChild(cel);
instructions.Add(new PictureInstruction.DrawCel(cel));
}
}
else
{
Dimensions = new Vector2i(320, 190);
reader.BaseStream.Seek(-2, SeekOrigin.Current);
byte[] data = reader.ReadBytes(checked ((int)reader.BaseStream.Length));
Stream stream = new MemoryStream(data, false);
PicturePatternFlags patternFlags = PicturePatternFlags.None;
byte patternNumber = 0;
while (true)
{
PictureInstruction instruction = PictureInstruction.ReadInstruction(stream, ref patternFlags, ref patternNumber);
instructions.Add(instruction);
if (instruction.IsQuit)
{
break;
}
}
}
Cels = cels;
Instructions = instructions;
}
internal Model(Table table, int index, AssetLoader loader)
: base(table, index)
{
BinaryReader reader = loader.Reader;
loader.Expect(HeaderLength);
Type = (ModelType)reader.ReadInt32();
Index = reader.ReadInt32();
int contentSize = reader.ReadInt32(); // Size from start to end of Name
Unknowns.ReadInt32s(reader, 1);
loader.ExpectZeroes(4, 3);
Name = reader.ReadStringz(EncodingShiftJis);
Path = reader.ReadStringz(EncodingShiftJis);
}
internal ParameterDefinition(AssetLoader loader)
: base(loader)
{
var reader = loader.Reader;
loader.Expect(loader.CheckedShortLength);
loader.Expect((ushort)0x30); // Offset of rows
Unknowns.ReadInt16s(reader, 1); // 1-4
int rowCount = reader.ReadUInt16();
loader.Expect((ushort)0xB0); // Size in bytes of a row
Name = reader.ReadStringz(32, EncodingShiftJis);
loader.Expect((ushort)0);
loader.Expect((ushort)0x68);
for (int index = 0; index < rowCount; index++)
{
new ParameterDefinitionRow(this, index, loader);
}
}
internal ParameterTable(AssetLoader loader)
: base(loader)
{
var reader = loader.Reader;
int stringsOffset = reader.ReadInt32();
int firstRowDataOffset = reader.ReadUInt16();
Unknowns.ReadInt16s(reader, 2);
int rowCount = reader.ReadUInt16();
Name = reader.ReadStringz(0x20, Encoding.ASCII);
Unknowns.ReadInt32s(reader, 1);
// Read in the row headers.
RowInfo[] rows = new RowInfo[rowCount];
for (int index = 0; index < rowCount; index++)
{
rows[index].Read(reader);
}
// Read in the rows.
for (int index = 0; index < rowCount; index++)
{
loader.Position = rows[index].DataOffset;
int next = index < rows.Length - 1 ? rows[index + 1].DataOffset : stringsOffset;
ParameterTableRow item = ParameterTableRow.ReadRow(this, index, loader, next);
item.Id = rows[index].Id;
if (loader.Position != next)
{
loader.AddError(rows[index].DataOffset, "Row {0} of the table did not read the correct amount; position should be {1}, but is {2}.", index, next, loader.Position);
}
}
// Read in the row names.
for (int index = 0; index < rowCount; index++)
{
loader.Position = rows[index].NameOffset;
((ParameterTableRow)Children[index]).Name = reader.ReadStringz(EncodingShiftJis).Trim(); //((index < rows.Length - 1 ? rows[index + 1].NameOffset : loader.ShortLength) - rows[index].NameOffset - 1, EncodingShiftJis));
}
}
internal void ReadAddOn(BinaryReader reader)
{
switch (Message.MajorVersion)
{
case 4:
string value = reader.ReadStringz(Encoding.ASCII);
if (!string.IsNullOrEmpty(value))
{
Comment = value;
}
Unknowns.ReadBytes(reader, 6);
break;
case 5:
Unknowns.ReadBytes(reader, 6);
break;
default:
throw new NotImplementedException();
}
}
internal Group(Module module, uint contentSize, uint label, ModuleGroupType groupType)
: base(module.Manager, "")
{
BinaryReader reader = module.Reader;
ContentSize = contentSize;
LabelUInt32 = label;
GroupType = groupType;
var timeStampDay = reader.ReadByte(); // One-based day in the month.
var timeStampMonth = reader.ReadByte();
TimeStamp = new DateTime(2002, 12, 1).AddMonths(timeStampMonth);
int currentMonth = TimeStamp.Month;
if (timeStampDay == 0)
{
throw new InvalidDataException();
}
TimeStamp = TimeStamp.AddDays(timeStampDay - 1);
if (TimeStamp.Month != currentMonth)
{
throw new InvalidDataException();
}
//.AddDays(timeStampDay);
Unknowns.ReadInt16s(reader, 1);
Version = reader.ReadUInt16();
Unknowns.ReadInt16s(reader, 1);
ContentOffset = reader.BaseStream.Position;
reader.BaseStream.Seek(ContentSize, SeekOrigin.Current);
Name = GroupType + " " + LabelValue;
}
internal Part(Table table, int index, AssetLoader loader, int next)
: base(table, index)
{
BinaryReader reader = loader.Reader;
long start = reader.BaseStream.Position;
loader.Expect(HeaderLength);
Type = (ModelType)reader.ReadInt32();
Unknowns.ReadInt32s(reader, 1);
Index = reader.ReadInt32();
int pathOffset = reader.ReadInt32();
Position = reader.ReadVector3f();
Rotation = Angle3.Degrees(reader.ReadSingle(), reader.ReadSingle(), reader.ReadSingle());
Scale = reader.ReadVector3f();
Unknowns.ReadInt32s(reader, 8);
int offset1 = reader.ReadInt32();
int offset2 = reader.ReadInt32();
if (offset1 + 0x18 != offset2)
{
loader.AddError(start, "Offset2 is not correct.");
}
loader.ExpectZeroes(4, 1);
Name = reader.ReadStringz(EncodingShiftJis);
Path = reader.ReadStringz(EncodingShiftJis);
loader.Position = start + offset1;
Unknowns.ReadInt32s(reader, 6, "Offset1s");
if (loader.Position > next || (next - loader.Position) / 4 > 64)
{
}
Unknowns.ReadInt32s(reader, (int)(next - loader.Position) / 4, "Offset2s");
}
