【進捗報告】弾幕

Kingdom Come: Deliverance

夏も終わり、秋口らしく長雨が続き時々晴れたら蒸し暑い、という涼と暑がどっちつかずの季節になってきました。

その所為なのか私の周りでは体調を崩す人も多く、私自身も疲れが中々取れない、モチベーションが上がらない、という日々が続いていて、ゲーム制作を進めないといけないとはわかっていても何故か手にはPS4のコントローラーが握られていたり、一歩進んでは休み、一歩進んではPS4ボタンを押し、一歩進んでは15世紀初頭の中央ヨーロッパを探索する、を繰り返す進捗となっています。

『Kingdom Come: Deliverance』というゲームの話なんですが、中世暗黒時代のチェコ(ボヘミア地方)を舞台としたオープンワールドRPGで非常に自由度が高いゲーム性ながら、魔法もモンスターもない世界観が地味過ぎて日本では2万本未満のセールスとなっているゲームです。

モンハンみたいに巨大なモンスターとかダンジョンがあるわけではなく、せいぜい敵国の兵士とか野盗らを相手に剣を振ったり弓を撃ったりするだけで、主人公もイケメンでも美少女でもない無精ひげの青年だったりするので本当に見た目は地味なのですが、善人プレイも悪人プレイもどちらでもこなせる自由度の高さと、それに伴うストーリー展開の豊富さにハマってしまい、ほぼ毎日プレイしています。赤の他人の主人公を看病して救ってくれた親切な粉屋のオッサンからうける最初クエストが「死体から指輪盗んで来い」とか、暗黒時代の闇深さが現れていてメッチャ面白い。

そんな訳で

現在制作中の2.5Dシューティングゲームですが、遂に敵側の方も弾が撃てるようになりました！パチパチ。

以前の記事で書いたようにJobSystemを使って弾を動かしているのですが、平行移動に加えて公転運動と伸縮運動が行えるので色々なパターンの弾丸を作りました。

例えば

一列に並んで移動するパターン、とか

リング状に並んで移動するパターン、とか
発射時の弾の位置を変えているだけなんで簡単に作れました。

後は

巷のSTGでよく見かけるような円陣が広がりながら回転するパターン
真上から見たパターンはお馴染みでしたが、横から見るとこんな風に見えます。

最後に球状に弾丸を配置して回転

なんだか弾幕っぽい感じになりました。

まぁ弾幕STGにする気はないんですが・・・

【Unity】Animation実行中にイベントを実行する

大雨

今年はやっぱり冷夏だったのか、夏休み期間が終わるのと同時ぐらいに「猛暑日」というワードも全く聞かれなくなって、どちらかと言えば「大雨」というワードがトレンドで賑う季節になっています。
私の住んでいる福岡では2日連続で大雨・洪水警戒レベル5を達成するという偉業を成し遂げて、しかも丁度帰宅の時間でピークを迎えるとか、もう帰れないかと思った、という貴重な経験を2日連続で味わう事ができました。ありがとうございます。もう二度と御免です。

さて・・・

前回、前々回の記事で紹介した通り、やっとSTGらしく弾を撃てるようなりました。

未だ敵側の弾丸制御は未実装なんですが、やっぱり自機側だけでも弾を撃てると画面に派手さが加わりますね。

これで自機側の機能(武器)としては直線的に飛ぶ弾丸と、ロックオンターゲットに向かっての科学忍法『火の鳥』の二つになります。

ここで『火の鳥』って何？という方に説明すると、『火の鳥』言うのは下の動画のように、自機が敵に向かってKamikaze Attackする戦法の事を言います。
Kamikaze Attackの精神は最強なので、ゲーム内では最強の攻撃方法となる予定です。

二つの攻撃方法を切り替えたい

攻撃方法が二つあるのですが、各それぞれで制御するモジュールは異なります。
弾丸の方は前述のようにJobSystem(Script)にて制御しますが、『火の鳥』の方はAnimation動作で自機の動きを制御しています。

この為、攻撃方法を切り替える際には互いに同期をとる必要があるのですが、Animationを使用してオブジェクトを動かす際には、開始時にトリガーを指定するだけで、その完了を待って次の動作を行いたい場合にはちょっとした工夫が必要なります。
(・・・っていうのが今回の記事の主旨)

