一、生命周期函数

​ 所有继承 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<int> list;   
public E_TestEnum type; 
public GameObject gameObject;
                        
// 字典不能被Inspector窗口显示    
public Dictionary<int, string> 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<Lesson3_Test>();                                             
if( t != null )                                                                    
{                                                                                  
    print(t);                                                                      
}                                                                                  
                                                                                   
// 只要你能得到场景中别的对象或者对象依附的脚本                                                           
// 那你就可以获取到它的所有信息                                                                   
                                                                                   
// 2.得到自己挂载的多个脚本                                                                    
Lesson3[] array = this.GetComponents<Lesson3>();                                   
print(array.Length);                                                               
List<Lesson3> list = new List<Lesson3>();                                          
this.GetComponents<Lesson3>(list);                                                 
print(list.Count);                                                                 
                                                                                   
// 3.得到子对象挂载的脚本(它默认也会找自己身上是否挂载该脚本)                                                  
// 函数是有一个参数的 默认不传 是false 意思就是 如果子对象失活 是不会去找这个对象上是否有某个脚本的                            
// 如果传true 即使 失活 也会找                                                                
// 得子对象 挂载脚本 单个                                                                     
t = this.GetComponentInChildren<Lesson3_Test>(true);                               
print(t);                                                                          
// 得子对象 挂载脚本 多个                                                                     
                                                                                   
Lesson3_Test[] lts = this.GetComponentsInChildren<Lesson3_Test>(true);             
print(lts.Length);                                                                 
                                                                                   
List<Lesson3_Test> list2 = new List<Lesson3_Test>();                               
this.GetComponentsInChildren<Lesson3_Test>(true, list2);                           
print(list2.Count);                                                                
                                                                                   
// 4.得到父对象挂载的脚本(它默认也会找自己身上是否挂载该脚本)                                                  
t = this.GetComponentInParent<Lesson3_Test>();                                     
print(t);                                                                          
lts = this.GetComponentsInParent<Lesson3_Test>();                                  
print(lts.Length);                                                                 
// 它也有list的 省略不写了 和上面是一样的套路                                                         
                                                                                   
// 5.尝试获取脚本                                                                         
Lesson3_Test l3t;                                                                  
// 提供了一个更加安全的 获取单个脚本的方法 如果得到了 会返回true                                               
// 然后在来进行逻辑处理即可                                                                     
if(this.TryGetComponent<Lesson3_Test>(out l3t))                                    
{                                                                                  
    // 逻辑处理                                                                         
}

