Unity入门3——脚本基础

一、生命周期函数

​ 所有继承 MonoBehavior 的脚本，最终都会挂载到 GameObject 游戏对象上
​ 生命周期函数就是该脚本对象依附的 GameObject 对象从出生到消亡整个生命周期中
​ 会通过反射自动调用的一些特殊函数

​ Unity 帮助我们记录了一个 GameObject 对象依附了哪些脚本
​ 会自动得到这些对象，通过反射去执行一些固定名字的函数

​ 生命周期函数的访问修饰符一般为 private 和 protected
​ 因为不需要再外部自己调用生命周期函数 都是 Unity 自己帮助我们调用的

// 当对象（自己这个类对象）被创建时 才会调用该生命周期函数                                             
// 类似构造函数的存在 我们可以在一个类对象 该创建 进行一些初始化操作                                       
protected virtual void Awake()                                             
{                                                                          
    // 在Unity中打印信息的两种方式                                                     
    // 1. 没有继承MOnoBehavior类的时候                                              
    // Debug.Log("123");                                                    
    // Debug.LogError("出错了！！！！！");                                          
    // Debug.LogWarning("警告！！！");                                           
    // 2. 继承了MonoBehavior 有一个线程的方法 可以使用                                     
    print("Awake");                                                        
}                                                                          
                                                                           
// 对于我们来说 想要当一个对象被激活时 进行一些逻辑处理 就可以写在这个函数                                    
void OnEnable()                                                            
{                                                                          
    print("OnEnable");                                                     
}                                                                          
                                                                           
// 主要作用还是用于初始化信息的 但是它相对Awake来说 要晚一点                                         
// 因为它是在对象 进行第一次帧更新之前才会执行的                                                  
void Start()                                                               
{                                                                          
    print("Start");                                                        
}                                                                          
                                                                           
// 它主要是用于 进行物理更新                                                            
// 它是每一帧的执行的 但是 这里的帧 和游戏帧 有点不同                                              
// 它的时间间隔 是可以在 project setting中的 Time里去设置的                                  
void FixedUpdate()                                                         
{                                                                          
    print("FixedUpdate");                                                  
}                                                                          
                                                                           
// 主要用于处理游戏核心逻辑更新的函数                                                        
void Update()                                                              
{                                                                          
    print("Update");                                                       
}                                                                          
                                                                           
// 一般这个更新是用来处理 摄像机位置更新相关内容的                                                 
// Update和LateUpdate之间 Unity进了一些处理 处理我们动画相关的更新                              
void LateUpdate()                                                          
{                                                                          
    print("LateUpdate");                                                   
}                                                                          
                                                                           
// 如果我们希望在一个对象失活时做一些处理 就可以在该函数中写逻辑                                          
void OnDisable()                                                           
{                                                                          
    print("OnDisable");                                                    
}                                                                          
                                                                           
void OnDestroy()                                                           
{                                                                          
    print("OnDestroy");                                                    
}                                   

 

二、Inspector窗口可编辑变量

1.Inspector 显示的可编辑内容就是脚本的成员变量
2.私有和保护无法显示编辑
3.让私有的和保护的也可以被显示

                                  // 加上强制序列化字段特性                  
// [SerializeField]             
// 所谓序列化就是把一个对象保存到一个文件或数据库字段中去  
[SerializeField]               
private int privateInt;         
[SerializeField]               
protected string protectedStr;            

 

4.公共的可以显示编辑

[HideInInspector] public int publicInt = 10; public bool publicBool = false;

5.公共的也不让其显示编辑

// 在变量前加上特性 // [HideInInspector] [HideInInspector] public int publicInt2 = 50;

6.大部分类型都能显示编辑

public int[] array;      
public List list;   
public E_TestEnum type; 
public GameObject gameObject;
                        
// 字典不能被Inspector窗口显示    
public Dictionary dic;
// 自定义类型变量               
public MyStruct myStruct
public MyClass myClass; 

7.让自定义类型可以被访问

// 加上序列化特性              
// [System.Serializable]
// 字典怎样都不行    

[System.Serializable] 
public struct MyStruct
{                     
    public int age;    
    public bool sex;   
}                     
                      
[System.Serializable] 
public class MyClass  
{                     
    public int age;    
    public bool sex;   
}    

8.一些辅助特性

 // 1.分组说明特性Header                            
// 为成员分组                                     
// Header特性                                  
// [Header("分组说明")]                          
[Header("基础属性")]                            
public int age;                              
public bool sex;                             
[Header("战斗属性")]                            
public int atk;                              
public int def;                              
                                            
// 2.悬停注释Tooltip                             
// 为变量添加说明                                   
// [Tooltip("说明内容")]                         
[Tooltip("闪避")]                             
public int miss;                             
                                            
