Debug.Log(gameObject.activeSelf);

Debug.Log(gameObject.isStatic);

Debug.Log(gameObject.layer);

Debug.Log(gameObject.tag);

//获取AudioSource
audioSource = GetComponent<AudioSource>();

audioSource.Play();//播放
audioSource.PlayDelayed(5);//5秒后播放 单位秒
audioSource.Stop();//停止
audioSource.Pause();//暂停
//停止暂停 和暂停后play是一个效果
audioSource.UnPause();

if(audioSource.isPlaying){
    Print("播放中");
}
else{
     Print("播放结束");
}

public AudioClip clip;
audioSource.clip = clip;
audioSource.Play();

String[] strs = Microphone.devices;

//参数1：设备名 如果使用默认设备传null
//参数2：超过录制长度后是否重新入职 一般faslse
//参数3：录制长度 单位秒
//参数4：采样率
//返回一个AudioClip
AudioClip clip = Microphone.Start(null,false,10,44100);

//参数：设备名
Microphone.End(null);

//规则 用于存储数组数据的长度 是用 声道数*剪辑长度
float[] f = new float[clip.channels * clip.samples];
clip.GetData(f,0);

//T只能作为返回值
delegate T TestOut<out T>();
delegate T TestOut<out T>(T value);//报错

//在泛型接口中使用
interfacet Test<out T>{
    T TestFun1();
    void TestFun2(T value);//报错
}

//T只能作为参数
delegate void TestIn<in T>(T value);
delegate T TestOIn<in T>(T value);//报错
//在泛型接口中使用
interfacet Test<in T>{
    void TestFun2(T value);
    T TestFun1();//报错
}

class Fater{}
class Son:Fater{}

delegate T TestOut<out T>();
delegate T TestNoOut<T>();

TestNoOut<Son> tnos = ()=>{return new Son();}
TestNoOut<Fater> tnof = tnos;//报错

//out修饰 会去判断父子关系
TestOut<Son> tos = ()=>{return new Son();}
TestOut<Fater> tof = tos;
//返回值为父类的方法 将子类作为返回值返回
//父类装子类 协变
Fater f = tof();

//返回值为子类的方法 不可以将父类作为返回值返回
tos = tof；//报错

class Fater{}
class Son:Fater{}

delegate void TestIn<in T>(T value);
delegate void TestNoIn<T>(T value);

TestNoIn<Fater> tnif = (value)=>{};
TestNoIn<Son> tnis = tnif;//报错

//in修饰 会去判断父子关系
TestIn<Fater> tif = (value)=>{};
TestIn<Son> tis = tif;
//将子类的对象  传入了参数为父类的方法里
//子类转父类 逆变
tis(new sun());

//父类对象 不可以传入 子类作为参数的方法里
tif = tis;//报错

public void Test(){
    Debug.log(transform.position);//报错不可以使用
}
Thread t = new Thread(Test);
t.Start();

IEnumerator MyCoroutine(int i,string str){
	print(i);
	yield return new WaitForSeconds(5f);//五秒钟后 执行
    print(str);
}

StartCoroutine(MyCoroutine(123,"123"));

//关闭所有携程
StopAllCoroutines();
//关闭指定携程
Coroutine c1 = StartCoroutine(MyCoroutine(123,"123"));
StopAllCoroutines(c1);
//也可以传入字符串  不推荐
StopAllCoroutines("MyCoroutine");

