Merge pull request #102 from Kamzik123/tyres

Added Tyres.bin xml support

Mafia2Libs/Core/IO/FileBin.cs

@@ -4,6 +4,7 @@
 using ResourceTypes.Navigation;
 using ResourceTypes.SDSConfig;
 using ResourceTypes.Sound;
+using ResourceTypes.Tyres;
 using System.IO;
 using System.Windows.Forms;
 
@@ -19,6 +20,7 @@ public class FileBin : FileBase
         private const uint ShopMenu2Magic = 0x73686D32;
         private const uint CGameMagic = 0x676D7072;
         private const uint EntityActivatorMagic = 0x656E7461;
+        private const uint TyresMagic = 0x12345678;
 
         public FileBin(FileInfo info) : base(info) { }
 
@@ -72,6 +74,22 @@ public override bool Open()
                 data.ReadFromFile(file);
                 return true;
             }
+            else if(CheckFileMagic(file, TyresMagic))
+            {
+                SaveFileDialog saveFile = new SaveFileDialog()
+                {
+                    InitialDirectory = Path.GetDirectoryName(file.FullName),
+                    FileName = Path.GetFileNameWithoutExtension(file.FullName),
+                    Filter = "XML (*.xml)|*.xml"
+                };
+
+                if (saveFile.ShowDialog() == DialogResult.OK)
+                {
+                    // Unsure on how we should handle this. For now we will just try and hope the loader works.
+                    Tyres loader = new Tyres(file);
+                    loader.ConvertToXML(saveFile.FileName);
+                }
+            }
             else
             {
                 SaveFileDialog saveFile = new SaveFileDialog()
@@ -94,20 +112,41 @@ public override bool Open()
 
         public override void Save()
         {
-            OpenFileDialog openFile = new OpenFileDialog()
+            if (CheckFileMagic(file, TyresMagic))
             {
-                InitialDirectory = Path.GetDirectoryName(file.FullName),
-                FileName = Path.GetFileNameWithoutExtension(file.FullName),
-                Filter = "XML (*.xml)|*.xml"
-            };
+                OpenFileDialog openFile = new OpenFileDialog()
+                {
+                    InitialDirectory = Path.GetDirectoryName(file.FullName),
+                    FileName = Path.GetFileNameWithoutExtension(file.FullName),
+                    Filter = "XML (*.xml)|*.xml"
+                };
+
+                if (openFile.ShowDialog() == DialogResult.OK)
+                {
+                    Tyres loader = new Tyres(file);
+                    loader.ConvertFromXML(openFile.FileName);
 
-            if (openFile.ShowDialog() == DialogResult.OK)
+                    File.Copy(file.FullName, file.FullName + "_old", true);
+                    loader.WriteToFile(file.FullName);
+                }
+            }
+            else
             {
-                SoundSectorResource loader = new SoundSectorResource(file);
-                loader.ConvertFromXML(openFile.FileName);
+                OpenFileDialog openFile = new OpenFileDialog()
+                {
+                    InitialDirectory = Path.GetDirectoryName(file.FullName),
+                    FileName = Path.GetFileNameWithoutExtension(file.FullName),
+                    Filter = "XML (*.xml)|*.xml"
+                };
 
-                File.Copy(file.FullName, file.FullName + "_old", true);
-                loader.WriteToFile(file.FullName, false);
+                if (openFile.ShowDialog() == DialogResult.OK)
+                {
+                    SoundSectorResource loader = new SoundSectorResource(file);
+                    loader.ConvertFromXML(openFile.FileName);
+
+                    File.Copy(file.FullName, file.FullName + "_old", true);
+                    loader.WriteToFile(file.FullName, false);
+                }
             }
         }
 

Mafia2Libs/ResourceTypes/FileTypes/Tyres/Tyre.cs

@@ -0,0 +1,45 @@
+using System.IO;
+using Utils.Extensions;
+using Utils.Helpers.Reflection;
+
+namespace ResourceTypes.Tyres
+{
+    [PropertyClassAllowReflection]
+    public class Tyre
+    {
+        public string Name { get; set; }
+        public TyreCondition[] Conditions { get; set; } = new TyreCondition[0];
+        public Tyre()
+        {
+
+        }
+
+        public Tyre(MemoryStream stream)
+        {
+            Read(stream);
+        }
+
+        public void Read(MemoryStream stream)
+        {
+            Name = stream.ReadStringBuffer(4, true);
+            int Count = stream.ReadInt32(false);
+            Conditions = new TyreCondition[Count];
+
+            for (int i = 0; i < Conditions.Length; i++)
+            {
+                Conditions[i] = new(stream);
+            }
+        }
+
+        public void Write(MemoryStream stream, bool isBigEndian)
+        {
+            stream.WriteStringBuffer(4, Name);
+            stream.Write(Conditions.Length, isBigEndian);
+
+            foreach (var condition in Conditions)
+            {
+                condition.Write(stream, isBigEndian);
+            }
+        }
+    }
+}

