// Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            agent.Value.isStopped = isStopped.Value;

            ExecuteNext(0, _flowReactor);
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            moduleNodeEventDispatcher.RaiseEvent(eventBoard, "TestEvent", "this is a string", 66.6f);

            ExecuteNext(0, _flowReactor);
        }
Exemple #3
0
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            animator.Value.SetFloat(floatNameHash, setFloat.Value);

            ExecuteNext(0, _flowReactor);
        }
        static void CreateFlowReactorComponent()
        {
            Event current = Event.current;

            switch (current.type)
            {
            case EventType.DragUpdated:
            case EventType.DragPerform:
                if (current.button == 0)
                {
                    if (DragAndDrop.objectReferences.Length > 0)
                    {
                        if (DragAndDrop.objectReferences[0] is Graph)
                        {
                            if (current.type == EventType.DragPerform)
                            {
                                DragAndDrop.AcceptDrag();
                                FlowReactorComponent _flowReactor = targetObject.AddComponent <FlowReactorComponent>();
                                _flowReactor.graph = (Graph)DragAndDrop.objectReferences[0];
                                EditorGUIUtility.PingObject(_flowReactor);
                                Selection.activeGameObject = targetObject;
                                current.Use();
                            }
                            DragAndDrop.PrepareStartDrag();
                        }
                    }
                }
                break;
            }
        }
Exemple #5
0
		// Execute node
		public override void OnExecute(FlowReactorComponent _flowReactor)
		{
			////////////////////////	
			ExecuteNext(0, _flowReactor);
			ExecuteNext(1, _flowReactor);
		
		}
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            databoxObject.RegisterToDatabase(databoxObjectToRegister, tableID.Value, entryID.Value, newEntryID.Value);

            ExecuteNext(0, _flowReactor);
        }
Exemple #7
0
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            toInt.Value = (int)value.Value;

            ExecuteNext(0, _flowReactor);
        }
Exemple #8
0
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            setInt.Value = Random.Range(minRange.Value, maxRange.Value + 1);

            ExecuteNext(0, _flowReactor);
        }
 public override void OnNodeDisable(FlowReactorComponent _flowReactor)
 {
     if (databoxObject != null)
     {
         databoxObject.OnDatabaseSaved -= DatabaseSaved;
     }
 }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            animator.Value.Rebind();

            ExecuteNext(0, _flowReactor);
        }
Exemple #11
0
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            result.Value = RandomPosition();

            ExecuteNext(0, _flowReactor);
        }
Exemple #12
0
        public override void OnUpdate(FlowReactorComponent _flowReactor)
        {
            if (!graphOwner.isActive)
            {
                return;
            }

            currentFrameCount = Time.frameCount;

            if (currentFrameCount > activeFrameCount + waitForFrameCount.Value && isActive && repeatCount.Value <= 0)
            {
                isActive = false;
                currentRepeatCount++;

                runParallel = false;
                ExecuteNext(0, _flowReactor);
            }
            else if (currentFrameCount > activeFrameCount + waitForFrameCount.Value && isActive && repeatCount.Value > 0 && currentRepeatCount < repeatCount.Value)
            {
                isActive = false;
                currentRepeatCount++;

                runParallel = false;
                ExecuteNext(0, _flowReactor);
            }
            else if (currentFrameCount > activeFrameCount + waitForFrameCount.Value && isActive && repeatCount.Value > 0 && currentRepeatCount >= repeatCount.Value)
            {
                isActive           = false;
                currentRepeatCount = 0;

                runParallel = false;
                ExecuteNext(1, _flowReactor);
            }
        }
Exemple #13
0
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            result.Value = Resources.Load(resourcePath, typeof(GameObject)) as GameObject;

            ExecuteNext(0, _flowReactor);
        }
Exemple #14
0
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            graphOwner.blackboards[Guid.Parse(availableBlackBoardsGuid[selectedBlackBoard])].blackboard.SaveToFile(fileName, savePath, saveFormat);

            ExecuteNext(0, _flowReactor);
        }
