using DG.Tweening;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;
using System.Linq;
using Unity.VisualScripting;
using UnityEngine;
using UnityEngine.SceneManagement;

/// <summary>
/// 公共指令
/// </summary>
public enum PublicCommond
{
    /// <summary>
    /// 初始化场景
    /// </summary>
    init_scene,
    /// <summary>
    /// 加载音频
    /// </summary>
    audio_load,
    /// <summary>
    /// 播放音频
    /// </summary>
    audio_play,
    /// <summary>
    /// 暂停音频
    /// </summary>
    audio_pause,
    /// <summary>
    /// 停止音频
    /// </summary>
    audio_stop,
    /// <summary>
    /// 设置音量
    /// </summary>
    audio_set_volume,
    /// <summary>
    /// 截图
    /// </summary>
    screen_shot,
    /// <summary>
    //  获取所有可替换的场景照片
    /// </summary>
    get_control_image,
    /// <summary>
    /// 设置背景照片
    /// </summary>
    set_control_image,
    /// <summary>
    /// 获取所有可创建的场景物体
    /// </summary>
    get_scene_objet,
    /// <summary>
    /// 设置场景元素物体
    /// </summary>
    set_scene_objet,
    /// <summary>
    /// 相机模式
    /// </summary>
    set_camera_mode
}

public enum UAVCommand
{
    /// <summary>
    /// 创建
    /// </summary>
    init_position,
    /// <summary>
    /// 设置名称
    /// </summary>
    set_name,
    /// <summary>
    /// 设置颜色
    /// </summary>
    set_color,
    /// <summary>
    /// 启动
    /// </summary>
    start_engine,
    /// <summary>
    /// 关闭
    /// </summary>
    shut_down_engine,
    /// <summary>
    /// 设置旋翼动力
    /// </summary>
    set_rotor_power,
    /// <summary>
    /// 方向向量控制飞行
    /// </summary>
    fly_by_3d_direction,
    /// <summary>
    /// 时间控制定点飞行
    /// </summary>
    fly_to_point_by_time,
    /// <summary>
    /// 速度控制定点飞行
    /// </summary>
    fly_to_point_by_speed,
    /// <summary>
    /// 悬停
    /// </summary>
    hovering,
    /// <summary>
    /// 启用避障
    /// </summary>
    enable_obstacle_avoidance,
    /// <summary>
    /// 禁用避障
    /// </summary>
    disable_obstacle_avoidance,
    /// <summary>
    /// 编队控制
    /// </summary>
    formation_control,
    /// <summary>
    /// 控制高亮
    /// </summary>
    open_lighter,
    /// <summary>
    /// 关闭高亮
    /// </summary>
    close_lighter,
    /// <summary>
    /// 轨迹渲染
    /// </summary>
    open_trail_render,
    /// <summary>
    /// 关闭轨迹渲染
    /// </summary>
    close_trail_render,
    /// <summary>
    /// 获取当前高度
    /// </summary>
    get_current_height,
    /// <summary>
    /// 获取当前距离
    /// </summary>
    get_current_distance,
    /// <summary>
    /// 获取当前姿态
    /// </summary>
    get_current_attitude_angle,
    /// <summary>
    /// 获取当前水平速度
    /// </summary>
    get_current_horizontal_speed,
    /// <summary>
    /// 获取当前垂直速度
    /// </summary>
    get_current_vertical_speed,
    /// <summary>
    /// 打开模拟图传
    /// </summary>
    open_hd,
    /// <summary>
    /// 关闭模拟图传
    /// </summary>
    close_hd,
    /// <summary>
    /// 设置昼夜
    /// </summary>
    time_set,
    /// <summary>
    /// 打开摄像头
    /// </summary>
    open_real_camera,
    /// <summary>
    /// 关闭摄像头
    /// </summary>
    close_real_camera,
    /// <summary>
    /// 获取语音识别结果
    /// </summary>
    get_speech_text,
    /// <summary>
    /// 打开碰撞碰撞
    /// </summary>
    openCollider,
    /// <summary>
    /// 关闭碰撞
    /// </summary>
    close_collider,
    /// <summary>
    /// 单无人机飞立方体
    /// </summary>
    draw_fly_Cube,
    /// <summary>
    /// 单无人机飞球体
    /// </summary>
    draw_fly_Sphere,
    /// <summary>
    /// 单无人机飞圆柱
    /// </summary>
    draw_fly_Cylinder,
    /// <summary>
    /// 单无人机飞圆锥
    /// </summary>
    draw_fly_Cone
}

public class UAVManager : MonoBehaviour
{
    public static UAVManager Instance;

    private GameObject templete;
    /// <summary>
    /// 无人机模板
    /// </summary>
    public GameObject Templete { get { if (templete == null) templete = Resources.Load("Prefabs/UAV") as GameObject; return templete; } }

    /// <summary>
    /// 使用全局坐标
    /// </summary>
    public bool useGlobalPosition;

    [SerializeField]
    private Transform uav_parent;
    /// <summary>
    /// 无人机生成父物体
    /// </summary>
    public Transform UAVParent
    {
        get
        {
            if (uav_parent == null)
                Init();
            return uav_parent;
        }
    }

    /// <summary>
    /// 创建无人机间隔
    /// </summary>
    public float create_distance = 1;

    /// <summary>
    /// 所有创建的无人机对象
    /// </summary>
    public List<GameObject> UAVs = new List<GameObject>();
    /// <summary>
    /// 所有无人机模拟控制器对象
    /// </summary>
    public List<UAVSimulator> uav_simulator = new List<UAVSimulator>();
    /// <summary>
    /// 所有无人机控制器对象
    /// </summary>
    public List<UAVController> uav_controller = new List<UAVController>();

    /// <summary>
    /// 碰撞层
    /// </summary>
    public LayerMask ColliderLayer;

    /// <summary>
    /// 场景元素物体
    /// </summary>
    private List<GameObject> sceneObject = new List<GameObject>();

    #region 环境元素

    public Material day_skybox;
    public Material night_skybox;
    public Light direction_light;
    public GameObject night_environment;
    public Material trail_material;
    #endregion

    #region Editor 

    public Vector3 pos;//创建单无人机位置
    public Vector2 size;//创建无人机阵列大小
    public Vector4 quat;//四旋翼各速度

    /// <summary>
    /// 各向速度修正
    /// </summary>
    public float rise_modify, descend_modify, move_modify, rotate_modify;