yield return null; // 下一帧再执行后续代码
yield return 6;//(任意数字) 下一帧再执行后续代码
yield break; //直接结束该协程的后续操作
yield return asyncOperation;//等异步操作结束后再执行后续代码
yield return StartCoroution(/*某个协程*/);//等待某个协程执行完毕后再执行后续代码
yield return WWW();//等待WWW操作完成后再执行后续代码
yield return new WaitForEndOfFrame();//等待帧结束,等待直到所有的摄像机和GUI被渲染完成后，在该帧显示在屏幕之前执行
yield return new WaitForSeconds(0.3f);//等待0.3秒，一段指定的时间延迟之后继续执行，在所有的Update函数完成调用的那一帧之后（这里的时间会受到Time.timeScale的影响）;
yield return new WaitForSecondsRealtime(0.3f);//等待0.3秒，一段指定的时间延迟之后继续执行，在所有的Update函数完成调用的那一帧之后（这里的时间不受到Time.timeScale的影响）;
yield return WaitForFixedUpdate();//等待下一次FixedUpdate开始时再执行后续代码
yield return new WaitUntil()//将协同执行直到 当输入的参数（或者委托）为true的时候....如:yield return new WaitUntil(() => frame >= 10);
yield return new WaitWhile()//将协同执行直到 当输入的参数（或者委托）为false的时候.... 如:yield return new WaitWhile(() => frame < 10);

//1.协程函数本体
//如果我们不通过 开启协程方法执行协程 
//Unity的协程调度器是不会帮助我们管理协程函数的
IEnumerator ie = Test();
//但是我们可以自己执行迭代器函数内容
ie.MoveNext();//会执行函数中内容遇到 yield return为止的逻辑
print(ie.Current);//得到 yield return 返回的内容

Vector3 A = new Vector3(1, 2, 3);
Vector3 B = new Vector3(5, 1, 5);
//B相对于A的向量
Vector3 AB = B - A;
//A相对于B的向量
Vector3 BA = A - B;

Vector3 C = new Vector3(5, 6, 7);
//原点到C的长度
print(C.magnitude);
//等于Vector3.Distance(Vector.zero,c);

//Vector3中提供了获取单位向量的成员属性
AB.normalized
//等同于AB / AB.magnitude

float dotResult = Vector3.Dot(B.transform.position, target.position - this.transform.position);

Invoke("函数名",5);//单位秒 不能传入参数

InvokeRepeating("函数名",5,2);//第一次延迟5秒执行 然后每隔2秒执行一次

CancelInvoke();//取消所有的
CancelInvoke("函数名");//取消指定的延时函数方法

IsInvoking();//只要有就返回true
IsInvoking("函数名");//是否有指定的延时函数

//得到主摄像机 摄像机的tag一定要是maincamera
Camera c = Camera.main;
//获取摄像机的数量
Camera.allCamerasCount;
//得到所有的摄像机
Camera[] allCamrea = Camera.allCameras;

//摄像机剔除前处理的委托函数
//有一个参数camrea
Camera.onPreCull += (c)=>{

};
//摄像机 渲染前处理的委托
Camera.onPreRender +=(c)=>{
        
};
//摄像机 渲染后 处理的委托
Camera.onPostRender +=(c)=>{
        
};

transform.position = transform.position + transform.forward(本地坐标向前 对应世界坐标的向量) * 1 * Time.deltaTime;
//transform.forward(本地坐标向前 对应世界坐标的向量)

//参数一：位移多少 方向*速度*时间
//参数二：表示相对坐标系 默认参数是 物体自己的坐标系Space.Self 可选世界坐标Space.World
transform.Translate(Vector3.forward*1*Time.deltaTime);
//也可以使用世界坐标系 使用transform.forward作为向量
transform.Translate(transform.forward*1*Time.deltaTime,Space.World);

//世界坐标角度
transform.eulerAngles = new Vector3(0,1,0);
//相对父对象角度
transform.localEulerAngles = new Vector3(0,1,0);

//对位计算    &有0则0  |有1则1   异或^相同为0 不同为1
int a = 1; //001
int b = 5; //101
int c = a & b;//结果：001   1

//补0
a = 3; //  011
b = 19;//10011
c = a & b;//结果00011  3

int a = 5;//0101
int b = ~a; //b=-6
//完整的int 2进制 第一位是符号位
//0000 0000 0000 0000 0000 0000 0000 0101
//取反后
//1111 1111 1111 1111 1111 1111 1111 1010

