using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Physics;
using Unity.Physics.Systems;
using UnityEngine;

public struct TriggerGravityFactor : IComponentData
{
    public float GravityFactor; //重力系数
    public float DampingFactor; //阻尼系数
}

public class TriggerGravityFactorBehaviour : MonoBehaviour, IConvertGameObjectToEntity
{
    public float GravityFactor = 0f;
    public float DampingFactor = 0.9f;

    void OnEnable() { }

    void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
    {
        if (enabled)
        {
            dstManager.AddComponentData(entity, new TriggerGravityFactor()
            {
                GravityFactor = GravityFactor,
                DampingFactor = DampingFactor,
            });
        }
    }
}


// This system sets the PhysicsGravityFactor of any dynamic body that enters a Trigger Volume.
// A Trigger Volume is defined by a PhysicsShapeAuthoring with the `Is Trigger` flag ticked and a
// TriggerGravityFactor behaviour added.

//此系统设置任何进入触发体积的动态物体的PhysicsGravityFactor。
//触发量由PhysicsShapeAuthoring定义，其中勾选了“ Is Trigger”标志，
//添加了TriggerGravityFactor行为。
//这个系统在EndFramePhysicsSystem之后执行
[UpdateAfter(typeof(EndFramePhysicsSystem))]
public class TriggerGravityFactorSystem : JobComponentSystem
{
    BuildPhysicsWorld m_BuildPhysicsWorldSystem;
    StepPhysicsWorld m_StepPhysicsWorldSystem;

    EntityQuery TriggerGroup;

    protected override void OnCreate()
    {
        m_BuildPhysicsWorldSystem = World.GetOrCreateSystem<BuildPhysicsWorld>();
        m_StepPhysicsWorldSystem = World.GetOrCreateSystem<StepPhysicsWorld>();
        //筛选出具有TriggerGravityFactor组件的实体组
        TriggerGroup = GetEntityQuery(new EntityQueryDesc
        {
            All = new ComponentType[] { typeof(TriggerGravityFactor), }
        });
    }

	//继承自触发器的接口ITriggerEventsJob
    [BurstCompile]
    struct TriggerGravityFactorJob : ITriggerEventsJob
    {
        /// <summary>
        /// 自定义的TriggerGravityFactor组件群体
        /// </summary>
        [ReadOnly] public ComponentDataFromEntity<TriggerGravityFactor> TriggerGravityFactorGroup;
        /// <summary>
        /// 物理重力组件群，只要添加了Physics Body组件的实体都会在这个Group中
        /// </summary>
        public ComponentDataFromEntity<PhysicsGravityFactor> PhysicsGravityFactorGroup;
        /// <summary>
        /// 物理速度组件群
        /// </summary>
        public ComponentDataFromEntity<PhysicsVelocity> PhysicsVelocityGroup;

        public void Execute(TriggerEvent triggerEvent)
        {
            //发生碰撞的两个实体
            Entity entityA = triggerEvent.Entities.EntityA;
            Entity entityB = triggerEvent.Entities.EntityB;

            //判断这两个实体是否是自定义的触发器实体
            bool isBodyATrigger = TriggerGravityFactorGroup.Exists(entityA);
            bool isBodyBTrigger = TriggerGravityFactorGroup.Exists(entityB);

            // Ignoring Triggers overlapping other Triggers
            // 如果两个都是自定义的触发器，则他们碰撞是不处理的，因为这两个是不可能发生碰撞的
            if (isBodyATrigger && isBodyBTrigger)
                return;

            bool isBodyADynamic = PhysicsVelocityGroup.Exists(entityA);
            bool isBodyBDynamic = PhysicsVelocityGroup.Exists(entityB);

            // Ignoring overlapping static bodies
            // 忽略重叠的静态物体
            if ((isBodyATrigger && !isBodyBDynamic) ||
                (isBodyBTrigger && !isBodyADynamic))
                return;

            //找到TriggerEntity和小球Entity
            var triggerEntity = isBodyATrigger ? entityA : entityB;
            var dynamicEntity = isBodyATrigger ? entityB : entityA;

            var triggerGravityComponent = TriggerGravityFactorGroup[triggerEntity];
            // tweak PhysicsGravityFactor
            //调整PhysicsGravityFactor的值
            {
                //获得碰撞的小球修改他的重力系数
                var component = PhysicsGravityFactorGroup[dynamicEntity];
                component.Value = triggerGravityComponent.GravityFactor;
                PhysicsGravityFactorGroup[dynamicEntity] = component;
            }
            // damp velocity
            // 调整阻尼速度
            {
                var component = PhysicsVelocityGroup[dynamicEntity];
                component.Linear *= triggerGravityComponent.DampingFactor;
                PhysicsVelocityGroup[dynamicEntity] = component;
            }
        }
    }

    protected override JobHandle OnUpdate(JobHandle inputDeps)
    {
        JobHandle jobHandle = new TriggerGravityFactorJob
        {
            TriggerGravityFactorGroup = GetComponentDataFromEntity<TriggerGravityFactor>(true),
            PhysicsGravityFactorGroup = GetComponentDataFromEntity<PhysicsGravityFactor>(),
            PhysicsVelocityGroup = GetComponentDataFromEntity<PhysicsVelocity>(),
        }.Schedule(m_StepPhysicsWorldSystem.Simulation,
                    ref m_BuildPhysicsWorldSystem.PhysicsWorld, inputDeps);

        return jobHandle;
    }
}

using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Physics;
using Unity.Physics.Systems;
using UnityEngine;

public struct CollisionEventImpulse : IComponentData
{
    public float3 Impulse;
}

public class CollisionEventImpulseBehaviour : MonoBehaviour, IConvertGameObjectToEntity
{
    public float Magnitude = 1.0f;
    public float3 Direction = math.up();

