Example #1
0
    public ActionConnection AddConnection(ActionSkill ToSkill, ActionSkill FromSkill, double toValue, double fromValue)
    {
        ActionConnection newConnection = new ActionConnection(ToSkill, FromSkill, toValue, fromValue, this);

        bool alreadyExists = false;

        foreach (ActionConnection ac in connections)
        {
            if (ac.IsThereConnectionBetween(ToSkill, FromSkill))
            {
                alreadyExists = true;

                break;
            }
        }

        if (alreadyExists)
        {
            Debug.Log("Editting existing connection");
        }
        else
        {
            connections.Add(newConnection);
        }

        return(newConnection);
    }
Example #2
0
    private void HandleEvents()
    {
        switch (Event.current.type)
        {
        case EventType.MouseDown:

            if (Event.current.button == 0)
            {
                if (LeftMouseDown())
                {
                    Event.current.Use();

                    return;
                }
            }

            break;

        case EventType.MouseDrag:

            if (Event.current.button == 0)
            {
                if (LeftMouseDragged())
                {
                    Event.current.Use();
                }
            }

            if (Event.current.button == 2 || (Event.current.button == 1 && Event.current.modifiers == EventModifiers.Alt))
            {
                Vector2 delta = Event.current.delta;
                delta /= _zoom;

                offset.X += delta.x;
                offset.Y += delta.y;

                Event.current.Use();
            }

            break;

        case EventType.MouseUp:

            if (Event.current.button == 0)
            {
                if (doingSelectionBox)
                {
                    doingSelectionBox = false;

                    Rect    getSelected = GetSelectionArea();
                    Vector2 zoomGetSelectionAreaConvertedTopLeft = ConvertScreenCoordsToZoomCoords(getSelected.TopLeft());

                    Select(new Rect(zoomGetSelectionAreaConvertedTopLeft.x - offset.X, zoomGetSelectionAreaConvertedTopLeft.y - offset.Y, getSelected.width / _zoom, getSelected.height / _zoom), Event.current.modifiers == EventModifiers.Shift);

                    Event.current.Use();
                }
                else
                {
                    if (selectedSkills.Count > 0)
                    {
                        ActionEditor.instance.SaveLibrary();
                    }

                    Event.current.Use();
                }
            }
            else if (Event.current.button == 2)
            {
                ActionEditor.instance.SaveLibrary();

                Event.current.Use();
            }

            break;

        case EventType.ScrollWheel:

            Vector2 d         = Event.current.delta;
            float   zoomDelta = -d.y / 150.0f;
            _zoom += zoomDelta;
            _zoom  = Mathf.Clamp(_zoom, kZoomMin, kZoomMax);
            //offset.X += (zoomCoordsMousePos.x - offset.X) - (oldZoom / _zoom) * (zoomCoordsMousePos.x - offset.X);
            //offset.Y += (zoomCoordsMousePos.y - offset.Y) - (oldZoom / _zoom) * (zoomCoordsMousePos.y - offset.Y);

            Event.current.Use();

            break;
        }

        if (isCreatingConnection && Event.current.keyCode == KeyCode.Escape)
        {
            Debug.Log("Cancelling connection");

            isCreatingConnection = false;
            skillsToConnect.Clear();


            currentContent = empty;

            this.Repaint();

            Event.current.Use();
        }

        if (Event.current.keyCode == KeyCode.Delete)
        {
            if (selectedSkills.Count > 0)
            {
                List <ActionSkill> skillsToDelete = new List <ActionSkill>();

                foreach (int i in selectedSkills)
                {
                    skillsToDelete.Add(ActionEditor.instance.currentLibraryNetwork.skills[i]);
                }

                selectedSkills.Clear();

                foreach (ActionSkill actS in skillsToDelete)
                {
                    ActionEditor.instance.currentLibraryNetwork.DeleteSkill(actS);

                    ActionEditor.instance.SaveLibrary();
                    this.Repaint();
                }

                Event.current.Use();
            }

            if (selectedConnection.HasValue)
            {
                ActionConnection connectionToDelete = ActionEditor.instance.currentLibraryNetwork.connections[selectedConnection.Value];
                selectedConnection = null;

                ActionEditor.instance.currentLibraryNetwork.connections.Remove(connectionToDelete);

                ActionEditor.instance.SaveLibrary();
            }
        }

        if (Event.current.modifiers == EventModifiers.Control && Event.current.keyCode == KeyCode.F)
        {
            if (!creatingNewSkill)
            {
                if (ActionEditor.instance != null && ActionEditor.instance.currentLibraryNetwork != null)
                {
                    GetWindow(typeof(ActionSkillCreation), true);

                    ActionEditor.instance.SaveLibrary();
                }
            }
        }

        if (Event.current.modifiers == EventModifiers.Control && Event.current.keyCode == KeyCode.D)
        {
            if (!isCreatingConnection)
            {
                if (ActionEditor.instance != null && ActionEditor.instance.currentLibraryNetwork != null)
                {
                    if (selectedSkills.Count == 2)
                    {
                        skillsToConnect.Add(ActionEditor.instance.currentLibraryNetwork.skills[selectedSkills[0]]);
                        skillsToConnect.Add(ActionEditor.instance.currentLibraryNetwork.skills[selectedSkills[1]]);

                        GetWindow(typeof(ActionConnectionCreation), true);
                    }
                    else
                    {
                        currentContent = creatingConnection;

                        this.Repaint();
                        isCreatingConnection = true;
                    }
                }
            }
        }

        if (Event.current.modifiers == EventModifiers.Control && Event.current.keyCode == KeyCode.A)
        {
            if (selectedSkills.Count != ActionEditor.instance.currentLibraryNetwork.skills.Count)
            {
                for (int i = 0; i < ActionEditor.instance.currentLibraryNetwork.skills.Count; ++i)
                {
                    selectedSkills.Add(i);
                }

                this.Repaint();
                inspectorNeedsRepaint = true;
            }
        }

//		if(Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.Z && Event.current.modifiers != EventModifiers.Control)
//		{
//			ActionEditor.instance.Undo();
//
//		}
//
//		if(Event.current.type == EventType.KeyDown && Event.current.keyCode == KeyCode.X && Event.current.modifiers != EventModifiers.Control)
//		{
//			ActionEditor.instance.Redo();
//		}
    }
    public override void OnInspectorGUI()
    {
        if (ActionEditor.instance == null || ActionEditor.instance.currentAssetLibrary == null || ActionEditor.instance.currentLibraryNetwork == null)
        {
            GUILayout.Label("No Action Network currently loaded, please selected an Action Library from the project view" +
                            " and press 'Edit Library' in the inspector.", ActionResources.inspectorLabel, new GUILayoutOption[0]);
            return;
        }
        else
        {
            GUILayout.Space(15f);

            GUILayout.BeginHorizontal("toolbar", new GUILayoutOption[]
            {
                GUILayout.ExpandWidth(true)
            });
            {
                GUILayout.Label("Action Skill Editor", ActionResources.boldLabel, new GUILayoutOption[0]);
            } GUILayout.EndHorizontal();

            GUILayout.BeginVertical();
            {
                if (ActionNetworkEditor.instance.selectedConnection.HasValue)
                {
                    ActionConnection actC = ActionEditor.instance.currentLibraryNetwork.connections[ActionNetworkEditor.instance.selectedConnection.Value];

                    GUILayout.Space(2.5f);
                    GUILayout.Label(actC.From.Name + "-" + actC.To.Name + " Connection", ActionResources.boldLabel, new GUILayoutOption[0]);
                    GUILayout.Space(2.5f);

                    GUILayout.BeginHorizontal();
                    {
                        EditorGUILayout.LabelField(actC.From.Name + " to " + actC.To.Name + ":");

                        double.TryParse(EditorGUILayout.TextField(actC.fromValue.ToString()), out actC.fromValue);

//						if(actC.fromValue == 0 && actC.toValue == 0)
//						{
//							ActionConnection connectionToDelete = ActionEditor.instance.currentLibraryNetwork.connections
//								[ActionNetworkEditor.instance.selectedConnection.Value];
//
//							ActionNetworkEditor.instance.selectedConnection = null;
//
//							ActionEditor.instance.currentLibraryNetwork.connections.Remove(connectionToDelete);
//
//							ActionEditor.instance.SaveLibrary();
//						}
                    } GUILayout.EndHorizontal();

                    GUILayout.BeginHorizontal();
                    {
                        EditorGUILayout.LabelField(actC.To.Name + " to " + actC.From.Name + ":");

                        double.TryParse(EditorGUILayout.TextField(actC.toValue.ToString()), out actC.toValue);

//						if(actC.fromValue == 0 && actC.toValue == 0)
//						{
//							ActionConnection connectionToDelete = ActionEditor.instance.currentLibraryNetwork.connections
//								[ActionNetworkEditor.instance.selectedConnection.Value];
//
//							ActionNetworkEditor.instance.selectedConnection = null;
//
//							ActionEditor.instance.currentLibraryNetwork.connections.Remove(connectionToDelete);
//
//							ActionEditor.instance.SaveLibrary();
//						}
                    } GUILayout.EndHorizontal();

                    GUILayout.Space(2.5f);

                    GUILayout.BeginHorizontal();
                    {
                        GUILayout.FlexibleSpace();

                        if (GUILayout.Button("Delete Connection"))
                        {
                            ActionConnection connectionToDelete = ActionEditor.instance.currentLibraryNetwork.connections
                                                                  [ActionNetworkEditor.instance.selectedConnection.Value];

                            ActionNetworkEditor.instance.selectedConnection = null;

                            ActionEditor.instance.currentLibraryNetwork.connections.Remove(connectionToDelete);

                            ActionEditor.instance.SaveLibrary();
                        }

                        GUILayout.Space(10f);
                    } GUILayout.EndHorizontal();

                    ActionResources.ActionSeparator();
                }

                foreach (int i in ActionNetworkEditor.instance.selectedSkills)
                {
                    ActionSkill actS = ActionEditor.instance.currentLibraryNetwork.skills[i];

                    GUILayout.Space(2.5f);
                    GUILayout.Label(actS.Name, ActionResources.boldLabel, new GUILayoutOption[0]);
                    GUILayout.Space(2.5f);

                    GUILayout.BeginHorizontal();
                    {
                        EditorGUILayout.PrefixLabel("Name: ");
                        actS.Name = EditorGUILayout.TextField(actS.Name).Replace(" ", string.Empty);
                    } GUILayout.EndHorizontal();

                    GUILayout.BeginHorizontal();
                    {
                        EditorGUILayout.PrefixLabel("Q: ");

                        double.TryParse(EditorGUILayout.TextField(actS.Q.ToString()), out actS.Q);
                    } GUILayout.EndHorizontal();

                    GUILayout.BeginHorizontal();
                    {
                        EditorGUILayout.PrefixLabel("B: ");

                        double.TryParse(EditorGUILayout.TextField(actS.B.ToString()), out actS.B);
                    } GUILayout.EndHorizontal();

                    GUILayout.BeginHorizontal();
                    {
                        EditorGUILayout.PrefixLabel("v: ");

                        double.TryParse(EditorGUILayout.TextField(actS.v.ToString()), out actS.v);
                    } GUILayout.EndHorizontal();

                    GUILayout.Space(2.5f);
                    GUILayout.Label("Connections", ActionResources.boldLabel, new GUILayoutOption[0]);
                    GUILayout.Space(2.5f);

                    foreach (ActionConnection actC in ActionEditor.instance.currentLibraryNetwork.connections)
                    {
                        if (actC.Contains(actS))
                        {
                            ActionSkill otherEnd = actC.OtherEnd(actS);

                            bool isToEnd = actC.isTo(actS);

                            GUILayout.BeginHorizontal();
                            {
                                EditorGUILayout.LabelField(actS.Name + " to " + otherEnd.Name + ":");

                                if (isToEnd)
                                {
                                    double.TryParse(EditorGUILayout.TextField(actC.toValue.ToString()), out actC.toValue);
                                }
                                else
                                {
                                    double.TryParse(EditorGUILayout.TextField(actC.fromValue.ToString()), out actC.fromValue);
                                }
                            } GUILayout.EndHorizontal();

                            GUILayout.BeginHorizontal();
                            {
                                EditorGUILayout.LabelField(otherEnd.Name + " to " + actS.Name + ":");

                                if (isToEnd)
                                {
                                    double.TryParse(EditorGUILayout.TextField(actC.fromValue.ToString()), out actC.fromValue);
                                }
                                else
                                {
                                    double.TryParse(EditorGUILayout.TextField(actC.toValue.ToString()), out actC.toValue);
                                }
                            } GUILayout.EndHorizontal();

                            GUILayout.Space(2.5f);
                        }
                    }

                    GUILayout.Space(2.5f);

                    GUILayout.BeginHorizontal();
                    {
                        GUILayout.FlexibleSpace();

                        if (GUILayout.Button("Preview skill", new GUILayoutOption[]
                        {
                            GUILayout.Width(125f)
                        }))
                        {
                            ActionMenu.ShowSkillPreview(actS);
                        }

                        GUILayout.Space(10f);
                    } GUILayout.EndHorizontal();

                    ActionResources.ActionSeparator();
                }
            } GUILayout.EndVertical();
        }

        HandleEvents();
    }