Пример #1
0
 public void reset()
 {
     selectedEdge   = -1;
     selected       = null;
     m0             = false;
     transitionLine = false;
 }
Пример #2
0
        protected Rect makeNodeRect(MoronIONode node)
        {
            IEnumerable <FieldInfo> attributes;
            float width, height;

            width  = 180;
            height = 25;

            attributes = node.getFieldsWithAttribute <MoronManualWriteAttribute>();
            if (attributes.Count() > 0)
            {
                height += attributes.Count() * 20f;
            }

            attributes = node.getFieldsWithAttribute <MoronStateWriteAttribute>();
            if (attributes.Count() > 0)
            {
                height += (attributes.Count() + 1) * 20f;
            }

            attributes = node.getFieldsWithAttribute <MoronStateReadAttribute>();
            if (attributes.Count() > 0)
            {
                height += (attributes.Count() + 1) * 20f;
            }

            return(new Rect(node.position.x - width / 2, node.position.y - height / 2, width, height));
        }
Пример #3
0
        /// <summary>
        ///		Creates and returns the root of a fresh set of nodes and edges for the given [thinker].
        /// </summary>
        public MoronIONode createResolvedGraph(MoronThinker thinker)
        {
            MoronIONode[] resolvedNodes;
            MoronIONode   node;

            resolvedNodes = new MoronIONode[nodes.Count];

            for (int i = 0; i < nodes.Count; i++)
            {
                node                  = (MoronIONode)Activator.CreateInstance(nodes[i].GetType());
                node.thinker          = thinker;
                node.guid             = nodes[i].guid;
                node.interruptsIntent = nodes[i].interruptsIntent;
                node.setJoistsTo(nodes[i]);

                resolvedNodes[i] = node;
            }

            foreach (Pair <int, int> edge in edges)
            {
                resolvedNodes[edge.key].addEdge(resolvedNodes[edge.value]);
            }

            for (int i = 0; i < resolvedNodes.Length; i++)
            {
                resolvedNodes[i].init();
            }

            return(resolvedNodes[0]);
        }
Пример #4
0
        protected void drawNode(MoronIONode node)
        {
            Rect nodeRect;

            nodeRect = makeNodeRect(node);

            drawBody(node, nodeRect);
            drawTitleLabel(node, nodeRect);
            drawFields(node, nodeRect);
        }
Пример #5
0
        protected void setCurrentNode(MoronIONode node)
        {
            if (currentNode != null)
            {
                currentNode.deactivate();
                notifyNearby(currentNode, false);
            }

            currentNode = node;
            notifyNearby(currentNode, true);
            currentNode.activate();
        }
Пример #6
0
        protected void drawJoistList <T>(MoronIONode node, Rect nodeRect, ref Rect current, ref Rect label, Func <String, String> getCall, Action <String, String> setCall, String labelText) where T : Attribute
        {
            IEnumerable <FieldInfo> fields;

            String[] matchingArray;
            float    labelWidth;
            int      index, original, adj;

            fields = node.getFieldsWithAttribute <T>();
            if (fields.Count() <= 0)
            {
                return;
            }

            label.y     = current.y;
            label.width = GUI.skin.label.CalcSize(new GUIContent(labelText)).x;
            current.y  += 20;

            EditorGUI.LabelField(label, labelText);

            // reads
            foreach (FieldInfo field in fields)
            {
                label.y     = current.y;
                label.width = GUI.skin.label.CalcSize(new GUIContent(field.Name)).x;

                labelWidth    = label.width + 5;
                current.x     = nodeRect.x + labelWidth;
                current.width = nodeRect.width - labelWidth - 2;

                EditorGUI.LabelField(label, field.Name);

                matchingArray = graph.statemapDefinition.getFieldsForType(field.FieldType).Select(k => k.name).ToArray();
                original      = Array.IndexOf(matchingArray, getCall(field.Name));

                adj = original;
                if (original < 0)
                {
                    adj = 0;
                }

                index = EditorGUI.Popup(current, adj, matchingArray);

                if (index >= 0 && index < matchingArray.Length && index != original)
                {
                    setCall(field.Name, matchingArray[index]);
                    EditorUtility.SetDirty(graph);
                }

                current.y += 20;
            }
        }
Пример #7
0
        protected void recurseReadUpdates(MoronIONode node)
        {
            MoronChoice choice;

            node.updateReadFields();

            foreach (GraphEdge edge in node.edges)
            {
                choice = edge.to as MoronChoice;
                if (choice != null)
                {
                    recurseReadUpdates(choice);
                    continue;
                }

                ((MoronIONode)edge.to).updateReadFields();
            }
        }
