[Header("基础属性")] 
public int age;
public string name;

[Header("进阶属性")]
public float height;
public float weight;

//当对象(自己找个类对象)被创建时，才会调用该生命周期函数
//类似构造函数，一个对象只会调用一次
void Awake()

//依附的GameObject对象每次激活时调用（打勾）
//想要当一个对象被激活时进行一些逻辑处理,就可以写在这个函数
void OnEnable()

// 对象Awake后，第一次帧更新之前调用，一个对象只会调用一次
void Start()

//进行物理帧更新  
//固定间隔执行，间隔时间可以设置  
void FixedUpdate()C

// 逻辑帧执行，每帧执行
// 处理游戏核心逻辑更新
void Update()

// 每帧执行，于Update之后执行（速度相同）
//一般用来处理摄像机位置更新相关内容的
//Update和LateUpdate之间，Unity会处理动画相关的更新，如果将摄像机放在Update中更新，可能会造成渲染上的问题
void LateUpdate()

//依附的GameObject对象每次失活时调用（去掉勾）
//想要当一个对象失活时进行一些逻辑处理,就可以写在这个函数
void OnDisable()

//当对象被销毁时调用(衣服的GameObject对象被删除时调用)
//一般用来做一些资源的释放
void OnDestroy()

//随机数 int 重载规则是左包含，右不包含 [)
int randomNum = Random.Range(0, 100);

//float 重载规则是左右都包含 []
float randomNum = Random.Range(0.0f, 100.0f);

System.Random r = new System.Random();  
r.Next(); //生成一个非负的随机数  
r.Next(100); //生成[0,99)的随机数 

UnityAction ac1 = () => { print("test1"); };  //无参无返回值  
  
UnityAction<string> ac2 = (str) => { print("test2");};//有参无返回值

System.Action ac1 = () => { print("test1"); }; //无参无返回值  
System.Action<int,float> ac2 = (i,f)=> { print("test2"); };//有参无返回值  
  
System.Func<string> ac3 = () => { return "test3"; };//无参有返回值  
System.Func<int, float, string> ac4 = (i, f) => { return "test3"; };//有参有返回值

public event UnityAction clickEvent;

[Serializable]  
public class EventVector3 : UnityEvent<Vector3>  //<Vector3> 是该事件的参数
{  

}

//Lerp原理
result = （1-t）start + t * end; //t为插值系数，取值范围为0~1

//用法
result  = Mathf.Lerp(start,end,t);

//每帧改变 start 的值—变化速度先快后慢，位置无限接近，但是不会得到 end 位置 
start = Mathf.Lerp ( start，10，Time.deltaTime);

//每帧改变 t 的值—变化速度匀速，位置每帧接近，当 t>=1 时，得到结果
time += Time.deltaTime;
result = Mathf.Lerp(start,10,time);

//用Slerp，让物体围绕一个点旋转
C.position = Vector3.slerp(Vector3.right * 10，Vector3.forward * 10,time);

//弧度转角度  
float radian = Mathf.PI;  
float angle = radian * Mathf.Rad2Deg; //Deg:degree 度  
  
//角度转弧度  
radian = angle * Mathf.Deg2Rad;


//Mathf中的三角函数，传入的参数需要是弧度
float sinValue = Mathf.Sin(30 * Mathf.Deg2Rad); //注意角度转成弧度

//反三角函数得到的结果也是弧度
float arcSinValue = Mathf.Asin(0.5f);

//Vector3的初始化
Vector3 v1 = new Vector3();
v1.x = 10;
v1.y = 10;
v1.z = 10;

Vector3 v2 = new Vector3(10, 10, 10);

//对应世界空间位置
Vector3 v3 = Vector3.zero; // (0, 0, 0)
Vector3 v4 = Vector3.one; // (1, 1, 1)
Vector3 v5 = Vector3.right; // (1, 0, 0)
Vector3 v6 = Vector3.left; // (-1, 0, 0)
Vector3 v7 = Vector3.up; // (0, 1, 0)
Vector3 v8 = Vector3.down; // (0, -1, 0)
Vector3 v9 = Vector3.forward; // (0, 0, 1)
Vector3 v10 = Vector3.back; // (0, 0, -1)

