/// <summary>
/// BaseEntity.cs
/// Entity基类(逻辑对象抽象，相当于ECS里的E部分)
public abstract class BaseEntity : IRecycle
{
    /// <summary>
    /// Entity Uuid
    /// </summary>
    public int Uuid
    {
        get;
        private set;
    }

    /// <summary>
    /// Entity类型信息
    /// </summary>
    public Type ClassType
    {
        get
        {
            if(mClassType == null)
            {
                mClassType = GetType();
            }
            return mClassType;
        }
    }
    protected Type mClassType;

    /// <summary>
    /// 组件类型和组件列表映射Map
    /// </summary>
    private Dictionary<Type, List<BaseComponent>> mComponentTypeMap;

    *******
}

/// <summary>
/// ECS裡Component基类抽象
/// </summary>
public abstract class BaseComponent : IRecycle
{
    public BaseComponent()
    {

    }

    /// <summary>
    /// 出池
    /// </summary>
    public virtual void OnCreate()
    {

    }

    /// <summary>
    /// 入池
    /// </summary>
    public virtual void OnDispose()
    {
        ResetDatas();
    }

    /// <summary>
    /// 重置数据(子类重写)
    /// </summary>
    protected virtual void ResetDatas()
    {

    }
}

//// <summary>
/// BaseSystem.cs
/// 逻辑系统基类抽象(相当于ECS里的S部分)
/// </summary>
public abstract class BaseSystem
{
    /// <summary>
    /// 所属世界
    /// </summary>
    public BaseWorld OwnerWorld
    {
        get;
        private set;
    }

    /// <summary>
    /// 系统类型信息
    /// </summary>
    public Type ClassType
    {
        get
        {
            if(mClassType == null)
            {
                mClassType = GetType();
            }
            return mClassType;
        }
    }
    protected Type mClassType;

    /// <summary>
    /// 系统系统激活
    /// </summary>
    public bool Enable
    {
        get;
        set;
    }

    /// <summary>
    /// 系统相关Entity列表
    /// </summary>
    public List<BaseEntity> SystemEntityList
    {
        get;
        private set;
    }

    public BaseSystem()
    {
        SystemEntityList = new List<BaseEntity>();
    }

    /// <summary>
    /// 初始化
    /// </summary>
    /// <param name="ownerWorld"></param>
    public virtual void Init(BaseWorld ownerWorld)
    {
        OwnerWorld = ownerWorld;
    }

    /// <summary>
    /// Entity过滤
    /// </summary>
    /// <param name="entity"></param>
    /// <returns></returns>
    public virtual bool Filter(BaseEntity entity)
    {
        return false;
    }
    
    ******
        
        
    /// <summary>
    /// 添加所有事件
    /// </summary>
    public virtual void AddEvents()
    {

    }

    /// <summary>
    /// 响应系统添加到世界
    /// </summary>
    public virtual void OnAddToWorld()
    {
        Debug.Log($"世界名:{OwnerWorld.WorldName}的系统类型:{ClassType.Name}被添加到世界！");
    }

    /// <summary>
    /// 响应Entity添加
    /// </summary>
    /// <param name="entity"></param>
    public virtual void OnAdd(BaseEntity entity)
    {

    }

    /// <summary>
    /// 移除所有事件
    /// </summary>
    public virtual void RemoveEvents()
    {

    }

    /// <summary>
    /// 响应Entity移除
    /// </summary>
    /// <param name="entity"></param>
    public virtual void OnRemove(BaseEntity entity)
    {

    }

    /// <summary>
    /// 响应系统从世界移除
    /// </summary>
    public virtual void OnRemoveFromWorld()
    {
        Debug.Log($"世界名:{OwnerWorld.WorldName}的系统类型:{ClassType.Name}被从世界移除！");
        RemoveSystemAllEntity();
        OwnerWorld = null;
        mClassType = null;
        Enable = false;
    }

    /// <summary>
    /// PreUpdate
    /// </summary>
    /// <param name="deltaTime"></param>
    public virtual void PreProcess(float deltaTime)
    {

    }

    /// <summary>
    /// Entity Update
    /// </summary>
    /// <param name="entity"></param>
    /// <param name="deltaTime"></param>
    public virtual void Process(BaseEntity entity, float deltaTime)
    {

    }

    /// <summary>
    /// PostUpdate
    /// </summary>
    /// <param name="deltaTime"></param>
    public virtual void PostProcess(float deltaTime)
    {

    }