    /// <summary>
    /// 无人机飞至指定位置
    /// </summary>
    public Vector3 tar_pos = new Vector3(5, 5, 5);
    /// <summary>
    /// 是否控制所有无人机
    /// </summary>
    public bool all_uav;
    /// <summary>
    /// 无人机单控编号
    /// </summary>
    public int uav_index = 1;
    /// <summary>
    /// 无人机固定飞行速度
    /// </summary>
    public float fly_speed = 2;
    /// <summary>
    /// 无人机固定飞行时间
    /// </summary>
    public float fly_time = 2;
    public string array_light_json_data;
    public string array_position_json_data;
    public string array_position_json_data2;

    #endregion

    private void Awake()
    {
        Instance = this;
    }

    private void Start()
    {
        Init();
        MyServer.instance.SetHandler_wrj(PythonDataHandler);
        MyServer.instance.SetHandler_other((data) =>
        {
            var command = (PublicCommond)Enum.Parse(typeof(PublicCommond), data["commond"].ToString());
            var eventid = data["event_id"].ToObject<int>();
            //后添加
          //  ScoreManager.Instance.UpdateScore(command.ToString());
            switch (command)
            {
                case PublicCommond.init_scene:
                    //清理无人机
                    ClearAllUavs();

                    //关闭摄像头
                    MainCanvasManager.webcam_panel.gameObject.SetActive(false);
                    //重置分数
                    ScoreManager.Instance.ResetScore();

                    //关闭媒体音乐
                    MediaPlayer.Instance.AudioStop();

                    //切回自由模式
                    Camera.main.transform.GetComponent<CameraMove>().enabled = true;
                    transform.GetComponent<MyCameraRoate>().EndRoate();

                    //清理场景元素
                    sceneObject.ForEach(a =>
                    {
                        Destroy(a);
                    });
                    sceneObject.Clear();

                    //隐藏ide面板
                    //MainCanvasManager.Instance.transform.Find("ide设置面板").gameObject.SetActive(false);

                    MyServer.instance.SendMsgToSDK(eventid, ResultStatus.SUCCESS);
                    break;
                case PublicCommond.audio_load:
                    var __file_name = data["filepath"].ToObject<string>();
                    MediaPlayer.Instance.NewAudioLoad(__file_name, (result, msg) =>
                    {
                        ConsolePanel.ConsoleOutput("语音加载" + (result == true ? "完成：" : "失败：" + msg), "log");
                        DoReturn(result, eventid, msg);
                    });
                    break;
                case PublicCommond.audio_play:
                    MediaPlayer.Instance.AudioPlay();
                    break;
                case PublicCommond.audio_pause:
                    MediaPlayer.Instance.AudioPause();
                    break;
                case PublicCommond.audio_stop:
                    MediaPlayer.Instance.AudioStop();
                    break;
                case PublicCommond.audio_set_volume:
                    var __volume = data["volume"].ToObject<float>();
                    MediaPlayer.Instance.AudioSetVolume(__volume);
                    break;
                case PublicCommond.screen_shot:
                    bool isStep = data["isStep"].ToObject<bool>();
                    string stepName = data["stepName"].ToObject<string>();
                    if (!isStep)
                    {
                        MainCanvasManager.Instance.ScreemShot(CallForTest.instance.pathTaskFile + "/任务.png");
                    }
                    else
                    {
                        MainCanvasManager.Instance.ScreemShot(CallForTest.instance.pathTaskFile + "/步骤_" + stepName + ".png");
                    }

                    break;
                case PublicCommond.get_control_image:
                    List<string> tmpNames = new List<string>();
                    List<MyCardItem> list = GameObject.FindObjectsByType<MyCardItem>(FindObjectsInactive.Exclude, FindObjectsSortMode.None).ToList();
                    list.ForEach(a =>
                    {
                        if (!string.IsNullOrEmpty(a.Nameid))
                        {
                            tmpNames.Add(a.Nameid);
                        }
                    });
                    DoReturn(true, eventid, JsonConvert.SerializeObject(tmpNames));
                    break;
                case PublicCommond.set_control_image:
                    {
                        string name = data["name"].ToString();
                        string filePath = data["filePath"].ToString();
                        MyCardItem item = GameObject.FindObjectsByType<MyCardItem>(FindObjectsInactive.Exclude, FindObjectsSortMode.None).ToList().Find(a => a.Nameid == name);
                        if (item != null)
                        {
                            item.ChangeTexture(filePath, (isok, str) =>
                            {
                                DoReturn(isok, eventid, str);
                            });
                        }
                    }
                    break;
                case PublicCommond.get_scene_objet:
                    {
                        List<string> names = new List<string>();
                        var tmps = Resources.LoadAll<GameObject>("sceneObject").ToList();
                        tmps.ForEach(a =>
                        {
                            names.Add(a.name);
                        });
                        DoReturn(true, eventid, JsonConvert.SerializeObject(names));
                    }
                    break;
                case PublicCommond.set_scene_objet:
                    {
                        string name = data["name"].ToString();
                        float[] point = data["point"].ToObject<float[]>();
                        float[] rotate = data["rotate"].ToObject<float[]>();
                        GameObject obj = Resources.Load<GameObject>("sceneObject/" + name);
                        if (obj != null)
                        {
                            GameObject sceneObj = GameObject.Instantiate<GameObject>(obj, UAVParent, true);
                            sceneObject.Add(sceneObj);
                            sceneObj.transform.localPosition = new Vector3(point[0], point[1], point[2]);
                            sceneObj.transform.localEulerAngles = new Vector3(rotate[0], rotate[1], rotate[2]);
                            DoReturn(true, eventid, "设置成功");
                        }
                        else
                        {
                            DoReturn(false, eventid, "不存在此场景元素");
                        }
                    }
                    break;
                    //问题待解决
                case PublicCommond.set_camera_mode:
                    {
                        //设置相机模式
                        var mode = data["mode"].ToObject<string>();
                        if (mode == "自由模式")
                        {
                            Camera.main.transform.GetComponent<CameraMove>().enabled = true;
                            transform.GetComponent<MyCameraRoate>().EndRoate();
                        }
                        else if (mode == "环绕模式")
                        {
                            var center = data["center"].ToObject<float[]>();
                            var radius = data["radius"].ToObject<float>();
                            var tmpspeed = data["speed"].ToObject<float>();
                            var high = data["high"].ToObject<float>();
                            Camera.main.transform.GetComponent<CameraMove>().enabled = false; 
                            Vector3 tmpc=new Vector3(center[0], center[1], center[2]);
                            
                            transform.GetComponent<MyCameraRoate>().StartRoate(Camera.main, UAVParent.position + tmpc, radius, tmpspeed, high);
                        }
                    }
                    break;
                default:
                    break;
            }
        });
        ClearAllUavs();

        MainCanvasManager.on_reset_scene += ResetScene;
    }

