码迷，mamicode.com
首页 > 编程语言 > 详细

【转载】关于对方法实例化的相关感悟以及unity的50个技巧

时间：2017-11-28 17:20:27      阅读：359      评论：0      收藏：0      [点我收藏+]

标签：参考   发送   并且   isa   evm   uil   effect   bug   区别   

关于实例化问题的感悟（笔者自悟，大神勿喷）

在之前的程序编写过程中，虽然对相关的方法进行了实例化，但是在运行的时候总是会出现“未将对象引用设置到对象的实例”，出现该种问题的原因是由于在实例化后，没有对实例化进行引用赋值，所以导致相关变量无法在其他方法中进行读取，以后需对此谨记。

 

同时之前浏览过一片大神写过的关于unity相关技巧的文章，笔者觉得受益匪浅，现将链接与原文转载于下，希望可以帮助大家。

 

使用Unity3D的50个技巧：Unity3D最佳实践

作者：房燕良

 

关于这些技巧

这些技巧不可能适用于每个项目。
  • 这些是基于我的一些项目经验，项目团队的规模从3人到20人不等；
  • 框架结构的可重用性、清晰程度是有代价的——团队的规模和项目的规模决定你要在这个上面付出多少；
  • 很多技巧是品味的问题（这里所列的所有技巧，可能有同样好的技术替代方案）；
  • 一些技巧可能是对传统的Unity开发的一个冲击。例如，使用prefab替代对象实例并不是一个传统的Unity风格，并且这样做的代价还挺高的（需要很多的preffab）。也许这些看起来有些疯狂，但是在我看来是值得的。

流程

1、避免Assets分支

 

所有的Asset都应该只有一个唯一的版本。如果你真的需要一个分支版本的Prefab、Scene或是Mesh，那你要制定一个非常清晰的流程，来确定哪个是正确的版本。错误的分支应该起一个特别的名字，例如双下划线前缀：__MainScene_Backup。Prefab版本分支需要一个特别的流程来保证安全（详见Prefabs一节）。

2、如果你在使用版本控制的话，每个团队成员都应该保有一个项目的Second Copy用来测试

修改之后，Second Copy和Clean Copy都应该被更新和测试。大家都不要修改自己的Clean Copy。这对于测试Asset丢失特别有用。

3、考虑使用外部的关卡编辑工具

Unity不是一个完美的关卡编辑器。例如，我们使用TuDee来创建3D Tile-Based的游戏，这使我们可以获得对Tile友好的工具的益处（网格约束，90度倍数的旋转，2D视图，快速Tile选择等）。从一个XML文件来实例化Prefab也很简单。详见Guerrilla Tool Development。

4、考虑把关卡保存为XML，而非scene

这是一种很奇妙的技术：
  • 它可以让你不必每个场景都设置一遍；
  • 他可以加载的更快（如果大多数对象都是在场景之间共享的）。
  • 它让场景的版本合并变的简单（就算是Unity的新的文本格式的Scene，也由于数据太多，而让版本合并变的不切实际）。
  • 它可以使得在关卡之间保持数据更简便。
你仍就可以使用Unity作为关卡编辑器（尽管你用不着了）。你需要写一些你的数据的序列化和反序列化的代码，并实现在编辑器和游戏运行时加载关卡、在编辑器中保存关卡。你可能需要模仿Unity的ID系统来维护对象之间的引用关系。

5、考虑编写通用的自定义Inspector代码

实现自定义的Inspector是很直截了当的，但是Unity的系统有很多的缺点：
  • 它不支持从继承中获益；
  • 它不允许定义字段级别的Inspector组件，而只能是class类型级别。举个例子，如果没有游戏对象都有一个ScomeCoolType字段，而你想在Inspector中使用不同的渲染，那么你必须为你的所有class写Inspector代码。
你可以通过从根本上重新实现Inspector系统来处理这些问题。通过一些反射机制的小技巧，他并不像看上去那么看，文章底部（日后另作翻译）将提供更多的实现细节。
                                                                                                                                         

场景组织

6、使用命名的空Game Object来做场景目录