//计算点之间的距离
Vector3.Distance(v1, v2);

//向量模长
v1.magnitude

//单位向量
v1.normalized

//点乘
Vector3.Dot  //gameplay中点乘可以用来判断目标物体的前后方向
//叉乘
Vector3.Cross //gameplay中点乘可以用来得到两个向量之间的左右位置关系

//线性插值
Vector3.Lerp
//球形插值
Vector3.SLerp 

//方法一：
//绕轴（3，4，5）旋转30度，注意要转弧度
Quaternion q = new Quaternion(Mathf.Sin(30/2 * Mathf.Deg2Rad)*3, Mathf.Sin(30/2 * Mathf.Deg2Rad)*4, Mathf.Sin(30/2 * Mathf.Deg2Rad)*5,Mathf.Cos(30/2 * Mathf.Deg2Rad));  

//方法二：更方便！推荐！
//绕轴（3，4，5）旋转30度  
Quaternion q2 = Quaternion.AngleAxis(30, new Vector3(3,4,5));

//创建一个立方体  
GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Cube);  
obj.transform.rotation = q;  //结果可直接赋给rotation

//欧拉角转四元数
Quaternion.Euler(x,y,z)

//四元数转欧拉角
Quaternion q;
q.eulerAngles

//将rotation改为了（0，0，0）
obj.transform.rotation = Quaternion.identity; 

//创建一个位置和角度都为0的对象
GameObject objClone = Instantiate(obj, Vector3.zero, Quaternion.identity);

//A看向B
Quaternion q = Quaternion.LookRotation(B.position - A.position);
A.rotation = q;

 //绕y轴转30
 //注意旋转轴是局部空间的！
Quaternion q = Quaternion.AngleAxis(30,Vector3.up);
this.transform.rotation *= q;

//每帧绕 Vector3.forward 旋转 1 度
this.transform.rotation *= Quaternion.AngleAxis(1，Vector3.forward); 

Vector3 v = Vector3.forward;  
v = Quaternion.AngleAxis(45, Vector3.up) * v;

this.transform.position;
this.transform.rotation;
this.transform.eulerAngles;
this.transform.lossyScale;

//相对父对象的物体坐标系的位置本地坐标相对坐标T/
this.transform.localposition;
this.transform.localEulerAngles;
this.transform.localRotation;
this.transform.localscale;
//修改他们会是相对父对象物体坐标系的变化

Input.mousePosition
Screen.width
Screen.height

//世界坐标系的点转换为局部坐标系点（会受缩放影响）
//上图中的P即为Vector3.forward
this.transform.InverseTransformPoint(Vector3.forward);

//世界坐标系的向量转换为局部坐标系的向量
//不受缩放影响
this.transform.InverseTransformDirection(Vector3.forward);
//受缩放影响
this.transform.InverseTransformVector(Vector3.forward);

//⭐点（受缩放影响）
print(this.transform.TransformPoint(Vector3.forward));  

//向量
//不受缩放影响
print(this.transform.TransformDirection(Vector3.forward));
//受缩放影响
print(this.transform.TransformDirection(Vector3.up));

//世界坐标转屏幕坐标
Vector3 screenPos = Camera.main.WorldToScreenPoint(this.transform.position);  //XY是屏幕坐标，Z轴是深度
print(screenPos);

//屏幕坐标转世界坐标
Vector3 worldPos = Camera.main.ScreenToWorldPoint(screenPos);
print(worldPos);

//世界坐标转视口坐标
Camera.main.worldToViewportPoint

//视口转世界
Camera.main.ViewportToworldPoint 

//视口转屏幕
Camera.main.ViewportToScreenPoint

//屏幕转视口
Camera.main.screenToViewportPoint

//1.没有继承MonoBehaviour的类的时候，可以使用Debug.Log
Debug.Log("Awake Hello!");
Debug.LogError("Awake Error");
Debug.LogWarning("Awake Warning");  
//2. 继承了MonoBehaviour的类，可以使用线程方法print
print("Awake Hello!");

//画线段
//前两个参数为起点、终点
//向前方画一条线段：
Debug.DrawLine(this.transform.position,
               this.transform.position + this.transform.forward,
               Color.red);