    private void OnDestroy()
    {
        MainCanvasManager.on_reset_scene -= ResetScene;
    }

    public void Init()
    {
        if (GameObject.Find("GameCenter") != null)
            uav_parent = GameObject.Find("GameCenter").transform;
        else
        {
            Debug.Log("未找到GameCenter！");
            if (ConsolePanel.Instance != null)
                ConsolePanel.ConsoleOutput("未找到GameCenter！", "warning");
        }
    }

    /// <summary>
    /// 重置场景
    /// </summary>
    public void ResetScene()
    {
        ClearAllUavs();
        UIScene.Instance.Reset();
        UIScene.Instance.ResetCameraTransform();
    }

    #region 功能实现

    /// <summary>
    /// 从位置创建新无人机
    /// </summary>
    /// <param name="_pos"></param>
    public bool CreateNewUAV(Vector3 _pos, bool _isarray = false, int _uav_number = 0)
    {
        //检测范围内是否有无人机
        if (Physics.CheckSphere(_pos, 0.5f, 1 << 6) && !_isarray)
            return false;

        var newt = Instantiate(Templete, UAVParent);
        UAVs.Add(newt);
        if (useGlobalPosition)
            newt.transform.position = _pos;
        else
            newt.transform.localPosition = _pos;
        newt.transform.SetAsLastSibling();
        newt.SetActive(true);
        var uav = newt.GetComponentInChildren<UAVController>();
        var moni2 = newt.GetComponentInChildren<UAVSimulator>();
        moni2.Init();
        uav_simulator.Add(moni2);
        moni2.uav_id = _uav_number == 0 ? uav_simulator.Count : _uav_number;
        uav_controller.Add(uav);

        return true;
    }


    /// <summary>
    /// 更新无人机名称
    /// </summary>
    /// <param name="_uav_number"></param>
    /// <param name="_name"></param>
    /// <returns></returns>
    public bool UpdateUavName(int _uav_number, string _name)
    {
        var uav = uav_simulator.Find(x => x.uav_id == _uav_number);
        if (uav == null)
            return false;
        uav.name = _name;
        return true;
    }

    /// <summary>
    /// 更新无人机颜色
    /// </summary>
    /// <param name="_uav_number"></param>
    /// <param name="_color_1"></param>
    /// <param name="_color_2"></param>
    /// <returns></returns>
    public bool UpdateUavColor(int _uav_number, Color _color_1, Color _color_2)
    {
        var uav = uav_simulator.Find(x => x.uav_id == _uav_number);
        if (uav == null)
            return false;
        uav.UpdateModelColor(_color_1, _color_2);
        //UnityEngine.ColorUtility.TryParseHtmlString(_color, out Color __color);
        Debug.Log(_color_1);
        //todo
        return true;
    }

    /// <summary>
    /// 根据id启动无人机
    /// </summary>
    /// <param name="number"></param>
    public bool StartUav(int id)
    {
        var uav = uav_simulator.Find(x => x.uav_id == id);
        if (uav == null)
        {
            Debug.Log("id 未找到");
            return false;
        }
        else
        {
            uav.StartUav();
            return true;
        }
    }

    /// <summary>
    /// 根据id关闭无人机
    /// </summary>
    /// <param name="id"></param>
    public bool ShutdownUav(int id)
    {
        var uav = uav_simulator.Find(x => x.uav_id == id);
        if (uav == null)
        {
            Debug.Log("id 未找到");
            return false;
        }
        else
        {
            uav.ShutDownUAV();
            return true;
        }
    }

    /// <summary>
    /// 设置旋翼速度
    /// </summary>
    /// <param name="_number"></param>
    /// <param name="_power"></param>
    public void SetRotorPower(int _number, float[] _power)
    {
        var _uav = uav_simulator.Find(x => x.uav_id == _number);
        if (_uav != null)
        {
            _uav.ManualSpeed();
            _uav.f1 = _power[0]; _uav.f2 = _power[1];
            _uav.f3 = _power[2]; _uav.f4 = _power[3];
        }
    }

    /// <summary>
    /// 给定速度朝方向飞行
    /// </summary>
    /// <param name="_number"></param>
    /// <param name="_direction"></param>
    /// <param name="_speed"></param>
    /// <param name="_time"></param>
    public void Fly_By_Direction(int _number, Vector3 _direction, float _speed, float _time)
    {
        var _uav = uav_simulator.Find(x => x.uav_id == _number);
        if (_uav != null)
        {
            //_uav.uav_id
            _uav.FlyByDirection(_direction, _speed, _time);
        }
    }