    /// <summary>
    /// LogicUpdate
    /// </summary>
    public virtual void LogicUpdate()
    {

    }

    /// <summary>
    /// FixedUpdate
    /// </summary>
    /// <param name="fixedDeltaTime"></param>
    public virtual void FixedUpdate(float fixedDeltaTime)
    {

    }

    /// <summary>
    /// LateUpdate
    /// </summary>
    /// <param name="deltaTime"></param>
    public virtual void LateUpdate(float deltaTime)
    {

    }
}

/// <summary>
/// BaseWorld.cs
/// 逻辑世界基类抽象(相当于tiny里的World)
/// </summary>
public abstract class BaseWorld
{
    #region World成员定义部分开始
    /// <summary>
    /// 世界名(唯一ID)
    /// </summary>
    public string WorldName
    {
        get;
        private set;
    }

    /// <summary>
    /// 世界根节点GameObject
    /// </summary>
    protected GameObject mWorldRootGo;
    #endregion

    #region System成员定义部分开始
    /// <summary>
    /// 所有系统类型和系统Map<系统类型，系统>
    /// </summary>
    protected Dictionary<Type, BaseSystem> mAllSystemTypeAndSystemMap;

    /// <summary>
    /// 所有系统列表
    /// Note:
    /// 用于确保确定性更新顺序
    /// </summary>
    protected List<BaseSystem> mAllSystems;

    /// <summary>
    /// 等待添加的系统列表
    /// </summary>
    protected List<BaseSystem> mWaitAddSystems;

    /// <summary>
    /// 临时等待添加系统列表
    /// </summary>
    protected List<BaseSystem> mTempWaitAddSystems;

    /// <summary>
    /// 等待移除的系统列表
    /// </summary>
    protected List<BaseSystem> mWaitRemoveSystems;

    /// <summary>
    /// 临时等待移除系统列表
    /// </summary>
    protected List<BaseSystem> mTempWaitRemoveSystems;
    #endregion

    #region Entity成员定义开始
    /// <summary>
    /// 下一个Entity Uuid
    /// </summary>
    protected int mNextEntityUuid;

    /// <summary>
    /// Entity根节点GameObject
    /// </summary>
    protected GameObject mEntityRootGo;

    /// <summary>
    /// Entity类型信息父节点Map
    /// </summary>
    protected Dictionary<Type, Transform> mEntityClassTypeParentMap;

    /// <summary>
    /// Entity Uuid Map<Entitiy Uuid, Entity>
    /// </summary>
    protected Dictionary<int, BaseEntity> mEntityMap;

    /// <summary>
    /// 所有的Entity
    /// Note:
    /// 用于确保有序访问
    /// </summary>
    protected List<BaseEntity> mAllEntity;

    /// <summary>
    /// Entity类型信息和Entity列表Map<Entity类型信息, Entity列表>
    /// </summary>
    protected Dictionary<Type, List<BaseEntity>> mEntityTypeAndEntitiesMap;

    /// <summary>
    /// 等待添加的Entity列表
    /// </summary>
    protected List<BaseEntity> mWaitAddEntities;

    /// <summary>
    /// 临时等待添加Entity列表
    /// </summary>
    protected List<BaseEntity> mTempWaitAddEntities;

    /// <summary>
    /// 等待移除的Entity列表
    /// </summary>
    protected List<BaseEntity> mWaitRemoveEntities;

    /// <summary>
    /// 临时等待移除Entity列表
    /// </summary>
    protected List<BaseEntity> mTempWaitRemoveEntities;
    #endregion
        
    ******
}

/// <summary>
/// WorldManager.cs
/// 世界管理单例类(相当于Tiny)
/// </summary>
public class WorldManager : SingletonTemplate<WorldManager>
{
    /// <summary>
    /// 所有世界Map<世界名, 世界>
    /// </summary>
    private Dictionary<string, BaseWorld> mAllWorldMap;

    /// <summary>
    /// 所有世界列表
    /// Note:
    /// 用于确保确定性更新顺序
    /// </summary>
    private List<BaseWorld> mAllWorlds;

    /// <summary>
    /// 所有更新的世界名列表
    /// </summary>
    private List<string> mAllUpdateWorldNames;

    public WorldManager()
    {
        mAllWorldMap = new Dictionary<string, BaseWorld>();
        mAllWorlds = new List<BaseWorld>();
        mAllUpdateWorldNames = new List<string>();
    }

