/// <summary>
/// Unity callback called when playmode changes.
/// Un-/Registered in the OnDisable/OnEnable.
/// Updates the m_PlayModeState member and the activeParent.
/// Creates or destroy the guiCallback.
/// </summary>
void OnPlaymodeChange()
{
// Update playmode
if (EditorApplication.isPlaying)
{
m_PlayModeState = !EditorApplication.isPlayingOrWillChangePlaymode ? PlayModeState.SwitchingToEditor : PlayModeState.Playing;
}
else
{
m_PlayModeState = EditorApplication.isPlayingOrWillChangePlaymode ? PlayModeState.SwitchingToPlaymode : PlayModeState.Editor;
}
// if (/*!EditorApplication.isPaused &&*/ (EditorApplication.isPlayingOrWillChangePlaymode && EditorApplication.isPlaying || !EditorApplication.isPlayingOrWillChangePlaymode && !EditorApplication.isPlaying)) {
if (m_PlayModeState == PlayModeState.Playing || m_PlayModeState == PlayModeState.Editor)
{
var parentID = m_SerializedParentID;
activeParent = null;
activeParent = EditorUtility.InstanceIDToObject(parentID) as ParentBehaviour;
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
}
// Create guiCallback?
if (m_PlayModeState == PlayModeState.SwitchingToEditor && m_GUICallback == null)
{
m_GUICallback = this.CreateGUICallback();
}
// Destroy guiCallback?
else if (m_PlayModeState == PlayModeState.SwitchingToPlaymode && m_GUICallback != null)
{
DestroyImmediate(m_GUICallback.gameObject, true);
}
}
void CheckAllFiles(GUICallback callback = null)
{
// The shared context for all script analysis.
var analysisContext = new Yarn.Analysis.Context();
// We shouldn't try to perform program analysis if
// any of the files fails to compile, because that
// analysis would be performed on incomplete data.
bool shouldPerformAnalysis = true;
// How many files have we finished checking?
int complete = 0;
// Let's get started!
// First, ensure that we're looking at all of the scripts.
UpdateYarnScriptList();
// Next, compile each one.
foreach (var result in checkResults)
{
// Attempt to compile the file. Record any compiler messages.
CheckerResult.State state;
var messages = ValidateFile(result.script, analysisContext, out state);
result.state = state;
result.messages = messages;
// Don't perform whole-program analysis if any file failed to compile
if (result.state != CheckerResult.State.Passed)
{
shouldPerformAnalysis = false;
}
// We're done with it; if we have a callback to call after
// each file is validated, do so.
complete++;
if (callback != null)
{
callback(complete, checkResults.Count);
}
}
var results = new List <Yarn.Analysis.Diagnosis>();
if (shouldPerformAnalysis)
{
var scriptAnalyses = analysisContext.FinishAnalysis();
results.AddRange(scriptAnalyses);
}
var environmentAnalyses = AnalyseEnvironment();
results.AddRange(environmentAnalyses);
diagnoses = results;
}
/// </summary>
/// Register OnGUI node in editor mode.
/// </summary>
void RegisterEditorOnGUI()
{
if (!EditorApplication.isPlayingOrWillChangePlaymode)
{
if (m_ActionState.onGUINode != null && ((m_ActionState.isRoot && BehaviourWindow.activeState == null) || m_ActionState == BehaviourWindow.activeState))
{
GUICallback.ResetCallbacks();
GUICallback.onGUI += m_ActionState.onGUINode.EditorOnTick;
}
}
}
/// <summary>
/// Unity callback called after compilation.
/// Un-/Registered in the OnDisable/OnEnable.
/// Recreates guiCallback if the Unity is in the editor mode.
/// </summary>
void OnDelayCall()
{
switch (m_PlayModeState)
{
case PlayModeState.Editor:
if (m_GUICallback == null)
{
m_GUICallback = this.CreateGUICallback();
}
break;
}
}
/// <summary>
/// Creates the GUI dialog to show
/// </summary>
/// <param name='callback'>
/// Callback. when intialize is over
/// </param>
/// <param name='style'>
/// Style.
/// </param>
/// <param name='_dele'>
/// _dele function callback when dialog confirm button is clicked
/// </param>
public void CreateGUIDialog(GUICallback <GUIDialog> callback, EDialogStyle style, GUIDialog.ConfirmDelegate _dele = null)
{
CreateWindow <GUIDialog>(delegate(GUIDialog gui){
gui.InitializeGUI(style);
gui.SetConfirmBtnDelegate(_dele);
if (callback != null)
{
callback(gui);
}
});
}
/// <summary>
/// A Unity callback called when the window is loaded.
/// </summary>
void OnEnable()
{
// Set window name
this.name = Print.GetLogo() + " Behaviour";
// Update singleton instance
Instance = this;
// Update NotVisible value
BehaviourWindow.s_NotVisible = this.m_NotVisible;
// Set playmode state
if (m_PlayModeState == PlayModeState.Unknow)
{
m_PlayModeState = EditorApplication.isPlaying ? PlayModeState.Playing : PlayModeState.Editor;
// The guiCallback is null and the unity application is not playing or changing playmode?
if (m_GUICallback == null && !EditorApplication.isPlayingOrWillChangePlaymode)
{
// Create game object
GameObject go = EditorUtility.CreateGameObjectWithHideFlags("GUI Object", HideFlags.HideAndDontSave, new System.Type[] { typeof(GUICallback) });
// Get GUICallback component
m_GUICallback = go.GetComponent <GUICallback>();
}
}
// Set callbacks
activeParentChanged += OnParentSelectionChange;
activeNodeChanged += OnNodeSelectionChange;
EditorApplication.playmodeStateChanged += OnPlaymodeChange;
EditorApplication.delayCall += OnDelayCall;
LoadSceneUtility.onLoadScene += this.OnLoadScene;
BehaviourMachinePrefs.preferencesChanged += this.Repaint;
// The minimum size of this window
base.minSize = new Vector2(200f, 150f);
// Forces selection update
activeParent = EditorUtility.InstanceIDToObject(m_SerializedParentID) as ParentBehaviour;
OnSelectionChange();
activeNodeID = m_SerializedNodeID;
// Set guiController
SetParentGUI();
// Automatically repaint window whenever the scene has change
base.autoRepaintOnSceneChange = true;
}
/// <summary>
/// A Unity callback called when the object goes out of scope.
/// </summary>
private void OnDisable()
{
BehaviourWindow.activeNodeChanged -= this.ActiveNodeChanged;
// Unregister the callback for visual debugging
ActionNode.onNodeTick -= OnNodeTick;
// Register Update
if (Application.isPlaying)
{
EditorApplication.update -= this.Update;
}
else
{
GUICallback.ResetCallbacks();
}
}
/// <summary>
/// Creates the window.
/// </summary>
/// <returns>
/// return true if the window create otherwise false because creating or created
/// </returns>
/// <param name='callback'>
/// If set to <c>true</c> callback.
/// </param>
/// <typeparam name='T'>
/// the window type (GUIWindow's child class)
/// </typeparam>
public bool CreateWindow <T>(GUICallback <T> callback) where T : GUIWindow
{
if (_mTempWindowList.IndexOf(typeof(T)) != -1)
{
return(false);
}
T ui = GetGUIWindow <T>();
if (null != ui)
{
if (null != callback)
{
callback(ui);
}
return(false);
}
_mTempWindowList.Add(typeof(T));
CreateGUIWindow <T>
(typeof(T).Name, false,
delegate(T gui)
{
_mTempWindowList.Remove(typeof(T));
gui.InitializeGUI();
if (null != callback)
{
callback(gui);
}
}
);
return(true);
}
public ModalDialogue(string question, GUICallback yesCallback, GUICallback noCallback)
{
this.Question = question;
this.YesCallback = yesCallback;
this.NoCallback = noCallback;
}
public ModalDialogue(string question, GUICallback yesCallback, GUICallback noCallback)
{
this.Question = question;
this.YesCallback = yesCallback;
this.NoCallback = noCallback;
}
/// <summary>
/// Unity callback to draw a custom inspector.
/// </summary>
public override void OnInspectorGUI()
{
// Create styles?
if (s_Styles == null)
{
s_Styles = new InternalActionStateEditor.Styles();
}
// Workaround to update nodes
if (Event.current.type == EventType.ValidateCommand && Event.current.commandName == "UndoRedoPerformed")
{
GUIUtility.hotControl = 0;
GUIUtility.keyboardControl = 0;
m_ActionState.LoadNodes();
UpdateActiveNode();
return;
}
// Reload nodes?
if (m_ActionState.isDirty)
{
m_ActionState.LoadNodes();
UpdateActiveNode();
}
// Register OnGUI node?
if (!Application.isPlaying && m_ActionState.onGUINode != null && !GUICallback.HasCallbacks())
{
this.RegisterEditorOnGUI();
}
#if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
EditorGUIUtility.LookLikeInspector();
#endif
// Draw default inspector
DrawDefaultInspector();
// Shows the node editor?
bool showNodeEditor = m_ActionState.parent == null || BehaviourWindow.activeState == m_ActionState;
// Draw Action List
if (m_NodeList == null)
{
// m_NodeList = new ReorderableList(this.serializedObject, this.serializedObject.FindProperty("m_UpdateActions"));
m_NodeList = new ReorderableList(m_ActionState.GetNodes(), typeof(ActionNode));
m_NodeList.drawHeaderCallback += delegate(Rect rect) { EditorGUI.LabelField(rect, "Nodes"); };
m_NodeList.drawElementCallback += DrawNode;
m_NodeList.onAddCallback += this.OnAddNode;
m_NodeList.onRemoveCallback += this.OnRemoveSelectedNode;
m_NodeList.onSelectCallback += this.OnSelectNode;
m_NodeList.onReorderCallback += this.OnReorderNode;
// Select the active node
UpdateActiveNode();
#if !UNITY_4_0_0 && !UNITY_4_1 && !UNITY_4_2 && !UNITY_4_3
m_NodeList.list = m_ActionState.GetNodes();
m_NodeList.DoLayoutList();
#else
this.Repaint();
#endif
}
else if (showNodeEditor)
{
m_NodeList.list = m_ActionState.GetNodes();
m_NodeList.DoLayoutList();
}
if (showNodeEditor)
{
GUILayout.Space(6f);
#if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
EditorGUIUtility.LookLikeControls();
#endif
// Get the active node
ActionNode activeNode = m_ActionState.isRoot ? this.GetActiveNode() : BehaviourWindow.activeNode;
// Draw node properties
if (m_NodeEditor != null)
{
// Is there an active node?
if (activeNode != null && activeNode.owner as InternalActionState == m_ActionState)
{
// It's an Update node
var oldGUIEnabled = GUI.enabled;
GUI.enabled = !(activeNode is Update);
m_NodeEditor.DrawNode(activeNode);
GUI.enabled = oldGUIEnabled;
GUILayout.Space(4f);
}
}
// Copy/Paste/Cut/Duplicate/Delete keyboard shortcuts
Event current = Event.current;
if (current.type == EventType.ValidateCommand)
{
// Use event to call event ExecuteCommand
if (current.commandName == "Paste")
{
ActionNode[] nodesToPaste = ActionStateUtility.GetActionsAndConditions(BehaviourTreeUtility.nodeToPaste != null ? new ActionNode[] { BehaviourTreeUtility.nodeToPaste } : new ActionNode[0]);
if (nodesToPaste.Length > 0)
{
current.Use();
}
}
if (activeNode != null)
{
if (current.commandName == "Copy")
{
current.Use();
}
else if (current.commandName == "Duplicate")
{
current.Use();
}
else if (current.commandName == "Delete")
{
current.Use();
}
else if (current.commandName == "Cut")
{
current.Use();
}
}
}
else if (Event.current.type == EventType.ExecuteCommand)
{
if (current.commandName == "Paste")
{
ActionNode[] nodesToPaste = ActionStateUtility.GetActionsAndConditions(BehaviourTreeUtility.nodeToPaste != null ? new ActionNode[] { BehaviourTreeUtility.nodeToPaste } : new ActionNode[0]);
ActionStateUtility.PasteNodes(m_ActionState, nodesToPaste);
}
else if (current.commandName == "Copy")
{
BehaviourTreeUtility.nodeToPaste = activeNode;
}
else if (current.commandName == "Duplicate")
{
ActionStateUtility.PasteNodes(m_ActionState, new ActionNode[] { activeNode });
}
else if (current.commandName == "Delete")
{
this.OnDestroyNode(activeNode);
}
else if (current.commandName == "Cut")
{
BehaviourTreeUtility.nodeToPaste = activeNode;
this.OnDestroyNode(activeNode);
}
}
}
}