咖啡丶七

public class MoveState : CharacterState
{
    private void OnEnable()
    {
        Debug.Log("播放Move动画");
    }
}

public class IdleState : CharacterState
{
    private void OnEnable()
    {
        Debug.Log("播放Idle动画");
    }

    private void Update()
    {
        // 不要出现如下状态转换的逻辑，这种逻辑应该在PlayerBrain里做
        // if (Input.GetKeyDown(KeyCode.Space))
        // {
        //     _stateMachine.TrySetState(State.Air);
        // }
    }
}

public class AttackState : CharacterState
{
    [SerializeField]
    private PlayerBrain1 _brain;
    private int _animationTime = 1000;
    private void OnEnable()
    {
        Debug.Log("播放Attack动画");
        AnimationDelay();
    }

    // 将攻击状态设置为中优先级，避免被其他状态打断
    public override CharacterStatePriority Priority
        => CharacterStatePriority.Medium;

    private async void AnimationDelay()
    {
        await Task.Delay(_animationTime);               // 模拟动画播放
        _brain.StateMachine.ForceSetDefaultState();     // 在动画播放完毕后强制设置成默认状态
    }
}

private void Update()
{
    if (在空中)
        FSM.TrySetState(State.Air);         // 角色在空中，成功进入了空中状态
    FSM.TrySetState(State.Idle);            // 但是还会继续执行Update，导致进入Idle状态。
    // 最终表现在游戏中的结果是玩家疯狂在这两个状态中切换
}

private void Update()
{
    if (在空中)
        FSM.TrySetState(State.Air);         // 角色在空中，成功进入了空中状态
    else
        FSM.TrySetState(State.Idle);        // 角色不在空中，则进入Idle状态
}

public sealed class PlayerBrain1 : MonoBehaviour
{
    public StateMachine<CharacterState>.WithDefault StateMachine = new();

    [SerializeField] private CharacterState _idleState;
    [SerializeField] private CharacterState _moveState;
    [SerializeField] private CharacterState _attackState;


    private void Start()
    {
        // 初始化状态机，需要选择默认状态，在使用ForceSetDefaultState等方法时会进入该状态
        StateMachine.InitializeAfterDeserialize(_idleState);
    }

    private void Update()
    {
        UpdateMovement();
        UpdateAttackAction();
    }

    private void UpdateMovement()
    {
        if (Input.GetAxis("Horizontal") != 0)
        {
            // 两种方法进入状态
            StateMachine.TrySetState(_moveState);
            // _stateMachine.TrySetState(_moveState);
        }
        else
        {
            StateMachine.TrySetState(_idleState);
        }
    }

    private void UpdateAttackAction()
    {
        if (!Input.GetMouseButtonDown(0)) return;
        StateMachine.TrySetState(_attackState);
    }
}

public sealed class PlayerBrain2 : MonoBehaviour
{
    private enum State { Idle, Move }

    [SerializeField]
    private StateMachine<State, CharacterState>.WithDefault _stateMachine = new();

    [SerializeField] private CharacterState _idleState;
    [SerializeField] private CharacterState _moveState;

    private void Awake()
    {
        // 需要映射枚举与状态的关系
        _stateMachine.AddRange(
            new [] { State.Idle , State.Move },
            new [] { _idleState, _moveState});
    }

    private void Start()
    {
        // 可以使用枚举初始化
        _stateMachine.InitializeAfterDeserialize(State.Idle);
    }

    private void Update()
    {
        UpdateMovement();
    }

    private void UpdateMovement()
    {
        if (Input.GetAxis("Horizontal") > .1f)
            _stateMachine.TrySetState(State.Move);      // 可以使用枚举做状态转换，而不需要类的实例
        else
            _stateMachine.TrySetState(State.Idle);
    }
}

public struct StateChange<TState> : IDisposable
    where TState : class, IState
{
    [ThreadStatic]  // 标记为线程静态
    public static StateChange<TState> _current;

    private StateMachine<TState> _stateMachine;
    private TState _previousState;
    private TState _nextState;

    internal StateChange(StateMachine<TState> stateMachine, TState previousState, TState nextState)
    {
        this = _current;    // 嵌套循环中上一层的 StateChange 暂存在 this 中，方便在 using 结束时复原

        _current._stateMachine = stateMachine;
        _current._previousState = previousState;
        _current._nextState = nextState;
    }

    public void Dispose()
    {
        _current = this;        // 在退出 using 时复原嵌套循环上一层的 StateChange
    }
}

public class AttackState : State
{
    StateMachine<State>.WithDefault _stateMachine;
    public AttackState(StateMachine<State>.WithDefault stateMachine)
    {
        _stateMachine = stateMachine;
    }

    public override void OnEnterState()
    {
        // 输出： 从 IdleState 进入 AttackState
        Debug.Log($"从 {_stateMachine.PreviousState} 进入 {_stateMachine.NextState}");
    }
}

public class RunState : State
{
    // 在进入 RunState 时，可能需要判断是否应该返回 DefaultState 或者进入 HitState
    public override void OnEnterState()         // 第一层嵌套，FallState -> RunState
    {
        Debug.Log($"第一层嵌套开始 {_stateMachine.NextState}");    // 输出：第一层嵌套开始 RunState

        if (true)
        {
            _stateMachine.TrySetDefaultState();     // 第二层嵌套一号，RunState -> DefaultState
        }
        
		// 输出：第二层嵌套结束，继续第一次嵌套 RunState
        Debug.Log($"第二层嵌套结束，继续第一次嵌套 {_stateMachine.NextState}");    

         if (true)
        { 
            _stateMachine.TrySetState(_brain.hitState);     // 第二层嵌套二号，RunState -> HitState
        }
    }
}