//声明一个 可以用来存储无参无返回值函数的容器
public delegate void MyFun();
//使用委托
MyFun f1 = new MyFun();
//另一种写法
//My Fun f1 = ()=>{Console.WirteLin("我没有参数和返回值")};  
f1 += ()=>{Console.WirteLin("我没有参数和返回值")};

//委托的调用
f1();//方法1
f1.Invoke();//方法2

//声明一个 可以用来存储无参无返回值函数的容器
public delegate int MyFun(int value);
//使用委托
MyFun f2 = new MyFun((value)=>{return value+1});
int a = f2(3);
Console.WriteLine(a);//4

//基本语法
//~类名(){}
~Person(){
    
}

//object是引用类型
object a = 3;//装箱
int b = (int)a;//拆箱

Object.Equals(1,1);

Test t = new Test();
//因为所有的类型都继承自object 所以可以使用GetType();
Type type = t.GetType();

Mathf.PI

Mathf.Abs(-5);

Mathf.CeilToInt(1.3f);//2

Mathf.FloorToInt(1.8f);//1

Mathf.Clamp(value,min,max);
//比最小值小 返回最小值 比最大值大 返回最大值 

Mathf.Max(1,2,3); //3

Mathf.Min(1,2,3);//1

Mathf.Pow(3,2);//9

Mathf.RoundToInt(1.4f);//1
Mathf.RoundToInt(1.5f);//2

Mathf.Sqrt(4);//2

Mathf.IsPowerOfTwo(256);//true

Mathf.Sign(-1);//正数返回1 负数返回-1

//Unity默认使用弧度作为单位
//弧度转角度
float rad = 1;
float anger = rad * Mathf.Rad2Deg;
//角度转弧度
anger = 1;
rad = anger * Mathf.Deg2Rad;

//本质是一个类 类名中的Attribute会被省略
class MyCustomAttribute : Attribute{
	//特性中的成员 一般根据需求来写
    public string info;
    public MyCustomAttribute(string info){
        this.info = info;
    }
}

[MyCustom("这是我自己写的特性")]
class MyClass{
    
    [MyCustom("特性可以写在成员变量前面")]
    public int value;
    
	[MyCustom("特性可以写在函数前面")]
	public void TestFun([MyCustom("特性可以写在参数前面")] int a){
		
	}
}
MyClass mc = new MyClass();
Type type = mc.GetType();
//判断是否使用了某个特性
//参数一：特性的类型
//参数二：是否搜索继承链（属性和事件忽略此参数）
if(type.IsDefined(typeof(MyCustomAttribute),false)){
    Console.WriteLine("该类型应用了MyCustom特性")
    //获取type元素中的所有特性 参数是否搜索继承链
    object[] array = type.GetCustomAttributes(true);
    foreach(var item in array){
        if(item is MyCustomAttribute){
            Console.WriteLine((item as MyCustomAttribute).info);
        }
    }
}

[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct , AllowMultiple = true , Inherited = true)]
class MyCustomAttribute : Attribute{
	//特性中的成员 一般根据需求来写
    public string info;
    public MyCustomAttribute(string info){
        this.info = info;
    }
}

class Test{
	//参数1提示 参数2 true-使用时会报错   false-警告
	[Obsolete("OldSpeak已经过时,请使用新方法",false)]
	public void OldSpeak(){
	
	}
}

#define test
class Test(){
	[Conditional("test")] //有test这个符号这个方法才会被执行
	static void Func(){
	
	}
}

class Test(){
	[DllImport("dll包路径名")] 
	static void extern int Add(int a,int b)();
    //相当于是把这个dll包里的方法 映射到了c#中来
}

class Person{
    private string name;
    private int age;
    private Person[] friends;
    private int[,] array;
    public Person this[int index] {
        get{
            return friend[index];
        }
        set{
            friends[index] = value;
        }
    }
    //索引器重载
    public int this[int i,int j]{
        get{
            return array[i,j];
        }
        set{
            array[i,j] = value;
        } 
    }
}
Person p = new Person();
p[0] = new Person();//访问set方法
Console.WriteLine(p[0].name);//访问get方法
p[0,0] = 10;

