public void DeleteEdge(int v1, int v2)
{
EdgeView edgeToDelete = null;
foreach (var edge in E)
{
if (edge.V1.Number == v1 && edge.V2.Number == v2)
{
edgeToDelete = edge;
E.Remove(edgeToDelete);
break;
}
}
if (edgeToDelete != null)
{
if (edgeToDelete.IsOriented == false)
{
foreach (var edge in E)
{
if (edge.V1.Number == v2 && edge.V2.Number == v1)
{
E.Remove(edge);
break;
}
}
}
}
}
public void AddEdge(EdgeView edge)
{
foreach (var e in E)
{
if (edge.IsOriented == true && e.V1.Number == edge.V1.Number && e.V2.Number == edge.V2.Number ||
edge.IsOriented == false && (e.V1.Number == edge.V1.Number && e.V2.Number == edge.V2.Number ||
e.V2.Number == edge.V1.Number && e.V1.Number == edge.V2.Number))
{
throw new Exception("Edge is already exists");
}
else if (edge.IsOriented == true && e.V1.Number == edge.V2.Number && e.V2.Number == edge.V1.Number)
{
E.Add(edge);
throw new Exception("Add new nonOriented edge");
}
}
if (edge.IsOriented == false)
{
E.Add(new EdgeView()
{
V1 = edge.V2, V2 = edge.V1, Distance = edge.Distance, IsOriented = edge.IsOriented
});
}
E.Add(edge);
}
public static EdgeView Create(GameObject _newTarget, bool _hasWorldIndicator, bool _destroysOnDeath = true)
{
EdgeView edgeView = Create(_destroysOnDeath);
edgeView.SetTarget(_newTarget, _hasWorldIndicator);
return(edgeView);
}
void SpawnPayload()
{
Data data = EquipmentManager.instance.GetRandomData().ToAssetData();
GameObject pickup = Instantiate(pickupPrefab, transform.TransformPoint(Vector3.up * 0.2f), Quaternion.identity);
pickup.GetComponent <Pickup> ().Init(data, true);
EdgeView.Create(pickup, true);
}
private void ShowEdge(EdgeView edge)
{
Handles.color = edge.IsOriented() ? Color.red : Color.green;
Vector2 start = edge.GetStart().transform.position;
Vector2 end = edge.GetEnd().transform.position;
Handles.DrawAAPolyLine(10, 2, start, end);
}
protected override void ShowNodeCreationMenuFromEdge(EdgeView edgeView, Vector2 position)
{
if (edgeNodeCreateMenuWindow == null)
{
edgeNodeCreateMenuWindow = ScriptableObject.CreateInstance <CreateConvertNodeMenuWindow>();
}
edgeNodeCreateMenuWindow.Initialize(graphView, EditorWindow.focusedWindow, edgeView);
SearchWindow.Open(new SearchWindowContext(position + EditorWindow.focusedWindow.position.position), edgeNodeCreateMenuWindow);
}
private void OnParticleCollision(GameObject other)
{
EdgeView edge = other.GetComponentInParent <EdgeView>();
if (edge != null)
{
edge.A.DisconnectEdge(edge);
edge.B.DisconnectEdge(edge);
Destroy(edge.gameObject);
}
}
public void MoveToEdge(EdgeView edge)
{
if (CanMoveToEdge(edge))
{
Vector3 start = edge.GetStart().transform.position;
Vector3 end = edge.GetEnd().transform.position;
m_TargetPos = (start + end) / 2;
StartCoroutine(MoveRoutine());
new GameFlowEvent(EGameFlowAction.EnterEdge).Push();
}
}
public bool CanMoveToEdge(EdgeView edge)
{
if (m_CurrentNode == edge.GetStart())
{
return(m_CurrentNode.GetNode().IsNeighbor(edge.GetEnd().GetNode()));
}
else if (m_CurrentNode == edge.GetEnd())
{
return(m_CurrentNode.GetNode().IsNeighbor(edge.GetStart().GetNode()));
}
return(false);
}
public void OnGameEvent(OnEdgeClick edgeEvent)
{
gameObject.SetActive(true);
UpdaterProxy.Get().SetPause(true);
m_CurrentEdge = edgeEvent.GetEdge();
m_ChoosePathButton.interactable = m_Player.CanMoveToEdge(m_CurrentEdge);
EdgeResource tempEdgeResource = m_CurrentEdge.GetEdgeResource();
switch (tempEdgeResource.GetEdgeType())
{
case EEdgeType.Normal:
m_MoveType = EEdgeType.Normal;
break;
case EEdgeType.Combat:
if (TeamManagerProxy.Get().IsNotTooMuchCharacters(tempEdgeResource.GetEdgeCharacterNumber()))
{
m_MoveType = EEdgeType.Normal;
}
else
{
m_MoveType = EEdgeType.Combat;
}
break;
case EEdgeType.Obstacle:
if (TeamManagerProxy.Get().IsCharacterClass(tempEdgeResource.GetEdgeCharacterClass()))
{
m_MoveType = EEdgeType.Normal;
}
else
{
m_MoveType = EEdgeType.Obstacle;
m_ChoosePathButton.interactable = false;
}
break;
case EEdgeType.Diversion:
if (TeamManagerProxy.Get().IsNotTooMuchCharacters(tempEdgeResource.GetEdgeCharacterNumber()))
{
m_MoveType = EEdgeType.Normal;
}
else
{
m_MoveType = EEdgeType.Diversion;
}
break;
}
m_Description.text = tempEdgeResource.GetDescription();
}
public float timer = 0f; //for defend objectives
void Awake()
{
instance = this;
if (savedObjectiveId == 0)
{
savedObjectiveId = startingObjective;
}
curObjectiveId = savedObjectiveId;
winScreen.SetActive(false);
winText = winScreen.transform.Find("Window").Find("Title").GetComponent <Text>();
pc = GameObject.FindObjectOfType <PlayerController> ();
objectiveEdgeView = EdgeView.Create(false);
objectiveEdgeView.Hide();
PrepareObjectives();
if (gameTimer != null)
{
gameTimer.enabled = curObjective.timerActiveState;
if (timeRemaining > 0)
{
gameTimer.Init(timeRemaining);
return;
}
int firstTimerIndex = 0; //find the first event with a timer
while (!objectives [firstTimerIndex].timerActiveState)
{
firstTimerIndex++;
}
if (firstTimerIndex > savedObjectiveId)
{
gameTimer.Init(objectives [firstTimerIndex].time); //set it to what it will start as
}
else
{
foreach (GameTimerEvent timerEvent in gameTimer.timerEvents)
{
if (timerEvent.isActivatedOncePassed && savedObjectiveId > timerEvent.objectiveIdsToActivateOn[0])
{
timerEvent.onTimerEnd.Invoke(); //we finished the timer so invoke whatever methods we were supposed to invoke
}
}
}
}
}
public void OnEdge(EdgeView edge, bool enter)
{
if (enter)
{
m_CurrentEdge = edge;
MoveToEdge(edge);
}
else
{
Assert.IsTrue(m_CurrentEdge.GetEdge().UseNode(m_CurrentNode.GetNode()));
MoveToNode(m_CurrentNode == m_CurrentEdge.GetStart() ? m_CurrentEdge.GetEnd() : m_CurrentEdge.GetStart());
}
}
public static EdgeView Create(bool _destroysOnDeath = true)
{
if (!hasSetPrefabs)
{
LoadPrefab();
}
GameObject edgeViewObj = Instantiate(screenIndicatorPrefab, GameManager.instance.transform.parent.GetComponentInChildren <Canvas>().transform); //always use the canvas in LevelAssets
EdgeView edgeView = edgeViewObj.GetComponent <EdgeView> ();
edgeView.Init(_destroysOnDeath);
return(edgeView);
}
private void Update()
{
if (A != null && B == null)
{
if (!Input.GetMouseButton(0))
{
Cancel();
return;
}
if (edgeView == null)
{
edgeView = Instantiate(edgeViewPrefab, stringParent).GetComponent <EdgeView>();
}
edgeView.A = A.NoteView;
edgeView.EndOverride = Camera.main.ScreenToWorldPoint(Input.mousePosition);
edgeView.gameObject.name = $"{A.NoteView.Note.ID}:";
}
}
void UpdateObjectiveUI()
{
bool hasIndicators = objectives.Count > 0 && curObjectiveId < objectives.Count && curObjective.type != Objective.Type.Kills && curObjective.showsScreenIndicator;
if (hasIndicators)
{
GameObject targetObj = (curObjective.overrideTarget == null) ? curObjective.objectiveObj : curObjective.overrideTarget;
objectiveEdgeView.SetTarget(targetObj, curObjective.showsWorldIndicator); //set target
}
if (curObjective.type == Objective.Type.Kills)
{
Transform targetParent = curObjective.objectiveObj.transform;
foreach (Transform child in targetParent)
{
if (child.name.Contains("Target"))
{
EdgeView.Create(child.gameObject, true);
}
}
}
if (curObjectiveId < objectives.Count && !string.IsNullOrEmpty(curObjective.helpText))
{
NotificationManager.instance.ShowHelp(curObjective.helpText);
}
barAnim.SetBool("Open", curObjective.crucialHealth != null);
if (curObjective.crucialHealth != null)
{
if (curObjective.icon != null)
{
barIcon.gameObject.SetActive(true);
barIcon.sprite = curObjective.icon;
}
else
{
barIcon.gameObject.SetActive(false);
}
}
}
public void Connect()
{
if (edgeView == null)
{
edgeView = Instantiate(edgeViewPrefab, stringParent).GetComponent <EdgeView>();
}
edgeView.A = A.NoteView;
edgeView.B = B.NoteView;
edgeView.EndOverride = Vector3.zero;
A.NoteView.Note.Connect(B.NoteView.Note.ID);
B.NoteView.Note.Connect(A.NoteView.Note.ID);
A.NoteView.ConnectEdge(ref edgeView);
B.NoteView.ConnectEdge(ref edgeView);
edgeView.gameObject.name = $"{A.NoteView.Note.ID}:{B.NoteView.Note.ID}";
A = null;
B = null;
edgeView = null;
}
private void OnSceneGUI()
{
m_Graph = target as GraphView;
m_HandleTransform = m_Graph.transform;
m_HandleRotation = Tools.pivotRotation == PivotRotation.Local ? m_HandleTransform.rotation : Quaternion.identity;
foreach (NodeView node in m_Graph.GetNodes())
{
if (node != null)
{
ShowNode(node);
}
}
List <EdgeView> edges = m_Graph.GetEdges();
for (int i = 0; i < edges.Count; i++)
{
EdgeView edge = edges[i];
if (edge != null && edge.IsValid())
{
ShowEdge(edge);
}
}
}
public override void UpdateView(IATKProperty property)
{
if (!isInitialised)
{
return;
}
if (EdgeView == null || View == null)
{
if (CheckEdgeDimensions() && CheckNodeDimensions())
{
CreateView(VisualisationReference);
}
return;
}
switch (property)
{
case IATKProperty.X:
if (XDimension.Name == "Undefined")
{
float[] zeroArray = new float[nodeLength];
EdgeView.SetVertices(zeroArray, IATKDimension.X);
View.SetVertices(zeroArray, IATKDimension.X);
DestroyAxis(IATKDimension.X);
}
else
{
EdgeView.SetVertices(DataSource[XDimension.Name].Data, IATKDimension.X);
View.SetVertices(DataSource[XDimension.Name].Data, IATKDimension.X);
if (XAxis == null)
{
CreateAxis(IATKDimension.X);
}
else
{
UpdateAxisDimensionAndRanges(IATKDimension.X);
}
View.SetFloatProperty("_MinNormX", XDimension.MinScale);
View.SetFloatProperty("_MaxNormX", XDimension.MaxScale);
View.SetFloatProperty("_MinX", XDimension.MinFilter);
View.SetFloatProperty("_MaxX", XDimension.MaxFilter);
}
break;
case IATKProperty.Y:
if (YDimension.Name == "Undefined")
{
float[] zeroArray = new float[nodeLength];
EdgeView.SetVertices(zeroArray, IATKDimension.Y);
View.SetVertices(zeroArray, IATKDimension.Y);
DestroyAxis(IATKDimension.Y);
}
else
{
EdgeView.SetVertices(DataSource[YDimension.Name].Data, IATKDimension.Y);
View.SetVertices(DataSource[YDimension.Name].Data, IATKDimension.Y);
if (YAxis == null)
{
CreateAxis(IATKDimension.Y);
}
else
{
UpdateAxisDimensionAndRanges(IATKDimension.Y);
}
View.SetFloatProperty("_MinNormY", YDimension.MinScale);
View.SetFloatProperty("_MaxNormY", YDimension.MaxScale);
View.SetFloatProperty("_MinY", YDimension.MinFilter);
View.SetFloatProperty("_MaxY", YDimension.MaxFilter);
}
break;
case IATKProperty.Z:
if (ZDimension.Name == "Undefined")
{
float[] zeroArray = new float[nodeLength];
EdgeView.SetVertices(zeroArray, IATKDimension.Z);
View.SetVertices(zeroArray, IATKDimension.Z);
DestroyAxis(IATKDimension.Z);
}
else
{
EdgeView.SetVertices(DataSource[ZDimension.Name].Data, IATKDimension.Z);
View.SetVertices(DataSource[ZDimension.Name].Data, IATKDimension.Z);
if (ZAxis == null)
{
CreateAxis(IATKDimension.Z);
}
else
{
UpdateAxisDimensionAndRanges(IATKDimension.Z);
}
View.SetFloatProperty("_MinNormZ", ZDimension.MinScale);
View.SetFloatProperty("_MaxNormZ", ZDimension.MaxScale);
View.SetFloatProperty("_MinZ", ZDimension.MinFilter);
View.SetFloatProperty("_MaxZ", ZDimension.MaxFilter);
}
break;
case IATKProperty.Colour:
if (ColourBy == "Undefined")
{
View.SetColour(Colour);
EdgeView.SetColour(Colour);
}
break;
case IATKProperty.ColourBy:
case IATKProperty.ColourGradient:
if (ColourBy != "Undefined")
{
Color[] colours = MapColoursContinuous(DataSource[ColourBy].Data);
View.SetColours(colours);
EdgeView.SetColours(colours);
}
else
{
UpdateView(IATKProperty.Colour);
}
break;
case IATKProperty.Size:
View.SetUVs(Size, IATKDimension.Y);
EdgeView.SetUVs(Size, IATKDimension.Y);
break;
case IATKProperty.SizeBy:
if (SizeBy != "Undefined")
{
View.SetUVs(DataSource[SizeBy].Data, IATKDimension.Y);
EdgeView.SetUVs(DataSource[SizeBy].Data, IATKDimension.Y);
}
else
{
UpdateView(IATKProperty.Size);
}
break;
case IATKProperty.Scale:
UpdateAxisLength(IATKDimension.X);
UpdateAxisLength(IATKDimension.Y);
UpdateAxisLength(IATKDimension.Z);
View.transform.localScale = Scale;
EdgeView.transform.localScale = Scale;
break;
}
}
public void Update()
{
if (Input.GetMouseButtonDown(0))
{
if (EventSystem.current.currentSelectedGameObject == gameObject)
{
foreach (GameObject existingOutLink in FindObjectsOfType <EdgeView>().Where(x => x.Root == transform).Select(x => x.gameObject))
{
Destroy(existingOutLink);
}
int index = transform.GetSiblingIndex();
NodeController nodeController = gameObject.GetComponentInParent <NodeController> ();
Edge myEdge = nodeController.node.Outputs [index];
myEdge.OnRight = null;
Transform wireParent = GameObject.FindWithTag("LinkParent").transform;
dragging = GameObject.Instantiate <GameObject> (Resources.Load <GameObject> ("EdgeView")).GetComponent <EdgeView> ();
dragging.transform.SetParent(wireParent);
dragging.Root = transform;
}
}
if (Input.GetMouseButtonUp(0))
{
if (EventSystem.current.currentSelectedGameObject == gameObject)
{
Edge target = LinkDrop.GetDroppedEdge();
if (target == null)
{
Destroy(dragging.gameObject);
}
else
{
int index = transform.GetSiblingIndex();
NodeController nodeController = gameObject.GetComponentInParent <NodeController> ();
Edge myEdge = nodeController.node.Outputs [index];
if (myEdge.GetType() != target.GetType())
{
SFXPlayer.PlaySound("LinkFail");
Destroy(dragging.gameObject);
}
else
{
myEdge.OnRight = target;
dragging.Target = LinkDrop.CurrentTarget().transform;
dragging.IsActive = () => target.IsActive;
foreach (EdgeView edge in GameObject.FindObjectsOfType <EdgeView>().Where(x => x.Target == dragging.Target))
{
if (dragging != edge)
{
Destroy(edge.gameObject);
}
}
SFXPlayer.PlaySound("CreateLink");
}
}
}
}
}
public async Task <Graph> AlgBoruvka(Canvas graphCanvas, bool isLearnignMode)
{
Graph T = new Graph();
T.V = V;
if (!isLearnignMode)
{
foreach (UIElement elem in graphCanvas.Children)
{
if (elem is Line line)
{
line.Visibility = Visibility.Hidden;
}
else if (elem is TextBlock text)
{
if (text.Tag.ToString().Split().Length == 2)
{
text.Visibility = Visibility.Hidden;
}
}
}
}
while (T.FindRelatedComponents().Count() != 1)
{
List <UIElement> linesToDraw = new List <UIElement>();
var components = T.FindRelatedComponents();
foreach (var relatedComponent in components)
{
EdgeView minEdgeInRelatedComponent = FindMinEdgeInRelatedComponent(relatedComponent, FindEdgesInRalatedComponents(relatedComponent));
if (minEdgeInRelatedComponent != null)
{
if (!isLearnignMode)
{
foreach (UIElement elem in graphCanvas.Children)
{
if (elem is Line line)
{
int v1 = int.Parse(line.Tag.ToString().Split()[0]);
int v2 = int.Parse(line.Tag.ToString().Split()[1]);
if (minEdgeInRelatedComponent.V1.Number == v1 && minEdgeInRelatedComponent.V2.Number == v2 ||
minEdgeInRelatedComponent.V2.Number == v1 && minEdgeInRelatedComponent.V1.Number == v2)
{
linesToDraw.Add(line);
}
}
else if (elem is TextBlock text)
{
if (text.Tag.ToString().Split().Length == 2)
{
int v1 = int.Parse(text.Tag.ToString().Split()[0]);
int v2 = int.Parse(text.Tag.ToString().Split()[1]);
if (minEdgeInRelatedComponent.V1.Number == v1 && minEdgeInRelatedComponent.V2.Number == v2 ||
minEdgeInRelatedComponent.V2.Number == v1 && minEdgeInRelatedComponent.V1.Number == v2)
{
linesToDraw.Add(text);
}
}
}
}
}
T.E.Add(minEdgeInRelatedComponent);
}
}
if (!isLearnignMode)
{
await Task.Delay(2000);
foreach (var line in linesToDraw)
{
line.Visibility = Visibility.Visible;
}
}
}
return(T);
}
public override void CreateView(Visualisation visualisationReference)
{
VisualisationReference = visualisationReference;
SetDataSource(visualisationReference.DataSource);
// NODES
// Create view if it does not yet exist
if (View == null)
{
GameObject viewHolder = new GameObject("NodeView");
viewHolder.transform.SetParent(transform);
viewHolder.transform.localPosition = Vector3.zero;
viewHolder.transform.localRotation = Quaternion.identity;
View = viewHolder.AddComponent <View>();
}
// If the dimensions are all correct, then we can actually create the View
if (CheckNodeDimensions())
{
Material material = new Material(Shader.Find("IATK/OutlineDots"));
material.mainTexture = Resources.Load("circle-outline-basic") as Texture2D;
material.renderQueue = 3000;
material.enableInstancing = true;
View.CreateView(GenerateNodeVertices(),
GenerateNodeIndices(),
GenerateNodeColours(),
GenerateNodeVertices(),
GenerateNodeUVs(),
MeshTopology.Points,
material
);
}
// EDGEs
// Create view if it does not yet exist
if (EdgeView == null)
{
GameObject viewHolder = new GameObject("EdgeView");
viewHolder.transform.SetParent(transform);
viewHolder.transform.localPosition = Vector3.zero;
viewHolder.transform.localRotation = Quaternion.identity;
EdgeView = viewHolder.AddComponent <View>();
}
// If the dimensions are all correct, then we can actually create the View
if (CheckEdgeDimensions())
{
Material material = new Material(Shader.Find("Standard"));
material.renderQueue = 3000;
material.enableInstancing = true;
EdgeView.CreateView(GenerateEdgeVertices(),
GenerateEdgeIndices(),
GenerateEdgeColours(),
GenerateEdgeVertices(),
GenerateEdgeUVs(),
MeshTopology.Lines,
material
);
}
if (XDimension.Name != "Undefined")
{
CreateAxis(IATKDimension.X);
}
if (YDimension.Name != "Undefined")
{
CreateAxis(IATKDimension.Y);
}
if (ZDimension.Name != "Undefined")
{
CreateAxis(IATKDimension.Z);
}
isInitialised = true;
}
public OnEdgeClick(string tag, EdgeView edge)
: base(tag)
{
m_Edge = edge;
}
private void AddSelectionsToSubGraph(Vector2 position)
{
RegisterCompleteObjectUndo("SubGraph");
var cGraph = graph as ConvertGraph;
var newGraph = ScriptableObject.CreateInstance <SubGraph>();
var newNode = BaseNode.CreateFromType(typeof(SubGraphNode), position) as SubGraphNode;
var selectedNodeSet = new HashSet <string>();
var selectedNodeViews = new List <GraphNodeView>();
int inputIndex = 0, outputIndex = 0;
var inputEdges = new List <Tuple <SerializableEdge, string> >();
var outputEdges = new List <Tuple <SerializableEdge, string> >();
var edgeMap = new Dictionary <string, List <SerializableEdge> >();
for (int i = 0; i < selection.Count; i++)
{
ISelectable selectItem = selection[i];
if (selectItem is ConvertNodeView graphNodeView)
{
selectedNodeViews.Add(graphNodeView);
selectedNodeSet.Add(graphNodeView.nodeTarget.GUID);
}
else if (selectItem is SourceNodeView sourceNodeView)
{
Debug.LogWarning("You can't subgraph your source node");
selection.Clear();
return;
}
}
for (int i = 0; i < selectedNodeViews.Count; i++)
{
GraphNodeView selectItem = selectedNodeViews[i];
var cNode = selectItem.nodeTarget as ConvertNode;
edgeMap.Clear();
var iEdges = cNode.GetInputEdges();
foreach (var edge in iEdges)
{
if (!edgeMap.ContainsKey(edge.outputNodeGUID))
{
edgeMap[edge.outputNodeGUID] = new List <SerializableEdge>();
}
edgeMap[edge.outputNodeGUID].Add(edge);
}
var inputNodes = cNode.GetInputNodes();
foreach (var inputNode in inputNodes)
{
if (!selectedNodeSet.Contains(inputNode.GUID))
{
var parameterInfos = cNode.ParameterInfos;
var index = inputIndex;
foreach (var parameterInfo in parameterInfos)
{
if (!parameterInfo.IsOut)
{
newNode.AddInputPorData(new SerialPortData
{
displayName = parameterInfo.Name,
displayType = new TypeInfo(parameterInfo.ParameterType),
identifier = inputIndex.ToString(),
guid = $"{inputNode.GUID}-{(inputIndex - index).ToString()}",
position = new Vector2(cNode.position.x - (24 + 8) * 10, cNode.position.y + inputIndex * 24 * 10),
});
inputIndex++;
}
}
var list = edgeMap[inputNode.GUID];
for (int j = 0; j < list.Count; j++)
{
inputEdges.Add(new Tuple <SerializableEdge, string>(list[j], (Convert.ToInt32(list[j].inputPortIdentifier) + index).ToString()));
}
// PLAN Default Nodes (empty input)
}
}
edgeMap.Clear();
var oEdges = cNode.GetOutputEdges();
foreach (var edge in oEdges)
{
if (!edgeMap.ContainsKey(edge.inputNodeGUID))
{
edgeMap[edge.inputNodeGUID] = new List <SerializableEdge>();
}
edgeMap[edge.inputNodeGUID].Add(edge);
}
var outputNodes = cNode.GetOutputNodes();
foreach (var outputNode in outputNodes)
{
if (!selectedNodeSet.Contains(outputNode.GUID))
{
int index = outputIndex;
var parameterInfos = cNode.ParameterInfos;
foreach (var parameterInfo in parameterInfos)
{
if (parameterInfo.IsOut)
{
newNode.AddOutputPorData(new SerialPortData
{
displayName = parameterInfo.Name,
displayType = new TypeInfo(parameterInfo.ParameterType.GetElementType()),
identifier = outputIndex.ToString(),
guid = $"{outputNode.GUID}-{(outputIndex - index).ToString()}",
position = new Vector2(cNode.position.x + (24 + 8 * 10), cNode.position.y + outputIndex * 24 * 10),
});
outputIndex++;
}
}
var list = edgeMap[outputNode.GUID];
for (int j = 0; j < list.Count; j++)
{
outputEdges.Add(new Tuple <SerializableEdge, string>(list[j], (Convert.ToInt32(list[j].outputPortIdentifier) + index).ToString()));
}
}
}
}
string path = EditorUtility.SaveFilePanel(
"Save your convert graph",
"",
"NewConverterSubGraph",
"asset"
);
if (string.IsNullOrEmpty(path))
{
return;
}
path = $"Assets{path.Substring(Application.dataPath.Length)}";
AssetDatabase.CreateAsset(newGraph, path);
newNode.subGraphGUID = AssetDatabase.AssetPathToGUID(path);
AddNode(newNode);
var delayConnectEdgeViews = new List <EdgeView>();
for (int i = 0; i < inputEdges.Count; i++)
{
var inputEdge = inputEdges[i].Item1;
var oldOutputNode = inputEdge.outputNode;
var outputPort = oldOutputNode.GetPort(inputEdge.outputPort.fieldName, inputEdge.outputPortIdentifier);
var inputPort = newNode.GetPort(nameof(newNode.inputValue), inputEdges[i].Item2.ToString());
var newEdge = SerializableEdge.CreateNewEdge(newGraph, inputPort, outputPort);
if (nodeViewsPerNode.ContainsKey(oldOutputNode) && nodeViewsPerNode.ContainsKey(newNode))
{
var edgeView = new EdgeView()
{
userData = newEdge,
input = nodeViewsPerNode[newNode].GetPortViewFromFieldName(newEdge.inputFieldName, newEdge.inputPortIdentifier),
output = nodeViewsPerNode[oldOutputNode].GetPortViewFromFieldName(newEdge.outputFieldName, newEdge.outputPortIdentifier)
};
Connect(edgeView);
}
}
for (int i = 0; i < outputEdges.Count; i++)
{
var outputEdge = outputEdges[i].Item1;
var oldInputNode = outputEdge.inputNode;
var inputPort = oldInputNode.GetPort(outputEdge.inputPort.fieldName, outputEdge.inputPortIdentifier);
var outputPort = newNode.GetPort(nameof(newNode.outputValue), outputEdges[i].Item2.ToString());
var newEdge = SerializableEdge.CreateNewEdge(newGraph, inputPort, outputPort);
if (nodeViewsPerNode.ContainsKey(oldInputNode) && nodeViewsPerNode.ContainsKey(newNode))
{
var edgeView = new EdgeView()
{
userData = newEdge,
input = nodeViewsPerNode[oldInputNode].GetPortViewFromFieldName(newEdge.inputFieldName, newEdge.inputPortIdentifier),
output = nodeViewsPerNode[newNode].GetPortViewFromFieldName(newEdge.outputFieldName, newEdge.outputPortIdentifier)
};
delayConnectEdgeViews.Add(edgeView);
}
}
string copyDatas = SerialzieSubGraphElements(selection.OfType <GraphElement>(), inputEdges.Select(v => v.Item1).Concat(outputEdges.Select(v => v.Item1)));
for (int i = 0; i < selectedNodeViews.Count; i++)
{
RemoveNodeWithEdges(selectedNodeViews[i]);
}
// Reconnect
for (int i = 0; i < delayConnectEdgeViews.Count; i++)
{
Connect(delayConnectEdgeViews[i]);
}
if (CanPasteSerializedDataCallback(copyDatas))
{
var subGraphWindow = EditorWindow.GetWindow <SubGraphWindow>();
subGraphWindow.serialData = copyDatas;
subGraphWindow.oldGUIDs = selectedNodeViews.Select(s => s.nodeTarget.GUID).ToList();
subGraphWindow.subGraphNode = newNode;
subGraphWindow.InitializeGraph(newGraph);
}
}
void UnserializeAndPasteCallback(string serializedData, List <string> oldGUIDs, SubGraphNode subGraphNode)
{
List <SerialPortData> inputPortDatas = subGraphNode.InputPortDatas; List <SerialPortData> outputPortDatas = subGraphNode.OutputPortDatas;
var data = JsonUtility.FromJson <CopyPasteHelper>(serializedData);
Dictionary <string, BaseNode> copiedNodesMap = new Dictionary <string, BaseNode>();
Dictionary <string, string> nodesMap = new Dictionary <string, string>();
for (int i = 0; i < data.copiedNodes.Count; i++)
{
var serializedNode = data.copiedNodes[i];
var node = JsonSerializer.DeserializeNode(serializedNode);
if (node == null)
{
continue;
}
//Call OnNodeCreated on the new fresh copied node
node.OnNodeCreated();
//And move a bit the new node
node.position.position += new Vector2(20, 20);
var newNodeView = AddNode(node);
nodesMap.Add(oldGUIDs[i], newNodeView.nodeTarget.GUID);
copiedNodesMap[node.GUID] = node;
//Select the new node
AddToSelection(nodeViewsPerNode[node]);
}
for (int i = 0; i < inputPortDatas.Count; i++)
{
var node = GraphNode.CreateFromType(typeof(SourceNode), inputPortDatas[i].position) as SourceNode;
node.graphNodeType = GraphNodeType.VNode;
node.nodeName = inputPortDatas[i].displayName;
node.canChangeType = false;
node.vTypeInfo = inputPortDatas[i].displayType;
AddNode(node);
nodesMap[inputPortDatas[i].guid] = node.GUID;
copiedNodesMap[inputPortDatas[i].guid] = node;
}
for (int i = 0; i < outputPortDatas.Count; i++)
{
var node = GraphNode.CreateFromType(typeof(SourceNode), outputPortDatas[i].position) as SourceNode;
node.graphNodeType = GraphNodeType.MNode;
node.nodeName = outputPortDatas[i].displayName;
node.canChangeType = false;
node.mTypeInfo = outputPortDatas[i].displayType;
AddNode(node);
nodesMap[outputPortDatas[i].guid] = node.GUID;
copiedNodesMap[outputPortDatas[i].guid] = node;
}
foreach (var serializedGroup in data.copiedGroups)
{
var group = JsonSerializer.Deserialize <Group>(serializedGroup);
//Same than for node
group.OnCreated();
// try to centre the created node in the screen
group.position.position += new Vector2(20, 20);
var oldGUIDList = group.innerNodeGUIDs.ToList();
group.innerNodeGUIDs.Clear();
foreach (var guid in oldGUIDList)
{
graph.nodesPerGUID.TryGetValue(guid, out var node);
// In case group was copied from another graph
if (node == null)
{
copiedNodesMap.TryGetValue(guid, out node);
group.innerNodeGUIDs.Add(node.GUID);
}
else
{
group.innerNodeGUIDs.Add(copiedNodesMap[guid].GUID);
}
}
AddGroup(group);
}
foreach (var oldEdge in data.copiedEdges)
{
var edge = JsonSerializer.Deserialize <SerializableEdge>(oldEdge);
string outputDataNodeGUID = $"{edge.outputNodeGUID}-{edge.outputPortIdentifier}";
string inputDataNodeGUID = $"{edge.inputNodeGUID}-{edge.inputPortIdentifier}";
BaseNode oldOutputNode = null;
BaseNode oldInputNode = null;
string outputFieldName = edge.outputFieldName;
string inputFieldName = edge.inputFieldName;
// Find port of new nodes:
if (!nodesMap.TryGetValue(edge.outputNodeGUID, out string outputNodeGUID))
{
if (nodesMap.TryGetValue(outputDataNodeGUID, out outputNodeGUID))
{
if (!graph.nodesPerGUID.ContainsKey(outputNodeGUID))
{
continue;
}
edge.outputNode = graph.nodesPerGUID[outputNodeGUID];
if (edge.outputNode is SourceNode sNode)
{
outputFieldName = nameof(sNode.outputValue);
}
edge.outputPort = edge.outputNode.GetPort(outputFieldName, "0");
copiedNodesMap.TryGetValue(edge.outputNode.GUID, out oldOutputNode);
}
else
{
continue;
}
}
else
{
if (!graph.nodesPerGUID.ContainsKey(outputNodeGUID))
{
continue;
}
edge.outputNode = graph.nodesPerGUID[outputNodeGUID];
edge.outputPort = edge.outputNode.GetPort(outputFieldName, edge.outputPortIdentifier);
copiedNodesMap.TryGetValue(edge.outputNode.GUID, out oldOutputNode);
}
if (!nodesMap.TryGetValue(edge.inputNodeGUID, out string inputNodeGUID))
{
if (nodesMap.TryGetValue(inputDataNodeGUID, out inputNodeGUID))
{
if (!graph.nodesPerGUID.ContainsKey(inputNodeGUID))
{
continue;
}
edge.inputNode = graph.nodesPerGUID[inputNodeGUID];
if (edge.inputNode is SourceNode sNode)
{
inputFieldName = nameof(sNode.inputValue);
}
edge.inputPort = edge.inputNode.GetPort(inputFieldName, "0");
copiedNodesMap.TryGetValue(edge.inputNode.GUID, out oldInputNode);
}
else
{
continue;
}
}
else
{
if (!graph.nodesPerGUID.ContainsKey(inputNodeGUID))
{
continue;
}
edge.inputNode = graph.nodesPerGUID[inputNodeGUID];
edge.inputPort = edge.inputNode.GetPort(inputFieldName, edge.inputPortIdentifier);
copiedNodesMap.TryGetValue(edge.inputNode.GUID, out oldInputNode);
}
oldInputNode = oldInputNode ?? edge.inputNode; // Don't f*****g delete that
oldOutputNode = oldOutputNode ?? edge.outputNode;
var inputPort = edge.inputPort;
var outputPort = edge.outputPort;
var newEdge = SerializableEdge.CreateNewEdge(graph, inputPort, outputPort);
if (nodeViewsPerNode.ContainsKey(oldInputNode) && nodeViewsPerNode.ContainsKey(oldOutputNode))
{
var edgeView = new EdgeView()
{
userData = newEdge,
input = nodeViewsPerNode[oldInputNode].GetPortViewFromFieldName(newEdge.inputFieldName, newEdge.inputPortIdentifier),
output = nodeViewsPerNode[oldOutputNode].GetPortViewFromFieldName(newEdge.outputFieldName, newEdge.outputPortIdentifier)
};
Connect(edgeView);
}
}
}
public OnEdgeBattleGameEvent(bool enter, EdgeView edge = null) : base("Game")
{
m_Enter = enter;
m_Edge = edge;
}
public void OnNormalEdge(EdgeView edge)
{
Assert.IsTrue(edge.GetEdge().UseNode(m_CurrentNode.GetNode()));
MoveToNode(m_CurrentNode == edge.GetStart() ? edge.GetEnd() : edge.GetStart());
}
public void Cancel()
{
m_CurrentEdge = null;
gameObject.SetActive(false);
UpdaterProxy.Get().SetPause(false);
}
public void AttachView(object view, object context = null)
{
View = view as EdgeView;
}
