Beispiel #1
0
    void DosukoiSide(float timing)
    {
        if (NAct.NowDamage == DamagePattern.None)
        {
            float hitBoxX = NAct.X;
            float hitBoxY = NAct.Y;
            // 左方向の場合はマイナス値とする。
            float leftMinusVector = (NAct.leftFlag) ? -1 : 1;

            if (NAct.vx != 0 ||
                NAct.dashFlag)
            {
                NAct.NowAttack = AttackPattern.DosukoiWalk;
            }
            else
            {
                NAct.NowAttack = AttackPattern.Dosukoi;
            }

            switch (timing)
            {
            case 1:

                NAct.hitBox
                    = new Rect(hitBoxX + (0.6f * leftMinusVector),
                               hitBoxY + 0.2f,
                               0.6f, 0.5f);

                NSound.SEPlay(SEPattern.attack);

                break;

            case 2:
                NAct.hitBox
                    = new Rect(hitBoxX + (0.6f * leftMinusVector),
                               hitBoxY + 0.2f,
                               0.6f, 0.5f);

                NAct.NowAttack = AttackPattern.None;

                break;

            default:
                break;
            }
        }
    }
Beispiel #2
0
    /// <summary>
    /// 熱血インプットで入力された値を元に、
    /// 移動・ダッシュ・ブレーキの状態を管理
    /// </summary>
    public void MoveMain(NekketsuSound NSound)
    {
        if (!NAct.squatFlag &&
            NAct.NowDamage == DamagePattern.None)
        {
            #region 歩き

            // もし、右キーが押されたら
            if (NAct.XInputState == XInputState.XRightPushMoment ||
                NAct.XInputState == XInputState.XRightPushButton)
            {
                if (!NAct.brakeFlag)
                {
                    NAct.leftFlag = false;
                }

                if (!NAct.dashFlag && !NAct.jumpFlag && !NAct.brakeFlag)
                {
                    NAct.vx = NAct.speed; // 右に歩く移動量を入れる
                }
            }
            // もし、左キーが押されたら ★else if でもキーボード同時押し対策NG★
            else if (NAct.XInputState == XInputState.XLeftPushMoment ||
                     NAct.XInputState == XInputState.XLeftPushButton)
            {
                if (!NAct.brakeFlag)
                {
                    NAct.leftFlag = true;
                }

                if (!NAct.dashFlag && !NAct.jumpFlag && !NAct.brakeFlag)
                {
                    NAct.vx = -NAct.speed; // 左に歩く移動量を入れる
                }
            }

            // もし、上キーが押されたら
            if (NAct.ZInputState == ZInputState.ZBackPushMoment ||
                NAct.ZInputState == ZInputState.ZBackPushButton)
            {
                if (!NAct.jumpFlag)
                {
                    NAct.vz = NAct.speed * Settings.Instance.Move.ZWalkSpeed; // 上に進む移動量を入れる(熱血っぽく奥行きは移動量小)
                }
            }
            // もし、下キーが押されたら
            else if (NAct.ZInputState == ZInputState.ZFrontPushMoment ||
                     NAct.ZInputState == ZInputState.ZFrontPushButton)
            {
                if (!NAct.jumpFlag)
                {
                    NAct.vz = -NAct.speed * Settings.Instance.Move.ZWalkSpeed; // 下に進む移動量を入れる(熱血っぽく奥行きは移動量小)
                }
            }

            #endregion

            #region ダッシュ

            if (!NAct.dashFlag)
            {
                // 非ダッシュ状態で、横移動し始めた瞬間か?
                if (NAct.XInputState == XInputState.XRightPushMoment ||
                    NAct.XInputState == XInputState.XLeftPushMoment)
                {
                    if (!pushMove)
                    {
                        //ダッシュしたい方向と同じ方向キーが押されている
                        if (XInputDashVector == NAct.XInputState)
                        {
                            //ダッシュの準備をする
                            pushMove    = true;
                            leftDash    = NAct.leftFlag;
                            nowTimeDash = 0;
                        }

                        //ダッシュしようとしている方向を覚えておく
                        XInputDashVector = NAct.XInputState;
                    }
                    else
                    {
                        // ダッシュ準備済なので、ダッシュしてよい状態か判断
                        if (canDash && !NAct.jumpFlag &&
                            leftDash == NAct.leftFlag &&
                            nowTimeDash <= NAct.nextButtonDownTimeDash)
                        {
                            NAct.dashFlag = true;
                        }
                    }
                }
                else
                {
                    // 非ダッシュ状態で、ダッシュ準備済か?
                    // 1度左右キーが押された状態で、ダッシュ受付時間内にもう一度左右キーが押された時
                    if (pushMove &&
                        !NAct.brakeFlag)
                    {
                        // 時間計測
                        nowTimeDash += Time.deltaTime;

                        if (nowTimeDash > NAct.nextButtonDownTimeDash)
                        {
                            pushMove         = false;
                            canDash          = false;
                            XInputDashVector = XInputState.XNone;
                        }
                        else
                        {
                            canDash = true;
                        }
                    }
                }
            }
            else
            {   //ダッシュ済の場合
                if (!NAct.brakeFlag)
                {
                    // ダッシュ中に逆方向を押した場合
                    if (leftDash != NAct.leftFlag)
                    {
                        /// @@@ if文で代入の値を変える場合は、
                        /// バグを避けるためにも可能な限り代入を一箇所にしたほうがよいですね。
                        /// ここで言えば
                        /// int GetSign(bool leftDash) { return leftDash ? -1 : +1;}
                        /// というような関数を作っておき、
                        ///  NAct.vx = GetSign(leftDash) * NAct.speed * Settings.Instance.Move.DashSpeed;
                        /// と書けば1行ですむ上に、左右で値を間違えてしまうことなどもなくなります。
                        if (leftDash)
                        {
                            // 左ダッシュの移動量を入れる
                            NAct.vx = -NAct.speed * Settings.Instance.Move.DashSpeed;
                        }
                        else
                        {
                            // 右ダッシュの移動量を入れる
                            NAct.vx = NAct.speed * Settings.Instance.Move.DashSpeed;;
                        }

                        NAct.dashFlag = false;
                        pushMove      = false;
                        canDash       = false;

                        // ブレーキ状態
                        if (!NAct.jumpFlag)
                        {
                            NAct.brakeFlag = true;
                            NSound.SEPlay(SEPattern.brake);
                        }
                    }
                    else
                    {
                        // ダッシュ中の加速を計算する。
                        // ダッシュ中は方向キー入力なしで自動で進む。(クロカン・障害ふう)
                        if (NAct.leftFlag)
                        {
                            // 左ダッシュの移動量を入れる
                            NAct.vx = -NAct.speed * Settings.Instance.Move.DashSpeed;
                        }
                        else
                        {
                            // 右ダッシュの移動量を入れる
                            NAct.vx = NAct.speed * Settings.Instance.Move.DashSpeed;;
                        }
                    }
                }
            }

            // ブレーキ処理
            if (!NAct.jumpFlag && NAct.brakeFlag)
            {
                if (NAct.leftFlag)
                {
                    NAct.vx = NAct.speed * NAct.st_brake; // 右に進む移動量を入れる
                }
                else
                {
                    NAct.vx = -NAct.speed * NAct.st_brake; // 左に進む移動量を入れる
                }
                // ブレーキ状態の時間計測
                nowTimebrake += Time.deltaTime;

                // ブレーキ状態解除
                if (nowTimebrake > Settings.Instance.Move.BrakeTime)
                {
                    NAct.brakeFlag = false;
                    nowTimebrake   = 0;
                }
            }

            // ダッシュ入力受付中
            if (pushMove)
            {
                // 時間計測
                nowTimeDash += Time.deltaTime;

                if (nowTimeDash > NAct.nextButtonDownTimeDash)
                {
                    pushMove         = false;
                    canDash          = false;
                    XInputDashVector = XInputState.XNone;
                }
            }
            #endregion
        }
    }
