NetServer/NetCore/ContentParse/ByteParse.cs

using NetCore.NetServerCoreBasic;
using NetCore.Protocol;

namespace NetCore.ContentParse;

public class ByteParse : IContentParse
{
    // private byte[] buffData = new byte[655350];

    //记录半包数据
    private bool isBufferData;
    private byte[] lastBuffData;
    private int lastCount;

    private ushort lastXueLieHao;
    //数据结束

    //尾包
    private byte[] weiBaoBuffData;


    private byte[] ShortToByte(short number)
    {
        byte[] numberBytes = BitConverter.GetBytes(number).Reverse().ToArray();
        return numberBytes;
    }

    private byte[] UShortToByte(ushort number)
    {
        byte[] numberBytes = BitConverter.GetBytes(number).Reverse().ToArray();
        return numberBytes;
    }

    private byte[] IntToByte(int number,bool isReverse = false)
    {
        if (isReverse)
        {
            byte[] numberBytes = BitConverter.GetBytes(number).Reverse().ToArray();
            return numberBytes;
        }
        else
        {
            byte[] numberBytes = BitConverter.GetBytes(number);
            return numberBytes;
        }

    }

    private short ByteToShort(byte[] numberBytes, bool isReverse = false)
    {
        if (isReverse)
        {
            short converted = BitConverter.ToInt16(numberBytes.Reverse().ToArray(), 0);
            return converted;
        }
        else
        {
            short converted = BitConverter.ToInt16(numberBytes, 0);
            return converted;
        }
    }

    private ushort ByteToUshort(byte[] numberBytes, bool isReverse = false)
    {
        if (isReverse)
        {
            ushort converted = BitConverter.ToUInt16(numberBytes.Reverse().ToArray(), 0);
            return converted;
        }
        else
        {
            ushort converted = BitConverter.ToUInt16(numberBytes, 0);
            return converted;
        }
    }

    private int ByteToInt(byte[] numberBytes, bool isReverse = false)
    {
        if (isReverse)
        {
            int converted = BitConverter.ToInt32(numberBytes.Reverse().ToArray(), 0);
            return converted;
        }
        else
        {
            int converted = BitConverter.ToInt32(numberBytes, 0);
            return converted;
        }
    }

    public byte[] AssembleByte(byte[] content)
    {
        byte[] mdata = null;
        // LogTool.Log("回复消息" + buffer.Length);
        mdata = new byte[content.Length + 4];

        byte[] zcd = IntToByte(content.Length);
        mdata[0] = zcd[0];
        mdata[1] = zcd[1];
        mdata[2] = zcd[2];
        mdata[3] = zcd[3];
        Array.Copy(content, 0, mdata, 4, content.Length);
        return mdata;
    }

