Exemple #1
0
    protected void CreateButtonText(RectTransform buttonTransform, string textContent, ref GameObject textObject, ref RectTransform textTransform,
                                    ref SpritedStringUI textComponent, bool replicateScale)
    {
        RectTransform areaParentTrans = null;

        if ((buttonTransform != null) && (textContent != null))
        {
            areaParentTrans = (RectTransform)buttonTransform.parent;
            if (areaParentTrans != null)
            {
                textObject    = new GameObject("ButtonText", typeof(RectTransform));
                textTransform = textObject.GetComponent <RectTransform>();
                textTransform.SetParent(areaParentTrans, false);
                textComponent = textObject.AddComponent <SpritedStringUI>();
                textComponent.SetSymbolSource(font);
                textComponent.SetValue(textContent);
                textComponent.ToggleRaycastTargeting(false);
                textTransform.anchoredPosition = buttonTransform.anchoredPosition;
                if (replicateScale)
                {
                    textTransform.localScale = buttonTransform.localScale;
                }
            }
        }
    }
Exemple #2
0
    protected void UpdateTextDisplayObject(string objectContent, Vector2 scaleChange, Vector2 positionRates, TextAlignment anchorAlign,
                                           RectTransform readyTransform, SpritedStringUI readyText)
    {
        Vector2 originalUIDimensions = Vector2.zero;

        if (readyText != null)
        {
            readyText.SetValue(objectContent);
            originalUIDimensions = readyText.GetUIDimensions();
            PlaceTransformProperly(readyTransform, originalUIDimensions, scaleChange, positionRates, anchorAlign);
        }
    }