Пример #8
0
        protected void drawTitleLabel(MoronIONode node, Rect nodeRect)
        {
            String name;
            Rect   labelRect;

            name = findNodeTypeName(node.GetType());

            labelRect        = nodeRect;
            labelRect.x     += labelRect.width / 2;
            labelRect.x     -= GUI.skin.label.CalcSize(new GUIContent(name)).x / 2;
            labelRect.xMax   = nodeRect.xMax;
            labelRect.height = 15;

            GUI.color = Color.white;
            GUI.Label(labelRect, name, GUIStyle.none);

            labelRect.xMin   = nodeRect.xMin;
            labelRect.y     += labelRect.height;
            labelRect.height = 1;
            GUI.color        = Color.black;
            GUI.DrawTexture(labelRect, EditorGUIUtility.whiteTexture);
        }
Пример #9
0
        protected void notifyNearby(MoronIONode node, bool active)
        {
            MoronChoice choice;

            foreach (GraphEdge edge in node.edges)
            {
                choice = edge.to as MoronChoice;
                if (choice == null || !choice.interruptsIntent)
                {
                    continue;
                }

                if (active)
                {
                    choice.notifyNearby();
                }
                else
                {
                    choice.notifyNotNearby();
                }
            }
        }
Пример #10
0
        protected void drawFields(MoronIONode node, Rect nodeRect)
        {
            System.Object value, original;
            Rect          current, label;
            float         labelWidth;

            current = new Rect(nodeRect.x, nodeRect.y + 20, nodeRect.width, 20);
            label   = current;

            GUI.color           = NODE_BACKGROUND_COLOR;
            GUI.contentColor    = NODE_BACKGROUND_COLOR;
            GUI.backgroundColor = NODE_BACKGROUND_COLOR;

            // manual
            foreach (FieldInfo field in node.getFieldsWithAttribute <MoronManualWriteAttribute>())
            {
                label.y     = current.y;
                label.width = GUI.skin.label.CalcSize(new GUIContent(field.Name)).x;

                labelWidth    = label.width + 5;
                current.x     = nodeRect.x + labelWidth;
                current.width = nodeRect.width - labelWidth - 2;

                original = node.getManualJoist(field.Name);
                value    = EditorPropertyHelper.propertyField(current, label, field.Name, field.FieldType, original);
                node.setManualJoist(field.Name, value);

                if (value != original)
                {
                    EditorUtility.SetDirty(graph);
                }

                current.y += 20;
            }

            drawJoistList <MoronStateReadAttribute>(node, nodeRect, ref current, ref label, node.getReadJoist, node.setReadJoist, "    Reads:");
            drawJoistList <MoronStateWriteAttribute>(node, nodeRect, ref current, ref label, node.getWriteJoist, node.setWriteJoist, "    Writes:");
        }
Пример #11
0
        protected void makeTransition(MoronIONode from, MoronIONode to)
        {
            Pair <int, int> edge;
            int             metaIndex, previousEdgeMetaIndex, count;

            if (from == to)
            {
                return;
            }

            metaIndex             = graph.nodes.IndexOf(from);
            previousEdgeMetaIndex = -1;

            switch (transitionReplacement)
            {
            case MoronTransitionCondition.INTENT:

                // if both are intents, we make sure that [from] has no other intent edges - an intent can only have one other intent as an edge.
                if (from is MoronIntent && to is MoronIntent)
                {
                    graph.edges.RemoveAll(e => e.key == metaIndex && graph.nodes[e.value] is MoronIntent);
                }
                break;

            case MoronTransitionCondition.YES:

                // remove the lowest-index transition, and insert into its old spot.
                for (int i = 0; i < graph.edges.Count; i++)
                {
                    if (graph.edges[i].key == metaIndex)
                    {
                        previousEdgeMetaIndex = i;
                        break;
                    }
                }

                if (previousEdgeMetaIndex >= 0)
                {
                    graph.edges.RemoveAt(previousEdgeMetaIndex);
                }
                break;

            case MoronTransitionCondition.NO:

                // remove the highest-index transition, and insert into its old spot.
                count = 0;

                for (int i = 0; i < graph.edges.Count; i++)
                {
                    if (graph.edges[i].key == metaIndex && ++count == 2)
                    {
                        previousEdgeMetaIndex = i;
                        break;
                    }
                }

                if (previousEdgeMetaIndex >= 0)
                {
                    graph.edges.RemoveAt(previousEdgeMetaIndex);
                }
                break;
            }

            edge = new Pair <int, int>(graph.nodes.IndexOf(from), graph.nodes.IndexOf(to));

            if (previousEdgeMetaIndex < 0)
            {
                graph.edges.Add(edge);
            }
            else
            {
                graph.edges.Insert(previousEdgeMetaIndex, edge);
            }

            EditorUtility.SetDirty(graph);
        }