    void OnEnable() { }

    void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
    {
        if (enabled)
        {
            dstManager.AddComponentData(entity, new CollisionEventImpulse()
            {
                Impulse = Magnitude * Direction,
            });
        }
    }
}

// This system applies an impulse to any dynamic that collides with a Repulsor.
// A Repulsor is defined by a PhysicsShapeAuthoring with the `Raise Collision Events` flag ticked and a
// CollisionEventImpulse behaviour added.
[UpdateAfter(typeof(EndFramePhysicsSystem))]
unsafe public class CollisionEventImpulseSystem : JobComponentSystem
{
    BuildPhysicsWorld m_BuildPhysicsWorldSystem;
    StepPhysicsWorld m_StepPhysicsWorldSystem;

    EntityQuery ImpulseGroup;

    protected override void OnCreate()
    {
        m_BuildPhysicsWorldSystem = World.GetOrCreateSystem<BuildPhysicsWorld>();
        m_StepPhysicsWorldSystem = World.GetOrCreateSystem<StepPhysicsWorld>();
        //筛选出所有挂有CollisionEventImpulse组件的Entity
        ImpulseGroup = GetEntityQuery(new EntityQueryDesc
        {
            All = new ComponentType[] { typeof(CollisionEventImpulse), }
        });
    }

    //继承自碰撞器的接口
    [BurstCompile]
    struct CollisionEventImpulseJob : ICollisionEventsJob
    {
        [ReadOnly] public ComponentDataFromEntity<CollisionEventImpulse> ColliderEventImpulseGroup;
        public ComponentDataFromEntity<PhysicsVelocity> PhysicsVelocityGroup;

        public void Execute(CollisionEvent collisionEvent)
        {
            Entity entityA = collisionEvent.Entities.EntityA;
            Entity entityB = collisionEvent.Entities.EntityB;

            bool isBodyADynamic = PhysicsVelocityGroup.Exists(entityA);
            bool isBodyBDynamic = PhysicsVelocityGroup.Exists(entityB);

            bool isBodyARepulser = ColliderEventImpulseGroup.Exists(entityA);
            bool isBodyBRepulser = ColliderEventImpulseGroup.Exists(entityB);

            if(isBodyARepulser && isBodyBDynamic)
            {
                var impulseComponent = ColliderEventImpulseGroup[entityA];
                var velocityComponent = PhysicsVelocityGroup[entityB];
                velocityComponent.Linear = impulseComponent.Impulse;
                PhysicsVelocityGroup[entityB] = velocityComponent;
            }
            if (isBodyBRepulser && isBodyADynamic)
            {
                //改变小球的初速度即可
                var impulseComponent = ColliderEventImpulseGroup[entityB];
                var velocityComponent = PhysicsVelocityGroup[entityA];
                velocityComponent.Linear = impulseComponent.Impulse;
                PhysicsVelocityGroup[entityA] = velocityComponent;
            }
        }
    }

    protected override JobHandle OnUpdate(JobHandle inputDeps)
    {
        JobHandle jobHandle = new CollisionEventImpulseJob
        {
            ColliderEventImpulseGroup = GetComponentDataFromEntity<CollisionEventImpulse>(true),
            PhysicsVelocityGroup = GetComponentDataFromEntity<PhysicsVelocity>(),
        }.Schedule(m_StepPhysicsWorldSystem.Simulation,
                    ref m_BuildPhysicsWorldSystem.PhysicsWorld, inputDeps);

        return jobHandle;
    }
}

using System.Collections.Generic;
using Unity.Entities;
using Unity.Physics;
using Unity.Physics.Authoring;
using Unity.Physics.Systems;
using Unity.Rendering;
using UnityEngine;

public struct ChangeMotionType : IComponentData
{
    public Entity EntityDynamic;
    public Entity EntityKinematic;
    public Entity EntityStatic;

    public PhysicsCollider DynamicCollider;
    public PhysicsMass DynamicMass;
    public PhysicsVelocity DynamicVelocity;
    public float TimeToSwap;
    internal float LocalTime;
    public BodyMotionType MotionType;
}

//改变实体的Motion类型，Motion之前已经介绍过
public class ChangeMotionTypeBehaviour : MonoBehaviour, IDeclareReferencedPrefabs//, IConvertGameObjectToEntity
{
    public GameObject DynamicBody;
    public GameObject KinematicBody;
    public GameObject StaticBody;

    [Range(0, 10)] public float TimeToSwap = 1.0f;


    public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
    {
        var collider = dstManager.GetComponentData<PhysicsCollider>(entity);
        var mass = dstManager.GetComponentData<PhysicsMass>(entity);
        var velocity = dstManager.GetComponentData<PhysicsVelocity>(entity);

        dstManager.AddComponentData(entity, new ChangeMotionType
        {
            EntityDynamic = conversionSystem.GetPrimaryEntity(DynamicBody),
            EntityKinematic = conversionSystem.GetPrimaryEntity(KinematicBody),
            EntityStatic = conversionSystem.GetPrimaryEntity(StaticBody),

            DynamicCollider = collider,
            DynamicMass = mass,
            DynamicVelocity = velocity,
            TimeToSwap = TimeToSwap,
            LocalTime = TimeToSwap,
            MotionType = BodyMotionType.Dynamic,
        });
    }

    // 添加引用物体
    public void DeclareReferencedPrefabs(List<GameObject> referencedPrefabs)
    {
        referencedPrefabs.Add(DynamicBody);
        referencedPrefabs.Add(KinematicBody);
        referencedPrefabs.Add(StaticBody);
    }
}

