Migrate netcode to use Moffat.EndlessOnline.Sdk (eolib-dotnet)

EOBot/BotBase.cs

@@ -1,11 +1,14 @@
 using System;
 using System.Threading;
 using System.Threading.Tasks;
+using EOLib;
 using EOLib.Config;
 using EOLib.Domain.Protocol;
 using EOLib.Net.Communication;
 using EOLib.Net.Connection;
 using EOLib.Net.PacketProcessing;
+using Moffat.EndlessOnline.SDK.Packet;
+using Moffat.EndlessOnline.SDK.Protocol.Net.Server;
 
 namespace EOBot
 {
@@ -17,9 +20,12 @@ public abstract class BotBase : IBot
 
         public event Action WorkCompleted;
 
+        protected Random _random;
+
         protected BotBase(int botIndex)
         {
             _index = botIndex;
+            _random = new Random();
         }
 
         //all bots are going to want to do the init handshake with the server
@@ -52,17 +58,16 @@ public virtual async Task InitializeAsync(string host, int port)
                 connectionActions.DisconnectFromServer();
             };
 
-            var handshakeResult = await connectionActions.BeginHandshake();
+            var handshakeResult = await connectionActions.BeginHandshake(_random.Next(Constants.MaxChallenge));
 
-            if (handshakeResult.Response != InitReply.Success)
+            if (handshakeResult.ReplyCode != InitReply.Ok)
                 throw new InvalidOperationException(string.Format("Bot {0}: Invalid response from server or connection failed! Must receive an OK reply.", _index));
 
-            var packetProcessActions = c.Resolve<IPacketProcessActions>();
+            var handshakeData = (InitInitServerPacket.ReplyCodeDataOk)handshakeResult.ReplyCodeData;
 
-            packetProcessActions.SetInitialSequenceNumber(handshakeResult[InitializationDataKey.SequenceByte1],
-                handshakeResult[InitializationDataKey.SequenceByte2]);
-            packetProcessActions.SetEncodeMultiples(handshakeResult[InitializationDataKey.ReceiveMultiple],
-                handshakeResult[InitializationDataKey.SendMultiple]);
+            var packetProcessActions = c.Resolve<IPacketProcessActions>();
+            packetProcessActions.SetSequenceStart(InitSequenceStart.FromInitValues(handshakeData.Seq1, handshakeData.Seq2));
+            packetProcessActions.SetEncodeMultiples(handshakeData.ServerEncryptionMultiple, handshakeData.ClientEncryptionMultiple);
 
             connectionActions.CompleteHandshake(handshakeResult);
 

EOBot/BotHelper.cs

@@ -2,9 +2,10 @@
 using EOLib.Domain.Character;
 using EOLib.Domain.Login;
 using EOLib.Domain.Map;
-using EOLib.Domain.Protocol;
 using EOLib.IO.Actions;
 using EOLib.Net.FileTransfer;
+using Moffat.EndlessOnline.SDK.Protocol.Net.Client;
+using Moffat.EndlessOnline.SDK.Protocol.Net.Server;
 using Optional.Collections;
 using System;
 using System.IO;
@@ -29,7 +30,7 @@ public async Task<AccountReply> CreateAccountAsync(string name, string password)
             var accountActions = DependencyMaster.TypeRegistry[_botIndex].Resolve<IAccountActions>();
             var accParams = new CreateAccountParameters(name, password, password, name, name, name + "@eobot.net");
             var nameResult = await accountActions.CheckAccountNameWithServer(name);
-            return nameResult >= AccountReply.OK_CodeRange
+            return nameResult >= (AccountReply)10
                 ? await accountActions.CreateAccount(accParams, (int)nameResult)
                 : nameResult;
         }
@@ -73,19 +74,19 @@ public async Task LoginToCharacterAsync(string name)
             }
 
             var fileRequestActions = DependencyMaster.TypeRegistry[_botIndex].Resolve<IFileRequestActions>();
-            if (unableToLoadMap || fileRequestActions.NeedsFileForLogin(InitFileType.Map, mapStateProvider.CurrentMapID))
+            if (unableToLoadMap || fileRequestActions.NeedsFileForLogin(FileType.Emf, mapStateProvider.CurrentMapID))
                 await fileRequestActions.GetMapFromServer(mapStateProvider.CurrentMapID, sessionID);
 