    /// <summary>
    /// 以固定时间飞至指定地点
    /// 最终使用方法
    /// </summary>
    /// <param name="_number"></param>
    /// <param name="_target"></param>
    /// <param name="_time"></param>
    public void Fly_To_Target_By_Time(int _number, Vector3 _target, float _time, int _event_id)
    {
        uav_simulator.Find(x => x.uav_id.Equals(_number))?.ToTargetByTime(_target, _time, (_success) =>
        {
            if (_success)
            {
                MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.SUCCESS, "");
            }
        });
    }

    /// <summary>
    /// 以固定速度飞至指定地点
    /// 最终使用方法
    /// </summary>
    /// <param name="_number"></param>
    /// <param name="_target"></param>
    /// <param name="_fly_speed"></param>
    public void Fly_To_Target_By_Speed(int _number, Vector3 _target, float _fly_speed, int _event_id) 
    {
        uav_simulator.Find(x => x.uav_id.Equals(_number))?.ToTargetBySpeed(_target, _fly_speed, (_success) =>
        {
            if (_success)
            {
                MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.SUCCESS, "");
            }
        });
    }

    /// <summary>
    /// 保持悬停
    /// </summary>
    /// <param name="_number"></param>
    public void Hovering(int _number)
    {
        uav_simulator.Find(x => x.uav_id.Equals(_number))?.HoveringController();
    }

    /// <summary>
    /// 启用自动避障
    /// </summary>
    public void EnableObstacleAvoidance(int _number)
    {
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            _u.controller.autoStopBeforeCollision = true;
            _u.controller.on_collision_warning += OnUavCollisionWarning;
        }
    }

    /// <summary>
    /// 关闭自动避障
    /// </summary>
    public void DisableObstacleAvoidance(int _number)
    {
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            _u.controller.autoStopBeforeCollision = false;
        }
    }

    /// <summary>
    /// 编队控制
    /// </summary>
    /// <param name="_json_data"></param>
    /// <returns></returns>
    public float Formation_Control(string _json_data)
    {
        var jds = JsonConvert.DeserializeObject<UavIndexData[]>(_json_data);
        var __max_time = 0f;
        var __current_time = 0f;
        for (int i = 0; i < jds.Length; i++)
        {
            __current_time = uav_simulator[jds[i].uav_index - 1].HandleUavTimeData(jds[i]);
            if (__current_time > __max_time)
                __max_time = __current_time;
        }
        return __max_time;
    }

    /// <summary>
    /// 打开灯光
    /// </summary>
    /// <param name="_number"></param>
    /// <param name="_parameters"></param>
    public void Open_Lighter(int _number, JObject _parameters)
    {
        string _color = _parameters["color"].ToObject<string>();
        //float _intensity = _parameters["intensity"].ToObject<float>();

        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            _u.OpenLighter(_color);
        }
    }

    /// <summary>
    /// 关闭灯光
    /// </summary>
    /// <param name="_number"></param>
    public void Close_Lighter(int _number)
    {
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            _u.CloseLighter();
        }
    }

    /// <summary>
    /// 打开轨迹渲染
    /// </summary>
    /// <param name="_number"></param>
    /// <param name="_jobject"></param>
    public void Open_Trail_Render(int _number, JObject _jobject)
    {
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            var trail_color_str = _jobject["parameters"]["color"].ToObject<string>();
            UnityEngine.ColorUtility.TryParseHtmlString(trail_color_str, out Color _color);
            var trail_thickness = _jobject["parameters"]["thickness"].ToObject<float>();
            _u.uav_trail_render.Open(_color, trail_thickness,false);
        }
    }

    /// <summary>
    /// 关闭轨迹渲染
    /// </summary>
    /// <param name="_number"></param>
    public void Close_Trail_Render(int _number)
    {
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            _u.uav_trail_render.Close();
        }
    }

    /// <summary>
    /// 获取当前高度
    /// </summary>
    /// <param name="_number"></param>
    /// <returns></returns>
    public float Get_Current_Height(int _number)
    {
        var _height = -1f;
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            _height = _u.controller.transform.localPosition.y;
        }
        return (float)System.Math.Round(_height, 1);
    }

    /// <summary>
    /// 获取当前水平距离
    /// </summary>
    /// <param name="_number"></param>
    /// <returns></returns>
    public float Get_Current_Distance(int _number)
    {
        var _distance = -1f;
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            _distance = Mathf.Sqrt(_u.controller.transform.localPosition.x * _u.controller.transform.localPosition.x + _u.controller.transform.localPosition.z * _u.controller.transform.localPosition.z);
        }
        return (float)System.Math.Round(_distance, 1);
    }

    /// <summary>
    /// 获取当前姿态角
    /// </summary>
    /// <param name="_number"></param>
    /// <returns></returns>
    public Vector3 Get_Current_Attitude_Angle(int _number)
    {
        var _attitude_angle = Vector3.zero;
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            _attitude_angle = _u.controller.transform.localEulerAngles;
        }
        return _attitude_angle;
    }

    /// <summary>
    /// 获取当前水平速度
    /// </summary>
    /// <param name="_number"></param>
    /// <returns></returns>
    public float Get_Current_Horizontal_Speed(int _number)
    {
        var _horizontal_speed = 0f;
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
             _horizontal_speed = Mathf.Sqrt(_u.controller.rigidBody.velocity.x * _u.controller.rigidBody.velocity.x + _u.controller.rigidBody.velocity.z * _u.controller.rigidBody.velocity.z);
            //_horizontal_speed = _u.controller.horizontal_speed;
            Debug.Log(_horizontal_speed);
        }
        return _horizontal_speed;
    }

    /// <summary>
    /// 获取当前垂直速度
    /// </summary>
    /// <param name="_number"></param>
    /// <returns></returns>
    public float Get_Current_Vertical_Speed(int _number)
    {
        var _vertical_speed = 0f;
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
              _vertical_speed = _u.controller.rigidBody.velocity.y;
            //_vertical_speed = _u.controller.vertical_speed;
            Debug.Log(_vertical_speed);
        }
        return _vertical_speed;
    }

    /// <summary>
    /// 打开模拟高清图传
    /// </summary>
    public void Open_Hd(int _number)
    {
        var _u = uav_simulator.Find(x => x.uav_id.Equals(_number));
        if (_u != null)
        {
            UavFpsCamera.Instance.UpdateTarget(_u.uav_fps_camera_transform);
        }
    }

    /// <summary>
    /// 关闭模拟高清图传
    /// </summary>
    public void Close_Hd(int _number)
    {
        UavFpsCamera.Instance.UpdateTarget(null);
    }

    #endregion

    /// <summary>
    /// 无人机碰撞预警输出
    /// </summary>
    /// <param name="_msg"></param>
    void OnUavCollisionWarning(string _msg)
    {
        Console(_msg, "warning");
    }

    /// <summary>
    /// 更新所有速度
    /// </summary>
    /// <param name="fs"></param>
    public void UpdateAllSpeed(Vector4 fs)
    {
        uav_simulator.ForEach(v =>
        {
            v.ManualSpeed();
            v.f1 = fs.x; v.f2 = fs.y;
            v.f3 = fs.z; v.f4 = fs.w;
        });
    }

    /// <summary>
    /// 启动所有无人机
    /// </summary>
    public void StartAll()
    {
        uav_simulator.ForEach(v => v.StartUav());
    }

    /// <summary>
    /// 关闭所有无人机
    /// </summary>
    public void ShutdownAll()
    {
        uav_simulator.ForEach(v => v.ShutDownUAV());
    }

    /// <summary>
    /// 重置所有无人机位置、状态
    /// </summary>
    public void ResetAll()
    {
        uav_simulator.ForEach(v => v.ResetUAV());
    }

    /// <summary>
    /// 设置所有无人机上升速度矫正
    /// </summary>
    /// <param name="modify"></param>
    public void SetAllRiseModify(float modify)
    {
        if (modify > 0)
            uav_simulator.ForEach(v => v.rise_speed_modify = modify);
    }

    /// <summary>
    /// 设置所有无人机下降速度矫正
    /// </summary>
    /// <param name="modify"></param>
    public void SetAllDescendModify(float modify)
    {
        if (modify > 0)
            uav_simulator.ForEach(v => v.descend_speed_modify = modify);
    }

    /// <summary>
    /// 设置所有无人机移动速度矫正
    /// </summary>
    /// <param name="modify"></param>
    public void SetAllMoveModify(float modify)
    {
        if (modify > 0)
            uav_simulator.ForEach(v => v.move_speed_modify = modify);
    }

    /// <summary>
    /// 设置所有无人机旋转速度矫正
    /// </summary>
    /// <param name="modify"></param>
    public void SetAllRotateModify(float modify)
    {
        if (modify > 0)
            uav_simulator.ForEach(v => v.rotate_speed_modify = modify);
    }

    /// <summary>
    /// 创建无人机阵列
    /// </summary>
    /// <param name="size"></param>
    public void CreateUavArray(Vector2 size)
    {
        ClearAllUavs();
        for (int i = 0; i < size.x; i++)
        {
            for (int j = 0; j < size.y; j++)
            {
                CreateNewUAV(new Vector3(i, 0, j) * create_distance, true);//无人机阵列创建调用
            }
        }
    }

    /// <summary>
    /// 清除所有无人机
    /// </summary>
    public void ClearAllUavs()
    {
        for (int i = 0; i < UAVs.Count; i++)
        {
            Destroy(UAVs[i].gameObject);
        }

        UAVs.Clear();
        uav_simulator.Clear();
        uav_controller.Clear();
    }

    /// <summary>
    /// 固定速度飞至指定坐标
    /// </summary>
    /// <param name="tar_pos"></param>
    /// <param name="index"></param>
    /// <param name="fly_speed"></param>
    public void Fly2TargetBySpeed(Vector3 tar_pos, int index, float fly_speed)
    {
        if (tar_pos.y > 0 && Mathf.Abs(tar_pos.x) < 100 && Mathf.Abs(tar_pos.z) < 100)
        {
            var moni = uav_simulator[index - 1];

            moni.ToTargetBySpeed(tar_pos, fly_speed);
        }
        else
        {
            Debug.Log("超出范围![100,100]");
        }
    }

    /// <summary>
    /// 固定时间飞至指定坐标
    /// </summary>
    /// <param name="tar_pos"></param>
    /// <param name="index"></param>
    /// <param name="fly_time"></param>
    public void Fly2TargetByTime(Vector3 tar_pos, int index, float fly_time)
    {
        if (tar_pos.y > 0 && Mathf.Abs(tar_pos.x) < 100 && Mathf.Abs(tar_pos.z) < 100)
        {
            var moni = uav_simulator[index - 1];

            moni.ToTargetByTime(tar_pos, fly_time);
        }
        else
        {
            Debug.Log("超出范围![100,100]");
        }
    }

    /// <summary>
    /// 设置当前时间
    /// </summary>
    /// <param name="_event_id"></param>
    /// <param name="_time"></param>
    public void Time_Set(int _event_id, string _time)
    {
        if (_time == "昼" || _time == "夜")
        {
            if (GameManager.current_scene_time != _time)
            {
                var _scene = GameManager.current_scene + "_" + _time;
                if (SceneManager.GetSceneByName(_scene) != null)
                {
                    GameManager.current_scene_time = _time;
                    SceneOverlayManager.Instance.LoadSceneAsync(_scene, true, ((_async) =>
                    {
                        MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.SUCCESS);
                        Console("切换场景[" + _scene + "]成功！");
                    }));
                }
                else
                {
                    MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.FAILED_WARNING);
                    Console("切换场景[" + _scene + "]失败！", "warning");
                }
            }
            else
            {
                MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.SUCCESS);
                Console("当前场景时间为[" + _time + "]！");
            }
        }
        else
        {
            MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.FAILED_WARNING, "切换场景失败！请输入“昼”或“夜”来切换场景时间！");
            Console("切换场景失败！请输入“昼”或“夜”来切换场景时间！", "warning");
        }
    }

    /// <summary>
    /// 打开摄像头
    /// </summary>
    public void Open_Real_Camera()
    {
        MainCanvasManager.webcam_panel.OnActive(true);
    }

    /// <summary>
    /// 关闭摄像头
    /// </summary>
    public void Close_Real_Camera()
    {
        MainCanvasManager.webcam_panel.OnNagetive(false);
    }

    #region 弃用

