public struct CubeProperties: IComponentData
{
    public Vector2 FieldSize;
    public int CubeCount;
    public Entity CubePrefab;
}

public struct CubeRandom : IComponentData
{
    public Random Value;

public class CubeMono : MonoBehaviour
{
    public Vector2 FieldSize;
    public int CubeCount;
    public GameObject CubePrefab;
    public uint RandomSeed;
}

public class CubeBaker : Baker<CubeMono>
{
    public override void Bake(CubeMono authoring)
    {
        // 为当前Entity添加Component，可以添加多个
        AddComponent(new CubeProperties
        {
            FieldSize = authoring.FieldSize,
            CubeCount = authoring.CubeCount,   
            CubePrefab = GetEntity(authoring.CubePrefab)	// 这里做了Prefab转Entity
        });
        AddComponent(new CubeRandom
        {
            Value = Random.CreateFromIndex(authoring.RandomSeed)
        });
    }
}

namespace ECS.Study
{
    public readonly partial struct CubeAspect : IAspect
    {
        public readonly Entity Entity;
		// TransformAspect 已经被取消
        private readonly RefRW<LocalTransform> _localTransform; 
        private readonly RefRO<CubeProperties> _cubeProperties;
        private readonly RefRW<CubeRandom> _cubeRandom;
        private readonly RefRW<SphereSpawnPoints> _sphereSpawnPoints;

        public int CubeCount => _cubeProperties.ValueRO.CubeCount;
        public Entity CubePrefab => _cubeProperties.ValueRO.CubePrefab;

        // 在中心创建一个球，球内将不会创建Cube
        #region SphereCreate
        public bool SphereSpawnPointsIsCreated() {
            return _sphereSpawnPoints.ValueRO.Value.IsCreated && SphereSpawnPointsCount > 0;
        }
        private int SphereSpawnPointsCount => _sphereSpawnPoints.ValueRO.Value.Value.Value.Length;

        #endregion
        
		// 生成Cube的位置和朝向
        #region Transform

        public LocalTransform GetRandomCubeTransform()
        {
            return new LocalTransform
            {
                Position = GetRandomPosition(),
                Rotation = GetRandomRotation(),
                Scale = GetRandomScale(0.5f)
            };
        }

        private float3 GetRandomPosition()
        {
            float3 randomPosition;
            do
            {
                randomPosition = _cubeRandom.ValueRW.Value.NextFloat3(MinCorner, MaxCorner);
            } while (math.distancesq(_localTransform.ValueRO.Position, randomPosition) <= CUBE_SAFETY_RADIUS_SQ);

            return randomPosition;
        }

        private float3 HalfDimension => new()
        {
            x = _cubeProperties.ValueRO.FieldSize.x * 0.5f,
            y = 0f,
            z = _cubeProperties.ValueRO.FieldSize.y * 0.5f
        };

        private float3 MinCorner => _localTransform.ValueRO.Position - HalfDimension;
        private float3 MaxCorner => _localTransform.ValueRO.Position + HalfDimension;
        private const float CUBE_SAFETY_RADIUS_SQ = 100;

        private quaternion GetRandomRotation()
        {
            return quaternion.RotateY(_cubeRandom.ValueRW.Value.NextFloat(-0.25f, 0.25f));
        }

        private float GetRandomScale(float min)
        {
            return _cubeRandom.ValueRW.Value.NextFloat(min, 1f);
        }

        public float2 GetRandomOffset()
        {
            return _cubeRandom.ValueRW.Value.NextFloat2();
        }
        #endregion
    }
}

// 设置初始化顺序，能在System界面看到
[UpdateInGroup(typeof(InitializationSystemGroup))]	
public partial struct CubeGenerateSystem : ISystem
{
    [BurstCompile]
    public void OnCreate(ref SystemState state)
    {
		// 当场景中包含至少一个 CubeProperties 组件时，启用 Update
        state.RequireForUpdate<CubeProperties>();
    }

    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
		state.Enabled = false;  // 禁用 Update
        var cubeEntity = SystemAPI.GetSingletonEntity<CubeProperties>();
        var cube = SystemAPI.GetAspect<CubeAspect>(cubeEntity);
        var builder = new BlobBuilder(Allocator.Temp);
        ref var spawnPoints = ref builder.ConstructRoot<SphereSpawnPointsBlob>();
        var arrayBuilder = builder.Allocate(ref spawnPoints.Value, cube.CubeCount);
        var spawnOffset = new float3(0f, -2f, 1f);
        // 创建命令缓冲区
        var cmd = new EntityCommandBuffer(Allocator.Temp);
        for (int i = 0; i < cube.CubeCount; i++)
        {
            // 将命令添加至命令缓冲区
            var newCube = cmd.Instantiate(cube.CubePrefab);
            var newTransform = cube.GetRandomCubeTransform();
            cmd.SetComponent(newCube, newTransform);

            var newSpawnPoint = newTransform.Position + spawnOffset;
            arrayBuilder[i] = newSpawnPoint;
        }

        var blobAsset = builder.CreateBlobAssetReference<SphereSpawnPointsBlob>(Allocator.Persistent);
        cmd.SetComponent(cubeEntity, new SphereSpawnPoints{ Value = blobAsset });
        builder.Dispose();

        cmd.Playback(state.EntityManager);    // 执行命令 
    }

    [BurstCompile]
    public void OnDestroy(ref SystemState state)
    {
        
    }
}

public struct SphereSpawnPoints : IComponentData
{
    public BlobAssetReference<SphereSpawnPointsBlob> Value;
}

public struct SphereSpawnPointsBlob
{
    public BlobArray<float3> Value;
}

public partial struct DoSomeJob: IJobEntity
{
    // 这两个public的成员用来传递参数
    public float DeltaTime;
    public EntityCommandBuffer ECS;

    private void Execute(CubeAspect cubeAspect)
    {
		...
    }
}

[BurstCompile]
public void OnUpdate(ref SystemState state)
{
    var deltaTime = SystemAPI.Time.DeltaTime;
    var ecbSingleton = SystemAPI.GetSingleton<BeginInitializationEntityCommandBufferSystem.Singleton>();
            
    new DoSomeJob
    {
        DeltaTime = deltaTime,
        ECB = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged)
    }.Run();
}

public partial class CameraControllerSystem : SystemBase
{
    protected override void OnUpdate()
    {
        var cameraSigleton = CameraSingleton.Instance;
        if(cameraSigleton == null) return;
        float positionFactor =(float) SystemAPI.Time.ElapsedTime * cameraSigleton.Speed;
        float scale = 1;
        var radius = cameraSigleton.RadiusAtScale(scale);
        var height = cameraSigleton.HeightAtScale(scale);
        cameraSigleton.transform.position = new UnityEngine.Vector3
        {
            x = Mathf.Cos(positionFactor) * radius,
            y = height,
            z = Mathf.Sin(positionFactor) * radius
        };
        cameraSigleton.transform.LookAt(Vector3.zero, Vector3.up);
    }
}

public class CameraSingleton : MonoBehaviour
{
    public static CameraSingleton Instance { get; private set; }

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

    [SerializeField] private float startRadius;
    [SerializeField] private float endRadius;
    [SerializeField] private float startHeight;
    [SerializeField] private float endHeight;
    [SerializeField] private float speed;

    public float RadiusAtScale(float scale) => Mathf.Lerp(startRadius, endRadius, 1 - scale);
    public float HeightAtScale(float scale) => Mathf.Lerp(startHeight, endHeight, 1 - scale);
    public float Speed => speed;
}