    /// <summary>
    /// Update
    /// </summary>
    /// <param name="deltaTime"></param>
    public void Update(float deltaTime)
    {
        UpdateAllUpdateWorldNames();
        foreach(var updateWorldName in mAllUpdateWorldNames)
        {
            var world = GetWorld<BaseWorld>(updateWorldName);
            world?.Update(deltaTime);
        }
    }

    /// <summary>
    /// LogicUpdate
    /// </summary>
    public void LogicUpdate()
    {
        UpdateAllUpdateWorldNames();
        foreach (var updateWorldName in mAllUpdateWorldNames)
        {
            var world = GetWorld<BaseWorld>(updateWorldName);
            world?.LogicUpdate();
        }
    }

    /// <summary>
    /// FixedUpdate
    /// </summary>
    /// <param name="fixedDeltaTime"></param>
    public void FixedUpdate(float fixedDeltaTime)
    {
        UpdateAllUpdateWorldNames();
        foreach (var updateWorldName in mAllUpdateWorldNames)
        {
            var world = GetWorld<BaseWorld>(updateWorldName);
            world?.FixedUpdate(fixedDeltaTime);
        }
    }


    /// <summary>
    /// LateUpdate
    /// </summary>
    /// <param name="deltaTime"></param>
    public void LateUpdate(float deltaTime)
    {
        UpdateAllUpdateWorldNames();
        foreach (var updateWorldName in mAllUpdateWorldNames)
        {
            var world = GetWorld<BaseWorld>(updateWorldName);
            world?.LateUpdate(deltaTime);
        }
    }

    /// <summary>
    /// 创建指定类型和名字的世界
    /// </summary>
    /// <typeparam name="T"></typeparam>
    /// <param name="worldName"></param>
    /// <param name="parameters"></param>
    /// <returns></returns>
    public T CreateWrold<T>(string worldName, params object[] parameters) where T : BaseWorld, new()
    {
        var existWorld = GetWorld<T>(worldName);
        if(existWorld != null)
        {
            var worldType = typeof(T);
            Debug.LogError($"已存在世界类型:{worldType.Name}和世界名:{worldName}的世界，创建世界失败！");
            return null;
        }
        var newWorld = new T();
        newWorld.Init(worldName, parameters);
        var result = AddWorld(newWorld);
        if(result)
        {
            newWorld.OnCreate();
        }
        return newWorld;
    }
    
    ******
}

/// <summary>
/// 四个角的视口坐标
/// </summary>
private static Vector3[] ViewPortPoints = new Vector3[5]
{
    new Vector3(0, 0, 0),        // 左下角
    new Vector3(0, 1, 0),        // 左上角
    new Vector3(1, 1, 0),        // 右上角
    new Vector3(1, 0, 0),        // 右下角
    new Vector3(0.5f, 0.5f, 0),  // 中心
};