Beispiel #3
0
    /// @@@Main関数が長くなってしまっているので、
    /// 処理ごとに関数を切るのが良いでしょう
    /// regionで切るのも良いですが、
    /// regionは変数のスコープが長いままにもなりますし
    /// 今後さらに膨れてきた際にバグの発見が難しくなることや
    /// チームで仕事をする際に、流れを知らない他の人が目的箇所にたどり着くため
    /// 上から延々と処理を追うことになってしまうので、
    /// 処理の見出しを作るような感覚で、可能な限り関数で小分けにしておくのが良いかと思います
    /// 自分はVSCODEを使っていますが、
    /// VisualStudioにもメソッドの抽出があると思いますので、
    /// https://docs.microsoft.com/ja-jp/visualstudio/ide/reference/extract-method?view=vs-2019
    /// 積極的に使ってみてください。
    public void HurtBoxMain(NekketsuSound NSound)
    {
        DamagePattern otherPlayerDmgPtn = DamagePattern.None;

        float otherPlayerX = 0;
        float otherPlayerZ = 0;

        float otherPlayerPunch = 0;
        float otherPlayerKick  = 0;

        AttackPattern otherPlayerAttack = AttackPattern.None;
        Rect          otherHitBox       = new Rect(0, 0, 0, 0);

        // 自分から見て、他プレイヤーの情報を取得
        switch (NAct.gameObject.name)
        {
        case "Player1":
            otherPlayerDmgPtn = NAct.Nmng.Player2.NowDamage;
            otherPlayerX      = NAct.Nmng.Player2.X;
            otherPlayerZ      = NAct.Nmng.Player2.Z;
            otherPlayerPunch  = NAct.Nmng.Player2.st_punch;
            otherPlayerKick   = NAct.Nmng.Player2.st_kick;
            otherPlayerAttack = NAct.Nmng.Player2.NowAttack;
            otherHitBox       = NAct.Nmng.Player2.hitBox;
            break;

        case "Player2":
            otherPlayerDmgPtn = NAct.Nmng.Player1.NowDamage;
            otherPlayerX      = NAct.Nmng.Player1.X;
            otherPlayerZ      = NAct.Nmng.Player1.Z;
            otherPlayerPunch  = NAct.Nmng.Player1.st_punch;
            otherPlayerKick   = NAct.Nmng.Player1.st_kick;
            otherPlayerAttack = NAct.Nmng.Player1.NowAttack;
            otherHitBox       = NAct.Nmng.Player1.hitBox;
            break;
        }

        // ダウン状態の時()
        if (NAct.NowDamage == DamagePattern.UmaTaore ||
            NAct.NowDamage == DamagePattern.UmaTaoreUp)
        {
            // まだ失格していない
            if (NAct.DeathFlag == DeathPattern.None)
            {
                // ダウンした瞬間、体力0なら失格
                if (NAct.st_life <= 0)
                {
                    if (NAct.DeathFlag == DeathPattern.None)
                    {
                        NSound.SEPlay(SEPattern.death);
                    }

                    NAct.DeathFlag = DeathPattern.deathNow;
                }
                else
                {
                    // たいりょくがまだあるので起き上がり

                    //現在計測中のダウン時間が、ダウン時間(各キャラのステータス値)を超えた場合
                    if (NAct.st_downTime < NAct.nowDownTime)
                    {
                        NAct.NowDamage = DamagePattern.SquatGetUp; //起き上がり(しゃがみ)
                        NAct.squatFlag = true;

                        NAct.nowDownTime = 0;
                    }
                    NAct.nowDownTime += Time.deltaTime;
                }
            }
        }
        else
        {
            //ふっとばされ中
            if (NAct.BlowUpFlag)
            {
                // ふっとび処理
                if (NAct.BlowUpNowTime <= NAct.BlowUpInitalVelocityTime)
                {
                    NAct.Y += 0.1f;

                    if (otherPlayerAttack == AttackPattern.DosukoiBack)
                    {
                        NAct.Z += 0.1f;
                    }

                    if (otherPlayerAttack == AttackPattern.DosukoiFront)
                    {
                        NAct.Z -= 0.1f;
                    }

                    // 他プレイヤーの攻撃が前か後ろか(おおよそ)で、前後に吹っ飛ぶか分ける
                    // @@@相手の位置ではなく向きで攻撃方向をとった方がいいですね
                    // 旋風脚のように相対位置で飛び方向を決めたほうがいいものもあるのでそれは技にフラグをもたせるのが良いです
                    if (otherPlayerX <= NAct.X)
                    {
                        NAct.X += 0.01f;
                    }
                    else
                    {
                        NAct.X -= 0.01f;
                    }
                }
                else
                {
                    //固定吹っ飛び時間終了なので、落下させる
                    NAct.Y -= 0.08f;

                    //ふっとび状態から地面についたら
                    if (NAct.Y <= 0)
                    {
                        NAct.Y          = 0;
                        NAct.BlowUpFlag = false;;
                        NAct.downDamage = 0;

                        //ふっとびパターンによってダウン状態(ドット絵)を変更
                        if (NAct.NowDamage == DamagePattern.UmaBARF)
                        {
                            NAct.NowDamage = DamagePattern.UmaTaoreUp;
                        }
                        else if (NAct.NowDamage == DamagePattern.UmaOttotto)
                        {
                            NAct.NowDamage = DamagePattern.UmaTaore;
                        }

                        NAct.BlowUpNowTime = 0;
                    }
                }

                NAct.BlowUpNowTime += Time.deltaTime;
            }
            else
            {
                // プレイヤー1~4の喰らい判定
                if ((otherPlayerZ - 0.4f <= NAct.Z && NAct.Z <= otherPlayerZ + 0.4f) &&
                    NAct.hurtBox.Overlaps(otherHitBox) &&
                    otherHitBox != Settings.Instance.Attack.AttackNone)
                {
                    NAct.NowAttack = AttackPattern.None;
                    NAct.dashFlag  = false; //被弾したらダッシュ解除

                    if (NAct.NowDamage == DamagePattern.None)
                    {
                        // 喰らったダメージを計算
                        switch (otherPlayerAttack)
                        {
                        case AttackPattern.JumpKick:
                            NAct.downDamage += otherPlayerKick;
                            NAct.st_life    -= otherPlayerKick;

                            if (NAct.st_life <= 0)
                            {
                                NAct.st_life = 0;
                            }
                            break;

                        default:
                            NAct.downDamage += otherPlayerPunch;
                            NAct.st_life    -= otherPlayerPunch;

                            if (NAct.st_life <= 0)
                            {
                                NAct.st_life = 0;
                            }
                            break;
                        }
                    }

                    // 自キャラが空中にいるか?
                    if (!NAct.jumpFlag)
                    {
                        //自キャラが地上にいるので通常のダメージ計算

                        // ダメージ喰らい状態に変更
                        if (NAct.downDamage < 20)
                        {
                            if (NAct.vx == 0 && NAct.vz == 0)
                            {
                                if (otherPlayerX <= NAct.X)
                                {
                                    NAct.NowDamage = DamagePattern.UmaHitFront;
                                }
                                else
                                {
                                    NAct.NowDamage = DamagePattern.UmaHitBack;
                                }
                            }
                            else
                            {
                                NAct.NowDamage = DamagePattern.UmaHogeWalk;
                            }

                            //ダメージ受けた瞬間から、蓄積ダメージリセットまでの時間を計測
                            NAct.nowHogeTime = 0;
                        }
                        else if (NAct.NowDamage != DamagePattern.UmaHoge &&
                                 20 <= NAct.downDamage)
                        {
                            NAct.NowDamage = DamagePattern.UmaHoge;

                            //ダメージ受けた瞬間から、蓄積ダメージリセットまでの時間を計測
                            NAct.nowHogeTime = 0;
                        }
                        else if (NAct.NowDamage == DamagePattern.UmaHoge &&
                                 30 <= NAct.downDamage)
                        {
                            // 他プレイヤーの攻撃が前か後ろか(おおよそ)と、
                            // 自キャラの向きから吹っ飛びアニメを切り替え
                            if (otherPlayerX <= NAct.X)
                            {
                                if (NAct.leftFlag)
                                {
                                    NAct.NowDamage = DamagePattern.UmaBARF;
                                }
                                else
                                {
                                    NAct.NowDamage = DamagePattern.UmaOttotto;
                                }
                            }
                            else
                            {
                                if (NAct.leftFlag)
                                {
                                    NAct.NowDamage = DamagePattern.UmaOttotto;
                                }
                                else
                                {
                                    NAct.NowDamage = DamagePattern.UmaBARF;
                                }
                            }

                            NAct.BlowUpFlag = true;

                            NAct.downDamage = 0;
                        }
                        else
                        {
                        }
                    }
                    else
                    {
                        //自分がジャンプ状態のときに、
                        //攻撃を受けた際は蓄積ダメージを考慮せず、固定でダウン状態へ

                        // 他プレイヤーの攻撃が前か後ろか(おおよそ)と、
                        // 自キャラの向きから吹っ飛びアニメを切り替え
                        if (otherPlayerX <= NAct.X)
                        {
                            if (NAct.leftFlag)
                            {
                                NAct.NowDamage = DamagePattern.UmaBARF;
                            }
                            else
                            {
                                NAct.NowDamage = DamagePattern.UmaOttotto;
                            }
                        }
                        else
                        {
                            if (NAct.leftFlag)
                            {
                                NAct.NowDamage = DamagePattern.UmaOttotto;
                            }
                            else
                            {
                                NAct.NowDamage = DamagePattern.UmaBARF;
                            }
                        }

                        NAct.BlowUpFlag = true;

                        NAct.downDamage = 0;

                        //ジャンプ中にダウンしたので、ジャンプ周りをリセット
                        NAct.vy        = 0;
                        NAct.jumpFlag  = false;
                        NAct.jumpSpeed = 0;
                    }

                    if (NAct.NowDamage == DamagePattern.UmaHitBack ||
                        NAct.NowDamage == DamagePattern.UmaHitFront)
                    {
                        // ノックバック処理
                        if (otherPlayerX <= NAct.X)
                        {
                            if (otherPlayerAttack == AttackPattern.DosukoiBack)
                            {
                                NAct.Z += 0.02f;
                            }
                            else if (otherPlayerAttack == AttackPattern.DosukoiFront)
                            {
                                NAct.Z -= 0.02f;
                            }
                            else
                            {
                                NAct.X += 0.02f;
                            }
                        }
                        else
                        {
                            if (otherPlayerAttack == AttackPattern.DosukoiBack)
                            {
                                NAct.Z += 0.02f;
                            }
                            else if (otherPlayerAttack == AttackPattern.DosukoiFront)
                            {
                                NAct.Z -= 0.02f;
                            }
                            else
                            {
                                NAct.X -= 0.02f;
                            }
                        }
                    }

                    // 攻撃効果音
                    if (otherPlayerAttack == AttackPattern.Dosukoi ||
                        otherPlayerAttack == AttackPattern.DosukoiBack ||
                        otherPlayerAttack == AttackPattern.DosukoiFront)
                    {
                        NSound.SEPlay(SEPattern.hit);
                    }
                    else
                    {
                        NSound.SEPlay(SEPattern.hijiHit);
                    }
                }
                else
                {
                    NAct.NowDamage = DamagePattern.None;
                }

                // ★デバッグ用 うにうにくんダメージ★
                if ((NAct.Nmng.uni.Z - 0.4f <= NAct.Z && NAct.Z <= NAct.Nmng.uni.Z + 0.4f) &&
                    NAct.hurtBox.Overlaps(NAct.Nmng.uni.hitBoxTEST))
                {
                    NAct.NowDamage = DamagePattern.UmaHoge;
                    if (!NSound.audioSource.isPlaying)
                    {
                        NAct.BlowUpFlag = true;
                        NAct.NowDamage  = DamagePattern.UmaBARF;
                        NSound.SEPlay(SEPattern.hit);
                    }

                    //ジャンプ中にダウンを考慮して、ジャンプ周りをリセット
                    NAct.vy       = 0;
                    NAct.jumpFlag = false;
                }
            }
        }
    }
