296 lines
13 KiB
C#
296 lines
13 KiB
C#
using System.Buffers.Binary;
|
|
using System.Text;
|
|
|
|
namespace Age.Engine.Persistence;
|
|
|
|
public sealed record NativeSavedScriptFrame(
|
|
int ParentContext,
|
|
uint ScriptId,
|
|
IReadOnlyList<int> ReturnIndices,
|
|
int ResumeIndex,
|
|
int CallTargetIndex);
|
|
|
|
public sealed record NativeSavedGfxObject(long Handle, byte[] Record);
|
|
|
|
public sealed record NativeNumberedSaveState(
|
|
int SavedFrameOwner,
|
|
int BgmTrackId,
|
|
IReadOnlyList<int> SoundEffectResourceIds,
|
|
byte[] ResourceRecords,
|
|
byte[] SurfaceRecords,
|
|
IReadOnlyList<NativeSavedScriptFrame> Frames,
|
|
IReadOnlyList<int> IntegerGlobals,
|
|
IReadOnlyList<int> FloatGlobals,
|
|
IReadOnlyList<string> StringGlobals,
|
|
IReadOnlyList<int> PointerGlobals,
|
|
IReadOnlyList<int> PointerStrings,
|
|
IReadOnlyList<int> LocalPointerScratch,
|
|
IReadOnlyList<NativeSavedGfxObject> GfxObjects,
|
|
long RangeTransformFirst,
|
|
int RangeTransformCount,
|
|
byte[] RangeTransformRecord)
|
|
{
|
|
public const int SoundEffectChannelCount = 10;
|
|
public const int ResourceRecordsSize = 300 * 4;
|
|
public const int SurfaceRecordsSize = 20_000;
|
|
public const int GfxRecordSize = 0x2d4;
|
|
}
|
|
|
|
/// <summary>AGE SaveVersion1=3 numbered-save logical payload.</summary>
|
|
public static class NativeNumberedSaveCodec
|
|
{
|
|
private const int FixedPrefixSize = 0x5304;
|
|
private const int FrameSize = 0x414;
|
|
private const int FixedSuffixSize = 0x414;
|
|
private const int FrameReturnCapacity = 256;
|
|
private const int GfxAllocationDwords = 0x2d8;
|
|
private const int GfxConstantDwords = 0x2e1;
|
|
private static readonly Encoding NativeEncoding = CreateNativeEncoding();
|
|
|
|
public static byte[] Encode(NativeNumberedSaveState state)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(state);
|
|
ValidateState(state);
|
|
|
|
int cutoff = state.Frames.Count - 1;
|
|
byte[] strings = EncodeStrings(state.StringGlobals);
|
|
int stringDwords = strings.Length / 4;
|
|
int bankDwords = checked(
|
|
state.IntegerGlobals.Count + state.FloatGlobals.Count + state.StringGlobals.Count
|
|
+ state.PointerGlobals.Count + state.PointerStrings.Count + state.LocalPointerScratch.Count);
|
|
int totalDwords = checked(
|
|
cutoff * 0x105 + 0x53ea + bankDwords + stringDwords
|
|
+ GfxConstantDwords + state.GfxObjects.Count * GfxAllocationDwords);
|
|
byte[] payload = new byte[checked((totalDwords - 2) * 4)];
|
|
|
|
WriteInt(payload, 0, cutoff);
|
|
WriteInt(payload, 4, state.SavedFrameOwner);
|
|
WriteInt(payload, 8, state.BgmTrackId);
|
|
WriteIntList(payload, 0x0c, state.SoundEffectResourceIds);
|
|
state.ResourceRecords.CopyTo(payload, 0x34);
|
|
state.SurfaceRecords.CopyTo(payload, 0x4e4);
|
|
|
|
for (int i = 0; i < state.Frames.Count; i++)
|
|
WriteFrame(payload, FixedPrefixSize + i * FrameSize, state.Frames[i], i == cutoff);
|
|
|
|
int at = checked(0x5718 + cutoff * FrameSize);
|
|
int[] counts =
|
|
[
|
|
state.IntegerGlobals.Count, state.FloatGlobals.Count, state.StringGlobals.Count,
|
|
state.PointerGlobals.Count, state.PointerStrings.Count, state.LocalPointerScratch.Count,
|
|
];
|
|
WriteIntList(payload, at, counts);
|
|
at += 24;
|
|
WriteIntList(payload, at, state.IntegerGlobals);
|
|
at += state.IntegerGlobals.Count * 4;
|
|
WriteIntList(payload, at, state.FloatGlobals);
|
|
at += state.FloatGlobals.Count * 4;
|
|
WriteInt(payload, at, stringDwords);
|
|
at += 4;
|
|
strings.CopyTo(payload, at);
|
|
at += strings.Length;
|
|
WriteIntList(payload, at, state.PointerGlobals);
|
|
at += state.PointerGlobals.Count * 4;
|
|
WriteIntList(payload, at, state.PointerStrings);
|
|
at += state.PointerStrings.Count * 4;
|
|
WriteIntList(payload, at, state.LocalPointerScratch);
|
|
at += state.LocalPointerScratch.Count * 4;
|
|
|
|
WriteInt(payload, at, NativeNumberedSaveState.GfxRecordSize);
|
|
WriteInt(payload, at + 4, state.GfxObjects.Count);
|
|
at += 8;
|
|
foreach (NativeSavedGfxObject gfx in state.GfxObjects)
|
|
{
|
|
WriteInt(payload, at, unchecked((int)gfx.Handle));
|
|
gfx.Record.CopyTo(payload, at + 4);
|
|
at += 4 + NativeNumberedSaveState.GfxRecordSize;
|
|
}
|
|
WriteInt(payload, at, unchecked((int)state.RangeTransformFirst));
|
|
WriteInt(payload, at + 4, state.RangeTransformCount);
|
|
state.RangeTransformRecord.CopyTo(payload, at + 8);
|
|
return payload;
|
|
}
|
|
|
|
public static NativeNumberedSaveState Decode(ReadOnlySpan<byte> payload)
|
|
{
|
|
if (payload.Length < 0x5718)
|
|
throw new InvalidDataException("Numbered-save layout 3 payload is truncated.");
|
|
int cutoff = ReadNonNegative(payload, 0, "saved frame cutoff");
|
|
int fixedBytes = checked(0x5718 + cutoff * FrameSize);
|
|
Require(payload, 0, fixedBytes, "numbered-save fixed state");
|
|
|
|
int[] soundEffects = ReadInts(
|
|
payload, 0x0c, NativeNumberedSaveState.SoundEffectChannelCount);
|
|
byte[] resources = payload.Slice(0x34, NativeNumberedSaveState.ResourceRecordsSize).ToArray();
|
|
byte[] surfaces = payload.Slice(0x4e4, NativeNumberedSaveState.SurfaceRecordsSize).ToArray();
|
|
var frames = new NativeSavedScriptFrame[cutoff + 1];
|
|
for (int i = 0; i < frames.Length; i++)
|
|
frames[i] = ReadFrame(payload, FixedPrefixSize + i * FrameSize);
|
|
|
|
int at = fixedBytes;
|
|
int[] counts = ReadInts(payload, at, 6);
|
|
if (counts.Any(count => count < 0))
|
|
throw new InvalidDataException("Numbered-save layout 3 contains a negative bank count.");
|
|
at += 24;
|
|
int[] integers = ReadInts(payload, at, counts[0]);
|
|
at = checked(at + counts[0] * 4);
|
|
int[] floats = ReadInts(payload, at, counts[1]);
|
|
at = checked(at + counts[1] * 4);
|
|
int stringDwords = ReadNonNegative(payload, at, "string blob length");
|
|
at += 4;
|
|
int stringBytes = checked(stringDwords * 4);
|
|
Require(payload, at, stringBytes, "numbered-save string blob");
|
|
string[] strings = DecodeStrings(payload.Slice(at, stringBytes), counts[2]);
|
|
at += stringBytes;
|
|
int[] pointers = ReadInts(payload, at, counts[3]);
|
|
at = checked(at + counts[3] * 4);
|
|
int[] pointerStrings = ReadInts(payload, at, counts[4]);
|
|
at = checked(at + counts[4] * 4);
|
|
int[] localPointerScratch = ReadInts(payload, at, counts[5]);
|
|
at = checked(at + counts[5] * 4);
|
|
|
|
int gfxRecordSize = ReadNonNegative(payload, at, "gfx record size");
|
|
int gfxCount = ReadNonNegative(payload, at + 4, "gfx object count");
|
|
if (gfxRecordSize != NativeNumberedSaveState.GfxRecordSize)
|
|
throw new InvalidDataException($"Unsupported native gfx record size 0x{gfxRecordSize:x}.");
|
|
at += 8;
|
|
var objects = new NativeSavedGfxObject[gfxCount];
|
|
for (int i = 0; i < objects.Length; i++)
|
|
{
|
|
Require(payload, at, 4 + gfxRecordSize, "numbered-save gfx object");
|
|
long handle = ReadInt(payload, at);
|
|
objects[i] = new NativeSavedGfxObject(handle, payload.Slice(at + 4, gfxRecordSize).ToArray());
|
|
at += 4 + gfxRecordSize;
|
|
}
|
|
Require(payload, at, 8 + gfxRecordSize, "numbered-save range transform");
|
|
long rangeFirst = ReadInt(payload, at);
|
|
int rangeCount = ReadInt(payload, at + 4);
|
|
byte[] rangeRecord = payload.Slice(at + 8, gfxRecordSize).ToArray();
|
|
|
|
return new NativeNumberedSaveState(
|
|
ReadInt(payload, 4), ReadInt(payload, 8), soundEffects, resources, surfaces, frames,
|
|
integers, floats, strings, pointers, pointerStrings, localPointerScratch, objects,
|
|
rangeFirst, rangeCount, rangeRecord);
|
|
}
|
|
|
|
public static NativeNumberedSaveState Empty(IReadOnlyList<NativeSavedScriptFrame> frames)
|
|
=> new(
|
|
0, 0, new int[NativeNumberedSaveState.SoundEffectChannelCount],
|
|
new byte[NativeNumberedSaveState.ResourceRecordsSize],
|
|
new byte[NativeNumberedSaveState.SurfaceRecordsSize],
|
|
frames, Array.Empty<int>(), Array.Empty<int>(), Array.Empty<string>(),
|
|
Array.Empty<int>(), Array.Empty<int>(), Array.Empty<int>(),
|
|
Array.Empty<NativeSavedGfxObject>(), 0, 0,
|
|
new byte[NativeNumberedSaveState.GfxRecordSize]);
|
|
|
|
private static void WriteFrame(Span<byte> payload, int offset, NativeSavedScriptFrame frame, bool terminal)
|
|
{
|
|
if (frame.ReturnIndices.Count > FrameReturnCapacity)
|
|
throw new InvalidDataException("A native saved frame cannot hold more than 256 return entries.");
|
|
WriteInt(payload, offset, frame.ParentContext);
|
|
WriteInt(payload, offset + 4, unchecked((int)frame.ScriptId));
|
|
WriteInt(payload, offset + 8, frame.ReturnIndices.Count);
|
|
for (int i = 0; i < frame.ReturnIndices.Count; i++)
|
|
WriteInt(payload, offset + 12 + i * 4, frame.ReturnIndices[i]);
|
|
WriteInt(payload, offset + 0x40c, frame.ResumeIndex);
|
|
WriteInt(payload, offset + 0x410, terminal ? -1 : frame.CallTargetIndex);
|
|
}
|
|
|
|
private static NativeSavedScriptFrame ReadFrame(ReadOnlySpan<byte> payload, int offset)
|
|
{
|
|
int count = ReadNonNegative(payload, offset + 8, "frame return count");
|
|
if (count > FrameReturnCapacity)
|
|
throw new InvalidDataException("Numbered-save frame return count exceeds 256.");
|
|
return new NativeSavedScriptFrame(
|
|
ReadInt(payload, offset), unchecked((uint)ReadInt(payload, offset + 4)),
|
|
ReadInts(payload, offset + 12, count),
|
|
ReadInt(payload, offset + 0x40c), ReadInt(payload, offset + 0x410));
|
|
}
|
|
|
|
private static byte[] EncodeStrings(IReadOnlyList<string> strings)
|
|
{
|
|
using var stream = new MemoryStream();
|
|
foreach (string text in strings)
|
|
{
|
|
byte[] encoded = NativeEncoding.GetBytes(text ?? "");
|
|
stream.Write(encoded);
|
|
stream.WriteByte(0);
|
|
}
|
|
while ((stream.Length & 3) != 0) stream.WriteByte(0);
|
|
return stream.ToArray();
|
|
}
|
|
|
|
private static string[] DecodeStrings(ReadOnlySpan<byte> blob, int count)
|
|
{
|
|
var result = new string[count];
|
|
int at = 0;
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if (at >= blob.Length)
|
|
throw new InvalidDataException("Numbered-save string blob ended before its declared string count.");
|
|
int end = blob[at..].IndexOf((byte)0);
|
|
if (end < 0)
|
|
throw new InvalidDataException("Numbered-save string blob ended before its declared string count.");
|
|
result[i] = NativeEncoding.GetString(blob.Slice(at, end));
|
|
at += end + 1;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private static void ValidateState(NativeNumberedSaveState state)
|
|
{
|
|
if (state.Frames.Count == 0) throw new InvalidDataException("A numbered save requires at least one frame.");
|
|
if (state.SoundEffectResourceIds.Count != NativeNumberedSaveState.SoundEffectChannelCount)
|
|
throw new InvalidDataException("Numbered-save sound-effect channel count must be 10.");
|
|
if (state.ResourceRecords.Length != NativeNumberedSaveState.ResourceRecordsSize)
|
|
throw new InvalidDataException("Numbered-save resource table must be 1,200 bytes.");
|
|
if (state.SurfaceRecords.Length != NativeNumberedSaveState.SurfaceRecordsSize)
|
|
throw new InvalidDataException("Numbered-save surface table must be 20,000 bytes.");
|
|
if (state.RangeTransformRecord.Length != NativeNumberedSaveState.GfxRecordSize
|
|
|| state.GfxObjects.Any(item => item.Record.Length != NativeNumberedSaveState.GfxRecordSize))
|
|
throw new InvalidDataException("Numbered-save gfx records must be 0x2d4 bytes.");
|
|
}
|
|
|
|
private static int[] ReadInts(ReadOnlySpan<byte> source, int offset, int count)
|
|
{
|
|
int bytes = checked(count * 4);
|
|
Require(source, offset, bytes, "numbered-save integer array");
|
|
var values = new int[count];
|
|
for (int i = 0; i < count; i++) values[i] = ReadInt(source, offset + i * 4);
|
|
return values;
|
|
}
|
|
|
|
private static void WriteIntList(Span<byte> destination, int offset, IReadOnlyList<int> values)
|
|
{
|
|
for (int i = 0; i < values.Count; i++) WriteInt(destination, offset + i * 4, values[i]);
|
|
}
|
|
|
|
private static int ReadNonNegative(ReadOnlySpan<byte> source, int offset, string name)
|
|
{
|
|
int value = ReadInt(source, offset);
|
|
if (value < 0) throw new InvalidDataException($"Numbered-save {name} is negative.");
|
|
return value;
|
|
}
|
|
|
|
private static int ReadInt(ReadOnlySpan<byte> source, int offset)
|
|
{
|
|
Require(source, offset, 4, "numbered-save dword");
|
|
return BinaryPrimitives.ReadInt32LittleEndian(source.Slice(offset, 4));
|
|
}
|
|
|
|
private static void WriteInt(Span<byte> destination, int offset, int value)
|
|
=> BinaryPrimitives.WriteInt32LittleEndian(destination.Slice(offset, 4), value);
|
|
|
|
private static void Require(ReadOnlySpan<byte> source, int offset, int count, string name)
|
|
{
|
|
if (offset < 0 || count < 0 || offset > source.Length - count)
|
|
throw new InvalidDataException($"{name} is truncated.");
|
|
}
|
|
|
|
private static Encoding CreateNativeEncoding()
|
|
{
|
|
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
|
|
return Encoding.GetEncoding(932);
|
|
}
|
|
}
|