コード例 #1
0
    private void ShowOptionTexts(FSNSnapshot.Layer layer, Segments.Text textSeg, IInGameSetting setting)
    {
        // TODO : 상하좌우 여백, 정렬 등도 따져야함

        Vector2 screenDim = FSNEngine.Instance.ScreenDimension;                 // (계산용) 화면 크기
        Vector3 fadePosOffset;

        switch (setting.CurrentFlowDirection)                                                   // 흐름 방향에 따라 이동 오프셋 세팅
        {
        case FSNInGameSetting.FlowDirection.Up:
            fadePosOffset = new Vector3(0, screenDim.y / 2);
            break;

        case FSNInGameSetting.FlowDirection.Down:
            fadePosOffset = new Vector3(0, -screenDim.y / 2);
            break;

        case FSNInGameSetting.FlowDirection.Right:
            fadePosOffset = new Vector3(screenDim.x / 2, 0);
            break;

        case FSNInGameSetting.FlowDirection.Left:
            fadePosOffset = new Vector3(-screenDim.x / 2, 0);
            break;

        default:
            throw new System.Exception("HUH???");
        }

        // 새 텍스트 엘레먼트 세팅 : 선택지 질문 텍스트

        var newTextSize = CalculateTextSize(textSeg.text, setting);

        var questionTextElem = new SnapshotElems.Text(setting);

        questionTextElem.text           = textSeg.text;
        questionTextElem.fontSize       = setting.FontSize;
        questionTextElem.Color          = Color.white;                //TODO
        questionTextElem.Alpha          = 1;
        questionTextElem.TransitionTime = setting.TextTransitionTime; //TODO
        questionTextElem.type           = SnapshotElems.Text.Type.OptionTexts;
        questionTextElem.MakeItUnique();

        questionTextElem.InitialState.Alpha = 0;
        questionTextElem.FinalState.Alpha   = 0;
        CopyCurrentToFinal(questionTextElem);                                                           // 임시 FinalState

        // 새 텍스트 엘레먼트 - 위치 세팅 (시작 위치만. 끝 위치는 프로세스 끝에 결정된다)
        var qtextPos = new Vector3(-newTextSize.x / 2f, newTextSize.y / 2f);

        ApplyCenterTextMargin(ref qtextPos, setting);                                           // 여백 지정

        questionTextElem.Position = qtextPos;
        questionTextElem.InitialState.Position = questionTextElem.Position - fadePosOffset;

        layer.AddElement(questionTextElem);                                                                     // 텍스트 엘리멘트 추가

        //
        int    dirIndex;
        string dirText;

        // 선택지 : 위쪽 (등장 위치는 아래쪽)
        dirIndex = (int)FSNInGameSetting.FlowDirection.Up;
        dirText  = textSeg.optionTexts[dirIndex];
        if (textSeg.optionTexts.Length - 1 >= dirIndex && !string.IsNullOrEmpty(dirText))
        {
            var upTextSize = CalculateTextSize(dirText, setting);

            var upTextElem = new SnapshotElems.Text(setting);

            upTextElem.text           = dirText;
            upTextElem.fontSize       = setting.FontSize;
            upTextElem.Color          = Color.white;                                  //TODO
            upTextElem.Alpha          = 1;
            upTextElem.TransitionTime = setting.TextTransitionTime;                   //TODO
            upTextElem.type           = SnapshotElems.Text.Type.OptionTexts;
            upTextElem.optionDir      = (FSNInGameSetting.FlowDirection)dirIndex;
            upTextElem.MakeItUnique();

            upTextElem.InitialState.Alpha = 0;
            upTextElem.FinalState.Alpha   = 0;
            CopyCurrentToFinal(upTextElem);                                                                     // 임시 FinalState

            // 새 텍스트 엘레먼트 - 위치 세팅 (시작 위치만. 끝 위치는 프로세스 끝에 결정된다)
            var tpos = new Vector3(upTextSize.x / 2f, -screenDim.y / 2f + upTextSize.y);
            ApplySideTextMargin(ref tpos, setting, FSNInGameSetting.FlowDirection.Up);
            upTextElem.Position = tpos;
            upTextElem.InitialState.Position = upTextElem.Position - fadePosOffset;

            layer.AddElement(upTextElem);                                                                       // 텍스트 엘리멘트 추가
        }

        // 선택지 : 아래쪽 (등장 위치는 위쪽)
        dirIndex = (int)FSNInGameSetting.FlowDirection.Down;
        dirText  = textSeg.optionTexts[dirIndex];
        if (textSeg.optionTexts.Length - 1 >= dirIndex && !string.IsNullOrEmpty(dirText))
        {
            var downTextSize = CalculateTextSize(dirText, setting);

            var downTextElem = new SnapshotElems.Text(setting);

            downTextElem.text           = dirText;
            downTextElem.fontSize       = setting.FontSize;
            downTextElem.Color          = Color.white;                                //TODO
            downTextElem.Alpha          = 1;
            downTextElem.TransitionTime = setting.TextTransitionTime;                 //TODO
            downTextElem.type           = SnapshotElems.Text.Type.OptionTexts;
            downTextElem.optionDir      = (FSNInGameSetting.FlowDirection)dirIndex;
            downTextElem.MakeItUnique();

            downTextElem.InitialState.Alpha = 0;
            downTextElem.FinalState.Alpha   = 0;
            CopyCurrentToFinal(downTextElem);                                                                   // 임시 FinalState

            // 새 텍스트 엘레먼트 - 위치 세팅 (시작 위치만. 끝 위치는 프로세스 끝에 결정된다)
            var tpos = new Vector3(downTextSize.x / 2f, screenDim.y / 2f);
            ApplySideTextMargin(ref tpos, setting, FSNInGameSetting.FlowDirection.Down);
            downTextElem.Position = tpos;
            downTextElem.InitialState.Position = downTextElem.Position - fadePosOffset;

            layer.AddElement(downTextElem);                                                                     // 텍스트 엘리멘트 추가
        }

        // 선택지 : 왼쪽 (등장 위치는 오른쪽)
        dirIndex = (int)FSNInGameSetting.FlowDirection.Left;
        dirText  = textSeg.optionTexts[dirIndex];
        if (textSeg.optionTexts.Length - 1 >= dirIndex && !string.IsNullOrEmpty(dirText))
        {
            var leftTextSize = CalculateTextSize(dirText, setting);

            var leftTextElem = new SnapshotElems.Text(setting);

            leftTextElem.text           = dirText;
            leftTextElem.fontSize       = setting.FontSize;
            leftTextElem.Color          = Color.white;                                //TODO
            leftTextElem.Alpha          = 1;
            leftTextElem.TransitionTime = setting.TextTransitionTime;                 //TODO
            leftTextElem.type           = SnapshotElems.Text.Type.OptionTexts;
            leftTextElem.optionDir      = (FSNInGameSetting.FlowDirection)dirIndex;
            leftTextElem.MakeItUnique();

            leftTextElem.InitialState.Alpha = 0;
            leftTextElem.FinalState.Alpha   = 0;
            CopyCurrentToFinal(leftTextElem);                                                                   // 임시 FinalState

            // 새 텍스트 엘레먼트 - 위치 세팅 (시작 위치만. 끝 위치는 프로세스 끝에 결정된다)
            var tpos = new Vector3(screenDim.x / 2f - leftTextSize.x, -leftTextSize.y * 3f);
            ApplySideTextMargin(ref tpos, setting, FSNInGameSetting.FlowDirection.Left);
            leftTextElem.Position = tpos;
            leftTextElem.InitialState.Position = leftTextElem.Position - fadePosOffset;

            layer.AddElement(leftTextElem);                                                                     // 텍스트 엘리멘트 추가
        }

        // 선택지 : 오른쪽 (등장 위치는 왼쪽)
        dirIndex = (int)FSNInGameSetting.FlowDirection.Right;
        dirText  = textSeg.optionTexts[dirIndex];
        if (textSeg.optionTexts.Length - 1 >= dirIndex && !string.IsNullOrEmpty(dirText))
        {
            var rightTextSize = CalculateTextSize(dirText, setting);

            var rightTextElem = new SnapshotElems.Text(setting);

            rightTextElem.text           = dirText;
            rightTextElem.fontSize       = setting.FontSize;
            rightTextElem.Color          = Color.white;                              //TODO
            rightTextElem.Alpha          = 1;
            rightTextElem.TransitionTime = setting.TextTransitionTime;               //TODO
            rightTextElem.type           = SnapshotElems.Text.Type.OptionTexts;
            rightTextElem.optionDir      = (FSNInGameSetting.FlowDirection)dirIndex;
            rightTextElem.MakeItUnique();

            rightTextElem.InitialState.Alpha = 0;
            rightTextElem.FinalState.Alpha   = 0;
            CopyCurrentToFinal(rightTextElem);                                                                          // 임시 FinalState

            // 새 텍스트 엘레먼트 - 위치 세팅 (시작 위치만. 끝 위치는 프로세스 끝에 결정된다)
            var tpos = new Vector3(-screenDim.x / 2f, rightTextSize.y * 3f);
            ApplySideTextMargin(ref tpos, setting, FSNInGameSetting.FlowDirection.Right);
            rightTextElem.Position = tpos;
            rightTextElem.InitialState.Position = rightTextElem.Position - fadePosOffset;

            layer.AddElement(rightTextElem);                                                                            // 텍스트 엘리멘트 추가
        }
    }