Beispiel #4
0
    /// <summary>
    /// 熱血インプットで入力された値を元に、
    /// 移動・ダッシュ・ブレーキの状態を管理
    /// </summary>
    public void MoveMain(NekketsuSound NSound)
    {
        if (!NAct.NJumpV.squatFlag &&
            NAct.NAttackV.NowDamage == DamagePattern.None &&
            NAct.NAttackV.DamageRigidityFlag == false)
        {
            #region 歩き

            // もし、右キーが押されたら
            if (NAct.NMoveV.XInputState == XInputState.XRightPushMoment ||
                NAct.NMoveV.XInputState == XInputState.XRightPushButton)
            {
                if (!NAct.NMoveV.brakeFlag)
                {
                    NAct.NMoveV.leftFlag = false;
                }

                if (!NAct.NMoveV.dashFlag && !NAct.NJumpV.jumpFlag && !NAct.NMoveV.brakeFlag)
                {
                    NAct.NVariable.vx = NAct.NVariable.st_speed; // 右に歩く移動量を入れる
                }
            }
            // もし、左キーが押されたら ★else if でもキーボード同時押し対策NG★
            else if (NAct.NMoveV.XInputState == XInputState.XLeftPushMoment ||
                     NAct.NMoveV.XInputState == XInputState.XLeftPushButton)
            {
                if (!NAct.NMoveV.brakeFlag)
                {
                    NAct.NMoveV.leftFlag = true;
                }

                if (!NAct.NMoveV.dashFlag && !NAct.NJumpV.jumpFlag && !NAct.NMoveV.brakeFlag)
                {
                    NAct.NVariable.vx = -NAct.NVariable.st_speed; // 左に歩く移動量を入れる
                }
            }

            // もし、上キーが押されたら
            if (NAct.NMoveV.ZInputState == ZInputState.ZBackPushMoment ||
                NAct.NMoveV.ZInputState == ZInputState.ZBackPushButton)
            {
                if (!NAct.NJumpV.jumpFlag)
                {
                    NAct.NVariable.vz = NAct.NVariable.st_speed * Settings.Instance.Move.ZWalkSpeed; // 上に進む移動量を入れる(熱血っぽく奥行きは移動量小)
                }
            }
            // もし、下キーが押されたら
            else if (NAct.NMoveV.ZInputState == ZInputState.ZFrontPushMoment ||
                     NAct.NMoveV.ZInputState == ZInputState.ZFrontPushButton)
            {
                if (!NAct.NJumpV.jumpFlag)
                {
                    NAct.NVariable.vz = -NAct.NVariable.st_speed * Settings.Instance.Move.ZWalkSpeed; // 下に進む移動量を入れる(熱血っぽく奥行きは移動量小)
                }
            }

            #endregion

            #region ダッシュ

            if (!NAct.NMoveV.dashFlag)
            {
                // 非ダッシュ状態で、横移動し始めた瞬間か?
                if (NAct.NMoveV.XInputState == XInputState.XRightPushMoment ||
                    NAct.NMoveV.XInputState == XInputState.XLeftPushMoment)
                {
                    if (!pushMove)
                    {
                        //ダッシュしたい方向と同じ方向キーが押されている
                        if (XInputDashVector == NAct.NMoveV.XInputState)
                        {
                            //ダッシュの準備をする
                            pushMove    = true;
                            leftDash    = NAct.NMoveV.leftFlag;
                            nowTimeDash = 0;
                        }

                        //ダッシュしようとしている方向を覚えておく
                        XInputDashVector = NAct.NMoveV.XInputState;
                    }
                    else
                    {
                        // ダッシュ準備済なので、ダッシュしてよい状態か判断
                        if (canDash && !NAct.NJumpV.jumpFlag &&
                            leftDash == NAct.NMoveV.leftFlag &&
                            nowTimeDash <= NAct.NMoveV.nextButtonDownTimeDash)
                        {
                            NAct.NMoveV.dashFlag = true;
                        }
                    }
                }
                else
                {
                    // 非ダッシュ状態で、ダッシュ準備済か?
                    // 1度左右キーが押された状態で、ダッシュ受付時間内にもう一度左右キーが押された時
                    if (pushMove &&
                        !NAct.NMoveV.brakeFlag)
                    {
                        // 時間計測
                        nowTimeDash += Time.deltaTime;

                        if (nowTimeDash > NAct.NMoveV.nextButtonDownTimeDash)
                        {
                            pushMove         = false;
                            canDash          = false;
                            XInputDashVector = XInputState.XNone;
                        }
                        else
                        {
                            canDash = true;
                        }
                    }
                }
            }
            else
            {   //ダッシュ済の場合
                if (!NAct.NMoveV.brakeFlag)
                {
                    // ダッシュ中に逆方向を押した場合
                    if (leftDash != NAct.NMoveV.leftFlag)
                    {
                        // 逆方向の移動量を入れる
                        NAct.NVariable.vx = GetSign(NAct.NMoveV.leftFlag) * NAct.NVariable.st_speed * Settings.Instance.Move.DashSpeed;

                        NAct.NMoveV.dashFlag = false;
                        pushMove             = false;
                        canDash = false;

                        // ブレーキ状態
                        if (!NAct.NJumpV.jumpFlag)
                        {
                            NAct.NMoveV.brakeFlag = true;
                            NSound.SEPlay(SEPattern.brake);
                        }
                    }
                    else
                    {
                        // ダッシュの移動量を入れる
                        NAct.NVariable.vx = GetSign(NAct.NMoveV.leftFlag) * NAct.NVariable.st_speed * Settings.Instance.Move.DashSpeed;
                    }
                }
            }

            // ブレーキ処理
            if (!NAct.NJumpV.jumpFlag && NAct.NMoveV.brakeFlag)
            {
                // ブレーキ中の移動量を入れる
                NAct.NVariable.vx = GetSign(!NAct.NMoveV.leftFlag) * NAct.NVariable.st_speed * NAct.NVariable.st_brake;

                // ブレーキ状態の時間計測
                nowTimebrake += Time.deltaTime;

                // ブレーキ状態解除
                if (nowTimebrake > Settings.Instance.Move.BrakeTime)
                {
                    NAct.NMoveV.brakeFlag = false;
                    nowTimebrake          = 0;
                }
            }

            // ダッシュ入力受付中
            if (pushMove)
            {
                // 時間計測
                nowTimeDash += Time.deltaTime;

                if (nowTimeDash > NAct.NMoveV.nextButtonDownTimeDash)
                {
                    pushMove         = false;
                    canDash          = false;
                    XInputDashVector = XInputState.XNone;
                }
            }
            #endregion
        }
    }
