Beispiel #1
0
    // Start is called before the first frame update
    void Start()
    {
        dialog = DialogPiece.ParseDialog(dialogText.text);

        GameObject dialogBoxObj = GameObject.FindWithTag("DialogBox");

        dialogBox = dialogBoxObj.GetComponent <DialogBox>();
    }
Beispiel #2
0
    private void Awake()
    {
        answermenu  = new List <GameObject>();
        dialogPiece = new DialogPiece();

        answermenu.Add(DefaultOption);
        if (DialogOperationBehaviour.instance != null)
        {
            Operator = DialogOperationBehaviour.instance;
        }
    }
Beispiel #3
0
    public Dialog BehaviourToDialog()
    {
        Dialog dialog = new Dialog();
        int    i      = 0;

        foreach (var v in dialogPieceBehaviours)
        {
            DialogPiece dialogPiece = new DialogPiece();
            dialogPiece.content      = v.ContentText.text;
            dialogPiece.speaker      = v.SpeakerText.text;
            dialogPiece.NodePosition = DialogPieces[v.QueueIndex].GetComponent <RectTransform>().anchoredPosition;
            if (v.formarDialogPieceNode.Count != 0)
            {
                foreach (var w in v.formarDialogPieceNode)
                {
                    dialogPiece.formarPiece.Add(w.GetComponent <DialogPieceBehaviour>().QueueIndex);
                }
            }



            if (v.answermenu[0].GetComponent <MenuOptionBehaviour>().nextDialogPieceNode != null)
            {
                dialogPiece.nextPiece = new int();
                dialogPiece.nextPiece = v.answermenu[0].GetComponent <MenuOptionBehaviour>().nextDialogPieceNode
                                        .GetComponent <DialogPieceBehaviour>().QueueIndex;
            }

            if (v.answermenu.Count > 1)
            {
                for (int w = 1; w < v.answermenu.Count - 1; w++)
                {
                    DialogAnswer dialogAnswer = new DialogAnswer();

                    dialogAnswer.answerContent =
                        v.answermenu[w].GetComponent <MenuOptionBehaviour>().AnswerContent.GetComponent <InputField>().text;
                    dialogAnswer.nextPiece = v.answermenu[w].GetComponent <MenuOptionBehaviour>().nextDialogPieceNode
                                             .GetComponent <DialogPieceBehaviour>().QueueIndex;
                    dialogPiece.dialoganswer.Add(dialogAnswer);
                }
            }
            dialog.dialogStream.Add(dialogPiece);

            i++;
        }
        Debug.Log(JsonUtility.ToJson(dialog));
        return(dialog);
    }
Beispiel #4
0
    private IEnumerator DoAddToDialogText(string speaker, string text, TextAlignmentOptions align)
    {
        DialogPiece p = Instantiate(dialogObject);

        p.SetAlignment(align);
        p.SetText(speaker, text);
        yield return(null);

        p.transform.SetParent(conversationHolder);
        p.transform.SetSiblingIndex(conversationHolder.childCount - 2);
        p.transform.localScale = Vector3.one;
        yield return(null);

        conversationScroll.value = 0;
        yield return(null);

        conversationScroll.value = 0;
    }
    private IEnumerator DoAddToDialogText(string speaker, string text, TextAlignmentOptions align)
    {
        DialogPiece p = Instantiate(dialogObject);

        p.SetAlignment(align);
        p.SetText(speaker, text);
        yield return(null);

        p.transform.SetParent(conversationHolder);
        //Set this as almost but not quite the last element, since we always want the spacer to be the last
        //Without the spacer, the text winds up too close to the bottom of the screen and is hard to read
        p.transform.SetSiblingIndex(conversationHolder.childCount - 2);
        p.transform.localScale = Vector3.one;

        //I don't know why I need to do this twice, but it seems to work better this way?
        yield return(null);

        conversationScroll.value = 0;
        yield return(null);

        conversationScroll.value = 0;
    }