仔细的组织场景，就可以方便的找到任何对象。

7、把控制对象和场景目录（空Game Objec）放在原点（0，0，0）

如果位置对于这个对象不重要，那么就把他放到原点。这样你就不会遇到处理Local Space和World Space的麻烦，代码也会更简洁。

8、尽量减少使用GUI组件的offset

通常应该由控件的Layout父对象来控制Offset；它们不应该依赖它们的爷爷节点的位置。位移不应该互相抵消来达到正确显示的目的。做基本上要防止了下列情况的发生：
父容器被放到了（100，-50），而字节点应该在（10，10），所以把他放到（90，60）[父节点的相对位置]。
这种错误通常放生在容器不可见时。

9、把世界的地面放在Y=0

这样可以更方便的把对象放到地面上，并且在游戏逻辑中，可以把世界作为2D空间来处理（如果合适的话），例如AI和物理模拟。

10、使游戏可以从每个Scene启动

这将大大的降低测试的时间。为了达到所有场景可运行，你需要做两件事：
首先，如果需要前面场景运行产生的一些数据，那么要模拟出它们。
其次，生成在场景切换时必要保存的对象，可以是这样：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. myObject = FindMyObjectInScene();  
  2.    
  3. if (myObjet == null)  
  4. {  
  5.    myObject = SpawnMyObject();  
  6. }  
 
                                                                                                                                                                   

美术

11、把角色和地面物体的中心点(Pivot)放在底部，不要放在中间

这可以使你方便的把角色或者其他对象精确的放到地板上。如果合适的话，它也可能使得游戏逻辑、AI、甚至是物理使用2D逻辑来表现3D。

12、统一所有的模型的面朝向（Z轴正向或者反向）

对于所有具有面朝向的对象（例如角色）都应该遵守这一条。在统一面朝向的前提下，很多算法可以简化。

13、在开始就把Scale搞正确

请美术把所有导入的缩放系数设置为1，并且把他们的Transform的Scale设置为1,1,1。可以使用一个参考对象（一个Unity的Cube）来做缩放比较。为你的游戏选择一个世界的单位系数，然后坚持使用它。

14、为GUI组件或者手动创建的粒子制作一个两个面的平面模型

设置这个平面面朝向Z轴正向，可能简化Billboard和GUI创建。

15、制作并使用测试资源

  • 为SkyBox创建带文字的方形贴图；
  • 一个网格（Grid）；
  • 为Shader测试使用各种颜色的平面：白色，黑色，50%灰度，红，绿，蓝，紫，黄，青；
  • 为Shader测试使用渐进色：黑到白，红到绿，红到蓝，绿到蓝；
  • 黑白格子；
  • 平滑的或者粗糙的法线贴图；
  • 一套用来快速搭建场景的灯光（使用Prefa）；
 
                                                                                                                                                                     

Prefabs

16、所有东西都使用Prefab

只有场景中的“目录”对象不使用Prefab。甚至是那些只使用一次的唯一对象也应该使用Prefab。这样可以在不动用场景的情况下，轻松修改他们。（一个额外的好处是，当你使用EZGUI时，这可以用来创建稳定的Sprite Atlases）

17、对于特例使用单独的Prefab，而不要使用特殊的实例对象

如果你有两种敌人的类型，并且只是属性有区别，那么为不同的属性分别创建Prefab，然后链接他们。这可以：
  • 在同一个地方修改所有类型
  • 在不动用场景的情况下进行修改
如果你有很多敌人的类型，那么也不要在编辑器中使用特殊的实例。一种可选的方案是程序化处理它们，或者为所有敌人使用一个核心的文件/Prefab。使用一个下拉列表来创建不同的敌人，或者根据敌人的位置、玩家的进度来计算。

18、在Prefab之间链接，而不要链接实例对象

当Prefab放置到场景中时，它们的链接关系是被维护的，而实例的链接关系不被维护。尽可能的使用Prefab之间的链接可以减少场景创建的操作，并且减少场景的修改。

19、如果可能，自动在实例对象之间产生链接关系