Пример #12
0
        protected void drawBody(MoronIONode node, Rect nodeRect)
        {
            MoronThinker thinker;
            MoronIONode  thinkerNode;
            TimeSpan     age;
            Rect         borderRect;
            Color        desiredColor;

            // border
            borderRect         = nodeRect;
            borderRect.x      -= 1;
            borderRect.y      -= 1;
            borderRect.width  += 2;
            borderRect.height += 2;

            if (node == selected)
            {
                GUI.color = Color.yellow;
            }
            else
            {
                GUI.color = Color.black;
            }

            GUI.DrawTexture(borderRect, EditorGUIUtility.whiteTexture);

            // body
            if (node is MoronIntent)
            {
                if (node == graph.nodes[0])
                {
                    desiredColor = INTENT_ROOT_COLOR;
                }
                else
                {
                    desiredColor = INTENT_COLOR;
                }
            }
            else
            {
                desiredColor = CHOICE_COLOR;
            }

            if (Application.isPlaying && Selection.gameObjects.Length > 0)
            {
                thinker = Selection.gameObjects[0].GetComponent <MoronThinker>();
                if (thinker != null)
                {
                    if (thinker.getCurrentNode().guid == node.guid)
                    {
                        desiredColor = Color.white;
                    }
                    else
                    {
                        if (guidMap.ContainsKey(node.guid))
                        {
                            thinkerNode = guidMap[node.guid];

                            age = DateTime.Now.AddMilliseconds(-NODE_FLASHTIME).Subtract(thinkerNode.lastActiveTime);
                            if (age.TotalMilliseconds < NODE_FLASHTIME)
                            {
                                desiredColor = Color.LerpUnclamped(Color.white, desiredColor, (float)age.TotalMilliseconds / (float)NODE_FLASHTIME);
                            }
                        }
                    }
                }
            }

            GUI.color = desiredColor;
            GUI.DrawTexture(nodeRect, EditorGUIUtility.whiteTexture);
        }
Пример #13
0
 public void setJoistsTo(MoronIONode other)
 {
     readJoists   = other.readJoists;
     writeJoists  = other.writeJoists;
     manualJoists = other.manualJoists;
 }
Пример #14
0
        public void updateInput(Event current)
        {
            MoronIONode currentNode;
            Vector2     position;

            position = current.mousePosition + scrollPosition;

            switch (current.type)
            {
            case EventType.MouseDown:

                if (!checkStatemapWidth(position.x))
                {
                    break;
                }

                lastClicked = position;

                switch (current.button)
                {
                case 0:

                    selectedEdge = -1;
                    currentNode  = findNodeForPosition(position);

                    if (transitionLine)
                    {
                        m0 = false;

                        if (currentNode != null)
                        {
                            makeTransition(selected, currentNode);
                        }
                        break;
                    }

                    selected = currentNode;

                    if (selected != null)
                    {
                        selectionOffset = VectorHandling.convXY(selected.position) - position;
                        m0 = true;
                    }
                    else
                    {
                        deselectNode();
                        selectionOffset = Vector3.zero;
                        selectedEdge    = findEdgeForPosition(position);
                    }

                    break;

                case 1:

                    selected = findNodeForPosition(position);
                    if (selected == null)
                    {
                        selectedEdge = findEdgeForPosition(position);
                    }

                    rightClick();
                    break;
                }

                transitionLine = false;
                GUI.FocusControl("");
                break;

            case EventType.MouseUp:

                transitionLine = false;

                if (current.button != 0)
                {
                    break;
                }

                m0 = false;

                if (!checkStatemapWidth(position.x))
                {
                    break;
                }

                if (findNodeForPosition(position) != selected)
                {
                    deselectNode();
                }
                break;

            case EventType.MouseDrag:

                lastDragged = position;
                if (!m0 || selected == null)
                {
                    break;
                }

                selected.position = VectorHandling.gridsnap(lastDragged + selectionOffset, GRIDSNAP_SIZE);
                markDirty();
                break;

            case EventType.KeyDown:

                if (!checkStatemapWidth(current.mousePosition.x))
                {
                    break;
                }

                switch (current.keyCode)
                {
                case KeyCode.X:
                case KeyCode.Delete:

                    deleteSelected();
                    break;

                case KeyCode.T:

                    MoronTransitionCondition condition;

                    if (selected == null || transitionLine)
                    {
                        break;
                    }

                    condition = MoronTransitionCondition.INTENT;

                    if (selected is MoronChoice)
                    {
                        condition = MoronTransitionCondition.YES;
                    }

                    startTransition(condition);
                    break;

                case KeyCode.A:

                    showAddMenu();
                    break;
                }
                break;
            }
        }
Пример #15
0
 protected void deselectNode()
 {
     selected = null;
     GUI.FocusControl("");
 }