Added autologin support for CSRO (ICCGame) & fixed inventory update

Library/RSBot.Core/Components/ClientManager.cs

@@ -14,6 +14,15 @@ namespace RSBot.Core.Components;
 
 public class ClientManager
 {
+    private const int SroClientImageBase = 0x00400000;
+    private static readonly (int Address, byte[] Expected, byte[] Patch)[] ChineseClientPatches =
+    {
+        (0x0060C6DB, new byte[] { 0x75, 0x2E }, new byte[] { 0xEB, 0x2E }),
+        (0x0060C6A1, new byte[] { 0x75, 0x26 }, new byte[] { 0xEB, 0x26 }),
+        (0x0067BF56, new byte[] { 0x75, 0x2C }, new byte[] { 0xEB, 0x2C }),
+        (0x00AD449E, new byte[] { 0x68, 0x5C, 0x54, 0xE1, 0x00 }, new byte[] { 0xEB, 0x2D, 0x90, 0x90, 0x90 }),
+    };
+
     /// <summary>
     ///     The client process
     /// </summary>
@@ -153,6 +162,13 @@ out var pi
 
             WaitForSingleObject(remoteThread, uint.MaxValue);
 
+            if (Game.ClientType == GameClientType.Chinese)
+            {
+                var sroProcess = System.Diagnostics.Process.GetProcessById((int)pi.dwProcessId);
+                WaitForChineseClientPatchTargets(sroProcess, pi.hThread);
+                ApplyChineseClientPatch(sroProcess, pi);
+            }
+
             VirtualFreeEx(handle, remotePath, 0, MEM_RELEASE);
 
             CloseHandle(remoteThread);
@@ -190,10 +206,6 @@ public static void BypassLauncherCheck(Process process, PROCESS_INFORMATION pi)
             out _
         );
 
-        var patchNop = new byte[] { 0x90, 0x90 };
-        var patchNop2 = new byte[] { 0x90, 0x90, 0x90, 0x90, 0x90 };
-        var patchJmp = new byte[] { 0xEB };
-
         string signature =
             "55 8B EC 83 EC ?? 8B 45 ?? 50 E8 ?? ?? ?? ?? 83 C4 04 89 45 ?? 8B 4D ?? 89 4D ?? 68 ?? ?? ?? ?? 6A 00 6A 00";
 
@@ -367,6 +379,130 @@ out _
         GC.Collect();
     }
 
+    /// <summary>
+    /// Runs the suspended Chinese client until the target bytes are unpacked and readable.
+    /// On return the primary thread is left suspended so the caller can patch and resume.
+    /// </summary>
+    private static void WaitForChineseClientPatchTargets(Process process, IntPtr hThread)
+    {
+        const int sliceMs = 8;
+        const int maxWaitMs = 5000;
+
+        var sw = Stopwatch.StartNew();
+
+        while (true)
+        {
+            ResumeThread(hThread);
+            Thread.Sleep(sliceMs);
+            SuspendThread(hThread);
+
+            if (process.HasExited)
+                return;
+
+            process.Refresh();
+
+            if (ChineseClientPatchTargetsReady(process.Handle, process.MainModule.BaseAddress.ToInt32()))
+                return;
+
+            if (sw.ElapsedMilliseconds >= maxWaitMs)
+            {
+                Log.Warn("Chinese client patch: unpack timeout.");
+                return;
+            }
+        }
+    }
+
+    private static bool ChineseClientPatchTargetsReady(IntPtr processHandle, int moduleBaseAddress)
+    {
+        foreach (var patch in ChineseClientPatches)
+        {
+            if (
+                !TryReadClientBytes(
+                    processHandle,
+                    moduleBaseAddress,
+                    patch.Address,
+                    patch.Expected.Length,
+                    out var current
+                )
+            )
+                return false;
+
+            if (!current.SequenceEqual(patch.Expected) && !current.SequenceEqual(patch.Patch))
+                return false;
+        }
+
+        return true;
+    }
+
+    /// <summary>
+    /// Applies fixed in-memory patches for the Chinese sro_client.exe.
+    /// </summary>
+    private static void ApplyChineseClientPatch(Process process, PROCESS_INFORMATION pi)
+    {
+        int moduleBaseAddress = process.MainModule.BaseAddress.ToInt32();
+
+        foreach (var patch in ChineseClientPatches)
+            PatchKnownClientBytes(pi.hProcess, moduleBaseAddress, patch.Address, patch.Expected, patch.Patch);
+    }
+
+    private static void PatchKnownClientBytes(
+        IntPtr processHandle,
+        int moduleBaseAddress,
+        int clientAddress,
+        byte[] expected,
+        byte[] patch
+    )
+    {
+        if (!TryReadClientBytes(processHandle, moduleBaseAddress, clientAddress, expected.Length, out var current))
+        {
+            Log.Warn($"Chinese client patch: could not read 0x{clientAddress:X8}.");
+            return;
+        }
+
+        if (current.SequenceEqual(patch))
+            return;
+
+        if (!current.SequenceEqual(expected))
+        {
+            Log.Warn(
+                $"Chinese client patch: unexpected bytes at 0x{clientAddress:X8}. Expected {FormatBytes(expected)}, got {FormatBytes(current)}."
+            );
+            return;
+        }
+
+        PatchProcessMemory(processHandle, GetClientAddress(moduleBaseAddress, clientAddress), patch);
+    }
+
+    private static bool TryReadClientBytes(
+        IntPtr processHandle,
+        int moduleBaseAddress,
+        int clientAddress,
+        int length,
+        out byte[] bytes
+    )
+    {
+        bytes = new byte[length];
+
+        return ReadProcessMemory(
+                processHandle,
+                GetClientAddress(moduleBaseAddress, clientAddress),
+                bytes,
+                bytes.Length,
+                out var read
+            )
+            && read.ToInt32() == bytes.Length;
+    }
+
+    private static IntPtr GetClientAddress(int moduleBaseAddress, int clientAddress)
+    {
+        return (IntPtr)(moduleBaseAddress + clientAddress - SroClientImageBase);
+    }
+
+    private static string FormatBytes(byte[] bytes)
+    {
+        return BitConverter.ToString(bytes).Replace("-", " ");
+    }
+
     /// <summary>
     /// Finds the XIGNCODE init call anchor in WinMain by locating the standalone "XIGNCODE" Unicode
     /// string and its reference in the code pattern: push 0; push VA("XIGNCODE"); push code_string; call func.

