FPSSample分析

// Component需要是struct，并且实现IComponentData接口
public struct Foo : IComponentData
{
    public int value;
}

public struct Bar : IComponentData
{
    public int value;
}

// Entity的创建和组件添加
// Entity e = entityManager.CreateEntity();
// entityManager.AddComponentData(e, new Foo{value = 0});
// entityManager.AddComponentData(e, new Bar{value = 1});
// entityManager.SetComponentData(e, new Bar{value = 100});

// Unity提供了ComponentSystem和用于多线程的JobComponentSystem，
// 目前项目没有用到JobComponentSystem
public class FoobarSystem : ComponentSystem
{
    ComponentGroup group;

    // 通过注入的方式指定过滤的Component
    // public struct GroupType
    // {
    //    public readonly int Length;
    //    public ComponentDataArray<Foo> Foo;
    //    public ComponentDataArray<Bar> Bar;
    // }
    // [Inject] GroupType group;

    protected override void OnCreateManager(int capacity)
    {
        base.OnCreateManager(capacity);
        // 通过API指定这个System要操作带所有同时具有Foo和Bar组件实体
        // 还有一种就是上面演示的那样通过[Inject]注入的方式指定
        group = GetComponentGroup(typeof(Foo), typeof(Bar));
    }

    protected override void OnUpdate()
    {
        // 获取所有满足条件的Entity
        EntityArray entityArray = group.GetEntityArray();
        // 获取组件
        ComponentDataArray fooArray = group.GetComponentDataArray<Foo>();
        ComponentDataArray barArray = group.GetComponentDataArray<Foo>();
       
       for(int i = 0; i < fooArray.Length; i++)
       {
           Foo foo =  fooArray[i];
           Bar bar = barArray[i];
           foo.value = bar.value;

            // 正常情况下操作组件是通过EntityManager的API实现的，
            // 而这里因为操作组件会破坏内部的数据结构，导致fooArray元素变化，所以使用PostUpdateCommands使操作延迟作用
           // 需要重新设置Entity的Foo组件数据，因为Foo是个struct
           PostUpdateCommands.SetComponentData(entityArray[i], foo);
           PostUpdateCommands.RemoveComponent<Bar>(entityArray[i]);
       }
    }
}

        output.WriteBits(0, 8);                                 // 0-7位为数据包类型,由NetworkMessage定义
        output.WriteBits(Sequence.ToUInt16(outSequence), 16);   // 8-23位为输出数据包序列号
        output.WriteBits(Sequence.ToUInt16(inSequence), 16);    // 24-39位为收到的最大输入数据包序列号
        output.WriteBits(inSequenceAckMask, 16);               // 40-55位为输入数据包掩码

        if (outSequence % 3 == 0) // 每3个数据包写入从收到输入数据包到发出确认的时间间隔，用于计算rtt
        {
            var now = NetworkUtils.stopwatch.ElapsedMilliseconds;
            var timeOnServer = (byte)Math.Min(now - inSequenceTime, 255);
            output.WriteBits(timeOnServer, 8);
        }

        output.Align(); // 如果当前头部数据位数不满足8的倍数，则填充0直至字节对齐，

        // 接下来写入数据包主体,也就是消息(message)数据

public enum NetworkMessage
{
    // Shared messages
    Events      = 1 << 0, // 除了下面定义的消息类型以外的类型，一般是自定义的消息

    // Server -> Client messages
    ClientInfo  = 1 << 1, // 服务器把一些配置信息发给客户端，如协议版本号protocolId，数据压缩模型NetworkCompressionModel
    MapInfo     = 1 << 2, // 地图信息
    Snapshot    = 1 << 3, // 服务器快照数据

    // Client -> Server messages
    ClientConfig  = 1 << 1, // 需要通知给服务器的客户端参数
    Commands    = 1 << 2, // 客户端的输入指令

    FRAGMENT = 1 << 7,   // 标识数据包是否被分包
}

public class NetworkSchema
{
    ...

    public class FieldInfo // 字段定义
    {
        public string name;             // 字段名称，用于调试
        public FieldType fieldType;     // 字段类型
        public int bits;                // 字段位数
        public bool delta;              // 是否压缩过
        public int precision;           // 精度，表示{ 1.0f, 10.0f, 100.0f, 1000.0f }数组的下标，用于把浮点数转成整数 
        public int arraySize;           // 数组或字符串长度
        public int byteOffset;          // 字段的偏移量
        public int startContext;        // 用于数据压缩
        public byte fieldMask;          // 忽略被屏蔽的字段