using (new StateChange<TState>(stateMachine, FallState, RunState))
{
    using (new StateChange<TState>(stateMachine, RunState, DefaultState))
    {
    }
    
    using (new StateChange<TState>(stateMachine, RunState, HitState))
    {
    }
}

public void ForceSetState(TState state)
{
    using (new StateChange<TState>(this, CurrentState, state))	//执行构造函数： 将 FallState -> RunState 暂存在this中
    {
        CurrentState?.OnExitState();

        _currentState = state;

        state?.OnEnterState();
    }						// 执行Dispose： 将 FallState -> RunState 复原
}

internal StateChange(StateMachine<TState> stateMachine, TState previousState, TState nextState)
{
    this = _current;    // 将 FallState -> RunState 暂存在this中
 
    _current._stateMachine = stateMachine;		// 开始第二层嵌套一号
    _current._previousState = previousState;
    _current._nextState = nextState;
}

public void Dispose()
{
    _current = this;        // 将 FallState -> RunState 复原
}

TrackEntry shootTrack = skeletonAnimation.AnimationState.SetAnimation(1, shoot, false);
shootTrack.AttachmentThreshold = 1f;	// 表示shoot在与其他动画融合时，依然会完整运行自己的动画
shootTrack.MixDuration = 0f;		// 表示进入shoot不需要融合

private void DisposableSubscribe()
{
    // better performance
    var d = Disposable.CreateBuilder();
    Observable.EveryUpdate().Subscribe().AddTo(ref d);
    Observable.EveryUpdate().Subscribe().AddTo(ref d);
    Observable.EveryUpdate().Subscribe().AddTo(ref d);
    d.RegisterTo(this.destroyCancellationToken); // Build and Register
}

```





#### 多个事件

```c#
private DisposableBag d;		// 监听的事件较多时可以使用DisposableBag统一处理

private void OnDestroy()
{
    subscription?.Dispose();
    d.Dispose();
    cts?.Dispose();
}

exitButton.OnClickAsObservable().Subscribe(_ => ExitGame());

// 遍历所有Entity并删除
foreach (var world in World.All)
{
    if (world.Flags == WorldFlags.Game)
    {
        world.Dispose();
        break;
    }
}
// 上面只能删除Entity，并不会删除GameObject的，所以需要使用Single
SceneManager.LoadScene(1, LoadSceneMode.Single);

private void StartServer()
{
    var serverWorld = ClientServerBootstrap.CreateServerWorld("Coffee Server World");	// 创建服务端世界

    // 使服务器监听7979端口
    var serverEndpoint = NetworkEndpoint.AnyIpv4.WithPort(7979);
    {
        using var networkDriverQuery = serverWorld.EntityManager.CreateEntityQuery(ComponentType.ReadWrite<NetworkStreamDriver>());
        networkDriverQuery.GetSingletonRW<NetworkStreamDriver>().ValueRW.Listen(serverEndpoint);
    }
}

public enum TeamType : byte
{
    None = 0,
    Blue = 1,
    Red = 2,
    AutoAssign = byte.MaxValue
}
public struct ClientTeamSelect : IComponentData
{
    public TeamType Value;
}

private void StartClient()
{
    var clientWorld = ClientServerBootstrap.CreateClientWorld("Coffee Client World");	// 创建客户端世界

    var connectionEndpoint = NetworkEndpoint.Parse("127.0.0.1", 7979);		// 将用户输入转换成网络地址
    {
        // 根据端口连接服务端
        using var networkDriverQuery = clientWorld.EntityManager.CreateEntityQuery(ComponentType.ReadWrite<NetworkStreamDriver>());
        networkDriverQuery.GetSingletonRW<NetworkStreamDriver>().ValueRW.Connect(clientWorld.EntityManager, connectionEndpoint);
    }

    // 将对Default World世界的操作同步到Client World，以免每次操作都要使用Client的API
    World.DefaultGameObjectInjectionWorld = clientWorld;

    var team = _teamDropdown.value switch		// 设置传递给Entities的信息
    {
        0 => TeamType.AutoAssign,
        1 => TeamType.Blue,
        2 => TeamType.Red,
        _ => TeamType.None
    };
    
	// 将用户在GameObject中选择的队伍传递到Entities中，！！！注意：这里并没有向服务端发送请求
    var teamRequestEntity = clientWorld.EntityManager.CreateEntity();
    clientWorld.EntityManager.AddComponentData(teamRequestEntity, new ClientTeamSelect()
    {
        Value = team
    });
}

// 只在客户端运行
[WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation | WorldSystemFilterFlags.ThinClientSimulation)]   
public partial struct ClientRequestGameEntrySystem : ISystem
{
    private EntityQuery _pendingNetworkIdQuery;