/// <summary>
/// 获取指定摄像机的射线数据列表
/// </summary>
/// <param name="camera"></param>
/// <param name="rayCastDataList"></param>
/// <returns></returns>
public static bool GetCameraRayCastDataList(Camera camera, ref List<KeyValuePair<Vector3, Vector3>> rayCastDataList)
{
    rayCastDataList.Clear();
    if(camera == null)
    {
        Debug.LogError($"不允许传递空摄像机组件，获取摄像机的射线数据列表失败！");
        return false;
    }

    var cameraNearClipPlane = camera.nearClipPlane;
    ViewPortPoints[0].z = cameraNearClipPlane;
    ViewPortPoints[1].z = cameraNearClipPlane;
    ViewPortPoints[2].z = cameraNearClipPlane;
    ViewPortPoints[3].z = cameraNearClipPlane;
    ViewPortPoints[4].z = cameraNearClipPlane;

    var isOrthographic = camera.orthographic;
    if(isOrthographic)
    {
        // 转换为射线
        for (int i = 0; i < ViewPortPoints.Length; i++)
        {
            Ray ray = camera.ViewportPointToRay(ViewPortPoints[i]);
            var rayCastToPoint = ray.origin + ray.direction * camera.farClipPlane;
            var rayCastData = new KeyValuePair<Vector3, Vector3>(ray.origin, rayCastToPoint);
            rayCastDataList.Add(rayCastData);
        }
    }
    else
    {
        var radio = camera.farClipPlane / cameraNearClipPlane;
        var cameraPosition = camera.transform.position;

        // 获取饰扣四个角的屏幕映射世界坐标
        var lbNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[0]);
        var ltNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[1]);
        var rtNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[2]);
        var rbNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[3]);
        var ctNearPlaneWorldPoints = camera.ViewportToWorldPoint(ViewPortPoints[4]);

        var lbNearPlaneCameraWorldPointDir = lbNearPlaneWorldPoints - cameraPosition;
        var ltNearPlaneCameraWorldPointDir = ltNearPlaneWorldPoints - cameraPosition;
        var rtNearPlaneCameraWorldPointDir = rtNearPlaneWorldPoints - cameraPosition;
        var rbNearPlaneCameraWorldPointDir = rbNearPlaneWorldPoints - cameraPosition;
        var ctNearPlaneCameraWorldPointDir = ctNearPlaneWorldPoints - cameraPosition;

        var lbFarPlaneWorldPoint = cameraPosition + lbNearPlaneCameraWorldPointDir * radio;
        var ltFarPlaneWorldPoint = cameraPosition + ltNearPlaneCameraWorldPointDir * radio;
        var rtFarPlaneWorldPoint = cameraPosition + rtNearPlaneCameraWorldPointDir * radio;
        var rbFarPlaneWorldPoint = cameraPosition + rbNearPlaneCameraWorldPointDir * radio;
        var ctFarPlaneWorldPoint = cameraPosition + ctNearPlaneCameraWorldPointDir * radio;

        var lbRayCastData = new KeyValuePair<Vector3, Vector3>(lbNearPlaneWorldPoints, lbFarPlaneWorldPoint);
        var ltRayCastData = new KeyValuePair<Vector3, Vector3>(ltNearPlaneWorldPoints, ltFarPlaneWorldPoint);
        var rtRayCastData = new KeyValuePair<Vector3, Vector3>(rtNearPlaneWorldPoints, rtFarPlaneWorldPoint);
        var rbRayCastData = new KeyValuePair<Vector3, Vector3>(rbNearPlaneWorldPoints, rbFarPlaneWorldPoint);        
        var ctRayCastData = new KeyValuePair<Vector3, Vector3>(ctNearPlaneWorldPoints, ctFarPlaneWorldPoint);        
        rayCastDataList.Add(lbRayCastData);
        rayCastDataList.Add(ltRayCastData);
        rayCastDataList.Add(rtRayCastData);
        rayCastDataList.Add(rbRayCastData);
        rayCastDataList.Add(ctRayCastData);
    }
    return true;
}

/// <summary>
/// Vector3Utilities.cs
/// Vector3静态工具类
/// </summary>
public static class Vector3Utilities
{
    /// <summary>
    /// 获取指定射线和平面数据的交叉点(返回null表示没有交叉点)
    /// </summary>
    /// <param name="rayOrigin"></param>
    /// <param name="rayDirection"></param>
    /// <param name="planePoint"></param>
    /// <param name="planeNormal"></param>
    /// <returns></returns>
    public static Vector3? GetRayAndPlaneIntersect(Vector3 rayOrigin, Vector3 rayDirection, Vector3 planePoint, Vector3 planeNormal)
    {
        // 计算法向量和方向向量的点积
        float ndotu = Vector3.Dot(planeNormal, rayDirection);

        // 向量几乎平行，可能没有交点或者射线在平面内
        if (Mathf.Approximately(Math.Abs(ndotu), Mathf.Epsilon))
        {
            return null;
        }

        // 计算 t
        Vector3 w = rayOrigin - planePoint;
        float t = -Vector3.Dot(planeNormal, w) / ndotu;

        // 交点在射线起点的后面
        if (t < 0)
        {
            return null;
        }

        // 计算交点
        Vector3 intersectionPoint = rayOrigin + t * rayDirection;
        return intersectionPoint;
    }
}