[UpdateBefore(typeof(BuildPhysicsWorld))]
public class ChangeMotionTypeSystem : ComponentSystem
{
    protected override void OnUpdate()
    {
        Entities.WithAll<ChangeMotionType, RenderMesh>().ForEach(
            (Entity entity, ref ChangeMotionType modifier) =>
        {
            modifier.LocalTime -= UnityEngine.Time.deltaTime;

            if (modifier.LocalTime > 0.0f) return;

            modifier.LocalTime = modifier.TimeToSwap;

            var renderMesh = World.EntityManager.GetSharedComponentData<RenderMesh>(entity);
            UnityEngine.Material material = renderMesh.material;
            switch (modifier.MotionType)
            {
                case BodyMotionType.Dynamic:
                    // move to kinematic body by removing PhysicsMass component
                    // note that a 'kinematic' body is really just a dynamic body with infinite mass properties
                    // hence the same thing could be achieved by setting properties via PhysicsMass.CreateKinematic
                    PostUpdateCommands.RemoveComponent<PhysicsMass>(entity);

                    // set the new modifier type and grab the appropriate new render material
                    material = World.EntityManager.GetSharedComponentData<RenderMesh>(modifier.EntityKinematic).material;
                    modifier.MotionType = BodyMotionType.Kinematic;
                    break;
                case BodyMotionType.Kinematic:
                    // move to static by removing PhysicsVelocity
                    PostUpdateCommands.RemoveComponent<PhysicsVelocity>(entity);

                    // set the new modifier type and grab the appropriate new render material
                    material = World.EntityManager.GetSharedComponentData<RenderMesh>(modifier.EntityStatic).material;
                    modifier.MotionType = BodyMotionType.Static;
                    break;
                case BodyMotionType.Static:
                    // move to dynamic by adding PhysicsVelocity and non infinite PhysicsMass
                    modifier.DynamicVelocity.Linear.y = 5.0f;
                    PostUpdateCommands.AddComponent(entity, modifier.DynamicVelocity);
                    PostUpdateCommands.AddComponent(entity, modifier.DynamicMass);

                    // set the new modifier type and grab the appropriate new render material
                    material = World.EntityManager.GetSharedComponentData<RenderMesh>(modifier.EntityDynamic).material;
                    modifier.MotionType = BodyMotionType.Dynamic;
                    break;
            }
            //赋予新的网格材质
            renderMesh.material = material;
            PostUpdateCommands.SetSharedComponent(entity, renderMesh);
    });
    }
}

using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Physics;
using Unity.Physics.Systems;
using Unity.Transforms;
using UnityEngine;
using SphereCollider = Unity.Physics.SphereCollider;

/// <summary>
/// 数据组件
/// </summary>
public struct ChangeSphereColliderRadius : IComponentData
{
    public float Min;
    public float Max;
    public float Target;
}

// In general, you should treat colliders as immutable data at run-time, as several bodies might share the same collider.
// If you plan to modify mesh or convex colliders at run-time, remember to tick the Force Unique box on the PhysicsShapeAuthoring component.
// This guarantees that the PhysicsCollider component will have a unique instance in all cases.

// Converted in PhysicsSamplesConversionSystem so Physics and Graphics conversion is over
public class ChangeSphereColliderRadiusBehaviour : MonoBehaviour//, IConvertGameObjectToEntity
{
    [Range(0, 10)] public float Min = 0;
    [Range(0, 10)] public float Max = 10;

    public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
    {
        dstManager.AddComponentData(entity, new ChangeSphereColliderRadius
        {
            Min = Min,
            Max = Max,
            Target = math.lerp(Min, Max, 0.5f),
        });
        //物体的物理和图形表示可以在很大程度上独立。
        //每个表示的位置和旋转都通过BuildPhysicsWorld＆ExportPhysicsWorld系统关联。
        //由于通常会缩放比例以提高运行时性能，因此我们特别需要在此处添加比例组件
        //，并将在我们自己的演示更新系统中更新图形和物理比例
        dstManager.AddComponentData(entity, new Scale
        {
            Value = 1.0f,
        });
    }
}

[UpdateBefore(typeof(BuildPhysicsWorld))]
public class ChangeSphereColliderRadiusSystem : JobComponentSystem
{
    private struct ChangeSphereColliderRadiusJob : IJobForEach<PhysicsCollider, ChangeSphereColliderRadius, Scale>
    {
        public unsafe void Execute(ref PhysicsCollider collider, ref ChangeSphereColliderRadius radius, ref Scale scale)
        {
            // make sure we are dealing with spheres
            if (collider.ColliderPtr->Type != ColliderType.Sphere) return;


            //调整球体的物理表示
            //抓取球形指针
            SphereCollider* scPtr = (SphereCollider*)collider.ColliderPtr;
            float oldRadius = scPtr->Radius;
            float newRadius = math.lerp(oldRadius, radius.Target, 0.05f);
            //如果我们已经达到目标半径，则获得一个新的目标
            if (math.abs(newRadius - radius.Target) < 0.01f)
            {
                radius.Target = radius.Target == radius.Min ? radius.Max : radius.Min;
            }

            // 修改球体碰撞器的半径
            var sphereGeometry = scPtr->Geometry;
            sphereGeometry.Radius = newRadius;
            scPtr->Geometry = sphereGeometry;

            //调整球的图形显示
            float oldScale = scale.Value;
            float newScale = oldScale;
            if (oldRadius == 0.0f)
            {
                newScale = newRadius;
            }
            else
            {
                newScale *= newRadius / oldRadius;
            }
            scale = new Scale() { Value = newScale };
        }
    }

    protected override JobHandle OnUpdate(JobHandle inputDeps)
    {
        JobHandle job = new ChangeSphereColliderRadiusJob().Schedule(this, inputDeps);

        return job;
    }
}

using System.Collections.Generic;
using Unity.Entities;
using Unity.Physics;
using Unity.Physics.Systems;
using Unity.Rendering;
using UnityEngine;