    public void OnCreate(ref SystemState state)
    {
        // 捕获有`NetworkId`且没有`NetworkStreamInGame`的实体
        // "NetworkStreamInGame"是unity为我们准备的一个统一标签，表示该client已经处理过登录了
        var builder = new EntityQueryBuilder(Allocator.Temp).WithAll<NetworkId>().WithNone<NetworkStreamInGame>();
        _pendingNetworkIdQuery = state.GetEntityQuery(builder);
        state.RequireForUpdate(_pendingNetworkIdQuery);
        state.RequireForUpdate<ClientTeamSelect>();        // 获取在登入界面创建的组件
    }

    public void OnUpdate(ref SystemState state)
    {
        // 获取在登入界面创建的组件
        var requestedTeam = SystemAPI.GetSingleton<ClientTeamSelect>().Value;

        var ecb = new EntityCommandBuffer(Allocator.Temp);
        var pendingNetworkIds = _pendingNetworkIdQuery.ToEntityArray(Allocator.Temp);

        foreach (Entity pendingNetworkId in pendingNetworkIds)// 肯定是只有一个的，所以也使用pendingNetworkIds[0]
        {
            ecb.AddComponent<NetworkStreamInGame>(pendingNetworkId); // 将物体标记为进入游戏，该组件是一个Tag
            
            // 向服务器发送请求，这里才是真正向服务器发送请求
            var requestTeamEntity = ecb.CreateEntity();
            ecb.AddComponent(requestTeamEntity, new MobaTeamRequest() { Value = requestedTeam });
            ecb.AddComponent(requestTeamEntity, new SendRpcCommandRequest() { TargetConnection = pendingNetworkId });
        }

        ecb.Playback(state.EntityManager);		// 等待缓冲器完成所有任务
    }
}

[WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]      // 只在服务端运行
public partial struct ServerProcessGameEntryRequestSystem : ISystem
{
    public void OnCreate(ref SystemState state)
    {
        state.RequireForUpdate<MobaPrefabs>();
        var builder = new EntityQueryBuilder(Allocator.Temp).WithAll<MobaTeamRequest, ReceiveRpcCommandRequest>();
        state.RequireForUpdate(state.GetEntityQuery(builder));  // 获取到信息包才执行update
    }

    public void OnDestroy(ref SystemState state) { }

    public void OnUpdate(ref SystemState state)
    {
        var ecb = new EntityCommandBuffer(Allocator.Temp);
        var championPrefab = SystemAPI.GetSingleton<MobaPrefabs>().Champion;    // 获取角色预制体

        foreach (var (teamRequest, requestSource, requestEntity) 
                 in SystemAPI.Query<MobaTeamRequest, ReceiveRpcCommandRequest>().WithEntityAccess())
        {
            ecb.DestroyEntity(requestEntity);   // 客户端发送的请求包，但这里需要手动销毁。
            // requestSource.SourceConnection为客户端存放在服务端上的连接器，每个客户端就会存放一个
            ecb.AddComponent<NetworkStreamInGame>(requestSource.SourceConnection);

            // 数据处理
            var requestedTeamType = teamRequest.Value;

            if (requestedTeamType == TeamType.AutoAssign)
            {
                requestedTeamType = TeamType.Blue;
            }

            float3 spawnPosition = new float3(0, 1, 0);

            switch (requestedTeamType)
            {
                case TeamType.Blue:
                    spawnPosition = new float3(-50f, 1f, -50f);
                    break;
                case TeamType.Red:
                    spawnPosition = new float3(50f, 1f, -50f);
                    break;
                default:
                    continue;
            }
			     // 获取客户端ID
            var clientId = SystemAPI.GetComponent<NetworkId>(requestSource.SourceConnection).Value;

            // Debug.Log($"{clientId}   {requestedTeamType.ToString()}");

            var newChamp = ecb.Instantiate(championPrefab);         // 实例化角色
            ecb.SetName(newChamp, "Champion");      // 方便测试，设置名称
            var newTransform = LocalTransform.FromPosition(spawnPosition);
            ecb.SetComponent(newChamp, newTransform);
            // NetworkId是幽灵数据，即完全由服务端控制，设置该数值后clientId客户端对应的Entity的GhostOwnerIsLocal将被标记为true，GhostOwnerIsLocal同样也只能被服务端控制
            ecb.SetComponent(newChamp, new GhostOwner() { NetworkId = clientId });
            ecb.SetComponent(newChamp, new MobaTeam() { Value = requestedTeamType });   // 设置队伍

            // 当玩家断线重连时，会摧毁旧的Entity，并创建新的Entity
            ecb.AppendToBuffer(requestSource.SourceConnection, new LinkedEntityGroup(){ Value = newChamp }); 
        }

        ecb.Playback(state.EntityManager);
    }
}

// 下面代码可能无法通过编译，但只是想简单的告诉你发送RPC的方法就是：
// 创建一个实体，并在其上面添加实现`IRpcCommand`接口的数据组件，和`SendRpcCommandRequest`的特殊组件就OK了
// 其他的系统会自动帮你完成
public struct LoadLevelRPC : IRpcCommand
{
    public int LevelIndex;
}
private void LoadNewLevel(int levelIndex)
{
    var rpcEntity = EntityManager.CreateEntity(typeof(LoadLevelRPC), typeof(SendRpcCommandRequest));
    EntityManager.SetComponentData(rpcEntity, new LoadLevelRpc()
    {
        LevelIndex = levelIndex
    });
}