/// <summary>
/// 获取指定摄像机指定区域顶点和法线的的可视区域顶点数据
/// </summary>
/// <param name="camera"></param>
/// <param name="areaPoint"></param>
/// <param name="areaNormal"></param>
/// <param name="areaPointsList"></param>
/// <param name="rectPointList"></param>
/// <returns></returns>
public static bool GetCameraVisibleArea(Camera camera, Vector3 areaPoint, Vector3 areaNormal, ref List<Vector3> areaPointsList, ref List<Vector3> rectPointList)
{
    areaPointsList.Clear();
    rectPointList.Clear();
    if (camera == null)
    {
        Debug.LogError($"不允许传递空摄像机组件，获取摄像机的可视区域顶点数据失败！");
        return false;
    }

    RayCastDataList.Clear();
    GetCameraRayCastDataList(camera, ref RayCastDataList);
    foreach(var rayCastData in RayCastDataList)
    {
        var rayCastDirection = rayCastData.Value - rayCastData.Key;
        var areaData = Vector3Utilities.GetRayAndPlaneIntersect(rayCastData.Key, rayCastDirection, areaPoint, areaNormal);
        if(areaData != null)
        {
            areaPointsList.Add((Vector3)areaData);
        }
    }

    rectPointList.Add(new Vector3(areaPointsList[1].x, areaPointsList[0].y, areaPointsList[0].z));
    rectPointList.Add(new Vector3(areaPointsList[1].x, areaPointsList[1].y, areaPointsList[1].z));
    rectPointList.Add(new Vector3(areaPointsList[2].x, areaPointsList[2].y, areaPointsList[2].z));
    rectPointList.Add(new Vector3(areaPointsList[2].x, areaPointsList[3].y, areaPointsList[3].z));
    rectPointList.Add(areaPointsList[4]);
    return true;
}

/// <summary>
/// 区域顶点
/// </summary>
[Header("区域顶点")]
public Vector3 AreaPoint = Vector3.zero;

/// <summary>
/// 区域法线
/// </summary>
[Header("区域法线")]
public Vector3 AreaNormal = Vector3.up;

/// <summary>
/// 更新摄像机指定平面映射区域数据
/// </summary>
public void UpdateAreaDatas()
{
    CameraUtilities.GetCameraRayCastDataList(mCameraComponent, ref mRayCastDataList);
    CameraUtilities.GetCameraVisibleArea(mCameraComponent, AreaPoint, AreaNormal, ref mAreaPointsList, ref mRectAreaPointsList);
    mAreaLinesList.Clear();
    mRectAreaLinesList.Clear();
    if(mAreaPointsList.Count > 0)
    {
        var lbToLtLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[0], mAreaPointsList[1]);
        var ltToRtLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[1], mAreaPointsList[2]);
        var rtToRbLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[2], mAreaPointsList[3]);
        var rbToLbLine = new KeyValuePair<Vector3, Vector3>(mAreaPointsList[3], mAreaPointsList[0]);
        mAreaLinesList.Add(lbToLtLine);
        mAreaLinesList.Add(ltToRtLine);
        mAreaLinesList.Add(rtToRbLine);
        mAreaLinesList.Add(rbToLbLine);

        var rectLbToLtLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[0], mRectAreaPointsList[1]);
        var rectLtToRtLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[1], mRectAreaPointsList[2]);
        var rectRtToRbLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[2], mRectAreaPointsList[3]);
        var rectRbToLbLine = new KeyValuePair<Vector3, Vector3>(mRectAreaPointsList[3], mRectAreaPointsList[0]);
        mRectAreaLinesList.Add(rectLbToLtLine);
        mRectAreaLinesList.Add(rectLtToRtLine);
        mRectAreaLinesList.Add(rectRtToRbLine);
        mRectAreaLinesList.Add(rectRbToLbLine);
    }
}

/// <summary>
/// 绘制区域信息Gizmos
/// </summary>
private void DrawAreaInfoGUI()
{
    var preGizmosColor = Gizmos.color;
    Gizmos.color = Color.green;
    Gizmos.DrawSphere(AreaPoint, SphereSize);
    var areaPointTo = AreaPoint + AreaNormal * 5;
    Gizmos.DrawLine(AreaPoint, areaPointTo);
    Gizmos.color = preGizmosColor;
}

/// <summary>
/// 绘制矩形区域
/// </summary>
private void DrawRectAreaGUI()
{
    var preGizmosColor = Gizmos.color;
    Gizmos.color = new Color(0, 0.5f, 0);
    if(mRectAreaLinesList.Count > 0)
    {
        Gizmos.DrawLine(mRectAreaLinesList[0].Key, mRectAreaLinesList[0].Value);
        Gizmos.DrawLine(mRectAreaLinesList[1].Key, mRectAreaLinesList[1].Value);
        Gizmos.DrawLine(mRectAreaLinesList[2].Key, mRectAreaLinesList[2].Value);
        Gizmos.DrawLine(mRectAreaLinesList[3].Key, mRectAreaLinesList[3].Value);
    }
    Gizmos.color = preGizmosColor;
}