/// <summary>
/// 修改Collider Type组件
/// </summary>
public struct ChangeColliderType : IComponentData
{
    public PhysicsCollider ColliderA;
    public PhysicsCollider ColliderB;
    public Entity EntityA;
    public Entity EntityB;
    public float TimeToSwap;
    internal float LocalTime;
}

//依然是之前讲过的转换实体代码
public class ChangeColliderTypeBehaviour : MonoBehaviour, IDeclareReferencedPrefabs//, IConvertGameObjectToEntity
{
    public GameObject PhysicsColliderPrefabA;
    public GameObject PhysicsColliderPrefabB;
    [Range(0, 10)] public float TimeToSwap = 1.0f;


    public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
    {
        if (PhysicsColliderPrefabA == null || PhysicsColliderPrefabB == null) return;

        var entityA = conversionSystem.GetPrimaryEntity(PhysicsColliderPrefabA);
        var entityB = conversionSystem.GetPrimaryEntity(PhysicsColliderPrefabB);

        if (entityA == Entity.Null || entityB == Entity.Null) return;

        var colliderA = dstManager.GetComponentData<PhysicsCollider>(entityA);
        var colliderB = dstManager.GetComponentData<PhysicsCollider>(entityB);

        dstManager.AddComponentData(entity, new ChangeColliderType()
        {
            ColliderA = colliderA,
            ColliderB = colliderB,
            EntityA = entityA,
            EntityB = entityB,
            TimeToSwap = TimeToSwap,
            LocalTime = TimeToSwap,
        });
    }

    public void DeclareReferencedPrefabs(List<GameObject> referencedPrefabs)
    {
        if (PhysicsColliderPrefabA == null || PhysicsColliderPrefabB == null) return;

        referencedPrefabs.Add(PhysicsColliderPrefabA);
        referencedPrefabs.Add(PhysicsColliderPrefabB);
    }
}

//该系统在BuildPhysicsWorld之后执行
[UpdateBefore(typeof(BuildPhysicsWorld))]
public class ChangeColliderTypeSystem : ComponentSystem
{
    protected unsafe override void OnUpdate()
    {
        //遍历所有带有一下三个组件的实体
        Entities.WithAll<PhysicsCollider, ChangeColliderType, RenderMesh>().ForEach( 
            (Entity entity, ref ChangeColliderType modifier) =>
        {
            modifier.LocalTime -= UnityEngine.Time.fixedDeltaTime;

            if (modifier.LocalTime > 0.0f) return;

            modifier.LocalTime = modifier.TimeToSwap;
            var collider = World.EntityManager.GetComponentData<PhysicsCollider>(entity); //获取实体的组件
            if (collider.ColliderPtr->Type == modifier.ColliderA.ColliderPtr->Type) //指针获取类型
            {
                //修改组件数据，使用PostUpdateCommands修改，因为必须在主线程中执行
                PostUpdateCommands.SetComponent(entity,modifier.ColliderB);
                PostUpdateCommands.SetSharedComponent(entity, World.EntityManager.GetSharedComponentData<RenderMesh>(modifier.EntityB));
            }
            else
            {
                PostUpdateCommands.SetComponent(entity, modifier.ColliderA);
                PostUpdateCommands.SetSharedComponent(entity, World.EntityManager.GetSharedComponentData<RenderMesh>(modifier.EntityA));
            }
        });
    }
}

using System;
using Unity.Burst;
using Unity.Collections;
using Unity.Entities;
using Unity.Jobs;
using Unity.Mathematics;
using Unity.Physics;
using Unity.Physics.Extensions;
using Unity.Physics.Systems;
using Unity.Transforms;
using UnityEngine;
using UnityEngine.Assertions;
using static CharacterControllerUtilities;
using static Unity.Physics.PhysicsStep;

[Serializable]
public struct CharacterControllerComponentData : IComponentData
{
    public float3 Gravity;
    public float MovementSpeed;
    public float MaxMovementSpeed;
    public float RotationSpeed;
    public float JumpUpwardsSpeed;
    public float MaxSlope; // radians
    public int MaxIterations;
    public float CharacterMass;
    public float SkinWidth;
    public float ContactTolerance;
    public int AffectsPhysicsBodies;
}

public struct CharacterControllerInput : IComponentData
{
    public float2 Movement;
    public float2 Looking;
    public int Jumped;
}

public struct CharacterControllerInternalData : IComponentData
{
    public float CurrentRotationAngle;
    public CharacterSupportState SupportedState;
    public float3 UnsupportedVelocity;
    public float3 LinearVelocity;
    public Entity Entity;
    public bool IsJumping;
    public CharacterControllerInput Input;
}

[Serializable]
public class CharacterControllerAuthoring : MonoBehaviour, IConvertGameObjectToEntity
{
    // Gravity force applied to the character controller body
    public float3 Gravity = Default.Gravity;

    // Speed of movement initiated by user input
    public float MovementSpeed = 2.5f;

    // Maximum speed of movement at any given time
    public float MaxMovementSpeed = 10.0f;

    // Speed of rotation initiated by user input
    public float RotationSpeed = 2.5f;

    // Speed of upwards jump initiated by user input
    public float JumpUpwardsSpeed = 5.0f;

    // Maximum slope angle character can overcome (in degrees)
    public float MaxSlope = 60.0f;

    // Maximum number of character controller solver iterations
    public int MaxIterations = 10;

    // Mass of the character (used for affecting other rigid bodies)
    public float CharacterMass = 1.0f;

    // Keep the character at this distance to planes (used for numerical stability)
    public float SkinWidth = 0.02f;

    // Anything in this distance to the character will be considered a potential contact
    // when checking support
    public float ContactTolerance = 0.1f;

    // Whether to affect other rigid bodies
    public int AffectsPhysicsBodies = 1;

    void OnEnable() { }