//画射线
//前两个参数为起点、方向
Debug.DrawRay(this.transform.position,
               this.transform.forward,
               Color.red);

//方法一：
MyScript s1 = this.GetComponent<MyScript>();
if (s1 != null)
{
    s1.dosomething();
}

//方法二：
MyScript s2;
if(this.TryGetComponent<MyScript>(out s2))
{
    s2.dosomething();

//等价，这样写更简便
if(this.TryGetComponent<MyScript>(out MyScript s2))
{
    s2.dosomething();
}

void Start()
{
    Invoke("TestFunc", 5.0f);
}

public void TestFunc()
{
    print("延时执行");
    
    paramFunc(2); //通过包裹一层来延迟执行paramFunc函数
}

public void paramFunc(int i)
{
    print("参数为" + i);
}

//5s后输出
//延时执行
//参数为2

private void QnEnable()
{
    //对象激活的生命周期函数中开启延迟(重复执行的延迟)
}

private void QnDisable()
{
    //对象失活的生命周期函数中停止延迟
}

//名字
print(this.gameObject.name);

//是否激活
print(this.gameObject.activeSelf);

//static
print(this.gameObject.isStatic);

//层级
print(this.gameObject.layer);

//标签
print(this.gameObject.tag);

//transform
print(this.transform.position);

//创建几何体
//只要得到了一个Gameobject 对象我就可以得到它身上挂在的任何脚本信息
//通过obj.GetComponent来得到脚本信息
GameObject obj = GameObject.CreatePrimitive(PrimitiveType.Sphere);
obj.name = "球体";
obj.tag = "Player";

//1 查找单个对象
//通过对象名查找，效率低，需要遍历所有对象
GameObject obj2 = GameObject.Find("球体");
if (obj2 != null)
{
    print(obj2);
}

//通过tag查找象，需要遍历所有对象
GameObject obj3 = GameObject.FindWithTag("Player");
if (obj3 != null)
{
    print(obj3);
}

//找到场景中挂载的某一个脚本对象 ，效率太低，需要遍历所有对象，还要便利对象上挂载的脚本 
TestScript ts = GameObject.FindObjectOfType<TestScript>();

//2.查找多个对象（只能通过tag）
GameObject[] objs = GameObject.FindGameObjectsWithTag("Player");

//准备克隆的GameObject
public GameObject obj;
void Start()
{
    //准备用来克隆的对象
    //1.直接是场景上的某个对象
    //2.可以是一个预设体对象
    GameObject objClone = GameObject.Instantiate(obj);
}

//删除GameObject对象 
GameObject.Destroy(obj, 5);  //第二个参数可选，表示延迟几秒删除

//删除脚本对象
GameObject.Destroy(this);

//立即移除
//如果没有特殊需求，不用该方法，因为该方法不是异步的，可能会卡顿
GameObject.DestroyImmediate(obj);

//过场景不移除
//默认情况在切换场景时场景中对象都会被自动删除掉
//如果你希望某个对象过场景不被移除就使用该方法
//一般都是传依附的Gameobject对象
//比如下面这句代码的意思就是自己依附的Gameobject对象过场景不被删除
GameObject.DontDestroyOnLoad(this.gameObject);

//创建空GameObject
GameObject obj1 = new GameObject(); //默认名字New Game Object
GameObject obj2 = new GameObject("物体"); //自定义名字
GameObject obj3 = new GameObject("物体", typeof(TestScript)); //自定义名字，添加脚本，可以添加多个

//为对象添加脚本
//继承MonoBehaviour的脚本是无法new的
//如果给GameObject对象动态添加继承MonoBehaviour的脚本，需要使用AddComponent方法
TestScript ts1 = obj1.AddComponent(typeof(TestScript)) as TestScript;
//⭐用泛型更方便，推荐！
TestScript script = obj1.AddComponent<TestScript>();
//通过返回值，可以得到脚本的信息，来进行一些处理

//获取脚本
TestScript ts2 = obj1.GetComponent<TestScript>();

 //标签比较
if (this.gameObject.CompareTag("Player"))
{
    
}
//显式字符串比较效率低下，建议改用‘CompareTag'
if (this.gameObject.tag == "Player")
{
}

//设置激活失活
obj1.SetActive(false);

void Start()
{
    //通知自己执行什么行为
    //命令自己去执行这个Test这个函数 会在自己身上挂载的所有脚本去找这个名字的函数
    //它会去找到自己身上所有的脚本有这个名字的函数去执行
    this.gameObject.SendMessage("TestFunc");
    this.gameObject.SendMessage("TestFunc1",10); //第二个参数可以传参
    
    //广播，让自己和自己的子对象执行函数
    this.gameObject.BroadcastMessage("TestFunc");
    
    //向父对象和自己发送消息并执行
    this.gameObject.SendMessageUpwards("TestFunc");
}

void TestFunc()
{
    print("Hello World!");
}

void TestFunc1(int i)
{
    print("Hello World!"+i);
}

void Update()
{
    //时间缩放比例 
    Time.timeScale = 0; //时间停止
    Time.timeScale = 1; //时间正常
    Time.timeScale = 2; //2倍速 
    
    //帧间隔时间（最近的两帧之间的时间间隔）主要用于计算位移
    //路程=速度*时间
    //受Scale影响的帧间隔时间
    print(Time.deltaTime);   //如果希望游戏暂停时就不动的，就是用deltaTime
    //不受Scale影响的帧间隔时间
    print(Time.unscaledDeltaTime); //如果希望游戏暂停时还能动的，就是用unscaledDeltaTime
    
    //游戏开始到现在的时间
    //受Scale影响
    print(Time.time);
    //不受Scale影响
    print(Time.unscaledTime);
    
    //游戏开始到现在跑了多少帧
    print(Time.frameCount);
}

private void FixedUpdate()
{
    //物理帧间隔时间
    //受Scale影响
    print(Time.fixedTime);
    
    //不受Scale影响
    print(Time.fixedUnscaledTime);
}

 //世界空间位置
print(this.transform.position);

//局部空间位置
print(this.transform.localPosition);

//position的赋值不能单独改变x,y,z，只能整体改变
//this.transform.position.x = 1; error！
this.transform.position = new Vector3(1, 1, 1);
this.transform.position = new Vector3(this.transform.position.x+100, this.transform.position.y, this.transform.position.z);

print(this.transform.forward); //局部空间的z轴方向，注意和Vector3.forward区分
print(this.transform.right);   //局部空间的x轴方向
print(this.transform.up);      //局部空间的y轴方向

//理解坐标系下的位移计算公式
//路程–方向*速度*时间
//方式一：自己计算
//想要变化的就是 position
this.transform.position += this.transform.forward * (1 * Time.deltaTime);  //朝对象局部空间的z轴前进
this.transform.position += Vector3.forward * (1 * Time.deltaTime);  //朝世界空间Z轴前进

//方式二：API,一般使用前两种
//参数一:表示位移多少路程=方向*速度*时间
//参数二:表示相对哪个坐标系移动 ,默认该参数是自身局部空间Space.Self
this.transform.Translate(Vector3.forward*(1 * Time.deltaTime),Space.Self);  //始终朝向局部空间Z轴移动
this.transform.Translate(this.transform.forward*(1 * Time.deltaTime), Space.World); //始终朝向局部空间Z轴移动
this.transform.Translate(Vector3.forward*(1 * Time.deltaTime), Space.World); //始终朝向世界空间Z轴移动
this.transform.Translate(this.transform.forward(1 * Time.deltaTime), Space.Self);  //方向错误，因为this.transform.forward的值是世界空间下的，并不是(0,0,1)

//和角度设置一样，不能单独设置x,y,z

//inspector界面上显示的Rotation是欧拉角
print(this.transform.eulerAngles); //该方法返回欧拉角,
print(this.transform.localEulerAngles);

print(this.transform.rotation);  //该方法返回四元数
print(this.transform.localRotation); 

 void Update()
{
    //绕轴自转
    //方法一：
    //参数一：每帧旋转的角度
    //参数二：默认Space.Self
    this.transform.Rotate(new Vector3(0,10,0) * Time.deltaTime,Space.World);
    
    //方法二：
    //参数一：绕哪个轴旋转
    //参数二：是每帧转动的角度
    //参数三：默认Space.Self
    this.transform.Rotate(Vector3.up, 10 * Time.deltaTime, Space.World);
    this.transform.Rotate(Vector3.up, 10 * Time.deltaTime, Space.Self); 

    //绕点转
    //点，轴，旋转速度
    this.transform.RotateAround(Vector3.zero, Vector3.up, 10 * Time.deltaTime);
}

//相对世界坐标系的缩放大小只能得，不能改
print(this.transform.lossyScale); 

//相对局部坐标系(父对象)
this.transform.localScale  = new Vector3(1.0f, 1.0f, 1.0f);
//和角度设置一样，不能单独设置x,y,z

//Unity没有提供关于缩放的API，只能自己修改localScale

this.transform.LookAt(Vector3.zero); //看向点
this.transform.LookAt(obj); //看向一个对象，参数为对象的Transform

//获取父对象
print(this.transform.parent.name);

//断绝父子关系
this.transform.parent = null;

//设置父对象
this.transform.parent = GameObject.Find("FatherObject").transform;

//通过API设置，差别主要是多了一个参数二
//参数一:我的父亲
//参数二:是否保留世界坐标的位置角度缩放信息
//true会保留世界，坐标下的状态和父对象进行计算得到本地坐标系的信息
//false不会保留，会直接把世界坐标系下的位置角度缩放直接赋值到本地坐标系下,通常会改变原位置
this.transform.SetParent(null); //断绝父子关系
this.transform.SetParent(GameObject.Find("FatherObject").transform,false); //设置父对象
this.transform.DetachChildren(); //和自己的所有儿子断绝关系，不会影响儿子和孙子的关系

//按名字查找儿子
//只能找儿子，不能找孙子
//Find方法效率比GameObject.Find()高，前提要知道父亲是谁
//Find方法是能够找到失活的对象的! Gameobject相关的查找是不能找到失活对象的
print(this.transform.Find("Son").name);

print(this.transform.Find("Son/grandson").name);  //找到子对象的子对象

//遍历儿子
for (int i = 0; i < this.transform.childCount; i++) 
{
    //通过索引号找到特定的儿子
    print(this.transform.GetChild(i).name);
}

//判断是不是我的儿子
if (son.IsChildOf(this.transform))
{
}

//得到自己作为儿子的编号  sibling:兄弟姐妹
print(son.GetSiblingIndex());

//把自己设置为第一个儿子
son.SetAsFirstSibling();

//把自己设置为最后一个儿子
son.SetAsLastSibling();

//把自己设置为指定索引号的儿子，编号超出范围不会报错，自动设置会最后一个编号
son.SetSiblingIndex(5);

//鼠标在屏幕上的位置
//屏幕坐标的原点是在屏幕的左下角，往右是x轴正方向，往上是Y轴正方向
//返回值是Vector3，但是只有x和y有值，z一直是0是，因为屏幕本来就是2D的不存在z轴
Input.mousePosition

//检测鼠标输入
//0左键 1右键 2中键

//按下Down
Input.GetMouseButtonDown(0)

//抬起Up
Input.GetMouseButtonUp(0)

//按住
Input.GetMouseButton(0)

//中键滚动
//它的返回值是（0，Y），返回值的Y -1往下滚  0没有滚  1往上滚
Input.mouseScrollDelta

//键盘按下
//方法一(推荐)
Input.GetKeyDown(KeyCode.W) //本质上是按W时返回true


//方法二：传入字符串的重载
//只能传入小写字符串
Input.GetKeyDown("w")


//键盘抬起
Input.GetKeyUp(KeyCode.W)
    
//键盘按住
Input.GetKey(KeyCode.W)

//任意键 按下
Input.anyKeyDown

//任意键 抬起
Input.anyKeyUp

//任意键 按下
Input.anyKey

//鼠标AD按下时，返回-1到1之间的浮点值
//相当于得到这个值，就是我们的左右方向，用于控制左右移、旋转
Input.GetAxis("Horizontal")

//鼠标WS按下时，返回-1到1之间的浮点值
//相当于得到这个值，就是我们的上下方向，用于控制上下移、旋转
Input.GetAxis("Vertical")

//鼠标横向移动时，返回-1到1之间的浮点值
Input.GetAxis("Mouse X")

//鼠标纵向移动时，返回-1到1之间的浮点值
Input.GetAxis("Mouse Y")


//GetAxisRaw方法和GetAxis使用方式相同
//只不过它的返回值只会是-1,0,1不会有中间值

//移动设备触摸相关
if (Input.touchCount > 0)
{
    Touch t1 = Input.touches[0];
    
    //位置
    print(t1.position);
    
    //相对上次位置的变化
    print(t1.deltaPosition);
}
//是否启用多点触控
Input.multiTouchEnabled = false;

//陀螺仪
//是否启用陀螺仪
Input.gyro.enabled = true;

//陀螺仪的旋转速度 
print(Input.gyro.rotationRate);

//陀螺仪的重力加速度向量
print(Input.gyro.gravity);

//陀螺仪 当前的旋转四元数
//比如用这个角度信息来控制场景上的一个3D物体受到重力影响
//手机怎么动它怎么动
print(Input.gyro.attitude);

//得到连接的手柄的所有按钮名字
string[] strs = Input.GetJoystickNames();
        
//某一个手柄键按下
Input. GetButtonDown("Jump")
  
//某一个手柄键抬起
Input.GetButtonup("Jump"))

