using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEditor;
using UnityEditor.Experimental.GraphView;
using UnityEngine.UIElements;
using UnityEditor.UIElements;
using System.IO;
public class FSMGraphView : GraphView
{
private Edge selectedCache;
public AIGraphWindow instance;
public string savePath = "Assets/ScriptableObjects/FSM/";
private Dictionary<Edge,Transition> edgeTransitionTupleList = new Dictionary<Edge, Transition>();
private List<StateNode> statesToRemove = new List<StateNode>();
private List<Edge> edgesToRemove = new List<Edge>();
public FSMGraphView()
{
AddGridBackground();
AddManipulators();
graphViewChanged = OnGraphViewChange;
}
private GraphViewChange OnGraphViewChange(GraphViewChange change)
{
if (change.edgesToCreate != null)
{
foreach (Edge edge in change.edgesToCreate)
{
Transition newTransition = ScriptableObject.CreateInstance<Transition>();
StateNode goalStateNode = (StateNode)edge.input.node;
StateNode sourceStateNode = (StateNode)edge.output.node;
newTransition.name = sourceStateNode.titleInputField.value+goalStateNode.titleInputField.value + "Transition";
newTransition.goalState = goalStateNode.state;
edgeTransitionTupleList.Add(edge, newTransition);
}
}
if (change.elementsToRemove != null)
{
foreach (GraphElement element in change.elementsToRemove)
{
if (element is Edge)
{
edgesToRemove.Add((Edge)element);
}
if (element is StateNode)
{
// RemoveStateNode((StateNode)element);
statesToRemove.Add((StateNode)element);
}
}
}
return change;
}
//runs on build
private void RegisterTransitions()
{
foreach (Port p in ports)
{
if (p.direction == Direction.Output)
{
if (p.connected && p.node is StateNode)
{
List<Transition> transitionsToBeAdded = new List<Transition>();
StateNode sn = (StateNode)p.node;
foreach (Edge e in p.connections)
{
Transition targetTransition = null;
if (edgeTransitionTupleList.TryGetValue(e, out targetTransition))
{
transitionsToBeAdded.Add(targetTransition);
}
}
sn.state.transitions = transitionsToBeAdded.ToArray();
}
}
}
}
public void ClearGraph()
{
graphElements.ForEach(grapElement => RemoveElement(grapElement));
edgeTransitionTupleList.Clear();
statesToRemove.Clear();
edgesToRemove.Clear();
}
public void OnGUI()
{
}
public Transition[] OpenTransitions()
{
List<Transition> transitions = new List<Transition>();
foreach (ISelectable selected in selection)
{
if (selected is Edge)
{
Transition transitionFound;
if (edgeTransitionTupleList.TryGetValue((Edge)selected, out transitionFound))
{
transitions.Add(transitionFound);
//TransitionEditorWindow.Init(transitionFound);
selectedCache = (Edge)selected;
}
}
}
return transitions.ToArray();
// TransitionEditorWindow.Init(transitions.ToArray());
}
private void AddGridBackground()
{
GridBackground gridBackground = new GridBackground();
gridBackground.StretchToParentSize();
Insert(0, gridBackground);
}
private void AddManipulators()
{
this.AddManipulator(CreateNodeContextualMenu());
// this.AddManipulator(LoadContextualMenu());
this.AddManipulator(new SelectionDragger());
this.AddManipulator(new ContentDragger());
this.AddManipulator(new ContentZoomer());
}
private IManipulator CreateNodeContextualMenu()
{
ContextualMenuManipulator contextualMenuManipulator = new ContextualMenuManipulator(
menuEvent => menuEvent.menu.AppendAction("Add State", actionEvent => AddElement(CreateStateNode(actionEvent.eventInfo.localMousePosition)))
);
return contextualMenuManipulator;
}
public void Load(FSMSave loadSource)
{
if (loadSource == null) return;
ClearGraph();
if (loadSource.states != null)
{
foreach (FSMSave.SavedElement s in loadSource.states)
{
StateNode st = RecreateStateNode(s.position, s.node);
AddElement(st);
}
}
foreach (Node nodElement in nodes)
{
StateNode st = (StateNode)nodElement;
st.titleInputField.value = st.state.name;
if (st.state.transitions != null)
{
foreach (Transition transition in st.state.transitions)
{
if (transition != null)
{
LoadTrasition(loadSource, st, transition);
}
}
}
}
}
private void LoadTrasition(FSMSave sv,StateNode sourceState,Transition transition)
{
FSMSave.SavedElement st = sv.states.Find((FSMSave.SavedElement savedState) => {
return savedState.node == transition.goalState;
});
foreach (Node n in nodes)
{
StateNode targetStateNode = (StateNode)n;
if (targetStateNode.state == st.node)
{
Edge newEdge = sourceState.outputPort.ConnectTo(targetStateNode.inputPort);
AddElement(newEdge);
edgeTransitionTupleList.Add(newEdge, transition);
}
}
sourceState.RefreshPorts();
sourceState.RefreshExpandedState();
}
public StateNode CreateStateNode(Vector2 pos)
{
StateNode st = new StateNode(ScriptableObject.CreateInstance<State>());
st.Initialize(pos);
st.Draw();
return st;
}
public StateNode RecreateStateNode(Vector2 pos,State state)
{
StateNode st = new StateNode(state);
st.Initialize(pos);
st.Draw();
return st;
}
public override List<Port> GetCompatiblePorts(Port startPort, NodeAdapter nodeAdapter)
{
List<Port> compatiblePorts = new List<Port>();
ports.ForEach((Port port) => {
if (port == startPort)
{
return;
}
if (startPort.node == port.node)
{
return;
}
if (startPort.direction == port.direction)
{
return;
}
compatiblePorts.Add(port);
});
return compatiblePorts;
}
public void Save()
{
RegisterTransitions();
ActualSave(instance.saveFile);
}
private void ActualSave(FSMSave sv)
{
string path = instance.rootDirectory;
foreach (Node currentNode in nodes)
{
if (currentNode is StateNode)
{
StateNode stateNode = (StateNode)currentNode;
stateNode.state.entryAction = (Action)stateNode.entry.value;
Action[] actionArray = new Action[stateNode.actions.Count];
if (stateNode.state != null)
{
EditorUtility.SetDirty(stateNode.state);
}
//ObjectField actionsObjectField in primary.actions.ToArray()
for (int i = 0; i < actionArray.Length; i++)
{
actionArray[i] = (Action)stateNode.actions[i].value;
}
stateNode.state.actions = actionArray;
stateNode.state.exitAction = (Action)stateNode.exit.value;
//AssetDatabase.CreateAsset(primary.state, string.Empty);
if (stateNode.state != null)
{
/* string combinedPath = System.IO.Path.GetRelativePath(Application.dataPath,System.IO.Path.Combine(path,"States", stateNode.titleInputField.value));
combinedPath = System.IO.Path.Combine("Assets", combinedPath);
AssetDatabase.CreateAsset(stateNode.state, combinedPath + ".asset");*/
if (!PathExists(path, "States", stateNode.titleInputField.value + ".asset"))
{
string finalPath = LocatePathOrCreateFolder(path, "States", stateNode.titleInputField.value);
AssetDatabase.CreateAsset(stateNode.state, finalPath);
if (instance.saveFile.states != null)
{
if (!instance.saveFile.states.Exists((FSMSave.SavedElement element) => { return element.node == stateNode.state; }))
{
instance.saveFile.states.Add(new FSMSave.SavedElement(stateNode.state, stateNode.GetPosition().position));
}
}
} else
{
if (instance.saveFile.states != null)
{
if (!instance.saveFile.states.Exists((FSMSave.SavedElement element) => { return element.node == stateNode.state; }))
{
instance.saveFile.states.Add(new FSMSave.SavedElement(stateNode.state, stateNode.GetPosition().position));
}
else
{
int index = instance.saveFile.states.FindIndex((FSMSave.SavedElement element) => { return element.node == stateNode.state; });
instance.saveFile.states[index] = new FSMSave.SavedElement(stateNode.state, stateNode.GetPosition().position);
}
}
}
}
}
}
foreach (Edge removalEdgeGoal in edgesToRemove)
{
Transition transitionToCleanup = null;
if (edgeTransitionTupleList.TryGetValue(removalEdgeGoal, out transitionToCleanup))
{
foreach (StateNode st in nodes)
{
if (st.state.transitions != null)
{
RemoveTransitionFromState(st.state, transitionToCleanup);
}
RemoveTransition(transitionToCleanup);
}
}
}
foreach (StateNode stateNodeToRemove in statesToRemove)
{
State stateToRemove = stateNodeToRemove.state;
if (sv.states.Exists((FSMSave.SavedElement stElement) => { return stElement.node == stateToRemove; }))
{
if (stateToRemove.transitions != null)
{
foreach (Transition removalTransition in stateToRemove.transitions)
{
if (removalTransition != null)
{
RemoveTransition(removalTransition);
}
}
}
edgesToRemove.Clear();
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(stateToRemove));
sv.states.RemoveAll((FSMSave.SavedElement removePredicate) => {
return removePredicate.node == stateToRemove;
});
}
}
statesToRemove.Clear();
foreach (Edge e in edges)
{
Transition transition = null;
if (edgeTransitionTupleList.TryGetValue(e, out transition))
{
if (!PathExists(path, "Transitions", transition.name + ".asset"))
{
string finalPath = LocatePathOrCreateFolder(path, "Transitions", transition.name);
string assetId = Path.Combine(finalPath, "Transitions");
AssetDatabase.CreateAsset(transition, finalPath);
EditorUtility.SetDirty(transition);
} else
{
EditorUtility.SetDirty(transition);
}
}
}
EditorUtility.SetDirty(instance.saveFile);
AssetDatabase.SaveAssets();
AssetDatabase.Refresh();
EditorUtility.FocusProjectWindow();
}
private void RemoveTransition(Transition transition)
{
Edge edgeToClear = FindEdgeByTransition(transition);
if (edgeToClear != null)
{
edgeTransitionTupleList.Remove(edgeToClear);
}
AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(transition));
}
private void RemoveTransitionFromState(State state, Transition targetTransition)
{
List<Transition> newTransitionList = new List<Transition>(state.transitions);
if (newTransitionList.Contains(targetTransition))
{
newTransitionList.Remove(targetTransition);
}
state.transitions = newTransitionList.ToArray();
}
private Edge FindEdgeByTransition(Transition transition)
{
foreach (KeyValuePair<Edge,Transition> kvp in edgeTransitionTupleList)
{
if (kvp.Value == transition)
{
return kvp.Key;
}
}
return null;
}
private string LocatePathOrCreateFolder(string path,string folder,string fileName)
{
string folderRelativePath = Path.GetRelativePath(Application.dataPath, path);
string transitionFolder = string.Empty;
if (folder != string.Empty)
{
if (!Directory.Exists(Path.Combine(path, folder)))
{
AssetDatabase.CreateFolder(Path.Combine("Assets", folderRelativePath), folder);
transitionFolder = Path.Combine("Assets", folderRelativePath, folder);
}
else
{
transitionFolder = Path.Combine("Assets", folderRelativePath, folder);
}
} else
{
transitionFolder = Path.Combine("Assets", folderRelativePath);
}
return Path.Combine(transitionFolder, fileName + ".asset");
}
private bool PathExists(string path, string folders, string fileName)
{
return File.Exists(Path.Combine(path,folders,fileName));
}
}