// 捕获unity转换成ReceiveRpcCommandRequest的实体
foreach (var (levelToLoad, rpcEntity) in 
         SystemAPI.Query<LoadLevelRPC>().WithAll<ReceiveRpcCommandRequest>().WithEntityAccess())
{
    ecb.DestroyEntity(rpcEntity);			// 删除数据包
    LoadLevel(levelToLoad.LevelIndex);		// 数据处理
}

[DontSupportPrefabOverrides]
[GhostComponent(SendDataForChildEntity = true)]
public struct GhostOwner : IComponentData
{
    [GhostField] public int NetworkId;
}

public struct GhostOwnerIsLocal : IComponentData, IEnableableComponent { }

// [UpdateInGroup(typeof(SimulationSystemGroup), OrderFirst = true)]	// 共同初始化
// [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation | WorldSystemFilterFlags.ThinClientSimulation)]  // 只在客户端上初始化
// [WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]      // 只在服务端运行
public partial struct InitializeCharacterSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var ecb = new EntityCommandBuffer(Allocator.Temp);
        foreach (var (physicsMass, mobaTeam, newCharacterEntity) in SystemAPI.Query<RefRW<PhysicsMass>, MobaTeam>().WithAll<NewChampTag>().WithEntityAccess())
        {
            // ...
            // 初始化角色
            // ...
            ecb.RemoveComponent<NewChampTag>(newCharacterEntity);	// 非常经典的"工具人"标签
        }
        ecb.Playback(state.EntityManager);
    }
}

var teamColor = mobaTeam.Value switch
{
    TeamType.Blue => new float4(0, 0, 1, 1),
    TeamType.Red => new float4(1, 0, 0, 1),
    _ => new float4(1)
};

ecb.SetComponent(newCharacterEntity, new URPMaterialPropertyBaseColor{ Value = teamColor });	// 设置颜色

public struct DamageThisTick : ICommandData{
    public NetworkTick Tick {get; set;}
    public int Value
}

// [GhostComponent(PrefabType = GhostPrefabType.AllPredicted)]		// 可以优化需要传递的对象
public struct ChampMoveTargetPosition : IInputComponentData
{
    // [GhostField(Quantization = 0)]		// 设置精度，0表示全精度；1表示整数；10表示0.1f
    public float3 Value;		// IInputComponentData会自动将自身的数据修饰为[GhostField]
}

[UpdateInGroup(typeof(GhostInputSystemGroup))]  // 添加到输入组，该组只存在于Client中
public partial class ChampMoveInputSystem : SystemBase
{
    protected override void OnStartRunning()
    {
        // 以委托事件的形式监听输出
        PlayerInputSystem.Instance.SelectMovePositionEvent += OnSelectMovePosition;
    }

    protected override void OnStopRunning()
    {
        PlayerInputSystem.Instance.SelectMovePositionEvent -= OnSelectMovePosition;
    }
    
    private void OnSelectMovePosition(InputAction.CallbackContext obj)
    {
        var champEntity = SystemAPI.GetSingletonEntity<OwnerChampTag>();
        EntityManager.SetComponentData(champEntity, new ChampMoveTargetPosition()
        {
            Value = closestHit.Position		// 设置数值，unity会自动将其同步到main entity上
        });
    }
}

// [GhostComponent(PrefabType = GhostPrefabType.AllPredicted)]		// 可以优化需要传递的对象
public struct AbilityInput : IInputComponentData
{
    // [GhostField]
    public InputEvent AoeAbility;		// IInputComponentData会自动将自身的数据修饰为[GhostField]
}

[UpdateInGroup(typeof(GhostInputSystemGroup))]  // 添加到输入组，该组只存在于Client中
public partial class AbilityInputSystem : SystemBase
{
    protected override void OnUpdate()
    {  
        var newAbilityInput = new AbilityInput();			// 因为是结构体是值类型，所以不会有GC；

        if (PlayerInputSystem.Instance.QKeyWasPressedThisFrame)		// 监听输入
        {
            newAbilityInput.AoeAbility.Set();		// Set()表示加一，即被按下了
        }

        foreach (var abilityInput in SystemAPI.Query<RefRW<AbilityInput>>())
        {
            abilityInput.ValueRW = newAbilityInput;		// 设置数值，unity会自动将其同步到main entity上
        }
    }
}

private void OnSelectMovePosition()
{
    var collisionWorld = SystemAPI.GetSingleton<PhysicsWorldSingleton>().CollisionWorld;	// 获取物理系统
    var cameraEntity = SystemAPI.GetSingletonEntity<MainCameraTag>();
    var mainCamera = EntityManager.GetComponentObject<MainCamera>(cameraEntity).Value;		// 获取相机位置

    var mousePosition = Input.mousePosition;        // 屏幕像素坐标
    mousePosition.z = 100f;         // 屏幕坐标的Z表示屏幕距离，100表示屏幕前方100米
    var worldPosition = mainCamera.ScreenToWorldPoint(mousePosition);   // 转换成世界坐标
    
    // 设置射线的起点、终点和碰撞规则
    var selectionInput = new RaycastInput()
    {
        Start = mainCamera.transform.position,
        End = worldPosition,			// BelongTo射线属于第五层  CollidesWith射线将与第一层碰撞
        Filter = new CollisionFilter() { BelongsTo = 1 << 5, CollidesWith = 1 << 0 };
    };
    if (collisionWorld.CastRay(selectionInput, out RaycastHit closestHit))   // 使用Entity的碰撞世界进行射线检测
    {					// RaycastHit看起来和GameObject的长的一样，但其实不是同一个类。但是用法类似
        var champEntity = SystemAPI.GetSingletonEntity<OwnerChampTag>();
        EntityManager.SetComponentData(champEntity, new ChampMoveTargetPosition()
        {
            Value = closestHit.Position		// 使用碰撞点
        });
    }
}