//某一个手柄键长按
Input.GetButton("Jump"))

//当前设备屏幕分辨率
Resolution r = Screen.currentResolution;
print(r.width);
print(r.height);

//Game窗口宽高
print(Screen.width);
print(Screen.height);

//屏幕睡眠模式
Screen.sleepTimeout = SleepTimeout.NeverSleep;
Screen.sleepTimeout = SleepTimeout.SystemSetting;

//运行时是否全屏模式
Screen.fullScreen = true;

//窗口模式
//独占全屏FullscreenMode.ExclusiveFullscreen
//全屏窗口FullscreenMode.Fullscreenwindow
//最大化窗口FullscreenMode. Maximizedwindow
//窗口模式FullscreenMode.windowed
Screen.fullScreenMode = FullScreenMode.Windowed;

//移动设备屏幕转向相关
//允许自动旋转为左横向 Home键在左
Screen.autorotateToLandscapeLeft = true;
//允许自动旋转为右横向 Home键在右
Screen.autorotateToLandscapeRight = true;
//允许自动旋转到纵向 Home键在下
Screen.autorotateToPortrait = true;
//允许自动旋转到纵向倒着看 Home键在上
Screen.autorotateToPortraitUpsideDown = true;

//指定屏幕显示方向
Screen.orientation = ScreenOrientation.LandscapeLeft;