    void IConvertGameObjectToEntity.Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
    {
        if (enabled)
        {
            var componentData = new CharacterControllerComponentData
            {
                Gravity = Gravity,
                MovementSpeed = MovementSpeed,
                MaxMovementSpeed = MaxMovementSpeed,
                RotationSpeed = RotationSpeed,
                JumpUpwardsSpeed = JumpUpwardsSpeed,
                MaxSlope = math.radians(MaxSlope),
                MaxIterations = MaxIterations,
                CharacterMass = CharacterMass,
                SkinWidth = SkinWidth,
                ContactTolerance = ContactTolerance,
                AffectsPhysicsBodies = AffectsPhysicsBodies,
            };
            var internalData = new CharacterControllerInternalData
            {
                Entity = entity,
                Input = new CharacterControllerInput(),
            };

            dstManager.AddComponentData(entity, componentData);
            dstManager.AddComponentData(entity, internalData);
        }
    }
}


[UpdateAfter(typeof(ExportPhysicsWorld)), UpdateBefore(typeof(EndFramePhysicsSystem))]
public class CharacterControllerSystem : JobComponentSystem
{
    const float k_DefaultTau = 0.4f;
    const float k_DefaultDamping = 0.9f;

    [BurstCompile]
    struct CharacterControllerJob : IJobChunk
    {
        public float DeltaTime;

        [ReadOnly]
        public PhysicsWorld PhysicsWorld;

        public ArchetypeChunkComponentType<CharacterControllerInternalData> CharacterControllerInternalType;
        public ArchetypeChunkComponentType<Translation> TranslationType;
        public ArchetypeChunkComponentType<Rotation> RotationType;
        [ReadOnly] public ArchetypeChunkComponentType<CharacterControllerComponentData> CharacterControllerComponentType;
        [ReadOnly] public ArchetypeChunkComponentType<PhysicsCollider> PhysicsColliderType;

        // Stores impulses we wish to apply to dynamic bodies the character is interacting with.
        // This is needed to avoid race conditions when 2 characters are interacting with the
        // same body at the same time.
        public NativeStream.Writer DeferredImpulseWriter;

        public unsafe void Execute(ArchetypeChunk chunk, int chunkIndex, int firstEntityIndex)
        {
            float3 up = math.up();

            var chunkCCData = chunk.GetNativeArray(CharacterControllerComponentType);
            var chunkCCInternalData = chunk.GetNativeArray(CharacterControllerInternalType);
            var chunkPhysicsColliderData = chunk.GetNativeArray(PhysicsColliderType);
            var chunkTranslationData = chunk.GetNativeArray(TranslationType);
            var chunkRotationData = chunk.GetNativeArray(RotationType);

            DeferredImpulseWriter.BeginForEachIndex(chunkIndex);

            for (int i = 0; i < chunk.Count; i++)
            {
                var ccComponentData = chunkCCData[i];
                var ccInternalData = chunkCCInternalData[i];
                var collider = chunkPhysicsColliderData[i];
                var position = chunkTranslationData[i];
                var rotation = chunkRotationData[i];

                // Collision filter must be valid
                Assert.IsTrue(collider.ColliderPtr->Filter.IsValid);

                // Character step input
                CharacterControllerStepInput stepInput = new CharacterControllerStepInput
                {
                    World = PhysicsWorld,
                    DeltaTime = DeltaTime,
                    Up = math.up(),
                    Gravity = ccComponentData.Gravity,
                    MaxIterations = ccComponentData.MaxIterations,
                    Tau = k_DefaultTau,
                    Damping = k_DefaultDamping,
                    SkinWidth = ccComponentData.SkinWidth,
                    ContactTolerance = ccComponentData.ContactTolerance,
                    MaxSlope = ccComponentData.MaxSlope,
                    RigidBodyIndex = PhysicsWorld.GetRigidBodyIndex(ccInternalData.Entity),
                    CurrentVelocity = ccInternalData.LinearVelocity,
                    MaxMovementSpeed = ccComponentData.MaxMovementSpeed
                };

                // Character transform
                RigidTransform transform = new RigidTransform
                {
                    pos = position.Value,
                    rot = rotation.Value
                };

                // Check support
                CheckSupport(ref PhysicsWorld, ref collider, stepInput, transform, ccComponentData.MaxSlope,
                    out ccInternalData.SupportedState, out float3 surfaceNormal, out float3 surfaceVelocity);

                // User input
                float3 desiredVelocity = ccInternalData.LinearVelocity;
                HandleUserInput(ccComponentData, stepInput.Up, surfaceVelocity, ref ccInternalData, ref desiredVelocity);

                // Calculate actual velocity with respect to surface
                if (ccInternalData.SupportedState == CharacterSupportState.Supported)
                {
                    CalculateMovement(ccInternalData.CurrentRotationAngle, stepInput.Up, ccInternalData.IsJumping,
                        ccInternalData.LinearVelocity, desiredVelocity, surfaceNormal, surfaceVelocity, out ccInternalData.LinearVelocity);
                }
                else
                {
                    ccInternalData.LinearVelocity = desiredVelocity;
                }

                // World collision + integrate
                CollideAndIntegrate(stepInput, ccComponentData.CharacterMass, ccComponentData.AffectsPhysicsBodies > 0,
                    collider.ColliderPtr, ref transform, ref ccInternalData.LinearVelocity, ref DeferredImpulseWriter);

                // Write back and orientation integration
                position.Value = transform.pos;
                rotation.Value = quaternion.AxisAngle(up, ccInternalData.CurrentRotationAngle);

                // Write back to chunk data
                {
                    chunkCCInternalData[i] = ccInternalData;
                    chunkTranslationData[i] = position;
                    chunkRotationData[i] = rotation;
                }
            }

            DeferredImpulseWriter.EndForEachIndex();
        }