// 球形碰撞
var hits = new NativeList<DistanceHit>(Allocator.TempJob);
if (CollisionWorld.OverlapSphere(transform.Position, targetRadius.Value, ref hits, CollisionFilter))
{
    var closestDistance = float.MaxValue;
    var closestEntity = Entity.Null;
    foreach (var hit in hits)
    {
        if (hit.Distance < closestDistance)		// 只需要距离玩家最近的目标
        {
            closestDistance = hit.Distance;
            closestEntity = hit.Entity;
        }
    }
    targetEntity.Value = closestEntity;
}
hits.Dispose();

public struct DestroyAtTick : IComponentData
{
    [GhostField] public NetworkTick Value;		// 应在服务器的第几Tick销毁
}

public struct DestroyEntityTag : IComponentData { }		// 达到了被销毁时间的entitiy

public struct DestroyOnTimer : IComponentData
{
    public float Value;		// 烘焙预设的销毁时间
}

// 默认客户端和服务端都会执行，计算多少Tick销毁，并添加DestroyAtTick
public partial struct InitializeDestroyOnTimerSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var ecb = new EntityCommandBuffer(Allocator.Temp);
        // 获取服务器帧率：默认60
        var simulationTickRate = NetCodeConfig.Global.ClientServerTickRate.SimulationTickRate;
        var currentTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;         // 当前服务器运行多少Tick

        foreach (var (destroyOnTimer, entity) in SystemAPI.Query<DestroyOnTimer>().WithNone<DestroyAtTick>()
                     .WithEntityAccess())	// 捕获被预设为销毁的物体
        {
            var lifetimeInTicks = (uint)(destroyOnTimer.Value * simulationTickRate);
            var targetTick = currentTick;
            targetTick.Add(lifetimeInTicks);        // 设置该entity应该在服务器的第几帧销毁
            ecb.AddComponent(entity, new DestroyAtTick { Value = targetTick });
        }

        ecb.Playback(state.EntityManager);
    }
}

// 默认客户端和服务端都会执行，判断物体是否达到销毁Tick，并添加DestroyEntityTag
public partial struct DestroyOnTimerSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        // 在结束的时候添加标签
        var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);

        var currentTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;

        foreach (var (destroyAtTick, entity) in SystemAPI.Query<DestroyAtTick>().WithAll<Simulate>()
                     .WithNone<DestroyEntityTag>().WithEntityAccess())	// 捕获有销毁时间的物体
        {
            if (currentTick.Equals(destroyAtTick.Value) || currentTick.IsNewerThan(destroyAtTick.Value))
                ecb.AddComponent<DestroyEntityTag>(entity);		// Tick大于等于当前服务器Tick就添加标签
        }
    }
}

// 预测，客户端和服务端都会预测
[UpdateInGroup(typeof(PredictedSimulationSystemGroup), OrderLast = true)]
public partial struct DestroyEntitySystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var networkTime = SystemAPI.GetSingleton<NetworkTime>();

        // 在开始的时候销毁
        var ecbSingleton = SystemAPI.GetSingleton<BeginSimulationEntityCommandBufferSystem.Singleton>();
        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);

        foreach (var (transform, entity) in SystemAPI.Query<RefRW<LocalTransform>>()
                     .WithAll<DestroyEntityTag, Simulate>().WithEntityAccess())
        {
            if (state.World.IsServer())			// 服务器直接销毁
                ecb.DestroyEntity(entity);
            else								// 客户端移动到不可见位置，等待服务器同步
                transform.ValueRW.Position = new float3(999f, 999f, 999f);
        }
    }
}

public struct DamageOnTrigger : IComponentData
{
    public int Value;			// 烘焙到可造成伤害的实体上，设置其伤害量
}

public struct AlreadyDamagedEntity : IBufferElementData
{
    public Entity Value;		// 烘焙到可造成伤害的实体上，记录伤害过的实体，避免重复伤害
}

[GhostComponent(PrefabType = GhostPrefabType.AllPredicted)]
public struct DamageBufferElement : IBufferElementData
{
    public int Value;		// 烘焙到可受伤的对象上，表示该物体是可受伤的。该组件只是暂存伤害，并不直接应用
}

// 发送给除entity控制者以外的所有其他客户端Ghost entity
[GhostComponent(PrefabType = GhostPrefabType.AllPredicted, OwnerSendType = SendToOwnerType.SendToNonOwner)]
public struct DamageThisTick : ICommandData		// 烘焙到可受伤的实体上
{
    public NetworkTick Tick { get; set; }
    public int Value;
}