//设置分辨率
Screen.SetResolution(1920, 1080, true); //第三个参数是是否全屏

//场景切换，指定的场景必须先在构建设置中加入
SceneManager.LoadScene("GameScene");
//旧版本代码
//Application.LoadIevel("GameScene");


//过场景不移除
//默认情况在切换场景时场景中对象都会被自动删除掉
//如果你希望某个对象过场景不被移除就使用该方法
//一般都是传依附的Gameobject对象
//比如下面这句代码的意思就是自己依附的Gameobject对象过场景不被删除
GameObject.DontDestroyOnLoad(this.gameObject);

//退出游戏
if( Input.GetKeyDown( Keycode.Escape) )
{
    //游戏打包后才起作用
    Application.Quit();
}

//当前场景判断
if (SceneManager.GetActiveScene().name == "StartMenu")  
{  
    //让开始面板显示  
    BeginPanel.Instance.ShowMe();  
}

while(!ao.isDone)
{
    print(ao.progress);
    yield return null;
}
//离开循环后就会认为场景加载结束
//可以把进度条顶满然后隐藏进度条

yield return ao;
//场景加载结束更新 20%进度
//接着去加载场景中的其它信息
//比如
//动态加载怪物
//这时进度条再更新 20%
//动态加载场景模型
//这时就认为加载结束了进度条顶满
//隐藏进度条