Script側の設定

最初にアニメーション終了時に呼び出すコールバック関数を作成します。

ここで原則としてAnimation側からコールバックを受け取れるのは、Animatorと同じオブジェクトに付与されているScriptだけになります。Animatorが別オブジェクトのスクリプトに対してコールバック関数を呼び出すことはできません。

今回の場合は『火の鳥』のアニメ動作完了後にJobSystemへ弾丸発射の依頼をするだけなので、下記のように一行だけです。 

 Animation側の設定

次にAnimation側でイベント発行(今回は完了時)のタイミングと、その時に呼び出すコールバック関数を指定します。

Animationウィンドウを開き、アニメーション終了時のKeyFrame上あたりで右クリックします。

そうするとAdd AnimationEventという吹き出しが出てくるのでそれを選択します。

選択後にInspectorウィンドウにAnimatorと同じオブジェクトに付与されているScriptのpublic関数が表示されるので、コールバック関数になるものを指定します。

指定後はこんな感じになります。

実際の動き

これらの設定後に実際のゲーム上で動作確認した結果がコレです。

次は敵側の弾丸制御かぁ・・・

【Unity】JobSystemを使って弾を回転させながら撃つ

夏の思ひで

盆過ぎあたりから秋雨前線が北上してきた影響なのか、朝夕は涼しくなって猛暑が過ぎたことを実感できる気候になってきました。
ということは夏も終わり、と言う事なんですが、社会人になってからは夏だろうが冬だろうが代わり映えのない日々を過ごしているので、夏を振り返るとか、夏の終わりを寂しく思うとか、そんな傷心な気持ちになったりしません。

まぁ、無理やり思い返してみても、夏季休暇中に二回ライブを観に行って二回とも隣の席が巨汗デブとセーラ服を着たおっさんという奇人変人だったとか、珍しく遠出をしたら何故か上司と鉢合わせになったとか、碌な思い出しかないので大人しく季節が過ぎていくのを静観したいと思います。

前回の続き

そんな訳で前回の続きとなります。

前回ではJobSystemを使って弾丸を真直ぐ飛ばす処理を作りましたが、今回はそれに回転の動きを加えてみたいと思います。
まぁ、ゲームとしては弾丸が回る必要はないんですがね。

こんな感じで回ります。

公転処理

今作中、自機の発射する弾丸は弾3つで1組の構成となっています。
弾丸はZ方向へ移動し、かつ弾3つの中心点を原点としてZ軸を回転軸に公転運動を行います。

通常、このような構成で公転運動を実装する場合、公転原点に空のオブジェクトを生成し、弾丸はその子オブジェクトして定義、親オブジェクトを回転させることで弾丸を公転させる処理を取ったりします。

が、今回は各弾丸にそれぞれに対して公転運動の計算を行います。

公転運動の計算については、@mao_氏がQuiitaに書かれた下記の記事中の「任意点周りの回転行列の算出について」の章を参考してMatrixを使用して計算しています。(なのでソースの転記はしません。ご了承ください。)

qiita.com

処理順番を制御する

公転運動はMatrixで計算するとして、弾丸はZ方向へ移動し続けるので、当然、公転原点となる場所も移動します。
なのでJobSystemを使ってZ方向への移動と公転運動を行う場合は、移動計算用のJOBと公転計算用のJOBの二つを用意して、先に移動計算用JOBでZ方向へ移動させ、その完了後に公転計算用JOBで公転運動の計算と反映を行う、という順序になります。

 

このJOBを待ち合わせて実行させるのは非常に簡単で、待ち合わせる側のJOBのSchedule関数にて第二引数に待ち合わせ対象のJOBハンドルを設定する、だけで実装できます。

    JobHandle _jobMoveHandle;           // 移動用
    JobHandle _jobRevolutionHandle;     // 公転運動用

    void Update()
    {
        // 移動用JOB領域設定
        BlockMotionUpdate obstractMoveJob = new BlockMotionUpdate()
        {
            Accessor = this._moveStructs,
            DeltaTime = Time.deltaTime,
        };

        // 公転用JOB領域設定
        RevolutionMotionUpdate revolutionJob = new RevolutionMotionUpdate()
        {
            Accessor = this._revolutionStructs,
            DeltaTime = Time.deltaTime,
        };
        
        // JobSystemの完了待ち
        this._jobMoveHandle.Complete();
        this._jobRevolutionHandle.Complete();

        // 移動後のチェック
        UpdatedCheck();
        
        // JobのSchedule発行
        this._jobMoveHandle = obstractMoveJob.Schedule(this._transformAccessArray);
        this._jobRevolutionHandle = revolutionJob.Schedule(this._transformAccessArray, _jobMoveHandle);

        // Jobの実行
        JobHandle.ScheduleBatchedJobs();
    }