Beispiel #5
0
    /// <summary>
    /// ジャンプ・空中制御・しゃがみ状態を管理
    /// </summary>
    public void JumpMain(NekketsuSound NSound)
    {
        #region 空中制御

        if (!NAct.NJumpV.squatFlag &&
            NAct.NJumpV.jumpFlag &&
            NAct.NAttackV.NowDamage == DamagePattern.None)
        {
            if (!NAct.NMoveV.dashFlag)
            {
                // 空中制御 疑似X軸
                switch (JumpX)
                {
                case VectorX.None:

                    if (JumpZ == VectorZ.None)
                    {
                        if (!leftJumpFlag)
                        {
                            // 右向き時の垂直ジャンプ中に右キーが押されたら
                            if (NAct.NMoveV.XInputState == XInputState.XRightPushMoment ||
                                NAct.NMoveV.XInputState == XInputState.XRightPushButton)
                            {
                                //垂直ジャンプ時の加速を設定
                                NAct.NJumpV.jumpSpeed +=
                                    NAct.NVariable.st_speed * Settings.Instance.Move.VerticalJumpSpeed;
                                NAct.NVariable.vx   += NAct.NJumpV.jumpSpeed;   // 右に進む移動量を入れる
                                NAct.NMoveV.leftFlag = false;
                            }
                        }
                        else
                        {
                            // 左向き時の垂直ジャンプ中に左キーが押されたら ★else if でもキーボード同時押し対策NG★
                            if (NAct.NMoveV.XInputState == XInputState.XLeftPushMoment ||
                                NAct.NMoveV.XInputState == XInputState.XLeftPushButton)
                            {
                                //垂直ジャンプ時の加速を設定
                                NAct.NJumpV.jumpSpeed +=
                                    NAct.NVariable.st_speed * Settings.Instance.Move.VerticalJumpSpeed;
                                NAct.NVariable.vx   += -NAct.NJumpV.jumpSpeed;   // 左に進む移動量を入れる
                                NAct.NMoveV.leftFlag = true;
                            }
                        }
                    }
                    break;

                case VectorX.Right:
                    // もし、右空中移動中に、左キーが押されたら  ★else if でもキーボード同時押し対策NG★
                    if (NAct.NMoveV.XInputState == XInputState.XLeftPushMoment ||
                        NAct.NMoveV.XInputState == XInputState.XLeftPushButton)
                    {
                        //シャンプスピードを弱めていく
                        NAct.NJumpV.jumpSpeed *= Settings.Instance.Move.OppositeJumpSpeed;
                        NAct.NMoveV.leftFlag   = true;
                    }

                    NAct.NVariable.vx += NAct.NJumpV.jumpSpeed;     // 右に進む移動量を入れる

                    break;

                case VectorX.Left:
                    // もし、左空中移動中に、右キーが押されたら
                    if (NAct.NMoveV.XInputState == XInputState.XRightPushMoment ||
                        NAct.NMoveV.XInputState == XInputState.XRightPushButton)
                    {
                        //シャンプスピードを弱めていく
                        NAct.NJumpV.jumpSpeed *= Settings.Instance.Move.OppositeJumpSpeed;
                        NAct.NMoveV.leftFlag   = false;
                    }

                    NAct.NVariable.vx += -NAct.NJumpV.jumpSpeed;     // 左に進む移動量を入れる

                    break;
                }
            }

            // 空中制御 疑似Z軸
            switch (JumpZ)
            {
            case VectorZ.None:
                //FC・再っぽく、垂直ジャンプからのZ入力は受け付けない とりあえず。
                break;

            case VectorZ.Up:
                // もし、奥へ空中移動中に、下キー(手前)が押されたら  ★else if でもキーボード同時押し対策NG★
                if (NAct.NMoveV.ZInputState == ZInputState.ZFrontPushMoment ||
                    NAct.NMoveV.ZInputState == ZInputState.ZFrontPushButton)
                {
                    //シャンプスピードを弱めていく
                    NAct.NJumpV.jumpSpeed *= Settings.Instance.Move.OppositeJumpSpeed;
                }

                NAct.NVariable.vz += NAct.NJumpV.jumpSpeed * 0.4f;     // 上に進む移動量を入れる(熱血っぽく奥行きは移動量小)

                break;

            case VectorZ.Down:
                // もし、手前へ空中移動中に、奥キー(上)が押されたら  ★else if でもキーボード同時押し対策NG★
                if (NAct.NMoveV.ZInputState == ZInputState.ZBackPushMoment ||
                    NAct.NMoveV.ZInputState == ZInputState.ZBackPushButton)
                {
                    //シャンプスピードを弱めていく
                    NAct.NJumpV.jumpSpeed *= Settings.Instance.Move.OppositeJumpSpeed;
                }

                NAct.NVariable.vz += -NAct.NJumpV.jumpSpeed * 0.4f;     // 下に進む移動量を入れる(熱血っぽく奥行きは移動量小)

                break;
            }
        }

        #endregion

        #region ジャンプ処理

        if (!NAct.NJumpV.squatFlag &&
            !NAct.NMoveV.brakeFlag &&
            NAct.NAttackV.NowDamage == DamagePattern.None)
        {
            // ジャンプした瞬間
            if (!NAct.NJumpV.jumpFlag &&
                NAct.NJumpV.JumpButtonState == JumpButtonPushState.PushMoment)
            {
                // 着地状態
                if (NAct.NVariable.Y <= NAct.NVariable.mapY)
                {
                    NAct.NJumpV.jumpFlag = true;                       // ジャンプの準備
                    miniJumpFlag         = false;                      // 小ジャンプ
                    NAct.NVariable.vy   += NAct.NMoveV.InitalVelocity; // ジャンプした瞬間に初速を追加
                    jumpAccelerate       = true;                       // ジャンプ加速度の計算を行う

                    if (NAct.NMoveV.XInputState == XInputState.XNone &&
                        NAct.NMoveV.ZInputState == ZInputState.ZNone)
                    {
                        // 垂直ジャンプ
                        NAct.NJumpV.jumpSpeed = 0;
                    }
                    else
                    {
                        // 垂直ジャンプ以外(横・奥移動ジャンプ)
                        NAct.NJumpV.jumpSpeed = NAct.NVariable.st_speed;
                    }


                    // 空中制御用に、ジャンプした瞬間に入力していたキーを覚えておく(X軸)
                    if (NAct.NMoveV.XInputState == XInputState.XRightPushMoment ||
                        NAct.NMoveV.XInputState == XInputState.XRightPushButton ||
                        (NAct.NMoveV.dashFlag && !NAct.NMoveV.leftFlag))
                    {
                        JumpX = VectorX.Right;
                    }
                    else if (NAct.NMoveV.XInputState == XInputState.XLeftPushMoment ||
                             NAct.NMoveV.XInputState == XInputState.XLeftPushButton ||
                             (NAct.NMoveV.dashFlag && NAct.NMoveV.leftFlag))
                    {
                        JumpX = VectorX.Left;
                    }
                    else
                    {
                        // 垂直ジャンプであれば、向いていた方向を覚えておく。
                        JumpX        = VectorX.None;
                        leftJumpFlag = NAct.NMoveV.leftFlag;
                    }

                    // 空中制御用に、ジャンプした瞬間に入力していたキーを覚えておく(Z軸)
                    if (NAct.NMoveV.ZInputState == ZInputState.ZBackPushMoment ||
                        NAct.NMoveV.ZInputState == ZInputState.ZBackPushButton)
                    {
                        JumpZ = VectorZ.Up;
                    }
                    else if (NAct.NMoveV.ZInputState == ZInputState.ZFrontPushMoment ||
                             NAct.NMoveV.ZInputState == ZInputState.ZFrontPushButton)
                    {
                        JumpZ = VectorZ.Down;
                    }
                    else
                    {
                        JumpZ = VectorZ.None;
                    }
                }
                NSound.SEPlay(SEPattern.jump);
            }

            // ジャンプ状態
            if (NAct.NJumpV.jumpFlag)
            {
                // ジャンプボタンが離されたかつ、上昇中かつ、小ジャンプフラグが立ってない
                // 小ジャンプ処理
                if (NAct.NJumpV.JumpButtonState == JumpButtonPushState.ReleaseButton &&
                    NAct.NVariable.vy > 0 &&
                    !miniJumpFlag)
                {
                    // 小ジャンプ用に、現在の上昇速度を半分にする
                    NAct.NVariable.vy = NAct.NVariable.vy * 0.5f;

                    // 小ジャンプフラグTrue
                    miniJumpFlag = true;
                }

                // ジャンプ中の重力加算(重力は変化せず常に同じ値が掛かる)
                NAct.NVariable.vy += NAct.NJumpV.Gravity;

                //座標へのジャンプ力反映
                NAct.NVariable.Y += NAct.NVariable.vy;

                // 着地判定
                if (NAct.NVariable.Y <= NAct.NVariable.mapY)
                {
                    NAct.NJumpV.jumpFlag        = false;
                    NAct.NJumpV.JumpButtonState = JumpButtonPushState.None; // ジャンプボタン非押下状態とする。
                    NAct.NMoveV.dashFlag        = false;                    //ダッシュ中であれば、着地時にダッシュ解除
                    NAct.NJumpV.squatFlag       = true;                     //しゃがみ状態
                    NAct.NJumpV.jumpSpeed       = 0;                        //ジャンプ速度初期化

                    if (NAct.NMoveV.InitalVelocity != 0)
                    {
                        // 内部Y軸変数を初期値に戻す
                        NAct.NVariable.vy = 0;
                    }
                }
            }
        }

        // しゃがみ状態の処理
        if (NAct.NJumpV.squatFlag)
        {
            // しゃがみ状態の時間計測
            nowTimesquat += Time.deltaTime;

            // しゃがみ状態解除
            if (nowTimesquat > Settings.Instance.Move.SquatTime)
            {
                NAct.NJumpV.squatFlag = false;
                nowTimesquat          = 0;
            }
        }
        #endregion
    }