Exemple #3
0
    protected void CreateTextDisplayObject(string objectName, string objectContent, Vector2 scaleChange, Vector2 positionRates,
                                           TextAlignment anchorAlign, ref GameObject newObject, ref RectTransform newTransform, ref SpritedStringUI newText)
    {
        Vector2 originalUIDimensions = Vector2.zero;

        if (font != null)
        {
            newObject    = new GameObject(objectName, typeof(RectTransform));
            newTransform = newObject.GetComponent <RectTransform>();
            newText      = newObject.AddComponent <SpritedStringUI>();
            newText.SetSymbolSource(font);
            newText.SetValue(objectContent);
            newText.ToggleRaycastTargeting(false);
            originalUIDimensions = newText.GetUIDimensions();
            PlaceTransformProperly(newTransform, originalUIDimensions, scaleChange, positionRates, anchorAlign);
        }
    }
    private bool AddCanvasText(string textString, SymbolDatabase textFont, Color textColor, Vector4 textColorGradient, int textEvolution,
                               Transform originTransform, Vector2 originWorldPosition, bool workDuringPause)
    {
        GameObject      textObject         = null;
        RectTransform   textTrans          = null;
        SpritedStringUI text               = null;
        int             textIndex          = -1;
        Vector3         completeWorldPos   = Vector3.zero;
        Vector2         currentWorldPos    = Vector2.zero;
        Vector2         canvasPosition     = Vector2.zero;
        Vector2         textSpeed          = Vector2.zero;
        Vector2         textIncreasedScale = Vector2.zero;
        Color           textGeneralColor   = Color.white;
        float           textDurationShow   = 0f;
        float           textDurationPlain  = 0f;
        float           textDurationHide   = 0f;
        int             textStage          = INVALID_TEXT_STAGE;

        if (originTransform != null)
        {
            completeWorldPos = originTransform.position;
            currentWorldPos  = new Vector2(completeWorldPos.x, completeWorldPos.y);

            /*halmeida - in case there is an origin transform, the originWorldPosition vector is interpreted as an offset
             * from the transform's position.*/
            currentWorldPos += originWorldPosition;
        }
        else
        {
            currentWorldPos = originWorldPosition;
        }
        if (TransformWorldToCanvasPosition(currentWorldPos, ref canvasPosition))
        {
            textIndex  = (textObjects == null) ? 0 : textObjects.Length;
            textObject = new GameObject("UIText" + textIndex, typeof(RectTransform));
            if (textObject != null)
            {
                textTrans = textObject.GetComponent <RectTransform>();
                text      = textObject.AddComponent <SpritedStringUI>();
                if (text != null)
                {
                    text.SetSymbolSource(textFont);
                    text.ToggleRaycastTargeting(false);
                    text.SetValue(textString);
                    textTrans.SetParent(interfaceCanvasTrans, false);
                    textTrans.anchoredPosition = canvasPosition;
                    switch (textEvolution)
                    {
                    case TEXT_EVOLUTION_ASCENT:
                        textSpeed.y        = TEXT_ASCENT_SPEED;
                        textGeneralColor   = text.GetGeneralColor();
                        textGeneralColor.a = 0f;
                        text.SetGeneralColor(textGeneralColor);
                        textStage            = TEXT_STAGE_SHOW;
                        textIncreasedScale   = new Vector2(TEXT_ASCENT_START_SCALE_X, TEXT_ASCENT_START_SCALE_Y);
                        textTrans.localScale = new Vector3(textIncreasedScale.x, textIncreasedScale.y, 1f);
                        textDurationShow     = TEXT_ASCENT_DURATION_SHOW;
                        textDurationPlain    = TEXT_ASCENT_DURATION_PLAIN;
                        textDurationHide     = TEXT_ASCENT_DURATION_HIDE;
                        break;

                    case TEXT_EVOLUTION_STAY:
                        textGeneralColor   = text.GetGeneralColor();
                        textGeneralColor.a = 0f;
                        text.SetGeneralColor(textGeneralColor);
                        textStage            = TEXT_STAGE_SHOW;
                        textIncreasedScale   = new Vector2(TEXT_STAY_START_SCALE_X, TEXT_STAY_START_SCALE_Y);
                        textTrans.localScale = new Vector3(textIncreasedScale.x, textIncreasedScale.y, 1f);
                        textDurationShow     = TEXT_STAY_DURATION_SHOW;
                        textDurationPlain    = TEXT_STAY_DURATION_PLAIN;
                        textDurationHide     = TEXT_STAY_DURATION_HIDE;
                        break;

                    case TEXT_EVOLUTION_NONE_WAIT:
                    case TEXT_EVOLUTION_NONE_GO:
                        textGeneralColor   = text.GetGeneralColor();
                        textGeneralColor.a = 0f;
                        text.SetGeneralColor(textGeneralColor);
                        textStage            = TEXT_STAGE_SHOW;
                        textIncreasedScale   = new Vector2(TEXT_NONE_START_SCALE_X, TEXT_NONE_START_SCALE_Y);
                        textTrans.localScale = new Vector3(textIncreasedScale.x, textIncreasedScale.y, 1f);
                        textDurationShow     = TEXT_NONE_DURATION_SHOW;
                        textDurationPlain    = TEXT_NONE_DURATION_PLAIN;
                        textDurationHide     = TEXT_NONE_DURATION_HIDE;
                        break;
                    }
                    text.SetColor(textColor, textColorGradient);
                    UsefulFunctions.IncreaseArray <GameObject>(ref textObjects, textObject);
                    UsefulFunctions.IncreaseArray <RectTransform>(ref textTransforms, textTrans);
                    UsefulFunctions.IncreaseArray <SpritedStringUI>(ref texts, text);
                    UsefulFunctions.IncreaseArray <int>(ref textEvolutions, textEvolution);
                    UsefulFunctions.IncreaseArray <Transform>(ref textOriginTransforms, originTransform);
                    UsefulFunctions.IncreaseArray <Vector2>(ref textOriginPositions, originWorldPosition);
                    UsefulFunctions.IncreaseArray <Vector2>(ref textSpeeds, textSpeed);
                    UsefulFunctions.IncreaseArray <Vector2>(ref textIncreasedScales, textIncreasedScale);
                    UsefulFunctions.IncreaseArray <float>(ref textDurationsShow, textDurationShow);
                    UsefulFunctions.IncreaseArray <float>(ref textDurationsPlain, textDurationPlain);
                    UsefulFunctions.IncreaseArray <float>(ref textDurationsHide, textDurationHide);
                    UsefulFunctions.IncreaseArray <int>(ref textStages, textStage);
                    UsefulFunctions.IncreaseArray <float>(ref textStageElapseds, 0f);
                    UsefulFunctions.IncreaseArray <float>(ref textElapseds, 0f);
                    UsefulFunctions.IncreaseArray <bool>(ref textPauseds, workDuringPause);
                    return(true);
                }
            }
            textTrans = null;
            if (textObject != null)
            {
                Destroy(textObject);
            }
        }
        return(false);
    }