如果你确实需要在实例之间链接，那么应该在程序代码中去创建。例如，Player对象在Start时需要把自己注册到GameManager，或者GameManager可以在Start时去查找Player对象。
对于需要添加脚本的Prefab，不要用Mesh作为根节点。当你需要从Mesh创建一个Prefab时，首先创建一个空的GameObject作为父对象，并用来做根节点。把脚本放到根节点上，而不要放到Mesh节点上。使用这种方法，当你替换Mesh时，就不会丢失所有你在Inspector中设置的值了。
使用互相链接的Prefab来实现Prefab嵌套。Unity并不支持Prefab的嵌套，在团队合作中第三方的实现方案可能是危险的，因为嵌套的Prefab之间的关系是不明确的。

20、使用安全的流程来处理Prefab分支

我们用一个名为Player的Prefab来讲解这个过程。
用下面这个流程来修改Player：
  1. 复制Player Prefab；
  2. 把复制出来的Prefab重命名为__Player_Backup；
  3. 修改Player Prefab；
  4. 测试一切工作正常，删除__Player_Backup；
不要把新复制的命名为Player_New，然后修改它。
有些情况可能更复杂一些。例如，有些修改可能涉及到两个人，上述过程有可能使得场景无法工作，而所有人必须停下来等他们修改完毕。如果修改能够很快完成，那么还用上面这个流程就可以。如果修改需要花很长时间，则可以使用下面的流程：
    • 第一个人：
      1. 复制Player Prefab；
      2. 把它重命名为__Player_WithNewFeature或者__Player_ForPerson2；
      3. 在复制的对象上做修改，然后提交给第二个人；
    • 第二个人：
      1. 在新的Prefab上做修改；
      2. 复制Player Prefab，并命名为__Player_Backup；
      3. 把__Player_WithNewFeature拖放到场景中，创建它的实例；
      4. 把这个实例拖放到原始的Player Prefab中；
      5. 如果一切工作正常，则可使删除__Player_Backup和__Player_WithNewFeature;
 
                                                                                                                                                                       

扩展和MonoBehaviourBase

21、扩展一个自己的Mono Behaviour基类，然后自己的所有组件都从它派生

这可以使你方便的实现一些通用函数，例如类型安全的Invoke，或者是一些更复杂的调用（例如random等等）。

22、为Invoke, StartCoroutine and Instantiate 定义安全调用方法

定义一个委托任务（delegate Task），用它来定义需要调用的方法，而不要使用字符串属性方法名称，例如：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. public void Invoke(Task task, float time)  
  2. {  
  3.    Invoke(task.Method.Name, time);  
  4. }  

23、为共享接口的组件扩展

有些时候把获得组件、查找对象实现在一个组件的接口中会很方便。
下面这种实现方案使用了typeof，而不是泛型版本的函数。泛型函数无法在接口上工作，而typeof可以。下面这种方法把泛型方法整洁的包装起来。
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. //Defined in the common base class for all mono behaviours  
  2. public I GetInterfaceComponent<I>() where I : class  
  3. {  
  4.    return GetComponent(typeof(I)) as I;  
  5. }  
  6.    
  7. public static List<I> FindObjectsOfInterface<I>() where I : class  
  8. {  
  9.    MonoBehaviour[] monoBehaviours = FindObjectsOfType<MonoBehaviour>();  
  10.    List<I> list = new List<I>();  
  11.    
  12.    foreach(MonoBehaviour behaviour in monoBehaviours)  
  13.    {  
  14.       I component = behaviour.GetComponent(typeof(I)) as I;  
  15.    
  16.       if(component != null)  
  17.       {  
  18.          list.Add(component);  
  19.       }  
  20.    }  
  21.    
  22.    return list;  
  23. }  

24、使用扩展来让代码书写更便捷

例如：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. public static class CSTransform   
  2. {  
  3.    public static void SetX(this Transform transform, float x)  
  4.    {  
  5.       Vector3 newPosition =   
  6.          new Vector3(x, transform.position.y, transform.position.z);  
  7.    
  8.       transform.position = newPosition;  
  9.    }  
  10.    ...  
  11. }   

