委托是什么? event 关键字有什么用？
委托：
委托是一种特殊类型的对象，它包含了对一个方法的引用。简单来说，委托就像是一个安全的函数指针。它允许我们创建可在运行时动态更改其引用方法的变量，并且可以指向类中定义的任何具有相同签名（即参数类型和返回类型）的方法。
Event ：
"Event"关键字在C#或其他面向对象编程语言中常被使用, 它主要用于发布/订阅模式（也称为观察者模式）。当某个重要事件（比如点击按钮、文件下载完成等）发生时，程序需要通知其他部分进行相应处理。这时候就会使用到"Event"关键字来声明事件，并通过调用这个事件来通知所有订阅了该事件（即注册了该事件处理器）的代码块。
Unity协程是如何实现的
Unity中的协程是一种特殊类型的函数，可以在给定的时间段内多次返回。它们在某些情况下非常有用，比如当你需要对一个操作进行计时或者延迟执行。
以下是Unity协程实现的基本步骤：
创建协程函数：首先，你需要创建一个返回IEnumerator接口类型的函数。这个接口允许你控制代码何时暂停和恢复。
IEnumerator MyCoroutine()
{
// 这里写入你想要执行的代码
yield return null; // 暂停并在下一帧继续
}
启动协程：使用StartCoroutine()方法启动定义好的协程。
StartCoroutine(MyCoroutine());
控制流：通过yield关键字来控制代码执行流。例如：
- yield return null：暂停当前帧，并在下一帧恢复。
- yield return new WaitForSeconds(1)：暂停1秒后恢复。
- yield return StartCoroutine(“AnotherCoroutine”)：
开始另一个协程，并等待它完成后再继续。
以上就是Unity中实现和使用协程的基本方式。请注意，虽然看起来像多线程编程，但实际上所有Unity API调用都必须在主线程上完成，因此不会遇到常规多线程序可能遇到的并发问题。
摄像机有几种模式，成像原理分别是什么？
摄像机（Camera）有三种模式：正交投影模式（Orthographic）、透视投影模式（Perspective）和物理相机（Physical Camera）。
-
正交投影模式：
在这种模式下，摄像机将场景以平行线方式进行投影。这种方式没有透视效果，即远离或靠近摄像头的物体大小不会改变。这种模式通常用于2D游戏或者需要特殊视觉效果的3D游戏。 -
透视投影模式：
在此设置下，摄像机将场景以收敛线方式进行投影。也就是说，远离镜头的物体会显得更小。这就产生了一种深度感或者三维空间感觉，使得画面看起来更加真实立体。 -
物理相机：
从Unity 2018版本开始引入了"Physical Camera"属性, 可以让你设置镜头、传感器和其他一些参数, 更接近现实世界中相机的工作原理.
在Unity中，“成像原理”主要依赖于渲染管线(Render Pipeline)来完成。当你启动一个Scene时, Unity首先创建一个包含所有对象数据(位置、纹理、光照等)的渲染队列(Render Queue), 然后通过Shader程序对每个物体进行处理并生成图形数据, 最后由GPU根据这些数据生成最终图像并显示到屏幕上.
Canvas 有几种模式，如何配置？
Canvas是用于布局和渲染所有UI元素的组件。它有三种模式：
-
世界空间（World Space）：在这种模式下，Canvas表现为任何常规的3D对象一样。你可以自由地移动、旋转、缩放它。这种模式通常用于3D游戏中的交互UI或者VR应用。
-
屏幕空间-覆盖（Screen Space - Overlay）：这是默认的Canvas模式。在此模式下，Canvas将覆盖屏幕，并始终对准摄像机视野的前方，无论摄像机如何移动或旋转。当你需要全屏显示UI元素时，比如菜单、得分板等，这个选项非常实用。
-
屏幕空间-相机（Screen Space - Camera）：此模式将Canvas渲染到特定摄像头的平面上，并随着摄像头移动而变化位置和大小。
UGUI如何打包图集
在Unity 2018及以后的版本中，Unity引入了新的系统"Sprite Atlas"来替代旧的"Sprite Packer"。以下是使用新版Sprite Atlas打包图集的步骤：
在Project窗口中右键点击 -> Create -> Sprite Atlas，创建一个新的Sprite Atlas对象。
将所有需要打包成图集的图片拖动到这个新建立的Sprite Atlas对象上，在Inspector窗口中可以看到Objects for Packing区域，里面列出了你添加进来的所有图片。
在Inspector窗口可以看到Pack Preview按钮, 点击它可以预览打包效果。如果满意，则可以保存并关闭预览。
在编写脚本或者配置UI元素时引用这些Sprite时, Unity会自动使用它们在图集中对应部分, 而不再是单独加载原始小图片。
如果你想要手动控制何时进行打包操作，也可以通过编程方式调用UnityEditor.U2D.SpriteAtlasUtility.PackAtlases()函数进行手动打包。注意这个函数只能在编辑器环境下使用，并且需要添加#if UNITY_EDITOR和#endif标记防止在构建游戏时产生错误。
UGUI 如何实现UI物体淡入淡出
在Unity的UGUI系统中，实现UI物体的淡入淡出效果可以通过调整Canvas Group组件或者Image和Text组件自身的Alpha值来达到。这里以Canvas Group为例，演示如何使用C#脚本实现：
首先，在你想要进行淡入淡出操作的UI物体上添加一个Canvas Group组件。
然后创建一个新的C#脚本，例如命名为FadeInOut，并把以下代码粘贴进去：
using System.Collections;
using UnityEngine;
using UnityEngine.UI;
public class FadeInOut : MonoBehaviour
{
public float fadeSpeed = 0.5f; // 控制淡入淡出速度
private CanvasGroup canvasGroup;
void Start()
{
canvasGroup = GetComponent<CanvasGroup>();
StartCoroutine(FadeIn());
}
IEnumerator FadeIn()
{
while (canvasGroup.alpha < 1)
{
canvasGroup.alpha += Time.deltaTime * fadeSpeed;
yield return null;
}
yield return new WaitForSeconds(2); // 淡入完成后等待两秒开始执行淡出
StartCoroutine(FadeOut());
}
IEnumerator FadeOut()
{
while (canvasGroup.alpha > 0)
{
canvasGroup.alpha -= Time.deltaTime * fadeSpeed;
yield return null;
}
}
}
最后，将这个脚本附加到你刚才添加了Canvas Group组件的UI物体上，并设置好fadeSpeed参数即可。
运行游戏时，该UI物体就会以指定速度进行一次完整的从完全透明（alpha=0）到完全不透明（alpha=1）再回到完全透明（alpha=0）的过程。如果你需要在特定事件触发时进行此效果，则需要稍微修改以上代码结构来满足需求。
Hash表的原理是什么, 如何实现
哈希表(HashTable)也被称为散列表，是一种数据结构，它提供了快速插入、删除和查找操作的功能。哈希表通过使用哈希函数将键(Key)映射到存储位置，然后在这个位置存储值(Value)。
这是一个简单的示例来解释它是如何工作的：
假设我们有一个空的哈希表，并且我们想要在其中添加一个元素，例如（“name”, “John”）。
我们首先将键(“name”)输入到哈希函数中。这个函数会返回一个数字（假设返回3），我们把值(“John”)存储在数组索引为3的位置上。
当我们想要查找键为"name"对应的值时，我们再次使用同样的哈希函数处理键(“name”)，得到相同的数字(3)，然后直接访问数组索引为3处获取其对应值即可。
实现基本步骤如下：
-
初始化：
创建一个足够大容量（通常大于预期元素数量）且初始全部为空或特定标记值（例如null） 的数组用于存放数据。 -
插入：
当需要插入新元素时, 先通过hash 函数计算出该元素key 对应 hashcode, 然后根据 hashcode 找到在数组中对应下标位置并将value 存放进去. -
查找：
当需要查找某个key 对应value 时, 同样先计算出该key 对应hashcode, 再根据hashcode 找到对应下标并读取value. -
删除：
删除则与查找类似, 先定位到具体位置然后再进行删除操作.
不过需要注意，在实际情况中可能会发生所谓“碰撞”现象——即两个不同Key经过Hash Function计算得出相同HashCode导致他们试图占用同一块内存地址。
解决碰撞问题主要有两种方法：“开放寻址法”和“链地址法”。
- 开放寻址法就是如果发生碰撞，则向前或向后探测其他空位；
- 链地址法则是每个Hash槽里面维护了一个链表或者其他数据结构，在碰撞时就把Value添加进对应槽位里面去。
实际使用中还需要考虑扩容、缩容、哈希函数设计等问题。
链表如何实现
链表是一种动态数据结构，它使用节点（Node）来存储数据。每个节点包含两个部分：一个是数据域，用于保存数据；另一个是指针域，用于链接到下一个节点。这种结构使得在任何位置插入或删除元素都变得相对容易。
在C#中，链表的实现相对简单，因为它提供了内建的LinkedList类。但是如果你想自己实现一个链表，那么可以按照以下步骤操作：
定义节点(Node)类：
public class Node
{
public int Data {
get; set; }
public Node Next {
get; set; }
public Node(int data)
{
this.Data = data;
this.Next = null;
}
}
定义链表(LinkedList)类，并实现添加(add)、删除(delete)等方法：
public class LinkedList
{
private Node head;
public LinkedList()
{
this.head = null;
}
// 添加节点到链表尾部
public void AddLast(int data)
{
Node newNode = new Node(data);
if (head == null)
head = newNode;
else
{
Node current = head;
while (current.Next != null)
current = current.Next;
current.Next = newNode;
}
}
// 删除特定值的节点（假设值唯一）
public void DeleteNode(int key)
{
// 如果头结点就是要删除的结点
if(head != null && head.Data == key)
{
head= head.Next;
return ;
}
// 其他情况，找到要删除结点前面一个结点prev和要删除结点current
Node prev=null, current=head ;
while(current!=null && current.Data!=key){
prev=current ;
current=current.Next ;
}
// 如果找不到这样的结点，则返回
if(current==null)return ;
// 跳过当前要删除的节点
prev.next=current.next ;
}
}
Unity节点缓存池如何实现
在Unity中，对象池（Object Pool）是一种常用的优化技术，可以减少实例化和销毁对象的开销。以下是一个简单的Unity节点缓存池实现：
首先，创建一个新的C#脚本并命名为ObjectPooler，然后添加以下代码：
using System.Collections.Generic;
using UnityEngine;
public class ObjectPooler : MonoBehaviour
{
public static ObjectPooler Instance;
public GameObject pooledObject;
public int pooledAmount = 20;
public bool willGrow = true;
List<GameObject> pooledObjects;
void Awake()
{
Instance = this;
}
void Start ()
{
pooledObjects = new List<GameObject>();
for (int i = 0; i < pooledAmount; i++)
{
GameObject obj = (GameObject)Instantiate(pooledObject);
obj.SetActive(false);
pooledObjects.Add(obj);
}
}
public GameObject GetPooledObject()
{
for (int i=0; i<pooledObjects.Count; i++)
{
if (!pooledObjects[i].activeInHierarchy)
{
return pooledObjects[i];
}
}
if (willGrow)
{
GameObject obj = (GameObject)Instantiate(pooledObject);
obj.SetActive(false);
pooledObjects.Add(obj);
return obj;
}
return null;
}
}
这个脚本会创建并管理一个指定类型的游戏对象(GameObject)列表。它首先预加载一定数量(pooledAmount)的游戏对象，并将它们设置为非激活状态。当你需要从池中获取一个对象时，它会遍历列表并返回第一个非激活状态的对象。
如果所有对象都处于激活状态，并且willGrow属性设置为true，则该脚本将实例化一个新的游戏对象，并添加到列表中。
注意：在使用时，请确保已经把要生成物体预制体拖入到pooledObject位置上，并且在使用完物体后记得把物体设为非激活状态以便再次使用。
更复杂的
对于复制一点的需求，你可能是想要创建一个能够存储和管理多种类型游戏对象的对象池。这可以通过在我们先前示例的基础上进行扩展来实现。
首先，我们需要创建一个新的类来存储每种类型游戏对象的信息：
[System.Serializable]
public class ObjectPoolItem
{
public GameObject objectToPool;
public int amountToPool;
public bool shouldExpand = true;
}
然后，在ObjectPooler类中使用这个新类：
public class ObjectPooler : MonoBehaviour
{
public static ObjectPooler SharedInstance;
//新增：用于存储不同类型游戏对象信息的列表
public List<ObjectPoolItem> itemsToPool;
//新增：用于存储所有已经实例化出来的游戏对象列表
public List<GameObject> pooledObjects;
void Awake()
{
SharedInstance = this;
}
void Start ()
{
pooledObjects = new List<GameObject>();
foreach (ObjectPoolItem item in itemsToPool)
{
for (int i = 0; i < item.amountToPool; i++)
{
GameObject obj = (GameObject)Instantiate(item.objectToPool);
obj.SetActive(false);
pooledObjects.Add(obj);
}
}
}
public GameObject GetPooledObject(string tag)
{
for (int i=0; i<pooledObjects.Count; i++)
{
if (!pooledObjects[i].activeInHierarchy && pooledObjects[i].tag == tag)
{
return pooledObjects[i];
}
}
foreach(ObjectPoolItem item in itemsTopool){
if(item.objectTopool.tag == tag){
if(item.shouldExpand){
GameObject obj=(GameObject)Instantiate(item.objectTopool);
obj.SetActive(false);
poolobjects.Add(obj);
return obj;
}
}
}
return null;
}
}
在此版本中，你可以通过Unity编辑器为每种类型游戏对象指定预设、数量以及是否允许扩展。当需要获取一个特定标签(tag)的游戏对象时，只需调用GetPooledObject()函数并传入相应标签即可。
注意：请确保预设物体都有正确设置tag, 并且在使用完物体后记得把物体设为非激活状态以便再次使用。
Unity如何实现单例模式
在Unity中实现单例模式可以通过创建一个静态实例的脚本类来完成。这个类将始终返回同一个对象的引用，如果该对象没有被创建，那么它就会创建一个。
以下是在Unity中实现单例模式的一种常见方法：
public class Singleton<T> : MonoBehaviour where T : MonoBehaviour
{
private static T _instance;
public static T Instance
{
get
{
if (_instance == null)
{
_instance = FindObjectOfType<T>();
if (_instance == null)
{
GameObject singleton = new GameObject();
_instance = singleton.AddComponent<T>();
singleton.name = typeof(T).ToString() + " (Singleton)";
// 确保单例不会被销毁
DontDestroyOnLoad(singleton);
}
}
return _instance;
}
}
}
你可以通过继承这个Singleton类来创建自己的单例类。例如：
public class MySingletonClass : Singleton<MySingletonClass>
{
// 这里是你自己的代码...
}
然后，你就可以通过MySingletonClass.Instance来访问这个单例对象了。
注意：虽然使用单例模式很方便，但也需要谨慎对待。过度使用可能导致代码难以理解和维护，并可能引发难以调试的问题。只有当你确信某个特定组件真正需要全局访问时，才应该使用此模式。
[MenuItem] 什么意思
在Unity中，[MenuItem]是一个特性(Attribute)，它用于在Unity的菜单栏中创建新的菜单项。这个特性可以应用于静态方法。
例如，你可能会使用以下代码来添加一个名为"Custom/My Function"的新菜单项：
using UnityEngine;
using UnityEditor;
public class MyEditorScript
{
[MenuItem("Custom/My Function")]
static void MyFunction()
{
// 这里是你自定义功能的代码...
Debug.Log("My Function Was Called!");
}
}
当你点击"Custom/My Function"这个菜单项时，就会执行MyFunction()方法，并在控制台打印出"My Function Was Called!"。
注意：因为[MenuItem]特性只能应用于静态方法，所以被标记为菜单项的函数必须是静态的。此外，这个特性只能用在编辑器脚本中，也就是说包含该函数的类必须放置在项目文件夹下名为 “Editor” 的文件夹内。
打包ab包出来后.manifest有什么作用
在Unity中，AssetBundle文件的".manifest"文件包含了一些关于AssetBundle的元数据，包括其依赖项和散列值。这些信息主要用于加载和缓存AssetBundles。
-
依赖项：
当你从一个AssetBundle加载资源时，可能需要先加载其他的AssetBundles。这是因为资源可能引用了其他AssetBundles中的资源（例如材质、纹理等）。".manifest"文件会列出所有必须首先加载的依赖项。 -
散列值：
散列值用于检查缓存中是否存在最新版本的AssetBundle。当你尝试从服务器下载一个已经在本地缓存过的AssetBundle时，Unity会比较本地版本和服务器上版本的散列值。如果两者相同，则Unity会直接从缓存中加载该bundle，而不是重新下载。
所以说，在处理.manifest文件时需要特别注意其作用和重要性。正确处理它们可以确保游戏正常运行，并有效利用玩家设备上的存储空间。
Image与RawImage的区别
在Unity的UI系统中，Image和RawImage都是用于显示图像的组件，但它们之间有一些关键区别：
Image：
这个组件使用Sprite作为其图像源。它支持各种类型的填充方法（例如简单填充、水平或垂直填充、径向360度等），可以使用九宫格布局来处理图像边缘，并且支持颜色渐变。此外，你还可以在Image上应用遮罩。
RawImage:
这个组件使用Texture作为其图像源。它不支持填充方法、九宫格布局或者遮罩等特性。但是，由于直接引用纹理数据，所以Raw Image更适合显示不需要以上特性，并且希望直接访问原始纹理数据的情况（例如WebCamTexture或者RenderTexture）。
总结
如果你需要更多控制和复杂的渲染选项(如颜色渐变, 填充, 遮罩等), 使用 Image. 如果你只是想简单地展示一个纹理并且不需要额外功能, 或者你正在处理不能转换为 Sprite 的纹理类型（例如WebCamTexture或RenderTexture）时，那么选择 Raw Image.
Unity有哪些特定的文件夹名字，有什么作用
在Unity项目中，有一些特定的文件夹名称具有特殊的含义和作用：
-
Assets：这是所有Unity项目的根目录，所有的脚本、场景、预设、音频和图像等资源都应该放在这个文件夹或其子文件夹中。
-
Editor：这个文件夹用于存放编辑器脚本，即那些只在Unity编辑器中运行并扩展其功能的脚本。例如自定义Inspector面板、菜单项等。
-
Resources：你可以将需要使用到Resources.Load()方法动态加载的资源放入此文件夹。注意不要过度使用此类加载方式，因为它可能会增加应用程序启动时间，并使内存管理更复杂。
-
StreamingAssets：这个目录下的所有内容都会被原封不动地拷贝到最终构建结果中。你可以用来存储如文本文件、数据库或者已经压缩好了格式无法再进行进一步优化处理的数据（比如视频）。
-
Gizmos: 这个目录主要是用来存储自定义Gizmo图标，在Scene视图里面显示出来帮助开发者定位对象和理解场景布局。
-
Plugins: 这个目录主要是用来存储插件，包括各种第三方库, 如Android .jar/.aar 文件, iOS静态库.a 文件等.
注意: 使用以上特殊名称创建新目录时，请确保大小写正确，并且直接将其创建在正确位置上。否则Unity可能无法识别该目录并提供相应功能。
Unity如何实现游戏截图
针对去屏幕截图
在Unity中，你可以使用ScreenCapture.CaptureScreenshot()方法来实现游戏截图。以下是一个简单的例子：
csharp
复制
using UnityEngine;
public class ScreenshotTaker : MonoBehaviour
{
public void TakeScreenshot()
{
// 生成文件名（以当前时间命名）
string fileName = “Screenshot_” + System.DateTime.Now.ToString(“yyyy-MM-dd_HH-mm-ss”) + “.png”;
// 在游戏的数据路径下创建 Screenshots 文件夹（如果不存在）
string directoryPath = Application.persistentDataPath + "/Screenshots/";
if (!System.IO.Directory.Exists(directoryPath))
System.IO.Directory.CreateDirectory(directoryPath);
// 捕获屏幕并保存为 .png 文件
ScreenCapture.CaptureScreenshot(directoryPath + fileName);
Debug.Log("Screenshot saved to: " + directoryPath + fileName);
}
}
然后，你可以将这个脚本添加到场景中的任何GameObject上，并通过代码或者按钮点击等方式调用TakeScreenshot()方法。
注意：ScreenCapture.CaptureScreenshot()方法会在下一帧捕获屏幕，因此如果你立即查找文件可能不会找到它。
针对于特定摄像机或者区域进行截图
使用RenderTexture和Texture2D.ReadPixels()方法。
以下是一个简单的例子：
using UnityEngine;
public class CameraScreenshotTaker : MonoBehaviour
{
public Camera screenshotCamera; // 截图用的摄像机
public void TakeScreenshot(int width, int height)
{
// 创建一个新的RenderTexture
RenderTexture renderTex = new RenderTexture(width, height, 24);
// 让截图用的摄像机渲染到新建立的RenderTexture上
screenshotCamera.targetTexture = renderTex;
// 创建一个空纹理并读取屏幕内容到这个纹理中
Texture2D screenShot = new Texture2D(width, height, TextureFormat.RGB24, false);
screenshotCamera.Render();
RenderTexture.active = renderTex;
screenShot.ReadPixels(new Rect(0, 0, width,height), 0 ,0);
screenShot.Apply();
byte[] bytes=screenShot.EncodeToPNG();
string filename=Application.dataPath + "/Screenshot.png";
System.IO.File.WriteAllBytes(filename, bytes);
Debug.Log(string.Format("截屏了一张照片: {0}", filename));
// 恢复环境，释放申请的资源。
screenshotCamera.targetTexture=null;
RenderTexture.active=null;
GameObject.Destroy(renderTex);
}
}
在这个脚本中，我们首先创建了一个新的RenderTexture对象，并将其设置为我们希望进行截图操作的摄像机目标纹理。然后，我们让该摄像机渲染一次，并使用ReadPixels()方法从当前激活（active）状态下得 RenderTexturereadPixels()读取所有像素信息。
之后就可以将这些数据保存为图片文件了。记住在完成所有操作后恢复环境并释放资源。
注意：以上代码只能在Unity主线程中运行，不能在另外线程中执行。
Unity如何调用android与iOS的 API函数
在Unity中调用Android和iOS的API，你需要使用Unity的插件功能。下面是一些基本步骤：
对于Android：
首先，你需要使用Java（或Kotlin）创建一个Android库（.jar或.aar文件），并在此库中定义你想要调用的函数。
然后，在Unity项目的Assets/Plugins/Android目录下放置这个库文件。
在C#脚本中，使用AndroidJavaObject 或 AndroidJavaClass来调用这个库里面的函数。
例如：
using UnityEngine;
public class AndroidPluginTest : MonoBehaviour
{
void Start()
{
if (Application.platform == RuntimePlatform.Android)
{
AndroidJavaClass unityPlayer = new AndroidJavaClass("com.unity3d.player.UnityPlayer");
AndroidJavaObject currentActivity = unityPlayer.GetStatic<AndroidJavaObject>("currentActivity");
// Assuming the plugin class name is "com.example.myplugin.MyPlugin"
// and it has a static method "foo"
using (var pluginClass = new AndroidJavaClass("com.example.myplugin.MyPlugin"))
pluginClass.CallStatic("foo", currentActivity);
}
}
}
对于iOS：
你需要创建一个Objective-C（或Swift但会更复杂）类，并在其中定义你想要调用的函数。
将该类保存为.mm文件，并放入到Assets/Plugins/iOS目录下。
Unity将自动将这些类编译到生成的Xcode项目中。然后，在C#脚本中可以直接通过PInvoke机制来访问它们。
例如：
using System.Runtime.InteropServices;
using UnityEngine;
public class iOSPluginTest : MonoBehaviour
{
#if UNITY_IOS && !UNITY_EDITOR
[DllImport("__Internal")]
private static extern void _Foo();
#endif
public void CallFoo()
{
#if UNITY_IOS && !UNITY_EDITOR
_Foo();
#endif
}
}
以上代码假设您有一个名为_Foo() 的Objective-C方法。
注意：确保当平台不匹配时正确处理平台相关代码，以防止在其他平台上产生编译错误。