コード例 #2
0
    private void AddNormalText(FSNSnapshot.Layer layer, Segments.Text textSeg, IInGameSetting setting)
    {
        // TODO : 상하좌우 여백, 정렬 등도 따져야함

        var newTextSize = CalculateTextSize(textSeg.text, setting);                                             // 텍스트 영역 크기 미리 구하기


        // 새 텍스트 엘레먼트 세팅

        var newTextElem = new SnapshotElems.Text(setting);

        newTextElem.text           = textSeg.text;
        newTextElem.fontSize       = setting.FontSize;
        newTextElem.Color          = Color.white;                     //TODO
        newTextElem.Alpha          = 1;
        newTextElem.TransitionTime = setting.TextTransitionTime;      //TODO
        newTextElem.MakeItUnique();

        newTextElem.InitialState.Alpha = 0;
        newTextElem.FinalState.Alpha   = 0;

        // 새 텍스트 엘레먼트 - 위치 세팅 (시작 위치만. 끝 위치는 프로세스 끝에 결정된다)

        Vector2 screenDim = FSNEngine.Instance.ScreenDimension;                                                 // (계산용) 화면 크기
        Vector3 fadeinpos;

        switch (setting.CurrentFlowDirection)                                                                                   // 흐름 방향에 따라 시작 위치를 지정해준다
        {
        case FSNInGameSetting.FlowDirection.Up:
            fadeinpos = new Vector3(-screenDim.x / 2, -screenDim.y / 2);
            break;

        case FSNInGameSetting.FlowDirection.Down:
            fadeinpos = new Vector3(-screenDim.x / 2, screenDim.y / 2 + newTextSize.y);
            break;

        case FSNInGameSetting.FlowDirection.Right:
            fadeinpos = new Vector3(-screenDim.x / 2 - newTextSize.x, 0);
            break;

        case FSNInGameSetting.FlowDirection.Left:
            fadeinpos = new Vector3(screenDim.x / 2, 0);
            break;

        default:
            throw new System.Exception("HUH???");
        }
        ApplySideTextMargin(ref fadeinpos, setting, setting.CurrentFlowDirection);              // 여백 적용

        newTextElem.Position = fadeinpos;                                                       // 나중에 일괄적으로 이동시킬 것이기 때문에 시작 위치랑 화면 밖 위치를 같게 설정한다
        newTextElem.InitialState.Position = fadeinpos;

        if (!setting.StackTexts || setting.ScreenCenterText)                                                    // 텍스트를 쌓지 않는 경우, 기존 텍스트를 전부 Clear한다.
        // 가운데텍스트 모드일 경우에도 (텍스트 쌓기 여부와는 상관 없이) 기존 텍스트를 지운다.
        {
            ClearTextsToDirection(layer, setting.CurrentFlowDirection);
        }

        if (setting.ScreenCenterText)                                                                                                   // * 가운데 텍스트일 경우,
        {
            layer.AddElement(newTextElem);                                                                                              // 텍스트 엘리멘트 추가

            var posToCenter = newTextElem.Position;
            TextPositionToCenter(ref posToCenter, newTextSize, setting.CurrentFlowDirection, setting);            // 텍스트 중앙으로 움직이기
            newTextElem.Position = posToCenter;
            CopyCurrentToFinal(newTextElem);                                                                      // 임시 FinalState
        }
        else
        {                                                                                                                       // * 일반 텍스트
            layer.AddElement(newTextElem);                                                                                      // 텍스트 엘리멘트 추가
            PushTextsToDirection(layer, setting.CurrentFlowDirection, newTextSize, setting.ParagraphSpacing);                   // 텍스트 일괄적으로 해당 방향으로 밀기
        }
    }