//int 重载 左包含 右不包含
int randomNum = Random.Range(0,100);
//float 重载 左包含 右包含
float singleRandomNum = Random.Range(1.1f,99,9f);

//参数 string key,int 值
PlayerPrefs.SetInt("myAge",18);//存到了内存中
PlayerPrefs.SetFloat("myHeight",188.5f);
PlayerPrefs.SetString("myName","路飞");

PlayerPrefs.Save();

bool sex = true;
PlayerPrefs.SetInt("mySex",sex?1:0);
//键名一样 会被覆盖
PlayerPrefs.SetFloat("mySex",2);//

//如果 没有这个值 返回默认值 当int被float覆盖键相同也找不到
int age = PlayerPrefs.GetInt("myAge");
//指定默认值
int age = PlayerPrefs.GetInt("myAge",100);

PlayerPrefs.HasKey("key");

PlayerPrefs.DeleteKey("key");
//删除所有数据
PlayerPrefs.DeleteAll("key");

<?xml version="1.0" encoding="UTF-8"?>
<Test>测试</Test>

<Item>
    <id>1</id>
    <num>2</num>
</Item>
<!-- 属性的写法-->
<Item id="1" num="10"/>

XmlDocument xml = new XmlDocument();
TextAsset asset = Resources.Load<TextAsset>("TestXml");
xml.LoadXml(text.text);
//通过路径来加载xml 不可以加载resources文件夹下面的
xml.load(Application.persistenDataPath+"TestXml.xml");

//通过XmlDocument对象 得到XmlNode 传入根节点
XmlNode root = xml.SelectSingleNode("Root");
//在通过根节点的对象 找到下面的子节点
XmlNode name = root.SelectSingleNode("name");
//获取内容
print(name.InnerText);
//获取属性
XmlNode item = root.SelectSingleNode("item");
print(item.Attributes["id"].Value);
//第二种方式
print(item.Attributes.GetNamedItem("id").Value);
//找到所有的xmlnode
XmlNodeList nodelist = xml.SelectNodes("Root");

//创建文本对象
XmlDocument xml = new XmlDocument();
//创建xml 版本信息
XmlDeclaration xmlDec = xml.CreateXmlDeclaration("1.0","UTF-8","");
//将版本信息添加到xml中
xml.AppendChild(xmlDec);
//添加根节点
XmlElment root = xml.CreateElement("Root");
xml.AppendChild(root);
//为根节点添加子节点  <name>路飞</name>
XmlElement name = xml.CreateElement("name");
name.InnerTest = "路飞";
//将name添加到root节点中
root.AppendChild(name);

xml.Save("路径");

//判断文件是否存在
if(File.Exists(path)){
	//创建xml文本对象
	XmlDocument xml = new XmlDocument();
    xml.load(path);  
    //修改 就是在原有文件的基础上 删除 或者添加
    XmlNode root = xml.SelectSingleNode("Root");
    XmlNode node = root.SelectSingleNode("name");
    XmlNode node2 = xml.SelectSingleNode("Root/name");//第二种写法 
    //移除节点
    root.RemoveChild(node);
    XmlElement name = xml.CreateElement("name");
	name.InnerTest = "王路飞";
    root.AppendChild(name);
   //保存
    xml.Save(path);
}

using(){

}

//首先确认存储的路径
string path = Application.persistentDataPath+"/Test.xml";
//创建文件写入流
StreamWriter stream = new StreamWriter(path)

XmlSerializer xs = new XmlSerializer(type);
//序列化
s.Serialize(文件流对象,对象);

Cusor.visible= false;

//CursorLockMode枚举
//none不锁定 Locked将锁定在屏幕中心点（并隐藏鼠标） Confined限制在窗口范围内
Cursor.lockState = CursorLockMode.Locked;

Cursor.SetCursor(texture,vector2.zero,CursorMode.Auto);