上記の

  this._jobRevolutionHandle =
 revolutionJob.Schedule(this._transformAccessArray, _jobMoveHandle);

にて、第二引数に移動用のJOBハンドルを指定して、移動計算後に公転運動の計算が行われるようになります。

移動後のチェック処理(UpdatedCheck)で、移動用JOBから引き渡された出力パラメータ(NativeArray)の移動ベクトルを元に、公転運動用の原点位置を移動ベクトル分だけ移動させて公転運動用の入力パラメータ(NativeArray)へ引き渡します。

    /// <summary>
    /// 移動後のチェック処理
    /// </summary>
    public void UpdatedCheck()
    {
        for (int iCnt = 0; iCnt < _moveStructs.Length; iCnt++)
        {
            // 移動ベクトルの取得
            Vector3 CurrentVec =  this._moveStructs[iCnt].CurrentVec;
            
            // 公転原点の移動
            Vector3 RotOrigin = this._revolutionStructs[iCnt].RotOrigin;
            RotOrigin = RotOrigin + CurrentVec;
            
            // 公転運動用の入力パラメータへ反映
            this._revolutionStructs[iCnt].RotOrigin = RotOrigin;
        }
    }

上記の処理を行う為に、移動計算用JOBでは移動ベクトルを結果として保持するように変更します。

    struct MotionUpdate : IJobParallelForTransform
    {
        public NativeArray<MoveStruct> Accessor;
        public float DeltaTime;

        /// <summary>
        /// JobSystem側で実行する処理
        /// </summary>
        /// <param name="index"></param>
        /// <param name="transform"></param>
        public void Execute(int index, TransformAccess transform)
        {
            MoveStruct accessor = this.Accessor[index];

            // 動作フラグがOFFの場合は終了
            if (accessor.ActiveFLG == 0)
            {
                this.Accessor[index] = accessor;
                return;
            }
            
            // 現在の位置取得
            Vector3 nowPos = transform.position;

            // 移動方向ベクトル取得
            Vector3 purVec = accessor.purVec;

            //-------------------------
            // 移動方向ベクトルに沿って移動
            //-------------------------
            // 移動距離計算
            float vo = accessor.Vo;
            float deltaDist = vo * DeltaTime;

            // 移動後の位置計算
            Vector3 modPos = nowPos + deltaDist * purPos.normalized;

            // transformへ反映する
            transform.position = modPos;

            // 累積値の更新
            float Amount_Dist = accessor.Amount_Dist;
            Amount_Dist += deltaDist;
            accessor.Amount_Dist = Amount_Dist;

            // 今回の移動ベクトル
            accessor.CurrentVec = modPos - nowPos;
            
            // 結果保持
            this.Accessor[index] = accessor;
        }
    }

Update関数内で原点の移動を行うので公転運動計算用JOBではMatrixに沿って公転運動の計算を行うだけになります。

    /// <summary>
    /// 公転運動用計算
    /// </summary>
    struct RevolutionMotionUpdate : IJobParallelForTransform
    {
        public NativeArray<RotCalStruct> Accessor;
        public float DeltaTime;

        /// <summary>
        /// JobSystem側で実行する処理
        /// </summary>
        /// <param name="index"></param>
        /// <param name="transform"></param>
        public void Execute(int index, TransformAccess transform)
        {
            RotCalStruct accessor = this.Accessor[index];

            // 公転無しの場合は処理終了
            if (accessor.isRevFLG == 0) return;

            // 原点位置設置
            Vector3 originPoint = accessor.RotOrigin;

            // 公転計算用のMatrix取得
            // (ここは先程のリンクの記事を参考にしてください・・・)
            float rotVo = accessor.CurrentAngle;
            Matrix matrix = CalRoundAtMatrix(Vector3.zero,
                                             accessor.RodAxis,
                                             rotVo);
                                              
            // 現在の位置取得
            Vector3 nowPos = transform.position;

            // 公転計算用のMatrix取得
            Vector3 CalResPos = matrix.MultiplyPoint3x4(nowPos);

            // 計算結果をTransformに反映
            transform.position = CalResPos;

            // 結果保持
            this.Accessor[index] = accessor;

        }
    }

