186 lines
8.4 KiB
C#
186 lines
8.4 KiB
C#
using System.Buffers.Binary;
|
|
using System.Text;
|
|
|
|
namespace Age.Engine.Sys4;
|
|
|
|
/// <summary>One raw SYS4INI file record. Placeholder records remain addressable by
|
|
/// <see cref="RawIndex"/> but are excluded from scene and name views.</summary>
|
|
public sealed record AssetEntry(
|
|
string Name,
|
|
string Archive,
|
|
long Offset,
|
|
long Size,
|
|
int RawIndex = -1,
|
|
int ArchiveId = -1,
|
|
int FileNumber = -1,
|
|
bool IsPlaceholder = false);
|
|
|
|
/// <summary>Runtime parser and lookup views for a base S4IC SYS4INI catalog.</summary>
|
|
public sealed class Sys4AssetCatalog
|
|
{
|
|
private const int PackedSizeOffset = 0x134;
|
|
private const int ExpandedSizeOffset = 0x12c;
|
|
private const int ArchiveNameSize = 256;
|
|
private const int RecordSize = 80;
|
|
|
|
private readonly Dictionary<string, AssetEntry> _byName;
|
|
private readonly Dictionary<string, (int Start, int End)> _sceneRanges;
|
|
|
|
public string Magic { get; }
|
|
public IReadOnlyList<string> Archives { get; }
|
|
public IReadOnlyList<AssetEntry> RawSlots { get; }
|
|
public IReadOnlyList<AssetEntry> Files { get; }
|
|
|
|
private Sys4AssetCatalog(string magic, List<string> archives, List<AssetEntry> rawSlots)
|
|
{
|
|
Magic = magic;
|
|
Archives = archives;
|
|
RawSlots = rawSlots;
|
|
Files = rawSlots.Where(r => !r.IsPlaceholder).ToArray();
|
|
_byName = Files.ToDictionary(r => r.Name, StringComparer.OrdinalIgnoreCase);
|
|
_sceneRanges = BuildSceneRanges(Files);
|
|
}
|
|
|
|
public static Sys4AssetCatalog Load(string path) => Parse(File.ReadAllBytes(path), Path.GetFileName(path));
|
|
|
|
public static Sys4AssetCatalog Parse(byte[] data, string name = "SYS4INI.BIN")
|
|
{
|
|
if (data.Length < PackedSizeOffset + 4 || !data.AsSpan(0, 4).SequenceEqual("S4IC"u8))
|
|
throw new InvalidDataException($"{name}: expected an S4IC catalog");
|
|
|
|
uint expandedSize = BinaryPrimitives.ReadUInt32LittleEndian(data.AsSpan(ExpandedSizeOffset, 4));
|
|
uint packedSize = BinaryPrimitives.ReadUInt32LittleEndian(data.AsSpan(PackedSizeOffset, 4));
|
|
if (packedSize > data.Length - (PackedSizeOffset + 4))
|
|
throw new InvalidDataException($"{name}: packed directory is truncated");
|
|
if (expandedSize == 0 || expandedSize > int.MaxValue)
|
|
throw new InvalidDataException($"{name}: invalid expanded size {expandedSize}");
|
|
|
|
var blob = DecompressLzss(data.AsSpan(PackedSizeOffset + 4, checked((int)packedSize)),
|
|
checked((int)expandedSize), name);
|
|
int p = 0;
|
|
uint ReadU32()
|
|
{
|
|
if (p > blob.Length - 4) throw new InvalidDataException($"{name}: directory is truncated");
|
|
uint value = BinaryPrimitives.ReadUInt32LittleEndian(blob.AsSpan(p, 4));
|
|
p += 4;
|
|
return value;
|
|
}
|
|
|
|
uint archiveCount = ReadU32();
|
|
if (archiveCount is 0 or >= 0x1000 || archiveCount > (blob.Length - p) / ArchiveNameSize)
|
|
throw new InvalidDataException($"{name}: invalid archive count {archiveCount}");
|
|
var archives = new List<string>(checked((int)archiveCount));
|
|
for (int i = 0; i < archiveCount; i++, p += ArchiveNameSize)
|
|
archives.Add(ReadCString(blob.AsSpan(p, ArchiveNameSize)));
|
|
|
|
uint fileCount = ReadU32();
|
|
if (fileCount is 0 or >= 0x400000 || fileCount > (blob.Length - p) / RecordSize)
|
|
throw new InvalidDataException($"{name}: invalid file count {fileCount}");
|
|
var slots = new List<AssetEntry>(checked((int)fileCount));
|
|
for (int i = 0; i < fileCount; i++, p += RecordSize)
|
|
{
|
|
var row = blob.AsSpan(p, RecordSize);
|
|
string fileName = ReadCString(row[..64]);
|
|
int archiveId = checked((int)BinaryPrimitives.ReadUInt32LittleEndian(row.Slice(64, 4)));
|
|
int fileNumber = checked((int)BinaryPrimitives.ReadUInt32LittleEndian(row.Slice(68, 4)));
|
|
long offset = BinaryPrimitives.ReadUInt32LittleEndian(row.Slice(72, 4));
|
|
long size = BinaryPrimitives.ReadUInt32LittleEndian(row.Slice(76, 4));
|
|
string archive = archiveId >= 0 && archiveId < archives.Count ? archives[archiveId] : "";
|
|
bool placeholder = fileName is "" or "@";
|
|
slots.Add(new AssetEntry(fileName, archive, offset, size, i, archiveId, fileNumber, placeholder));
|
|
}
|
|
|
|
string magic = ReadCString(data.AsSpan(0, Math.Min(8, data.Length)));
|
|
return new Sys4AssetCatalog(magic, archives, slots);
|
|
}
|
|
|
|
/// <summary>Universal raw-id lookup. Placeholder slots are returned, not collapsed.</summary>
|
|
public AssetEntry? ResolveRaw(long rawId)
|
|
=> rawId >= 0 && rawId < RawSlots.Count ? RawSlots[(int)rawId] : null;
|
|
|
|
/// <summary>Case-insensitive exact-name lookup over real records.</summary>
|
|
public AssetEntry? ResolveName(string name)
|
|
=> _byName.TryGetValue(Path.GetFileName(name), out var entry) && Path.GetFileName(name) == name
|
|
? entry : null;
|
|
|
|
/// <summary>Resolve within the owning scene section; ids cannot spill into the next section.</summary>
|
|
public AssetEntry? ResolveScene(string scene, long localId)
|
|
{
|
|
string key = Path.GetFileNameWithoutExtension(scene);
|
|
if (!_sceneRanges.TryGetValue(key, out var range)) return null;
|
|
long pos = range.Start + localId;
|
|
return localId >= 0 && pos <= range.End ? Files[(int)pos] : null;
|
|
}
|
|
|
|
public IReadOnlyList<string> ScriptNames => Files
|
|
.Where(f => f.Name.EndsWith(".BIN", StringComparison.OrdinalIgnoreCase))
|
|
.Select(f => f.Name.ToUpperInvariant()).ToArray();
|
|
|
|
private static Dictionary<string, (int Start, int End)> BuildSceneRanges(IReadOnlyList<AssetEntry> files)
|
|
{
|
|
var ranges = new Dictionary<string, (int Start, int End)>(StringComparer.OrdinalIgnoreCase);
|
|
int start = 0;
|
|
for (int i = 1; i <= files.Count; i++)
|
|
{
|
|
bool end = i == files.Count || files[i].FileNumber <= files[i - 1].FileNumber;
|
|
if (!end) continue;
|
|
for (int k = start; k < i; k++)
|
|
if (files[k].Name.Length == 10 && files[k].Name.StartsWith("SC", StringComparison.OrdinalIgnoreCase)
|
|
&& files[k].Name.EndsWith(".BIN", StringComparison.OrdinalIgnoreCase)
|
|
&& files[k].Name.AsSpan(2, 4).ToString().All(char.IsDigit))
|
|
{
|
|
ranges[Path.GetFileNameWithoutExtension(files[k].Name)] = (start, i - 1);
|
|
break;
|
|
}
|
|
start = i;
|
|
}
|
|
return ranges;
|
|
}
|
|
|
|
private static string ReadCString(ReadOnlySpan<byte> bytes)
|
|
{
|
|
int zero = bytes.IndexOf((byte)0);
|
|
if (zero >= 0) bytes = bytes[..zero];
|
|
Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
|
|
return Encoding.GetEncoding(932).GetString(bytes);
|
|
}
|
|
|
|
private static byte[] DecompressLzss(ReadOnlySpan<byte> source, int expectedSize, string name)
|
|
{
|
|
var frame = new byte[0x1000];
|
|
int framePos = 0xfee, input = 0, output = 0;
|
|
var result = new byte[expectedSize];
|
|
while (output < expectedSize)
|
|
{
|
|
if (input >= source.Length) throw new InvalidDataException($"{name}: LZSS stream ended early");
|
|
int control = source[input++];
|
|
for (int bit = 1; bit <= 0x80 && output < expectedSize; bit <<= 1)
|
|
{
|
|
if ((control & bit) != 0)
|
|
{
|
|
if (input >= source.Length) throw new InvalidDataException($"{name}: truncated LZSS literal");
|
|
byte value = source[input++];
|
|
result[output++] = value;
|
|
frame[framePos] = value;
|
|
framePos = (framePos + 1) & 0xfff;
|
|
}
|
|
else
|
|
{
|
|
if (input > source.Length - 2) throw new InvalidDataException($"{name}: truncated LZSS back-reference");
|
|
int lo = source[input++], hi = source[input++];
|
|
int readPos = ((hi & 0xf0) << 4) | lo;
|
|
int length = 3 + (hi & 0x0f);
|
|
for (int j = 0; j < length && output < expectedSize; j++)
|
|
{
|
|
byte value = frame[readPos++ & 0xfff];
|
|
result[output++] = value;
|
|
frame[framePos] = value;
|
|
framePos = (framePos + 1) & 0xfff;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
}
|