unity c#帧同步网络优化方案

unity帧同步实现机制分享:

看了很多文章,也在自己的游戏中亲自编写,整理并实现了一套帧同步方案,废话不多,直接分享。

网络重播:这块是帧同步必须做的,我们需要把服务器发过来的每一帧,以及随机种子,英雄数据记录下来,用于重播,有人问为什么要重播呢?因为重播是查不同步的重要手段,你大概率都不知道你干什么导致不同步了,那么你可以利用你的保存的数据用每个玩家重播一遍,看看差异在哪里,从而定位到导致不同步的代码。

定点数的使用:既然要同步,那必须使用定点数了,因为浮点数的计算结果不一定一样,使用定点数,可以保证结果的一致性。我们使用的是long 保存,把浮点数左移14位的做法,然后重载所有云算符。

 

  1. 传输协议:战斗使用冗余UDP(我们暂时用的是3),什么是冗余呢,就是说UDP协议不保证客户端肯定能收到,那么每次下发一帧的时候,会携带前2帧的数据,这样,即便丢包,也能保证大概率客户端稳定。
  2. 超时TCP重传机制,网络非常不好的情况,那么,就会造成丢帧较多,即便冗余也可能缺帧
     //如果客户端的帧和服务器的帧误差小于Margin的帧数,则为安全边际,
     //否则需要重新从服务器请求丢失的帧信息
     ret = (serverFrame - clientFrame) <= nFrames; 

     

  3. 位置计算:所有的逻辑帧,只计算起始位置,朝向,速度,表现帧计算具体:
  4.  ///距离大于1.5s的位移,暂时先直接拉扯
            ///如果x/z小于一帧位移距离,也直接拉扯
            ///其余情况 匀速移动,减速,加速情况后续会加
            private Vector3 LerpPos(Vector3 start, Vector3 end, float intepoation)
            {
                Vector3 pos = new Vector3(start.x, start.y, start.z);
    
                //pve加速模式 或 pvp落后很多帧情况下,直接移动到对应位置
                if (GameLogic.TestMode || FrameDriver.Current.GetIsRunFast())
                {
                    pos.x = end.x;
                    pos.z = end.z;
                }
    
                if (Vector3.Distance(start, end) > Speed * 1.5f)
                {
                    pos.x = end.x;
                    pos.z = end.z;
                }
                else
                {
                    float dis = Mathf.Sqrt((end.x - start.x) * (end.x - start.x) + (end.z - start.z) * (end.z - start.z));
                    if (dis != 0)
                    {
                        float moveX = (end.x - start.x) / dis * Speed * intepoation;
                        float moveZ = (end.z - start.z) / dis * Speed * intepoation;
                        if (Mathf.Abs(start.x - end.x) > Mathf.Abs(moveX))
                        {
                            pos.x = start.x + moveX;
                        }
                        else
                        {
                            pos.x = end.x;
                        }
    
                        if (Mathf.Abs(start.z - end.z) > Mathf.Abs(moveZ))
                        {
                            pos.z = start.z + moveZ;
                        }
                        else
                        {
                            pos.z = end.z;
                        }
                    }
                }
                var positionY = GameScene.Current.mMapHypsogramInfo.GetHeight_View(pos.x, pos.z) + L2VRiseHigh;
                pos.y = Mathf.Lerp(start.y, positionY, LERP_POS_T);
                return pos;
            }
            private int LerpToAngle(ref float angle, int dstAngle, float intepoation)
            {
                var delta = Tr.DeltaAngle((int)angle, dstAngle);
                if (Abs(delta) > 5F)
                {
                    var d = Mathf.Lerp(0, delta, 0.4F * Time.deltaTime * 60);
                    angle += d;
                }
                else
                {
                    angle = dstAngle;
                }
                return delta;
            }

    上面是所有可控制物体的位置以及角度运算,位置采用匀速,角度采用每次update40%的方式插值。

  5. 帧缓存算法:我这里提供一下最简单的一种,当然也是最稳定有效的算法,网上有很多可查的jitterbuffer算法,实现起来,理解起来都需要费电李琦,不如来个简单的,- -,好用就行。方法很简单,我缓存最近100帧的延迟(到客户端解析的时候算时间,这个才是真正能驱动游戏的时间),然后排序,去掉几个最大最小值,然后去5个最大最小值的差平均为jitter值,直接上代码:
     using System;
    using System.Text;
    
    namespace YHP1
    {
        /// 
        /// 网络抖动值
        /// 
        public class NetJitterTime
        {
            private const int MAX_CALC_DELAY_LEN = 100;
            private const int AVERAGE_NUM = 5;
            private const int DISCARD_NUM = 2;
            private float[] delayArr = new float[MAX_CALC_DELAY_LEN];
            private float[] sortedDelayArr = new float[MAX_CALC_DELAY_LEN];
            private bool isInitialed = false;
            private int oldestIndex = 0;
    
    
            public void Update(float aDelay)
            {
                if (!isInitialed)
                {
                    Initial(aDelay);
                    return;
                }
                InsertOneDelay(aDelay);
            }
    
            //按照升序,初始化所有的延迟
            private void Initial(float aDelay)
            {
                sortedDelayArr[oldestIndex] = aDelay;
                delayArr[oldestIndex] = aDelay;
                int currentindex = oldestIndex - 1;
                while (currentindex >= 0)
                {
                    if (sortedDelayArr[currentindex] > sortedDelayArr[currentindex + 1])
                    {
                        Swap(ref sortedDelayArr[currentindex], ref sortedDelayArr[currentindex + 1]);
                        currentindex--;
                    }
                    else
                    {
                        break;
                    }
                }
                oldestIndex++;
                if (oldestIndex >= MAX_CALC_DELAY_LEN)
                {
                    isInitialed = true;
                    oldestIndex = 0;
                }
            }
    
            public void InsertOneDelay(float aDelay)
            {
                oldestIndex = oldestIndex % MAX_CALC_DELAY_LEN;
                float deletDelayVale = delayArr[oldestIndex];
                delayArr[oldestIndex] = aDelay;
                oldestIndex++;
                int sortIndex = BinarySearch(sortedDelayArr, 0, MAX_CALC_DELAY_LEN - 1, deletDelayVale);
                if (sortIndex < 0 || sortIndex >= MAX_CALC_DELAY_LEN)
                {
                    Logger.LogError("InsertOneDelay sortIndex is a invalid number : " + sortIndex);
                    return;
                }
                sortedDelayArr[sortIndex] = aDelay;
    
                //替换最老数据以后使用插入排序
                if (sortIndex - 1 > 0 && sortedDelayArr[sortIndex - 1] > sortedDelayArr[sortIndex])
                {
                    sortIndex--;
                    while (sortIndex >= 0)
                    {
                        if (sortedDelayArr[sortIndex] > sortedDelayArr[sortIndex + 1])
                        {
                            Swap(ref sortedDelayArr[sortIndex], ref sortedDelayArr[sortIndex + 1]);
                            sortIndex--;
                        }
                        else
                        {
                            break;
                        }
                    }
                }
                else if (sortIndex + 1 < MAX_CALC_DELAY_LEN && sortedDelayArr[sortIndex + 1] < sortedDelayArr[sortIndex])
                {
                    sortIndex++;
                    while (sortIndex < MAX_CALC_DELAY_LEN)
                    {
                        if (sortedDelayArr[sortIndex] < sortedDelayArr[sortIndex - 1])
                        {
                            Swap(ref sortedDelayArr[sortIndex], ref sortedDelayArr[sortIndex - 1]);
                            sortIndex++;
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }
    
    
            private float GetJitterTime()
            {
                if (isInitialed)
                {
                    float minSum = 0;
                    for (int i = DISCARD_NUM; i < AVERAGE_NUM + DISCARD_NUM; i++)
                    {
                        minSum += sortedDelayArr[i];
                    }
                    float maxSum = 0;
                    for (int i = MAX_CALC_DELAY_LEN - 1 - DISCARD_NUM; i >= MAX_CALC_DELAY_LEN - AVERAGE_NUM - DISCARD_NUM; i--)
                    {
                        maxSum += sortedDelayArr[i];
                    }
                    float jitter = (maxSum - minSum) / AVERAGE_NUM;
                    if (jitter < GameConfig.FrameIntervalL / 2)
                    {
                        return 0;
                    }
                    return jitter;
                }
                else
                {
                    return 0;
                }
            }
    
            public int GetJitterLength()
            {
                float jitterTime = GetJitterTime();
                int result = UnityEngine.Mathf.CeilToInt(jitterTime / (GameConfig.FrameIntervalL * 1000));
                return result;
            }
    
            public static void Swap(ref T a, ref T b)
            {
                T t = a;
                a = b;
                b = t;
            }
    
            //二分搜索找到排序中的最老的值的index
            public static int BinarySearch(float[] arr, int low, int high, float key)
            {
                int mid = (low + high) / 2;
                if (low > high)
                    return -1;
                else
                {
                    if (arr[mid] == key)
                        return mid;
                    else if (arr[mid] > key)
                        return BinarySearch(arr, low, mid - 1, key);
                    else
                        return BinarySearch(arr, mid + 1, high, key);
                }
            }
    
            public void Clear()
            {
                isInitialed = false;
                oldestIndex = 0;
            }
    
        }
    }
    

    上面代码很多参数可调,根据实际项目决定,基本可以实现客户端流畅运行,不过会适当增加自己的操作延迟,其实就是用延迟换流畅。

  6.  帧执行逻辑:为了应付网络抖动,可能缺帧或者多帧的情况,客户端要流畅,至少保证每逻辑帧能有一帧的数据。我的处理是,没有帧的时候就等,因为项目原因,做不到预测回滚,或者说比较麻烦,因此这里暂时就是没有帧的时候会小卡一下,多帧的时候,采用每update一次执行一帧,当执行到jitterbuffer保存的值的时候,那么就每逻辑帧时间执行一帧(1/16s)。
            protected void ExecutesLogicFrames(float delta)
            {
                if (mFrameBuffer.LastFrame == 0)
                    return;
    
                int jitterLength = NetworkSyncManager.Instance.GetJitterLength();
    
                if (ShouldRunFast(jitterLength))
                {
                    int K = 0;
                    while (true)
                    {
                        var L = mFrameBuffer.NextFrame();
                        if (!ExecuteEachFrame(L))
                        {
                            return;
                        }
                        ++K;
                        if (K > 50)
                        {
                            break;//一次最多跑50帧,避免主线程卡死
                        }
                    }
                }
                else
                {
                    mTickTime += delta;
                    if (mTickTime < GameConfig.FrameIntervalL && mFrameBuffer.IsConsumeBuffer(jitterLength))
                    {
                        return;
                    }
    
                    var L = mFrameBuffer.NextFrame();
                    if (L != null)
                    {
                        mTickTime = 0;
                        ExecuteEachFrame(L);
                    }
                }
            }

    哈,看到快速模式了对吧,这个是下面要讲的。

  7. 10.快速模式呢,就是追帧,跟大家差的太远了,正常执行已经很难追上了:

  8.         private bool ShouldRunFast(int jitterLength)
            {
                if (FastMode)
                    return true;
    
                if (mIsRunFast)
                {
                    if (mFrameBuffer.CacheFrameNum() <= jitterLength)
                        mIsRunFast = false;
                }
                else
                {
                    if (FrameInfo.ServerFrame - FrameInfo.CurFrame > 90)
                        mIsRunFast = true;
                }
    
                return mIsRunFast;
            }

    这里简单给了一下是否快速执行,

  9.  

你可能感兴趣的:(帧同步,帧同步)