Example #1
0
    public void update(float delta_time)
    {
        if (m_IsPlaying)
        {
            if (m_IsDebugStopMode)
            {
                bool mouse_button = Input.GetMouseButton(0);
                if (mouse_button)
                {
                    BattleParam.setAutoPlayState(BattleParam.AutoPlayState.CANCEL);
                    m_IsPlaying     = false;
                    m_AutoPlayPhase = AutoPlayPhase.NOT_INPUT_PHASE;
                    return;
                }
            }

            BattleParam.BattlePhase battle_phase = BattleParam.getBattlePhase();
            if (battle_phase == BattleParam.BattlePhase.INPUT ||
                battle_phase == BattleParam.BattlePhase.INPUT_HANDLING
                )
            {
                if (m_IsFullField)
                {
                    return;
                }

                Vector2 hand_pos    = new Vector2(2.0f, 5.0f); //画面外の見えない位置に初期化
                bool    is_touching = false;

                switch (m_AutoPlayPhase)
                {
                case AutoPlayPhase.NOT_INPUT_PHASE:
                {
                    // オートプレイの停止判定
                    if (m_AI.isStopAutoPlay())
                    {
                        BattleParam.setAutoPlayState(BattleParam.AutoPlayState.CANCEL);
                        m_IsPlaying     = false;
                        m_AutoPlayPhase = AutoPlayPhase.NOT_INPUT_PHASE;
                        m_IsFullField   = false;
                        return;
                    }

                    // プレイヤーフェイズに戻ってきたときにここに来る.
                    m_Timer         = 1.0f;
                    m_AutoPlayPhase = AutoPlayPhase.START_WAIT;
                }
                break;

                case AutoPlayPhase.START_WAIT:
                {
                    m_Timer -= delta_time;
                    if (m_Timer <= 0.0f)
                    {
                        m_PanelInfo = new AI.PanelInfo();
                        m_PanelInfo.m_HandElements  = new MasterDataDefineLabel.ElementType[m_BattleCardManager.m_HandArea.getCardMaxCount()];
                        m_PanelInfo.m_NextElements  = new MasterDataDefineLabel.ElementType[m_BattleCardManager.m_NextArea.getCardMaxCount()];
                        m_PanelInfo.m_FieldElements = new AI.CostInfo[m_BattleCardManager.m_FieldAreas.getFieldAreaCountMax()];
                        for (int field_idx = 0; field_idx < m_PanelInfo.m_FieldElements.Length; field_idx++)
                        {
                            m_PanelInfo.m_FieldElements[field_idx] = new AI.CostInfo(m_BattleCardManager.m_FieldAreas.getFieldArea(field_idx).getCardMaxCount());
                        }
                        m_PanelInfo.m_FieldCosts = new int[m_PanelInfo.m_FieldElements.Length];
                        m_PanelInfo.m_IsBoosts   = new bool[m_PanelInfo.m_FieldElements.Length];

                        // 思考ルーチン初期化
                        m_AI.initThink(_updatePanelInfo());

                        // リミブレスキルをチェック
                        GlobalDefine.PartyCharaIndex limit_break_skill_caster = m_AI.getLimitBreakSkillCaster();
                        if (BattleParam.IsEnableLBS(limit_break_skill_caster) == false)
                        {
                            limit_break_skill_caster = GlobalDefine.PartyCharaIndex.ERROR;
                        }

                        if (limit_break_skill_caster >= GlobalDefine.PartyCharaIndex.LEADER &&
                            limit_break_skill_caster <= GlobalDefine.PartyCharaIndex.FRIEND
                            )
                        {
                            // リミブレスキル発動
                            BattleParam.RequestLBS(limit_break_skill_caster);
                            m_AutoPlayPhase = AutoPlayPhase.NOT_INPUT_PHASE;
                            m_IsFullField   = false;
                        }
                        else
                        {
                            // パネル操作開始
                            m_PanelPutTimer        = 0.0f;
                            m_PanelPutCountGoal    = m_AI.getPanelPutCount();
                            m_PanelPutCountCurrent = 0;

                            float count_down_time = BattleSceneManager.Instance.PRIVATE_FIELD.calcCountDownTime();
                            if (count_down_time < COUNT_DOWN_TIME)
                            {
                                count_down_time = COUNT_DOWN_TIME;
                            }

                            m_PanelPutInterval = count_down_time / m_PanelPutCountGoal * (1.0f + 1.0f / m_PanelPutCountGoal);
                            m_AutoPlayPhase    = AutoPlayPhase.CARD_GET;
                        }
                    }
                }
                break;

                case AutoPlayPhase.CARD_GET:
                {
                    m_PanelPutTimer += delta_time;

                    float card_get_time = m_PanelPutCountCurrent * m_PanelPutInterval;            // カードを掴む時刻

                    if (m_PanelPutTimer >= card_get_time)
                    {
                        if (m_BattleCardManager != null)
                        {
                            if (m_BattleCardManager.m_FieldAreas.getFieldArea(0).isFull() &&
                                m_BattleCardManager.m_FieldAreas.getFieldArea(1).isFull() &&
                                m_BattleCardManager.m_FieldAreas.getFieldArea(2).isFull() &&
                                m_BattleCardManager.m_FieldAreas.getFieldArea(3).isFull() &&
                                m_BattleCardManager.m_FieldAreas.getFieldArea(4).isFull()
                                )
                            {
                                BattleSceneManager.Instance.PRIVATE_FIELD.skipCountDown();
                                m_IsFullField   = true;
                                m_AutoPlayPhase = AutoPlayPhase.NOT_INPUT_PHASE;
                                return;
                            }
                        }

                        // カウントダウンスキップ判定
                        if (m_AI.isSkipCountDown())
                        {
                            BattleSceneManager.Instance.PRIVATE_FIELD.skipCountDown();
                            m_AutoPlayPhase = AutoPlayPhase.NOT_INPUT_PHASE;
                            m_IsFullField   = false;
                            return;
                        }

                        // 思考ルーチン呼び出し
                        int hand_index  = 0;
                        int field_index = 0;
                        m_AI.execThink(ref hand_index, ref field_index, _updatePanelInfo());

                        m_StartPosition = new Vector2(hand_index, 1.0f - 0.3f);
                        m_GoalPosition  = new Vector2(field_index, 0.0f - 0.5f);

                        hand_pos    = m_StartPosition;
                        is_touching = true;

                        float card_put_time = (m_PanelPutCountCurrent + 1) * m_PanelPutInterval - CARD_PUT_TIME;            // カードを置く時刻
                        m_Duration = card_put_time - m_PanelPutTimer;
                        m_Duration = Mathf.Max(m_Duration, 0.0f);
                        m_Duration = Mathf.Min(m_Duration, CARD_MOVE_TIME_MAX);

                        m_Timer         = 0.0f;
                        m_AutoPlayPhase = AutoPlayPhase.CARD_MOVE;
                    }
                }
                break;

                case AutoPlayPhase.CARD_MOVE:
                {
                    m_PanelPutTimer += delta_time;
                    m_Timer         += delta_time;
                    if (m_Timer < m_Duration)
                    {
                        float t = m_Timer / m_Duration;

                        Vector2 vec = m_GoalPosition - m_StartPosition;
                        vec.x      *= t * t;    // 横方向は動き始めをゆっくりにする(2枚以上を掴まないようにするため)
                        vec.y      *= t;
                        hand_pos    = m_StartPosition + vec;
                        is_touching = true;
                    }
                    else
                    {
                        hand_pos    = m_GoalPosition;
                        is_touching = true;

                        m_AutoPlayPhase = AutoPlayPhase.CARD_PUT;
                    }
                }
                break;

                case AutoPlayPhase.CARD_PUT:        // タッチしていないフレームが最低1フレームはあるようにするための処理
                {
                    m_PanelPutTimer += delta_time;

                    m_PanelPutCountCurrent++;

                    hand_pos    = m_GoalPosition;
                    is_touching = false;

                    m_AutoPlayPhase = AutoPlayPhase.CARD_GET;
                }
                break;
                }

                BattleSceneManager.Instance.setOverrideTouchMode(BattleSceneManager.Instance.getCardFieldScreenPos(hand_pos.x, hand_pos.y), is_touching);
            }
            else
            {
                m_AutoPlayPhase = AutoPlayPhase.NOT_INPUT_PHASE;
                m_IsFullField   = false;
            }
        }
        else
        {
            m_AutoPlayPhase = AutoPlayPhase.NOT_INPUT_PHASE;
            m_IsFullField   = false;
        }
    }