Unity入门3——脚本基础相关推荐

  1. 【Unity入门】25.零基础实现游戏Demo--神鸟大战怪兽

    [Unity入门]零基础实现游戏Demo--神鸟大战怪兽     大家好,我是Lampard~~     欢迎来到Unity入门系列博客,所学知识来自B站阿发老师~感谢  (一) 前言     经过了 ...

  2. Unity快速入门之三 脚本与事件

    Unity快速入门之一 3D基础概念.Camera.Canvas RenderMode的几种方式对比_翕翕堂 Unity快速入门之二 GUI Transform 详解_翕翕堂 Unity快速入门之三 ...

  3. Unity快速入门之一 3D基础概念、Camera、Canvas RenderMode的几种方式对比

    最近要给公司的小伙伴做Unity入门,针对几个常用的知识进行快速入门介绍. Unity快速入门之一 3D基础概念.Camera.Canvas RenderMode的几种方式对比_翕翕堂 Unity快速 ...

  4. FLASH脚本基础入门讲解1

    1.FLASH脚本基础入门讲解.按钮AS的编写.影片剪辑的AS编写 认识"动作"面板 在Flash中,动作脚本的编写,都是在"动作"面板的编辑环境中进行,熟悉& ...

  5. Unity入门 ---- unity2D基础知识

    Unity入门 DAY 一: 向量Vector 向量夹角 物体的指向 屏幕坐标 DAY 二 鼠标事件处理 探测鼠标事件 鼠标跟随事件 鼠标拖拽 事件函数 Event Functions 脚本的执行顺序 ...

  6. Unity中的MonoBehaviour脚本-基础知识和继承关系

    本文分享Unity中的MonoBehaviour脚本-基础知识和继承关系 作为一个程序员, 在Unity中开发, 我们接触最多的对象之里一定有MonoBehaviour, 所以作为Unity基础知识学 ...

  7. 【Unity入门】8.生成第一个脚本

    [Unity入门]生成第一个脚本     大家好,我是Lampard~~     欢迎来到Unity入门系列博客,所学知识来自B站阿发老师~感谢 (一)搭建开发环境 (1)下载visual studi ...

  8. Unity学习-脚本基础part01

    文章目录 一.脚本相关概念 1-脚本的定义 2-语法结构 3-脚本编译过程 4-创建脚本文件 5-脚本在Unity中的一些操作 6-脚本生命周期(重要) 6-1.定义 6-2.初始阶段 6-3.物理阶 ...

  9. 从游戏脚本语言说起,剖析Mono所搭建的脚本基础

    0x00 前言 在日常的工作中,我偶尔能遇到这样的问题:"为何游戏脚本在现在的游戏开发中变得不可或缺?".那么这周我就写篇文章从游戏脚本聊起,分析一下游戏脚本因何出现,而mono又 ...

最新文章

  1. SAP MM 创建退货类型的公司间STO,报错 -No delivery type for returns processing assigned to item 00010-
  2. revit建筑样板_Revit出建筑施工图步骤及注意事项
  3. bigint对应java什么类型_「JAVA」从格式化输出到扫描输入,深究Java正则表达式匹配之道
  4. lcd timing 先关参数
  5. include(),include_once(),requice(),require_once()的区别
  6. How to include html native content to UI5 page - 直接在xml view里添加html namespace
  7. java-HDU1698(线段树的区间更新,和区间查询)
  8. TypeError: TF_SessionRun_wrapper: expected all values in input dict to be ndarray
  9. 小红伞杀毒软件|小红伞杀毒软件下载
  10. 【第一天】【ROS操作系统】【2】ROS安装教程
  11. 代码精进之路 码农到工匠pdf_专访张建飞:阿里技术也提倡,优雅代码和整洁架构...
  12. 使用 Illustrator 中组合形状的方法详解
  13. 奥克兰大学计算机专业好找工作吗,留学选择奥克兰大学的计算机专业肯定不会后悔...
  14. CTF-网络信息安全攻防学习平台(脚本关)
  15. 小白必看——炒币术语大盘点
  16. 实用的bi报表工具--Smartbi报表软件
  17. 中国计算机设计大赛蔡思琦,建策杯2018年江苏省大学生计算机设计大赛.PDF
  18. 如何将几个pdf合并成一个pdf?教你pdf合并最快速的方法
  19. Docker、CentOS 8遭弃用,GPT-3、M1芯片撼动技术圈,盘点2020影响开发者的十大事件!...
  20. 计算机管理上移动硬盘显示其他设备,win7系统拔出移动硬盘提示“该设备正在使用”怎么处理...

热门文章

  1. 2017年我国电力供需形势预测分析 清洁能源装机比重将提升
  2. linux函数怎么判断目录是否存在,linux C之判断文件或目录是否存在 access函数
  3. VS2015开发OpenDDS实例(ACE_TAO_6.5.10+OpenDDS_3.12+ActivePerl-5.28)
  4. 微信支付的形式及其发展条件
  5. 计算两幅图像PSNR
  6. CreateProcess函数 详细使用
  7. gzip 解压_简简单单_百度空间
  8. E3 V5 和Rme声卡不兼容
  9. 天气预报API(三):免费接口测试(“旧编码”)
  10. 树莓派2B 3B安装USB无线网卡 EDUP EP-8508GS