#if UNITY_EDITOR
    public string color_value;
    public float color_intensity;
    private void Update()
    {
        if (Input.GetKeyDown(KeyCode.L))
        {
            uav_simulator[0].OpenLighter(color_value, color_intensity);
        }

        if (Input.GetKeyDown(KeyCode.R))
        {
            uav_simulator[0].CloseLighter();
        }
    }
#endif

    #endregion

    /// <summary>
    /// 第三数据类型，无人机编组数据
    /// </summary>
    public string uav_index_json_data;


    /// <summary>
    /// 无人机矩阵飞行数据
    /// 分发至每个无人机各自执行
    /// </summary>
    public void UavTimeDataHandle()
    {
        var jds = JsonConvert.DeserializeObject<UavIndexData[]>(uav_index_json_data);

        for (int i = 0; i < jds.Length; i++)
        {
            uav_simulator[jds[i].uav_index - 1].HandleUavTimeData(jds[i]);
        }
    }

    /// <summary>
    /// 选择环境时间
    /// </summary>
    public void SwitchEnvironmentTime(bool use_night)
    {
        if (use_night)
        {
            //day_skybox.SetFloat("_Exposure", 0);
            RenderSettings.skybox = night_skybox;
            direction_light.intensity = 0.01f;
            night_environment.SetActive(true);
        }
        else
        {
            //day_skybox.SetFloat("_Exposure", 1);
            RenderSettings.skybox = day_skybox;
            direction_light.intensity = 0.45f;
            night_environment.SetActive(false);
        }
    }
    /// <summary>
    /// 打开录音面板,并开始语音识别
    /// </summary>
    /// <param name="v"></param>
    /// <param name="number"></param>
    /// <returns></returns>
    private void Openmicrophone(int number,Action<bool,string> callback)
    {
        RobotUI.Instance.OpenPanel(RobotePanelEnum.RecordPanel.ToString()).GetComponent<RecordPanel>().Init(number, callback);

        //if (MicrophoneInput.instance.CheckMicrophone())
        //{
        //    RobotUI.Instance.OpenPanel(RobotePanelEnum.RecordPanel.ToString()).GetComponent<RecordPanel>().Init(number,callback);
        //}
        //else
        //{
        //    callback(false,"错误：无麦克风");
        //}

    }

    public void PythonDataHandler(JObject _jobject)
    {
        //数据格式{"type": "wrj", "commond": "create", "pos": [0, 0], "number": 1, "eventid": 1}
        var _command = (UAVCommand)Enum.Parse(typeof(UAVCommand), _jobject["commond"].ToString());
        var _event_id = _jobject["event_id"].ToObject<int>();

        int _number = -1;
        if (_jobject["number"] != null)
            _number = _jobject["number"].ToObject<int>();

        JObject _parameters = null;
        if (_jobject["parameters"] != null)
            _parameters = _jobject["parameters"].ToObject<JObject>();

        ScoreManager.Instance.UpdateScore(_command.ToString());

        switch (_command)
        {
            case UAVCommand.init_position:
                var pos = _jobject["pos"].ToObject<float[]>();
                Console(string.Format("设置[{0}]号无人机初始化：[{1},{2}]", _number, pos[0], pos[1]));
                bool isCreate = CreateNewUAV(new Vector3(pos[0], 0, pos[1]), false, _number);
                DoReturn(isCreate, _event_id, isCreate==true? "创建无人机成功！": "创建无人机失败! ");
                break;

            case UAVCommand.set_name:
                var name = _jobject["name"].ToObject<string>();
                Console(string.Format("设置[{0}]号无人机名称：{1}", _number, name));
                DoReturn(UpdateUavName(_number, name), _event_id, "更新名称成功！");
                break;

            case UAVCommand.set_color:
                //var uav_color_1 = _jobject["color_1"].ToObject<Color>();
                //var uav_color_2 = _jobject["color_2"].ToObject<Color>();

                if (UnityEngine.ColorUtility.TryParseHtmlString(_jobject["color_1"].ToObject<string>(), out var uav_color_1)
                     && UnityEngine.ColorUtility.TryParseHtmlString(_jobject["color_2"].ToObject<string>(), out var uav_color_2))
                {
                    Console(string.Format("设置[{0}]号无人机颜色，区域1：{1}，区域2：{2}", _number, uav_color_1, uav_color_2));
                    DoReturn(UpdateUavColor(_number, uav_color_1, uav_color_2), _event_id, "");
                }
                else
                {
                    DoReturn(false, _event_id, "颜色代码错误！");
                }
                break;

            case UAVCommand.start_engine:
                Console(string.Format("启动[{0}]号无人机引擎", _number));
                DoReturn(StartUav(_number), _event_id, "启动引擎成功！");
                break;

            case UAVCommand.shut_down_engine:
                Console(string.Format("关闭[{0}]号无人机引擎", _number));
                DoReturn(ShutdownUav(_number), _event_id, "关闭引擎成功！");
                break;

            case UAVCommand.set_rotor_power:
                var _power = _jobject["parameters"]["power"].ToObject<float[]>();
                SetRotorPower(_number, _power);
                Console(string.Format("设置[{0}]号无人机旋翼速度", _number));
                break;

            case UAVCommand.fly_by_3d_direction://不会下降
                var direction = _jobject["direction"].ToObject<float[]>();
                var speed = _jobject["speed"].ToObject<float>();
                var time = _jobject["time"].ToObject<float>();
                Fly_By_Direction(_number, new Vector3(direction[0], direction[1], direction[2]), speed, time);
                Console(string.Format("[{0}]号无人机以速度：{1}米每秒，方向[{2},{3},{4}]，飞行{5}秒", _number, speed, direction[0], direction[1], direction[2], time));
                break;

            case UAVCommand.fly_to_point_by_time:
                var _fly_by_time_target = _jobject["direction"].ToObject<float[]>();
                var _fly_time = _jobject["duration"].ToObject<float>();
                Fly_To_Target_By_Time(_number, new Vector3(_fly_by_time_target[0], _fly_by_time_target[1], _fly_by_time_target[2]), _fly_time, _event_id);
                Console(string.Format("[{0}]号无人机在：{1}秒内，飞行至[{2},{3},{4}]", _number, _fly_time, _fly_by_time_target[0], _fly_by_time_target[1], _fly_by_time_target[2]));
                break;

            case UAVCommand.fly_to_point_by_speed://会下降
                var _fly_by_speed_target = _jobject["direction"].ToObject<float[]>();
                var _fly_speed = _jobject["duration"].ToObject<float>();
                Fly_To_Target_By_Speed(_number, new Vector3(_fly_by_speed_target[0], _fly_by_speed_target[1], _fly_by_speed_target[2]), _fly_speed, _event_id);
                Console(string.Format("[{0}]号无人机在：{1}秒内，飞行至[{2},{3},{4}]", _number, _fly_speed, _fly_by_speed_target[0], _fly_by_speed_target[1], _fly_by_speed_target[2]));
                break;

            case UAVCommand.hovering:
                Hovering(_number);
                Console(string.Format("[{0}]号无人机悬停", _number));
                break;

            case UAVCommand.enable_obstacle_avoidance:
                EnableObstacleAvoidance(_number);
                Console(string.Format("打开[{0}]号无人机自动避障", _number));
                break;

            case UAVCommand.disable_obstacle_avoidance:
                DisableObstacleAvoidance(_number);
                Console(string.Format("关闭[{0}]号无人机自动避障", _number));
                break;
            //问题待解决
            case UAVCommand.formation_control:
                var __formation_data = _jobject["formation_data"].ToObject<string>();
                var __wait_for_return = _jobject["wait_for_return"].ToObject<bool>();
                var __max_time = Formation_Control(__formation_data);
                if (__wait_for_return)
                {
                    //在最大时间后返回结果
                    var __t = 0f;
                    DOTween.To(() => __t, (t) => __t = t, __max_time, __max_time).OnComplete(() =>
                    {
                        MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.SUCCESS);
                    });
                }
                Console(string.Format("编队控制"));
                break;
            case UAVCommand.open_lighter:
                Open_Lighter(_number, _parameters);
                Console(string.Format("打开[{0}]号无人机灯光", _number));
                break;

            case UAVCommand.close_lighter:
                Close_Lighter(_number);
                Console(string.Format("关闭[{0}]号无人机灯光", _number));
                break;

            case UAVCommand.open_trail_render:
                Open_Trail_Render(_number, _jobject);
                Console(string.Format("[{0}]号无人机启动轨迹渲染", _number));
                break;

            case UAVCommand.close_trail_render:
                Close_Trail_Render(_number);
                Console(string.Format("[{0}]号无人机关闭轨迹渲染", _number));
                break;

            case UAVCommand.get_current_height:
                var _current_height = Get_Current_Height(_number);
                Console(string.Format("[{0}]号无人机当前高度为：{1:F1}", _number, _current_height));
                DoReturn(true, _event_id, _current_height);
                break;

            case UAVCommand.get_current_distance:
                var _current_distance = Get_Current_Distance(_number);
                Console(string.Format("[{0}]号无人机当前距离为：{1}", _number, _current_distance));
                DoReturn(true, _event_id, _current_distance);
                break;

            case UAVCommand.get_current_attitude_angle:
                var _current_attitude_angle = Get_Current_Attitude_Angle(_number);
                Console(string.Format("[{0}]号无人机当前旋转角为：{1}", _number, _current_attitude_angle.ToString(":F2")));
                DoReturn(true, _event_id, _current_attitude_angle);
                break;

            case UAVCommand.get_current_horizontal_speed:
                var _current_horizontal_speed = Get_Current_Horizontal_Speed(_number);
                //Console(string.Format("[{0}]号无人机当前水平速度为：{1}", _number, _current_horizontal_speed));
                //DoReturn(true, _event_id, _current_horizontal_speed);
                DoReturn(true, _event_id, "此方法暂时不可使用");
                break;

            case UAVCommand.get_current_vertical_speed:
                var _current_vertical_speed = Get_Current_Vertical_Speed(_number);
                //Console(string.Format("[{0}]号无人机当前垂直速度为：{1}", _number, _current_vertical_speed));
                //DoReturn(true, _event_id, _current_vertical_speed);
                DoReturn(true, _event_id, "此方法暂时不可使用");
                break;

            case UAVCommand.open_hd:
                Open_Hd(_number);
                Console(string.Format("[{0}]号无人机高清图传功能", _number));
                break;

            case UAVCommand.close_hd:
                Close_Hd(_number);
                Console(string.Format("[{0}]号无人机高清图传功能", _number));
                break;

            case UAVCommand.time_set:
                var t_time = _jobject["t_time"].ToObject<string>();
                Time_Set(_event_id, t_time);
                break;

            case UAVCommand.open_real_camera:
                Open_Real_Camera();
                ConsolePanel.ConsoleOutput("执行动作：" + "打开摄像头", "log");
                break;

            case UAVCommand.close_real_camera:
                Close_Real_Camera();
                ConsolePanel.ConsoleOutput("执行动作：" + "关闭摄像头", "log");
                break;
            case UAVCommand.get_speech_text:
                RobotUI.Instance.Init();
                Openmicrophone(_number, (isok, result) =>
                {
                    DoReturn(isok, _event_id, result);
                });
                break;
                //问题待解决
            case UAVCommand.openCollider:
                {
                    //打开碰撞
                    UAVSimulator uavs = uav_simulator.Find(a => a.uav_id == _number);
                    uavs.transform.parent.Find("_Drone [Quad]").GetComponents<Collider>().ToList().ForEach(a =>
                    {
                        a.enabled = true;
                    });
                    //设置无人机不掉下去
                    uavs.StartUav();
                    uavs.AutoSpeed();
                    uavs.f1 = uavs.f2 = uavs.f3 = uavs.f4 = 5;
                } 
                break;
            case UAVCommand.close_collider:
                {
                    //关闭碰撞
                    UAVSimulator uavs = uav_simulator.Find(a => a.uav_id == _number);
                    uavs.transform.parent.Find("_Drone [Quad]").GetComponents<Collider>().ToList().ForEach(a =>
                    {
                        a.enabled = false;
                    });
                }
                break;
            case UAVCommand.draw_fly_Cube:
                {
                    //飞立方体
                    List<float[]> firstPoint = _jobject["points"].ToObject<List<float[]>>();
                    List<Vector3> p = new List<Vector3>();
                    firstPoint.ForEach(a => 
                    {
                        p.Add(new Vector3(a[0], a[1], a[2]));
                    });

                    float length = _jobject["length"].ToObject<float>();
                    float wighth = _jobject["wighth"].ToObject<float>();
                    float high = _jobject["high"].ToObject<float>();
                    string color = _jobject["color"].ToString();
                    float alpha = _jobject["alpha"].ToObject<float>();
                    float thick = _jobject["thickness"].ToObject<float>();
                    float tmptime = _jobject["time"].ToObject<float>();
                    float[] center = _jobject["center"].ToObject<float[]>();

                    UnityEngine.ColorUtility.TryParseHtmlString(color, out Color _color);
                    uav_simulator.Find(x => x.uav_id.Equals(_number))?.ToPathByTime(p, tmptime, _color, thick, (_success) =>
                    {
                        if (_success)
                        {
                            //透明度
                            _color.a = alpha;
                            //生成cube
                            GameObject obj = Resources.Load<GameObject>("sceneObject/Cube");
                            if (obj != null)
                            {
                                GameObject sceneObj = GameObject.Instantiate<GameObject>(obj, UAVParent, true);
                                sceneObject.Add(sceneObj);
                                sceneObj.transform.localPosition = new Vector3(center[0], center[1], center[2]);
                                sceneObj.transform.localScale = new Vector3(length, high, wighth);
                                sceneObj.GetComponent<Renderer>().material.color= _color;
                                MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.SUCCESS, "");
                            }
                        }
                    });
                }
                break;
            case UAVCommand.draw_fly_Sphere:
                {
                    //飞球体
                    List<float[]> firstPoint = _jobject["points"].ToObject<List<float[]>>();
                    List<Vector3> p = new List<Vector3>();
                    firstPoint.ForEach(a =>
                    {
                        p.Add(new Vector3(a[0], a[1], a[2]));
                    });

                    float radius = _jobject["radius"].ToObject<float>();
                    string color = _jobject["color"].ToString();
                    float alpha = _jobject["alpha"].ToObject<float>();
                    float thick = _jobject["thickness"].ToObject<float>();
                    float tmptime = _jobject["time"].ToObject<float>();
                    float[] center = _jobject["center"].ToObject<float[]>();

                    UnityEngine.ColorUtility.TryParseHtmlString(color, out Color _color);
                    uav_simulator.Find(x => x.uav_id.Equals(_number))?.ToPathByTime(p, tmptime, _color, thick, (_success) =>
                    {
                        if (_success)
                        {
                            //透明度
                            _color.a = alpha;
                            //生成cube
                            GameObject obj = Resources.Load<GameObject>("sceneObject/Sphere");
                            if (obj != null)
                            {
                                GameObject sceneObj = GameObject.Instantiate<GameObject>(obj, UAVParent, true);
                                sceneObject.Add(sceneObj);
                                sceneObj.transform.localPosition = new Vector3(center[0], center[1], center[2]);
                                sceneObj.transform.localScale = new Vector3(radius*2, radius*2, radius*2);
                                sceneObj.GetComponent<Renderer>().material.color = _color;
                                MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.SUCCESS, "");
                            }
                        }
                    });
                }
                break;
            case UAVCommand.draw_fly_Cylinder:
                {
                    //飞圆柱体
                    List<float[]> firstPoint = _jobject["points"].ToObject<List<float[]>>();
                    List<Vector3> p = new List<Vector3>();
                    firstPoint.ForEach(a =>
                    {
                        p.Add(new Vector3(a[0], a[1], a[2]));
                    });

                    float radius = _jobject["radius"].ToObject<float>();
                    float high = _jobject["high"].ToObject<float>();
                    string color = _jobject["color"].ToString();
                    float alpha = _jobject["alpha"].ToObject<float>();
                    float thick = _jobject["thickness"].ToObject<float>();
                    float tmptime = _jobject["time"].ToObject<float>();
                    float[] center = _jobject["center"].ToObject<float[]>();

                    UnityEngine.ColorUtility.TryParseHtmlString(color, out Color _color);
                    uav_simulator.Find(x => x.uav_id.Equals(_number))?.ToPathByTime(p, tmptime, _color, thick, (_success) =>
                    {
                        if (_success)
                        {
                            //透明度
                            _color.a = alpha;
                            //生成cube
                            GameObject obj = Resources.Load<GameObject>("sceneObject/Cylinder");
                            if (obj != null)
                            {
                                GameObject sceneObj = GameObject.Instantiate<GameObject>(obj, UAVParent, true);
                                sceneObject.Add(sceneObj);
                                sceneObj.transform.localPosition = new Vector3(center[0], center[1], center[2]);
                                sceneObj.transform.localScale = new Vector3(radius * 2, high/2, radius * 2);
                                sceneObj.GetComponent<Renderer>().material.color = _color;
                                MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.SUCCESS, "");
                            }
                        }
                    });
                }
                break;
            case UAVCommand.draw_fly_Cone:
                {
                    //飞圆柱体
                    List<float[]> firstPoint = _jobject["points"].ToObject<List<float[]>>();
                    List<Vector3> p = new List<Vector3>();
                    firstPoint.ForEach(a =>
                    {
                        p.Add(new Vector3(a[0], a[1], a[2]));
                    });

                    float radius = _jobject["radius"].ToObject<float>();
                    float high = _jobject["high"].ToObject<float>();
                    string color = _jobject["color"].ToString();
                    float alpha = _jobject["alpha"].ToObject<float>();
                    float thick = _jobject["thickness"].ToObject<float>();
                    float tmptime = _jobject["time"].ToObject<float>();
                    float[] center = _jobject["center"].ToObject<float[]>();

                    UnityEngine.ColorUtility.TryParseHtmlString(color, out Color _color);
                    uav_simulator.Find(x => x.uav_id.Equals(_number))?.ToPathByTime(p, tmptime, _color, thick, (_success) =>
                    {
                        if (_success)
                        {
                            //透明度
                            _color.a = alpha;
                            //生成cube
                            GameObject obj = Resources.Load<GameObject>("sceneObject/Cone");
                            if (obj != null)
                            {
                                GameObject sceneObj = GameObject.Instantiate<GameObject>(obj, UAVParent, true);
                                sceneObject.Add(sceneObj);
                                sceneObj.transform.localPosition = new Vector3(center[0], center[1], center[2]);
                                sceneObj.transform.localScale = new Vector3(radius , high , radius);
                                sceneObj.GetComponent<Renderer>().material.color = _color;
                                MyServer.instance.SendMsgToSDK(_event_id, ResultStatus.SUCCESS, "");
                            }
                        }
                    });
                }
                break;
            default:
                break;
        }
    }

    /// <summary>
    /// 执行并返回结果
    /// </summary>
    /// <param name="_success"></param>
    /// <param name="_eventid"></param>
    /// <param name="_result"></param>
    private void DoReturn(bool _success, int _eventid, object _result = null)
    {
        if (_success)
            MyServer.instance.SendMsgToSDK(_eventid, ResultStatus.SUCCESS, _result.ToString());
        else
            MyServer.instance.SendMsgToSDK(_eventid, ResultStatus.FAILED_ERROR, _result.ToString());
    }

    private void Console(string _message, string _type = "log")
    {
        ConsolePanel.ConsoleOutput(_message, _type);//输出无人机信息
    }
}

#region 无人机编组数据
/// <summary>
/// 无人机阵列数据
/// </summary>
public class UavIndexData
{
    /// <summary>
    /// 无人机编号
    /// </summary>
    public int uav_index;
    public UavTimeData[] uav_time_data;
}

public class UavTimeData
{
    /// <summary>
    /// 时间
    /// </summary>
    public float time;
    /// <summary>
    /// 坐标
    /// </summary>
    public string position;
    /// <summary>
    /// 灯光颜色
    /// </summary>
    public string color;
    /// <summary>
    /// 灯光强度
    /// </summary>
    public float intensity;
}
#endregion