V2.0.0 (Acroarts, .mab Read)

Marathon.Tests/Formats/Acroarts/AckResourceTests.cs

@@ -0,0 +1,20 @@
+using Marathon.Formats.Acroarts;
+using Marathon.Tests.Helpers;
+
+namespace Marathon.Tests.Formats.Particle
+{
+    internal class AckResourceTests : ITest
+    {
+        private Func<bool>[] _tests = [BinaryIdenticalTest];
+
+        private static bool BinaryIdenticalTest()
+        {
+            return TestHelper.CheckAllBinaries<AckResource>("*mab");
+        }
+
+        public bool Run()
+        {
+            return TestHelper.RunSubTests(_tests);
+        }
+    }
+}

Marathon/Formats/Acroarts/ACM/IACM.cs

@@ -0,0 +1,12 @@
+using Marathon.IO.Types.BINA;
+
+namespace Marathon.Formats.Acroarts.Chunks
+{
+    public interface IACM
+    {
+        void Read(BINAReader in_reader,uint count);
+
+        void Write(BINAWriter in_writer);
+
+    }
+}

Marathon/Formats/Acroarts/ACM/_acmBlurBelt.cs

@@ -0,0 +1,34 @@
+using Amicitia.IO.Binary;
+using Marathon.Exceptions;
+using Marathon.Formats.Acroarts.Types;
+using Marathon.Helpers;
+using Marathon.IO.Types.BINA;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Marathon.Formats.Acroarts.Chunks
+{
+    public class _acmBlurBelt : IACM
+    {
+        public List<byte> Data { get; set; }
+        public _acmBlurBelt() { }
+
+        public _acmBlurBelt(BINAReader in_reader, uint count)
+        {
+            Read(in_reader, count);
+        }
+
+        public void Read(BINAReader in_reader, uint count)
+        {
+            var DefaultPosition = 0x50;
+            var Position = in_reader.Position;
+            Data = in_reader.ReadArray<byte>((int)(count * 4)).ToList();
+            Logger.Warning($"_acmBlurBelt at {Position:x} Count:{count}");
+        }
+
+        public void Write(BINAWriter in_writer)
+        {
+            // TODO
+        }
+    }
+}

Marathon/Formats/Acroarts/ACM/_acmParticlePlay.cs

@@ -0,0 +1,49 @@
+using Amicitia.IO.Binary;
+using Marathon.Exceptions;
+using Marathon.Formats.Acroarts.Types;
+using Marathon.Helpers;
+using Marathon.IO.Types.BINA;
+using System.Collections.Generic;
+
+namespace Marathon.Formats.Acroarts.Chunks
+{
+    public class _acmParticlePlay : IACM
+    {
+        public string Bank { get; set; }
+        public string BankParticle { get; set; }
+        public float Speed { get; set; }  // > 0 (Speed * 1.0/60.0)
+        public uint Mode { get; set; }  // 0 - 1
+
+        public _acmParticlePlay() { }
+
+        public _acmParticlePlay(BINAReader in_reader, uint count)
+        {
+            Read(in_reader, count);
+        }
+
+        public void Read(BINAReader in_reader, uint count)
+        {
+            var DefaultPosition = 0x50;
+            var Position = in_reader.Position;
+            in_reader.ReadAtOffset(in_reader.Read<uint>() + DefaultPosition, () =>
+            {
+                Bank = in_reader.ReadString(StringBinaryFormat.NullTerminated);
+            });
+
+            in_reader.ReadAtOffset(in_reader.Read<uint>() + DefaultPosition, () =>
+            {
+                BankParticle = in_reader.ReadString(StringBinaryFormat.NullTerminated);
+            });
+
+            Speed = in_reader.Read<float>();
+            Mode = in_reader.Read<uint>();
+
+            Logger.Warning($"_acmParticlePlay at {Position:x} Count:{count} Bank:{Bank} Particle:{BankParticle} Speed {Speed} Mode {Mode}");
+        }
+
+        public void Write(BINAWriter in_writer)
+        {
+            // TODO
+        }
+    }
+}

Marathon/Formats/Acroarts/ACM/_acmPlaceFanShaped.cs