Mafia2Libs/ResourceTypes/FileTypes/Tyres/TyreCondition.cs

@@ -0,0 +1,45 @@
+using System.IO;
+using Utils.Extensions;
+using Utils.Helpers.Reflection;
+
+namespace ResourceTypes.Tyres
+{
+    [PropertyClassAllowReflection]
+    public class TyreCondition
+    {
+        public string Name { get; set; }
+        public TyreSettings[] Settings { get; set; } = new TyreSettings[0];
+        public TyreCondition()
+        {
+
+        }
+
+        public TyreCondition(MemoryStream stream)
+        {
+            Read(stream);
+        }
+
+        public void Read(MemoryStream stream)
+        {
+            Name = stream.ReadStringBuffer(8, true);
+            int Count = stream.ReadInt32(false);
+            Settings = new TyreSettings[Count];
+
+            for (int i = 0; i < Settings.Length; i++)
+            {
+                Settings[i] = new(stream);
+            }
+        }
+
+        public void Write(MemoryStream stream, bool isBigEndian)
+        {
+            stream.WriteStringBuffer(8, Name);
+            stream.Write(Settings.Length, isBigEndian);
+
+            foreach (var setting in Settings)
+            {
+                setting.Write(stream, isBigEndian);
+            }
+        }
+    }
+}

Mafia2Libs/ResourceTypes/FileTypes/Tyres/TyreSettings.cs

@@ -0,0 +1,107 @@
+using System.IO;
+using Utils.Extensions;
+using Utils.Helpers.Reflection;
+
+namespace ResourceTypes.Tyres
+{
+    [PropertyClassAllowReflection]
+    public class TyreSettings
+    {
+        public int Index { get; set; }
+        public float Unk00 { get; set; }
+        public float Unk01 { get; set; }
+        public float Unk02 { get; set; }
+        public float Unk03 { get; set; }
+        public float Unk04 { get; set; }
+        public float Unk05 { get; set; }
+        public float Unk06 { get; set; }
+        public float Unk07 { get; set; }
+        public float Unk08 { get; set; }
+        public float Unk09 { get; set; }
+        public float Unk10 { get; set; }
+        public float Unk11 { get; set; }
+        public float Unk12 { get; set; }
+        public float Unk13 { get; set; }
+        public float Unk14 { get; set; }
+        public float Unk15 { get; set; }
+        public float Unk16 { get; set; }
+        public float Unk17 { get; set; }
+        public float Unk18 { get; set; }
+        public float Unk19 { get; set; }
+        public float Unk20 { get; set; }
+        public float Unk21 { get; set; }
+        public float Unk22 { get; set; }
+        public float Unk23 { get; set; }
+        public float Unk24 { get; set; }
+
+        public TyreSettings()
+        {
+
+        }
+
+        public TyreSettings(MemoryStream stream)
+        {
+            Read(stream);
+        }
+
+        public void Read(MemoryStream stream)
+        {
+            Index = stream.ReadInt32(false);
+            Unk00 = stream.ReadSingle(false);
+            Unk01 = stream.ReadSingle(false);
+            Unk02 = stream.ReadSingle(false);
+            Unk03 = stream.ReadSingle(false);
+            Unk04 = stream.ReadSingle(false);
+            Unk05 = stream.ReadSingle(false);
+            Unk06 = stream.ReadSingle(false);
+            Unk07 = stream.ReadSingle(false);
+            Unk08 = stream.ReadSingle(false);
+            Unk09 = stream.ReadSingle(false);
+            Unk10 = stream.ReadSingle(false);
+            Unk11 = stream.ReadSingle(false);
+            Unk12 = stream.ReadSingle(false);
+            Unk13 = stream.ReadSingle(false);
+            Unk14 = stream.ReadSingle(false);
+            Unk15 = stream.ReadSingle(false);
+            Unk16 = stream.ReadSingle(false);
+            Unk17 = stream.ReadSingle(false);
+            Unk18 = stream.ReadSingle(false);
+            Unk19 = stream.ReadSingle(false);
+            Unk20 = stream.ReadSingle(false);
+            Unk21 = stream.ReadSingle(false);
+            Unk22 = stream.ReadSingle(false);
+            Unk23 = stream.ReadSingle(false);
+            Unk24 = stream.ReadSingle(false);
+        }
+
+        public void Write(MemoryStream stream, bool isBigEndian)
+        {
+            stream.Write(Index, isBigEndian);
+            stream.Write(Unk00, isBigEndian);
+            stream.Write(Unk01, isBigEndian);
+            stream.Write(Unk02, isBigEndian);
+            stream.Write(Unk03, isBigEndian);
+            stream.Write(Unk04, isBigEndian);
+            stream.Write(Unk05, isBigEndian);
+            stream.Write(Unk06, isBigEndian);
+            stream.Write(Unk07, isBigEndian);
+            stream.Write(Unk08, isBigEndian);
+            stream.Write(Unk09, isBigEndian);
+            stream.Write(Unk10, isBigEndian);
+            stream.Write(Unk11, isBigEndian);
+            stream.Write(Unk12, isBigEndian);
+            stream.Write(Unk13, isBigEndian);
+            stream.Write(Unk14, isBigEndian);
+            stream.Write(Unk15, isBigEndian);
+            stream.Write(Unk16, isBigEndian);
+            stream.Write(Unk17, isBigEndian);
+            stream.Write(Unk18, isBigEndian);
+            stream.Write(Unk19, isBigEndian);
+            stream.Write(Unk20, isBigEndian);
+            stream.Write(Unk21, isBigEndian);
+            stream.Write(Unk22, isBigEndian);
+            stream.Write(Unk23, isBigEndian);
+            stream.Write(Unk24, isBigEndian);
+        }
+    }
+}

