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; }