/// <summary>
/// 绘制区域Gizmos
/// </summary>
private void DrawAreaGUI()
{
    var preGizmosColor = Gizmos.color;
    Gizmos.color = Color.green;
    if(mAreaLinesList.Count > 0)
    {
        Gizmos.DrawLine(mAreaLinesList[0].Key, mAreaLinesList[0].Value);
        Gizmos.DrawLine(mAreaLinesList[1].Key, mAreaLinesList[1].Value);
        Gizmos.DrawLine(mAreaLinesList[2].Key, mAreaLinesList[2].Value);
        Gizmos.DrawLine(mAreaLinesList[3].Key, mAreaLinesList[3].Value);
    }
    if(mAreaPointsList.Count > 0)
    {
        Gizmos.DrawSphere(mAreaPointsList[4], SphereSize);
    }
    Gizmos.color = preGizmosColor;
}

/// <summary>
/// MapSetting.cs
/// </summary>
public class MapSetting : ScriptableObject
{
#if UNITY_EDITOR
    /// <summary>
    /// Editor下的地图配置单例对象
    /// </summary>
    private static MapSetting EditorSingleton;

    /// <summary>
    /// 获取Editor地图配置单例对象
    /// </summary>
    /// <returns></returns>
    public static MapSetting GetEditorInstance()
    {
        if(EditorSingleton == null)
        {
            EditorSingleton = MapUtilities.LoadOrCreateGameMapSetting();
        }
        return EditorSingleton;
    }
    #endif
        
    /// <summary>
    /// 默认地图横向大小
    /// </summary>
    [Header("默认地图横向大小")]
    [Range(1, 1000)]
    public int DefaultMapWidth = MapConst.DefaultMapWidth;

    /// <summary>
    /// 默认地图纵向大小
    /// </summary>
    [Header("默认地图纵向大小")]
    [Range(1, 1000)]
    public int DefaultMapHeight = MapConst.DefaultMapHeight;

    /// <summary>
    /// 地图对象配置数据
    /// </summary>
    [Header("地图对象配置数据")]
    public MapObjectSetting ObjectSetting = new MapObjectSetting();

    /// <summary>
    /// 地图埋点配置数据
    /// </summary>
    [Header("地图埋点配置数据")]
    public MapDataSetting DataSetting = new MapDataSetting();
}

/// <summary>
/// MapObjectData.cs
/// 地图对象数据
/// </summary>
[Serializable]
public class MapObjectData
{
    /// <summary>
    /// 唯一Id(用于标识地图对象配置唯一)
    /// </summary>
    [Header("唯一Id")]
    public int UID;

    /// <summary>
    /// 实体对象
    /// </summary>
    [Header("实体对象")]
    public GameObject Go;

    /// <summary>
    /// 埋点位置(地图对象可能删除还原，所以需要逻辑层面记录位置)
    /// </summary>
    [Header("埋点位置")]
    public Vector3 Position;

    /// <summary>
    /// 旋转(地图对象可能删除还原，所以需要逻辑层面记录旋转)
    /// </summary>
    [Header("旋转")]
    public Vector3 Rotation = Vector3.zero;

    /// <summary>
    /// 本地缩放(地图对象可能删除还原，所以需要逻辑层面记录缩放)
    /// </summary>
    [Header("缩放")]
    public Vector3 LocalScale = Vector3.one;

    /// <summary>
    /// 碰撞器中心点
    /// </summary>
    [Header("碰撞器中心点")]
    public Vector3 ColliderCenter = new Vector3(0, 0, 0);

    /// <summary>
    /// 碰撞器大小
    /// </summary>
    [Header("碰撞器大小")]
    public Vector3 ColliderSize = new Vector3(1, 1, 1);

    /// <summary>
    /// 碰撞体半径
    /// </summary>
    [Header("碰撞体半径")]
    public float ColliderRadius = 1;

    /// <summary>
    /// 带参构造函数
    /// </summary>
    /// <param name="uid"></param>
    /// <param name="go"></param>
    public MapObjectData(int uid, GameObject go)
    {
        UID = uid;
        Go = go;
    }
}

/// <summary>
/// MapData.cs
/// 地图数据买点数据
/// </summary>
[Serializable]
public class MapData
{
    /// <summary>
    /// 唯一Id(用于标识地图对象配置唯一)
    /// </summary>
    [Header("唯一Id")]
    public int UID;

