Exemplo n.º 1
0
 //#################
 //	プレイヤーにあたった時
 //#################
 void OnCollisionEnter(Collision collis)
 {
     if (collis.gameObject.CompareTag("Player"))
     {
         this.nextStep = STEP.ATTACK;
         GameRoot.log("playTime : " + GameRoot.gameTimer);
         GameRoot.log("Enemy -> ATTACK");
     }
 }
Exemplo n.º 2
0
 //#################
 //	プレイヤーの攻撃にあたった時
 //#################
 void OnTriggerEnter(Collider collis)
 {
     if (collis.CompareTag("AttackRange"))
     {
         this.nextStep = STEP.DAMAGED;
         GameRoot.log("playTime : " + GameRoot.gameTimer);
         GameRoot.log("Enemy -> DAMAGED");
     }
 }
Exemplo n.º 3
0
 //#################
 //	敵との衝突処理
 //#################
 //OncollisionEnter()はFixedUpdate()より後、Update()より前に実行される
 void OnCollisionEnter(Collision collis)
 {
     if (collis.gameObject.CompareTag("Enemy"))
     {
         this.nextStep = STEP.DAMAGED;
         GameRoot.log("playTime : " + GameRoot.gameTimer);
         GameRoot.log("PLAYER -> DAMAGED");
     }
 }
Exemplo n.º 4
0
    //#################
    //	Update
    //#################
    void Update()
    {
        Vector3 velocity = this.rgbody.velocity;

        //-------------------------//
        //	状態の切り替えチェック
        //-------------------------//
        //このUpdateまでに次ステップが決まっていなければ
        //次ステップの状態を現ステップと変えるべきかどうかチェックする
        //ジャンプが押されたか、着地しているか、などなど
        //特に状態を変えなくてよい場合、nextStepはNONEのままになる
        if (this.nextStep == STEP.NONE)
        {
            switch (this.step)
            {
            case STEP.IDLE:
                break;

            case STEP.RUN:
                break;

            case STEP.ATTACK:                   //Playerと接触した時<-OnCollisionEnter
                if (attackEndTimer < 0.0f)
                {
                    this.nextStep = STEP.ATTACK_END;
                }
                break;

            case STEP.DAMAGED:                  //AttackRangeと接触した時<-OnTriggerEnter
                break;

            default:
                break;
            }
        }

        //=========================//
        //	状態変化時の初期処理
        //=========================//
        //次ステップが決まっている場合、それは状態が変化するということなので
        //その際に必要な処理を実行
        //状態が変化しない場合はこの中には入らない
        //whileを使っているので、nextStepがNONEにならない限り、繰り返し処理し続ける
        while (this.nextStep != STEP.NONE)
        {
            this.step     = this.nextStep;
            this.nextStep = STEP.NONE;

            switch (this.step)
            {
            case STEP.IDLE:
                break;

            case STEP.RUN:
                anime.Play("idle");
                break;

            case STEP.ATTACK:
                //ATTACK_ENDまでのカウントダウンタイマー
                attackEndTimer = ATTACK_END_TIME;

                velocity.x = 0.0f;
                anime.Play("special");
                break;

            case STEP.ATTACK_END:
                break;

            case STEP.DAMAGED:
                //ふっとび
                velocity.x = BLOWOFF_SPEED;                     //ふっとばされる勢い
                velocity.y = Mathf.Sqrt(2.0f * 9.8f * BLOWOFF_HEIGHT);
                velocity.z = 0.0f;

                //やられモーション
                anime.Play("wound");
                break;

            default:
                break;
            }
        }

        //=========================//
        //	毎フレームの処理
        //=========================//
        //現ステップの状態に応じた各種処理
        //移動速度の調整など
        switch (this.step)
        {
        case STEP.IDLE:
            break;

        case STEP.RUN:
            velocity.x = -1 * SPEED;
            break;

        case STEP.ATTACK:
            //ATTACK_ENDまでのタイマーをカウントダウン
            attackEndTimer -= Time.deltaTime;
            break;

        case STEP.ATTACK_END:
            //消える
            GameRoot.log("playTime : " + GameRoot.gameTimer);
            GameRoot.log("Enemy -> Destroy");

            Destroy(this.gameObject);
            break;

        case STEP.DAMAGED:
            break;

        default:
            break;
        }

        this.rgbody.velocity = velocity;
    }