これを応用して

こんな感じでJOBを待ち合わせることで色々な動作が実現することができるので、この公転運動に加えて公転半径の収縮の運動も別JOBで計算するようにしました。

結果としてはこんな感じ、3つの弾丸が回りながら一点に収束していきます。

まぁ、これもSTGとしては必要な機能ではないんですが・・・

【Unity】JobSystemを使ってSTGの弾を撃つ

最初に

ちょっと前の記事で「STGだけど弾を撃たないゲームを作る」、とか言ったなぁ！

あれは嘘だ！！

バン！バン！バン！

というわけで

作業スケジュールが詰まっている割に何故か夏休みは１週間もらえたので、その期間を利用して制作中のゲームで弾が撃てるようになりました。どうもありがとう。

まぁ、上の画像でもわかるように弾丸が前に飛ぶだけの単純な動作なのですが、それだけではつまらいので、弾を撃つ処理にはJobSystemを使っています。

 JobSystemについては丁度1年ぐらい前にも記事でまとめたのですが、実際のゲームに対して利用したものを紹介するのは今回が初めてになりますね。

www.karvan1230.com

JobSystemとは

JobSystemとは、ざっくり言うと「Unityで並列処理を可能とする機能」で、これにより大量のオブジェクトを動かすような場合に、高速で処理する事が可能になる・・・らしいので大量の弾丸が動き回るようなSTGではこのJobSystemはかなり有用です。

このJobSystemにはインターフェースが幾つか用意されているのですが、今回はIJobParallelForTransformを使っています。

IJobParallelForTransformはジョブ実行中にTransformを並列に処理できるインターフェースになっているので、JobSystemでObjectの動作を制御する場合はこのインターフェースを使用した方が有益です。

Transformを並列に処理できるとはいっても、ObjectのTransformを直接扱えるわけではなく、それとリンク付けされたTransformAccessという型をJobSystemへ渡して処理することになります。

このTransformAccessに用意されているプロパティは以下の5つ

• localPosition
• localRotation
• localScale
• position
• rotation

これらのプロパティをJobSystem内で操作するとObjectのTransformに反映される、という仕組みです。

事前準備

JobSystemは専用の入出力情報(NativeArray)を事前に用意して、Update()関数内でJobSystemにジョブを発行する流れとなりますが、IJobParallelForTransformを使う場合はこの入出力情報(NativeArray)以外に、前述のTransformAccessを配列化したTransformAccessArrayも用意する必要があります。

下のソースの場合、objList内のObjectからTransformAccessArrayを生成して、入出力情報(NativeArray)の領域確保も行っています。

    /// <summary>
    /// 移動用構造体
    /// </summary>
    struct MoveStruct
    {
        public int ActiveFLG;       // 動作フラグ 0:OFF 1:ON
        public float Vo;            // 速度
        public float Amount_Dist;   // 累積の移動距離
    
        public MoveStruct(float argVo, Vector3 argPos)
        {
            this.ActiveFLG = 1;
            this.Vo = argVo;
            this.Amount_Dist = 0.0f;
        }
    }
    
    // 対象となるGameObjectリスト
    List<GameObject> objList = new List<GameObject>();
    
    /// <summary>
    /// 初期処理
    /// </summary>
    public void Init_Test()
    {
        // TransformAccessArrayの領域確保
        Transform[] transforms = new Transform[objList.Count];
        for(int iCnt = 0; iCnt < objList.Count; iCnt++)
        {
            transforms[iCnt] = objList[iCnt].transform;
        }

        TransformAccessArray transformAccessArray = new TransformAccessArray(transforms);

        // 入出力情報の領域確保
        NativeArray<MoveStruct> moveStructs 
            = new NativeArray<MoveStruct>(transformAccessArray.length, Allocator.Persistent);
    }

 領域を用意したらJobSystem内で処理する為の入力バッファの中身を埋めます。