Library/RSBot.Core/Network/Handler/Agent/Inventory/InventoryUpdateItemResponse.cs

@@ -1,4 +1,4 @@
-using System.Collections.Generic;
+using System.Collections.Generic;
 using RSBot.Core.Event;
 using RSBot.Core.Objects;
 using RSBot.Core.Objects.Item;
@@ -30,14 +30,17 @@ internal class InventoryUpdateItemResponse : IPacketHandler
     public void Invoke(Packet packet)
     {
         if (Game.ClientType == GameClientType.Global || Game.ClientType == GameClientType.RuSro)
-            if (packet.ReadByte() != 0) //sometimes appears 9 with unknown structure
-                return;
-
-        var sourceSlot = packet.ReadByte();
+        {
+            InvokeModernClients(packet);
+            return;
+        }
 
-        if (Game.ClientType == GameClientType.Global || Game.ClientType == GameClientType.RuSro)
-            packet.ReadByte(); //0 - normal, 2 - item disappearing
+        InvokeLegacy(packet);
+    }
 
+    private static void InvokeLegacy(Packet packet)
+    {
+        var sourceSlot = packet.ReadByte();
         var itemUpdateFlag = (ItemUpdateFlag)packet.ReadByte();
 
         var item = Game.Player.Inventory.GetItemAt(sourceSlot);
@@ -79,4 +82,136 @@ public void Invoke(Packet packet)
 
         EventManager.FireEvent("OnUpdateInventoryItem", sourceSlot);
     }
