/// <summary>
/// Returns a copy of this node.
/// <param name = "newOwner">The owner of the new node.</param>
/// <returns>The copy of the node.</returns>
/// </summary>
public override ActionNode Copy(INodeOwner newOwner)
{
// Copy node
var copy = base.Copy(newOwner);
var branchCopy = copy as BranchNode;
// The copy is a valid branch?
if (branchCopy != null)
{
// Copy children
var copiedChildren = new List <ActionNode>();
for (int i = 0; i < this.children.Length; i++)
{
var copiedChild = this.children[i].Copy(newOwner);
if (copiedChild != null)
{
copiedChildren.Add(copiedChild);
}
}
branchCopy.SetChildren(copiedChildren.ToArray());
}
return(copy);
}
public void SetOwner(INodeOwner owner)
{
Owner = owner;
foreach (var node in GenNodes)
{
node.SetOwner(this);
}
}
public void AddChildToStart(ConditionalDialogueNode child, string child_id, INodeOwner owner)
{
if (child.ParentNode == null)
{
child.ParentNode = Nodes[0];
}
child.NodeID = child_id;
child.SetNodeOwner(owner);
Nodes.Add(child);
Nodes[0].Add(child);
}
/// <summary>
/// Creates and returns a node of the supplied type.
/// <param name="type">The node type to be created.</param>
/// <param name="gameObject">The game object that owns the node.</param>
/// <param name="nodeOwner">The node owner (usually a InternalStateBehaviour).</param>
/// <returns>Returns new created node.</returns>
/// </summary>
public static ActionNode CreateInstance(Type type, GameObject gameObject, INodeOwner nodeOwner)
{
var newNode = Activator.CreateInstance(type) as ActionNode;
if (newNode != null)
{
newNode.name = type.Name;
newNode.Init(gameObject, nodeOwner);
if (Application.isEditor)
{
newNode.Reset();
}
}
return(newNode);
}
/// <summary>
/// Returns a copy of this node.
/// <param name = "newOwner">The owner of the new node.</param>
/// <returns>The copy of the node.</returns>
/// </summary>
public virtual ActionNode Copy(INodeOwner newOwner)
{
// Copy node
var copy = newOwner.AddNode(GetType());
// Copy SerializedFields
var fields = NodeSerialization.GetSerializedFields(copy.GetType());
for (int i = 0; i < fields.Length; i++)
{
// Do not copy the instanceID field
if (fields[i].Name != "instanceID")
{
fields[i].SetValue(copy, fields[i].GetValue(this));
}
}
return(copy);
}
/// <summary>
/// Returns a copy of this node.
/// <param name = "newOwner">The owner of the new node.</param>
/// <returns>The copy of the node.</returns>
/// </summary>
public override ActionNode Copy (INodeOwner newOwner) {
// Copy node
var copy = base.Copy(newOwner);
var branchCopy = copy as BranchNode;
// The copy is a valid branch?
if (branchCopy != null) {
// Copy children
var copiedChildren = new List<ActionNode>();
for (int i = 0; i < this.children.Length; i++) {
var copiedChild = this.children[i].Copy(newOwner);
if (copiedChild != null)
copiedChildren.Add(copiedChild);
}
branchCopy.SetChildren(copiedChildren.ToArray());
}
return copy;
}
/// <summary>
/// Marks the state dirty flag; if the state is a prefab instance then disconnects the m_NodeSerialization property.
/// <param name="owner">The target owner to mark the dirty flag.</param>
/// </summary>
public static void SetDirty(INodeOwner owner)
{
var unityObject = owner as UnityEngine.Object;
if (!Application.isPlaying && unityObject != null)
{
// its a prefab Instance?
var prefabType = UnityEditor.PrefabUtility.GetPrefabType(unityObject);
if (prefabType != UnityEditor.PrefabType.None && prefabType != UnityEditor.PrefabType.Prefab && prefabType != UnityEditor.PrefabType.ModelPrefab)
{
PropertyUtility.DisconnectPropertyFromPrefab(unityObject, "m_NodeSerialization");
// Workaround to disconnect ArraySize properties
owner.Clear();
PrefabUtility.RecordPrefabInstancePropertyModifications(unityObject);
}
}
owner.SaveNodes();
EditorUtility.SetDirty(unityObject);
}
/// <summary>
/// Paste the state in StateUtility.stateToPaste in the supplied fsm.
/// <param name="gameObject">The target gameObject.</param>
/// <param name="originalStates">The original states.</param>
/// <param name="parent">Optionally parent for the cloned states.</param>
/// </summary>
public static void CloneStates(GameObject gameObject, InternalStateBehaviour[] originalStates, ParentBehaviour parent)
{
if (gameObject != null && originalStates != null && originalStates.Length > 0)
{
var orginalClone = new Dictionary <InternalStateBehaviour, InternalStateBehaviour>();
var originalFsm = parent != null ? originalStates[0].parent as InternalStateMachine : null;
var newFsm = parent as InternalStateMachine;
InternalStateBehaviour startState = null, concurrentState = null;
InternalAnyState anyState = null;
// Copy blackboard data?
var newBlackboard = gameObject.GetComponent <InternalBlackboard>();
if (newBlackboard == null)
{
// Get the original blackboard
InternalBlackboard originalBlackboard = originalStates[0].GetComponent <InternalBlackboard>();
#if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
Undo.RegisterSceneUndo("Paste State");
// Create the new blacbkoard
newBlackboard = gameObject.AddComponent(originalBlackboard.GetType()) as InternalBlackboard;
#else
// Create the new blacbkoard
newBlackboard = gameObject.AddComponent(originalBlackboard.GetType()) as InternalBlackboard;
if (newBlackboard != null)
{
Undo.RegisterCreatedObjectUndo(newBlackboard, "Paste State");
}
#endif
// Copy serialized values
EditorUtility.CopySerialized(originalBlackboard, newBlackboard);
}
foreach (InternalStateBehaviour state in originalStates)
{
// Don't clone AnyState in StateMachines
if (state != null && (newFsm == null || !(state is InternalAnyState) || newFsm.anyState == null))
{
#if UNITY_4_0_0 || UNITY_4_1 || UNITY_4_2
Undo.RegisterSceneUndo("Paste State");
// Create a new state
var newState = gameObject.AddComponent(state.GetType()) as InternalStateBehaviour;
#else
// Create a new state
var newState = gameObject.AddComponent(state.GetType()) as InternalStateBehaviour;
if (newState != null)
{
Undo.RegisterCreatedObjectUndo(newState, "Paste State");
}
#endif
if (newState != null)
{
// Store state
orginalClone.Add(state, newState);
// Copy serialized values
EditorUtility.CopySerialized(state, newState);
// Update blackboard
if (state.gameObject != newState.gameObject)
{
var serialObj = new SerializedObject(newState);
serialObj.FindProperty("m_Blackboard").objectReferenceValue = newBlackboard;
serialObj.ApplyModifiedProperties();
serialObj.Dispose();
}
// Update the AnyState, StartState and ConcurrentState
if (newState is InternalStateMachine)
{
var fsm = newState as InternalStateMachine;
fsm.startState = null;
fsm.concurrentState = null;
fsm.anyState = null;
}
EditorUtility.SetDirty(newState);
// Set new parent
if (parent != null)
{
newState.parent = parent;
// Update position
if (parent == state.parent)
{
newState.position += new Vector2(20f, 20f);
}
}
else
{
newState.parent = null;
}
// Saves state and sets dirty flag
INodeOwner nodeOwner = newState as INodeOwner;
if (nodeOwner != null)
{
nodeOwner.LoadNodes();
StateUtility.SetDirty(nodeOwner);
}
else
{
EditorUtility.SetDirty(newState);
}
// Try to get the StartState, AnyState and ConcurrentState
if (originalFsm != null)
{
if (originalFsm.startState == state)
{
startState = newState;
}
if (anyState == null)
{
anyState = newState as InternalAnyState;
}
if (originalFsm.concurrentState == state)
{
concurrentState = newState;
}
}
}
}
}
// Set StartState, AnyState and ConcurrentState
if (newFsm != null)
{
if (newFsm.startState == null)
{
newFsm.startState = startState;
}
if (newFsm.anyState == null)
{
newFsm.anyState = anyState;
}
if (newFsm.concurrentState == null)
{
newFsm.concurrentState = concurrentState;
}
EditorUtility.SetDirty(newFsm);
}
// Try to update the transitions' destination
foreach (KeyValuePair <InternalStateBehaviour, InternalStateBehaviour> pair in orginalClone)
{
InternalStateBehaviour state = pair.Key;
InternalStateBehaviour newState = pair.Value;
// Update the newState transition
for (int i = 0; i < newState.transitions.Length && i < state.transitions.Length; i++)
{
// The original destination is valid?
if (state.transitions[i].destination != null && orginalClone.ContainsKey(state.transitions[i].destination))
{
newState.transitions[i].destination = orginalClone[state.transitions[i].destination];
}
}
if (newState is ParentBehaviour)
{
var stateAsParent = state as ParentBehaviour;
// Removes the newState from the children state to avoid an infinite loop
List <InternalStateBehaviour> children = stateAsParent.states;
if (children.Contains(newState))
{
children.Remove(newState);
}
StateUtility.CloneStates(newState.gameObject, children.ToArray(), newState as ParentBehaviour);
}
EditorUtility.SetDirty(newState);
}
EditorUtility.SetDirty(gameObject);
}
}
public void SetNodeOwner(INodeOwner owner)
{
NodeOwner = owner;
}
/// <summary>
/// Call this to store the nodes.
/// <param name="nodes">The list of nodes to be saved.</param>
/// <param name="gameObject">The target game object.</param>
/// <param name="nodeOwner">The node owner.</param>
/// </summary>
public void SaveNodes (ActionNode[] nodes, GameObject gameObject, INodeOwner nodeOwner) {
m_ResaveNodes = false;
// Validate parameters
if (nodes == null || gameObject == null || nodeOwner == null)
return;
// Clear data
Clear();
// Update game object, tree and blackboard
m_GameObject = gameObject;
m_NodeOwner = nodeOwner;
m_Blackboard = gameObject.GetComponent<InternalBlackboard>();
// Save nodes
for (int i = 0; i < nodes.Length; i++)
Save (nodes[i]);
m_NodeFieldStartIndex.Add(m_NextFieldIndex);
}
/// <summary>
/// Call this to load nodes.
/// <param name="gameObject">The target game object.</param>
/// <param name="nodeOwner">The node owner.</param>
/// </summary>
public ActionNode[] LoadNodes (GameObject gameObject, INodeOwner nodeOwner) {
var nodes = new List<ActionNode>();
m_BranchChildren = new Dictionary<int, List<ActionNode>>();
// Validate parameters
if (gameObject == null || nodeOwner == null )
return nodes.ToArray();
m_GameObject = gameObject;
m_NodeOwner = nodeOwner;
m_Blackboard = gameObject.GetComponent<InternalBlackboard>();
// Goes through all node types and creates an instance
for (int i = 0; i < m_NodeTypes.Count; i++) {
ActionNode node = Load(nodes, i);
// It's a valid node?
if (node != null)
nodes.Add(node);
}
// Add children to branch
foreach (var pair in m_BranchChildren) {
var branch = nodes[pair.Key] as BranchNode;
if (branch == null || !branch.SetChildren(m_BranchChildren[pair.Key].ToArray()))
nodeOwner.HierarchyChanged();
}
m_BranchChildren = null;
return nodes.ToArray();
}
/// <summary>
/// Creates and returns a node of the supplied type.
/// <param name="type">The node type to be created.</param>
/// <param name="gameObject">The game object that owns the node.</param>
/// <param name="nodeOwner">The node owner (usually a InternalStateBehaviour).</param>
/// <returns>Returns new created node.</returns>
/// </summary>
public static ActionNode CreateInstance (Type type, GameObject gameObject, INodeOwner nodeOwner) {
var newNode = Activator.CreateInstance(type) as ActionNode;
if (newNode != null) {
newNode.name = type.Name;
newNode.Init(gameObject, nodeOwner);
if (Application.isEditor)
newNode.Reset();
}
return newNode;
}
/// <summary>
/// Returns a copy of this node.
/// <param name = "newOwner">The owner of the new node.</param>
/// <returns>The copy of the node.</returns>
/// </summary>
public virtual ActionNode Copy (INodeOwner newOwner) {
// Copy node
var copy = newOwner.AddNode(GetType());
// Copy SerializedFields
var fields = NodeSerialization.GetSerializedFields(copy.GetType());
for (int i = 0; i < fields.Length; i++) {
// Do not copy the instanceID field
if (fields[i].Name != "instanceID")
fields[i].SetValue(copy, fields[i].GetValue(this));
}
return copy;
}
/// <summary>
/// Node initialization.
/// Set the game object and the owner of the node.
/// <param name="gameObject">The game object that owns the node.</param>
/// <param name="nodeOwner">The state that owns the node.</param>
/// </summary>
public void Init (GameObject gameObject, INodeOwner nodeOwner) {
m_Self = gameObject;
m_Owner = nodeOwner;
}
/// <summary>
/// Node initialization.
/// Set the game object and the owner of the node.
/// <param name="gameObject">The game object that owns the node.</param>
/// <param name="nodeOwner">The state that owns the node.</param>
/// </summary>
public void Init(GameObject gameObject, INodeOwner nodeOwner)
{
m_Self = gameObject;
m_Owner = nodeOwner;
}
/// <summary>
/// Clears all data in the object.
/// </summary>
public void Clear () {
m_NodeTypes.Clear();
m_NodeTypeHash.Clear();
m_NodeFieldStartIndex.Clear();
m_UnityObjectValue.Clear();
m_IntValue.Clear();
m_FloatValue.Clear();
m_StringValue.Clear();
m_CurveValue.Clear();
m_GenericFieldType.Clear();
m_GenericFieldHash.Clear();
m_GenericFieldSize.Clear();
m_FieldIndex.Clear();
m_FieldType.Clear();
m_FieldPath.Clear();
m_BranchIndex.Clear();
m_NextFieldIndex = 0;
m_GameObject = null;
m_NodeOwner = null;
m_Blackboard = null;
}
/// <summary>
/// Marks the state dirty flag; if the state is a prefab instance then disconnects the m_NodeSerialization property.
/// <param name="owner">The target owner to mark the dirty flag.</param>
/// </summary>
public static void SetDirty (INodeOwner owner) {
var unityObject = owner as UnityEngine.Object;
if (!Application.isPlaying && unityObject != null) {
// its a prefab Instance?
var prefabType = UnityEditor.PrefabUtility.GetPrefabType(unityObject);
if (prefabType != UnityEditor.PrefabType.None && prefabType != UnityEditor.PrefabType.Prefab && prefabType != UnityEditor.PrefabType.ModelPrefab) {
PropertyUtility.DisconnectPropertyFromPrefab(unityObject, "m_NodeSerialization");
// Workaround to disconnect ArraySize properties
owner.Clear();
PrefabUtility.RecordPrefabInstancePropertyModifications(unityObject);
}
}
owner.SaveNodes();
EditorUtility.SetDirty(unityObject);
}
public void AddChild(ConditionalDialogueNode parent, ConditionalDialogueNode child, string child_id, INodeOwner owner)
{
if (Nodes.Count == 2)
{
if (child.ParentNode == null)
{
child.ParentNode = Nodes[0];
}
child.NodeID = child_id;
child.SetNodeOwner(owner);
Nodes.Add(child);
Nodes[0].Add(child);
}
else
{
int index = SearchNodeIndexByValue(parent.Value);
if (index == -1)
{
throw new Exception("No such parent node!");
}
if (child.ParentNode != null)
{
//Multiple Parents
child.MultipleParents = true;
child.SetNodeOwner(owner);
child.AddParent(parent);
child.NodeID = child_id;
Nodes[index].Add(child);
}
else
{
child.NodeID = child_id;
child.SetNodeOwner(owner);
child.AddParent(parent);
Nodes.Add(child);
Nodes[index].Add(child);
//SingleParent
}
}
}