今回の場合は移動速度を設定しています。 

    for (int i = 0; i < transformAccessArray.length; i++)
    {
        MoveStruct setStruct = new MoveStruct(velocity);
        moveStructs[i] = setStruct;
    }

ここまで用意出来たらUpdate()関数でJobSystemにジョブを発行します。

 

Updateでの処理の流れ

1. Jobのインスタンスを生成する
2. Jobへパラメータを引き渡す
3. Job処理を実行する
4. Job処理の完了を待つ

ここで注意することは、前述のようにJobSystemで処理する為の情報はNativeArrayで渡されますが、対象となるObjectのTransformはTransformAccessArrayという型でジョブには渡ってくる、ということです。

このNativeArrayとTransformAccessArrayはリンク付けはされていないので、複数のObjectを扱う場合はこちら側で意識してIndexを合わせる必要があります。

例えばJobSystemでの処理結果をNativeArrayに保持して次のJob実行時に引き渡すような処理をする場合、TransformAccessArrayとのIndexが一致していないと、Objectは意図しない動きをすることになります

また、注意する事はもう一つあって、それは

• NativeArrayの変更はJob処理の完了を待つ必要がある

ということです。

 NativeArrayの変更タイミング

実際のUpdate()関数のソースは以下のようになります。

    // Jobの終了待ち等を行うHandle
    JobHandle jobMoveHandle;           // 移動用
    
    float Threshold;                   // 閾値距離
    
    void Update()
    {
        // 移動用JOB領域設定
        MotionUpdate obstractMoveJob = new MotionUpdate()
        {
            Accessor = this._moveStructs,
            DeltaTime = Time.deltaTime,
        };

        // JobSystemの完了待ち
        this.jobMoveHandle.Complete();

        // 移動後のチェック
        UpdatedCheck();

        // Job処理実行
        this.jobMoveHandle = obstractMoveJob.Schedule(this.transformAccessArray);
        JobHandle.ScheduleBatchedJobs();
    }

    public void UpdatedCheck()
    {
        for (int iCnt = 0; iCnt < moveStructs.Length; iCnt++)
        {
            MoveStruct targetStruct = this.moveStructs[iCnt];
            
            // 累計移動距離が閾値距離を超えている場合
            if(targetStruct.Amount_Dist > Threshold)
            {
                // 動作フラグをOFFにする
                targetStruct.ActiveFLG = 0;
                this.moveStructs[iCnt] = targetStruct;
            }
        }
    }

ここでJob処理実行前に完了待ち(Complete)を行っているのが分かると思います。

これはJOB発行⇒完了待ち(同じフレーム)、よりも JOB発行⇒次フレーム⇒完了待ち、のほうがより高速化する、というTips以外にも、UpdatedCheck()でNativeArrayの情報を変更していますが、これをCompleteの後に実行しないとエラーが出る、という理由からです。

 こんな感じでエラーが大量にでる。

ちなみにJobSystem側のソースはこんな感じ、移動距離の累積をNativeArrayに保持して、次フレームのUpdatedCheck()にて参照されるようにしています。

    struct MotionUpdate : IJobParallelForTransform
    {
        public NativeArray<MoveStruct> Accessor;
        public float DeltaTime;

        /// <summary>
        /// JobSystem側で実行する処理
        /// </summary>
        /// <param name="index"></param>
        /// <param name="transform"></param>
        public void Execute(int index, TransformAccess transform)
        {
            MoveStruct accessor = this.Accessor[index];

            // 動作フラグがOFFの場合は終了
            if (accessor.ActiveFLG == 0)
            {
                this.Accessor[index] = accessor;
                return;
            }

            //-------------------------
            // Z方向へ移動
            //-------------------------
            // 移動距離計算
            float vo = accessor.Vo;
            float deltaDist = vo * DeltaTime;

            // 現在の位置取得
            Vector3 nowPos = transform.position;
            
            // transformへ反映する
            nowPos.z = nowPos.z + deltaDist;
            transform.position = nowPos;

            // 累積値の更新
            float Amount_Dist = accessor.Amount_Dist;
            Amount_Dist += deltaDist;
            accessor.Amount_Dist = Amount_Dist;

            // 結果保持
            this.Accessor[index] = accessor;
        }
    }

これでJobSystemを使用して弾丸を移動させることができるようになりました。
次回の記事では、この直進動作に回転の動きを加えてみようかと思います。