    /// <summary>
    /// 埋点位置
    /// </summary>
    [Header("埋点位置")]
    public Vector3 Position;

    /// <summary>
    /// 埋点旋转
    /// </summary>
    [Header("埋点旋转")]
    public Vector3 Rotation;

    /// <summary>
    /// 批量操作开关
    /// </summary>
    [Header("批量操作开关")]
    public bool BatchOperationSwitch;

    /// <summary>
    /// GUI关闭开关
    /// </summary>
    [Header("GUI关闭开关")]
    public bool GUISwitchOff = false;
    
    public MapData(int uid)
    {
        UID = uid;
    }

    public MapData(int uid, Vector3 position, Vector3 rotation)
    {
        UID = uid;
        Position = position;
        Rotation = rotation;
    }
}

/// <summary>
/// MapExport.cs
/// 地图导出数据结构定义(统一导出结构定义，方便支持导出不同的数据格式)
/// </summary>
[Serializable]
public class MapExport
{
    /// <summary>
    /// 地图导出数据成员
    /// </summary>
    public MapDataExport MapData = new MapDataExport();

    /// <summary>
    /// 所有怪物导出数据列表
    /// </summary>
    public List<MonsterMapDataExport> ALlMonsterMapDatas = new List<MonsterMapDataExport>();

    /// <summary>
    /// 所有宝箱导出数据列表
    /// </summary>
    public List<TreasureBoxMapDataExport> AllTreasureBoxMapDatas = new List<TreasureBoxMapDataExport>();

    /// <summary>
    /// 所有陷阱导出数据列表
    /// </summary>
    public List<TrapMapDataExport> AllTrapMapDatas = new List<TrapMapDataExport>();

    /// <summary>
    /// 剩余其他地图埋点导出数据成员
    /// </summary>
    public List<BaseMapDataExport> AllOtherMapDatas = new List<BaseMapDataExport>();
}

/// <summary>
/// MapObjectExport.cs
/// 地图动态物体数据导出定义
/// </summary>
[Serializable]
public class MapObjectExport
{
    /// <summary>
    /// 地图对象类型
    /// </summary>
    public MapObjectType MapObjectType;

    /// <summary>
    /// 关联配置Id
    /// </summary>
    public int ConfId;

    /// <summary>
    /// 位置信息
    /// </summary>
    public Vector3 Position;

    /// <summary>
    /// 旋转信息
    /// </summary>
    public Vector3 Rotation;

    /// <summary>
    /// 缩放信息
    /// </summary>
    public Vector3 LocalScale;

    public MapObjectExport(MapObjectType mapObjectType, int confId, Vector3 position, Vector3 rotation, Vector3 localScale) 
    {
        MapObjectType = mapObjectType;
        ConfId = confId;
        Position = position;
        Rotation = rotation;
        LocalScale = localScale;
    }
}

/// <summary>
/// BaseMapDataExport.cs
/// 地图埋点数据基类导出定义
/// </summary>
[Serializable]
public class BaseMapDataExport
{
    /// <summary>
    /// 埋点类型
    /// </summary>
    public MapDataType MapDataType;

    /// <summary>
    /// 关联Id
    /// </summary>
    public int ConfId;

    /// <summary>
    /// 位置信息
    /// </summary>
    public Vector3 Position;

    /// <summary>
    /// 旋转信息
    /// </summary>
    public Vector3 Roation;

    public BaseMapDataExport(MapDataType mapDataType, int confId, Vector3 position, Vector3 rotation)
    {
        MapDataType = mapDataType;
        ConfId = confId;
        Position = position;
        Roation = rotation;
    }
}

/// <summary>
/// MonsterMapDataExport.cs
/// 怪物地图埋点数据导出
/// </summary>
[Serializable]
public class MonsterMapDataExport : BaseMapDataExport
{
    /// <summary>
    /// 怪物创建半径
    /// </summary>
    public float MonsterCreateRadius;

    /// <summary>
    /// 怪物警戒半径
    /// </summary>
    public float MonsterActiveRadius;

    public MonsterMapDataExport(MapDataType mapDataType, int confId, Vector3 position,  Vector3 rotation, float monsterCreateRadius, float monsterActiveRadius)
        : base(mapDataType, confId, position, rotation)
        {
            MonsterCreateRadius = monsterCreateRadius;
            MonsterActiveRadius = monsterActiveRadius;
        }
}