        public FieldStatsBase stats;    // 用于编辑器中显示消息的统计信息
    }

    public List<FieldInfo> fields = new List<FieldInfo>();  // 消息的字段列表
    public int nextFieldOffset = 0;                         // 记录下一个字段的偏移量，用于计算FieldInfo.byteOffset
    public int id;                                          // 消息id

    ...
}

void ClientGameWorld.HandleTime(float frameDuration)
{
    // 采样输入指令，指令记录了采样时的渲染时间，用于延迟补偿的时间差
    m_PlayerModule.SampleInput(userInputEnabled, Time.deltaTime, m_RenderTime.tick);

    int prevTick = m_PredictedTime.tick;

    // 驱动预测时间前进
    var deltaPredictedTime = frameDuration * frameTimeScale;
    m_PredictedTime.AddDuration(deltaPredictedTime);

    // 新的预测时间 = 本地收到的最新快照时间 + 收到最新快照后已经过去的时间 + RTT + 安全量
    int preferredBufferedCommandCount = 2;      
    int preferredTick = m_NetworkClient.serverTime + (int)(((m_NetworkClient.timeSinceSnapshot + 
    m_NetworkStatistics.rtt.average) / 1000.0f) * m_GameWorld.worldTime.tickRate) + preferredBufferedCommandCount;

    // 如果新的预测时间和m_PredictedTime差距过大，则强制设置m_PredictedTime为新的预测时间
    bool resetTime = false;
    if (!resetTime && m_PredictedTime.tick < preferredTick - 3)
    {
        resetTime = true;
    }

    if (!resetTime && m_PredictedTime.tick > preferredTick + 6)
    {
        resetTime = true;
    }

    frameTimeScale = 1.0f;
    if (resetTime)
    {
        // 强制设置m_PredictedTime为新的预测时间
        m_PredictedTime.tick = preferredTick;
        m_PredictedTime.SetTime(preferredTick, 0);
    }
    else
    {
        // 根据服务器当前缓冲的命令个数来决定是否要缩放客户端的时间
        int bufferedCommands = m_NetworkClient.lastAcknowlegdedCommandTime - m_NetworkClient.serverTime;
        if (bufferedCommands < preferredBufferedCommandCount)
            frameTimeScale = 1.01f;

        if (bufferedCommands > preferredBufferedCommandCount)
            frameTimeScale = 0.99f;
    }

    // 驱动渲染时间前进
    m_RenderTime.AddDuration(frameDuration * frameTimeScale);

    // 渲染时间不能超过本地收到的最新快照时间
    if (m_RenderTime.tick >= m_NetworkClient.serverTime)
    {
        m_RenderTime.SetTime(m_NetworkClient.serverTime, 0);
    }

    // 如果渲染时间远远慢于本地收到的最新快照时间，表示本地有太多快照数据，则强制设置渲染时间
    if (m_RenderTime.tick < m_NetworkClient.serverTime - 10)
    {
        m_RenderTime.SetTime(m_NetworkClient.serverTime - 8, 0);
    }

    // 如果渲染时间接近本地收到的最新快照时间，表示本地马上没有快照数据，则让渲染时间以很慢的速度前进
    if (m_RenderTime.tick < m_NetworkClient.serverTime - 1)
    {
        m_RenderTime.AddDuration(frameDuration * 0.01f);
    }

    // 保存指令并放入发送队列中
    if (m_PredictedTime.tick > prevTick)
    {
        for (int tick = prevTick; tick < m_PredictedTime.tick; tick++)
        {
            m_PlayerModule.StoreCommand(tick);
            m_PlayerModule.SendCommand(tick);
        }
        m_PlayerModule.ResetInput(userInputEnabled);
        m_PlayerModule.StoreCommand(m_PredictedTime.tick);
    }

    m_PlayerModule.StoreCommand(m_PredictedTime.tick);
}

// 要插值的状态需要实现此接口
public interface IInterpolatedData<T>
{
    void Serialize(ref NetworkWriter writer, IEntityReferenceSerializer refSerializer);
    void Deserialize(ref NetworkReader reader, IEntityReferenceSerializer refSerializer, int tick);
    void Interpolate(ref T first, ref T last, float t);
}

// 插值功能的组件需要实现此接口
public interface IInterpolatedDataHandler : INetworkSerializable
{
    void Interpolate(GameTime time);
}