【Unity】Rigidbodyを使ってオブジェクトを吹き飛ばす

夏本番

別に夏の事は嫌いではありませんが、普通に最高気温が体温を超えるのはやめて下さい。
あと『表現の不自由』がそんなに表現したいたら中国に行って習近平の肖像でも燃して下さい。(これも表現の自由です)

壊したい

さて、現在制作中のゲームがシューティングゲームということで、当然のことながら何かしらの物が壊れるとか吹き飛ぶといった破壊表現が必要となってくるわけですが、まぁオーソドックスにパーティクルを表示してオブジェクトを非表示化する、みたいな表現だけではちょっと味気ないので、構造物が壊れて吹き飛ぶような演出も実装してみよう、というのが今回の目的。

こんな感じで壊したい

Unityではそれ(破壊処理)用のアセットもあったりして、Exploderあたりが有名なんでしょうか、メッシュ破壊系のアセットを導入すれば簡単なのですが、それなりにお値段もするし、だいたいドキュメントは英語で読むのが面倒！というわけで自力で何とかしたい。

メッシュ破壊は無理でもオブジェクト本体を飛ばすのはスクリプト何とか出来るので、そちらで実装する方法を考えます。

Rigidbodyを使う

Unityでは物理演算はエンジン側で行ってくれるので、有難くそちらを利用します。

RigidbodyにはAddExplosionForceというメソッドが用意されていて、こちらはその名前の通り、爆発の威力、爆発点、爆発半径を与えると爆発の状態をエミュレートした力をRigidbody加えてくれます。

Rigidbody.AddExplosionForce(
		float Force, 		// 爆発の威力
		Vector3 Position, 	// 爆発点
		float Radius);		// 爆発半径

例えば複数のオブジェクトで構成されている構造体に対して、オブジェクトそれぞれにこのAddExplosionForceを適用してやればまさに爆弾が爆発したような演出が可能になる。。。はず。

ターゲット

今回は以下のような六角形の床と天板、柱が並んでいる簡単な構造体を使ってみました。
当然のことならが全てのオブジェクトにはColliderとRigidbodyが設定されています。

 

これらにAddExplosionForceで力を加えてやります。ここで第二引数のPositionにはワールド座標を指定することに注意です。ローカル座標ではありません。

また、吹き飛ばしたい全てのオブジェクトのRigidbodyに対してAddExplosionForceを加えることが必要です。

今回のターゲットの場合は全て構造体の子オブジェクトとして定義しているので、Findでオブジェクトを取得し、そのオブジェクに対してGetComponentからRigidbodyを取り出してAddExplosionForceを加えます。

float ExplosionPosition = this.transform.position;

foreach (Transform child in ExplosionObjRoot)
{
	child.GetComponent<Rigidbody>()
			.AddExplosionForce(ExplosionForce,
                               ExplosionPosition,
                               ExplosionRadius);
}

で、構造物の中央のワールド座標からAddExplosionForceを加えた結果がこれ

あ、いや、わかるけどさー。もうちょっと、こう・・・

というわけで、爆発点を構造体中央からちょっとだけずらして指定すると

オブジェクトの移動に回転が加わるようになりました。

ただ、これでもちょっと味気ないので、今度は床と天板の中に小さいオブジェクトを仕込んでやり、そちらにもAddExplosionForceを加えるように変更。

ごちゃごちゃしているのが仕込んだオブジェクト

これらに対しても先ほどと同じようにAddExplosionForceを加え、かつ、0.1秒後に床と天板のオブジェクト自体を非表示化する処理を追加します。

これでいいか・・・

で、これを実際のゲームに組み込んでみました。

どうでしょうか？破壊されているように見えますかね？

【Unity】オブジェクトの衝突位置を取得する

暑い・・・

去年と比べて今年は全然暑くないなぁ、とか思っていたら梅雨明けと同時に蒸し暑い季節がやってきました。

兎に角、動くたびに汗をかくので制汗シートが欠かせないのですが、この前、薬局で売っていたICE-Typeというやつを購入してみたら、室内だと冷えすぎて逆に痛いです。

シートには４０枚分とか書いてるんですが、どうしよう。

本題