25、使用防御性的GetComponent()

有些时候强制性组件依赖（通过RequiredComponent）会让人蛋疼。例如，很难在Inspector中修改组件（即使他们有同样的基类）。下面是一种替代方案，当一个必要的组件没有找到时，输出一条错误信息。
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. public static T GetSafeComponent<T>(this GameObject obj) where T : MonoBehaviour  
  2. {  
  3.    T component = obj.GetComponent<T>();  
  4.    
  5.    if(component == null)  
  6.    {  
  7.       Debug.LogError("Expected to find component of type "   
  8.          + typeof(T) + " but found none", obj);  
  9.    }  
  10.    
  11.    return component;  
  12. }  
                                                                                                                                                    

风格

26、避免对同一件事使用不同的处理风格

在很多情况下，某件事并不只有一个惯用手法。在这种情况下，在项目中明确选择其中的一个来使用。下面是原因：
  • 一些做法并不能很好的一起协作。使用一个，能强制统一设计方向，并明确指出不是其他做法所指的方向；
  • 团队成员使用统一的风格，可能方便大家互相的理解。他使得整体结构和代码都更容易理解。这也可以减少错误；
几组风格的例子：
  • 协程与状态机（Coroutines vs. state machines）；
  • 嵌套的Prefab、互相链接的Prefab、超级Prefab（Nested prefabs vs. linked prefabs vs. God prefabs）；
  • 数据分离的策略；
  • 在2D游戏的使用Sprite的方法；
  • Prefab的结构；
  • 对象生成策略；
  • 定位对象的方法：使用类型、名称、层、引用关系；
  • 对象分组的方法：使用类型、名称、层、引用数组；
  • 找到一组对象，还是让它们自己来注册；
  • 控制执行次序（使用Unity的执行次序设置，还是使用Awake/Start/Update/LateUpdate，还是使用纯手动的方法，或者是次序无关的架构）；
  • 在游戏中使用鼠标选择对象/位置/目标：SelectionManager或者是对象自主管理；
  • 在场景变换时保存数据：通过PlayerPrefs，或者是在新场景加载时不要销毁的对象；
  • 组合动画的方法：混合、叠加、分层；
 
                                                                                                                                                     

时间

27、维护一个自己的Time类，可以使游戏暂停更容易实现

做一个“Time.DeltaTime”和""Time.TimeSinceLevelLoad"的包装，用来实现暂停和游戏速度缩放。这使用起来略显麻烦，但是当对象运行在不同的时钟速率下的时候就方便多了（例如界面动画和游戏内动画）。
 
                                                                                                                                                     

生成对象

28、不要让游戏运行时生成的对象搞乱场景层次结构

在游戏运行时，为动态生成的对象设置好它们的父对象，可以让你更方便的查找。你可以使用一个空的对象，或者一个没有行为的单件来简化代码中的访问。可以给这个对象命名为“DynamicObjects”。
 
                                                                                                                                                    

类设计

29、使用单件（Singleton）模式

从下面这个类派生的所有类，将自动获得单件功能：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. public class Singleton<T> : MonoBehaviour where T : MonoBehaviour  
  2. {  
  3.    protected static T instance;  
  4.    
  5.    /** 
  6.       Returns the instance of this singleton. 
  7.    */  
  8.    public static T Instance  
  9.    {  
  10.       get  
  11.       {  
  12.          if(instance == null)  
  13.          {  
  14.             instance = (T) FindObjectOfType(typeof(T));  
  15.    
  16.             if (instance == null)  
  17.             {  
  18.                Debug.LogError("An instance of " + typeof(T) +   
  19.                   " is needed in the scene, but there is none.");  
  20.             }  
  21.          }  
  22.    
  23.          return instance;  
  24.       }  
  25.    }  
  26. }  