-            if (fileRequestActions.NeedsFileForLogin(InitFileType.Item))
+            if (fileRequestActions.NeedsFileForLogin(FileType.Eif))
                 await fileRequestActions.GetItemFileFromServer(sessionID);
 
-            if (fileRequestActions.NeedsFileForLogin(InitFileType.Npc))
+            if (fileRequestActions.NeedsFileForLogin(FileType.Enf))
                 await fileRequestActions.GetNPCFileFromServer(sessionID);
 
-            if (fileRequestActions.NeedsFileForLogin(InitFileType.Spell))
+            if (fileRequestActions.NeedsFileForLogin(FileType.Esf))
                 await fileRequestActions.GetSpellFileFromServer(sessionID);
 
-            if (fileRequestActions.NeedsFileForLogin(InitFileType.Class))
+            if (fileRequestActions.NeedsFileForLogin(FileType.Ecf))
                 await fileRequestActions.GetClassFileFromServer(sessionID);
 
             await loginActions.CompleteCharacterLogin(sessionID);
@@ -106,7 +107,7 @@ public async Task<CharacterReply> DeleteCharacterAsync(string name, bool force)
             if (!characterSelectorRepository.CharacterForDelete.HasValue)
             {
                 ConsoleHelper.WriteMessage(ConsoleHelper.Type.Warning, $"Character {name} could not be deleted / does not exist");
-                return CharacterReply.THIS_IS_WRONG;
+                return (CharacterReply)255;
             }
 
             var characterActions = DependencyMaster.TypeRegistry[_botIndex].Resolve<ICharacterManagementActions>();

EOBot/Interpreter/BuiltInIdentifierConfigurator.cs

@@ -1,18 +1,20 @@
 using EOBot.Interpreter.States;
 using EOBot.Interpreter.Variables;
+using EOLib;
 using EOLib.Config;
-using EOLib.Domain.Account;
 using EOLib.Domain.Character;
 using EOLib.Domain.Chat;
 using EOLib.Domain.Login;
 using EOLib.Domain.Map;
 using EOLib.Domain.NPC;
 using EOLib.Domain.Party;
-using EOLib.Domain.Protocol;
 using EOLib.IO.Repositories;
 using EOLib.Net.Communication;
 using EOLib.Net.Connection;
 using EOLib.Net.PacketProcessing;
+using Moffat.EndlessOnline.SDK.Packet;
+using Moffat.EndlessOnline.SDK.Protocol.Net;
+using Moffat.EndlessOnline.SDK.Protocol.Net.Server;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -27,13 +29,15 @@ public class BuiltInIdentifierConfigurator
         private readonly int _botIndex;
         private readonly ArgumentsParser _parsedArgs;
         private readonly BotHelper _botHelper;
+        private readonly Random _random;
 
         public BuiltInIdentifierConfigurator(ProgramState state, int botIndex, ArgumentsParser parsedArgs)
         {
             _state = state;
             _botIndex = botIndex;
             _parsedArgs = parsedArgs;
             _botHelper = new BotHelper(_botIndex);
+            _random = new Random();
         }
 
         public void SetupBuiltInFunctions()
@@ -119,17 +123,16 @@ private async Task ConnectAsync(string host, int port)
             var backgroundReceiveActions = c.Resolve<IBackgroundReceiveActions>();
             backgroundReceiveActions.RunBackgroundReceiveLoop();
 
-            var handshakeResult = await connectionActions.BeginHandshake();
+            var handshakeResult = await connectionActions.BeginHandshake(_random.Next(Constants.MaxChallenge));
 
-            if (handshakeResult.Response != InitReply.Success)
+            if (handshakeResult.ReplyCode != InitReply.Ok)
                 throw new InvalidOperationException($"Bot {_botIndex}: Invalid response from server or connection failed! Must receive an OK reply.");
 
-            var packetProcessActions = c.Resolve<IPacketProcessActions>();
+            var handshakeData = (InitInitServerPacket.ReplyCodeDataOk)handshakeResult.ReplyCodeData;
 