さて、ご存じのように次回作は2.5Dのシューティングゲームになる予定なのですが、2.5Dというだけあってある程度広い空間(ステージ)の中を強制スクロールで進んでいく形式になっています。

なので自機の移動範囲をそのステージ内に収める必要があるのですが、この『ステージ内に収める』という仕様を満たすために外壁となるオブジェクトを設定して、その外壁に自機がぶつかったら強制的にステージ内に戻す、みたいな処理を作ることにしました。

つまり今回はステージの外壁部分との衝突を判定しよう、というお話。

衝突判定

通常、Unityで衝突判定を行う場合は「当てる側」「当てられる側」の両方にColliderコンポーネントを設定して、OnTrigger系関数かOnCollision系関数で判定する手法を取ります。

衝突判定にOnTriggerとOnCollisionの二種類あるのは、OnCollisionを使う場合はCollider以外に物理演算用のコンポーネント『Rigidbody』をオブジェクトに設定する必要があるためで、「動くオブジェクト=Rigidbody有り」「動かないオブジェクト=Rigidbody無し」みたいな使い分けを行う場合のために、OnTrigger系関数とOnCollision系関数の二種類が用意されています。

ただ、OnTrigger系関数を使う場合は衝突の有無は判定できますが、衝突したオブジェクトはすり抜けしまいます。また、衝突が発生した正確な位置は分からないため、衝突位置にパーティクル等のエフェクトを表示したい場合には、Collider.ClosestPoint()を使って求めた「コライダー内の最も近い点」を衝突位置として扱う事になります。

今回の場合、外壁とぶつかったら自機はステージの中へ戻ってほしいのでOnCollisionを使う方針にしました。

OnCollisionを使うために

前述のようにOnCollisionを使うためにはColliderに加えてRigidbodyが必要となります。また、ColliderにはMeshColliderを使用しているためConvexオプションをONにします。ConvexオプションはMeshCollider同士の衝突判定有無の設定です。

これを自機と外壁のオブジェクトどちらにも設定します。

自機側のMeshCollider(見え辛いけど…)

自機側のInspector設定

OnCollisionで衝突を検知するには外壁側にもRigidbodyが必要なのですが、外壁部分は動かないオブジェクトなのでIsKinematicオプションをONにして物理演算を無効に設定します。

ただIsKinematicをONにしても衝突によるRigidbodyの影響は受けるので、自機に比べてMass(重量)を大きく設定します。

外壁側のColliderとInspector設定

 スクリプト側の処理

ここまで設定すれば衝突時にOnCollision系関数が呼ばれるようになります。

自機側のOnCollisionEnter(衝突発生時)にて衝突位置を求めて、その衝突位置から自機へ向かうベクトルの方向にAddForceで力を加えてやれば自機がステージ内に戻ってくれます。

 

/// <summary>
/// 衝突発生時の処理
/// </summary>
/// <param name="collision">衝突したCollider</param>
private void OnCollisionEnter(Collision collision)
{
	float boundsPower = 10.0f;
	
	// 衝突位置を取得する
	Vector3 hitPos = collision.contacts[0].point;
	
	// 衝突位置から自機へ向かうベクトルを求める
	Vector3 boundVec = this.transform.position - hitPos;
	
	// 逆方向にはねる
	Vector3 forceDir = boundsPower * boundVec.normalized;
	this.GetComponent<Rigidbody>().AddForce(forceDir, ForceMode.Impulse);
}

上のソースでは直に取得していますが、GetComponentでRigidbodyを取得している箇所は、Start関数などで事前に取得しておく方が負荷が少ないです。

動作確認

実際に動かしてみるとこんな感じになります。
見た目が地味だったので、上の処理に加えて衝突位置にパーティクルを表示するようにしています。

 

 まぁ、パーティクルをつけても地味ですが・・・

【進捗報告】シューティングゲームだからって弾を発射すべきなのか

世間が騒がしかった一週間

先週から今週にわたって世間では放火事件があったり、参院選があったり、大雨が降ったりと予想もできない出来事が一遍に巻き起こって色々と騒がしい一週間でしたが、こと私に限って言えば、いつも通りの安定した低空飛行で、週末も選挙に行った以外は部屋に閉じこもってPCと向き合う日々でした。

