示例#1
0
        public T GetObject <T>(VariableReference variable) where T : Object
        {
            switch (variable.Location)
            {
            case VariableLocation.Owner: return(ComponentFinder.GetAsObject <T>(Owner));

            case VariableLocation.Parent: return(ComponentFinder.GetAsObject <T>(Parent));

            case VariableLocation.Scene: return(ComponentFinder.GetAsObject <T>(GameObject.Find(variable.Name)));
            }

            var store = GetStore(variable);

            if (store != null)
            {
                var v = store.GetVariable(variable.Name);

                switch (v.Type)
                {
                case VariableType.Asset: return(ComponentFinder.GetAsObject <T>(v.GetAsset()));

                case VariableType.GameObject: return(ComponentFinder.GetAsObject <T>(v.GetGameObject()));

                case VariableType.Other: return(ComponentFinder.GetAsObject <T>(v.GetOther() as Object));
                }
            }

            return(null);
        }
        public override void OnInspectorGUI()
        {
            var createPathfinding = false;

            using (new UndoScope(serializedObject))
            {
                EditorGUILayout.Space();
                EditorGUILayout.PropertyField(_loop);
                EditorGUILayout.PropertyField(_complete);
                EditorGUILayout.PropertyField(_usePathfinding);

                if (_usePathfinding.boolValue)
                {
                    EditorGUILayout.PropertyField(_findAlternate);

                    using (new EditorGUILayout.HorizontalScope())
                    {
                        var pathfinding = ComponentFinder.GetComponentInScene <Pathfinding>((target as PathedController).gameObject.scene.buildIndex);
                        if (pathfinding == null)
                        {
                            EditorGUILayout.HelpBox("In order to use pathfinding this scene's map object must have a pathfinding component attached.", MessageType.Warning, true);

                            createPathfinding = GUILayout.Button("Create\nNow", GUILayout.Height(39));
                        }
                    }
                }

                EditorGUILayout.PropertyField(_path);
            }

            if (createPathfinding)
            {
                var properties = ComponentFinder.GetComponentInScene <MapProperties>((target as PathedController).gameObject.scene.buildIndex);
                if (properties)
                {
                    var path = Undo.AddComponent <Pathfinding>(properties.gameObject);
                    path.RegenerateNodes();
                }
            }
        }
        private void OnSceneGUI()
        {
            var controller = target as PathedController;

            if (controller.Path.Nodes.Length > 0)
            {
                var pathfinding = ComponentFinder.GetComponentInScene <Pathfinding>(controller.gameObject.scene.buildIndex);
                var mover       = controller.GetComponent <Mover>();

                Handles.color = Color.cyan;

                if (controller.Path.Nodes.Length > 2 && controller.Path.Type == Path.PathType.Loop)
                {
                    var first = controller.Path.Nodes[0];
                    var last  = controller.Path.Nodes[controller.Path.Nodes.Length - 1];

                    var firstPosition = GetPosition(first.Position, controller.transform.position, mover.PositionOffset);
                    var lastPosition  = GetPosition(last.Position, controller.transform.position, mover.PositionOffset);

                    if (controller.UsePathfinding && pathfinding)
                    {
                        var pathFrom = GetPathPosition(first.Position, controller.transform.position);
                        var pathTo   = GetPathPosition(last.Position, controller.transform.position);
                        var path     = pathfinding.GetPath(mover, pathFrom, pathTo, controller.FindAlternateRoutes);

                        if (path.Count > 1)
                        {
                            for (var n = 1; n < path.Count; n++)
                            {
                                var node     = path[n];
                                var position = node + mover.PositionOffset;

                                Handles.DrawLine(position, firstPosition);

                                firstPosition = position;
                            }
                        }
                    }
                    else
                    {
                        Handles.DrawLine(lastPosition, firstPosition);
                    }
                }

                for (var i = 1; i < controller.Path.Nodes.Length; i++)
                {
                    var previous = controller.Path.Nodes[i - 1];
                    var current  = controller.Path.Nodes[i];

                    var previousPosition = GetPosition(previous.Position, controller.transform.position, mover.PositionOffset);
                    var currentPosition  = GetPosition(current.Position, controller.transform.position, mover.PositionOffset);

                    if (controller.UsePathfinding && pathfinding)
                    {
                        var pathFrom = GetPathPosition(previous.Position, controller.transform.position);
                        var pathTo   = GetPathPosition(current.Position, controller.transform.position);
                        var path     = pathfinding.GetPath(mover, pathFrom, pathTo, controller.FindAlternateRoutes);

                        if (path.Count > 1)
                        {
                            for (var n = 1; n < path.Count; n++)
                            {
                                var node     = path[n];
                                var position = node + mover.PositionOffset;

                                Handles.DrawLine(position, previousPosition);

                                previousPosition = position;
                            }
                        }
                    }
                    else
                    {
                        Handles.DrawLine(currentPosition, previousPosition);
                    }

                    var selectedPosition = Handles.FreeMoveHandle(currentPosition, Quaternion.identity, 0.25f, Vector3.one, DrawRect);

                    if (currentPosition != selectedPosition)
                    {
                        using (new UndoScope(serializedObject))
                        {
                            selectedPosition -= controller.transform.position;

                            var node = _path.FindPropertyRelative(string.Format("Nodes.Array.data[{0}].Position", i));
                            node.vector2IntValue = Vector2Int.FloorToInt(new Vector2(selectedPosition.x, selectedPosition.y));
                        }
                    }
                }

                for (var i = 1; i < controller.Path.Nodes.Length; i++)
                {
                    var position = GetPosition(controller.Path.Nodes[i].Position, controller.transform.position, mover.PositionOffset);
                    Handles.Label(new Vector2(position.x, position.y + 0.075f), i.ToString(), _textStyle);
                }
            }
        }