单件可以作为一些管理器，例如ParticleManager或者AudioManager亦或者GUIManager。
  • 对于那些非唯一的prefab实例使用单件管理器（例如Player）。不要为了坚持这条原则把类的层次关系复杂化，宁愿在你的GameManager（或其他合适的管理器中）中持有一个它们的引用。
  • 对于外部经常使用的共有变量和方法定义为static，这样你可以这样简便的书写“GameManager.Player”，而不用写成“GameManager.Instance.player”。

30、在组件中不要使用public成员变量，除非它需要在inspector中调节

除非需要设计师（策划or美术）去调节的变量，特别是它不能明确表明自己是做什么的变量，不要声明为public。如果在这些特殊情况下，无法避免，则可使用两个甚至四个下划线来表明不要从外部调节它，例如：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. public float __aVariable;   

31、把界面和游戏逻辑分开

这一条本质上就是指的MVC模式。
 
所有的输入控制器，只负责向相应的组件发送命令，让它们知道控制器被调用了。举一个控制器逻辑的例子，一个控制器根据玩家的状态来决定发送哪个命令。但是这样并不好（例如，如果你添加了多个控制器，那将会导致逻辑重复）。相反的，玩家对象应该根据当前状态（例如减速、惊恐）来设置当前的速度，并根据当前的面朝向来计算如何向前移动。控制器只负责做他们自己状态相关的事情，控制器不改变玩家的状态，因此控制前甚至可以根本不知道玩家的状态。另外一个例子，切换武器。正确的方法是，玩家有一个函数：“SwitchWeapon(Weapon newWeapon)”供GUI调用。GUI不应该维护所有对象的Transform和他们之间的父子关系。
 
所有界面相关的组件，只负责维护和处理他们自己状态相关的数据。例如，显示一个地图，GUI可以根据玩家的位移计算地图的显示。但是，这是游戏状态数据，它不属于GUI。GUI只是显示游戏状态数据，这些数据应该在其他地方维护。地图数据也应该在其他地方维护（例如GameManager）。
 
游戏玩法对象不应该关心GUI。有一个例外是处理游戏暂停（可能是通过控制Time.timeScale，其实这并不是个好主意）。游戏玩法对象应该知道游戏是否暂停。但是，这就是全部了。另外，不要把GUI组件挂到游戏玩法对象上。
 
这么说吧，如果你把所有的GUI类都删了，游戏应该可以正确编译。
 
你还应该达到：在不需要重写游戏逻辑的前提下，重写GUI和输入控制。
 
 

32、分离状态控制和簿记变量

簿记变量只是为了使用起来方便或者提高查找速度，并且可以根据状态控制来覆盖。将两者分离可以简化：
  • 保存游戏状态
  • 调试游戏状态
实现方法之一是为每个游戏逻辑定义一个”SaveData“类，例如：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. [Serializable]  
  2. PlayerSaveData  
  3. {  
  4.    public float health; //public for serialisation, not exposed in inspector  
  5. }   
  6.    
  7. Player  
  8. {  
  9.    //... bookkeeping variables  
  10.    
  11.    //Don’t expose state in inspector. State is not tweakable.  
  12.    private PlayerSaveData playerSaveData;   
  13. }  

33、分离特殊的配置

假设我们有两个敌人，它们使用同一个Mesh，但是有不同的属性设置（例如不同的力量、不同的速度等等）。有很多方法来分离数据。下面是我比较喜欢的一种，特别是对于对象生成或者游戏存档时，会很好用。（属性设置不是状态数据，而是配置数据，所以我们不需要存档他们。当对象加载或者生成是，属性设置会自动加载。）
  • 为每一个游戏逻辑类定义一个模板类。例如，对于敌人，我们来一个“EnemyTemplate”，所有的属性设置变量都保存在这个类中。
  • 在游戏逻辑的类中，定义一个上述模板类型的变量。
  • 制作一个敌人的Prefab，以及两个模板的Prefab：“WeakEnemyTemplate”和"StrongEnemyTemplate"。
  • 在加载或者生成对象是，把模板变量正确的复制。