Exemplo n.º 5
0
    //#################
    //	FixedUpdate
    //#################
    //BGMのテンポと合わせたい動作はここへ書く
    //1フレーム内で複数回呼ばれることもあるので、
    //インプット探知など、物理演算以外の処理は書かないこと。
    void FixedUpdate()
    {
        if (GameRoot.soundBeat == true)         //拍を叩くタイミングのみ実行
        //-------------------------//
        //	状態の切り替えチェック
        //-------------------------//
        //このFixedUpdateまでに次ステップが決まっていなければ
        //次ステップの状態を現ステップと変えるべきかどうかチェックする
        //特に状態を変えなくてよい場合、nextStepはNONEのままになる
        {
            if (this.nextStep == STEP.NONE)
            {
                switch (this.step)
                {
                case STEP.IDLE:
                    if (GameRoot.soundBeatCounter == TIME_FRAMEIN)
                    {
                        this.nextStep = STEP.FRAMEIN;
                    }
                    break;

                case STEP.FRAMEIN:
                    this.nextStep = STEP.STANDBY;
                    break;

                case STEP.STANDBY:
                    if (GameRoot.soundBeatCounter == TIME_JUMPTO)
                    {
                        this.nextStep = STEP.JUMPTO;
                    }
                    break;

                default:
                    break;
                }
            }

            //=========================//
            //	状態変化時の初期処理
            //=========================//
            //次ステップが決まっている場合、それは状態が変化するということなので
            //その際に必要な処理を実行
            //状態が変化しない場合はこの中には入らない
            //whileを使っているので、nextStepがNONEにならない限り、繰り返し処理し続ける
            while (this.nextStep != STEP.NONE)
            {
                this.step     = this.nextStep;
                this.nextStep = STEP.NONE;

                switch (this.step)
                {
                case STEP.FRAMEIN:
                    rgbody.AddForce(
                        -1.0f * FRAMEIN_SPEED,
                        FRAMEIN_HEIGHT,
                        0,
                        ForceMode.VelocityChange
                        );
                    GameRoot.log("playTime : " + GameRoot.gameTimer);
                    GameRoot.log("Enemy -> FRAME IN");
                    GameRoot.log("Enemy Position : " + this.transform.position);
                    break;

                case STEP.JUMPTO:                       //プレイヤーへ飛びかかる
                    rgbody.AddForce(
                        -1.0f * JUMPTO_SPEED,
                        JUMPTO_HEIGHT,
                        0,
                        ForceMode.VelocityChange
                        );
                    GameRoot.log("playTime : " + GameRoot.gameTimer);
                    GameRoot.log("Enemy -> JUMP TO PLAYER");
                    break;

                default:
                    break;
                }
            }

            //=========================//
            //	毎フレームの処理
            //=========================//
            //現ステップの状態に応じた各種処理
            switch (this.step)
            {
            case STEP.STANDBY:                  //待機状態のその場ジャンプ
                rgbody.AddForce(
                    Vector3.up * STANDBY_HEIGHT,
                    ForceMode.VelocityChange
                    );
                GameRoot.log("playTime : " + GameRoot.gameTimer);
                GameRoot.log("Enemy -> STAND BY JUMP");
                break;

            default:
                break;
            }
        }        //拍を叩くタイミングのみ実行するifのおわり
    }
Exemplo n.º 6
0
    //#################
    //	Update
    //#################
    void Update()
    {
        //現在のアニメーション名を取得
        AnimatorStateInfo animStateInfo = animator.GetCurrentAnimatorStateInfo(0);

        //-------------------------//
        //	状態の切り替えチェック
        //-------------------------//
        //このUpdateまでに次ステップが決まっていなければ
        //次ステップの状態を現ステップと変えるべきかどうかチェックする
        //ジャンプが押されたか、着地しているか、などなど
        //特に状態を変えなくてよい場合、nextStepはNONEのままになる
        if (this.nextStep == STEP.NONE)
        {
            switch (this.step)
            {
            case STEP.IDLE:
                //攻撃ボタンが押されたら、次のステップ->ATTACK
                if (Input.GetMouseButtonDown(0))
                {
                    this.nextStep = STEP.ATTACK;
                    GameRoot.log("playTime : " + GameRoot.gameTimer);
                    GameRoot.log("PLAYER -> ATTACK");
                }
                break;

            case STEP.ATTACK:
                //攻撃判定有効時間が終わっていたら、次のステップ->IDLE
                if (attackTimer < 0.0f)
                {
                    this.nextStep = STEP.IDLE;
                    GameRoot.log("playTime : " + GameRoot.gameTimer);
                    GameRoot.log("PLAYER -> ATTACK END");
                }
                break;

            case STEP.DAMAGED:
                //現在のアニメーションが「待機」になっていたら、次のステップ->IDLE
                if (animStateInfo.fullPathHash == stateIdle)
                {
                    this.nextStep = STEP.IDLE;
                    GameRoot.log("playTime : " + GameRoot.gameTimer);
                    GameRoot.log("PLAYER -> IDLE");
                }
                break;

            default:
                break;
            }
        }

        //=========================//
        //	状態変化時の初期処理
        //=========================//
        //次ステップが決まっている場合、それは状態が変化するということなので
        //その際に必要な処理を実行
        //状態が変化しない場合はこの中には入らない
        //whileを使っているので、nextStepがNONEにならない限り、繰り返し処理し続ける
        while (this.nextStep != STEP.NONE)
        {
            this.step     = this.nextStep;
            this.nextStep = STEP.NONE;
            //一旦すべてのアニメーションフラグをfalseにする
            animator.SetBool("Idle", false);
            animator.SetBool("Attack", false);
            animator.SetBool("Damaged", false);

            switch (this.step)
            {
            case STEP.IDLE:
                //攻撃判定オブジェクトを非アクティブにする
                //DAMAGEDから遷移してくる時は必要ない処理なのだが…
                transform.Find("AttackRange").gameObject.SetActive(false);
                animator.SetBool("Idle", true);
                break;

            case STEP.ATTACK:
                animator.SetBool("Attack", true);
                //攻撃判定オブジェクトをアクティブにする
                transform.Find("AttackRange").gameObject.SetActive(true);
                //攻撃判定発生タイマーを起動
                attackTimer = ATTACK_TIME;

                //ボイス
                vc = (Random.value < 0.5)? VCattack01 : VCattack02;
                audiosrc.PlayOneShot(vc);

                GameRoot.log("PLAYER -> ATTACK START!");
                break;

            case STEP.DAMAGED:
                animator.SetBool("Damaged", true);
                //ボイス
                vc = (Random.value < 0.5)? VCdamaged01 : VCdamaged02;
                audiosrc.PlayOneShot(vc);
                break;

            default:
                break;
            }
        }

        //=========================//
        //	毎フレームの処理
        //=========================//
        //現ステップの状態に応じた各種処理
        //移動速度の調整など
        switch (this.step)
        {
        case STEP.IDLE:
            break;

        case STEP.ATTACK:
            //攻撃判定発生タイマーをカウントダウン
            attackTimer -= Time.deltaTime;
            break;

        case STEP.DAMAGED:
            break;

        default:
            break;
        }
    }