//显示/隐藏鼠标
Cursor.visible = true;

//锁定鼠标，按ESC键解锁
// None 不锁定
// Locked 锁定鼠标会被限制在屏幕的中心点，并且会隐藏鼠标
// Confined 限制在窗口范围内
Cursor.lockState = CursorLockMode.Confined;

//参数一:光标图片
//参数二:偏移位置相对图片左上角
//参数三:平台支持的光标模式(硬件或软件)
Cursor.SetCursor(texture, new Vector2(0, 0), CursorMode.Auto);

//动态添加一个线段
GameObject line = new GameObject();
line.name = "Line";
LineRenderer lineRenderer = line.AddComponent<LineRenderer>();

//首尾相连
lineRenderer.loop = true;

//开始结束宽度
lineRenderer.startWidth = 1.0f;
lineRenderer.endWidth = 0.1f;

//开始结束颜色
lineRenderer.startColor = Color.white;
lineRenderer.endColor = Color.red;

//设置材质
lineRenderer.material = material;

//设置点，注意要先设置点的个数
lineRenderer.positionCount = 4;
lineRenderer.SetPosition(0, new Vector3(0, 0, 0));
lineRenderer.SetPosition(1, new Vector3(0, 10, 0));
lineRenderer.SetPosition(2, new Vector3(10, 10, 0));
lineRenderer.SetPosition(3, new Vector3(10, 0, 0));