Exemple #15
0
 public override void OnNodeDisable(FlowReactorComponent _flowReactor)
 {
     if (databoxObject != null)
     {
         databoxObject.OnImportFromGoogleComplete -= OnImportComplete;
     }
 }
Exemple #16
0
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            toVector3.Value = gameObject.Value.transform.position;

            ExecuteNext(0, _flowReactor);
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            animator.Value.SetLayerWeight(layerIndex.Value, weight.Value);

            ExecuteNext(0, _flowReactor);
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            DG.Tweening.DOTween.Kill(tweenID.Value);

            ExecuteNext(0, _flowReactor);
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            animator.Value.SetLookAtWeight(weight.Value, bodyWeight.Value, headWeight.Value, eyesWeight.Value, clampWeight.Value);

            ExecuteNext(0, _flowReactor);
        }
        public override void OnUpdate(FlowReactorComponent _flowReactor)
        {
            if (!graphOwner.isActive)
            {
                return;
            }

            currentFrameCount = Time.frameCount;

            if (currentFrameCount > activeFrameCount + 1 && isActive)
            {
                if (graphOwner.subGraphNodeInstance != null)
                {
                    graphOwner.subGraphNodeInstance.ExecuteOutput(guid, _flowReactor);
                }
                else
                {
                    if (graphOwner.subGraphNode != null)
                    {
                        graphOwner.subGraphNode.ExecuteOutput(guid, _flowReactor);
                    }
                }
                isActive            = false;
                graphOwner.isActive = false;
            }
        }
Exemple #21
0
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            toVector3.Value = new Vector3(valueX.Value, valueY.Value, valueZ.Value);

            ExecuteNext(0, _flowReactor);
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            toVector3.Value = new Vector3(gameObject.Value.transform.rotation.x, gameObject.Value.transform.rotation.y, gameObject.Value.transform.rotation.z);

            ExecuteNext(0, _flowReactor);
        }
Exemple #23
0
        public static void CreateNewGraphWithDefaultNodes(FlowReactorComponent _fr)
        {
            var _path = EditorUtility.SaveFilePanelInProject("Create new graph", "graph", "asset", "Please enter a graph name");

            if (string.IsNullOrEmpty(_path))
            {
                return;
            }

            var _name = System.IO.Path.GetFileName(_path);

            // create new graph, state and start node
            Graph graph = Graph.CreateGraph(_name, _path);

            graph.nodes = new List <Node>();

            if (_fr != null)
            {
                _fr.graph = graph;
            }

            NodeCreator.CreateNode(null, graph, graph, "OnStart", new Vector2(100, 100));

            graph.parentLevels = new List <Graph.ParentLevels>();
            graph.parentLevels.Add(new Graph.ParentLevels("Root", graph));
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            toString.Value = value.Value.ToString();

            ExecuteNext(0, _flowReactor);
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            coverPoint.Value = GetCoverPoint();
            Debug.DrawRay(coverPoint.Value, Vector3.up, Color.white, 1.0f);

            ExecuteNext(0, _flowReactor);
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            ////////////////////////
            velocity.Value          = agent.Value.velocity;
            velocityMagnitude.Value = agent.Value.velocity.magnitude;

            ExecuteNext(0, _flowReactor);
        }
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            activeFrameCount = Time.frameCount;
            isActive         = true;

            // Call execute next just for fading out node higlighting in editor
            ExecuteNext(0, _flowReactor);
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            // Enter your code here!
            ////////////////////////

            moduleNodeControllable.CallOnNode(_flowReactor, this, "Hello world from node");

            ExecuteNext(0, _flowReactor);
        }
        // Execute node
        public override void OnExecute(FlowReactorComponent _flowReactor)
        {
            Debug.LogWarning("AgentIsStopped is obsolete, use SetAgentIsStopped instead");

            ////////////////////////
            agent.Value.isStopped = isStopped.Value;

            ExecuteNext(0, _flowReactor);
        }
        public override void OnNodeDisable(FlowReactorComponent _flowReactor)
        {
            if (databoxObject == null)
            {
                return;
            }

            databoxObject.OnDatabaseLoaded -= DatabaseLoaded;
        }