@@ -0,0 +1,38 @@
+using Amicitia.IO.Binary;
+using Marathon.Exceptions;
+using Marathon.Formats.Acroarts.Types;
+using Marathon.Helpers;
+using Marathon.IO.Types.BINA;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Marathon.Formats.Acroarts.Chunks
+{
+    public class _acmPlaceFanShaped : IACM
+    {
+        public uint Start { get; set; }
+        public uint End { get; set; }
+
+        //End - Start
+        public _acmPlaceFanShaped() { }
+
+        public _acmPlaceFanShaped(BINAReader in_reader, uint count)
+        {
+            Read(in_reader, count);
+        }
+
+        public void Read(BINAReader in_reader, uint count)
+        {
+            var DefaultPosition = 0x50;
+            var Position = in_reader.Position;
+            Start = in_reader.Read<uint>();
+            End = in_reader.Read<uint>();
+            Logger.Warning($"_acmPlaceFanShaped at {Position:x} Count:{count} Start {Start} End {End}");
+        }
+
+        public void Write(BINAWriter in_writer)
+        {
+            // TODO
+        }
+    }
+}

Marathon/Formats/Acroarts/ACM/_acmRotateNormal.cs

@@ -0,0 +1,39 @@
+using Amicitia.IO.Binary;
+using Marathon.Exceptions;
+using Marathon.Formats.Acroarts.Types;
+using Marathon.Helpers;
+using Marathon.IO.Types.BINA;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Marathon.Formats.Acroarts.Chunks
+{
+    public class _acmRotateNormal : IACM
+    {
+        //Degrees
+        public float AngleX;
+        public float AngleY;
+        public float AngleZ;
+        public _acmRotateNormal() { }
+
+        public _acmRotateNormal(BINAReader in_reader, uint count)
+        {
+            Read(in_reader, count);
+        }
+
+        public void Read(BINAReader in_reader, uint count)
+        {
+            var DefaultPosition = 0x50;
+            var Position = in_reader.Position;
+            AngleX = in_reader.ReadSingle();
+            AngleY = in_reader.ReadSingle();
+            AngleZ = in_reader.ReadSingle();
+            Logger.Warning($"_acmRotateNormal at {Position:x} Count:{count} AngleX {AngleX} AngleY {AngleY} AngleZ {AngleZ}");
+        }
+
+        public void Write(BINAWriter in_writer)
+        {
+            // TODO
+        }
+    }
+}

Marathon/Formats/Acroarts/AckResource.cs

@@ -0,0 +1,62 @@
+using Amicitia.IO.Streams;
+using Marathon.Formats.Acroarts.Chunks;
+using Marathon.IO;
+using Marathon.IO.Extensions;
+using Marathon.IO.Types.BINA;
+using Marathon.IO.Types.FileSystem;
+using System.Collections.Generic;
+using System.IO;
+
+// Format names:        Acroarts Resource
+// Format references:   Sonicteam::Spanverse::AckResource
+// Format designers:    Sonic Team
+// Format researchers:  Hyper, Rei-san
+
+namespace Marathon.Formats.Acroarts
+{
+    /// <summary>
+    /// Support for *.mab files; used for Acroarts event data.
+    /// </summary>
+    public class AckResource : FileBase
+    {
+        private const string _extension = ".mab"; // "My Acroarts Binary" (speculatory)
+        private const string _signature = "MRAB"; // "My Resource Acroarts Binary" (speculatory)
+
+        public const uint Version = 2006020901; // 2006 February 9th, Revision 1
+
+        public AcroartsBinaryArchive Archive { get; set; }
+
+        public override string Extension => _extension;
+
+        public AckResource() { }
+
+        public AckResource(string in_path) : base(in_path) { }
+
+        public AckResource(Stream in_stream) : base(in_stream) { }
+
+        public AckResource(IFile in_file) : base(in_file) { }
+
+        public override void Read(Stream in_stream)
+        {
+            var mrabReader = new BinaryObjectReaderEx(in_stream, StreamOwnership.Retain, Endianness);
+
+            mrabReader.CheckSignature(_signature);
+
+            var binaStart = mrabReader.Read<uint>();
+            var binaLength = mrabReader.Read<uint>();
+
+            var binaReader = new BINAReader(in_stream, binaStart);
+
+            Endianness = binaReader.Endianness;
+
+            var abdaStart = binaReader.Read<uint>();
+            var abrsStart = binaReader.Read<uint>();
+
+            binaReader.JumpTo(binaReader.Offset + BINAHeader.Size + abdaStart);
+
+            Archive = new AcroartsBinaryArchive(binaReader);
+
+            binaReader.JumpTo(binaReader.Offset + BINAHeader.Size + abrsStart);
+        }
+    }
+}