    public void ParseByte(byte[] buffData, IProtocol iProtocol, IContentReceiver contentReceiver)
    {
        int count = buffData.Length;
        try
        {
            int currCount = 0;
            int startIndex = 0;

            // bool isEnd = false;
            while (currCount < count)
            {
                // isEnd = true;
                byte[] data = null;
                ushort xueLieHao = 1;
                int cdShort = 0;

                if (!isBufferData)
                {
                    if (weiBaoBuffData != null)
                    {
                        int maxCount = 6553500;
                        if (count + weiBaoBuffData.Length > maxCount)
                        {
                            maxCount = count + weiBaoBuffData.Length;
                        }

                        // LogTool.Log("修复包太短__" + count + "___" + weiBaoBuffData.Length);
                        byte[] newBuff = new byte[maxCount];
                        Array.Copy(weiBaoBuffData, 0, newBuff, 0, weiBaoBuffData.Length);
                        Array.Copy(buffData, 0, newBuff, weiBaoBuffData.Length, count);

                        buffData = newBuff;
                        count += weiBaoBuffData.Length;
                        // LogTool.Log("修复包后太短__" + count);
                        if (count < 6)
                        {
                            weiBaoBuffData = new byte[count];
                            // LogTool.Log("包太短222__" + count);
                            Array.Copy(buffData, currCount, weiBaoBuffData, 0, count);
                            break;
                        }
                        else
                        {
                            weiBaoBuffData = null;
                        }
                    }
                    else
                    {
                        if (count - currCount < 6)
                        {
                            weiBaoBuffData = new byte[count];
                            // LogTool.Log("包太短__" + count);
                            Array.Copy(buffData, currCount, weiBaoBuffData, 0, count);
                            break;
                        }
                    }
                }

                if (!isBufferData)
                {
                    byte[] dataBuffLanl = new byte[4];
                    dataBuffLanl[0] = buffData[currCount];
                    currCount++;
                    dataBuffLanl[1] = buffData[currCount];
                    currCount++;
                    dataBuffLanl[2] = buffData[currCount];
                    currCount++;
                    dataBuffLanl[3] = buffData[currCount];
                    currCount++;
                    cdShort = (ByteToInt(dataBuffLanl, false));
                    // LogTool.Log("数据到来" + cdShort + "__" + count + "_" + xueLieHao);
                    if ((currCount + cdShort) > count) //处理半包情况
                    {
                        lastBuffData = new byte[count - currCount];
                        lastCount = cdShort;
                        lastXueLieHao = xueLieHao;
                        Array.Copy(buffData, currCount, lastBuffData, 0, lastBuffData.Length);
                        // LogTool.Log("数据只有一半" + count + "__" + currCount + "___" + cdShort);
                        isBufferData = true;
                        break;
                    }
                    else
                    {
                        // LogTool.Log(currCount + "_收到长度：" + cdShort + "_Max" + count);
                        data = new byte[cdShort];
                        Array.Copy(buffData, currCount, data, 0, data.Length);
                    }
                }
                else if (lastCount - lastBuffData.Length > count)
                {
                    // LogTool.Log("数据只有一半的一半" + count + "__" + lastCount + "___" + lastBuffData.Length);
                    byte[] newLastBuffData = new byte[lastBuffData.Length + count];
                    Array.Copy(lastBuffData, 0, newLastBuffData, 0, lastBuffData.Length);
                    Array.Copy(buffData, 0, newLastBuffData, lastBuffData.Length, count);
                    lastBuffData = newLastBuffData;
                    break;
                }

                else if (lastBuffData != null) //处理半包情况
                {
                    isBufferData = false;
                    // LogTool.Log("修复半包" + lastCount + "__" + count + "___" +
                    //             (lastCount - lastBuffData.Length));
                    xueLieHao = lastXueLieHao;
                    data = new byte[lastCount];
                    cdShort = lastCount - lastBuffData.Length;
                    Array.Copy(lastBuffData, 0, data, 0, lastBuffData.Length);
                    Array.Copy(buffData, currCount, data, lastBuffData.Length, cdShort);
                }

                // SimulationCombat cr = SimulationCombat.Parser.ParseFrom(data);
                // RequestBuffer buffer = new RequestBuffer();
                // buffer.combatRequest = cr;
                // buffer.xlh = xueLieHao;
                // // allCount++;
                // // LogTool.Log("shoudao "+allCount);
                // // buffer.httpListenerContext = httpListenerContext;
                // LogTool.Log("收到中转服请求" + cr.CombatType + "___" + xueLieHao);
                // AddBuffer(buffer);
                currCount += cdShort;
                startIndex = currCount;
                object serializeData = iProtocol.Deserialize(data);
                contentReceiver.AddContent(serializeData);
            }

            // if (isEnd&&currCount < count&&!isBufferData)//尾包
            // {
            //     LogTool.Log("尾巴处理"+currCount+"___"+count);
            //     isWeiBao = true;
            //     lastBuffData = new byte[count - currCount];
            //     Array.Copy(buffData, currCount, lastBuffData, 0, lastBuffData.Length);
            //    
            // }
        }
        catch (Exception e)
        {
            Console.WriteLine(e);
            // RequestBuffer buffer = new RequestBuffer();
            // buffer.combatRequest = cr;
            // LogTool.Log(e);
            //
            // Send(null, null);
            // LogTool.Log("");
        }
    }
}