-            packetProcessActions.SetInitialSequenceNumber(handshakeResult[InitializationDataKey.SequenceByte1],
-                handshakeResult[InitializationDataKey.SequenceByte2]);
-            packetProcessActions.SetEncodeMultiples(handshakeResult[InitializationDataKey.ReceiveMultiple],
-                handshakeResult[InitializationDataKey.SendMultiple]);
+            var packetProcessActions = c.Resolve<IPacketProcessActions>();
+            packetProcessActions.SetSequenceStart(InitSequenceStart.FromInitValues(handshakeData.Seq1, handshakeData.Seq2));
+            packetProcessActions.SetEncodeMultiples(handshakeData.ServerEncryptionMultiple, handshakeData.ClientEncryptionMultiple);
 
             connectionActions.CompleteHandshake(handshakeResult);
         }

EOBot/TrainerBot.cs

@@ -11,6 +11,7 @@
 using EOLib.IO.Repositories;
 using EOLib.Net;
 using EOLib.Net.Handlers;
+using Moffat.EndlessOnline.SDK.Protocol.Net.Server;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -377,9 +378,9 @@ private async Task UseHealItem(IEnumerable<InventoryItem> healItems)
         private async Task ToggleSit()
         {
             var renderProps = _characterRepository.MainCharacter.RenderProperties;
-            var nextState = renderProps.SitState == SitState.Standing ? "Floor" : "Stand";
-            ConsoleHelper.WriteMessage(ConsoleHelper.Type.Sit, $"{nextState,7} - Toggling from: {Enum.GetName(typeof(SitState), renderProps.SitState)}");
-            await TrySend(_characterActions.ToggleSit);
+            var nextState = renderProps.SitState == EOLib.Domain.Character.SitState.Standing ? "Floor" : "Stand";
+            ConsoleHelper.WriteMessage(ConsoleHelper.Type.Sit, $"{nextState,7} - Toggling from: {Enum.GetName(typeof(EOLib.Domain.Character.SitState), renderProps.SitState)}");
+            await TrySend(() => _characterActions.Sit(MapCoordinate.Zero));
         }
 
         private async Task TrySend(Action action, uint attempts = 3)

EOLib.Graphics.Test/NativeGraphicsManagerTest.cs

@@ -155,7 +155,7 @@ public void WhenLoadTexture_MaleHat_Transparent_SetsSpecialColorToTransparent()
 
             Texture2D resultTexture;
             var bmp = LoadGFXReturnsBitmap(GFXTypes.MaleHat, requestedResource);
-            FillBitmapWithColor(bmp, new Color(0x08, 0x00, 0x00, 0xff));
+            FillBitmapWithColor(bmp, new Color(0xff000008));
             resultTexture = _nativeGraphicsManager.TextureFromResource(GFXTypes.MaleHat, requestedResource, true);
 
             var data = new Microsoft.Xna.Framework.Color[resultTexture.Width * resultTexture.Height];
