using UnityEngine;
|
using UnityEditor;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Reflection;
|
using System;
|
|
/// <summary>
|
/// 扫描 GameObject 中的无效脚本的编辑器工具
|
/// </summary>
|
public class InvalidScriptScanner : EditorWindow
|
{
|
// 扫描模式枚举
|
private enum ScanMode
|
{
|
Basic, // 基本扫描
|
Advanced, // 高级扫描
|
Deep // 深度扫描
|
}
|
|
// 当前扫描模式
|
private static ScanMode currentScanMode = ScanMode.Advanced;
|
|
/// <summary>
|
/// 添加右键菜单项
|
/// </summary>
|
[MenuItem("GameObject/扫描无效脚本", false, 20)]
|
private static void ScanInvalidScripts()
|
{
|
GameObject selectedObject = Selection.activeGameObject;
|
if (selectedObject == null)
|
{
|
EditorUtility.DisplayDialog("错误", "请先选择一个游戏对象", "确定");
|
return;
|
}
|
|
// 使用改进的方法检测无效脚本
|
List<int> invalidScriptIndices = FindInvalidScripts(selectedObject);
|
|
if (invalidScriptIndices.Count > 0)
|
{
|
// 找到了无效脚本
|
int invalidScriptIndex = invalidScriptIndices[0]; // 获取第一个无效脚本
|
Debug.LogWarning($"在游戏对象 '{selectedObject.name}' 上发现无效脚本，位于组件索引 {invalidScriptIndex}");
|
|
// 高亮显示该对象
|
Selection.activeGameObject = selectedObject;
|
|
// 打开检查器并滚动到该组件
|
EditorGUIUtility.PingObject(selectedObject);
|
|
// 显示对话框
|
if (EditorUtility.DisplayDialog("发现无效脚本",
|
$"在游戏对象 '{selectedObject.name}' 上发现无效脚本，位于组件索引 {invalidScriptIndex}。\n\n是否要移除该无效脚本？",
|
"移除", "取消"))
|
{
|
// 移除无效脚本
|
RemoveInvalidScript(selectedObject, invalidScriptIndex);
|
}
|
}
|
else
|
{
|
// 未找到无效脚本，尝试更深层次的扫描
|
if (currentScanMode != ScanMode.Deep)
|
{
|
if (EditorUtility.DisplayDialog("未找到无效脚本",
|
$"在游戏对象 '{selectedObject.name}' 上未发现无效脚本。\n\n是否要尝试深度扫描？这可能需要更长时间。",
|
"深度扫描", "取消"))
|
{
|
// 临时切换到深度扫描模式
|
ScanMode previousMode = currentScanMode;
|
currentScanMode = ScanMode.Deep;
|
|
// 重新扫描
|
invalidScriptIndices = FindInvalidScripts(selectedObject);
|
|
// 恢复之前的扫描模式
|
currentScanMode = previousMode;
|
|
if (invalidScriptIndices.Count > 0)
|
{
|
// 找到了无效脚本
|
int invalidScriptIndex = invalidScriptIndices[0];
|
Debug.LogWarning($"深度扫描：在游戏对象 '{selectedObject.name}' 上发现无效脚本，位于组件索引 {invalidScriptIndex}");
|
|
// 显示对话框
|
if (EditorUtility.DisplayDialog("深度扫描发现无效脚本",
|
$"在游戏对象 '{selectedObject.name}' 上发现无效脚本，位于组件索引 {invalidScriptIndex}。\n\n是否要移除该无效脚本？",
|
"移除", "取消"))
|
{
|
// 移除无效脚本
|
RemoveInvalidScript(selectedObject, invalidScriptIndex);
|
}
|
}
|
else
|
{
|
// 深度扫描也未找到无效脚本
|
EditorUtility.DisplayDialog("深度扫描完成", $"在游戏对象 '{selectedObject.name}' 上未发现无效脚本。", "确定");
|
}
|
}
|
else
|
{
|
// 用户取消深度扫描
|
EditorUtility.DisplayDialog("扫描完成", $"在游戏对象 '{selectedObject.name}' 上未发现无效脚本。", "确定");
|
}
|
}
|
else
|
{
|
// 已经是深度扫描模式
|
EditorUtility.DisplayDialog("扫描完成", $"在游戏对象 '{selectedObject.name}' 上未发现无效脚本。", "确定");
|
}
|
}
|
}
|
|
/// <summary>
|
/// 查找无效脚本
|
/// </summary>
|
/// <param name="gameObject">要检查的游戏对象</param>
|
/// <returns>无效脚本的索引列表</returns>
|
private static List<int> FindInvalidScripts(GameObject gameObject)
|
{
|
List<int> invalidIndices = new List<int>();
|
|
// 检查游戏对象是否有效
|
if (gameObject == null)
|
return invalidIndices;
|
|
// 方法1：使用 SerializedObject 检查组件
|
SerializedObject serializedObject = new SerializedObject(gameObject);
|
SerializedProperty componentsProperty = serializedObject.FindProperty("m_Component");
|
|
for (int i = 0; i < componentsProperty.arraySize; i++)
|
{
|
SerializedProperty componentProperty = componentsProperty.GetArrayElementAtIndex(i);
|
SerializedProperty scriptProperty = componentProperty.FindPropertyRelative("component");
|
|
// 检查脚本引用是否有效
|
if (scriptProperty.objectReferenceValue == null || scriptProperty.objectReferenceInstanceIDValue == 0)
|
{
|
invalidIndices.Add(i);
|
continue;
|
}
|
|
// 额外检查：尝试获取实际组件并检查其类型
|
UnityEngine.Object scriptObject = scriptProperty.objectReferenceValue;
|
if (scriptObject != null)
|
{
|
// 检查脚本是否为缺失或损坏的 MonoScript
|
MonoScript monoScript = scriptObject as MonoScript;
|
if (monoScript != null && monoScript.GetClass() == null)
|
{
|
invalidIndices.Add(i);
|
continue;
|
}
|
|
// 高级扫描：检查组件是否可以正确序列化
|
if (currentScanMode >= ScanMode.Advanced)
|
{
|
try
|
{
|
// 尝试获取组件的类型
|
Type componentType = scriptObject.GetType();
|
if (componentType == null || componentType.ToString().Contains("Missing") || componentType.ToString().Contains("missing"))
|
{
|
invalidIndices.Add(i);
|
continue;
|
}
|
}
|
catch (Exception)
|
{
|
// 如果获取类型时出现异常，可能是无效脚本
|
invalidIndices.Add(i);
|
continue;
|
}
|
}
|
}
|
}
|
|
// 方法2：使用 GetComponents 检查组件（可能会检测到一些方法1漏掉的情况）
|
Component[] components = gameObject.GetComponents<Component>();
|
for (int i = 0; i < components.Length; i++)
|
{
|
if (components[i] == null)
|
{
|
// 检查这个索引是否已经在列表中
|
if (!invalidIndices.Contains(i))
|
{
|
invalidIndices.Add(i);
|
}
|
continue;
|
}
|
|
// 深度扫描：尝试访问组件的一些属性，看是否会抛出异常
|
if (currentScanMode == ScanMode.Deep)
|
{
|
try
|
{
|
// 尝试获取组件的名称和启用状态
|
string name = components[i].name;
|
bool enabled = false;
|
|
// 尝试获取启用状态（只对 Behaviour 类型有效）
|
if (components[i] is Behaviour behaviour)
|
{
|
enabled = behaviour.enabled;
|
}
|
|
// 尝试序列化组件
|
SerializedObject testSerializedObject = new SerializedObject(components[i]);
|
SerializedProperty iterator = testSerializedObject.GetIterator();
|
bool hasProperties = iterator.NextVisible(true);
|
|
// 如果无法获取任何属性，可能是无效脚本
|
if (!hasProperties && !invalidIndices.Contains(i))
|
{
|
invalidIndices.Add(i);
|
}
|
}
|
catch (Exception)
|
{
|
// 如果访问组件属性时出现异常，可能是无效脚本
|
if (!invalidIndices.Contains(i))
|
{
|
invalidIndices.Add(i);
|
}
|
}
|
}
|
}
|
|
// 检查隐藏的游戏对象（即使是隐藏的，也可能包含无效脚本）
|
if (currentScanMode >= ScanMode.Advanced)
|
{
|
// 获取所有隐藏的子对象
|
Transform[] allChildren = gameObject.GetComponentsInChildren<Transform>(true);
|
foreach (Transform child in allChildren)
|
{
|
// 跳过当前对象（因为已经检查过了）
|
if (child.gameObject == gameObject)
|
continue;
|
|
// 如果子对象是隐藏的或者父对象是隐藏的，单独检查它
|
if (!child.gameObject.activeInHierarchy)
|
{
|
// 递归检查隐藏的子对象
|
List<int> childInvalidIndices = FindInvalidScriptsInHiddenObject(child.gameObject);
|
if (childInvalidIndices.Count > 0)
|
{
|
// 如果在隐藏的子对象中找到了无效脚本，添加到结果中
|
// 注意：这里我们只是记录了索引，实际上需要在UI中显示完整路径
|
foreach (int index in childInvalidIndices)
|
{
|
if (!invalidIndices.Contains(index))
|
{
|
invalidIndices.Add(index);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
return invalidIndices;
|
}
|
|
/// <summary>
|
/// 在隐藏的游戏对象中查找无效脚本
|
/// </summary>
|
private static List<int> FindInvalidScriptsInHiddenObject(GameObject gameObject)
|
{
|
List<int> invalidIndices = new List<int>();
|
|
// 检查游戏对象是否有效
|
if (gameObject == null)
|
return invalidIndices;
|
|
// 使用 SerializedObject 检查组件
|
SerializedObject serializedObject = new SerializedObject(gameObject);
|
SerializedProperty componentsProperty = serializedObject.FindProperty("m_Component");
|
|
for (int i = 0; i < componentsProperty.arraySize; i++)
|
{
|
SerializedProperty componentProperty = componentsProperty.GetArrayElementAtIndex(i);
|
SerializedProperty scriptProperty = componentProperty.FindPropertyRelative("component");
|
|
// 检查脚本引用是否有效
|
if (scriptProperty.objectReferenceValue == null || scriptProperty.objectReferenceInstanceIDValue == 0)
|
{
|
invalidIndices.Add(i);
|
}
|
}
|
|
return invalidIndices;
|
}
|
|
/// <summary>
|
/// 移除无效脚本
|
/// </summary>
|
private static void RemoveInvalidScript(GameObject gameObject, int componentIndex)
|
{
|
SerializedObject serializedObject = new SerializedObject(gameObject);
|
SerializedProperty componentsProperty = serializedObject.FindProperty("m_Component");
|
|
if (componentIndex >= 0 && componentIndex < componentsProperty.arraySize)
|
{
|
componentsProperty.DeleteArrayElementAtIndex(componentIndex);
|
serializedObject.ApplyModifiedProperties();
|
Debug.Log($"已从游戏对象 '{gameObject.name}' 移除无效脚本");
|
}
|
}
|
|
/// <summary>
|
/// 递归扫描所有子对象中的无效脚本
|
/// </summary>
|
[MenuItem("GameObject/递归扫描所有无效脚本", false, 21)]
|
private static void ScanAllInvalidScriptsRecursively()
|
{
|
GameObject selectedObject = Selection.activeGameObject;
|
if (selectedObject == null)
|
{
|
EditorUtility.DisplayDialog("错误", "请先选择一个游戏对象", "确定");
|
return;
|
}
|
|
List<KeyValuePair<GameObject, int>> invalidScripts = new List<KeyValuePair<GameObject, int>>();
|
ScanInvalidScriptsInChildren(selectedObject, invalidScripts);
|
|
if (invalidScripts.Count > 0)
|
{
|
// 找到了无效脚本
|
Debug.LogWarning($"在游戏对象 '{selectedObject.name}' 及其子对象中发现 {invalidScripts.Count} 个无效脚本");
|
|
// 显示结果窗口
|
InvalidScriptResultWindow.ShowWindow(invalidScripts);
|
}
|
else
|
{
|
// 未找到无效脚本，尝试更深层次的扫描
|
if (currentScanMode != ScanMode.Deep)
|
{
|
if (EditorUtility.DisplayDialog("未找到无效脚本",
|
$"在游戏对象 '{selectedObject.name}' 及其子对象中未发现无效脚本。\n\n是否要尝试深度扫描？这可能需要更长时间。",
|
"深度扫描", "取消"))
|
{
|
// 临时切换到深度扫描模式
|
ScanMode previousMode = currentScanMode;
|
currentScanMode = ScanMode.Deep;
|
|
// 重新扫描
|
invalidScripts.Clear();
|
ScanInvalidScriptsInChildren(selectedObject, invalidScripts);
|
|
// 恢复之前的扫描模式
|
currentScanMode = previousMode;
|
|
if (invalidScripts.Count > 0)
|
{
|
// 找到了无效脚本
|
Debug.LogWarning($"深度扫描：在游戏对象 '{selectedObject.name}' 及其子对象中发现 {invalidScripts.Count} 个无效脚本");
|
|
// 显示结果窗口
|
InvalidScriptResultWindow.ShowWindow(invalidScripts);
|
}
|
else
|
{
|
// 深度扫描也未找到无效脚本
|
EditorUtility.DisplayDialog("深度扫描完成", $"在游戏对象 '{selectedObject.name}' 及其子对象中未发现无效脚本。", "确定");
|
}
|
}
|
else
|
{
|
// 用户取消深度扫描
|
EditorUtility.DisplayDialog("扫描完成", $"在游戏对象 '{selectedObject.name}' 及其子对象中未发现无效脚本。", "确定");
|
}
|
}
|
else
|
{
|
// 已经是深度扫描模式
|
EditorUtility.DisplayDialog("扫描完成", $"在游戏对象 '{selectedObject.name}' 及其子对象中未发现无效脚本。", "确定");
|
}
|
}
|
}
|
|
/// <summary>
|
/// 递归扫描子对象
|
/// </summary>
|
private static void ScanInvalidScriptsInChildren(GameObject gameObject, List<KeyValuePair<GameObject, int>> results)
|
{
|
// 使用改进的方法检测无效脚本
|
List<int> invalidIndices = FindInvalidScripts(gameObject);
|
|
// 添加到结果列表
|
foreach (int index in invalidIndices)
|
{
|
results.Add(new KeyValuePair<GameObject, int>(gameObject, index));
|
}
|
|
// 递归检查所有子对象（包括隐藏的）
|
foreach (Transform child in gameObject.transform)
|
{
|
ScanInvalidScriptsInChildren(child.gameObject, results);
|
}
|
}
|
|
/// <summary>
|
/// 添加设置菜单项
|
/// </summary>
|
[MenuItem("GameObject/无效脚本扫描设置", false, 22)]
|
private static void ShowSettings()
|
{
|
// 创建设置窗口
|
InvalidScriptScannerSettings.ShowWindow();
|
}
|
}
|
|
/// <summary>
|
/// 无效脚本扫描设置窗口
|
/// </summary>
|
public class InvalidScriptScannerSettings : EditorWindow
|
{
|
private static string[] scanModeNames = { "基本扫描", "高级扫描", "深度扫描" };
|
|
public static void ShowWindow()
|
{
|
InvalidScriptScannerSettings window = GetWindow<InvalidScriptScannerSettings>("无效脚本扫描设置");
|
window.minSize = new Vector2(300, 150);
|
window.Show();
|
}
|
|
private void OnGUI()
|
{
|
EditorGUILayout.LabelField("扫描设置", EditorStyles.boldLabel);
|
EditorGUILayout.Space();
|
|
// 获取当前扫描模式
|
int currentMode = (int)typeof(InvalidScriptScanner).GetField("currentScanMode",
|
BindingFlags.NonPublic | BindingFlags.Static).GetValue(null);
|
|
// 显示扫描模式选择
|
int newMode = EditorGUILayout.Popup("扫描模式", currentMode, scanModeNames);
|
|
// 如果模式发生变化，更新设置
|
if (newMode != currentMode)
|
{
|
typeof(InvalidScriptScanner).GetField("currentScanMode",
|
BindingFlags.NonPublic | BindingFlags.Static).SetValue(null, newMode);
|
}
|
|
EditorGUILayout.Space();
|
EditorGUILayout.HelpBox("扫描模式说明：\n" +
|
"基本扫描：只检查明显的无效脚本\n" +
|
"高级扫描：检查更多类型的无效脚本，包括隐藏对象\n" +
|
"深度扫描：进行最彻底的检查，但可能较慢", MessageType.Info);
|
}
|
}
|
|
/// <summary>
|
/// 无效脚本结果窗口
|
/// </summary>
|
public class InvalidScriptResultWindow : EditorWindow
|
{
|
private List<KeyValuePair<GameObject, int>> invalidScripts;
|
private Vector2 scrollPosition;
|
|
public static void ShowWindow(List<KeyValuePair<GameObject, int>> scripts)
|
{
|
InvalidScriptResultWindow window = GetWindow<InvalidScriptResultWindow>("无效脚本扫描结果");
|
window.invalidScripts = scripts;
|
window.minSize = new Vector2(400, 300);
|
window.Show();
|
}
|
|
private void OnGUI()
|
{
|
if (invalidScripts == null || invalidScripts.Count == 0)
|
{
|
EditorGUILayout.LabelField("没有发现无效脚本");
|
return;
|
}
|
|
EditorGUILayout.LabelField($"发现 {invalidScripts.Count} 个无效脚本", EditorStyles.boldLabel);
|
EditorGUILayout.Space();
|
|
if (GUILayout.Button("移除所有无效脚本"))
|
{
|
if (EditorUtility.DisplayDialog("确认", "确定要移除所有无效脚本吗？", "确定", "取消"))
|
{
|
RemoveAllInvalidScripts();
|
}
|
}
|
|
EditorGUILayout.Space();
|
scrollPosition = EditorGUILayout.BeginScrollView(scrollPosition);
|
|
for (int i = 0; i < invalidScripts.Count; i++)
|
{
|
EditorGUILayout.BeginHorizontal();
|
|
if (GUILayout.Button("选择", GUILayout.Width(60)))
|
{
|
Selection.activeGameObject = invalidScripts[i].Key;
|
EditorGUIUtility.PingObject(invalidScripts[i].Key);
|
}
|
|
EditorGUILayout.ObjectField(invalidScripts[i].Key, typeof(GameObject), true);
|
|
EditorGUILayout.LabelField($"组件索引: {invalidScripts[i].Value}", GUILayout.Width(100));
|
|
if (GUILayout.Button("移除", GUILayout.Width(60)))
|
{
|
RemoveInvalidScript(invalidScripts[i].Key, invalidScripts[i].Value);
|
invalidScripts.RemoveAt(i);
|
i--;
|
GUIUtility.ExitGUI();
|
}
|
|
EditorGUILayout.EndHorizontal();
|
}
|
|
EditorGUILayout.EndScrollView();
|
}
|
|
/// <summary>
|
/// 移除无效脚本
|
/// </summary>
|
private void RemoveInvalidScript(GameObject gameObject, int componentIndex)
|
{
|
SerializedObject serializedObject = new SerializedObject(gameObject);
|
SerializedProperty componentsProperty = serializedObject.FindProperty("m_Component");
|
|
if (componentIndex >= 0 && componentIndex < componentsProperty.arraySize)
|
{
|
componentsProperty.DeleteArrayElementAtIndex(componentIndex);
|
serializedObject.ApplyModifiedProperties();
|
Debug.Log($"已从游戏对象 '{gameObject.name}' 移除无效脚本");
|
}
|
}
|
|
/// <summary>
|
/// 移除所有无效脚本
|
/// </summary>
|
private void RemoveAllInvalidScripts()
|
{
|
// 创建一个副本，因为我们会在循环中修改原始列表
|
var scripts = new List<KeyValuePair<GameObject, int>>(invalidScripts);
|
|
// 按照组件索引从大到小排序，这样删除时不会影响其他组件的索引
|
scripts = scripts.OrderByDescending(pair => pair.Value)
|
.GroupBy(pair => pair.Key)
|
.SelectMany(group => group.OrderByDescending(pair => pair.Value))
|
.ToList();
|
|
foreach (var pair in scripts)
|
{
|
RemoveInvalidScript(pair.Key, pair.Value);
|
}
|
|
invalidScripts.Clear();
|
Repaint();
|
}
|
}
|