        private void HandleUserInput(CharacterControllerComponentData ccComponentData, float3 up, float3 surfaceVelocity,
            ref CharacterControllerInternalData ccInternalData, ref float3 linearVelocity)
        {
            // Reset jumping state and unsupported velocity
            if (ccInternalData.SupportedState == CharacterSupportState.Supported)
            {
                ccInternalData.IsJumping = false;
                ccInternalData.UnsupportedVelocity = float3.zero;
            }

            // Movement and jumping
            bool shouldJump = false;
            float3 requestedMovementDirection = float3.zero;
            {
                float3 forward = math.forward(quaternion.identity);
                float3 right = math.cross(up, forward);

                float horizontal = ccInternalData.Input.Movement.x;
                float vertical = ccInternalData.Input.Movement.y;
                bool jumpRequested = ccInternalData.Input.Jumped > 0;
                bool haveInput = (math.abs(horizontal) > float.Epsilon) || (math.abs(vertical) > float.Epsilon);
                if (haveInput)
                {
                    float3 localSpaceMovement = forward * vertical + right * horizontal;
                    float3 worldSpaceMovement = math.rotate(quaternion.AxisAngle(up, ccInternalData.CurrentRotationAngle), localSpaceMovement);
                    requestedMovementDirection = math.normalize(worldSpaceMovement);
                }
                shouldJump = jumpRequested && ccInternalData.SupportedState == CharacterSupportState.Supported;
            }

            // Turning
            {
                float horizontal = ccInternalData.Input.Looking.x;
                bool haveInput = (math.abs(horizontal) > float.Epsilon);
                if (haveInput)
                {
                    ccInternalData.CurrentRotationAngle += horizontal * ccComponentData.RotationSpeed * DeltaTime;
                }
            }

            // Apply input velocities
            {
                if (shouldJump)
                {
                    // Add jump speed to surface velocity and make character unsupported
                    ccInternalData.IsJumping = true;
                    ccInternalData.SupportedState = CharacterSupportState.Unsupported;
                    ccInternalData.UnsupportedVelocity = surfaceVelocity + ccComponentData.JumpUpwardsSpeed * up;
                }
                else if (ccInternalData.SupportedState != CharacterSupportState.Supported)
                {
                    // Apply gravity
                    ccInternalData.UnsupportedVelocity += ccComponentData.Gravity * DeltaTime;
                }
                // If unsupported then keep jump and surface momentum
                // 如果没有支撑，则保持跳跃和表面动量
                linearVelocity = requestedMovementDirection * ccComponentData.MovementSpeed +
                (ccInternalData.SupportedState != CharacterSupportState.Supported ? ccInternalData.UnsupportedVelocity : float3.zero);
            }
        }

        private void CalculateMovement(float currentRotationAngle, float3 up, bool isJumping,
            float3 currentVelocity, float3 desiredVelocity, float3 surfaceNormal, float3 surfaceVelocity, out float3 linearVelocity)
        {
            float3 forward = math.forward(quaternion.AxisAngle(up, currentRotationAngle));

            Rotation surfaceFrame;
            float3 binorm;
            {
                binorm = math.cross(forward, up);
                binorm = math.normalize(binorm);

                float3 tangent = math.cross(binorm, surfaceNormal);
                tangent = math.normalize(tangent);

                binorm = math.cross(tangent, surfaceNormal);
                binorm = math.normalize(binorm);

                surfaceFrame.Value = new quaternion(new float3x3(binorm, tangent, surfaceNormal));
            }

            float3 relative = currentVelocity - surfaceVelocity;
            relative = math.rotate(math.inverse(surfaceFrame.Value), relative);

            float3 diff;
            {
                float3 sideVec = math.cross(forward, up);
                float fwd = math.dot(desiredVelocity, forward);
                float side = math.dot(desiredVelocity, sideVec);
                float len = math.length(desiredVelocity);
                float3 desiredVelocitySF = new float3(-side, -fwd, 0.0f);
                desiredVelocitySF = math.normalizesafe(desiredVelocitySF, float3.zero);
                desiredVelocitySF *= len;
                diff = desiredVelocitySF - relative;
            }

            relative += diff;

            linearVelocity = math.rotate(surfaceFrame.Value, relative) + surfaceVelocity +
                (isJumping ? math.dot(desiredVelocity, up) * up : float3.zero);
        }
    }

    [BurstCompile]
    struct ApplyDefferedPhysicsUpdatesJob : IJob
    {
        [DeallocateOnJobCompletion] public NativeArray<ArchetypeChunk> Chunks;

        public NativeStream.Reader DeferredImpulseReader;

        public ComponentDataFromEntity<PhysicsVelocity> PhysicsVelocityData;
        public ComponentDataFromEntity<PhysicsMass> PhysicsMassData;
        public ComponentDataFromEntity<Translation> TranslationData;
        public ComponentDataFromEntity<Rotation> RotationData;

        public void Execute()
        {
            int index = 0;
            int maxIndex = DeferredImpulseReader.ForEachCount;
            DeferredImpulseReader.BeginForEachIndex(index++);
            while (DeferredImpulseReader.RemainingItemCount == 0 && index < maxIndex)
            {
                DeferredImpulseReader.BeginForEachIndex(index++);
            }

            while (DeferredImpulseReader.RemainingItemCount > 0)
            {
                // Read the data
                var impulse = DeferredImpulseReader.Read<DeferredCharacterControllerImpulse>();
                while (DeferredImpulseReader.RemainingItemCount == 0 && index < maxIndex)
                {
                    DeferredImpulseReader.BeginForEachIndex(index++);
                }

                PhysicsVelocity pv = PhysicsVelocityData[impulse.Entity];
                PhysicsMass pm = PhysicsMassData[impulse.Entity];
                Translation t = TranslationData[impulse.Entity];
                Rotation r = RotationData[impulse.Entity];

                // Don't apply on kinematic bodies
                if (pm.InverseMass > 0.0f)
                {
                    // Apply impulse
                    pv.ApplyImpulse(pm, t, r, impulse.Impulse, impulse.Point);

                    // Write back
                    PhysicsVelocityData[impulse.Entity] = pv;
                }
            }
        }
    }