+
+    private static void InvokeModernClients(Packet packet)
+    {
+        var updateType = packet.ReadByte();
+
+        if (updateType == 9)
+        {
+            var objectId = packet.ReadUInt();
+            var containerSlot = packet.ReadByte();
+            var updateFlags = (ModernItemUpdateFlag)packet.ReadUShort();
+            var inventory = GetInventoryForObject(objectId);
+            var containerItem = inventory?.GetItemAt(containerSlot);
+
+            ApplyModernClientsContainerUpdate(packet, containerItem, updateFlags);
+
+            if (containerItem != null && ReferenceEquals(inventory, Game.Player.Inventory))
+                EventManager.FireEvent("OnUpdateInventoryItem", containerSlot);
+
+            return;
+        }
+
+        var sourceSlot = packet.ReadByte();
+        var itemUpdateFlags = (ModernItemUpdateFlag)packet.ReadUShort();
+        var item = Game.Player.Inventory.GetItemAt(sourceSlot);
+        if (item == null)
+            return;
+
+        ApplyModernClientsItemUpdate(packet, item, sourceSlot, itemUpdateFlags, updateType);
+        EventManager.FireEvent("OnUpdateInventoryItem", sourceSlot);
+    }
+
+    private static void ApplyModernClientsContainerUpdate(
+        Packet packet,
+        InventoryItem item,
+        ModernItemUpdateFlag updateFlags
+    )
+    {
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.Durability))
+        {
+            var durability = packet.ReadUInt();
+            if (item != null)
+                item.Durability = durability;
+        }
+
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.BindingOptions))
+            ReadBindingOptions(packet, item);
+    }
+
+    private static void ApplyModernClientsItemUpdate(
+        Packet packet,
+        InventoryItem item,
+        byte sourceSlot,
+        ModernItemUpdateFlag updateFlags,
+        byte updateType
+    )
+    {
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.RefObjID))
+            item.ItemId = packet.ReadUInt();
+
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.Quantity))
+            item.Amount = packet.ReadUShort();
+
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.Durability))
+            item.Durability = packet.ReadUInt();
+
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.OptLevel))
+            item.OptLevel = packet.ReadByte();
+
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.Variance))
+            item.Attributes = new ItemAttributesInfo(packet.ReadULong());
+
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.MagParams) && item.Record != null)
+            ReadMagicOptions(packet, item);
+
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.BindingOptions) && (updateType == 0 || updateType == 8))
+            ReadBindingOptions(packet, item);
+
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.RemainTime))
+            packet.ReadUInt();
+
+        if (updateFlags.HasFlag(ModernItemUpdateFlag.ItemState))
+        {
+            var itemState = (InventoryItemState)packet.ReadByte();
+
+            if (sourceSlot >= 0x11)
+                item.State = itemState;
+        }
+    }
+
+    private static void ReadMagicOptions(Packet packet, InventoryItem item)
+    {
+        item.MagicOptions = new List<MagicOptionInfo>();
+
+        var magParamCount = packet.ReadByte();
+        for (var i = 0; i < magParamCount; i++)
+            item.MagicOptions.Add(MagicOptionInfo.FromPacket(packet));
+    }
+
+    private static void ReadBindingOptions(Packet packet, InventoryItem item)
+    {
+        item ??= new InventoryItem();
+        item.BindingOptions = new List<BindingOption>();
+
+        for (var bindingIndex = 0; bindingIndex < 4; bindingIndex++)
+        {
+            var bindingType = (BindingOptionType)packet.ReadByte();
+            var bindingAmount = packet.ReadByte();
+
+            for (var i = 0; i < bindingAmount; i++)
+                item.BindingOptions.Add(BindingOption.FromPacket(packet, bindingType));
+        }
+    }
+
+    private static InventoryItemCollection GetInventoryForObject(uint objectId)
+    {
+        if (Game.Player.UniqueId == objectId)
+            return Game.Player.Inventory;
+
+        if (Game.Player.AbilityPet?.UniqueId == objectId)
+            return Game.Player.AbilityPet.Inventory;
+
+        if (Game.Player.Fellow?.UniqueId == objectId)
+            return Game.Player.Fellow.Inventory;
+
+        if (Game.Player.Growth?.UniqueId == objectId)
+            return Game.Player.Growth.Inventory;
+
+        if (Game.Player.Vehicle?.UniqueId == objectId)
+            return Game.Player.Vehicle.Inventory;
+
+        return null;
+    }
 }

Library/RSBot.Core/Objects/Inventory/Item/ModernItemUpdateFlag.cs

@@ -0,0 +1,17 @@
+using System;
+
+namespace RSBot.Core.Objects.Item;
+
+[Flags]
+public enum ModernItemUpdateFlag : ushort
+{
+    RefObjID = 0x0001,
+    Quantity = 0x0002,
+    Durability = 0x0010,
+    OptLevel = 0x0020,
+    Variance = 0x0040,
+    MagParams = 0x0080,
+    BindingOptions = 0x0100,
+    RemainTime = 0x0200,
+    ItemState = 0x8000,
+}

Plugins/RSBot.General/Components/AutoLogin.cs

@@ -191,7 +191,15 @@ private static void SendLoginRequest(Account account, Server server)
 
         loginPacket.WriteUShort(server.Id);
 
-        if (opcode == 0x610A)
+        if (Game.ClientType == GameClientType.Chinese)
+        {
+            if (!ChineseGatewayLogin.TryWriteVerificationAndTicket(loginPacket, account.Username))
+            {
+                _busy = false;
+                return;
+            }
+        }
+        else if (opcode == 0x610A)
             loginPacket.WriteByte(account.Channel);
 
         PacketManager.SendPacket(loginPacket, PacketDestination.Server);