Mafia2Libs/ResourceTypes/FileTypes/Tyres/Tyres.cs

@@ -0,0 +1,92 @@
+using System.IO;
+using System.Xml.Linq;
+using Utils.Extensions;
+using Utils.Helpers.Reflection;
+
+namespace ResourceTypes.Tyres
+{
+    public class Tyres
+    {
+        private static uint Magic = 0x12345678;
+        public int Version { get; set; } = 1;
+        public Tyre TyreData { get; set; } = new();
+        public Tyres()
+        {
+
+        }
+        public Tyres(FileInfo InFileInfo)
+        {
+            using (MemoryStream reader = new(File.ReadAllBytes(InFileInfo.FullName)))
+            {
+                Read(reader);
+            }
+        }
+
+        public void Read(MemoryStream stream)
+        {
+            uint _magic = stream.ReadUInt32(false);
+
+            if (_magic != Magic)
+            {
+                throw new System.Exception("Wrong file type.");
+            }
+
+            Version = stream.ReadInt32(false);
+            int initBlockOffset = stream.ReadInt32(false);
+            int littleEndianBlockOffset = stream.ReadInt32(false);
+            int littleEndianBlockSize = stream.ReadInt32(false);
+            int bigEndianBlockOffset = stream.ReadInt32(false);
+            int bigEndianBlockSize = stream.ReadInt32(false);
+            TyreData = new(new MemoryStream(stream.ReadBytes(littleEndianBlockSize)));
+            //Big endian data is identical to little endian so we just skip reading it
+        }
+
+        public void WriteToFile(string fileName)
+        {
+            using (MemoryStream ms = new())
+            {
+                Write(ms);
+                File.WriteAllBytes(fileName, ms.ToArray());
+            }
+        }
+
+        public void Write(MemoryStream stream)
+        {
+            stream.Write(Magic, false);
+            stream.Write(Version, false);
+            stream.Write(28, false);
+            stream.Write(28, false);
+
+            using (MemoryStream ms = new())
+            {
+                TyreData.Write(ms, false);
+                stream.Write((int)ms.Length, false);
+                stream.Write((int)(ms.Length + 28), false);
+                stream.Write((int)ms.Length, false);
+                stream.Write(ms.ToArray());
+            }
+
+            using (MemoryStream ms = new())
+            {
+                TyreData.Write(ms, true);
+                stream.Write(ms.ToArray());
+            }
+        }
+
+        public void ConvertToXML(string Filename)
+        {
+            XElement Root = ReflectionHelpers.ConvertPropertyToXML(this);
+            Root.Save(Filename);
+        }
+
+        public void ConvertFromXML(string Filename)
+        {
+            XElement LoadedDoc = XElement.Load(Filename);
+            Tyres FileContents = ReflectionHelpers.ConvertToPropertyFromXML<Tyres>(LoadedDoc);
+
+            // Copy data taken from loaded XML
+            Version = FileContents.Version;
+            TyreData = FileContents.TyreData;
+        }
+    }
+}