こんな私にも手を差し伸べて拾い上げてくれるような、「不安よな、動きます」とか言ってくるような心優しい先輩芸人がいれば良いのですが、なんせ人望とお金がないことには自信があるので自分で上昇気流に乗るしかないようです。

そんなわけで今回は制作中のゲームの進捗報告。

進捗報告をするよ

振り返ってみると、次回作として2.5Dのシューティングゲームを作っていることは前々からブログ内で紹介しているのですが、進捗の具合については記事にしていませんでした。

まぁ、線表を引いてプロジェクト管理しているわけではないので、ゲーム開発の進捗具合を表現するのは中々難しいのですが、今回のシューティングゲームに限って言えばコガネブログさんのシューティングゲームチュートリアル記事が指標になると思います。

baba-s.hatenablog.com

シューティングゲームを作る上で必要な作成工程をそれぞれの工程に分けて記事にしているので、この工程のどこまで終わったかを判定すれば現在の進捗具合を見極めることができます。

現在の進捗は・・・

と、いうことでそれで示せば、現在のところは背景のスクロールぐらいまでは完成していて、敵の動作パターンも増やしている状況なので20%ぐらい、ということになるでしょうか。

ただ、上記のチュートリアルでは全26回中の7回目という早い段階で取り上げられている、『弾の作成と発射』という工程、自機なり敵機なりが弾を発射する処理の作成に取り掛かるべきなんですが、未だにそこには手を付けていません。

というのも、自機にしても敵機しても弾をただ撃つだけなら簡単に作れるのですが、撃たれた弾は自機なり敵機なりに衝突するか、画面外に消えた場合に破棄もしくは回収しなくてはいけない。それに加えてただ真直ぐ飛ぶだけでは物足りないから、放射線状に動くとか、拡散するとか連帯を組むとかパターンを考えないといけないし、かつ、それらはゲーム内に数多く登場させて動かさないといけない。

ゲーム的にはただの弾だとしてもUnityの処理的には一つ一つがObjectになるので数が多くなると処理は当然重くなりますし、それに伴って高速化の手段も考えないといけない。

つまりはやる事が多すぎて手を付ける段階から二の足を踏んでいる、という感じ。
ゲーム制作ではゲーム中では簡単そうに見えるものでも意外と手のかかるものって色々と多いのですが、シューティングゲームの弾というのもその一つだと思います。オブジェクトプールを使用したりJobSystemを利用したり、弾幕用のアセットもあるし意外と手が込む。

大体、シューティングゲームだからって弾を発射すべきなのかって話ですよ。
自機が進みます、敵が来ます、かわします、進みます、かわします、クリアします、それでいいじゃない。
弾を撃ったとか撃たれたとか、玉を取ったとか取られたとかやくざの出入りじゃあるまいし、憲法九条の輝くこの日本に相応しくない、やられてもやられてもやめて下さいって言っている方が良いって作家なのかタレントなのか分からない自己顕示欲だけは高そうな女性コメンテーターも言っているように専守防衛の崇高な精神ですよ、そんな気位だけは高い時代遅れのインディゲームが一つあってもいいじゃない、って思うわけですよ。

なので、、、

ドーン

自機を弾丸にしました。

科学忍法火の鳥ですよ(知らない良い子はお父さんに聞いてね)。Kamikaze Attackの精神は最強なので、この一撃で全ての敵を倒せる仕様にします(ボスを含め)。敵をロックオンする⇒敵に向かってKamikaze Attack＝最強、これで行きます。弾が撃てない？あんなの飾りです。偉い人にはそれがわからんのですよ。

ゲームの仕様は決まった

そんな訳でSTGと言えば弾幕STGが主流となっている中、弾幕の中をかい潜りながら敵をロックしてホーミング弾を撃つとか、レーザーで一掃するとか、そんな感じのゲームにはならない予定です。主流のゲームデザインとは異なることで好き嫌いが分かれそうとか、「はっきり言う。気にいらんな。」みたいに言わそうとか懸念はあるのですが、そんな時はきっと「貴方ならうまくやれますよ」と言えば、「ありがとう。信じよう」と返してくれるはずなので大丈夫です。気休めかもしれませんが。(知らない良い子はお父さんに聞いてね(二度目))

あ、実際のゲームではこんな感じです(今のところ)

あー、でも敵が弾を撃つ仕様は必要かなぁ・・・じゃないと地味だし。