// 实现了IInterpolatedDataHandler的抽象类
public abstract class InterpolatedStructBehavior<T> : MonoBehaviour, IInterpolatedDataHandler  
    where T : struct, IInterpolatedData<T>
{
    // 插值结果
    public T State;
    // 保存服务器发送过来的历史状态
    private TickStateSparseBuffer<T> stateHistory = new TickStateSparseBuffer<T>(32);

    // 把内部状态序列化，实际上这个方法不会被调用，只有客户端才需要插值功能，而客户端不需要序列化状态发送给服务器
    public void Serialize(ref NetworkWriter writer, IEntityReferenceSerializer refSerializer)
    {
        State.Serialize(ref writer, refSerializer);
    }

    // 反序列化服务器快照到新的状态中，并保存到历史记录中
    public void Deserialize(ref NetworkReader reader, IEntityReferenceSerializer refSerializer, int tick)
    {
        var state = new T();
        state.Deserialize(ref reader, refSerializer, tick);
        stateHistory.Add(tick, state);
    }

    // 根据传入的时间进行插值，算出这个时间对应的状态
    public void Interpolate(GameTime interpTime)
    {
        int lowIndex = 0, highIndex = 0;
        float interpVal = 0;
        var interpValid = stateHistory.GetStates(interpTime.tick, interpTime.TickDurationAsFraction, ref lowIndex, ref highIndex, ref interpVal);

        if (interpValid)
        {
            var prevState = stateHistory[lowIndex];
            var nextState = stateHistory[highIndex];
            State.Interpolate(ref prevState, ref nextState, interpVal);
        }
        else
        {
            State = stateHistory.Last();
        }
    }
}

// ComponentSystem
public class InterpolatedStructBehaviorInterpolate<T,S> : ComponentSystem  
    where T : InterpolatedStructBehavior<S>
    where S : struct, IInterpolatedData<S> 
{
    public struct GroupType
    {
        public EntityArray entities;
        public ComponentArray<T> behaviors;
    }

    [Inject]
    public GroupType Group;

    public InterpolatedStructBehaviorInterpolate(GameWorld gameWorld) { m_world = gameWorld; }

    protected override void OnUpdate()
    {
        var time = m_world.worldTime;
        for (var i = 0; i < Group.behaviors.Length; i++)
        {
            // 过滤掉带ServerEntity的Entity，因为带有这个组件的Entity会被预测系统处理，不需要插值
            if(EntityManager.HasComponent<ServerEntity>(Group.entities[i])) 
                continue;
            Group.behaviors[i].Interpolate(time);
        }
    }

    readonly GameWorld m_world;
}

public class HitCollisionHistory : MonoBehaviour
{
    // 表示一个碰撞框的数据
    public struct ColliderData
    {
        // 相对于角色骨骼的坐标
        public Vector3 localPosition;
        public Quaternion localRotation;
        public Collider collider;
    }

    // 某一时刻角色骨骼的坐标，结合ColliderData就可以算出碰撞框的世界坐标
    public struct State
    {
        public int tick;
        public Vector3[] bonePositions;
        public Quaternion[] boneRotations;
    }
    
    // 角色所有碰撞框数据
    [NonSerialized] public ColliderData[] colliders;
    // 碰撞框对应骨骼的Transform数组
    [NonSerialized] public TransformAccessArray colliderParents;

    // buffer中最新数据对应的tick
    [NonSerialized] public int lastTick = -1;
    // buffer中最新数据对应的数组下标
    [NonSerialized] public int lastIndex = -1;
    // buffer中有效数据的数量
    [NonSerialized] public int bufferSize;
    // 上次回滚的时间点
    [NonSerialized] public int lastRollbackTick;

    // 记录一段时间内角色的骨骼坐标
    [NonSerialized] public State[] buffer;
    // 记录一段时间内包围球的中心点位置，
    // 用一个包围角色的球体表示角色碰撞范围，用于粗略的碰撞检测(broad phase collision detection)
    [NonSerialized] public float3[] boundsCenterBuffer;

    // 根据时间获取碰撞框数据对应的下标
    public int GetStateIndex(int tick)
    {
        // 回滚多久
        var roolbackTicks = lastTick - tick;
        if (roolbackTicks >= bufferSize || tick > lastTick)
            roolbackTicks = 0;

        // 计算下标
        var index = lastIndex - roolbackTicks;
        while (index < 0)
            index += buffer.Length;
        return index;
    }