Exemple #5
0
    private void SplitTextIntoLines()
    {
        GameObject      textLineObject        = null;
        RectTransform   textLineTrans         = null;
        SpritedStringUI textLineComponent     = null;
        string          textLine              = null;
        int             textLineLength        = 0;
        int             textLineIndex         = -1;
        float           textLineWidth         = 0f;
        float           interval              = 0f;
        float           position              = 0f;
        int             lineFirstIndex        = -1;
        int             lineLastIndex         = -1;
        int             lineLastIndexValid    = -1;
        int             lineLastIndexNext     = -1;
        int             lineLastIndexPrevious = -1;
        bool            lineReady             = false;
        bool            allLinesReady         = false;
        bool            spaceFound            = false;

        /*halmeida - to get one line I gotta create a long enough SpritedStringUI that fits
         * exactly into the maxTextWidth. If I don't have enough characters to fill the width,
         * I will just make a shorter line. The problem is that I'm able to see the width of a
         * sprited string only after I set its value with all the characters it is supposed to
         * have. Adding character by character to the SpritedString would be too slow, so I use
         * a sort of bynary search, looking for the maximum valid size for each line.*/
        if ((text != null) && (textLines == null) && (ownTransform != null))
        {
            textLineIndex  = 0;
            lineFirstIndex = 0;
            lineLastIndex  = text.Length - 1;
            while (!allLinesReady)
            {
                lineLastIndexValid = -1;
                interval           = lineLastIndex - lineFirstIndex + 1;
                position           = lineFirstIndex + interval;
                while (!lineReady)
                {
                    if (textLineObject == null)
                    {
                        textLineObject = new GameObject("TextBoxUILine" + textLineIndex, typeof(RectTransform));
                        textLineTrans  = textLineObject.GetComponent <RectTransform>();

                        /*halmeida - we should not add the lines as children of the object yet because the box
                         * image itself has not yet been added as a child of the object. The lines would get behind
                         * it if they were added now.*/
                        textLineComponent = textLineObject.AddComponent <SpritedStringUI>();
                        textLineComponent.SetSymbolSource(symbolDatabase);
                    }
                    textLineLength = lineLastIndex - lineFirstIndex + 1;
                    textLine       = text.Substring(lineFirstIndex, textLineLength);
                    textLineWidth  = symbolDatabase.GetStringWidthUI(textLine);
                    //Debug.Log("Debug : TextBoxUI : attempting text line width "+textLineWidth+".");
                    interval = interval / 2f;
                    if (textLineWidth > maxTextWidth)
                    {
                        position -= interval;
                    }
                    else
                    {
                        lineLastIndexValid = lineLastIndex;
                        position          += interval;
                    }
                    lineLastIndexNext = (int)position;

                    /*halmeida - the position value itself should never be the same, but since it is rounded
                     * to an integer index, we may end up falling back to a previously checked index. When that
                     * happens, it means the interval has become small enough to stop the search.*/
                    if ((lineLastIndexNext == lineLastIndexPrevious) || (lineLastIndexNext == lineLastIndex) ||
                        (lineLastIndexNext > text.Length - 1))
                    {
                        if (lineLastIndexValid == -1)
                        {
                            /*halmeida - after all the searching, no valid size was found. This probably means
                             * the maxTextWidth is just too small to fit even one character. Even so we will
                             * forcibly accept a one character wide line.*/
                            lineLastIndexValid = lineFirstIndex;
                        }
                        if (lineLastIndexValid > lineFirstIndex)
                        {
                            /*halmeida - if there is more than one character in the line, we can check for
                             * word integrity. We cannot break a word into two lines. This means that the last
                             * character in a line that is not the last line has to be an empty space or the
                             * space has to be the first character in the next line.*/
                            if ((lineLastIndexValid + 1) < text.Length)
                            {
                                spaceFound = false;
                                for (int i = (lineLastIndexValid + 1); i > lineFirstIndex; i--)
                                {
                                    if (text[i] == ' ')
                                    {
                                        lineLastIndexValid = i - 1;
                                        spaceFound         = true;
                                    }
                                    else
                                    {
                                        if (spaceFound)
                                        {
                                            break;
                                        }
                                    }
                                }
                            }
                        }
                        lineReady = true;

                        /*halmeida - we didn't necessarily end the search at a valid size, but the last valid
                         * size found is the biggest possible one. So we use that value to build the line.*/
                        textLineLength = lineLastIndexValid - lineFirstIndex + 1;
                        textLine       = text.Substring(lineFirstIndex, textLineLength);
                        textLineComponent.SetValue(textLine);
                        textLineComponent.ToggleAllSymbolVisuals(false);
                        //Debug.Log("Debug : TextBoxUI : line "+textLineIndex+" is \""+textLine+"\".");
                        textLineWidth = textLineComponent.GetUIDimensions().x;
                        //Debug.Log("Debug : TextBoxUI : final text line width "+textLineWidth+".");
                        if (textLineWidth > maxLineWidth)
                        {
                            maxLineWidth = textLineWidth;
                        }
                    }
                    else
                    {
                        lineLastIndexPrevious = lineLastIndex;
                        lineLastIndex         = lineLastIndexNext;
                    }
                }
                UsefulFunctions.IncreaseArray <string>(ref textLines, textLine);
                UsefulFunctions.IncreaseArray <GameObject>(ref textLineObjects, textLineObject);
                UsefulFunctions.IncreaseArray <RectTransform>(ref textLineTransforms, textLineTrans);
                UsefulFunctions.IncreaseArray <SpritedStringUI>(ref textLineComponents, textLineComponent);
                textLine          = null;
                textLineObject    = null;
                textLineTrans     = null;
                textLineComponent = null;
                if (lineLastIndexValid == (text.Length - 1))
                {
                    allLinesReady = true;
                }
                else
                {
                    textLineIndex++;
                    lineFirstIndex = lineLastIndexValid + 1;
                    for (int i = lineFirstIndex; i < text.Length; i++)
                    {
                        if (text[i] == ' ')
                        {
                            lineFirstIndex++;
                            if (lineFirstIndex == text.Length)
                            {
                                allLinesReady = true;
                            }
                        }
                        else
                        {
                            break;
                        }
                    }
                    lineLastIndex = text.Length - 1;
                    lineReady     = false;
                }
            }
        }
    }