我正在 Unity 2017.2 中开发一个小型 ARPG。
我尝试为我的游戏的 AbilityBluePrint 类实现自定义编辑器。
基本上，AbilityBluePrints 包含在运行时生成能力所需的所有信息。包括一个 Effect[] ScritpableObjects 数组，在使用该能力时触发。
我目前拥有我需要实施和工作的一切，但我认为创建能力非常乏味，原因如下。
假设我有一个效果类 DamagePlusX ：作为伤害修正值的效果。如果我想让这个效果对两个不同的能力有不同的修饰符值，那么我必须在我的资产目录中创建它的两个实例，并手动将每个实例分配给相应能力的 Effect[] 数组。我担心我最终会得到很多效果实例，每个效果实例基本上都有几个不同的整数和浮点数。
因此，我想我会使用一个有点像Unity Adventure Tutorial中的自定义检查器。
这个想法基本上是创建 AbilityBluePrint 的实例，然后使用自定义检查器能够动态实例化 Effects[] 数组中的效果，并能够直接在 AbilityBluePrint 检查器中编辑每个效果的属性。
基本上我想得到一些类似的东西（为可怜的photoshop道歉）：
我试图转换教程中的脚本以满足我的需要，但从昨天开始我一直遇到同样的错误：
NullReferenceException: Object reference not set to an instance of an object
AbilityBluePrintEditor.SubEditorSetup (.EffectEditor editor) (at Assets/Scripts/Editor/AbilityBluePrintEditor.cs:90)
EditorWithSubEditors`2[TEditor,TTarget].CheckAndCreateSubEditors (.TTarget[] subEditorTargets) (at Assets/Scripts/Editor/EditorWithSubEditors.cs:33)
我已经尝试了很多事情，我想知道我正在尝试做的事情是否可以使用可编写脚本的对象。在原始教程中，相当于我的 BluePrintAbility 是 Monobehaviour。
我的代码如下：
我的 BluePrintAbility 类：
[CreateAssetMenu(fileName = "New Ability BluePrint", menuName = "Ability BluePrint")]
public class AbilityBluePrint : ScriptableObject {
public Effect[] effects = new Effect[0];
public string description;
}
我的效果类：
public abstract class Effect : ScriptableObject {
}
我的 DamagePlusX 效果类：
[CreateAssetMenu(fileName = "DamagePlusX",menuName = "Effects/DamagePlusX")]
public class DamagePlusX : Effect
{
[SerializeField]
int modifier;
public void ApplyModifier(){ // some logic}
}
现在是编辑（为长样本道歉，但我现在不知道错误在哪里，但我已经减少了主要课程）：
这是教程中的基本编辑器，我的错误来自：
// This class acts as a base class for Editors that have Editors
// nested within them. For example, the InteractableEditor has
// an array of ConditionCollectionEditors.
// It's generic types represent the type of Editor array that are
// nested within this Editor and the target type of those Editors.
public abstract class EditorWithSubEditors<TEditor, TTarget> : Editor
where TEditor : Editor
where TTarget : Object
{
protected TEditor[] subEditors; // Array of Editors nested within this Editor.
// This should be called in OnEnable and at the start of OnInspectorGUI.
protected void CheckAndCreateSubEditors (TTarget[] subEditorTargets)
{
// If there are the correct number of subEditors then do nothing.
if (subEditors != null && subEditors.Length == subEditorTargets.Length)
return;
// Otherwise get rid of the editors.
CleanupEditors ();
// Create an array of the subEditor type that is the right length for the targets.
subEditors = new TEditor[subEditorTargets.Length];
// Populate the array and setup each Editor.
for (int i = 0; i < subEditors.Length; i++)
{
subEditors[i] = CreateEditor (subEditorTargets[i]) as TEditor;
SubEditorSetup (subEditors[i]); // ERROR comes inside this function HERE !!!!
}
}
// This should be called in OnDisable.
protected void CleanupEditors ()
{
// If there are no subEditors do nothing.
if (subEditors == null)
return;
// Otherwise destroy all the subEditors.
for (int i = 0; i < subEditors.Length; i++)
{
DestroyImmediate (subEditors[i]);
}
// Null the array so it's GCed.
subEditors = null;
}
// This must be overridden to provide any setup the subEditor needs when it is first created.
protected abstract void SubEditorSetup (TEditor editor);
}
[CustomEditor(typeof(AbilityBluePrint)), CanEditMultipleObjects]
public class AbilityBluePrintEditor : EditorWithSubEditors<EffectEditor, Effect>
{
private AbilityBluePrint blueprint; // Reference to the target.
private SerializedProperty effectsProperty; //represents the array of effects.
private Type[] effectTypes; // All the non-abstract types which inherit from Effect. This is used for adding new Effects.
private string[] effectTypeNames; // The names of all appropriate Effect types.
private int selectedIndex; // The index of the currently selected Effect type.
private const float dropAreaHeight = 50f; // Height in pixels of the area for dropping scripts.
private const float controlSpacing = 5f; // Width in pixels between the popup type selection and drop area.
private const string effectsPropName = "effects"; // Name of the field for the array of Effects.
private readonly float verticalSpacing = EditorGUIUtility.standardVerticalSpacing;
// Caching the vertical spacing between GUI elements.
private void OnEnable()
{
// Cache the target.
blueprint = (AbilityBluePrint)target;
// Cache the SerializedProperty
effectsProperty = serializedObject.FindProperty(effectsPropName);
// If new editors for Effects are required, create them.
CheckAndCreateSubEditors(blueprint.effects);
// Set the array of types and type names of subtypes of Reaction.
SetEffectNamesArray();
}
public override void OnInspectorGUI()
{
// Pull all the information from the target into the serializedObject.
serializedObject.Update();
// If new editors for Reactions are required, create them.
CheckAndCreateSubEditors(blueprint.effects);
DrawDefaultInspector();
// Display all the Effects.
for (int i = 0; i < subEditors.Length; i++)
{
if (subEditors[i] != null)
{
subEditors[i].OnInspectorGUI();
}
}
// If there are Effects, add a space.
if (blueprint.effects.Length > 0)
{
EditorGUILayout.Space();
EditorGUILayout.Space();
}
//Shows the effect selection GUI
SelectionGUI();
if (GUILayout.Button("Add Effect"))
{
}
// Push data back from the serializedObject to the target.
serializedObject.ApplyModifiedProperties();
}
private void OnDisable()
{
// Destroy all the subeditors.
CleanupEditors();
}
// This is called immediately after each ReactionEditor is created.
protected override void SubEditorSetup(EffectEditor editor)
{
// Make sure the ReactionEditors have a reference to the array that contains their targets.
editor.effectsProperty = effectsProperty; //ERROR IS HERE !!!
}
private void SetEffectNamesArray()
{
// Store the Effect type.
Type effectType = typeof(Effect);
// Get all the types that are in the same Assembly (all the runtime scripts) as the Effect type.
Type[] allTypes = effectType.Assembly.GetTypes();
// Create an empty list to store all the types that are subtypes of Effect.
List<Type> effectSubTypeList = new List<Type>();
// Go through all the types in the Assembly...
for (int i = 0; i < allTypes.Length; i++)
{
// ... and if they are a non-abstract subclass of Effect then add them to the list.
if (allTypes[i].IsSubclassOf(effectType) && !allTypes[i].IsAbstract)
{
effectSubTypeList.Add(allTypes[i]);
}
}
// Convert the list to an array and store it.
effectTypes = effectSubTypeList.ToArray();
// Create an empty list of strings to store the names of the Effect types.
List<string> reactionTypeNameList = new List<string>();
// Go through all the Effect types and add their names to the list.
for (int i = 0; i < effectTypes.Length; i++)
{
reactionTypeNameList.Add(effectTypes[i].Name);
}
// Convert the list to an array and store it.
effectTypeNames = reactionTypeNameList.ToArray();
}
private void SelectionGUI()
{
// Create a Rect for the full width of the inspector with enough height for the drop area.
Rect fullWidthRect = GUILayoutUtility.GetRect(GUIContent.none, GUIStyle.none, GUILayout.Height(dropAreaHeight + verticalSpacing));
// Create a Rect for the left GUI controls.
Rect leftAreaRect = fullWidthRect;
// It should be in half a space from the top.
leftAreaRect.y += verticalSpacing * 0.5f;
// The width should be slightly less than half the width of the inspector.
leftAreaRect.width *= 0.5f;
leftAreaRect.width -= controlSpacing * 0.5f;
// The height should be the same as the drop area.
leftAreaRect.height = dropAreaHeight;
// Create a Rect for the right GUI controls that is the same as the left Rect except...
Rect rightAreaRect = leftAreaRect;
// ... it should be on the right.
rightAreaRect.x += rightAreaRect.width + controlSpacing;
// Display the GUI for the type popup and button on the left.
TypeSelectionGUI(leftAreaRect);
}
private void TypeSelectionGUI(Rect containingRect)
{
// Create Rects for the top and bottom half.
Rect topHalf = containingRect;
topHalf.height *= 0.5f;
Rect bottomHalf = topHalf;
bottomHalf.y += bottomHalf.height;
// Display a popup in the top half showing all the reaction types.
selectedIndex = EditorGUI.Popup(topHalf, selectedIndex, effectTypeNames);
// Display a button in the bottom half that if clicked...
if (GUI.Button(bottomHalf, "Add Selected Effect"))
{
// ... finds the type selected by the popup, creates an appropriate reaction and adds it to the array.
Debug.Log(effectTypes[selectedIndex]);
Type effectType = effectTypes[selectedIndex];
Effect newEffect = EffectEditor.CreateEffect(effectType);
Debug.Log(newEffect);
effectsProperty.AddToObjectArray(newEffect);
}
}
}
public abstract class EffectEditor : Editor
{
public bool showEffect = true; // Is the effect editor expanded?
public SerializedProperty effectsProperty; // Represents the SerializedProperty of the array the target belongs to.
private Effect effect; // The target Reaction.
private const float buttonWidth = 30f; // Width in pixels of the button to remove this Reaction from the ReactionCollection array.
private void OnEnable()
{
// Cache the target reference.
effect = (Effect)target;
// Call an initialisation method for inheriting classes.
Init();
}
// This function should be overridden by inheriting classes that need initialisation.
protected virtual void Init() { }
public override void OnInspectorGUI()
{
Debug.Log("attempt to draw effect inspector");
// Pull data from the target into the serializedObject.
serializedObject.Update();
EditorGUILayout.BeginVertical(GUI.skin.box);
EditorGUI.indentLevel++;
DrawDefaultInspector();
EditorGUI.indentLevel--;
EditorGUILayout.EndVertical();
// Push data back from the serializedObject to the target.
serializedObject.ApplyModifiedProperties();
}
public static Effect CreateEffect(Type effectType)
{
// Create a reaction of a given type.
return (Effect) ScriptableObject.CreateInstance(effectType);
}
}
[CustomEditor(typeof(DamagePlusXEditor))]
public class DamagePlusXEditor : EffectEditor {}