[UpdateInGroup(typeof(PhysicsSystemGroup))]     // 涉及到物体碰撞（即客户端表现），所以放在PhysicsSystemGroup之中
[UpdateAfter(typeof(PhysicsSimulationGroup))]
public partial struct DamageOnTriggerSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var simulationSingleton = SystemAPI.GetSingleton<SimulationSingleton>();
        state.Dependency = job.Schedule(simulationSingleton, state.Dependency);*/
        bool isClient = state.World.IsClient();
        var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
        var damageOnTriggerJob = new DamageOnTriggerJob
        {
            DamageOnTriggerLookup = SystemAPI.GetComponentLookup<DamageOnTrigger>(true),
            TeamLookup = SystemAPI.GetComponentLookup<MobaTeam>(true),
            AlreadyDamagedLookup = SystemAPI.GetBufferLookup<AlreadyDamagedEntity>(true),
            DamageBufferLookup = SystemAPI.GetBufferLookup<DamageBufferElement>(true),
            ECB = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged),
            isClient = isClient,
        };
        var simulationSingleton = SystemAPI.GetSingleton<SimulationSingleton>();
        state.Dependency = damageOnTriggerJob.Schedule(simulationSingleton, state.Dependency);
    }
}
public struct DamageOnTriggerJob : ITriggerEventsJob        // 不是普通的IJobEntity
{	// 队伍
    [ReadOnly] public ComponentLookup<MobaTeam> TeamLookup;
    // 伤害量，该组件是被烘焙在可造成伤害的实体上
    [ReadOnly] public ComponentLookup<DamageOnTrigger> DamageOnTriggerLookup;
    // 受到多少伤害，该组件是被烘焙在可受到伤害的实体上
    [ReadOnly] public BufferLookup<DamageBufferElement> DamageBufferLookup;
	// 已经受到过伤害的实体，避免重复伤害
    [ReadOnly] public BufferLookup<AlreadyDamagedEntity> AlreadyDamagedLookup;
    public EntityCommandBuffer ECB;
    
    public void Execute(TriggerEvent triggerEvent)
    {
        Entity damageDealingEntity;         // 伤害来源，即飞行物
        Entity damageReceivingEntity;       // 受击者

        // 判断两个实体，哪个是伤害来源，哪个是受击者
        if (DamageBufferLookup.HasBuffer(triggerEvent.EntityA) &&
            DamageOnTriggerLookup.HasComponent(triggerEvent.EntityB))
        {
            damageReceivingEntity = triggerEvent.EntityA;
            damageDealingEntity = triggerEvent.EntityB;
        }
        else if (DamageOnTriggerLookup.HasComponent(triggerEvent.EntityA) &&
                 DamageBufferLookup.HasBuffer(triggerEvent.EntityB))
        {
            damageDealingEntity = triggerEvent.EntityA;
            damageReceivingEntity = triggerEvent.EntityB;
        }
        else return;     // 如果碰撞的两个没有伤害组件直接返回

        if (TeamLookup.TryGetComponent(damageDealingEntity, out var damageDealingTeam) &&
            TeamLookup.TryGetComponent(damageReceivingEntity, out var damageReceivingTeam))
        {
            if (damageDealingTeam.Value == damageReceivingTeam.Value) return;   // 没有友伤
        }

        var alreadyDamagedBuffer = AlreadyDamagedLookup[damageDealingEntity];

      	// 这里客户端有一个BUG，由于ECB没有及时的将enitiy添加到队列中，会导致重复添加伤害，但服务端是好的
        foreach (AlreadyDamagedEntity alreadyDamagedEntity in alreadyDamagedBuffer)
            if (alreadyDamagedEntity.Value.Equals(damageReceivingEntity)) return; // 判断是否已经造成过伤害了

        // 将伤害量缓冲到受击者实体上
        var damageOnTrigger = DamageOnTriggerLookup[damageDealingEntity];
        ECB.AppendToBuffer(damageReceivingEntity, new DamageBufferElement {Value = damageOnTrigger.Value }); 
        // 将受击者保存到伤害来源实体上
        ECB.AppendToBuffer(damageDealingEntity, new AlreadyDamagedEntity { Value = damageReceivingEntity });
    }
}

[UpdateInGroup(typeof(PredictedSimulationSystemGroup), OrderLast = true)]
public partial struct CalculateFrameDamageSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var currentTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;

        foreach (var (damageBuffer, damageThisTickBuffer) in SystemAPI
                     .Query<DynamicBuffer<DamageBufferElement>, DynamicBuffer<DamageThisTick>>()
                     .WithAll<Simulate>())
        {
            if (damageBuffer.IsEmpty)   // 如果为空
            {
                // 配合下方的GetDataAtTick方法，需要不停的赋值
                damageThisTickBuffer.AddCommandData(new DamageThisTick { Tick = currentTick, Value = 0 });
            }
            else
            {
                var totalDamage = 0;
                // 获取最靠近当前帧的上一帧的伤害，因为上面一直在设置为0，所以大多数这里捕获的值都是0
                // TODO: 讲道理，并不知道这么做有什么用？
                if (damageThisTickBuffer.GetDataAtTick(currentTick, out var damageThisTick))
                {
                    totalDamage = damageThisTick.Value;         // 加上最近一帧的伤害
                }

                foreach (var damage in damageBuffer)
                {
                    totalDamage += damage.Value;		// 累加缓冲器中的伤害值
                }

                // 将伤害
                damageThisTickBuffer.AddCommandData(new DamageThisTick 
                                                    { Tick = currentTick, Value = totalDamage });
                damageBuffer.Clear();
            }
        }
    }
}