    BuildPhysicsWorld m_BuildPhysicsWorldSystem;
    ExportPhysicsWorld m_ExportPhysicsWorldSystem;
    EndFramePhysicsSystem m_EndFramePhysicsSystem;

    EntityQuery m_CharacterControllersGroup;

    protected override void OnCreate()
    {
        m_BuildPhysicsWorldSystem = World.GetOrCreateSystem<BuildPhysicsWorld>();
        m_ExportPhysicsWorldSystem = World.GetOrCreateSystem<ExportPhysicsWorld>();
        m_EndFramePhysicsSystem = World.GetOrCreateSystem<EndFramePhysicsSystem>();

        EntityQueryDesc query = new EntityQueryDesc
        {
            All = new ComponentType[]
            {
                typeof(CharacterControllerComponentData),
                typeof(CharacterControllerInternalData),
                typeof(PhysicsCollider),
                typeof(Translation),
                typeof(Rotation),
            }
        };
        m_CharacterControllersGroup = GetEntityQuery(query);
    }

    protected override JobHandle OnUpdate(JobHandle inputDeps)
    {
        if (m_CharacterControllersGroup.CalculateEntityCount() == 0)
            return inputDeps;

        var chunks = m_CharacterControllersGroup.CreateArchetypeChunkArray(Allocator.TempJob);

        var ccComponentType = GetArchetypeChunkComponentType<CharacterControllerComponentData>();
        var ccInternalType = GetArchetypeChunkComponentType<CharacterControllerInternalData>();
        var physicsColliderType = GetArchetypeChunkComponentType<PhysicsCollider>();
        var translationType = GetArchetypeChunkComponentType<Translation>();
        var rotationType = GetArchetypeChunkComponentType<Rotation>();

        var deferredImpulses = new NativeStream(chunks.Length, Allocator.TempJob);

        var ccJob = new CharacterControllerJob
        {
            // Archetypes
            CharacterControllerComponentType = ccComponentType,
            CharacterControllerInternalType = ccInternalType,
            PhysicsColliderType = physicsColliderType,
            TranslationType = translationType,
            RotationType = rotationType,
            // Input
            DeltaTime = UnityEngine.Time.fixedDeltaTime,
            PhysicsWorld = m_BuildPhysicsWorldSystem.PhysicsWorld,
            DeferredImpulseWriter = deferredImpulses.AsWriter()
        };

        inputDeps = JobHandle.CombineDependencies(inputDeps, m_ExportPhysicsWorldSystem.FinalJobHandle);
        inputDeps = ccJob.Schedule(m_CharacterControllersGroup, inputDeps);

        var applyJob = new ApplyDefferedPhysicsUpdatesJob()
        {
            Chunks = chunks,
            DeferredImpulseReader = deferredImpulses.AsReader(),
            PhysicsVelocityData = GetComponentDataFromEntity<PhysicsVelocity>(),
            PhysicsMassData = GetComponentDataFromEntity<PhysicsMass>(),
            TranslationData = GetComponentDataFromEntity<Translation>(),
            RotationData = GetComponentDataFromEntity<Rotation>()
        };

        inputDeps = applyJob.Schedule(inputDeps);
        var disposeHandle = deferredImpulses.Dispose(inputDeps);

        //必须在PhysicsStep之前完成所有的jobs
        m_EndFramePhysicsSystem.HandlesToWaitFor.Add(disposeHandle);

        return inputDeps;
    }
}

using System;
using Unity.Entities;
using Unity.Physics;
using Unity.Mathematics;
using UnityEngine;
using Random = Unity.Mathematics.Random;

class SpawnRandomAsteroidsAuthoring : SpawnRandomObjectsAuthoringBase<AsteroidSpawnSettings>
{
    public float massFactor = 1;

    internal override void Configure(ref AsteroidSpawnSettings spawnSettings) => spawnSettings.MassFactor = massFactor;
}

struct AsteroidSpawnSettings : IComponentData, ISpawnSettings
{
    public Entity Prefab { get; set; }
    public float3 Position { get; set; }
    public float3 Range { get; set; }
    public int Count { get; set; }
    public float MassFactor;
}

class SpawnRandomAsteroidsSystem : SpawnRandomObjectsSystemBase<AsteroidSpawnSettings>
{
    Random m_RandomMass;

    internal override void OnBeforeInstantiatePrefab(AsteroidSpawnSettings spawnSettings)
    {
        m_RandomMass = new Random();
        m_RandomMass.InitState(10);
    }

    internal override void ConfigureInstance(Entity instance, AsteroidSpawnSettings spawnSettings)
    {
        var mass = EntityManager.GetComponentData<PhysicsMass>(instance);
        var halfMassFactor = spawnSettings.MassFactor * 0.5f;
        mass.InverseMass = m_RandomMass.NextFloat(mass.InverseMass * math.rcp(halfMassFactor), mass.InverseMass * halfMassFactor);
        EntityManager.SetComponentData(instance, mass);
    }
}

using System.Collections;
using Unity.Entities;
using Unity.Mathematics;
using Unity.Physics;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
/// 游戏管理器
/// </summary>
public class GameManager : MonoBehaviour
{
	public static GameManager main;

	public GameObject ballPrefab; //小球的Prefab引用

    //XY的边界方便小球的碰撞检测
	public float xBound = 3f;
	public float yBound = 3f;
	public float ballSpeed = 3f; //小球的速度
	public float respawnDelay = 2f; //小球重新生成的间隔时间
	public int[] playerScores; //玩家的分数