//是否使用世界坐标
lineRenderer.useWorldSpace = false;

AudioSource audioSource;
void Start()
{
    audioSource = this.GetComponent<AudioSource>();
}

void Update()
{
    //控制播放停止
    if (Input.GetKeyDown(KeyCode.P))
    {
        //播放
        audioSource.Play();
        //audioSource.PlayDelayed(5); //延迟几秒后播放

    }
    if(Input.GetKeyDown(KeyCode.S))
    {
        //停止
        audioSource.Stop();
    }

    if (Input.GetKeyDown(KeyCode.Space))
    {
        //暂停
        audioSource.Pause();
        //audioSource.UnPause(); //关闭暂停，实际上再执行一次Pause方法也会关闭暂停
    }

    //检测音效播放完毕
    if(audioSource.isPlaying)
    {
        print("正在播放");
    }
    else
    {
        print("播放结束");
    }
}

// 获取设备麦克风信息
string[] strs = Microphone.devices;
for (int i = 0; i < strs.Length; i++) 
{
    print(strs[i]);
}

//开始录音
//参数一:设备名，传null使用默认设备
//参数二:超过录制长度后是否重头录制
//参数三:录制时长
//参数四:采样率
audioClip = Microphone.Start(null, false, 10, 44100);

//结束录音
Microphone.End(null);

//播放录制音频
AudioSource s = this.GetComponent<AudioSource>();
if (s == null)
{
    s = this.gameObject.AddComponent<AudioSource>();
}
s.clip = audioClip;
s.Play();

//获取音频数据用于存储或者传输  
//用于存储数组数据的长度=声道数*剪辑长度  
float[] f = new float[audioClip.channels * audioClip.samples];  
audioClip.GetData(f, 0);  

//Collision类型的参数包含了碰到自己的对象的相关信息

//碰撞到的对象的碰撞器信息
collision.collider;

//碰撞对象的依附对象（GameObject）
collision.gameObject;

//碰撞对象的依附对象的位置信息
collision.transform;

//接触点点数量
collision.contactCount;

//接触点 坐标
ContactPoint[] pos = collision.contacts;

//只要得到碰撞道德对象的任意一个信息，就可以得到所有信息
collision.gameObject.GetComponent<>();

//碰撞触发接触时会自动执行这个函数
private void OnCollisionEnter(Collision collision)
{
    print(this.name + "碰撞到了" + collision.gameObject.name);
}

//两个物体相互接触摩擦时会不停的调用该函数
 private void OnCollisionStay(Collision collision)
{
    print(this.name+"正在摩擦"+collision.gameObject.name);
}

 //碰撞结束分离时会自动执行的函数
private void OnCollisionExit(Collision collision)
{
    print("碰撞结束");
}

//第一次接触时
private void OnTriggerEnter(Collider other)
{
}

//接触过程中
private void OnTriggerStay(Collider other)
{
}

//接触结束
private void OnTriggerExit(Collider other)
{
}

//1.首先应该获取刚体组件
rigidBody = this.GetComponent<Rigidbody>();

