Unity入门3——脚本基础

news2024/11/14 22:38:43

一、生命周期函数


​ 所有继承 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))                                    
{                                                                                  
    // 逻辑处理                                                                         
}          

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/638195.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

OpenShift Route 的实现原理

OpenShift Route 的实现原理 OpenShift 如何使用 HAProxy 实现 Router 和 RouteRouter appHAProxy 配置1. HTTP2. HTTPS OpenShift 中的 Route 解决了从集群外部访问服务的需求&#xff0c;与 Kubernetes 中的 Ingress 类似。 OpenShift 中 Route 资源 API 定义如下&#xff1…

解剖学关键点检测方向论文翻译和精读:基于热力图回归的CNN融入空间配置实现关键点定位

解剖学关键点检测方向论文翻译和精读&#xff1a;Integrating spatial configuration into heatmap regression based CNNs for landmark localization Abstract: In many medical image analysis applications, only a limited amount of training data is available due to t…

Pyinstaller 打包 paddle出现的问题

目录 问题解决方法 1.找到自己项目所需要的包 2.使用【auto-py-to-exe】库&#xff0c;添加对应项目对应的包 --add-data 需要添加的文件 --hidden-import 需要添加的文件 问题来源 问题解决思路 问题解决方法 1.找到自己项目所需要的包 这里可以参考博主的另外一篇文章&…

大模型当私人法律顾问?北大团队推出法律大模型,数据与模型全部开源!

作者 | 小戏、Python “要是我有一个学法的朋友就好了” 法律作为我们社会生活的最高指引&#xff0c;其重要性毋庸多言。然而类似于医学&#xff0c;法律又是一个入行门槛非常高的专业领域&#xff0c;想想通过率不到 10% 的法考&#xff0c;显然遇到法律相关的专业问题不太支…

mysql中SQL语句查询字段相加的和,以及更改小数精确位。和查询SQL语句结果相减的SQL查询

最近在工作中碰到了SQL进行查询&#xff0c;用户缴费以及退费信息的工作&#xff0c;以及查询完后需要修改SQL结果后小数位的需求&#xff0c;整理结果如下: 首先&#xff0c;看内容&#xff1a; 如图&#xff0c;operate_type代表缴费与退费&#xff0c;分别用0和1区别。 #…

快速教你如何使用postman工具进行接口测试?(配置全局token、JWT可用)

现在很多人都在使用前后端分离进行项目开发&#xff0c;那在后端开发过程中使用postman测试工具可快速便捷完成接口测试。但是在测试过程中&#xff0c;很多人发现因为JWT的鉴权&#xff0c;导致半个小时就需要更新一下token&#xff0c;让我们的测试变得复杂。 若是将token作…

【JUC中的 “8锁现象” 】 —— 每天一点小知识

&#x1f4a7; J U C 中的“ 8 锁现象” \color{#FF1493}{JUC中的 “8锁现象” } JUC中的“8锁现象”&#x1f4a7; &#x1f337; 仰望天空&#xff0c;妳我亦是行人.✨ &#x1f984; 个人主页——微风撞见云的博客&#x1f390; &#x1f433; 《数据结构与算法》…

python基础学习3【NumPy矩阵与通用函数【矩阵相乘+平方+广播机制+转置】+ save、load、sort、repeat、unique、鸢尾花1】

NumPy矩阵与通用函数 a np.mat([[1,2],[3,4]])#生成矩阵b np.matrix([[1,7],[6,4]])np.bmat("a b") 矩阵的运算 矩阵特有属性&#xff1a; 属性 说明 T自身转置H共轭转置I逆矩阵A自身数据的二维数据视图 例如&#xff1a; np.matrix(a).T 矩阵相乘&#xff1a;…

【Map集合的基本功能】

Map集合的基本功能 V put(K key,V value)&#xff1a;添加元素 V remove(K key,V value)&#xff1a;根据键删除键值对元素 package com.gather.map; //Map集合常用的基本功能 import java.util.HashMap; import java.util.Map; public class MapDemo02 {public static void m…

Flutter:路由、拦截返回事件、自定义独立路由

路由堆栈 Flutter 路由管理中有两个非常重要的概念&#xff1a; Route&#xff1a;路由是应用程序页面的抽象&#xff0c;对应 Android 中 Activity 和 iOS 中的 ViewController&#xff0c;由 Navigator 管理。Navigator&#xff1a;Navigator 是一个组件&#xff0c;管理和…

