SaveFile.cs

using AliceSaveFileEditor.Structs;
using System.IO;
using System.Runtime.InteropServices;

namespace AliceSaveFileEditor
{
    internal class SaveFile(string filePath)
    {
        public SaveFileHeader Header;
        public List<SaveFileSlot> Slots = [];
        public SaveFileOptions Options;
        private readonly string filePath = filePath;

        public void Read()
        {
            using FileStream fileStream = File.OpenRead(this.filePath);
            this.Slots = [];

            fileStream.Seek(0, SeekOrigin.Begin);
            this.ReadHeader(fileStream);

            int nextSlotStart = this.Header.FirstSlotStartAddress;
            int slotCount = this.Header.FileSetting >> 1;
            for (int slotNum = 0; slotNum < slotCount - 1; slotNum++)
            {
                fileStream.Seek(nextSlotStart + 0x11, SeekOrigin.Begin);
                this.ReadSlot(fileStream);
                nextSlotStart = this.Slots[slotNum].NextSlotStartAddress;
            }
            this.ReadOptionsSlot(fileStream);
        }

        public void Save()
        {
            using FileStream fileStream = File.OpenWrite(this.filePath);
            fileStream.Seek(0, SeekOrigin.Begin);
        }

        private unsafe void ReadHeader(FileStream fileStream)
        {
            int sizeOfHeader = sizeof(SaveFileHeader); // should be 0x1E
            byte[] buffer = new byte[sizeOfHeader];
            fileStream.Read(buffer, 0, sizeOfHeader);
            GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
            this.Header = *(SaveFileHeader*)handle.AddrOfPinnedObject();
            handle.Free();
        }

        private unsafe void ReadSlot(FileStream fileStream)
        {
            SaveFileSlot slot;
            int sizeOfSlot = sizeof(SaveFileSlot);
            byte[] buffer = new byte[sizeOfSlot];
            fileStream.Read(buffer, 0, sizeOfSlot);
            GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
            slot = *(SaveFileSlot*)handle.AddrOfPinnedObject();
            handle.Free();
            this.Slots.Add(slot);
        }

        private unsafe void ReadOptionsSlot(FileStream fileStream)
        {
            // options data always seems to be at the same offset
            // this also follows the +0x11 pattern of slots
            fileStream.Seek(0x010000 + 0x11, SeekOrigin.Begin);
            int sizeOfOptions = Marshal.SizeOf<SaveFileOptions>();
            byte[] buffer = new byte[sizeOfOptions];
            fileStream.Read(buffer, 0, sizeOfOptions);
            GCHandle handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
            this.Options = *(SaveFileOptions*)handle.AddrOfPinnedObject();
            handle.Free();
        }
    }
}