	public Text mainText; //ReadyGo
	public Text[] playerTexts; //玩家成绩

	Entity ballEntityPrefab; //Ball Prefab转成Entity Prefab
	EntityManager manager;

    //延时时间缓存变量，提前创建好，就不需要每次New而导致的内存分配
	WaitForSeconds oneSecond;
	WaitForSeconds delay; //小球重新生成的间隔时间

	private void Awake()
	{
		if (main != null && main != this)
		{
			Destroy(gameObject);
			return;
		}

		main = this;
		playerScores = new int[2];

		manager = World.DefaultGameObjectInjectionWorld.EntityManager;

		GameObjectConversionSettings settings = GameObjectConversionSettings.FromWorld(World.DefaultGameObjectInjectionWorld, null);
		ballEntityPrefab = GameObjectConversionUtility.ConvertGameObjectHierarchy(ballPrefab, settings); //将Prefab转换成Entity

		oneSecond = new WaitForSeconds(1f);
		delay = new WaitForSeconds(respawnDelay);

		StartCoroutine(CountdownAndSpawnBall());
	}

    /// <summary>
    /// 玩家得分
    /// </summary>
    /// <param name="playerID">0:左边 1:右边</param>
	public void PlayerScored(int playerID)
	{
		playerScores[playerID]++;
		for (int i = 0; i < playerScores.Length && i < playerTexts.Length; i++)
			playerTexts[i].text = playerScores[i].ToString();

		StartCoroutine(CountdownAndSpawnBall());
	}

    /// <summary>
    /// 倒计时生成小球
    /// </summary>
    /// <returns></returns>
	IEnumerator CountdownAndSpawnBall()
	{
		mainText.text = "Get Ready";
		yield return delay;

		mainText.text = "3";
		yield return oneSecond;

		mainText.text = "2";
		yield return oneSecond;

		mainText.text = "1";
		yield return oneSecond;

		mainText.text = "";

		SpawnBall();
	}

    /// <summary>
    /// 生成小球
    /// </summary>
	void SpawnBall()
	{
        //实例化小球
		Entity ball = manager.Instantiate(ballEntityPrefab);

        //计算得到一个小球的初始化速度(向量)
		Vector3 dir = new Vector3(UnityEngine.Random.Range(0, 2) == 0 ? -1 : 1, UnityEngine.Random.Range(-.5f, .5f), 0f).normalized;
		Vector3 speed = dir * ballSpeed;

		PhysicsVelocity velocity = new PhysicsVelocity()
		{
			Linear = speed,
			Angular = float3.zero  //角度？
		};

		manager.AddComponentData(ball, velocity); //给小球添加一个物理速度组件
	}
}

/// <summary>
/// 移动的按键组件
/// </summary>
[GenerateAuthoringComponent]
public struct PaddleInputData : IComponentData
{
	public KeyCode upKey;
	public KeyCode downKey;
}

/// <summary>
/// 移动组件
/// </summary>
[GenerateAuthoringComponent]
public struct PaddleMovementData : IComponentData
{
	public int direction;
	public float speed;
}

using Unity.Entities;
using Unity.Jobs;
using UnityEngine;

//允许作为异步的System处理
//每次JobComponentSystem执行的时候都要等待他自己所依赖的执行完成才行执行自己。同步频率每一帧。
[AlwaysSynchronizeSystem]
public class PlayerInputSystem : JobComponentSystem
{
	protected override JobHandle OnUpdate(JobHandle inputDeps)
	{
        //ref表示修改数据 in表示输入数据 不需要修改 in是主线程操作
		Entities.ForEach((ref PaddleMovementData moveData, in PaddleInputData inputData) =>
		{
			moveData.direction = 0;
			moveData.direction += Input.GetKey(inputData.upKey) ? 1 : 0;
			moveData.direction -= Input.GetKey(inputData.downKey) ? 1 : 0;
		}).Run();
        //.Schedule(inputDeps) //可以在work线程上使用
		return default;
	}
}

/// <summary>
/// 根据PaddleMovementData的值修改左右两侧的墙
/// </summary>
[AlwaysSynchronizeSystem]
public class PaddleMovementSystem : JobComponentSystem
{
	protected override JobHandle OnUpdate(JobHandle inputDeps)
	{
		float deltaTime = Time.DeltaTime;
		float yBound = GameManager.main.yBound;

		Entities.ForEach((ref Translation trans, in PaddleMovementData data) =>
		{
			trans.Value.y = math.clamp(trans.Value.y + (data.speed * data.direction * deltaTime), -yBound, yBound);
		}).Run();

		return default;
	}
}

using Unity.Entities;
using Unity.Transforms;
using Unity.Collections;
using Unity.Mathematics;
using Unity.Jobs;

/// <summary>
/// 检测球的边缘判断输赢
/// </summary>
[AlwaysSynchronizeSystem]
public class BallGoalCheckSystem : JobComponentSystem
{
	protected override JobHandle OnUpdate(JobHandle inputDeps)
	{
		EntityCommandBuffer ecb = new EntityCommandBuffer(Allocator.TempJob);

		Entities
			.WithAll<BallTag>()
			.WithoutBurst()
			.ForEach((Entity entity, in Translation trans) =>
			{
				float3 pos = trans.Value;
				float bound = GameManager.main.xBound;

				if (pos.x >= bound)
				{
					GameManager.main.PlayerScored(0);
					ecb.DestroyEntity(entity);
				}
				else if (pos.x <= -bound)
				{
					GameManager.main.PlayerScored(1);
					ecb.DestroyEntity(entity);
				}
			}).Run();

		ecb.Playback(EntityManager);
		ecb.Dispose();

		return default;
	}
}