Beispiel #6
0
    /// @@@Main関数が長くなってしまっているので、
    /// 処理ごとに関数を切るのが良いでしょう
    /// regionで切るのも良いですが、
    /// regionは変数のスコープが長いままにもなりますし
    /// 今後さらに膨れてきた際にバグの発見が難しくなることや
    /// チームで仕事をする際に、流れを知らない他の人が目的箇所にたどり着くため
    /// 上から延々と処理を追うことになってしまうので、
    /// 処理の見出しを作るような感覚で、可能な限り関数で小分けにしておくのが良いかと思います
    /// 自分はVSCODEを使っていますが、
    /// VisualStudioにもメソッドの抽出があると思いますので、
    /// https://docs.microsoft.com/ja-jp/visualstudio/ide/reference/extract-method?view=vs-2019
    /// 積極的に使ってみてください。
    public void HurtBoxMain(NekketsuSound NSound)
    {
        //他プレイヤーの攻撃情報取得
        getOtherPlayerInfo();

        // 自分がダウン状態の時()
        if (NAct.NAttackV.NowDamage == DamagePattern.UmaTaore ||
            NAct.NAttackV.NowDamage == DamagePattern.UmaTaoreUp)
        {
            // まだ失格していない
            if (NAct.NVariable.DeathFlag == DeathPattern.None)
            {
                // ダウンした瞬間、たいりょく0なら失格
                if (NAct.NVariable.st_life <= 0)
                {
                    if (NAct.NVariable.DeathFlag == DeathPattern.None)
                    {
                        NSound.SEPlay(SEPattern.death);
                    }

                    NAct.NVariable.DeathFlag = DeathPattern.deathNow;
                }
                else
                {
                    // たいりょくがまだあるので起き上がり

                    //現在計測中のダウン時間が、ダウン時間(各キャラのステータス値)を超えた場合
                    if (NAct.NVariable.st_downTime < NAct.NAttackV.nowDownTime)
                    {
                        NAct.NAttackV.NowDamage = DamagePattern.SquatGetUp; //起き上がり(しゃがみ)
                        NAct.NJumpV.squatFlag   = true;

                        NAct.NAttackV.nowDownTime = 0;
                    }
                    NAct.NAttackV.nowDownTime += Time.deltaTime;
                }
            }
        }
        else
        {
            //ダウン状態ではない
            //→ふっ飛ばされているか or 被ダメ状態


            //ふっとばされ中
            if (NAct.NAttackV.BlowUpFlag)
            {
                // ふっとび処理
                if (NAct.NAttackV.BlowUpNowTime <= NAct.NAttackV.BlowUpInitalVelocityTime)
                {
                    NAct.NVariable.Y += 0.1f;

                    if (otherPlayerAttack == AttackPattern.DosukoiBack)
                    {
                        NAct.NVariable.Z += 0.1f;
                    }

                    if (otherPlayerAttack == AttackPattern.DosukoiFront)
                    {
                        NAct.NVariable.Z -= 0.1f;
                    }

                    // 他プレイヤーの攻撃が前か後ろか(おおよそ)で、前後に吹っ飛ぶか分ける
                    // @@@相手の位置ではなく向きで攻撃方向をとった方がいいですね
                    // 旋風脚のように相対位置で飛び方向を決めたほうがいいものもあるのでそれは技にフラグをもたせるのが良いです
                    if (otherPlayerX <= NAct.NVariable.X)
                    {
                        NAct.NVariable.X += 0.01f;
                    }
                    else
                    {
                        NAct.NVariable.X -= 0.01f;
                    }

                    //TODO:
                    //相手の向いている方向で吹っ飛びを考慮した下記修正だと、
                    //攻撃終わり(=otherPlayerAttackがNone)のときNG
                    //相手のキメ攻撃を覚えて置く必要があるのか?
                    //NAct.X += GetSign(otherPlayerLeftFlag, otherPlayerAttack) * 0.01f;
                }
                else
                {
                    //固定吹っ飛び時間終了なので、落下させる
                    NAct.NVariable.Y -= 0.08f;

                    //ふっとび状態から地面についたら
                    if (NAct.NVariable.Y <= NAct.NVariable.mapY)
                    {
                        NAct.NVariable.Y          = 0;
                        NAct.NAttackV.BlowUpFlag  = false;;
                        NAct.NAttackV.downDamage  = 0;
                        NAct.NAttackV.nowHogeTime = 100;

                        //ふっとびパターンによってダウン状態(ドット絵)を変更
                        if (NAct.NAttackV.NowDamage == DamagePattern.UmaBARF)
                        {
                            NAct.NAttackV.NowDamage = DamagePattern.UmaTaoreUp;
                        }
                        else if (NAct.NAttackV.NowDamage == DamagePattern.UmaOttotto)
                        {
                            NAct.NAttackV.NowDamage = DamagePattern.UmaTaore;
                        }

                        NAct.NAttackV.BlowUpNowTime = 0;
                    }
                }

                NAct.NAttackV.BlowUpNowTime += Time.deltaTime;
            }
            else
            {
                //被ダメ状態を分岐させる処理

                // プレイヤー1~4の喰らい判定
                if ((otherPlayerZ - 0.4f <= NAct.NVariable.Z && NAct.NVariable.Z <= otherPlayerZ + 0.4f) &&
                    NAct.NAttackV.hurtBox.Overlaps(otherHitBox) &&
                    otherHitBox != Settings.Instance.Attack.AttackNone)
                {
                    NAct.NAttackV.NowAttack = AttackPattern.None;
                    NAct.NMoveV.dashFlag    = false; //被弾したらダッシュ解除

                    //他プレイヤーの攻撃ヒットフラグが、False(未ヒット)
                    //かつ、自身のダメージパターンが被ダメを受け付ける状態か?
                    if (!otherPlayeAttackHit &&
                        (NAct.NAttackV.NowDamage == DamagePattern.None ||
                         NAct.NAttackV.NowDamage == DamagePattern.SquatGetUp ||
                         NAct.NAttackV.NowDamage == DamagePattern.UmaHitBack ||
                         NAct.NAttackV.NowDamage == DamagePattern.UmaHitFront ||
                         NAct.NAttackV.NowDamage == DamagePattern.UmaHoge ||
                         NAct.NAttackV.NowDamage == DamagePattern.UmaHogeWalk))
                    {
                        // 喰らったダメージを計算
                        switch (otherPlayerAttack)
                        {
                        case AttackPattern.JumpKick:
                            NAct.NAttackV.downDamage += otherPlayerKick;
                            NAct.NVariable.st_life   -= otherPlayerKick;

                            if (NAct.NVariable.st_life <= 0)
                            {
                                NAct.NVariable.st_life = 0;
                            }
                            break;

                        default:
                            NAct.NAttackV.downDamage += otherPlayerPunch;
                            NAct.NVariable.st_life   -= otherPlayerPunch;

                            if (NAct.NVariable.st_life <= 0)
                            {
                                NAct.NVariable.st_life = 0;
                            }
                            break;
                        }
                    }

                    // 自キャラが空中にいるか?
                    if (!NAct.NJumpV.jumpFlag)
                    {
                        //自キャラが地上にいるので通常のダメージ計算

                        //被ダメ硬直処理
                        //被ダメ中で、硬直時間未計測の場合、硬直時間計測開始する
                        if (NAct.NAttackV.DamageRigidityFlag == false &&
                            (NAct.NAttackV.NowDamage == DamagePattern.UmaHoge ||
                             NAct.NAttackV.NowDamage == DamagePattern.UmaHitBack ||
                             NAct.NAttackV.NowDamage == DamagePattern.UmaHitFront))
                        {
                            NAct.NAttackV.DamageRigidityFlag = true;
                        }

                        // ダメージ喰らい状態に変更
                        if (NAct.NAttackV.downDamage < 20)
                        {
                            if (NAct.NVariable.vx == 0 && NAct.NVariable.vz == 0)
                            {
                                if (otherPlayerX <= NAct.NVariable.X)
                                {
                                    NAct.NAttackV.NowDamage = DamagePattern.UmaHitFront;
                                }
                                else
                                {
                                    NAct.NAttackV.NowDamage = DamagePattern.UmaHitBack;
                                }
                            }
                            else
                            {
                                NAct.NAttackV.NowDamage = DamagePattern.UmaHogeWalk;
                            }

                            //被ダメ状態1(ダメージ軽)
                            NAct.NAttackV.RigidityDmgTime = Settings.Instance.Attack.Damage1Time;

                            NAct.NAttackV.NowDmgRigidity = NAct.NAttackV.NowDamage;

                            //ダメージ受けた瞬間から、蓄積ダメージリセットまでの時間を計測
                            NAct.NAttackV.nowHogeTime = 0;
                        }
                        else if (NAct.NAttackV.NowDamage != DamagePattern.UmaHoge &&
                                 20 <= NAct.NAttackV.downDamage)
                        {
                            NAct.NAttackV.NowDamage = DamagePattern.UmaHoge;

                            //被ダメ状態2(ダメージ重 凹み状態)
                            NAct.NAttackV.RigidityDmgTime = Settings.Instance.Attack.Damage2Time;

                            NAct.NAttackV.NowDmgRigidity = NAct.NAttackV.NowDamage;

                            //ダメージ受けた瞬間から、蓄積ダメージリセットまでの時間を計測
                            NAct.NAttackV.nowHogeTime = 0;
                        }
                        else if (NAct.NAttackV.NowDamage == DamagePattern.UmaHoge &&
                                 30 <= NAct.NAttackV.downDamage)
                        {
                            //吹っ飛び状態に切り替え
                            changeBlowUp();
                        }
                    }
                    else
                    {
                        //自分がジャンプ状態のときに、
                        //攻撃を受けた際は蓄積ダメージを考慮せず、固定でダウン状態へ

                        //吹っ飛び状態に切り替え
                        changeBlowUp();

                        //ジャンプ中にダウンしたので、ジャンプ周りをリセット
                        NAct.NVariable.vy     = 0;
                        NAct.NJumpV.jumpFlag  = false;
                        NAct.NJumpV.jumpSpeed = 0;
                    }

                    if (NAct.NAttackV.NowDamage == DamagePattern.UmaHitBack ||
                        NAct.NAttackV.NowDamage == DamagePattern.UmaHitFront)
                    {
                        //ノックバック処理
                        knockBack();
                    }

                    // 攻撃効果音
                    if (!otherPlayeAttackHit)
                    {
                        if (otherPlayerAttack == AttackPattern.Dosukoi ||
                            otherPlayerAttack == AttackPattern.DosukoiBack ||
                            otherPlayerAttack == AttackPattern.DosukoiFront)
                        {
                            NSound.SEPlay(SEPattern.hit);
                        }
                        else
                        {
                            NSound.SEPlay(SEPattern.hijiHit);
                        }
                    }

                    //攻撃をヒットさせたプレイヤーの攻撃ヒットフラグをTrueにする。
                    //(1度の攻撃で連続ヒットさせない為)
                    setOtherPlayerAttackHitFlag();
                }
                else
                {
                    NAct.NAttackV.NowDamage = DamagePattern.None;
                }

                // ★デバッグ用 うにうにくんダメージ★
                if ((NAct.Nmng.uni.Z - 0.4f <= NAct.NVariable.Z && NAct.NVariable.Z <= NAct.Nmng.uni.Z + 0.4f) &&
                    NAct.NAttackV.hurtBox.Overlaps(NAct.Nmng.uni.hitBoxTEST))
                {
                    NAct.NAttackV.NowDamage = DamagePattern.UmaHoge;
                    if (!NSound.audioSource.isPlaying)
                    {
                        NAct.NAttackV.BlowUpFlag = true;
                        NAct.NAttackV.NowDamage  = DamagePattern.UmaBARF;
                        NSound.SEPlay(SEPattern.hit);
                    }

                    //ジャンプ中にダウンを考慮して、ジャンプ周りをリセット
                    NAct.NVariable.vy    = 0;
                    NAct.NJumpV.jumpFlag = false;
                }
            }
        }
    }