public override void HandleFluentNode(FluentNode fluentNode) { pause = (PauseNode)fluentNode; // Start pause StartCoroutine("StartPause"); }
public override void HandleFluentNode(FluentNode fluentNode) { continueWhen = (ContinueWhenNode)fluentNode; // Start pause StartCoroutine("RunTest"); }
private void RootDone(FluentNode node) { OnFinish(); if (Done != null) { Done(this); } }
public WhileNode(GameObject gameObject, Func <bool> test, FluentNode node) : base(gameObject) { // The children are defined as a node chain Children = node.UnravelFromBack(); this.test = test; }
public override void Interrupt(FluentNode fluentNode) { GameObject fluentPlayer = SoundPlayers.Find(x => x.GetComponent <SoundPlayer>().soundNode == fluentNode); SoundPlayer sp = fluentPlayer.GetComponent <SoundPlayer>(); sp.StopPlaying(); FinishSoundPlayer(sp); }
/// <summary> /// Child nodes tell us when they are interrupted so that we can interrupt the other parallel children /// eg. Write might be interrupted by being clicked on, we then also need to stop any sounds from playing /// </summary> /// <param name="node"></param> private void ParallelChildInterrupted(FluentNode node) { // Interrupt all the other children FluentNode[] childrenToInterrupt = childNodesNotDone.ToArray(); foreach (FluentNode childToInterrupt in childrenToInterrupt) { childToInterrupt.Interrupt(); } }
private void HandleNextNode() { if (childQueue.Count == 0) { Done(); return; } FluentNode firstNode = childQueue.Dequeue(); firstNode.SetDoneCallback(SequentialChildCompleted); firstNode.Execute(); }
protected override FluentNode Join(FluentNode rightNode) { // If the right node is an option, chain them if (rightNode is OptionNode) { return(base.Join(rightNode)); } // Otherwise we add the node as a child node to option and return the option // so that we can add other nodes to the same option Children.Add(rightNode); return(this); }
public FluentNode GetFirst() { FluentNode currentNode = this; while (true) { if (currentNode.Previous == null) { return(currentNode); } currentNode = currentNode.Previous; } }
private IEnumerator StartYell() { // Create an instance of a yell canvas if (YellUI == null) { Debug.LogError("Your Yell Handler does not have a yell dialog UI specified. Add a canvas that has a Text component as a child to this object", gameObject); yield break; } // Show the yell UI YellUI.SetActive(true); // Called now to orientate the yell to the camera otherwise there is a stutter Update(); // Set the yell canvas text TextMeshProUGUI text = YellUI.GetComponentInChildren <TextMeshProUGUI>(); // if (text == null) { throw new UnityException("Could not find a Text UI component in the specified Yell UI"); } // ConnectClickCallback(text.gameObject); foreach (FluentString str in CurrentNode.Sentences) { text.text = str; // Wait for the specified amount of seconds float elapsedTime = -1f; while (elapsedTime < CurrentNode.SecondsToPause && !interrupt) { elapsedTime += Time.deltaTime; yield return(null); } interrupt = false; } // FluentNode tempCurrentNode = CurrentNode; // Close the canvas CloseCanvas(); // CurrentNode = null; tempCurrentNode.Done(); }
private void OptionCompleted(FluentNode fluentNode) { OptionNode completedOptionNode = fluentNode as OptionNode; // Check to see if the selected option wants us to go back if (completedOptionNode.GoesBack) { currentOptionsNode.Done(); return; } // The completed option does not go back, just redisplay these options currentOptionsNode.Execute(); }
public override void HandleFluentNode(FluentNode fluentNode) { soundNode = (SoundNode)fluentNode; // Create the sound player GameObject soundPlayerGameObject = SoundPlayer.CreateSoundPlayer(soundNode); SoundPlayer soundPlayer = soundPlayerGameObject.GetComponent <SoundPlayer>(); soundPlayer.DonePlaying += soundPlayer_DonePlaying; // Make the game object the parent soundPlayer.transform.parent = soundNode.GameObject.transform; SoundPlayers.Add(soundPlayerGameObject); }
/// <summary> /// Start at the back and reconstruct a FluentNode chain. /// FluentNodes are constructed by chaining them with the * operator. /// Most of the times we want to turn that chain into a list. /// Will also remove the previous and next pointers from each node, they are only used internally /// </summary> /// <returns></returns> public List <FluentNode> UnravelFromBack() { List <FluentNode> nodeList = new List <FluentNode>(); FluentNode currentNode = this; while (currentNode != null) { nodeList.Insert(0, currentNode); FluentNode prevNode = currentNode; currentNode = currentNode.Previous; prevNode.Next = null; prevNode.Previous = null; } return(nodeList); }
public void End() { // Find the highest level Options node FluentNode highestOptionsNode = currentOptionsNode; while (highestOptionsNode.Parent is OptionsNode || highestOptionsNode.Parent is OptionNode) { highestOptionsNode = highestOptionsNode.Parent; } // Hide Hide(); // Call done on it highestOptionsNode.Done(); }
private void HandleNextNode() { // Check if all the nodes have been handled if (childQueue.Count == 0) { // Start the options presenter optionsPresenter.SetupOptions(this); return; } FluentNode firstNode = childQueue.Dequeue(); firstNode.SetDoneCallback(SequentialChildCompleted); firstNode.Execute(); }
private void ParallelChildCompleted(FluentNode node) { // It is possible that a child node completes via normal means before the interruption is triggered // Make sure we don't remove it twice, which would also make parallel's done be called twice if (!childNodesNotDone.Contains(node)) { return; } // Remove the node childNodesNotDone.Remove(node); // If all the child nodes have been completed // Notify whoever that this parallel node is complete if (childNodesNotDone.Count == 0) { DoneDelegate(this); } }
private IEnumerator StartYell() { // Create an instance of a yell canvas if (YellUI == null) { Debug.LogError("Your Yell Handler does not have a yell dialog UI specified. Add a canvas that has a Text component as a child to this object", gameObject); yield break; } // Show the yell UI YellUI.SetActive(true); // Called now to orientate the yell to the camera otherwise there is a hak Update(); // Set the yell canvas text Text text = YellUI.GetComponentInChildren <Text>(); // ConnectClickCallback(text.gameObject); if (text == null) { throw new UnityException("Could not find a Text UI component in the specified Yell UI"); } text.text = CurrentNode.Text; // Show the canvas for x seconds yield return(new WaitForSeconds(CurrentNode.SecondsToPause)); // FluentNode tempCurrentNode = CurrentNode; // Close the canvas CloseCanvas(); // CurrentNode = null; tempCurrentNode.Done(); }
void ConnectClickCallback(GameObject go) { if (go.GetComponentInChildren <Button>() == null) { go.AddComponent <Button>(); } // Add the button listener so that text can be skipped go.GetComponentInChildren <Button>().onClick.RemoveAllListeners(); go.GetComponentInChildren <Button>().onClick.AddListener(new UnityEngine.Events.UnityAction(() => { StopCoroutine("StartYell"); CloseCanvas(); FluentNode savedCurrentNode = CurrentNode; CurrentNode = null; savedCurrentNode.Done(); })); // Focus the button so that keypresses work EventSystem.current.SetSelectedGameObject(go); }
private void HandleNextNode() { // Check if we handled all the children if (childQueue.Count == 0) { // Lets see if we should restart the while if (!test()) { Done(); return; } // Add all the children again Children.ForEach(n => childQueue.Enqueue(n)); } FluentNode firstNode = childQueue.Dequeue(); firstNode.SetDoneCallback(ChildCompleted); firstNode.Execute(); }
private void HandleNextNode() { if (childrenLeftToExecute.Count == 0) { // Ugh, think about cleanup if (GoesBack && (Parent is OptionsNode) && (Parent.Parent is OptionNode) && (Parent.Parent.Parent is OptionsNode)) { Parent.Parent.Parent.Execute(); } else { HasBeenChosen = true; Done(); } return; } FluentNode firstNode = childrenLeftToExecute.Dequeue(); firstNode.SetDoneCallback(OptionChildCompleted); firstNode.Execute(); }
public override void HandleFluentNode(FluentNode fluentNode) { // We can only have one yell response for a given handler if (CurrentNode != null) { // Stop the current yell StopCoroutine("StartYell"); // Make sure it tells whoever is interested that it completed CurrentNode.Done(); } // Save parameters CurrentNode = fluentNode as YellNode; if (CurrentNode == null) { Debug.Log("CurrentNode is null"); } // Start yell StartCoroutine("StartYell"); }
/// <summary> /// Call this to start the FluentScript /// </summary> public virtual void Run() { // OnStart(); // Create the fluent script FluentNode firstNode = SequentialNode(Create()); // Do a couple of things to the tree before execution starts firstNode.Visit((n) => { // Tell all the children who the parent is n.Children.ForEach(c => c.Parent = n); // Run their before execute methods n.BeforeExecute(); }); // firstNode.SetDoneCallback(RootDone); // firstNode.Execute(); }
public override void Interrupt(FluentNode fluentNode) { StopCoroutine("StartYell"); CloseCanvas(); CurrentNode = null; }
/// <summary> /// The default join behaviour for two nodes is to chain them with Next and Previous and return the right node /// </summary> /// <param name="rightNode"></param> /// <returns></returns> protected virtual FluentNode Join(FluentNode rightNode) { Next = rightNode; rightNode.Previous = this; return(rightNode); }
public override void HandleFluentNode(FluentNode fluentNode) { // Store current node currentNode = fluentNode as WriteNode; // Check if the UI element is defined on the if (currentNode.TextUIElement != null) { currentTextUI = currentNode.TextUIElement.gameObject; } else { currentTextUI = TextUI; } // Get the text component we are using to write the text Text textTextUI = currentTextUI.GetComponent <Text>(); if (!(currentTextUI).activeSelf) { Debug.LogError("Did you forget to call Show() before Write() in your node chain ? The Write Node needs the element on to which text is written to be visible", this); return; } // Add a button to the text if it doent have one if (currentTextUI.GetComponentInChildren <Button>() == null) { currentTextUI.AddComponent <Button>(); } // Add the button listener so that text can be skipped currentTextUI.GetComponentInChildren <Button>().onClick.RemoveAllListeners(); currentTextUI.GetComponentInChildren <Button>().onClick.AddListener(new UnityEngine.Events.UnityAction(() => { // Do cleanup isTyping = false; StopCoroutine("TypeText"); StopCoroutine("Pause"); currentTextUI.GetComponent <Text>().text = currentNode.Text; RemoveSkipListener(); // Write's that require a button press to continue cannot be interrupted if (currentNode.WaitForButtonPress) { ShowButton(); return; } FluentNode prevNode = currentNode; currentNode.Done(); prevNode.IWasInterrupted(); })); // Set the text component to be the selected component EventSystem.current.SetSelectedGameObject(textTextUI.gameObject); // Check if this is an instant write if (CharacterPauseSeconds == 0) { currentTextUI.GetComponent <Text>().text = currentNode.Text; if (currentNode.SecondsToPause != 0) { StartCoroutine("Pause"); } else { currentNode.Done(); } return; } StartCoroutine("TypeText"); }
public abstract void HandleFluentNode(FluentNode fluentNode);
public FluentNode While(Func <bool> test, FluentNode node) { return(new WhileNode(gameObject, test, node)); }
public override void Interrupt(FluentNode fluentNode) { StopCoroutine("StartPause"); }
public override void Interrupt(FluentNode fluentNode) { Debug.Log("Interrupt write"); // }
/// <summary> /// Interrupt should interrupt the execution of the handler /// and call Done() for the fluentNode that was passed as parameter /// </summary> /// <param name="fluentNode"></param> public virtual void Interrupt(FluentNode fluentNode) { }