哈希表--想彻底了解哈希表,看这一篇文章就可以了

为了一次存储便能得到所查记录&#xff0c;在记录的存储位置和它的关键字之间建立一个确定的对应关系H&#xff0c;已H&#xff08;key)作为关键字为key的记录在表中的位置&#xff0c;这个对应关系H为哈希&#xff08;Hash&#xff09;函数&#xff0c; 按这个思路建立的表为哈…

【Leetcode】 1071. 字符串的最大公因子

For two strings s and t, we say “t divides s” if and only if s t ... t (i.e., t is concatenated with itself one or more times). Given two strings str1 and str2, return the largest string x such that x divides both str1 and str2. Example 1: Input: s…

开发改了接口,经常忘通知测试的解决方案!

目录 前言&#xff1a; Apifox解决方案 Apifox对此给出的解决方案是&#xff1a; 用Apifox怎么处理接口变更 接口代码实现逻辑修改 接口参数修改 前言&#xff1a; 在开发过程中&#xff0c;接口变动十分频繁&#xff0c;测试人员没有及时获得相关通知的情况也很普遍。这…

这一次AI应该是真正的已经到来

渐渐感觉这一次AI的变革能真正的突破迷雾&#xff0c;迎来真正的人工智能时代的到来。所以写篇博文学习一下。经过半年的发酵与发展&#xff0c;不得不说AI已经成为了不可逆转的趋势。之所以说这一次AI应该是真正的已经到来&#xff0c;是因为人工智能的发展其实已经经历了几十…

【Python】一文带你了解 正则表达式 + 简单操作

作者主页&#xff1a;爱笑的男孩。的博客_CSDN博客-深度学习,活动,python领域博主爱笑的男孩。擅长深度学习,活动,python,等方面的知识,爱笑的男孩。关注算法,python,计算机视觉,图像处理,深度学习,pytorch,神经网络,opencv领域.https://blog.csdn.net/Code_and516?typeblog个…

通过第三方软件修改 MacOS 的键盘映射

通过第三方软件修改 MacOS 的键盘映射 由于文本编辑时大量使用word level的左移、右移&#xff0c;其中&#xff1a; OSX的单词级左右移为option Left/Right Arrow&#xff0c;整行级左右移为command Left/Right Arrow 单词级移动与进行编辑常用的command不同键位&#xff0c…

Chat2DB:阿里巴巴开源的聊天数据管理工具--实践

Chat2DB&#xff1a;阿里巴巴开源的聊天数据管理工具–实践 简介 ​ Chat2DB 是一款有开源免费的多数据库客户端工具&#xff0c;支持windows、mac本地安装&#xff0c;也支持服务器端部署&#xff0c;web网页访问。和传统的数据库客户端软件Navicat、DBeaver 相比Chat2DB集成了…

Jetpack Compose ——Row

当我们构建界面时&#xff0c;经常需要在Compose中使用Row布局来水平排列多个组件。Row提供了一种方便的方式来管理和定位子组件&#xff0c;使它们按照我们期望的方式呈现。 在Compose中&#xff0c;Row可以接受多个子组件作为参数&#xff0c;并根据指定的布局规则进行排列。…

桥梁监测方案-智慧桥梁监测管理系统

桥梁作为现代交通基础设施的重要组成部分&#xff0c;承载着大量的车辆和行人交通。然而&#xff0c;随着时间的推移&#xff0c;桥梁结构可能会受到自然环境、交通负荷和物质疲劳等因素的影响&#xff0c;从而导致潜在的风险和结构损坏。桥梁监测能够通过实时监测桥梁的结构状…

git一定要学会,加油

gitgit文档http://file:///F:/%E8%B5%84%E6%96%99%E5%A4%8D%E4%B9%A0/Git%E4%BC%98%E7%A7%80%E5%BC%80%E6%BA%90%E4%B9%A6%E7%B1%8D/Git%E5%BC%80%E6%BA%90%E4%B9%A6%E7%B1%8D/Pro%20Git%E4%B8%AD%E6%96%87PDF%E7%89%88.pdf init 初始化仓库 这个命令在当前目录下初始化一个 G…