Release v4.

- Fixes remaining ProjectX issues and failing tests.
- Relaxes dependencies on other libraries.

src/build.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  
   <!-- Metadata -->
   <PropertyGroup>
     <Authors>Syroot</Authors>
@@ -10,6 +11,7 @@
     <PackageLicenseExpression>MIT</PackageLicenseExpression>
     <PackageProjectUrl>https://gitlab.com/Syroot/Worms</PackageProjectUrl>
     <PackageTags>team17;worms</PackageTags>
+    <RepositoryUrl>https://gitlab.com/Syroot/Worms</RepositoryUrl>
   </PropertyGroup>
   <ItemGroup>
     <None Include="$(MSBuildThisFileDirectory)..\res\icon.png" Pack="true" PackagePath="" />
@@ -33,4 +35,5 @@
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
   </PropertyGroup>
+  
 </Project>

src/library/Syroot.Worms.Armageddon.ProjectX/Actions/ActionConverter.cs

@@ -8,6 +8,7 @@ namespace Syroot.Worms.Armageddon.ProjectX
     {
         // ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
 
+        /// <inheritdoc/>
         public object? Read(Stream stream, object instance, BinaryMemberAttribute memberAttribute,
             ByteConverter byteConverter)
         {
@@ -15,19 +16,19 @@ namespace Syroot.Worms.Armageddon.ProjectX
             {
                 LauncherStyle launcherStyle => launcherStyle.ExplosionAction,
                 ClusterTarget clusterTarget => clusterTarget.ExplosionAction,
-                _ => throw new NotImplementedException(),
+                _ => throw new NotImplementedException()
             };
             return explosionAction switch
             {
-                ExplosionAction.None => null,
-                ExplosionAction.Bounce => stream.ReadObject<BounceAction>(),
-                ExplosionAction.Dig => stream.ReadObject<DigAction>(),
                 ExplosionAction.Home => stream.ReadObject<HomeAction>(),
+                ExplosionAction.Bounce => stream.ReadObject<BounceAction>(),
                 ExplosionAction.Roam => stream.ReadObject<RoamAction>(),
-                _ => throw new NotImplementedException(),
+                ExplosionAction.Dig => stream.ReadObject<DigAction>(),
+                _ => null
             };
         }
 
+        /// <inheritdoc/>
         public void Write(Stream stream, object instance, BinaryMemberAttribute memberAttribute, object value,
             ByteConverter byteConverter)
         {

src/library/Syroot.Worms.Armageddon.ProjectX/CollisionFlags.cs

@@ -1,12 +1,11 @@
 using System;
-using Syroot.BinaryData;
 
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     [Flags]
     public enum CollisionFlags : int
     {
-        None = 0,
+        None,
         Unused0 = 1 << 0,
         Terrain = 1 << 1,
         WormsOnTerrain = 1 << 2,

src/library/Syroot.Worms.Armageddon.ProjectX/Library.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.IO;
@@ -13,13 +14,17 @@ namespace Syroot.Worms.Armageddon.ProjectX
     /// Represents a library stored in a PXL file which contains reusable weapons, files and scripts.
     /// Used by WA PX. S. https://worms2d.info/Project_X/Library_file.
     /// </summary>
-    public class Library : List<LibraryItem>, ILoadableFile, ISaveableFile
+    public class Library : IList<LibraryItem>, ILoadableFile, ISaveableFile
     {
         // ---- CONSTANTS ----------------------------------------------------------------------------------------------
 
         private const int _signature = 0x1BCD0102;
         private const byte _version = 0x00;
 
+        // ---- FIELDS -------------------------------------------------------------------------------------------------
+
+        private readonly List<LibraryItem> _list = new List<LibraryItem>();
+
         // ---- CONSTRUCTORS & DESTRUCTOR ------------------------------------------------------------------------------
 
         /// <summary>
@@ -42,8 +47,17 @@ namespace Syroot.Worms.Armageddon.ProjectX
 
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
+        /// <inheritdoc/>
+        public int Count => _list.Count;
+
+        /// <summary>
+        /// Gets or sets the ProjectX library version.
+        /// </summary>
         public byte Version { get; set; }
 
+        /// <inheritdoc/>
+        bool ICollection<LibraryItem>.IsReadOnly => false;
+
         // ---- OPERATORS ----------------------------------------------------------------------------------------------
 
         /// <summary>
@@ -53,8 +67,57 @@ namespace Syroot.Worms.Armageddon.ProjectX
         /// <returns>All matching entries.</returns>
         public IEnumerable<LibraryItem> this[string key] => this.Where(x => x.Key == key);
 
+        /// <inheritdoc/>
+        public LibraryItem this[int index]
+        {
+            get => _list[index];
+            set => _list[index] = value;
+        }
+
         // ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
 
+        /// <inheritdoc/>
+        public void Add(LibraryItem item) => _list.Add(item);
+
+        /// <inheritdoc/>
+        public void Clear() => _list.Clear();
+
+        /// <inheritdoc/>
+        public bool Contains(LibraryItem item) => _list.Contains(item);
+
+        /// <inheritdoc/>
+        public void CopyTo(LibraryItem[] array, int arrayIndex) => _list.CopyTo(array, arrayIndex);
+
+        /// <inheritdoc/>
+        public IEnumerator<LibraryItem> GetEnumerator() => _list.GetEnumerator();
+
+        /// <summary>
+        /// Gets all attached files.
+        /// </summary>
+        /// <returns>The enumeration of attached files.</returns>
+        public IEnumerable<byte[]> GetFiles()
+            => this.Where(x => x.Type == LibraryItemType.File).Select(x => (byte[])x.Value);
+
+        /// <summary>
+        /// Gets all attached scripts.
+        /// </summary>
+        /// <returns>The enumeration of attached scripts.</returns>
+        public IEnumerable<string> GetScripts()
+            => this.Where(x => x.Type == LibraryItemType.Script).Select(x => (string)x.Value);
+
+        /// <summary>
+        /// Gets all attached weapons.
+        /// </summary>
+        /// <returns>The enumeration of attached weapons.</returns>
+        public IEnumerable<Weapon> GetWeapons()
+            => this.Where(x => x.Type == LibraryItemType.Weapon).Select(x => (Weapon)x.Value);
+
+        /// <inheritdoc/>
+        public int IndexOf(LibraryItem item) => _list.IndexOf(item);
+
+        /// <inheritdoc/>
+        public void Insert(int index, LibraryItem item) => _list.Insert(index, item);
+
         /// <summary>
         /// Loads the data from the given <see cref="Stream"/>.
         /// </summary>
@@ -71,7 +134,7 @@ namespace Syroot.Worms.Armageddon.ProjectX
                 throw new InvalidDataException("Invalid PXL file version.");
 
             // Read the items.
-            Clear();
+            _list.Clear();
             int itemCount = reader.ReadInt32();
             for (int i = 0; i < itemCount; i++)
             {
@@ -80,13 +143,13 @@ namespace Syroot.Worms.Armageddon.ProjectX
                 switch (type)
                 {
                     case LibraryItemType.File:
-                        Add(new LibraryItem(name, reader.ReadBytes(reader.ReadInt32())));
+                        _list.Add(new LibraryItem(name, reader.ReadBytes(reader.ReadInt32())));
                         break;
                     case LibraryItemType.Script:
-                        Add(new LibraryItem(name, reader.ReadString(StringCoding.Int32CharCount)));
+                        _list.Add(new LibraryItem(name, reader.ReadString(StringCoding.Int32CharCount)));
                         break;
                     case LibraryItemType.Weapon:
-                        Add(new LibraryItem(name, reader.Load<Weapon>()));
+                        _list.Add(new LibraryItem(name, reader.Load<Weapon>()));
                         break;
                 }
             }
@@ -102,6 +165,12 @@ namespace Syroot.Worms.Armageddon.ProjectX
             Load(stream);
         }
 
+        /// <inheritdoc/>
+        public bool Remove(LibraryItem item) => _list.Remove(item);
+
+        /// <inheritdoc/>
+        public void RemoveAt(int index) => _list.RemoveAt(index);
+
         /// <summary>
         /// Saves the data into the given <paramref name="stream"/>.
         /// </summary>
@@ -116,7 +185,7 @@ namespace Syroot.Worms.Armageddon.ProjectX
 
             // Write the items.
             writer.Write(Count);
-            foreach (LibraryItem item in this)
+            foreach (LibraryItem item in _list)
             {
                 writer.WriteEnum(item.Type, true);
                 writer.Write(item.Key, StringCoding.Int32CharCount);
@@ -147,26 +216,13 @@ namespace Syroot.Worms.Armageddon.ProjectX
             Save(stream);
         }
 
-        /// <summary>
+        // ---- METHODS ------------------------------------------------------------------------------------------------
-        /// Gets all attached files.
-        /// </summary>
-        /// <returns>The enumeration of attached files.</returns>
-        public IEnumerable<byte[]> GetFiles()
-            => this.Where(x => x.Type == LibraryItemType.File).Select(x => (byte[])x.Value);
 
-        /// <summary>
+        /// <inheritdoc/>
-        /// Gets all attached scripts.
+        IEnumerator IEnumerable.GetEnumerator()
-        /// </summary>
+        {
-        /// <returns>The enumeration of attached scripts.</returns>
+            return ((IEnumerable)_list).GetEnumerator();
-        public IEnumerable<string> GetScripts()
+        }
-            => this.Where(x => x.Type == LibraryItemType.Script).Select(x => (string)x.Value);
-
-        /// <summary>
-        /// Gets all attached weapons.
-        /// </summary>
-        /// <returns>The enumeration of attached weapons.</returns>
-        public IEnumerable<Weapon> GetWeapons()
-            => this.Where(x => x.Type == LibraryItemType.Weapon).Select(x => (Weapon)x.Value);
     }
 
     /// <summary>
@@ -232,19 +288,11 @@ namespace Syroot.Worms.Armageddon.ProjectX
     /// </summary>
     public enum LibraryItemType : byte
     {
-        /// <summary>
+        /// <summary>The entry is a raw file in form of a byte array.</summary>
-        /// The entry is a raw file in form of a byte array.
-        /// </summary>
         File = 2,
-
+        /// <summary>The entry is a script in form of a string.</summary>
-        /// <summary>
-        /// The entry is a script in form of a string.
-        /// </summary>
         Script = 4,
-
+        /// <summary>The entry is a weapon in form of a <see cref="Weapon"/> instance.</summary>
-        /// <summary>
-        /// The entry is a weapon in form of a <see cref="Weapon"/> instance.
-        /// </summary>
         Weapon = 8
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Mine.cs

@@ -1,21 +1,17 @@
-using System.Runtime.InteropServices;
+using Syroot.BinaryData;
 
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public struct Mine
     {
-        public int Sensitivity;
+        // ---- FIELDS -------------------------------------------------------------------------------------------------
 
-        public int TimeBeforeOn;
+        [BinaryMember(Order = 1)] public int Sensitivity;
-
+        [BinaryMember(Order = 2)] public int TimeBeforeOn;
-        public CollisionFlags SensitiveTo;
+        [BinaryMember(Order = 3)] public CollisionFlags SensitiveTo;
-
+        [BinaryMember(Order = 4)] public int FuseTime;
-        public int FuseTime;
+        [BinaryMember(Order = 5)] public int ExplosionBias;
-
+        [BinaryMember(Order = 6)] public int ExplosionPower;
-        public int ExplosionBias;
+        [BinaryMember(Order = 7)] public int MaxDamage;
-
-        public int ExplosionPower;
-
-        public int MaxDamage;
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Scheme.cs

@@ -110,10 +110,16 @@ namespace Syroot.Worms.Armageddon.ProjectX
             // Read a possibly attached scheme file.
             if (reader.ReadBoolean())
             {
-                reader.Seek(sizeof(int)); // Scheme length not required due to intelligent loading.
+                byte[] schemeData = reader.ReadBytes(reader.ReadInt32());
-                GameScheme = reader.Load<Armageddon.Scheme>();
+                using MemoryStream schemeStream = new MemoryStream(schemeData);
+                GameScheme = schemeStream.Load<Armageddon.Scheme>();
                 GameSchemeName = reader.ReadString(StringCoding.Int32CharCount);
             }
+            else
+            {
+                GameScheme = null;
+                GameSchemeName = String.Empty;
+            }
         }
 
         /// <inheritdoc/>
@@ -163,20 +169,24 @@ namespace Syroot.Worms.Armageddon.ProjectX
 
             // Write required libraries.
             writer.Write(Libraries.Count);
-            writer.Write(Libraries);
+            writer.Write(Libraries, StringCoding.Int32CharCount);
 
             // Write a possibly attached scheme file.
             if (GameScheme != null)
             {
-                byte[] schemeBytes;
+                writer.Write(true);
-                using (MemoryStream schemeStream = new MemoryStream())
+                using MemoryStream schemeStream = new MemoryStream();
-                {
+                GameScheme.Save(schemeStream);
-                    GameScheme.Save(schemeStream);
+
-                    schemeBytes = schemeStream.ToArray();
+                writer.Write((int)schemeStream.Position);
-                }
+                schemeStream.Position = 0;
-                writer.Write(schemeBytes.Length);
+                schemeStream.CopyTo(writer);
                 writer.Write(GameSchemeName, StringCoding.Int32CharCount);
             }
+            else
+            {
+                writer.Write(false);
+            }
         }
 
         /// <inheritdoc/>

src/library/Syroot.Worms.Armageddon.ProjectX/SchemeFlags.cs

@@ -8,49 +8,22 @@ namespace Syroot.Worms.Armageddon.ProjectX
     [StructLayout(LayoutKind.Sequential)]
     public struct SchemeFlags
     {
-        [MarshalAs(UnmanagedType.I1)]
+        // ---- FIELDS -------------------------------------------------------------------------------------------------
+
         public bool CyclicMaps;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool UnderwaterJetpack;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool UnderwaterRope;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool Unused1;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool Unused2;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool Unused3;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool Unused4;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool Unused5;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool Unused6;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool Unused7;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool Unused8;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool ShotDoesntEndTurn;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool LoseControlDoesntEndTurn;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool FiringPausesTimer;
-
-        [MarshalAs(UnmanagedType.I1)]
         public bool EnableSchemePowers;
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Sound.cs

@@ -4,16 +4,12 @@ namespace Syroot.Worms.Armageddon.ProjectX
 {
     public struct Sound
     {
-        public short SoundIndex;
+        // ---- FIELDS -------------------------------------------------------------------------------------------------
 
-        [BinaryMember(BooleanCoding = BooleanCoding.Word)]
+        [BinaryMember(Order = 1)] public ushort SoundIndex;
-        public bool RepeatSound;
+        [BinaryMember(Order = 2, BooleanCoding = BooleanCoding.Word)] public bool RepeatSound;
-
+        [BinaryMember(Order = 3, BooleanCoding = BooleanCoding.Dword)] public bool UseExplosionSound;
-        [BinaryMember(BooleanCoding = BooleanCoding.Dword)]
+        [BinaryMember(Order = 4)] public int SoundBeforeExplosion;
-        public bool UseExplosionSound;
+        [BinaryMember(Order = 5)] public int DelayBeforeExplosion;
-        
-        public int SoundBeforeExplosion;
-        
-        public int DelayBeforeExplosion;
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Sprite.cs

@@ -1,20 +1,17 @@
-using System.Runtime.InteropServices;
+using Syroot.BinaryData;
 
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public struct Sprite
     {
-        public int SpriteNumber;
+        // ---- FIELDS -------------------------------------------------------------------------------------------------
 
-        public SpriteAnimationType AnimationType;
+        [BinaryMember(Order = 1)] public int SpriteNumber;
-
+        [BinaryMember(Order = 2)] public SpriteAnimationType AnimationType;
-        public int TrailSprite;
+        [BinaryMember(Order = 3)] public int TrailSprite;
-
+        [BinaryMember(Order = 4)] public int TrailAmount;
-        public int TrailAmount;
+        [BinaryMember(Order = 5)] public int TrailVanishSpeed;
-
+        [BinaryMember(Order = 6)] public int Unknown;
-        public int TrailVanishSpeed;
-
-        public int Unknown;
     }
 
     public enum SpriteAnimationType : int

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/AirstrikeStyle.cs

@@ -6,20 +6,19 @@ namespace Syroot.Worms.Armageddon.ProjectX
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int PlaneSprite;
+        [BinaryMember(Order = 1)] public int PlaneSprite;
 
-        public int BombsCount;
+        [BinaryMember(Order = 2)] public int BombsCount;
 
-        public int DropDistance;
+        [BinaryMember(Order = 3)] public int DropDistance;
 
-        public int HorizontalSpeed;
+        [BinaryMember(Order = 4)] public int HorizontalSpeed;
 
-        public int Sound;
+        [BinaryMember(Order = 5)] public int Sound;
 
-        public WeaponAirstrikeSubstyle AirstrikeSubstyle;
+        [BinaryMember(Order = 6)] public WeaponAirstrikeSubstyle AirstrikeSubstyle;
 
-        [BinaryMember(Converter = typeof(AirstrikeSubstyleConverter))]
+        [BinaryMember(Order = 7, Converter = typeof(AirstrikeSubstyleConverter))] public IStyle? Style;
-        public IStyle? Style;
     }
 
     public enum WeaponAirstrikeSubstyle : int

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/AirstrikeSubstyleConverter.cs

@@ -8,7 +8,8 @@ namespace Syroot.Worms.Armageddon.ProjectX
     {
         // ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
 
-        public object Read(Stream stream, object instance, BinaryMemberAttribute memberAttribute,
+        /// <inheritdoc/>
+        public object? Read(Stream stream, object instance, BinaryMemberAttribute memberAttribute,
             ByteConverter byteConverter)
         {
             WeaponAirstrikeSubstyle airstrikeSubstyle = instance switch
@@ -18,12 +19,13 @@ namespace Syroot.Worms.Armageddon.ProjectX
             };
             return airstrikeSubstyle switch
             {
-                WeaponAirstrikeSubstyle.Launcher => stream.ReadObject<LauncherStyle>(),
                 WeaponAirstrikeSubstyle.Mines => stream.ReadObject<MineStyle>(),
-                _ => throw new NotImplementedException(),
+                WeaponAirstrikeSubstyle.Launcher => stream.ReadObject<LauncherStyle>(),
+                _ => null
             };
         }
 
+        /// <inheritdoc/>
         public void Write(Stream stream, object instance, BinaryMemberAttribute memberAttribute, object value,
             ByteConverter byteConverter)
         {

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/BaseballBatStyle.cs

@@ -1,11 +1,13 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class BaseballBatStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int Damage { get; set; }
+        [BinaryMember(Order = 1)] public int Damage { get; set; }
 
-        public int PushPower { get; set; }
+        [BinaryMember(Order = 2)] public int PushPower { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/BattleAxeStyle.cs

@@ -1,9 +1,11 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class BattleAxeStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int PercentualDamage { get; set; }
+        [BinaryMember(Order = 1)] public int PercentualDamage { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/BlowtorchStyle.cs

@@ -1,15 +1,17 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class BlowtorchStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int Damage { get; set; }
+        [BinaryMember(Order = 1)] public int Damage { get; set; }
 
-        public int PushPower { get; set; }
+        [BinaryMember(Order = 2)] public int PushPower { get; set; }
 
-        public int ImpactAngle { get; set; }
+        [BinaryMember(Order = 3)] public int ImpactAngle { get; set; }
 
-        public int TunellingTime { get; set; }
+        [BinaryMember(Order = 4)] public int TunellingTime { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/BowStyle.cs

@@ -1,9 +1,11 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class BowStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int Damage { get; set; }
+        [BinaryMember(Order = 1)] public int Damage { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/CanisterStyle.cs

@@ -1,15 +1,17 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class CanisterStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int SpriteInactive { get; set; }
+        [BinaryMember(Order = 1)] public int SpriteInactive { get; set; }
 
-        public int SpriteActive { get; set; }
+        [BinaryMember(Order = 2)] public int SpriteActive { get; set; }
 
-        public int DiseasePoints { get; set; }
+        [BinaryMember(Order = 3)] public int DiseasePoints { get; set; }
 
-        public int MaxDamage { get; set; }
+        [BinaryMember(Order = 4)] public int MaxDamage { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/DragonballStyle.cs

@@ -1,21 +1,23 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class DragonballStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int FiringSound { get; set; }
+        [BinaryMember(Order = 1)] public int FiringSound { get; set; }
 
-        public int ImpactSound { get; set; }
+        [BinaryMember(Order = 2)] public int ImpactSound { get; set; }
 
-        public int BallSprite { get; set; }
+        [BinaryMember(Order = 3)] public int BallSprite { get; set; }
 
-        public int Damage { get; set; }
+        [BinaryMember(Order = 4)] public int Damage { get; set; }
 
-        public int Angle { get; set; }
+        [BinaryMember(Order = 5)] public int Angle { get; set; }
 
-        public int Force { get; set; }
+        [BinaryMember(Order = 6)] public int Force { get; set; }
 
-        public int BallTime { get; set; }
+        [BinaryMember(Order = 7)] public int BallTime { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/FirepunchStyle.cs

@@ -1,15 +1,17 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class FirepunchStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int Damage { get; set; }
+        [BinaryMember(Order = 1)] public int Damage { get; set; }
 
-        public int Angle { get; set; }
+        [BinaryMember(Order = 2)] public int Angle { get; set; }
 
-        public int PushPower { get; set; }
+        [BinaryMember(Order = 3)] public int PushPower { get; set; }
 
-        public int JumpHeight { get; set; }
+        [BinaryMember(Order = 4)] public int JumpHeight { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/FlamethrowerStyle.cs

@@ -6,15 +6,14 @@ namespace Syroot.Worms.Armageddon.ProjectX
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int FuelAmount { get; set; }
+        [BinaryMember(Order = 1)] public int FuelAmount { get; set; }
 
-        public int FireIntensity { get; set; }
+        [BinaryMember(Order = 2)] public int FireIntensity { get; set; }
 
-        public int FireAmount { get; set; }
+        [BinaryMember(Order = 3)] public int FireAmount { get; set; }
 
-        public int FireBurnTime { get; set; }
+        [BinaryMember(Order = 4)] public int FireBurnTime { get; set; }
 
-        [BinaryMember(BooleanCoding = BooleanCoding.Dword)]
+        [BinaryMember(Order = 5, BooleanCoding = BooleanCoding.Dword)] public bool RemainOnTerrain { get; set; }
-        public bool RemainOnTerrain { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/GunStyle.cs

@@ -1,35 +1,37 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class GunStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int BulletCount { get; set; }
+        [BinaryMember(Order = 1)] public int BulletCount { get; set; }
 
-        public int ReloadTime { get; set; }
+        [BinaryMember(Order = 2)] public int ReloadTime { get; set; }
 
-        public int BulletSpread { get; set; }
+        [BinaryMember(Order = 3)] public int BulletSpread { get; set; }
 
-        public int Burst { get; set; }
+        [BinaryMember(Order = 4)] public int Burst { get; set; }
 
-        public int BurstSpread { get; set; }
+        [BinaryMember(Order = 5)] public int BurstSpread { get; set; }
 
-        public CollisionFlags Collisions { get; set; }
+        [BinaryMember(Order = 6)] public CollisionFlags Collisions { get; set; }
 
-        public int ExplosionBias { get; set; }
+        [BinaryMember(Order = 7)] public int ExplosionBias { get; set; }
 
-        public int ExplosionPower { get; set; }
+        [BinaryMember(Order = 8)] public int ExplosionPower { get; set; }
 
-        public int MaxDamage { get; set; }
+        [BinaryMember(Order = 9)] public int MaxDamage { get; set; }
 
-        public int DamageSpread { get; set; }
+        [BinaryMember(Order = 10)] public int DamageSpread { get; set; }
 
-        public int ExpEffect { get; set; }
+        [BinaryMember(Order = 11)] public int ExpEffect { get; set; }
 
-        public int Range1 { get; set; }
+        [BinaryMember(Order = 12)] public int Range1 { get; set; }
 
-        public int Range2 { get; set; }
+        [BinaryMember(Order = 13)] public int Range2 { get; set; }
 
-        public int Range3 { get; set; }
+        [BinaryMember(Order = 14)] public int Range3 { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/JetpackStyle.cs

@@ -1,9 +1,11 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class JetpackStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int Fuel { get; set; }
+        [BinaryMember(Order = 1)] public int Fuel { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/KamikazeStyle.cs

@@ -1,19 +1,21 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class KamikazeStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int FlyingTime { get; set; }
+        [BinaryMember(Order = 1)] public int FlyingTime { get; set; }
 
-        public int ExplosionDamage { get; set; }
+        [BinaryMember(Order = 2)] public int ExplosionDamage { get; set; }
 
-        public int FireSound { get; set; }
+        [BinaryMember(Order = 3)] public int FireSound { get; set; }
 
-        public int Damage { get; set; }
+        [BinaryMember(Order = 4)] public int Damage { get; set; }
 
-        public int ImpactForce { get; set; }
+        [BinaryMember(Order = 5)] public int ImpactForce { get; set; }
 
-        public int ImpactAngle { get; set; }
+        [BinaryMember(Order = 6)] public int ImpactAngle { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/LauncherStyle.cs

@@ -6,53 +6,50 @@ namespace Syroot.Worms.Armageddon.ProjectX
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int SpriteSize { get; set; }
+        [BinaryMember(Order = 1)] public int SpriteSize { get; set; }
 
-        public int FixedSpeed { get; set; }
+        [BinaryMember(Order = 2)] public int FixedSpeed { get; set; }
 
-        [BinaryMember(BooleanCoding = BooleanCoding.Dword)]
+        [BinaryMember(Order = 3, BooleanCoding = BooleanCoding.Dword)] public bool RunAway { get; set; }
-        public bool RunAway { get; set; }
 
-        public CollisionFlags Collisions { get; set; }
+        [BinaryMember(Order = 4)] public CollisionFlags Collisions { get; set; }
 
-        public int ExplosionBias { get; set; }
+        [BinaryMember(Order = 5)] public int ExplosionBias { get; set; }
 
-        public int ExplosionPushPower { get; set; }
+        [BinaryMember(Order = 6)] public int ExplosionPushPower { get; set; }
 
-        public int ExplosionDamage { get; set; }
+        [BinaryMember(Order = 7)] public int ExplosionDamage { get; set; }
 
-        public int ExplosionDamageVariation { get; set; }
+        [BinaryMember(Order = 8)] public int ExplosionDamageVariation { get; set; }
 
-        public int ExplosionUnknown { get; set; }
+        [BinaryMember(Order = 9)] public int ExplosionUnknown { get; set; }
 
-        public Sprite Sprite { get; set; }
+        [BinaryMember(Order = 10)] public Sprite Sprite { get; set; }
 
-        public int VariableSpeed { get; set; }
+        [BinaryMember(Order = 11)] public int VariableSpeed { get; set; }
 
-        public int WindFactor { get; set; }
+        [BinaryMember(Order = 12)] public int WindFactor { get; set; }
 
-        public int MotionRandomness { get; set; }
+        [BinaryMember(Order = 13)] public int MotionRandomness { get; set; }
 
-        public int GravityFactor { get; set; }
+        [BinaryMember(Order = 14)] public int GravityFactor { get; set; }
 
-        public int ExplosionCountdown { get; set; }
+        [BinaryMember(Order = 15)] public int ExplosionCountdown { get; set; }
 
-        public int ExplosionTimer { get; set; }
+        [BinaryMember(Order = 16)] public int ExplosionTimer { get; set; }
 
-        public Sound Sound { get; set; }
+        [BinaryMember(Order = 17)] public Sound Sound { get; set; }
 
-        [BinaryMember(BooleanCoding = BooleanCoding.Dword)]
+        [BinaryMember(Order = 18, BooleanCoding = BooleanCoding.Dword)] public bool ExplodeOnSpace { get; set; }
-        public bool ExplodeOnSpace { get; set; }
 
-        public ExplosionAction ExplosionAction { get; set; }
+        [BinaryMember(Order = 19)] public ExplosionAction ExplosionAction { get; set; }
 
-        [BinaryMember(Converter = typeof(ActionConverter))]
+        [BinaryMember(Order = 20, Converter = typeof(ActionConverter))] public IAction? Action { get; set; }
-        public IAction? Action { get; set; }
 
-        [BinaryMember(OffsetOrigin = OffsetOrigin.Begin, Offset = 180)]
+        [BinaryMember(Order = 21, OffsetOrigin = OffsetOrigin.Begin, Offset = 180)]
         public ExplosionTarget ExplosionTarget { get; set; }
 
-        [BinaryMember(Offset = sizeof(int), Converter = typeof(TargetConverter))]
+        [BinaryMember(Order = 22, Offset = sizeof(int), Converter = typeof(TargetConverter))]
         public ITarget? Target { get; set; }
     }
 

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/MineStyle.cs

@@ -1,9 +1,11 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class MineStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public Mine Mine;
+        [BinaryMember(Order = 1)] public Mine Mine;
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/NinjaRopeStyle.cs

@@ -1,13 +1,15 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class NinjaRopeStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int ShotCount { get; set; }
+        [BinaryMember(Order = 1)] public int ShotCount { get; set; }
 
-        public int Length { get; set; }
+        [BinaryMember(Order = 2)] public int Length { get; set; }
 
-        public int AngleRestriction { get; set; }
+        [BinaryMember(Order = 3)] public int AngleRestriction { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/NuclearTestStyle.cs

@@ -1,11 +1,13 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class NuclearTestStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int WaterRise { get; set; }
+        [BinaryMember(Order = 1)] public int WaterRise { get; set; }
 
-        public int DiseasePoints { get; set; }
+        [BinaryMember(Order = 2)] public int DiseasePoints { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/ParachuteStyle.cs

@@ -1,9 +1,11 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class ParachuteStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int WindResponse { get; set; }
+        [BinaryMember(Order = 1)] public int WindResponse { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/PneumaticDrillStyle.cs

@@ -1,15 +1,17 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class PneumaticDrillStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int Damage { get; set; }
+        [BinaryMember(Order = 1)] public int Damage { get; set; }
 
-        public int PushPower { get; set; }
+        [BinaryMember(Order = 2)] public int PushPower { get; set; }
 
-        public int ImpactAngle { get; set; }
+        [BinaryMember(Order = 3)] public int ImpactAngle { get; set; }
 
-        public int TunellingTime { get; set; }
+        [BinaryMember(Order = 4)] public int TunellingTime { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/ProdStyle.cs

@@ -1,13 +1,15 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class ProdStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int Damage { get; set; }
+        [BinaryMember(Order = 1)] public int Damage { get; set; }
 
-        public int Force { get; set; }
+        [BinaryMember(Order = 2)] public int Force { get; set; }
 
-        public int Angle { get; set; }
+        [BinaryMember(Order = 3)] public int Angle { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Styles/SuicideBomberStyle.cs

@@ -1,11 +1,13 @@
+using Syroot.BinaryData;
+
 namespace Syroot.Worms.Armageddon.ProjectX
 {
     public class SuicideBomberStyle : IStyle
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int DiseasePoints { get; set; }
+        [BinaryMember(Order = 1)] public int DiseasePoints { get; set; }
 
-        public int Damage { get; set; }
+        [BinaryMember(Order = 2)] public int Damage { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Syroot.Worms.Armageddon.ProjectX.csproj

@@ -1,5 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)build.xml" />
+  
+  <!-- Metadata -->
   <PropertyGroup>
     <AssemblyName>Syroot.Worms.Armageddon.ProjectX</AssemblyName>
     <Description>.NET library for loading and modifying files of Worms Armageddon ProjectX.</Description>
@@ -7,8 +9,12 @@
     <PackageTags>$(PackageTags);project x;worms armageddon</PackageTags>
     <Version>4.0.0</Version>
   </PropertyGroup>
+  
+  <!-- References -->
   <ItemGroup>
-    <ProjectReference Include="..\Syroot.Worms.Armageddon\Syroot.Worms.Armageddon.csproj" />
+    <PackageReference Include="Syroot.BinaryData.Serialization" Version="5.2.1" />
     <ProjectReference Include="..\Syroot.Worms\Syroot.Worms.csproj" />
+    <ProjectReference Include="..\Syroot.Worms.Armageddon\Syroot.Worms.Armageddon.csproj" />
   </ItemGroup>
+  
 </Project>

src/library/Syroot.Worms.Armageddon.ProjectX/Targets/ClusterTarget.cs

@@ -6,50 +6,48 @@ namespace Syroot.Worms.Armageddon.ProjectX
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int ClusterCount { get; set; }
+        [BinaryMember(Order = 1)] public int ClusterCount { get; set; }
 
-        public int DispersionPower { get; set; }
+        [BinaryMember(Order = 2)] public int DispersionPower { get; set; }
 
-        public int Speed { get; set; }
+        [BinaryMember(Order = 3)] public int Speed { get; set; }
 
-        public int EjectionAngle { get; set; }
+        [BinaryMember(Order = 4)] public int EjectionAngle { get; set; }
 
-        public int DispersionAngle { get; set; }
+        [BinaryMember(Order = 5)] public int DispersionAngle { get; set; }
 
-        public CollisionFlags Collisions { get; set; }
+        [BinaryMember(Order = 6)] public CollisionFlags Collisions { get; set; }
 
-        public int ExplosionBias { get; set; }
+        [BinaryMember(Order = 7)] public int ExplosionBias { get; set; }
 
-        public int ExplosionPushPower { get; set; }
+        [BinaryMember(Order = 8)] public int ExplosionPushPower { get; set; }
 
-        public int ExplosionDamage { get; set; }
+        [BinaryMember(Order = 9)] public int ExplosionDamage { get; set; }
 
-        public int ExplosionDamageVariation { get; set; }
+        [BinaryMember(Order = 10)] public int ExplosionDamageVariation { get; set; }
 
-        public int SpriteCount { get; set; }
+        [BinaryMember(Order = 11)] public int SpriteCount { get; set; }
 
-        public Sprite Sprite { get; set; }
+        [BinaryMember(Order = 12)] public Sprite Sprite { get; set; }
 
-        public int Acceleration { get; set; }
+        [BinaryMember(Order = 13)] public int Acceleration { get; set; }
 
-        public int WindResponse { get; set; }
+        [BinaryMember(Order = 14)] public int WindResponse { get; set; }
 
-        public int MotionRandomness { get; set; }
+        [BinaryMember(Order = 15)] public int MotionRandomness { get; set; }
 
-        public int GravityFactor { get; set; }
+        [BinaryMember(Order = 16)] public int GravityFactor { get; set; }
 
-        public int Unused1 { get; set; }
+        [BinaryMember(Order = 17)] public int Unused1 { get; set; }
 
-        public int Unused2 { get; set; }
+        [BinaryMember(Order = 18)] public int Unused2 { get; set; }
 
-        public Sound Sound { get; set; }
+        [BinaryMember(Order = 19)] public Sound Sound { get; set; }
 
-        [BinaryMember(BooleanCoding = BooleanCoding.Dword)]
+        [BinaryMember(Order = 20, BooleanCoding = BooleanCoding.Dword)] public bool ExplodeOnSpace { get; set; }
-        public bool ExplodeOnSpace { get; set; }
 
-        public ExplosionAction ExplosionAction { get; set; }
+        [BinaryMember(Order = 21)] public ExplosionAction ExplosionAction { get; set; }
 
-        [BinaryMember(Converter = typeof(ActionConverter))]
+        [BinaryMember(Order = 22, Converter = typeof(ActionConverter))] public IAction? Action { get; set; }
-        public IAction? Action { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Targets/FireTarget.cs

@@ -6,13 +6,12 @@ namespace Syroot.Worms.Armageddon.ProjectX
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public int Power { get; set; }
+        [BinaryMember(Order = 1)] public int Power { get; set; }
 
-        public int Spread { get; set; }
+        [BinaryMember(Order = 2)] public int Spread { get; set; }
 
-        public int Time { get; set; }
+        [BinaryMember(Order = 3)] public int Time { get; set; }
 
-        [BinaryMember(BooleanCoding = BooleanCoding.Dword)]
+        [BinaryMember(Order = 4, BooleanCoding = BooleanCoding.Dword)] public bool StayBetweenTurns { get; set; }
-        public bool StayBetweenTurns { get; set; }
     }
 }

src/library/Syroot.Worms.Armageddon.ProjectX/Targets/TargetConverter.cs

@@ -8,6 +8,7 @@ namespace Syroot.Worms.Armageddon.ProjectX
     {
         // ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
 
+        /// <inheritdoc/>
         public object? Read(Stream stream, object instance, BinaryMemberAttribute memberAttribute,
             ByteConverter byteConverter)
         {
@@ -18,13 +19,13 @@ namespace Syroot.Worms.Armageddon.ProjectX
             };
             return explosionTarget switch
             {
-                ExplosionTarget.None => null,
                 ExplosionTarget.Clusters => stream.ReadObject<ClusterTarget>(),
                 ExplosionTarget.Fire => stream.ReadObject<FireTarget>(),
-                _ => throw new NotImplementedException(),
+                _ => null,
             };
         }
 
+        /// <inheritdoc/>
         public void Write(Stream stream, object instance, BinaryMemberAttribute memberAttribute, object value,
             ByteConverter byteConverter)
         {

src/library/Syroot.Worms.Armageddon.ProjectX/Weapon.cs

@@ -12,99 +12,99 @@ namespace Syroot.Worms.Armageddon.ProjectX
     {
         // ---- PROPERTIES ---------------------------------------------------------------------------------------------
 
-        public WeaponVersion Version { get; set; }
+        [BinaryMember(Order = 1)] public WeaponVersion Version { get; set; }
 
-        public long Checksum { get; set; }
+        [BinaryMember(Order = 2)] public long Checksum { get; set; }
 
-        public int TableRow { get; set; }
+        [BinaryMember(Order = 3)] public int TableRow { get; set; }
 
-        public bool Remembered { get; set; }
+        [BinaryMember(Order = 4)] public bool Remembered { get; set; }
 
-        public bool UsableInCavern { get; set; }
+        [BinaryMember(Order = 5)] public bool UsableInCavern { get; set; }
 
-        public int Shots { get; set; }
+        [BinaryMember(Order = 6)] public int Shots { get; set; }
 
-        public bool ShotEndsTurn { get; set; }
+        [BinaryMember(Order = 7)] public bool ShotEndsTurn { get; set; }
 
-        public int RetreatTime { get; set; }
+        [BinaryMember(Order = 8)] public int RetreatTime { get; set; }
 
-        public int Unknown1 { get; set; }
+        [BinaryMember(Order = 9)] public int Unknown1 { get; set; }
 
-        public int CrateChance { get; set; }
+        [BinaryMember(Order = 10)] public int CrateChance { get; set; }
 
-        public int CrateCount { get; set; }
+        [BinaryMember(Order = 11)] public int CrateCount { get; set; }
 
-        public int Unknown2 { get; set; }
+        [BinaryMember(Order = 12)] public int Unknown2 { get; set; }
 
-        public WeaponActivation Activation { get; set; }
+        [BinaryMember(Order = 13)] public WeaponActivation Activation { get; set; }
 
-        public int NotUsed { get; set; }
+        [BinaryMember(Order = 14)] public int NotUsed { get; set; }
 
-        public int ThrowHerdCount { get; set; }
+        [BinaryMember(Order = 15)] public int ThrowHerdCount { get; set; }
 
-        public int AirstrikeSubtype { get; set; }
+        [BinaryMember(Order = 16)] public int AirstrikeSubtype { get; set; }
 
-        public WeaponSpacebarAction SpacebarAction { get; set; }
+        [BinaryMember(Order = 17)] public WeaponSpacebarAction SpacebarAction { get; set; }
 
-        public WeaponCrosshairAction CrosshairAction { get; set; }
+        [BinaryMember(Order = 18)] public WeaponCrosshairAction CrosshairAction { get; set; }
 
-        public WeaponThrowAction ThrowAction { get; set; }
+        [BinaryMember(Order = 19)] public WeaponThrowAction ThrowAction { get; set; }
 
-        public IStyle? Style { get; set; }
+        [BinaryMember(Order = 20)] public IStyle? Style { get; set; }
 
-        public bool AmmunitionOverride { get; set; }
+        [BinaryMember(Order = 21)] public bool AmmunitionOverride { get; set; }
 
-        public int Ammunition { get; set; }
+        [BinaryMember(Order = 22)] public int Ammunition { get; set; }
 
-        public int Unknown3 { get; set; }
+        [BinaryMember(Order = 23)] public int Unknown3 { get; set; }
 
-        public int WeaponSprite { get; set; }
+        [BinaryMember(Order = 24)] public int WeaponSprite { get; set; }
 
-        public string NameLong { get; set; } = String.Empty;
+        [BinaryMember(Order = 25)] public string NameLong { get; set; } = String.Empty;
 
-        public string Name { get; set; } = String.Empty;
+        [BinaryMember(Order = 26)] public string Name { get; set; } = String.Empty;
 
-        public string GridImageFile { get; set; } = String.Empty;
+        [BinaryMember(Order = 27)] public string GridImageFile { get; set; } = String.Empty;
 
-        public string GfxDirectoryFile { get; set; } = String.Empty;
+        [BinaryMember(Order = 28)] public string GfxDirectoryFile { get; set; } = String.Empty;
 
-        public string[] SpriteNames { get; } = new string[5];
+        [BinaryMember(Order = 29)] public string[] SpriteNames { get; } = new string[5];
 
-        public bool DelayOverride { get; set; }
+        [BinaryMember(Order = 30)] public bool DelayOverride { get; set; }
 
-        public int Delay { get; set; }
+        [BinaryMember(Order = 31)] public int Delay { get; set; }
 
-        public bool UseLibrary { get; set; }
+        [BinaryMember(Order = 32)] public bool UseLibrary { get; set; }
 
-        public string LibraryName { get; set; } = String.Empty;
+        [BinaryMember(Order = 33)] public string LibraryName { get; set; } = String.Empty;
 
-        public string LibraryWeaponName { get; set; } = String.Empty;
+        [BinaryMember(Order = 34)] public string LibraryWeaponName { get; set; } = String.Empty;
 
-        public string AimSpriteEven { get; set; } = String.Empty;
+        [BinaryMember(Order = 35)] public string AimSpriteEven { get; set; } = String.Empty;
 
-        public string AimSpriteUphill { get; set; } = String.Empty;
+        [BinaryMember(Order = 36)] public string AimSpriteUphill { get; set; } = String.Empty;
 
-        public string AimSpriteDownhill { get; set; } = String.Empty;
+        [BinaryMember(Order = 37)] public string AimSpriteDownhill { get; set; } = String.Empty;
 
-        public string PickSpriteEven { get; set; } = String.Empty;
+        [BinaryMember(Order = 38)] public string PickSpriteEven { get; set; } = String.Empty;
 
-        public string PickSpriteUphill { get; set; } = String.Empty;
+        [BinaryMember(Order = 39)] public string PickSpriteUphill { get; set; } = String.Empty;
 
-        public string PickSpriteDownhill { get; set; } = String.Empty;
+        [BinaryMember(Order = 40)] public string PickSpriteDownhill { get; set; } = String.Empty;
 
-        public string FireSpriteEven { get; set; } = String.Empty;
+        [BinaryMember(Order = 41)] public string FireSpriteEven { get; set; } = String.Empty;
 
-        public string FireSpriteUphill { get; set; } = String.Empty;
+        [BinaryMember(Order = 42)] public string FireSpriteUphill { get; set; } = String.Empty;
 
-        public string FireSpriteDownhill { get; set; } = String.Empty;
+        [BinaryMember(Order = 43)] public string FireSpriteDownhill { get; set; } = String.Empty;
 
-        public bool AimSpriteOverride { get; set; }
+        [BinaryMember(Order = 44)] public bool AimSpriteOverride { get; set; }
 
-        public bool PickSpriteOverride { get; set; }
+        [BinaryMember(Order = 45)] public bool PickSpriteOverride { get; set; }
 
-        public bool FireSpriteOverride { get; set; }
+        [BinaryMember(Order = 46)] public bool FireSpriteOverride { get; set; }
 
-        public bool Utility { get; set; }
+        [BinaryMember(Order = 47)] public bool Utility { get; set; }
 
         // ---- METHODS (PUBLIC) ---------------------------------------------------------------------------------------
 
@@ -141,97 +141,46 @@ namespace Syroot.Worms.Armageddon.ProjectX
                 case WeaponActivation.Crosshair:
                     NotUsed = reader.ReadInt32();
                     CrosshairAction = reader.ReadEnum<WeaponCrosshairAction>(false);
-                    switch (CrosshairAction)
+                    Style = CrosshairAction switch
                     {
-                        case WeaponCrosshairAction.Bow:
+                        WeaponCrosshairAction.Bow => reader.ReadObject<BowStyle>(),
-                            Style = reader.ReadObject<BowStyle>();
+                        WeaponCrosshairAction.Flamethrower => reader.ReadObject<FlamethrowerStyle>(),
-                            break;
+                        WeaponCrosshairAction.Gun => reader.ReadObject<GunStyle>(),
-                        case WeaponCrosshairAction.Flamethrower:
+                        WeaponCrosshairAction.Launcher => reader.ReadObject<LauncherStyle>(),
-                            Style = reader.ReadObject<FlamethrowerStyle>();
+                        _ => null
-                            break;
+                    };
-                        case WeaponCrosshairAction.Gun:
-                            Style = reader.ReadObject<GunStyle>();
-                            break;
-                        case WeaponCrosshairAction.Launcher:
-                            Style = reader.ReadObject<LauncherStyle>();
-                            break;
-                    }
                     break;
                 case WeaponActivation.Spacebar:
                     SpacebarAction = reader.ReadEnum<WeaponSpacebarAction>(false);
-                    switch (SpacebarAction)
+                    Style = SpacebarAction switch
                     {
-                        case WeaponSpacebarAction.Armageddon:
+                        WeaponSpacebarAction.Armageddon => reader.ReadObject<LauncherStyle>(),
-                            Style = reader.ReadObject<LauncherStyle>();
+                        WeaponSpacebarAction.BaseballBat => reader.ReadObject<BaseballBatStyle>(),
-                            break;
+                        WeaponSpacebarAction.BattleAxe => reader.ReadObject<BattleAxeStyle>(),
-                        case WeaponSpacebarAction.BaseballBat:
+                        WeaponSpacebarAction.Blowtorch => reader.ReadObject<BlowtorchStyle>(),
-                            Style = reader.ReadObject<BaseballBatStyle>();
+                        WeaponSpacebarAction.Dragonball => reader.ReadObject<DragonballStyle>(),
-                            break;
+                        WeaponSpacebarAction.Firepunch => reader.ReadObject<FirepunchStyle>(),
-                        case WeaponSpacebarAction.BattleAxe:
+                        WeaponSpacebarAction.Jetpack => reader.ReadObject<JetpackStyle>(),
-                            Style = reader.ReadObject<BattleAxeStyle>();
+                        WeaponSpacebarAction.Kamikaze => reader.ReadObject<KamikazeStyle>(),
-                            break;
+                        WeaponSpacebarAction.NinjaRope => reader.ReadObject<NinjaRopeStyle>(),
-                        case WeaponSpacebarAction.Blowtorch:
+                        WeaponSpacebarAction.NuclearTest => reader.ReadObject<NuclearTestStyle>(),
-                            Style = reader.ReadObject<BlowtorchStyle>();
+                        WeaponSpacebarAction.Parachute => reader.ReadObject<ParachuteStyle>(),
-                            break;
+                        WeaponSpacebarAction.PneumaticDrill => reader.ReadObject<PneumaticDrillStyle>(),
-                        case WeaponSpacebarAction.Dragonball:
+                        WeaponSpacebarAction.Prod => reader.ReadObject<ProdStyle>(),
-                            Style = reader.ReadObject<DragonballStyle>();
+                        WeaponSpacebarAction.SuicideBomber => reader.ReadObject<SuicideBomberStyle>(),
-                            break;
+                        _ => null
-                        case WeaponSpacebarAction.Firepunch:
+                    };
-                            Style = reader.ReadObject<FirepunchStyle>();
-                            break;
-                        case WeaponSpacebarAction.Jetpack:
-                            Style = reader.ReadObject<JetpackStyle>();
-                            break;
-                        case WeaponSpacebarAction.Kamikaze:
-                            Style = reader.ReadObject<KamikazeStyle>();
-                            break;
-                        case WeaponSpacebarAction.NinjaRope:
-                            Style = reader.ReadObject<NinjaRopeStyle>();
-                            break;
-                        case WeaponSpacebarAction.NuclearTest:
-                            Style = reader.ReadObject<NuclearTestStyle>();
-                            break;
-                        case WeaponSpacebarAction.Parachute:
-                            Style = reader.ReadObject<ParachuteStyle>();
-                            break;
-                        case WeaponSpacebarAction.PneumaticDrill:
-                            Style = reader.ReadObject<PneumaticDrillStyle>();
-                            break;
-                        case WeaponSpacebarAction.Prod:
-                            Style = reader.ReadObject<ProdStyle>();
-                            break;
-                        case WeaponSpacebarAction.SuicideBomber:
-                            Style = reader.ReadObject<SuicideBomberStyle>();
-                            break;
-                        case WeaponSpacebarAction.Bungee:
-                        case WeaponSpacebarAction.Earthquake:
-                        case WeaponSpacebarAction.Freeze:
-                        case WeaponSpacebarAction.Girder:
-                        case WeaponSpacebarAction.ScalesOfJustice:
-                        case WeaponSpacebarAction.SelectWorm:
-                        case WeaponSpacebarAction.SkipGo:
-                        case WeaponSpacebarAction.Surrender:
-                        case WeaponSpacebarAction.Teleport:
-                        case WeaponSpacebarAction.Utility:
-                            Style = null;
-                            break;
-                    }
                     break;
                 case WeaponActivation.Throw:
                     ThrowHerdCount = reader.ReadInt32();
                     ThrowAction = reader.ReadEnum<WeaponThrowAction>(false);
-                    switch (ThrowAction)
+                    Style = ThrowAction switch
                     {
-                        case WeaponThrowAction.Canister:
+                        WeaponThrowAction.Canister => reader.ReadObject<CanisterStyle>(),
-                            Style = reader.ReadObject<CanisterStyle>();
+                        WeaponThrowAction.Launcher => reader.ReadObject<LauncherStyle>(),
-                            break;
+                        WeaponThrowAction.Mine => reader.ReadObject<MineStyle>(),
-                        case WeaponThrowAction.Launcher:
+                        _ => null
-                            Style = reader.ReadObject<LauncherStyle>();
+                    };
-                            break;
-                        case WeaponThrowAction.Mine:
-                            Style = reader.ReadObject<MineStyle>();
-                            break;
-                    }
                     break;
             }
 

src/library/Syroot.Worms.Armageddon/Syroot.Worms.Armageddon.csproj

@@ -1,14 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)build.xml" />
+  
+  <!-- Metadata -->
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <AssemblyName>Syroot.Worms.Armageddon</AssemblyName>
     <Description>.NET library for loading and modifying files of Team17's Worms Armageddon.</Description>
     <PackageReleaseNotes>Overhaul implementation and documentation. Implement W:A V3 scheme format.</PackageReleaseNotes>
     <PackageTags>$(PackageTags);worms armageddon</PackageTags>
     <Version>4.0.0</Version>
   </PropertyGroup>
+  
+  <!-- References -->
   <ItemGroup>
     <ProjectReference Include="..\Syroot.Worms\Syroot.Worms.csproj" />
   </ItemGroup>
+
 </Project>

src/library/Syroot.Worms.Mgame/Syroot.Worms.Mgame.csproj

@@ -1,13 +1,18 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)build.xml" />
+  
+  <!-- Metadata -->
   <PropertyGroup>
-    <AssemblyName>Syroot.Worms.Mgame</AssemblyName>
     <Description>.NET library for loading and modifying files of Mgame Worms clients.</Description>
     <PackageReleaseNotes>Overhaul implementation and documentation.</PackageReleaseNotes>
     <PackageTags>$(PackageTags);online worms;worms world party aqua</PackageTags>
     <Version>4.0.0</Version>
   </PropertyGroup>
+  
+  <!-- References -->
   <ItemGroup>
+    <PackageReference Include="System.Text.Encoding.CodePages" Version="4.5.0" />
     <ProjectReference Include="..\Syroot.Worms\Syroot.Worms.csproj" />
   </ItemGroup>
+  
 </Project>

src/library/Syroot.Worms.WorldParty/Syroot.Worms.WorldParty.csproj

@@ -1,5 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)build.xml" />
+  
+  <!-- Metadata -->
   <PropertyGroup>
     <AssemblyName>Syroot.Worms.WorldParty</AssemblyName>
     <Description>.NET library for loading and modifying files of Team17's Worms World Party.</Description>
@@ -7,7 +9,10 @@
     <PackageTags>$(PackageTags);worms world party</PackageTags>
     <Version>4.0.0</Version>
   </PropertyGroup>
+  
+  <!-- References -->
   <ItemGroup>
     <ProjectReference Include="..\Syroot.Worms\Syroot.Worms.csproj" />
   </ItemGroup>
+  
 </Project>

src/library/Syroot.Worms.Worms2/Syroot.Worms.Worms2.csproj

@@ -1,13 +1,17 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)build.xml" />
+  
+  <!-- Metadata -->
   <PropertyGroup>
-    <AssemblyName>Syroot.Worms.Worms2</AssemblyName>
     <Description>.NET library for loading and modifying files of Team17's Worms 2.</Description>
     <PackageReleaseNotes>Overhaul implementation and documentation.</PackageReleaseNotes>
     <PackageTags>$(PackageTags);worms 2</PackageTags>
     <Version>4.0.0</Version>
   </PropertyGroup>
+  
+  <!-- References -->
   <ItemGroup>
     <ProjectReference Include="..\Syroot.Worms\Syroot.Worms.csproj" />
   </ItemGroup>
+  
 </Project>

src/library/Syroot.Worms/IO/BinaryStreamExtensions.cs

@@ -14,19 +14,6 @@ namespace Syroot.Worms.IO
 
         // ---- Reading ----
 
-        /// <summary>
-        /// Reads an <see cref="ILoadable"/> instance from the current stream.
-        /// </summary>
-        /// <typeparam name="T">The type of the <see cref="ILoadable"/> class to instantiate.</typeparam>
-        /// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
-        /// <returns>The <see cref="ILoadable"/> instance.</returns>
-        public static T Load<T>(this BinaryStream self) where T : ILoadable, new()
-        {
-            T instance = new T();
-            instance.Load(self.BaseStream);
-            return instance;
-        }
-
         /// <summary>
         /// Reads an RGBA 32-bit color.
         /// </summary>
@@ -78,17 +65,6 @@ namespace Syroot.Worms.IO
 
         // ---- Writing ----
 
-        /// <summary>
-        /// Writes the given <see cref="ISaveable"/> instance into the current stream.
-        /// </summary>
-        /// <typeparam name="T">The type of the <see cref="ISaveable"/> class to write.</typeparam>
-        /// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
-        /// <param name="value">The instance to write into the current stream.</param>
-        public static void Save<T>(this BinaryStream self, T value) where T : ISaveable
-        {
-            value.Save(self.BaseStream);
-        }
-
         /// <summary>
         /// Writes the given <paramref name="value"/> to the given <paramref name="offset"/>. This is meant to be used
         /// in combination with <see cref="ReserveOffset"/>.

src/library/Syroot.Worms/IO/StreamExtensions.cs

@@ -61,6 +61,29 @@ namespace Syroot.Worms.IO
         public static unsafe void WriteStructs<T>(this Stream stream, ReadOnlySpan<T> span) where T : unmanaged
             => stream.Write(MemoryMarshal.Cast<T, byte>(span));
 
+        // ---- ILoadable / ISaveable ----
+
+        /// <summary>
+        /// Reads an <see cref="ILoadable"/> instance from the current stream.
+        /// </summary>
+        /// <typeparam name="T">The type of the <see cref="ILoadable"/> class to instantiate.</typeparam>
+        /// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
+        /// <returns>The <see cref="ILoadable"/> instance.</returns>
+        public static T Load<T>(this Stream self) where T : ILoadable, new()
+        {
+            T instance = new T();
+            instance.Load(self);
+            return instance;
+        }
+
+        /// <summary>
+        /// Writes the given <see cref="ISaveable"/> instance into the current stream.
+        /// </summary>
+        /// <typeparam name="T">The type of the <see cref="ISaveable"/> class to write.</typeparam>
+        /// <param name="self">The extended <see cref="BinaryStream"/> instance.</param>
+        /// <param name="value">The instance to write into the current stream.</param>
+        public static void Save<T>(this Stream self, T value) where T : ISaveable => value.Save(self);
+
         // ---- Backports ----
 #if NETSTANDARD2_0
 

src/library/Syroot.Worms/Syroot.Worms.csproj

@@ -1,19 +1,21 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)build.xml" />
+  
+  <!-- Metadata -->
   <PropertyGroup>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <AssemblyName>Syroot.Worms</AssemblyName>
     <Description>.NET library for loading and modifying files of Team17 Worms games.</Description>
     <PackageReleaseNotes>Overhaul implementation and documentation.</PackageReleaseNotes>
     <Version>4.0.0</Version>
   </PropertyGroup>
+  
+  <!-- References -->
   <ItemGroup>
-    <PackageReference Include="Syroot.BinaryData.Serialization" Version="5.2.0" />
+    <PackageReference Include="Syroot.BinaryData" Version="5.2.1" />
-    <PackageReference Include="Syroot.BinaryData" Version="5.2.0" />
     <PackageReference Include="System.Drawing.Common" Version="4.5.0" />
-    <PackageReference Include="System.Text.Encoding.CodePages" Version="4.5.0" />
   </ItemGroup>
   <ItemGroup Condition="'$(TargetFramework)'=='netstandard2.0'">
     <PackageReference Include="Microsoft.Bcl.HashCode" Version="1.0.0" />
   </ItemGroup>
+  
 </Project>

src/test.xml

@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  
   <!-- Compilation -->
   <PropertyGroup>
     <LangVersion>latest</LangVersion>
@@ -23,4 +24,5 @@
     <Message Text="Linking Files" Importance="high" />
     <Exec Command="MKLINK /D &quot;$(OutputPath)Files&quot; &quot;$(ProjectDir)Files&quot;" />
   </Target>
+  
 </Project>

src/test/Syroot.Worms.Armageddon.ProjectX.Test/Syroot.Worms.Armageddon.ProjectX.Test.csproj

@@ -1,7 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)test.xml" />
+  
+  <!-- References -->
   <ItemGroup>
     <ProjectReference Include="..\..\library\Syroot.Worms.Armageddon.ProjectX\Syroot.Worms.Armageddon.ProjectX.csproj" />
     <ProjectReference Include="..\Syroot.Worms.Test\Syroot.Worms.Test.csproj" />
   </ItemGroup>
+  
 </Project>

src/test/Syroot.Worms.Armageddon.Test/Syroot.Worms.Armageddon.Test.csproj

@@ -1,7 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)test.xml" />
+
+  <!-- References -->
   <ItemGroup>
     <ProjectReference Include="..\..\library\Syroot.Worms.Armageddon\Syroot.Worms.Armageddon.csproj" />
     <ProjectReference Include="..\Syroot.Worms.Test\Syroot.Worms.Test.csproj" />
   </ItemGroup>
+
 </Project>

src/test/Syroot.Worms.Mgame.Test/Syroot.Worms.Mgame.Test.csproj

@@ -1,7 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)test.xml" />
+
+  <!-- References -->
   <ItemGroup>
     <ProjectReference Include="..\..\library\Syroot.Worms.Mgame\Syroot.Worms.Mgame.csproj" />
     <ProjectReference Include="..\Syroot.Worms.Test\Syroot.Worms.Test.csproj" />
   </ItemGroup>
+  
 </Project>

src/test/Syroot.Worms.Test/Syroot.Worms.Test.csproj

@@ -1,6 +1,9 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)test.xml" />
+  
+  <!-- References -->
   <ItemGroup>
     <ProjectReference Include="..\..\library\Syroot.Worms\Syroot.Worms.csproj" />
   </ItemGroup>
+  
 </Project>

src/test/Syroot.Worms.WorldParty.Test/Syroot.Worms.WorldParty.Test.csproj

@@ -1,7 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)test.xml" />
+
+  <!-- References -->
   <ItemGroup>
     <ProjectReference Include="..\..\library\Syroot.Worms.WorldParty\Syroot.Worms.WorldParty.csproj" />
     <ProjectReference Include="..\Syroot.Worms.Test\Syroot.Worms.Test.csproj" />
   </ItemGroup>
+
 </Project>

src/test/Syroot.Worms.Worms2.Test/Syroot.Worms.Worms2.Test.csproj

@@ -1,7 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
   <Import Project="$(SolutionDir)test.xml" />
+
+  <!-- References -->
   <ItemGroup>
     <ProjectReference Include="..\..\library\Syroot.Worms.Worms2\Syroot.Worms.Worms2.csproj" />
     <ProjectReference Include="..\Syroot.Worms.Test\Syroot.Worms.Test.csproj" />
   </ItemGroup>
+  
 </Project>