这种方法可能有点复杂（在一些情况下，可能不需要这样）。
举个例子，最好使用泛型，我们可以这样定义我们的类：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. public class BaseTemplate  
  2. {  
  3.    ...  
  4. }  
  5.    
  6. public class ActorTemplate : BaseTemplate  
  7. {  
  8.    ...  
  9. }  
  10.    
  11. public class Entity<EntityTemplateType> where EntityTemplateType : BaseTemplate  
  12. {  
  13.    EntityTemplateType template;  
  14.    ...  
  15. }  
  16.    
  17. public class Actor : Entity <ActorTemplate>  
  18. {  
  19.    ...  
  20. }  

34、除了显示用的文本，不要使用字符串

特别是不要用字符串作为对象或者prefab等等的ID标识。一个很遗憾的例外是动画系统，需要使用字符串来访问相应的动画。

35、避免使用public的数组

举例说明，不要定义一个武器的数组，一个子弹的数组，一个粒子的数组，这样你的代码看起来像这样：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. public void SelectWeapon(int index)  
  2. {   
  3.    currentWeaponIndex = index;  
  4.    Player.SwitchWeapon(weapons[currentWeapon]);  
  5. }  
  6.    
  7. public void Shoot()  
  8. {  
  9.    Fire(bullets[currentWeapon]);  
  10.    FireParticles(particles[currentWeapon]);     
  11. }  
这在代码中还不是什么大问题，但是在Inspector中设置他们的值的时候，就很难不犯错了。
我们可以定义一个类，来封装这三个变量，然后使用一个它的实例数组：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. [Serializable]  
  2. public class Weapon  
  3. {  
  4.    public GameObject prefab;  
  5.    public ParticleSystem particles;  
  6.    public Bullet bullet;  
  7. }   
这样代码看起来很整洁，但是更重要的是，在Inspector中设置时就不容易犯错了。

36、在结构中避免使用数组

举个例子，一个玩家可以有三种攻击形式，每种使用当前的武器，并发射不同的子弹、产生不同的行为。
你可以把三个子弹作为一个数组，并像下面这样组织逻辑：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. public void FireAttack()  
  2. {  
  3.    /// behaviour  
  4.    Fire(bullets[0]);  
  5. }  
  6.    
  7. public void IceAttack()  
  8. {  
  9.    /// behaviour  
  10.    Fire(bullets[1]);  
  11. }  
  12.    
  13. public void WindAttack()  
  14. {  
  15.    /// behaviour  
  16.    Fire(bullets[2]);  
  17. }   
使用枚举值可以让代码看起来更好一点：
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. public void WindAttack()  
  2. {  
  3.    /// behaviour  
  4.    Fire(bullets[WeaponType.Wind]);  
  5. }   
但是这对Inspector一点也不好。
最好使用单独的变量，并且起一个好的变量名，能够代表他们的内容的含义。使用下面这个类会更整洁。
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. [Serializable]  
  2. public class Bullets  
  3. {  
  4.    public Bullet FireBullet;  
  5.    public Bullet IceBullet;  
  6.    public Bullet WindBullet;  
  7. }  
这里假设没有其他的Fire、Ice、Wind的数据。

37、把数据组织到可序列化的类中，可以让inspector更整洁

有些对象有一大堆可调节的变量，这种情况下在Inspector中找到某个变量简直就成了噩梦。为了简化这种情况，可以使用一下的步骤：
  • 把这些变量分组定义到不同的类中，并让它们声明为public和serializable；
  • 在一个主要的类中，把上述类的实例定义为public成员变量；
  • 不用在Awake或者Start中初始化这些变量，因为Unity会处理好它们；
  • 你可以定义它们的默认值；
这可以把变量分组到Inspector的分组页签中，方便管理。
[csharp] view plain copy
 
 技术分享图片技术分享图片
  1. [Serializable]  
  2. public class MovementProperties //Not a MonoBehaviour!  
  3. {  
  4.    public float movementSpeed;  
  5.    public float turnSpeed = 1; //default provided  
  6. }  
  7.    
  8. public class HealthProperties //Not a MonoBehaviour!  
  9. {  
  10.    public float maxHealth;  
  11.    public float regenerationRate;  
  12. }  
  13.    
  14. public class Player : MonoBehaviour  
  15. {  
  16.    public MovementProperties movementProeprties;  
  17.    public HealthPorperties healthProeprties;  
  18. }  
                                                                                                                                                                 