[UpdateInGroup(typeof(PredictedSimulationSystemGroup), OrderLast = true)]
[UpdateAfter(typeof(CalculateFrameDamageSystem))]       // 在计算伤害量之后执行
public partial struct ApplyDamageSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var currentTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
        var ecb = new EntityCommandBuffer(Allocator.Temp);

        foreach (var (currentHitPoints, damageThisTickBuffer, entity) in SystemAPI
                     .Query<RefRW<CurrentHitPoints>, DynamicBuffer<DamageThisTick>>().WithAll<Simulate>()
                     .WithEntityAccess())
        {
            if (!damageThisTickBuffer.GetDataAtTick(currentTick, out DamageThisTick damageThisTick)) continue;
            // 过滤掉不是当前帧的伤害，因为本系统是在计算伤害系统之后运行的，所以这个是可行的
            if (damageThisTick.Tick != currentTick) continue;
            currentHitPoints.ValueRW.Value -= damageThisTick.Value;

            if (currentHitPoints.ValueRO.Value <= 0)
            {
                ecb.AddComponent<DestroyEntityTag>(entity);		// 如果血量低于0就添加销毁标签
            }
        }
        ecb.Playback(state.EntityManager);
    }
}

public struct AbilityCooldownTicks : IComponentData
{
    public uint AoeAbility;		// 烘焙预设技能CD
}

[GhostComponent(PrefabType = GhostPrefabType.AllPredicted)]
public struct AbilityCooldownTargetTicks : ICommandData
{
    public NetworkTick Tick { get; set; }
    public NetworkTick AoeAbility;				// 存储技能在多少Tick结束CD
}

var isOnCooldown = true;
var curTargetTicks = new AbilityCooldownTargetTicks();

// networkTime.SimulationStepBatchSize表示务器Tick步长，通常为1（即正常状态）
// 使用for循环的原因是为了避免服务器卡顿，而跳过了cd检测，进而永远都无法解除冷却了
for (var i = 0u; i < networkTime.SimulationStepBatchSize; i++)
{
    var testTick = currentTick;
    testTick.Subtract(i);


    if (!aoe.CooldownTargetTicks.GetDataAtTick(testTick, out curTargetTicks))   // 获取上一次释放技能的Tick
    {
        curTargetTicks.AoeAbility = NetworkTick.Invalid;        // 是第一次释放技能，就设置为无效
    }

    // 如果值无效 或者 达到目标Tick，就说明CD好了
    if (curTargetTicks.AoeAbility == NetworkTick.Invalid ||     // 无效，即第一次释放技能
        !curTargetTicks.AoeAbility.IsNewerThan(currentTick))    // 当前Tick大于目标Tick，说明CD过了
    {
        isOnCooldown = false;
        break;
    }
}

if (isOnCooldown) continue;


if (输入检测)
{
    // (技能释放逻辑)...
    
    // ICommandData只用在客户端做处理，unity会自动将数据发送给服务端
    if (state.WorldUnmanaged.IsServer()) continue;
    var newCooldownTargetTick = currentTick;
    newCooldownTargetTick.Add(aoe.CooldownTicks);
    curTargetTicks.AoeAbility = newCooldownTargetTick;

    var nextTick = currentTick;			    // 为什么要记录到下一个Tick：
    nextTick.Add(1u);				    	// 当在添加ICommandData的时候，我们需要将他的执行的Tick+1
    curTargetTicks.Tick = nextTick;    		// 要不然会导致，客户端释放了技能，但是服务端并没有同步
											// 虽然看起来很怪，但这确实是可行的
    aoe.CooldownTargetTicks.AddCommandData(curTargetTicks);
}

public struct HealthBarOffset : IComponentData
{
    public float3 Value;			// 预设烘焙血条相对entity的位置偏移
}

public class HealthBarUIReference : ICleanupComponentData		// 无法烘焙
{	// 注意，因为我们的数据是引用类型，不是值类型，所以组件也只能是class
    public GameObject Value;		// 保存GameObject世界中的血条的引用
}
public class HitPointAuthoring : MonoBehaviour		// 可以和之前的受伤烘焙写在一起
{
    public int maxHitPoints;
    public Vector3 healthBarOffset;

    private class Baker : Baker<HitPointAuthoring>
    {
        public override void Bake(HitPointAuthoring authoring)
        {
            var entity = GetEntity(TransformUsageFlags.Dynamic);
            AddComponent(entity, new CurrentHitPoints{Value = authoring.maxHitPoints});
            AddComponent(entity, new MaxHitPoints{Value = authoring.maxHitPoints});
            AddComponent<DamageBufferElement>(entity);
            AddComponent<DamageThisTick>(entity);
            AddComponent(entity, new HealthBarOffset() { Value = authoring.healthBarOffset });	// 位置偏移
        }
    }
}

public class UIPrefabs : IComponentData
{	// 注意，因为我们的数据是引用类型，不是值类型，所以组件也只能是class
    public GameObject HealthBar;		// 保存预制体，方便我们创建血条
}

public GameObject healthBarPrefab;

private class Baker : Baker<MobaPrefabsAuthoring>
{
    public override void Bake(MobaPrefabsAuthoring authoring)
    {
        var prefabContainerEntity = GetEntity(TransformUsageFlags.None);
        AddComponentObject(prefabContainerEntity, new UIPrefabs()		// 注意：这里使用的是AddComponentObject
        {
            HealthBar = authoring.healthBarPrefab
        });
    }
}