// 3.间隔特性 Space()                            
// 让两个字段间出现间隔                                
// [Space()]                                 
[Space()]                                   
public int crit;                             
                                            
// 4.修饰数值的滑条范围Range                          
// [Range(最小值, 最大值)]                         
[Range(0,10)]                               
public float luck;                           
                                            
// 5.多行显示字符串 默认不写参数显示3行                      
// 写参数就是对应行                                  
// [Multiline(4)]                            
[Multiline(5)]                              
public string tips;                          
                                            
// 6.滚动条显示字符串                                
// 默认不写参数就是超过3行显示滚动条                         
// [TextArea(3, 4)]                          
// 最少显示3行，最多4行，超过4行就显示滚动条                    
[TextArea(3,4)]                             
public string myLife;                        
                                            
// 7.为变量添加快捷方法 ContextMenuItem               
// 参数1 显示按钮名                                 
// 参数2 方法名 不能有参数                             
// [ContextMenuItem("显示按钮名", "方法名")]         
[ContextMenuItem("重置钱", "Test")]            
public int money;                            
private void Test()                         
{                                           
    money = 99;                             
}                                           
                                            
// 8.为方法添加特性能够在Inspector中执行                  
// [ContextMenu("测试函数")]                     
[ContextMenu("哈哈哈哈")]                       
private void TestFun()                      
{                                           
    print("测试方法");                          
}                                           

 

三、MonoBehavior

（一）重要成员

// 1.获取依附的GameObject                        
print(this.gameObject.name);               
// 2.获取依附的GameObject的位置信息                   
// 得到对象位置信息                                 
print(this.transform.position);     // 位置        
print(this.transform.eulerAngles);  // 角度     
print(this.transform.lossyScale);   // 缩放大小    
// 这种写法和上面是一样的效果 都是得到依附的对象的位置信息             
// this.gameObject.transform                
                                           
// 3.获取脚本是否激活                               
this.enabled = false;                      
                                           
// 获取别的脚本对象 依附的gameobject和 transform位置信息    
print(otherLesson3.gameObject.name);       
print(otherLesson3.transform.position);    

 （二）重要方法

// 得到依附对象上挂载的其它脚本                                                                   
                                                                                   
// 1.得到自己挂载的单个脚本                                                                    
// 根据脚本名获取                                                                          
// 获取脚本的方法 如果获取失败 就是没有对应的脚本 会默认返回空                                                  
Lesson3_Test t = this.GetComponent("Lesson3_Test") as Lesson3_Test;                
print(t);                                                                          
// 根据Type获取                                                                         
t = this.GetComponent(typeof(Lesson3_Test)) as Lesson3_Test;                       
print(t);                                                                          
// 根据泛型获取 建议使用泛型获取 因为不用二次转换                                                         
t = this.GetComponent();                                             
if( t != null )                                                                    
{                                                                                  
    print(t);                                                                      
}                                                                                  
                                                                                   
// 只要你能得到场景中别的对象或者对象依附的脚本                                                           
// 那你就可以获取到它的所有信息                                                                   
                                                                                   
// 2.得到自己挂载的多个脚本                                                                    
Lesson3[] array = this.GetComponents();                                   
print(array.Length);                                                               
List list = new List();                                          
this.GetComponents(list);                                                 
print(list.Count);                                                                 
                                                                                   
// 3.得到子对象挂载的脚本(它默认也会找自己身上是否挂载该脚本)                                                  
// 函数是有一个参数的 默认不传 是false 意思就是 如果子对象失活 是不会去找这个对象上是否有某个脚本的                            
// 如果传true 即使 失活 也会找                                                                
// 得子对象 挂载脚本 单个                                                                     
t = this.GetComponentInChildren(true);                               
print(t);                                                                          
// 得子对象 挂载脚本 多个                                                                     
                                                                                   
Lesson3_Test[] lts = this.GetComponentsInChildren(true);             
print(lts.Length);                                                                 
                                                                                   
List list2 = new List();                               
this.GetComponentsInChildren(true, list2);                           
print(list2.Count);                                                                
                                                                                   
// 4.得到父对象挂载的脚本(它默认也会找自己身上是否挂载该脚本)                                                  
t = this.GetComponentInParent();                                     
print(t);                                                                          
lts = this.GetComponentsInParent();                                  
print(lts.Length);                                                                 
// 它也有list的 省略不写了 和上面是一样的套路                                                         
                                                                                   
// 5.尝试获取脚本                                                                         
Lesson3_Test l3t;                                                                  
// 提供了一个更加安全的 获取单个脚本的方法 如果得到了 会返回true                                               
// 然后在来进行逻辑处理即可                                                                     
if(this.TryGetComponent(out l3t))                                    
{                                                                                  
    // 逻辑处理                                                                         
}