文本

38、如果你有很多的剧情文本，那么把他们放到一个文件里面。

不要把他们放到Inspector的字段中去编辑。这些需要做到不打开Unity，也不用保存Scene就可以方便的修改。

39、如果你计划实现本地化，那么把你的字符串分离到一个统一的位置。

有很多种方法来实现这点。例如，定义一个文本Class，为每个字符串定义一个public的字符串字段，并把他们的默认值设为英文。其他的语言定义为子类，然后重新初始化这些字段为相应的语言的值。
另外一种更好的技术（适用于文本很大或者支持的语言数量众多），可以读取几个单独的表单，然后提供一些逻辑，根据所选择的语言来选取正确的字符串。
 
                                                                                                                                                                       

测试与调试

40、实现一个图形化的Log用来调试物理、动画和AI。

这可以显著的加速调试工作。详见这里。

41、实现一个HTML的Log。

在很多情况下，日志是非常有用的。拥有一个便于分析的Log（颜色编码、有多个视图、记录屏幕截图等）可以使基于Log的调试变动愉悦。详见这里。

42、实现一个你自己的帧速率计算器。

没有人知道Unity的FPS计算器在做什么，但是肯定不是计算帧速率。实现一个你自己的，让数字符合直觉并可视化。

43、实现一个截屏的快捷键。

很多BUG是图形化的，如果你有一个截图，就很容易报告它。一个理想的系统，应该在PlayerPrefes中保存一个计数，并根据这个计数，使得所有成功保存的截屏文件都不被覆盖掉。截屏文件应该保存在工程文件夹之外，这可以防止人们不小心把它提交到版本库中。

44、实现一个打印玩家坐标的快捷键。

这可以在汇报位置相关的BUG时明确它发生在世界中的什么位置，这可以让Debug容易一些。

45、实现一些Debug选项，用来方便测试。

一些例子：
  • 解锁所有道具；
  • 关闭所有敌人；
  • 关闭GUI；
  • 让玩家无敌；
  • 关闭所有游戏逻辑；

46、为每一个足够小的团队，创建一个适合他们的Debug选项的Prefab。

设置一个用户标识文件，单不要提交到版本库，在游戏运行时读取它。下面是原因：
  • 团队的成员不会因为意外的提交了自己的Debug设置而影响到其他人。
  • 修改Debug设置不需要修改场景。

47、维护一个包含所有游戏元素的场景。

例如，一个场景，包括所有的敌人，所有可以交互的对象等等。这样可以不用玩很久，而进行全面的功能测试。

48、定义一些Debug快捷键常量，并把他们保存在统一的地方。

Debug键通常（方便起见）在一个地方来处理，就像其他的游戏输入一样。为了避免快捷键冲突，在一个中心位置定义所有常量。一种替代方案是，在一个地方处理所有按键输入，不管他是否是Debug键。（负面作用是，这个类可能需要引用更多的其他对象）
 

                                                                                                                                                           

文档

49、为你的设置建立文档。
代码应该拥有最多的文档，但是一些代码之外的东西也必须建立文档。让设计师们通过代码去看如果进行设置是浪费时间。把设置写入文档，可以提高效率（如果文档的版本能够及时更新的话）。
用文档记录下面这些：
  • Layer的使用（碰撞、检测、射线检测——本质上说，什么东西应该在哪个Layer里）；
  • Tag的使用；
  • GUI的depth层级（说什么应该显示在什么之上）；
  • 惯用的处理方式；
  • Prefab结构；
  • 动画Layer。
                                                                                                                                                                                                                                                             

命名规则和目录结构

50、遵从一个命名规范和目录结构，并建立文档

命名和目录结构的一致性，可以方便查找，并明确指出什么东西在哪里。
你很有可能需要创建自己的命名规则和目录结构，下面的例子仅供参考。
 