[UpdateAfter(typeof(TransformSystemGroup))]   		// 在玩家移动后的进行位置设置
[WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
public partial struct HealthBarSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);

        // 添加血条
        foreach (var (transform, healthBarOffset, maxHitPoints, entity) in SystemAPI.Query<LocalTransform, HealthBarOffset, MaxHitPoints>()
                     .WithNone<HealthBarUIReference>().WithEntityAccess())
        {
            // 使用ManagedAPI可以获取到class组件
            var healthBarPrefab = SystemAPI.ManagedAPI.GetSingleton<UIPrefabs>().HealthBar;
            var spawnPosition = transform.Position + healthBarOffset.Value;
            // Object.Instantiate是创造在GameObject中，而不是Entity中
            var newHealthBar = Object.Instantiate(healthBarPrefab, spawnPosition, quaternion.identity);
            SetHealthBar(newHealthBar, maxHitPoints.Value, maxHitPoints.Value);
            // 将生成的血条的引用添加到Entity上，注意：这里添加的并不是本身而是引用。
            // 也就是说在摧毁掉entity的时候并不会将血条也摧毁掉
            ecb.AddComponent(entity, new HealthBarUIReference() { Value = newHealthBar });
        }

        // 更新血条的位置和值
        foreach (var (transform, healthBarOffset, currentHitPoints, maxHitPoints, healthBarUI) in SystemAPI
                     .Query<LocalTransform, HealthBarOffset, CurrentHitPoints, MaxHitPoints, HealthBarUIReference>())
        {
            var healthBarPosition = transform.Position + healthBarOffset.Value;
            healthBarUI.Value.transform.position = healthBarPosition;
            SetHealthBar(healthBarUI.Value, currentHitPoints.Value, maxHitPoints.Value);
        }

        // 当角色死亡时，移除血条。HealthBarUIReference是cleanup类型，在销毁玩家时，该组件会被保留下来
        foreach (var (healthBarUI, entity) in SystemAPI.Query<HealthBarUIReference>()
                 .WithNone<LocalTransform>().WithEntityAccess())
        {
            Object.Destroy(healthBarUI.Value);
            ecb.RemoveComponent<HealthBarUIReference>(entity);
        }
    }
	// 设置血条进度
    private void SetHealthBar(GameObject healthBarCanvasObject, int curHitPoints, int maxHitPoints)
    {
        var healthBarSlider = healthBarCanvasObject.GetComponentInChildren<Slider>();
        healthBarSlider.minValue = 0;
        healthBarSlider.maxValue = maxHitPoints;
        healthBarSlider.value = curHitPoints;
    }
}

[WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
public partial struct AbilityCooldownUISystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var currentTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
        var abilityCooldownUIController = AbilityCooldownUIController.Instance;	// UI控制单例

        foreach (var (cooldownTargetTicks, abilityCooldownTicks) in SystemAPI
                     .Query<DynamicBuffer<AbilityCooldownTargetTicks>, AbilityCooldownTicks>())
        {
            // 如果是第一次释放技能
            if (!cooldownTargetTicks.GetDataAtTick(currentTick, out var curTargetTicks))
            {
                curTargetTicks.AoeAbility = NetworkTick.Invalid;
                curTargetTicks.SkillShotAbility = NetworkTick.Invalid;
            }

            // Q技能
            if (curTargetTicks.AoeAbility == NetworkTick.Invalid ||         // 未获取到即没有释放过技能
                currentTick.IsNewerThan(curTargetTicks.AoeAbility))         // 当前帧大于目标帧
            {
                abilityCooldownUIController.UpdateAoeMask(0f);		// 使用单例中的方法更新Image.fillAmount的值
            }
            else
            {													// TickIndexForValidTick能使计算更准确
                var aoeRemainTickCount = curTargetTicks.AoeAbility.TickIndexForValidTick -
                                         currentTick.TickIndexForValidTick;
                var fillAmount = (float)aoeRemainTickCount / abilityCooldownTicks.AoeAbility;
                abilityCooldownUIController.UpdateAoeMask(fillAmount);
            }
        }
    }
}

var networkConnection = SystemAPI.GetSingletonEntity<NetworkStreamConnection>();
SystemAPI.GetComponent<NetworkStreamRequestDisconnect>(networkConnection);
World.DisposeAllWorlds();		// 不要用在服务端了
SceneManager.LoadScene(0);

public partial struct TestSystem : ISystem
{
    public void OnUpdate(ref SystemState state)
    {
        var isServer = state.WorldUnmanaged.IsServer();
        if (isServer)
        {
        	var networkTime = SystemAPI.GetSingleton<NetworkTime>();
            Debug.Log($"Server: Tick: {networkTime.ServerTick}, ElapsedTime: {SystemAPI.Time.ElapsedTime}");
            Debug.Log("Server: Update time");
        }
        else
        {
        	var networkTime = SystemAPI.GetSingleton<NetworkTime>();
            Debug.Log($"Client: Tick: {networkTime.ServerTick}, ElapsedTime: {SystemAPI.Time.ElapsedTime}");
            Debug.Log("Client: Update time");
        }
    }
}

void start()
{
	ExampleUniTask().Forget();
}
async UniTask ExampleUniTask()
{
    for (int i = 0; i < 100; i++)
    {
        await UniTask.Delay(50);
    }
}

void start()
{
	ExampleUniTask();
}

await UniTask.WhenAll(
    ExampleUniTask(bar1, 50),
    ExampleUniTask(bar2, 100),
    ExampleUniTask(bar3, 100)
    );
Debug.Log("All tasks completed");