//2.添加力
//加力过后对象是否停止移动是由阻力决定的，没有阻力就不会停
//相对世界坐标
rigidBody.AddForce(Vector3.forward * 10,ForceMode.Acceleration); //力的模式
//相对本地坐标
rigidBody.AddRelativeForce(Vector3.forward * 10);


//3.添加扭矩力，让其旋转
//相对世界坐标
rigidBody.AddTorque(Vector3.up * 10);
//相对本地坐标
rigidBody.AddRelativeTorque(Vector3.up * 10);

//4.直接改变速度
//这个速度方向是相对于世界坐标系的
rigidBody.velocity = Vector3.forward * 5;

//5.模拟爆炸冲击波，只对该脚本挂载的对象起作用
//第一个参数是爆炸的中心点
//第二个参数是爆炸的半径
//第三个参数是爆炸的力
//第四个参数是爆炸的作用范围
rigidBody.AddExplosionForce(100,Vector3.zero,10,10);

rigidBody.AddForce(Vector3.forward * 10,ForceMode.Acceleration); 

if(rigidBody.IsSleeping())
{
    rigidBody.WakeUp();
}

Collider[] colliders = Physics.OverlapBox(
    Vector3.zero,
    Vector3.one, 
    Quaternion.AngleAxis(45,Vector3.up), 
    1<<LayerMask.NameToLayer("UI") | 1<<LayerMask.NameToLayer("Water"),
    //第四个参数用 | 继续添加就可以了
     QueryTriggerInteraction.UseGlobal);
        
for(int i=0;i<colliders.Length;i++)
{
    Debug.Log(colliders[i].gameObject.name); //打印触发器挂载的对象信息
}

Collider[] colliders = new Collider[10]; //数组数量必须等于检测到的碰撞体数量  

//碰撞到的碰撞器数量
int num = Physics.OverlapBoxNonAlloc(
    Vector3.zero,
    Vector3.one,
    colliders,
    Quaternion.AngleAxis(45,Vector3.up), 
    1<<LayerMask.NameToLayer("UI") | 1<<LayerMask.NameToLayer("Water"),
     QueryTriggerInteraction.UseGlobal);

//如果碰撞到的碰撞器数量不为0，则执行代码
if(num != 0)  
{  
    for(int i = 0;i < num;i++)  
    {  
        Debug.Log(colliders[i].gameObject.name);  
    }  
}

Collider[] colliders = Physics.OverlapSphere(
            Vector3.zero,
            5,
            1 << LayerMask.NameToLayer("UI"), 
            QueryTriggerInteraction.UseGlobal);
        
for(int i=0;i<colliders.Length;i++)
{
    Debug.Log(colliders[i].gameObject.name); //打印触发器挂载的对象信息
}

Collider[] colliders = new Collider[10]; //数组数量必须等于检测到的碰撞体数量  
  
//碰撞到的碰撞器数量  
int num = Physics.OverlapSphereNonAlloc(  
    Vector3.zero,  
    5,  
    colliders,  
    1<<LayerMask.NameToLayer("UI"),  
    QueryTriggerInteraction.UseGlobal);  
  
//如果碰撞到的碰撞器数量不为0，则执行代码  
if(num != 0)  
{  
    for(int i = 0;i < num;i++)  
        {  
            Debug.Log(colliders[i].gameObject.name);  
        }  
}

Collider[] colliders = new Collider[10]; //数组数量必须等于检测到的碰撞体数量  
        
//碰撞到的碰撞器数量
int num = Physics.OverlapCapsuleNonAlloc(
    Vector3.zero,
    Vector3.up,
    3,
    colliders,
    1 << LayerMask.NameToLayer("UI"),
    QueryTriggerInteraction.UseGlobal);

//如果碰撞到的碰撞器数量不为0，则执行代码
if(num != 0)  
{  
    for(int i = 0;i < num;i++)  
    {  
        Debug.Log(colliders[i].gameObject.name);  
    }  
}

//声明射线
//起点为坐标 (1,0,0)
//方向为世界坐标 z 轴正方向的射线 
Ray ray = new Ray(Vector3.right, Vector3.forward);
print(ray.origin); //起点
print(ray.direction); //方向