普遍的命名规则

  1. 名字应该代表它是什么，例如鸟就应该叫做Bird。
  2. 选择可以发音、方便记忆的名字。如果你在制作一个玛雅文化相关的游戏，不要把关卡命名为QuetzalcoatisReturn。
  3. 保持唯一性。如果你选择了一个名字，就坚持用它。
  4. 使用Pascal风格的大小写，例如ComplicatedVerySpecificObject。 不要使用空格，下划线，或者连字符，除了一个例外（详见为同一事物的不同方面命名一节）。
  5. 不要使用版本数字，或者标示他们进度的名词（WIP、final）。
  6. 不要使用缩写：DVamp@W应该写成DarkVampire@Walk。
  7. 使用设计文档中的术语：如果文档中称呼一个动画为Die，那么使用DarkVampire@Die，而不要用DarkVampire@Death。
  8. 保持细节修饰词在左侧：DarkVampire，而不是VampireDark；PauseButton，而不是ButtonPaused。举例说明，在Inspector中查找PauseButton，比所有按钮都以Button开头方便。（很多人倾向于相反的次序，认为那样名字可以自然的分组。然而，名字不是用来分组的，目录才是。名字是用来在同一类对象中可以快速辨识的。）
  9. 为一个序列使用同一个名字，并在这些名字中使用数字。例如PathNode0, PathNode1。永远从0开始，而不是1。
  10. 对于不是序列的情况，不要使用数字。例如 Bird0, Bird1, Bird2，本应该是Flamingo, Eagle, Swallow。
  11. 为临时对象添加双下划线前缀，例如__Player_Backup。

为同一事物的不同方面命名

在核心名称后面添加下划线，后面的部分代表哪个方面。例如
  • GUI中的按钮状态：EnterButton_Active、EnterButton_Inactive
  • 贴图： DarkVampire_Diffuse, DarkVampire_Normalmap
  • 天空盒：JungleSky_Top, JungleSky_North
  • LOD分组：DarkVampire_LOD0, DarkVampire_LOD1

结构

场景组织、工程目录、脚本目录应该使用相似的模式。

目录结构

[plain] view plain copy
 
 技术分享图片技术分享图片
  1. Materials  
  2. GUI  
  3. Effects  
  4. Meshes  
  5.    Actors  
  6.       DarkVampire  
  7.       LightVampire  
  8.       ...  
  9.    Structures  
  10.       Buildings  
  11.       ...  
  12.    Props  
  13.       Plants  
  14.       ...  
  15.    ...  
  16. Plugins  
  17. Prefabs  
  18.    Actors  
  19.    Items  
  20.    ...  
  21. Resources  
  22.    Actors  
  23.    Items  
  24.    ...  
  25. Scenes  
  26.    GUI  
  27.    Levels  
  28.    TestScenes  
  29. Scripts  
  30. Textures  
  31. GUI  
  32. Effects  
  33. ...  

场景结构

[plain] view plain copy
 
 技术分享图片技术分享图片
  1. Cameras  
  2. Dynamic Objects  
  3. Gameplay  
  4.    Actors  
  5.    Items  
  6.    ...  
  7. GUI  
  8.    HUD  
  9.    PauseMenu  
  10.    ...  
  11. Management  
  12. Lights  
  13. World  
  14.    Ground  
  15.    Props  
  16.    Structure  
  17.    ...  

脚本目录结构

[plain] view plain copy
 
 技术分享图片技术分享图片
  1. ThirdParty  
  2.    ...  
  3. MyGenericScripts  
  4.    Debug  
  5.    Extensions  
  6.    Framework  
  7.    Graphics  
  8.    IO  
  9.    Math  
  10.    ...  
  11. MyGameScripts  
  12.    Debug  
  13.    Gameplay  
  14.       Actors  
  15.       Items  
  16.       ...  
  17.    Framework  
  18.    Graphics  
  19.    GUI  
  20.    ...  

 

 


【转载】关于对方法实例化的相关感悟以及unity的50个技巧

标签：参考   发送   并且   isa   evm   uil   effect   bug   区别   

原文地址：http://www.cnblogs.com/cokefenta/p/7910912.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！