Marathon/Formats/Acroarts/Chunks/AcroartsBinaryArchive.cs

@@ -0,0 +1,69 @@
+using Amicitia.IO.Binary;
+using Marathon.Exceptions;
+using Marathon.Formats.Acroarts.Types;
+using Marathon.IO.Types.BINA;
+using System.Collections.Generic;
+
+namespace Marathon.Formats.Acroarts.Chunks
+{
+    public class AcroartsBinaryArchive : IChunk
+    {
+        public const string ID = "ABDA"; // "Acroarts Binary Archive" (speculatory)
+
+        public List<AcroartsBinaryData> Data { get; set; } = new();
+
+        public AcroartsBinaryArchive() { }
+
+        public AcroartsBinaryArchive(BINAReader in_reader)
+        {
+            Read(in_reader);
+        }
+
+        public void Read(BINAReader in_reader)
+        {
+            var DefaultPosition = 0x50;
+
+            var header = in_reader.ReadObject<ChunkHeader>();
+            /*
+            if (!header.ID.Equals(GetChunkID()))
+                throw new InvalidSignatureException(GetChunkID(), header.ID);
+            */
+
+            var version = in_reader.Read<uint>();
+
+            if (version != AckResource.Version)
+                throw new InvalidSignatureException(AckResource.Version, version);
+
+            var abdtChunkCount = in_reader.Read<uint>();
+            var abdaChunkLength = in_reader.Read<uint>();
+            var unkField1 = in_reader.Read<uint>();
+
+            List<uint> abdtChunkOffsets = new();
+
+            for (int i = 0; i < abdtChunkCount; i++)
+            {
+                //64 bit pointer, 32 bit part only
+                var abdtChunkOffset = in_reader.Read<uint>();
+                in_reader.Skip(4);
+                abdtChunkOffsets.Add(abdtChunkOffset);
+            }
+
+            for (int i = 0; i < abdtChunkCount; i++)
+            {
+                var offsetBinaryData = abdtChunkOffsets[i] + DefaultPosition;
+                in_reader.JumpTo(offsetBinaryData);
+                Data.Add(new AcroartsBinaryData(in_reader));
+            }
+        }
+
+        public void Write(BINAWriter in_writer)
+        {
+            // TODO
+        }
+
+        public virtual string GetChunkID()
+        {
+            return ID;
+        }
+    }
+}

Marathon/Formats/Acroarts/Chunks/AcroartsBinaryBranch.cs

@@ -0,0 +1,41 @@
+using Amicitia.IO.Binary;
+using Marathon.Exceptions;
+using Marathon.Formats.Acroarts.Types;
+using Marathon.Helpers;
+using Marathon.IO.Types.BINA;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Marathon.Formats.Acroarts.Chunks
+{
+    public class AcroartsBinaryBranch : INode
+    {
+        public List<byte> Data { get; set; }
+        public List<AcroartsBinaryLeaf> Leafs { get; set; } = new();
+        public AcroartsBinaryBranch() { }
+
+        public AcroartsBinaryBranch(BINAReader in_reader)
+        {
+            Read(in_reader);
+        }
+
+        public void Read(BINAReader in_reader)
+        {
+            var DefaultOffset = 0x50; // Should Use Offset Of Binary Archive
+            Data = in_reader.ReadArray<byte>(0x44).ToList();
+            var leafCount = in_reader.Read<uint>();
+            var leafOffsets = in_reader.ReadArrayAtOffset<uint>(in_reader.Read<uint>() + DefaultOffset, (int)leafCount);
+            for (int i = 0; i < leafCount; i++)
+            {
+                var leafOffset = leafOffsets[i] + DefaultOffset;
+                in_reader.JumpTo(leafOffset);
+                Leafs.Add(new AcroartsBinaryLeaf(in_reader));
+            }
+        }
+
+        public void Write(BINAWriter in_writer)
+        {
+            // TODO
+        }
+    }
+}