public void OnDrop(Inventory inv, bool tss, int slot, int amount, bool dbui, Vector3?pos)
{
if ((inv.interactiable & InventoryController.DropInvFlags) != InventoryController.DropInvFlags)
{
return;
}
if (optionalOnDropBehaviour == null)
{
InventoryHandler.DropItemEventArgs dea = new InventoryHandler.DropItemEventArgs(inv, tss, slot, this, amount, dbui, pos.GetValueOrDefault(), true);
InventoryHandler.current.Broadcast(BroadcastEventType.DropItem, dea: dea);
}
else
{
InventoryHandler.DropItemEventArgs dea = new InventoryHandler.DropItemEventArgs(inv, tss, slot, this, amount, dbui, pos.GetValueOrDefault(), false);
object[] tmp = new object[2] {
this, dea
};
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
MethodInfo monoMethod = optionalOnDropBehaviour.GetClass().GetMethod("OnDropItem", flags);
if (monoMethod == null)
{
Debug.LogError($"The script provided ({optionalOnDropBehaviour.name}) on item {itemName} does not contain, or its not accesible, the expected function OnDropItem.\n Check if this function exists and if the provided script derives from DropBehaviour");
}
else
{
monoMethod.Invoke(Activator.CreateInstance(optionalOnDropBehaviour.GetClass()), tmp);
}
}
}
private void Start()
{
if (platformTopCollider != null && topCustomAction != null && topCustomAction.GetClass().IsSubclassOf(typeof(OnCollisionCustomAction)))
{
OnCollisionCustomAction customAction = platformTopCollider.AddComponent(topCustomAction.GetClass()) as OnCollisionCustomAction;
customAction.InitializeData();
}
if (platformBottomCollider != null && bottomCustomAction != null && bottomCustomAction.GetClass().IsSubclassOf(typeof(OnCollisionCustomAction)))
{
OnCollisionCustomAction customAction = platformBottomCollider.AddComponent(bottomCustomAction.GetClass()) as OnCollisionCustomAction;
customAction.InitializeData();
}
if (platformRightCollider != null && rightCustomAction != null && rightCustomAction.GetClass().IsSubclassOf(typeof(OnCollisionCustomAction)))
{
OnCollisionCustomAction customAction = platformRightCollider.AddComponent(rightCustomAction.GetClass()) as OnCollisionCustomAction;
customAction.InitializeData();
}
if (platformLeftCollider != null && leftCustomAction != null && leftCustomAction.GetClass().IsSubclassOf(typeof(OnCollisionCustomAction)))
{
OnCollisionCustomAction customAction = platformLeftCollider.AddComponent(leftCustomAction.GetClass()) as OnCollisionCustomAction;
customAction.InitializeData();
}
}
/// <summary>
/// Returns a collection of MonoScripts whose class inherits from T.
/// <returns>A collection of MonoScript whose class inherits from T.</returns>
/// </summary>
public static MonoScript[] GetScripts <T>()
{
// Try get loaded MonoScripts
MonoScript[] loadedScripts = null;
if (s_LoadedScripts.TryGetValue(typeof(T), out loadedScripts))
{
return(loadedScripts);
}
// Load all MonoScripts
Resources.LoadAll(string.Empty, typeof(MonoScript));
var scripts = new List <MonoScript>();
// Get all MonoScripts
foreach (UnityEngine.Object obj in Resources.FindObjectsOfTypeAll(typeof(MonoScript)))
{
MonoScript mono = obj as MonoScript;
if (mono != null && mono.GetClass() != null && mono.GetClass().IsSubclassOf(typeof(T)) && !mono.GetClass().IsAbstract)
{
scripts.Add(mono);
}
}
// Sort scripts by name
scripts.Sort((MonoScript s1, MonoScript s2) => s1.GetClass().ToString().CompareTo(s2.GetClass().ToString()));
// Add scripts to dictionary
loadedScripts = scripts.ToArray();
s_LoadedScripts.Add(typeof(T), loadedScripts);
return(loadedScripts);
}
static public void CustomizeInterface()
{
string path = "";
string name = "";
MonoScript renderedScript = null;
if (Selection.activeObject is MonoScript)
{
renderedScript = (MonoScript)Selection.activeObject;
name = renderedScript.GetClass().ToString();
path = AssetDatabase.GetAssetPath(renderedScript);
if (File.Exists(path))
{
path = Path.GetDirectoryName(path);
}
path = path + "/Editor/";
name += "Interface";
}
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
Utils.CreateEditorScript(renderedScript.GetClass(), path);
}
private void OnGUI()
{
EditorGUILayout.BeginVertical();
EditorGUILayout.LabelField("Drag a ScriptableObject to create an instance of it");
EditorGUILayout.Space();
_scriptable = EditorGUILayout.ObjectField(_scriptable, typeof(MonoScript), true) as MonoScript;
EditorGUILayout.Space();
if (_scriptable == null || _scriptable.GetClass() == null || !_scriptable.GetClass().BaseType.Equals(typeof(ScriptableObject)))
{
_scriptable = null;
EditorGUILayout.LabelField("You need a subclass of a ScriptableObject");
}
else if (GUILayout.Button("Create Instance") && _scriptable != null)
{
ScriptableObjectUtility.CreateAsset(_scriptable.GetClass());
}
EditorGUILayout.Space();
EditorGUILayout.EndVertical();
}
/// <summary>
/// 建立 Scriptable Asset
/// </summary>
/// <returns>是否成功建立</returns>
public bool CreateScriptableAssets(string scriptableScriptName, string scriptableAssetName)
{
_config = ClientDataBaseManager.Instance.m_config;
MonoScript script = AssetDatabase.LoadAssetAtPath <MonoScript>(_config.GetScriptableScriptsPath() + scriptableScriptName);
if (script == null || script.GetClass() == null)
{
Debug.LogError(string.Format("Scriptable Script is Null. [Path:{0}]", _config.GetScriptableScriptsPath() + scriptableScriptName));
return(false);
}
string path = _config.GetScriptableAssetPath() + scriptableAssetName;
UtilityEditor.CreateFolder(_config.GetScriptableAssetPath());
Object _Object = ScriptableObject.CreateInstance(script.GetClass());
AssetDatabase.CreateAsset(_Object, path);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
Debug.Log(string.Format("[Scriptable Asset] is Create.\nFile:[{0}] Path:[{1}]", scriptableAssetName, _config.GetScriptableAssetPath()));
//資料讀取
ScriptableObjectBase scriptableObjectBase = AssetDatabase.LoadAssetAtPath <ScriptableObjectBase>(path);
return(scriptableObjectBase.LoadGameTable(true));
}
private void MoveFiles()
{
if (scriptFolder == null || editorFolder == null)
{
ShowNotification(new GUIContent("Folders not specified. Please assing a valid folder"), 3);
return;
}
string appPath = Application.dataPath.Replace("Assets", "") + AssetDatabase.GetAssetPath(scriptFolder);
string[] assetPaths = Directory.GetFiles(appPath, "*.cs", SearchOption.AllDirectories);
int assetsMoved = 0;
try
{
for (int i = 0; i < assetPaths.Length; i++)
{
if (EditorUtility.DisplayCancelableProgressBar("Moving editor scripts", "Moving folders... (" + i + "/" + assetPaths.Length + ")", (float)i / (float)assetPaths.Length))
{
break;
}
string path = AssetDatabase.GetAssetPath(scriptFolder) + assetPaths[i].Replace(appPath, "").Replace('\\', '/');
string targetPath = AssetDatabase.GetAssetPath(editorFolder) + assetPaths[i].Replace(appPath, "").Replace('\\', '/');
Object asset = AssetDatabase.LoadAssetAtPath(path, typeof(Object));
if (asset is MonoScript)
{
MonoScript script = asset as MonoScript;
if (script != null && script.GetClass() != null &&
(script.GetClass().IsSubclassOf(typeof(UnityEditor.Editor)) ||
script.GetClass().IsSubclassOf(typeof(EditorWindow)) ||
script.GetClass().IsSubclassOf(typeof(PropertyDrawer)) ||
IsParentClassEditor(script)))
{
CreatePath(targetPath);
string error = AssetDatabase.ValidateMoveAsset(path, targetPath);
if (string.IsNullOrEmpty(error))
{
Undo.RegisterCompleteObjectUndo(script, "Move " + script.name + " to editor folder");
AssetDatabase.MoveAsset(path, targetPath);
assetsMoved++;
}
else
{
Debug.LogError(error);
}
}
}
}
}
catch (System.Exception e) { Debug.LogException(e); }
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
ShowNotification(new GUIContent("Moved " + assetsMoved + " files to editor folder"), 3);
EditorUtility.ClearProgressBar();
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
if (property.propertyType == SerializedPropertyType.String)
{
Rect r = EditorGUI.PrefixLabel(position, label);
Rect labelRect = position;
labelRect.xMax = r.xMin;
position = r;
m_ViewString = GUI.Toggle(labelRect, m_ViewString, "", "label");
if (m_ViewString)
{
property.stringValue = EditorGUI.TextField(position, property.stringValue);
return;
}
MonoScript script = null;
if (!string.IsNullOrEmpty(property.stringValue))
{
string typeName = Type.GetType(property.stringValue).FullName;
if (!string.IsNullOrEmpty(typeName))
{
m_ScriptCache.TryGetValue(typeName, out script);
if (script == null)
{
GUI.color = Color.red;
}
}
}
script = (MonoScript)EditorGUI.ObjectField(position, script, typeof(MonoScript), false);
if (GUI.changed)
{
if (script != null)
{
var type = script.GetClass();
MonoScriptAttribute attr = (MonoScriptAttribute)attribute;
if (attr.type != null && !attr.type.IsAssignableFrom(type))
{
type = null;
}
if (type != null)
{
var targetClass = script.GetClass();
property.stringValue = targetClass.AssemblyQualifiedName;
}
else
{
Debug.LogWarning("The script file " + script.name + " doesn't contain an assignable class");
}
}
else
{
property.stringValue = "";
}
}
}
else
{
GUI.Label(position, "The MonoScript attribute can only be used on string variables");
}
}
public virtual void OnUse(Inventory inv, int slot)
{
InventoryHandler.UseItemEventArgs uea = new InventoryHandler.UseItemEventArgs(inv, this, slot);
if (onUseFunc == null)
{
InventoryHandler.current.Broadcast(BroadcastEventType.UseItem, uea: uea);
return;
}
object[] tmp = new object[2] {
this, uea
};
BindingFlags flags = BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly;
MethodInfo monoMethod = onUseFunc.GetClass().GetMethod("OnUse", flags);
if (monoMethod == null)
{
Debug.LogError($"The script provided ({onUseFunc.name}) on item {itemName} does not contain, or its not accesible, the expected function OnUse.\n Check if this function exists and if the provided script derives from IUsable");
}
else
{
monoMethod.Invoke(Activator.CreateInstance(onUseFunc.GetClass()), tmp);
}
InventoryHandler.current.Broadcast(BroadcastEventType.UseItem, uea: uea);
}
void DoJob()
{
GUI.color = Color.white;
msg = "Search for : <color=#00ffffff>" + searchType.GetClass().ToString() + "</color>" + "\n";
//Get all the scenes in project
var scenesGUIDs = AssetDatabase.FindAssets("t:Scene", new[] { "Assets/" });
msg += "Search in : " + scenesGUIDs.Length + " scenes" + "\n";
if (result == null)
{
result = new Dictionary <string, int>();
}
result.Clear();
for (int i = 0; i < scenesGUIDs.Length; i++)
{
//Open the scene
string scenePath = AssetDatabase.GUIDToAssetPath(scenesGUIDs[i]);
OpenScene(scenePath);
Scene currentScene = EditorSceneManager.GetSceneAt(0);
EditorSceneManager.SetActiveScene(currentScene);
//See if the scene contains the component we search for
Object[] subsceneObjs = UnityEngine.GameObject.FindObjectsOfType(searchType.GetClass(), true);
if (subsceneObjs.Length > 0)
{
result.Add(scenePath, subsceneObjs.Length);
}
}
msg += "Result : " + result.Count + " scenes" + "\n";
msg += "\n";
}
// Use this for initialization
void Start()
{
/*RuntimeScript = ScriptObject.GetComponent(CompileTimeScript.GetClass()); //The non-generic form of GetComponent, mothafuckaz!
* if (RuntimeScript == null)
* {
* //Good to put in a hard assert here
* Debug.LogError(name + ": Scriptobject " + ScriptObject.name + " doesn't contain script type " + CompileTimeScript.name + "!");
* }*/
//Cache MethodInfos for the register methods, so we can make them generic later without repeating these particular reflection calls.
_displayRegisterMethod = typeof(OldConsole).GetMethod("RegisterDisplayHelper", BindingFlags.Instance | BindingFlags.NonPublic);
_controlRegisterMethod = typeof(OldConsole).GetMethod("RegisterControlHelper", BindingFlags.Instance | BindingFlags.NonPublic);
_displayDeregisterMethod = typeof(OldConsole).GetMethod("DeregisterDisplayHelper", BindingFlags.Instance | BindingFlags.NonPublic);
_controlDeregisterMethod = typeof(OldConsole).GetMethod("DeregisterControlHelper", BindingFlags.Instance | BindingFlags.NonPublic);
#region Hard-Coded Test
if (false) //Change to turn this test on/off.
{
//Hard-code adding a float function to make sure this works conceptually.
MethodInfo[] methods = CompileTimeScript.GetClass().GetMethods(BindingFlags.Instance | BindingFlags.Public); //Should be the last time we call CompileTimeScript at runtime.
//TEST: Find the base type of TestDisplay, cached for faster iteration when we loop through methods.
Type disptype = (Type)TestDisplay.GetType().GetMethod("get_DisplayType").Invoke(TestDisplay, null);
Type conttype = (Type)TestControl.GetType().GetMethod("get_ControlType").Invoke(TestControl, null);
//Skip any that aren't from the user-created component
int validmethods = 0;
for (int i = 0; i < methods.Length; i++)
{
if (methods[i].DeclaringType == typeof(MonoBehaviour) || methods[i].DeclaringType.IsAssignableFrom(typeof(MonoBehaviour)))
{
continue;
}
validmethods++;
//Now for the actual hard-coded testing.
//Display:
if (methods[i].ReturnType == disptype)
{
RegisterIntoDisplay(methods[i], TestDisplay, disptype);
}
//Control:
ParameterInfo[] paramarray = methods[i].GetParameters();
if (paramarray.Length == 1 && paramarray[0].ParameterType == conttype)
{
print("Found control match: " + conttype + " in " + methods[i].Name);
RegisterIntoControl(methods[i], TestControl, conttype);
}
}
}
#endregion
//Actually set up the bindings
SetUpBindings();
}
public List <MonoScript> Importable(string folderName)
{
string[] filePaths = Directory.GetFiles(Application.dataPath + "/" + folderName, "*.cs", SearchOption.AllDirectories);
List <MonoScript> ret = new List <MonoScript>();
List <string> existingInspector = new List <string>();
foreach (string f in filePaths)
{
string file = f.Replace(Application.dataPath, "");
file = "Assets" + file.Replace("\\", "/");
Object obj = AssetDatabase.LoadAssetAtPath(file, typeof(MonoScript));
if (obj == null)
{
continue;
}
MonoScript m = (MonoScript)obj;
Type cl = m.GetClass();
if (cl != null && cl.IsSubclassOf(typeof(Editor)))
{
object[] attributes = m.GetClass().GetCustomAttributes(typeof(CustomEditor), false);
foreach (CustomEditor ce in attributes)
{
FieldInfo p = ce.GetType().GetField("m_InspectedType");
Type type = p.GetValue(ce) as Type;
existingInspector.Add(type.Name);
}
}
}
foreach (string f in filePaths)
{
string file = f.Replace(Application.dataPath, "");
file = "Assets" + file.Replace("\\", "/");
Object obj = AssetDatabase.LoadAssetAtPath(file, typeof(MonoScript));
if (obj == null)
{
continue;
}
MonoScript m = (MonoScript)obj;
Type cl = m.GetClass();
if (cl != null && CanHaveEditor(cl) && !existingInspector.Contains(m.name))
{
ret.Add(m);
}
}
return(ret);
}
/// <summary>
/// 批量添加组件
/// </summary>
public void AddThisTagComponents()
{
GameObject[] a = GameObject.FindGameObjectsWithTag(tag);
foreach (var item in a)
{
if (item.GetComponent(_scriptObj.GetClass()) == null)
{
item.AddComponent(_scriptObj.GetClass());
}
}
}
static bool ValidateInit()
{
if (Selection.activeObject.GetType() == typeof(MonoScript))
{
MonoScript script = (MonoScript)Selection.activeObject;
if (script.GetClass().BaseType == typeof(Node))
{
previewNodeType = script.GetClass();
return(true);
}
}
return(false);
}
string[] FindSceneObjectsWith(MonoScript component)
{
string[] allAssets = AssetDatabase.GetAllAssetPaths();
System.Type componentType = component.GetClass();
List <string> searchResult = new List <string>();
objRefs = new List <Object>();
for (int i = 0; i < allAssets.Length; i++)
{
string currentPath = allAssets[i];
if (currentPath.StartsWith("Assets")) //Remove annoying warning in editor for incorrect paths
{
System.Type assetType = AssetDatabase.GetMainAssetTypeAtPath(currentPath);
// In open Scenes
if (assetType == typeof(SceneAsset))
{
SceneAsset scene = AssetDatabase.LoadAssetAtPath <SceneAsset>(currentPath);
Scene s = SceneManager.GetSceneByName(scene.name);
if (s.IsValid())
{
GameObject[] rootObjects = s.GetRootGameObjects();
for (int j = 0; j < rootObjects.Length; j++)
{
GameObject currentObject = rootObjects[j];
var scripts = currentObject.GetComponentsInChildren(componentType, true);
if (scripts.Length > 0)
{
for (int k = 0; k < scripts.Length; k++)
{
GameObject currentSubObject = scripts[k].gameObject;
string r = string.Format("'{0}' {1} has '{2}' attached, in '{3}'",
currentSubObject.name,
(currentSubObject.GetInstanceID() == currentObject.GetInstanceID() ? "" : " (parent: " + currentObject.name + ")"),
component.GetClass().ToString(),
s.name);
searchResult.Add(r);
}
}
}
}
}
}
}
return(searchResult.ToArray());
}
void DrawRule <T>(string caption, ref bool ruleEnabled, ref string ruleClassName) where T : ScriptableObject
{
GUI.enabled = true;
EditorGUILayout.BeginHorizontal();
GUILayout.Space(CATEGORY_SPACING);
ruleEnabled = EditorGUILayout.ToggleLeft(caption, ruleEnabled);
GUI.enabled = ruleEnabled;
MonoScript script = null;
if (ruleClassName != null)
{
var rule = instanceCache.GetInstance(ruleClassName) as ScriptableObject;
if (rule != null)
{
script = MonoScript.FromScriptableObject(rule);
}
}
var oldScript = script;
script = EditorGUILayout.ObjectField(script, typeof(MonoScript), false) as MonoScript;
if (oldScript != script && script != null)
{
ruleClassName = script.GetClass().FullName;
}
else if (script == null)
{
ruleClassName = null;
}
EditorGUILayout.EndHorizontal();
GUI.enabled = true;
}
//detect is the object that draged is valid
private static bool IsDragValid()
{
//loop through the object is dragged that make sure it is an reaction
for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
{
//first must be monoscript otherwise invalid
if (DragAndDrop.objectReferences [i].GetType() != typeof(MonoScript))
{
return(false);
}
//determine is it a reaction
MonoScript script = DragAndDrop.objectReferences[i] as MonoScript;
//find the type of the script
Type scriptType = script.GetClass();
//check the typr is not reaction return false
if (!scriptType.IsSubclassOf(typeof(Reaction)))
{
return(false);
}
//if the type is abstract alse return false
if (scriptType.IsAbstract)
{
return(false);
}
}
return(true);
}
//Looks through all the objects being dragged and checks that they (all) inherit from Action
private static bool IsDragValid()
{
for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
{
//not a script
if (DragAndDrop.objectReferences[i].GetType() != typeof(MonoScript))
{
return(false);
}
MonoScript script = DragAndDrop.objectReferences[i] as MonoScript;
Type scriptType = script.GetClass();
if (!scriptType.IsSubclassOf(typeof(Action)))
{
return(false);
}
//Abstracts need their own check
if (scriptType.IsAbstract)
{
return(false);
}
}
return(true);
}
public void OnGUI()
{
script = (MonoScript)EditorGUILayout.ObjectField("Type", script, typeof(MonoScript), false);
if (script)
{
var type = script.GetClass();
// sometimes this happens after code reload
if (type == null)
{
return;
}
if (type.canBeUnityComponent())
{
if (GUILayout.Button("Select all"))
{
Selection.objects = findObjects(type, true);
}
if (GUILayout.Button("Select only exact type"))
{
Selection.objects = findObjects(type, false);
}
}
else
{
GUILayout.Label("Type should be MonoBehaviour, Component or interface");
}
}
}
private static void DraggingAndDropping(Rect dropArea, ReactionCollectionEditor editor)
{
// Cache the current event.
Event currentEvent = Event.current;
// If the drop area doesn't contain the mouse then return.
if (!dropArea.Contains(currentEvent.mousePosition))
{
return;
}
switch (currentEvent.type)
{
// If the mouse is dragging something...
case EventType.DragUpdated:
// ... change whether or not the drag *can* be performed by changing the visual mode of the cursor based on the IsDragValid function.
DragAndDrop.visualMode = IsDragValid() ? DragAndDropVisualMode.Link : DragAndDropVisualMode.Rejected;
// Make sure the event isn't used by anything else.
currentEvent.Use();
break;
// If the mouse was dragging something and has released...
case EventType.DragPerform:
// ... accept the drag event.
DragAndDrop.AcceptDrag();
// Go through all the objects that were being dragged...
for (int i = 0; i < DragAndDrop.objectReferences.Length; i++)
{
// ... and find the script asset that was being dragged...
MonoScript script = DragAndDrop.objectReferences[i] as MonoScript;
if (script != null)
{
// ... then find the type of that Reaction...
Type reactionType = script.GetClass();
// ... and create a Reaction of that type and add it to the array.
Reaction newReaction = ReactionEditor.CreateReaction(reactionType);
editor.reactionsProperty.AddToObjectArray(newReaction);
continue;
}
// ... or find the reaction asset that was being dragged...
Reaction reaction = DragAndDrop.objectReferences[i] as Reaction;
if (reaction != null)
{
editor.reactionsProperty.AddToObjectArray(reaction);
}
}
// Make sure the event isn't used by anything else.
currentEvent.Use();
break;
}
}
/// <summary>
/// Let the user select what king of scriptable object it desires to create and do so
/// </summary>
public void OnGUI()
{
Setup();
// Check if we can go directly to the Scriptable Object instance
if (selectedScriptableTypeIdx == 0)
{
MonoScript script = Selection.activeObject as MonoScript;
if (script != null)
{
int idx = typesList.IndexOf(script.GetClass());
if (idx > 0)
{
selectedScriptableTypeIdx = idx;
}
}
}
EditorGUILayout.BeginVertical();
{
selectedScriptableTypeIdx = EditorGUILayout.Popup(selectedScriptableTypeIdx, names.ToArray <string>());
EditorGUILayout.Space();
EditorGUI.BeginDisabledGroup(selectedScriptableTypeIdx == 0);
if (GUILayout.Button("Enter"))
{
ScriptableObjectMenu.CreateItem(typesList[selectedScriptableTypeIdx]);
Close();
}
EditorGUI.EndDisabledGroup();
}
EditorGUILayout.EndVertical();
}
// --------------------------------------------------------------
// Helpers
// --------------------------------------------------------------
/// <summary>
/// Get a list of methods.
/// </summary>
/// <param name="monoScript">The script that contains the methods.</param>
/// <returns>A list of methods.</returns>
private static List <MethodInfo> AddMethodsToList(MonoScript monoScript)
{
// exit early if there is no monoscript
if (monoScript == null)
{
return(new List <MethodInfo>());
}
// get the class attached to the monoscript
System.Type classType = monoScript.GetClass();
// exit early of there is no class attached to monoscript
if (classType == null)
{
return(new List <MethodInfo>());
}
// get the methods attached to the class
List <MethodInfo> list = new List <MethodInfo>();
MethodInfo[] methodInfo = classType.GetMethods(BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.Instance);
for (int i = 0; i < methodInfo.Length; i++)
{
if (!methodInfo[i].IsSpecialName)
{
list.Add(methodInfo[i]);
}
}
return(list);
}
void Init(MonoScript script)
{
m_Initialized = true;
Type scriptClass = script.GetClass();
// find public SyncVars to show (user doesn't want protected ones to be shown in inspector)
foreach (FieldInfo field in scriptClass.GetFields(BindingFlags.Public | BindingFlags.Instance))
{
Attribute[] fieldMarkers = (Attribute[])field.GetCustomAttributes(typeof(SyncVarAttribute), true);
if (fieldMarkers.Length > 0)
{
m_SyncVarNames.Add(field.Name);
}
}
int numSyncLists = scriptClass.GetFields().Count(
field => field.FieldType.BaseType != null &&
field.FieldType.BaseType.Name.Contains("SyncList"));
if (numSyncLists > 0)
{
m_ShowSyncLists = new bool[numSyncLists];
}
m_SyncsAnything = SyncsAnything(scriptClass);
}
public override void OnInspectorGUI()
{
if (target == null || !(target is MonoScript))
{
return;
}
MonoScript script = target as MonoScript;
System.Type t = script.GetClass();
if (t == null)
{
return;
}
if (!(t.IsSubclassOf(typeof(Editor)) || t.IsSubclassOf(typeof(EditorWindow))))
{
if (t.IsSubclassOf(typeof(ScriptableObject)) && GUILayout.Button("Create Asset"))
{
ScriptableObjectUtility.CreateAsset(t);
}
}
showCode = EditorGUILayout.Foldout(showCode, "Code");
if (showCode)
{
EditorGUILayout.TextArea(script.text);
}
}
/// <summary>
/// Determines if the script is a singleton scriptable object.
/// </summary>
/// <returns><c>true</c> if is singleton; otherwise, <c>false</c>.</returns>
/// <param name="script">Script.</param>
private static bool IsSingleton(MonoScript script)
{
Type toCheck = script.GetClass();
Type generic = typeof(SingletonHydraScriptableObject <>);
return(ReflectionUtils.IsSubclassOfRawGeneric(generic, toCheck));
}
private bool IsValidImport(object[] objects)
{
if (objects.Length == 0)
{
return(false);
}
for (int i = 0; i < objects.Length; i++)
{
object importObject = objects[i];
if (importObject.GetType() == typeof(MonoScript))
{
MonoScript monoScriptImport = (MonoScript)importObject;
Type monoScriptType = monoScriptImport.GetClass();
if (monoScriptType == null ||
!typeof(BehaviourNode).IsAssignableFrom(monoScriptType))
{
return(false);
}
}
else if (!typeof(IBehaviourGraph).IsAssignableFrom(importObject.GetType()))
{
return(false);
}
}
return(true);
}
private void OnEnable()
{
MonoScript script = (MonoScript)target;
m_type = script.GetClass();
m_isScriptableObject = IsScriptableObject(m_type);
}
public static void CreateAssetFromSelectedScript()
{
MonoScript script = Selection.objects[0] as MonoScript;
string path;
if (IsSingleton(script))
{
path = GetSingletonPath(script);
}
else
{
path = EditorUtility.SaveFilePanel("Save location", "Assets", "New " + script.name, "asset");
}
if (string.IsNullOrEmpty(path))
{
return;
}
// Get project relative path and ensure path is within project
string projectRelative = FileUtil.GetProjectRelativePath(path);
if (string.IsNullOrEmpty(projectRelative))
{
EditorUtility.DisplayDialog("Error", "Please select somewhere within your assets folder.", "OK");
return;
}
CreateAsset(script.GetClass(), path);
}
private void ProcessSourceFile(string sourceFile, string sourceIncludeTemplate, List <string> sourceIncludes, Dictionary <string, string> sourceGuidToClassName)
{
// Get the entry for the map
string guid = AssetDatabase.AssetPathToGUID(sourceFile);
MonoScript asset = AssetDatabase.LoadAssetAtPath <MonoScript>(sourceFile);
string classNameToAdd = null;
if (asset != null)
{
classNameToAdd = asset.GetClass()?.FullName;
}
sourceGuidToClassName.Add(guid, classNameToAdd);
string normalized = Utilities.GetNormalizedPath(sourceFile);
if (normalized.StartsWith("Packages"))
{
normalized = "PackagesCopy" + normalized.Substring("Packages".Length);
}
string sourcePath = normalized;
if (sourcePath.StartsWith("Assets"))
{
sourcePath = "..\\" + sourcePath;
}
sourceIncludes.Add(Utilities.ReplaceTokens(sourceIncludeTemplate, new Dictionary <string, string>()
{
{ "##RELATIVE_SOURCE_PATH##", $"..\\{sourcePath}" },
{ "##PROJECT_LINK_PATH##", normalized.Replace("Assets\\", string.Empty) }
}));
}
public static void DisableGizmoIcon(MonoScript script)
{
//----Doesnt Work----//
Type AnnotationUtility = Type.GetType("UnityEditor.AnnotationUtility, UnityEditor");
var scriptClass = script.GetClass();
MethodInfo getAnnotations = AnnotationUtility.GetMethod("GetAnnotations", BindingFlags.Static | BindingFlags.NonPublic);
MethodInfo setIconEnabled = AnnotationUtility.GetMethod("SetIconEnabled", BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Static);
MethodInfo setGizmoEnabled = AnnotationUtility.GetMethod("SetGizmoEnabled", BindingFlags.Static | BindingFlags.NonPublic);
var annotations = getAnnotations.Invoke(null, null);
foreach (object annotation in (IEnumerable)annotations)
{
Type annotationType = annotation.GetType();
FieldInfo classIdField = annotationType.GetField("classID", BindingFlags.Public | BindingFlags.Instance);
FieldInfo scriptClassField = annotationType.GetField("scriptClass", BindingFlags.Public | BindingFlags.Instance);
if (classIdField != null && scriptClassField != null)
{
//int classId = (int)classIdField.GetValue(annotation);
string _scriptClass = (string)scriptClassField.GetValue(annotation);
if (_scriptClass == scriptClass.Name)
{
Debug.Log(_scriptClass);
int classId = (int)classIdField.GetValue(annotation);
setIconEnabled.Invoke(null, new object[] { classId, _scriptClass, 0 });
}
}
}
}