Example #2
0
    void Update()
    {
        // 画面位置調整(アスペクト比)
        if (m_BattleLogic.m_InitialPhase >= BattleLogic.InitialPhase.QUEST_INIT)
        {
            adjustScreen();
        }

        if (m_TopRightAnchor != null)
        {
            if (SafeAreaControl.HasInstance)
            {
                RectTransform rect_transform = m_TopRightAnchor.GetComponent <RectTransform>();
                if (rect_transform != null)
                {
                    rect_transform.anchoredPosition = new Vector2(320.0f, -SafeAreaControl.Instance.bar_height);
                }
            }
        }

        // チュートリアル更新
        m_BattleTutorialManager.updateTutorial(Time.deltaTime);

        // オートプレイ
        m_BattleAutoPlay.update(Time.deltaTime);

        // タッチ乗っ取り時の手の表示
        _updateOverrideTouchHand();

        // パーティHP表示更新
        if (BattleParam.m_PlayerParty != null)
        {
            BattleParam.m_PlayerParty.updateDispHp(Time.deltaTime);
        }

        switch (m_BattleScenePhase)
        {
        case BattleScenePhase.NOT_BATTLE:
        {
            if (m_IsChangeBattleScenePhase)
            {
                m_IsChangeBattleScenePhase = false;
            }

            // 手札エリアはオブジェクトの初期化が完了したら表示できる.
            bool is_show_hand_area = m_IsShowHandArea && m_BattleLogic.m_InitialPhase >= BattleLogic.InitialPhase.QUEST_INIT;
            m_PartsGroup1.SetActive(is_show_hand_area);
            m_PartsGroup2.SetActive(false);
        }
            return;

        //break;

        case BattleScenePhase.IN_BATTLE:
            if (m_IsChangeBattleScenePhase)
            {
                m_IsChangeBattleScenePhase = false;
            }

            m_PartsGroup1.SetActive(true);
            m_PartsGroup2.SetActive(true);
            break;
        }

        if (gameObject.IsActive())
        {
            // エネミー詳細ウィンドウの制御
            if (BattleParam.m_TargetEnemyWindow != InGameDefine.SELECT_NONE)
            {
                if (m_IsShowEnemyDetailWindow == false)
                {
                    m_IsShowEnemyDetailWindow = true;
                    if (m_EnemyDetailWindowObject == null)
                    {
                        if (m_EnemyDetailWindowPrefab != null)
                        {
                            m_EnemyDetailWindowObject = GameObject.Instantiate(m_EnemyDetailWindowPrefab);
                            BattleSceneUtil.setRide(m_EnemyDetailWindowObject.transform, SceneObjReferGameMain.Instance.m_UIInstanceTargetWindowPosition.transform);
                        }
                    }

                    if (m_EnemyDetailWindowObject != null)
                    {
                        m_EnemyDetailWindowObject.SetActive(true);
                    }
                }
                else
                {
                    if (m_EnemyDetailWindowObject == null || m_EnemyDetailWindowObject.IsNullOrInactive())
                    {
                        BattleParam.m_TargetEnemyWindow = InGameDefine.SELECT_NONE;
                        m_IsShowEnemyDetailWindow       = false;
                        m_EnemyDetailWindowObject       = null;
                    }
                }
            }


            // スキル成立時プレイヤーへ向かって飛んでいくエフェクト
            MasterDataDefineLabel.ElementType[,] elements = m_BattleLogic.m_SkillIconArea.getNewSkillElementInfo();
            if (elements != null)
            {
                for (int field_idx = 0; field_idx < elements.GetLength(0); field_idx++)
                {
                    for (int idx = 0; idx < (int)GlobalDefine.PartyCharaIndex.MAX; idx++)
                    {
                        MasterDataDefineLabel.ElementType element = elements[field_idx, idx];
                        if (element != MasterDataDefineLabel.ElementType.NONE)
                        {
                            Transform  start_trans = m_BattleCardArea.GetComponent <BattleCardArea>().getEffectPosition(field_idx, BattleScene._BattleCardManager.EffectInfo.EffectPosition.FIELD_AREA);
                            Transform  goal_trans  = m_BattleLogic.m_BattlePlayerPartyViewControl.getEffectTransform((GlobalDefine.PartyCharaIndex)idx);
                            GameObject effect_obj  = EffectManager.Instance.playEffect(SceneObjReferGameMain.Instance.m_EffectPrefab.m_SkillSetupNaught, Vector3.zero, Vector3.zero, start_trans, null);

                            if (effect_obj != null)
                            {
                                effect_obj.transform.tweenToParent(goal_trans, 0.3f);
                            }
                        }
                    }
                }
            }
            m_BattleLogic.m_SkillIconArea.clearNewSkillElementInfo();
        }

        // ユーザー操作可能になってからの経過フレーム数
        {
            BattleParam.BattlePhase phase = BattleParam.getBattlePhase();
            if (phase == BattleParam.BattlePhase.INPUT ||
                phase == BattleParam.BattlePhase.INPUT_HANDLING
                )
            {
                m_InputEnableFrameCounter++;
            }
            else
            {
                m_InputEnableFrameCounter = 0;
            }
        }

        // 手札領域を暗くするマスクのオンオフ
        if (m_InputEnableFrameCounter >= 2)
        {
            m_CardMask.SetActive(false);
        }
        else
        {
            m_CardMask.SetActive(true);
        }

        // パーティUIの拡縮に応じたマスクコリジョンの制御
        {
            float offset_y = 0.0f;
            if (BattleParam.IsKobetsuHP)
            {
                if (BattleParam.isShowPartyInterfaceSkillCost())
                {
                    offset_y += 0.1f;
                }
                if (BattleParam.isShowPartyInterfaceSkillTurn())
                {
                    offset_y += 0.1f;
                }
            }
            m_UIMask.transform.localPosition = new Vector3(0.0f, offset_y, 0.0f);
        }

        // ガイド表示
        if (m_GuideDispTransform != null)
        {
            LocalSaveOption cOption = LocalSaveManager.Instance.LoadFuncOption();
            if (cOption != null)
            {
                bool is_change = false;
                if (m_InputEnableFrameCounter >= 2)
                {
                    if (m_GuideDispMode != cOption.m_OptionGuide)
                    {
                        is_change       = true;
                        m_GuideDispMode = cOption.m_OptionGuide;
                    }
                }
                else
                {
                    if (m_GuideDispMode != -1)
                    {
                        is_change       = true;
                        m_GuideDispMode = -1;
                    }
                }

                if (is_change)
                {
                    m_GuideDispTransform.gameObject.SetActive(m_GuideDispMode > 0);
                }
            }
        }
    }