Beispiel #6
0
    /// execute the current DialogPiece <br/> stops at Text and Choice pieces
    private void ExecuteDialog()
    {
        Dictionary <int, bool> jumped = new Dictionary <int, bool>();

again:

        if (dialogIndex >= currentDialog.Length)
        {
            // no more dialog
            inDialog = false;
            gameObject.SetActive(false);

            if (onDialogComplete != null)
            {
                onDialogComplete();
            }

            //erase all active sprites
            foreach (GameObject image in currentDialogSprites.Values)
            {
                GameObject.Destroy(image);
            }
            currentDialogSprites.Clear();

            return;
        }

        DialogPiece p = currentDialog[dialogIndex];

        if (p.type == DialogPieceType.Text)
        {
            TextDialogPiece piece = p as TextDialogPiece;

            speaking    = true;
            currentLine = piece.text;
            letterIndex = 0;
            letterTimer = 0;

            dialogText.text = "";

            continueArrow.SetActive(false);

            if (piece.charName != "")
            {
                nameBox.SetActive(true);
                nameText.text = piece.charName;

                if (currentDialogSprites.TryGetValue(piece.charName.ToLower(), out GameObject image))
                {
                    if (activeSprite)
                    {
                        activeSprite.GetComponent <Image>().CrossFadeAlpha(transparentSpriteAlpha, spriteFadeDuration, true);
                    }

                    if (!String.IsNullOrEmpty(piece.expression))
                    {
                        SetImageSprite(image, GetCharacterSprite(piece.charName, piece.expression, piece.line));
                    }

                    image.GetComponent <Image>().CrossFadeAlpha(1, spriteFadeDuration, true);
                    activeSprite = image;
                }
                else
                {
                    if (!String.IsNullOrEmpty(piece.expression))
                    {
                        throw new DialogException(piece.line, "character '" + piece.charName + "' doesn't have a sprite");
                    }
                }
            }
            else
            {
                nameBox.SetActive(false);
            }
        }
        else if (p.type == DialogPieceType.Choice)
        {
            ChoiceDialogPiece piece = p as ChoiceDialogPiece;

            foreach (Transform oldBtn in choiceContainer.transform)
            {
                GameObject.Destroy(oldBtn.gameObject);
            }

            float totalHeight = 0;

            for (int i = 0; i < piece.choices.Count; i++)
            {
                ChoiceTextPositionPair pair = piece.choices[i];
                Transform newButton         = Instantiate(choiceButtonPrefab, choiceContainer).transform;
                newButton.localPosition = new Vector3(0, -i * (choiceButtonHeight + choiceButtonMargin), 0);

                newButton.GetChild(0).GetComponent <Text>().text = pair.text;

                newButton.GetComponent <DialogOptionButton>().onClick.AddListener(delegate
                {
                    continueArrow.transform.localScale = new Vector3(1, 1, 1);
                    choiceBox.SetActive(false);

                    inChoice    = false;
                    dialogIndex = pair.position;
                    ExecuteDialog();
                });

                totalHeight += choiceButtonHeight + (i < piece.choices.Count - 1 ? choiceButtonMargin : 0);
            }

            choiceContainer.transform.localPosition = new Vector3(0, totalHeight / 2, 0);

            inChoice = true;

            continueArrow.transform.localScale = new Vector3(1, -1, 1);

            choiceBox.SetActive(true);
        }
        else if (p.type == DialogPieceType.Jump)
        {
            JumpDialogPiece piece = p as JumpDialogPiece;

            if (jumped.ContainsKey(piece.jumpTo))
            {
                throw new DialogException(piece.line, "infinite jump loop");
            }

            jumped.Add(piece.jumpTo, true);
            dialogIndex = piece.jumpTo;

            goto again;
        }
        else if (p.type == DialogPieceType.Sprite)
        {
            SpriteDialogPiece piece = p as SpriteDialogPiece;

            if (piece.filename != "" && !dialogSpriteFilenames.ContainsKey(piece.character.ToLower()))
            {
                dialogSpriteFilenames.Add(piece.character.ToLower(), piece.filename);
            }

            Sprite sprite = GetCharacterSprite(piece.character, piece.expression, piece.line);

            if (activeSprite)
            {
                activeSprite.GetComponent <Image>().CrossFadeAlpha(transparentSpriteAlpha, spriteFadeDuration, true);
            }

            GameObject image;
            if (!currentDialogSprites.ContainsKey(piece.character))
            {
                //create the object if it doesn't exist
                image = new GameObject(piece.character + " sprite");
                Image newImage = image.AddComponent <Image>();
                currentDialogSprites.Add(piece.character, image);
                RectTransform rect = image.GetComponent <RectTransform>();
                rect.SetParent(this.transform);
                rect.SetSiblingIndex(0);

                newImage.canvasRenderer.SetAlpha(0);
            }
            else
            {
                image = currentDialogSprites[piece.character];
            }

            activeSprite = image;

            image.GetComponent <Image>().CrossFadeAlpha(1, spriteFadeDuration, true);
            image.transform.localPosition = SpritePositions[piece.position].localPosition;
            SetImageSprite(image, sprite);

            dialogIndex++;
            goto again;
        }
    }
    private void Start()
    {
        button = GetComponent <Button>();

        theDialog = DialogPiece.ParseDialog(dialogFile.text);
    }