@@ -171,7 +171,7 @@ public void WhenLoadTexture_FemaleHat_Transparent_SetsSpecialColorToTransparent(
 
             Texture2D resultTexture;
             var bmp = LoadGFXReturnsBitmap(GFXTypes.FemaleHat, requestedResource);
-            FillBitmapWithColor(bmp, new Color(0x08, 0x00, 0x00, 0xff));
+            FillBitmapWithColor(bmp, new Color(0xff000008));
             resultTexture = _nativeGraphicsManager.TextureFromResource(GFXTypes.FemaleHat, requestedResource, true);
 
             var data = new Color[resultTexture.Width * resultTexture.Height];
@@ -221,9 +221,9 @@ private static void FillBitmapWithColor(Memory<byte> image, Color color)
         {
             for (int i = 54; i < image.Length; i+=4)
             {
-                image.Span[i] = color.R;
+                image.Span[i] = color.B;
                 image.Span[i + 1] = color.G;
-                image.Span[i + 2] = color.B;
+                image.Span[i + 2] = color.R;
                 image.Span[i + 3] = color.A;
             }
         }

EOLib.Graphics/NativeGraphicsManager.cs

@@ -61,23 +61,15 @@ private Texture2D LoadTexture(GFXTypes file, int resourceVal, bool transparent,
 
             if (transparent)
             {
-                // for all gfx: 0x000000 is transparent
-                processAction = data => CrossPlatformMakeTransparent(data, Color.Black);
+                processAction = data => CrossPlatformMakeTransparent(data);
 
-                // for hats: R=8 G=0 B=0 is transparent
-                // some default gfx use R=0 G=8 B=0 as black
-                // 0,0,0 clips pixels below it
-                if (file == GFXTypes.FemaleHat || file == GFXTypes.MaleHat)
+                if (fullTransparent)
                 {
-                    processAction = data => CrossPlatformMakeTransparent(data, new Color(0xff000008));
+                    processAction = data => CrossPlatformMakeTransparent(data, isHat: true);
                 }
-
-                // for hats: some hat gfx use multiple masking colors but don't have clipping behavior
-                if (fullTransparent)
+                else if (file == GFXTypes.FemaleHat || file == GFXTypes.MaleHat)
                 {
-                    processAction = data => CrossPlatformMakeTransparent(data,
-                        new Color(0xff000000),
-                        new Color(0xff000008));
+                    processAction = data => CrossPlatformMakeTransparent(data, checkClip: true, isHat: true);
                 }
             }
 
@@ -87,8 +79,39 @@ private Texture2D LoadTexture(GFXTypes file, int resourceVal, bool transparent,
             return ret;
         }
 
-        private static unsafe void CrossPlatformMakeTransparent(byte[] data, params Color[] transparentColors)
+        private static unsafe void CrossPlatformMakeTransparent(byte[] data, bool isHat = false, bool checkClip = false)
         {
+            var shouldClip = false;
+            if (checkClip)
+            {
+                fixed (byte* ptr = data)
+                {
+                    for (int i = 0; i < data.Length; i += 4)
+                    {
+                        uint* addr = (uint*)(ptr + i);
+                        if (*addr == 0xff000008)
+                        {
+                            shouldClip = true;
+                            break;
+                        }
+                    }
+                }
+            }
+
+            // for all gfx: 0,0,0 is transparent
+
+            // for some hats: 8,0,0 and 0,0,0 are both transparent
+
+            // for hats: R=8 G=0 B=0 is transparent
+            // some default gfx use R=0 G=8 B=0 as black
+            // 0,0,0 clips pixels below it if 8,0,0 is present on the frame
+
+            var transparentColors = isHat
+                ? shouldClip
+                    ? new Color[] { new Color(0xff000008) } // check clip: make ff000008 transparent only, use black for clipping if present
+                    : new Color[] { Color.Black, new Color(0xff000008) } // isHat: make both colors transparent
+                : new Color[] { Color.Black }; // default: make only black transparent
+
             fixed (byte* ptr = data)
             {
                 for (int i = 0; i < data.Length; i += 4)

EOLib.IO.Test/Map/MapFilePropertiesTest.cs

@@ -93,7 +93,7 @@ public void MapFileProperties_DeserializeFromByteArray_ThrowsExceptionWhenNotEMF
 
         private static IMapFileProperties CreateMapPropertiesWithSomeTestData(IMapFileProperties props)
         {
-            return props.WithChecksum(new byte[] {1, 2, 3, 4})
+            return props.WithChecksum(new List<int> {1, 2})
                 .WithName("Some test name")
                 .WithWidth(200)
                 .WithHeight(100)
@@ -117,7 +117,7 @@ private static byte[] CreateExpectedBytes(IMapFileProperties props)
             var ret = new List<byte>();
 
             ret.AddRange(Encoding.ASCII.GetBytes(props.FileType));
-            ret.AddRange(props.Checksum);
+            ret.AddRange(props.Checksum.SelectMany(x => numberEncoderService.EncodeNumber(x, 2)));
 
             var fullName = Enumerable.Repeat((byte)0xFF, 24).ToArray();
             var encodedName = mapStringEncoderService.EncodeMapString(props.Name, props.Name.Length);

EOLib.IO.Test/Services/Serializers/PubFileSerializerTest.cs

@@ -30,9 +30,12 @@ public abstract class PubFileSerializerTest<T, U>
         [Test]
         public void DeserializeFromByteArray_WrongLength_Throws()
         {
-            const int ExpectedChecksum = 1234567890;
+            const int ExpectedChecksum1 = 12345;
+            const int ExpectedChecksum2 = 6789;
             const int ExpectedLength = 4;
 
+            var expectedChecksum = new List<int> { ExpectedChecksum1, ExpectedChecksum2 };
+
             var records = new[]
             {
                 new U().WithID(1).WithName("Rec_1"),
@@ -41,16 +44,19 @@ public void DeserializeFromByteArray_WrongLength_Throws()
                 new U().WithID(4).WithName("Rec_4"),
             };
 
-            var pubBytesShort = MakePubFileBytes(ExpectedChecksum, ExpectedLength - 1, records);
+            var pubBytesShort = MakePubFileBytes(expectedChecksum, ExpectedLength - 1, records);
             Assert.That(() => CreateSerializer().DeserializeFromByteArray(1, pubBytesShort, () => new T()), Throws.InstanceOf<IOException>());
         }
 
         [Test]
         public void DeserializeFromByteArray_HasExpectedHeader()
         {
-            const int ExpectedChecksum = 1234567890;
+            const int ExpectedChecksum1 = 12345;
+            const int ExpectedChecksum2 = 6789;
             const int ExpectedLength = 4;
 
+            var expectedChecksum = new List<int> { ExpectedChecksum1, ExpectedChecksum2 };
+
             var records = new[]
             {
                 new U().WithID(1).WithName("Rec_1"),
@@ -59,17 +65,17 @@ public void DeserializeFromByteArray_HasExpectedHeader()
                 new U().WithID(4).WithName("Rec_4"),
             };
 
-            var pubBytes = MakePubFileBytes(ExpectedChecksum, ExpectedLength, records);
+            var pubBytes = MakePubFileBytes(expectedChecksum, ExpectedLength, records);
             var file = CreateSerializer().DeserializeFromByteArray(1, pubBytes, () => new T());
 
-            Assert.That(file.CheckSum, Is.EqualTo(ExpectedChecksum));
+            Assert.That(file.CheckSum, Is.EqualTo(expectedChecksum));
             Assert.That(file.Length, Is.EqualTo(ExpectedLength));
         }
 
         [Test]
         public void SerializeToByteArray_ReturnsExpectedBytes()
         {
-            var expectedBytes = MakePubFileBytes(55565554,
+            var expectedBytes = MakePubFileBytes(new List<int> { 5556, 5554 },
                 9,
                 new U().WithID(1).WithName("TestFixture"),
                 new U().WithID(2).WithName("Test2"),
@@ -104,7 +110,7 @@ public void DeserializeFromByteArray_HasExpectedIDAndNames()
                 new U().WithID(8).WithName("Test8"),
                 new U().WithID(9).WithName("eof")
             };
-            var bytes = MakePubFileBytes(55565554, 9, records);
+            var bytes = MakePubFileBytes(new List<int> { 5556, 5554 }, 9, records);
 
             var serializer = CreateSerializer();
             var file = serializer.DeserializeFromByteArray(1, bytes, () => new T());
@@ -113,14 +119,14 @@ public void DeserializeFromByteArray_HasExpectedIDAndNames()
                                       file.Select(x => new { x.ID, x.Name }).ToList());
         }
 
-        private byte[] MakePubFileBytes(int checksum, int length, params IPubRecord[] records)
+        private byte[] MakePubFileBytes(List<int> checksum, int length, params IPubRecord[] records)
         {
             var numberEncoderService = new NumberEncoderService();
             var recordSerializer = new PubRecordSerializer(numberEncoderService);
 
             var bytes = new List<byte>();
             bytes.AddRange(Encoding.ASCII.GetBytes(new T().FileType));
-            bytes.AddRange(numberEncoderService.EncodeNumber(checksum, 4));
+            bytes.AddRange(checksum.SelectMany(x => numberEncoderService.EncodeNumber(x, 2)));
             bytes.AddRange(numberEncoderService.EncodeNumber(length, 2));
             bytes.Add(numberEncoderService.EncodeNumber(1, 1)[0]);
             foreach (var record in records)