    // 设置碰撞框的坐标
    public void EnableCollisionForIndex(int index)
    {
        collidersEnabled = true;
        
        // 快速返回
        if (buffer[index].tick == lastRollbackTick)
        {
            return;
        }

        // 把碰撞框layer调成可被击中层
        for (var i = 0; i < colliders.Length; i++)
        {
            if(colliders[i].collider.gameObject.layer != HitCollisionModule.HitCollisionLayer)
                colliders[i].collider.gameObject.layer = HitCollisionModule.HitCollisionLayer;
        }

        lastRollbackTick = buffer[index].tick;

        GameDebug.Assert(index >= 0 && index < bufferSize, "Rollback index out of bounds");

        // 遍历角色所有碰撞框
        for (var i = 0; i < colliders.Length; i++)
        {
            // 取出这一时刻角色骨骼的坐标
            var bonePosition = buffer[index].bonePositions[i];
            var boneRotation = buffer[index].boneRotations[i];

            // 计算碰撞框的世界坐标
            var worldPos = boneRotation * colliders[i].localPosition + bonePosition;
            var worldRot = boneRotation * colliders[i].localRotation;

            // 设置碰撞框的坐标
            colliders[i].collider.transform.position = worldPos;
            colliders[i].collider.transform.rotation = worldRot;
        }
    }
}

// 挂载这个组件的Entity表示Entity及其INetworkSerializable组件会被同步到客户端
public struct ReplicatedDataEntity : IComponentData
{
    public int typeId; // Entity的类型id，由编辑器自动分配的
    public int id;     // Entity id 
    public int predictingPlayerId;  // 正在预测这个entity的玩家id  
}

// 管理可同步的Entity
public class ReplicatedEntityCollection : IEntityReferenceSerializer
{
    // 可同步的Entity以及它上面的需要同步的组件
    public struct ReplicatedData
    {
        public Entity entity;
        public INetworkSerializable[] serializableArray;
        public int lastServerUpdate;
    }

    ...

    // 添加一个新的Entity和实现了INetworkSerializable的组件
    public void Register(int entityId, Entity entity, INetworkSerializable[] serializableArray)
    {
        // 列表扩容
        if (entityId >= m_replicatedData.Count)
        {
            var count = entityId - m_replicatedData.Count + 1;
            var emptyData = new ReplicatedData();
            for (var i = 0; i < count; i++)
            {
                m_replicatedData.Add(emptyData);
            }
        }

        GameDebug.Assert(m_replicatedData[entityId].entity == Entity.Null,"ReplicatedData has entity set:{0}", m_replicatedData[entityId].entity);
        
        // 按类型名称对组件排序，保证客户端和服务器按同样的顺序序列化和反序列化组件
        networkSerializables.Clear();
        networkSerializables.AddRange(serializableArray);
        networkSerializables.Sort((p1,p2)=>p1.GetType().Name.CompareTo(p2.GetType().Name));
        
        var data = new ReplicatedData
        {
            entity = entity,
            serializableArray = networkSerializables.ToArray()
        };
        
        // entityid作为列表下标
        m_replicatedData[entityId] = data;
    }
    
    // 移除Entity
    public Entity Unregister(int entityId)
    {
        var entity = m_replicatedData[entityId].entity;
        GameDebug.Assert(entity != Entity.Null,"Unregister. ReplicatedData has has entity set");

        m_replicatedData[entityId] = new ReplicatedData();
        return entity;
    }

    // 收到服务器快照数据，更新Entity状态
    public void ProcessEntityUpdate(int serverTick, int id, ref NetworkReader reader)
    {
        var data = m_replicatedData[id];
        
        // 记录最新的更新时间
        GameDebug.Assert(data.lastServerUpdate < serverTick, "Failed to apply snapshot. Wrong tick order. entityId:{0} snapshot tick:{1} last server tick:{2}", id, serverTick, data.lastServerUpdate);
        data.lastServerUpdate = serverTick;

        GameDebug.Assert(data.serializableArray != null, "Failed to apply snapshot. Serializablearray is null");

        foreach (var entry in data.serializableArray)
            entry.Deserialize(ref reader, this, serverTick);

        m_replicatedData[id] = data;
    }

    // 序列化某个Entity的快照数据
    public void GenerateEntitySnapshot(int entityId, ref NetworkWriter writer)
    {
        var data = m_replicatedData[entityId];

        GameDebug.Assert(data.serializableArray != null, "Failed to generate snapshot. Serializablearray is null");
        
        foreach (var entry in data.serializableArray)
            entry.Serialize(ref writer, this);
    }

    ...

    List<ReplicatedData> m_replicatedData = new List<ReplicatedData>(512);
}