コンディション機能の実装３

　バフやデバフを適用するには、どのタイミングで適用するかが大切です。
この手順では、エネミーから攻撃を受けた際に、指定された確率でデバフのコンディションを付与する場合の実装例を提示します。
次の手順では、ステージ内にシンボルを配置し、そのシンボルに侵入した際にバフ/デバフのコンディションを付与する処理を実装します。

エネミーから攻撃を受けた際に、指定された確率でデバフのコンディションを付与する場合

設計

　バトルにおいてエネミーから攻撃を受けた場合に、エネミーごとに設定してある確率によって、デバフ効果を受けるようにする設計を行います。

　処理の流れは次のようなものを検討します。

　１．エネミーから攻撃を受けた際、PlayerController クラスの OnTriggerEnter メソッド内に、デバフの判定機能をメソッドとして追加する

　２．エネミーにデバフを付与する設定がある場合、乱数をつかって、指定された確率であるかどうかを判定する
　　　このときに、指定確率以下になった場合、デバフを付与する。その場合、GameData クラスのデバフ付与予定の List に記録し、バトル内ではデバフ付与については一旦保留にする
　　　GameData クラスのインスペクターで確認すること

　３．バトル終了後、ステージに戻った際に、Stage クラスの OnEnable メソッド内に、、バトルでデバフを付与されていないかを判定する機能をメソッドとして追加する

　４．GameData クラスのデバフ付与予定の List にデバフが登録されている場合、そのデバフの種類を特定して、該当するデバフを MapMoveController クラスに付与し、適用しているデバフの List に追加する
　　　この処理を、List 内にあるデバフすべてに繰り返す

　５．デバフのコンディションを付与した際に、エフェクトがある場合には、そちらを生成する

　６．MapMoveController クラスのインスペクターを確認し、適用しているデバフのクラス、および、 List 内にデバフが追加されているかを確認する

　７．ステージを移動し、デバフの適用時間が１マス移動するごとに１ずつ減少することを確認する。0 になったら、デバフのクラスが削除されて、デバフ状態が解消されることも確認する

　事前の準備として、GameData クラスに、バトル内で付与されたデバフの種類を登録しておくための List を作成します。
デバフはステージシーンに戻ってから適用されますので、GameData クラスに登録しておくことで、バトルシーンから遷移した後でも情報を利用できます。

　また、エネミーの情報を管理するために、スクリプタブル・オブジェクトを利用して、エネミー用のデータベースを作成します。
こちらにエネミーごとにデバフの設定も行えるようにします。

　これらが完成したら、スクリプトを修正し、バトル内でのデバフ判定、ステージシーンに移行してからのデバフの適用の処理を実装します。

GameData スクリプトを修正する

GameData.cs

<= クリックすると開きます

using System.Collections;
using System.Collections.Generic;
using UnityEngine;


public class GameData : MonoBehaviour
{
    public static GameData instance;


    public int hp;

    public int maxHp;

    //  現在のレベル
    public int playerLevel;          

    //  経験値のトータル値
    public int totalExp;             

    //  アビリティ開放用のポイント
    public int abilityPoint;        


    // バトルで付与されたデバフのリスト
    public List<ConditionType> debuffConditionsList = new List<ConditionType>();


    // 選択しているステージの番号
    public int chooseStageNo;

    // クリア済のステージの番号
    public List<int> clearedStageNos;

    // TODO 選択しているステージのデータ
    //public StageData currentStageData;

    // ボスバトルになったかどうかの確認用
    public bool isBossBattled;


    void Awake() {
        if (instance == null) {
            instance = this;
            DontDestroyOnLoad(gameObject);
        } else {
            Destroy(gameObject);
        }

        // ゲームの初期化
        InitialzeGameData();


        // ゲームの初期化用のローカル関数
        void InitialzeGameData() {

            // TODO キャラ用のデータがある場合には、そのキャラごとの最大値を設定
            //maxHp = currentCharaData.maxHp;

            hp = maxHp;

            playerLevel = 1;

            totalExp = 0;

            // TODO レベルアップで獲得できるボーナスのポイント
            //abilityPoint += playerLevel;
        }
    }
}

EnemyData

EnemyData.cs

<= クリックすると開きます

[System.Serializable]
public class EnemyData
{
    public string name;
    public int enemyNo;
    public int hp;
    public int attackPower;
    public float moveSpeed;
    public float attackInterval;
    public int exp;

    public EnemyController enemyPrefab;

    // デバフ用のコンディションのデータ
    public EnemyDebuffData[] debuffDatas;
}

/// <summary>
/// デバフ用のコンディションの登録用
/// </summary>
[System.Serializable]
public class EnemyDebuffData {

    // デバフ用のコンディションの設定
    public ConditionType debuffConditionType;

    // デバフ用のコンディションの付与確率
    [Range(0, 100)]
    public int rate;
}

EnemyDataSO スクリプトを作成する

EnemyDataSO.cs

<= クリックすると開きます

using System.Collections.Generic;
using UnityEngine;

[CreateAssetMenu(fileName = "EnemyDataSO", menuName = "Create EnemyDataSO")]
public class EnemyDataSO : ScriptableObject
{
    public List<EnemyData> enemyDatasList = new List<EnemyData>();
}

EnemyDataSO スクリプタブル・オブジェクトを作成する

　Datas フォルダを作成し、その中で右クリックをしてメニューを開き、Create => Create EnemyDataSO を選択します。
新しく EnemyDataSO スクリプタブル・オブジェクトが作成されます。名前はそのままで問題ありません。

　エネミー１体ずつのデータを登録できます。また、debuffDatas 変数に、プレイヤーに付与するデバフの種類と確率の設定が行えます。
debuffDatas 変数の Size は 0 なっていますので、この場合、デバフはないエネミーになります。デバフを設定したい場合には Size を 1 以上に変更し、
各 Element 内にデバフの種類と確率を登録します。

インスペクター画像

　デバフのコンディションの設定できる debuffDatas 変数は配列になっていますので、debuffDatas 変数のSize を 2 以上にすることで複数のデバフの設定が可能です。

DataBaseManager スクリプトを修正する

DataBaseManager.cs

<= クリックすると開きます

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class DataBaseManager : MonoBehaviour
{
    public static DataBaseManager instance;

    public EnemyDataSO enemyDataSO;


    void Awake() {
        if (instance == null) {
            instance = this;
            DontDestroyOnLoad(gameObject);
        } else {
            Destroy(gameObject);
        }
    }
}

　続けて、コンディション用のデータベースも作成します。こちらを参考にして作成してください。

PlayerController スクリプトを修正する

　バトルシーンで利用している PlayerController クラスを修正します。
OnTriggerEnter メソッドの処理に、デバフの確認用の処理を追加します。
実際にデバフの判定を行う処理はメソッド化して、そちらを利用します。

PlayerController.cs

<= クリックすると開きます

    private void OnTriggerEnter(Collider other) {
        if (other.TryGetComponent(out BulletController bullet)) {
            Debug.Log("被弾");

            CalcHp(-bullet.bulletPower);

            // TODO デバフ付与の判定


            Destroy(other.gameObject);
        }

        if (other.TryGetComponent(out EnemyController enemy)) {
            if (enemy.currentEnemyState == EnemyController.EnemyState.Attack) {
                // ダメージ
                CalcHp(-enemy.attackPower);


////*  新しく処理を追加  *////


                // デバフ付与の判定
                JudgeDebuffCondition(enemy.GetEnemyData());


////*  ここまで  *////


            }
        }
    }


////*  新しくメソッドを２つ追加  *////


    /// <summary>
    /// デバフ付与の判定
    /// </summary>
    private void JudgeDebuffCondition(EnemyData enemyData) {

        // エネミー側にデバフの付与設定がない場合には処理しない
        if (enemyData.debuffDatas.Length == 0) {
            return;
        }

        // エネミー側に設定されているデバフの数だけ判定
        for (int i = 0; i < enemyData.debuffDatas.Length; i++) {

            // 乱数が付与確率以下なら
            if (Random.Range(0, 100) <= enemyData.debuffDatas[i].rate) {

                // デバフ付与
                AddDebuffCondition(enemyData.debuffDatas[i].debuffConditionType);
            }
        }
    }

    /// <summary>
    /// 指定したタイプのデバフを付与し、GameData にて保持。Stage シーンに戻ってから適用
    /// </summary>
    /// <param name="debuffConditionType"></param>
    private void AddDebuffCondition(ConditionType debuffConditionType) {

        GameData.instance.debuffConditionsList.Add(debuffConditionType);
    }


////*  ここまで  *////

MapMoveController スクリプトを修正する

　Start メソッドでデバッグ用に設定していた処理をコメントアウトしておきます。

　コンディション用の処理を役割に合わせてメソッド単位でまとめておいて、それを追加します。

MapMoveController.cs

<= クリックすると開きます

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.Tilemaps;
using DG.Tweening;
using UnityEngine.Events;

public class MapMoveController : MonoBehaviour
{
    private Vector3 movePos;
    private float moveDuration = 0.35f;

    [SerializeField]
    private Tilemap tilemapCollider;

    [SerializeField]
    private bool isMoving;

    public GameManager gameManager;

    public bool IsMoving { set => isMoving = value;  get => isMoving; }

    private Stage stage;
	
    private int steppingRecoveryPoint = 3;// 足踏みしたときの HP 回復量

    private UnityEvent<MapMoveController> enemySymbolTriggerEvent;
    private UnityEvent<MapMoveController> orbSymbolTriggerEvent;

    [SerializeField]
    private List<PlayerConditionBase> conditionsList = new List<PlayerConditionBase>();　　//　コンディション用のリスト

　　[SerializeField]
    private Transform conditionEffectTran;　　　//　コンディション付与時にプレイヤーのどの辺りにエフェクトを表示するかの位置の設定
	
	
    //void Start() {
	    
　　　　// デバッグ用

　　　　// MapMoveController クラスのアタッチされているゲームオブジェクト(Player)に新しいクラス(PlayerCondition_Fatigue)を追加する
        //PlayerConditionBase condition = gameObject.AddComponent<PlayerCondition_Fatigue>();

　　　　// PlayerConditionBase クラスの AddCondition メソッドを実行する。引数は左から順番に(コンディションの種類、コンディションの持続時間、コンディションの効果(今回は攻撃力に乗算する値)、MapMoveController クラス、SymbolManager クラス)
        //condition.AddCondition(ConditionType.Fatigue, 5, 0.5f, this, stage.GetSymbolManager());

　　　　// コンディション用のリストに追加
        //conditionsList.Add(condition);
    //}


    void Update()
    {
        if(stage != null) {

            //キー入力の確認
            InputMove();
        }
    }
	
    /// <summary>
    /// キー入力判定
    /// </summary>
    public void InputMove()
    {	
        // プレイヤーの番でなければ処理しない
        if (stage.CurrentTurnState != Stage.TurnState.Player) {
            return;
        }

        // 移動禁止なら処理しない
        if (GameData.instance.staminaPoint <= 0)
        {
            return;
        }

        //移動中には処理しない
        if (isMoving)
        {
            return;
        }
		
        //キー入力の受け取り
        movePos.x = Input.GetAxisRaw("Horizontal");
        movePos.y = Input.GetAxisRaw("Vertical");

        //取得タイミングによって不用意な数値が入るので、その場合には処理しない
        if (movePos == Vector3.zero)
        {
            return;
        }
            
        isMoving = true;

        //斜め移動はなしにする
        if (Mathf.Abs(movePos.x) != 0)
        {
            movePos.y = 0;
        }

        // タイルマップの座標に変換
        Vector3Int tilePos = tilemapCollider.WorldToCell(transform.position + movePos);

        Debug.Log(tilemapCollider.GetColliderType(tilePos));

        // Grid のコライダーの場合
        if (tilemapCollider.GetColliderType(tilePos) == Tile.ColliderType.Grid)
        {
            // 移動しないで終了
            isMoving = false;
        }
        else // Grid 以外の場合
        {
            // 移動させる
            Move(transform.position + movePos);
        }       
    }
	
    /// <summary>
    /// 移動
    /// </summary>
    /// <param name="destination"></param>
    private void Move(Vector2 destination) {

        // 移動できる回数を減算する
        GameData.instance.staminaPoint--;

        // スタミナの表示更新
        gameManager.staminaPoint.text = GameData.instance.staminaPoint.ToString();

        // 移動(OnComplete メソッドの中身を修正する)
	tween = transform.DOMove(destination, moveDuration)
            .SetEase(Ease.Linear)
            .OnComplete(() => {

                // 敵のターン開始
                StartCoroutine(stage.ObserveEnemyTurnState());
            });
    }

    private void OnTriggerEnter2D(Collider2D collision) {

        //Symbolスクリプトがついているか確認して処理を実行
        if (collision.TryGetComponent(out SymbolBase symbolBase))
        {						
            // シンボルの種類によって分岐するので、コメントアウト
            //symbolBase.TriggerSymbol(this);


            // TODO エネミーのシンボルに接触した際、プレイヤーに透明のコンディションが付与されている場合


            // 同じシンボルに接触した場合は処理しない
            if (symbolBase.isSymbolTriggerd) {
                return;
            }

            Debug.Log("移動先でシンボルに接触 : " + symbolBase.symbolType.ToString());

            // エネミーのシンボルの場合
            if (symbolBase.symbolType == SymbolType.Enemy) {

                // エネミーのシンボルのイベントの重複登録はしない
                if (enemySymbolTriggerEvent != null) {
                    return;
                }

                symbolBase.isSymbolTriggerd = true;

                // シンボルのイベントを登録して予約し、すべてのエネミーの移動が終了してから実行
                enemySymbolTriggerEvent = new UnityEvent<MapMoveController>();
                enemySymbolTriggerEvent.AddListener(symbolBase.TriggerSymbol);

                Debug.Log("エネミーとのバトルを登録");
            }


            // TODO 特殊シンボルの場合、特殊シンボル用のイベントを登録して予約し、バトル後 Stage に戻ってきてから実行
			

            if (symbolBase.symbolType != SymbolType.Enemy) {

                // TODO 呪いのコンディションの確認
                // 呪い状態である場合は、シンボルのイベントを発生させない

                // それ以外のシンボルはすぐに実行
                symbolBase.TriggerSymbol(this);
            }
        }
    }

    /// <summary>
    /// 初期設定
    /// </summary>
    /// <param name="stage"></param>
    public void SetUpMapMoveController(Stage stage) {
        this.stage = stage;
    }

    /// <summary>
    /// 足踏み
    /// </summary>
    public void Stepping() {
        // プレイヤーの番でなければ処理しない
        if (stage.CurrentTurnState != Stage.TurnState.Player) {
            return;
        }

        GameData.instance.staminaPoint--;

        // 足踏みしてHP回復
        GameData.instance.hp = Mathf.Clamp(GameData.instance.hp += steppingRecoveryPoint, 0, GameData.instance.maxHp);

        // Hp ゲージ更新
        uiManager.DisplayHpGauge();

        // 敵のターン開始
        StartCoroutine(stage.ObserveEnemyTurnState());
    }

    /// <summary>
    /// 登録されているエネミーシンボルのイベント(エネミーとのバトル)を実行
    /// </summary>
    public bool CallBackEnemySymbolTriggerEvent() {

        if (enemySymbolTriggerEvent != null) {
            // 変数名の最後に ? がある場合、変数の値(中身)が null ではない場合のみ実行。つまり、イベントがあるときだけ実行する
            enemySymbolTriggerEvent?.Invoke(this);

            // イベントをクリア。ここも上と同じで、変数内に値があるか確認して、ある場合のみ、Remove～ してイベントをクリアする 
            enemySymbolTriggerEvent?.RemoveAllListeners();
            enemySymbolTriggerEvent = null;

            return true;
        }
        return false;
    }

    /// <summary>
    /// Stage の情報を取得
    /// </summary>
    /// <returns></returns>
    public Stage GetStage() {
        return stage;
    }


// ここからメソッドを６つ追加


    /// <summary>
    /// 引数に指定されたコンディションが付与されているか確認
    /// </summary>
    /// <param name="conditionType"></param>
    /// <returns></returns>
    public bool JudgeConditionType(ConditionType conditionType) {
        return conditionsList.Find(x => x.GetConditionType() == conditionType);
    }

    /// <summary>
    /// コンディション用のエフェクト生成位置の取得
    /// </summary>
    /// <returns></returns>
    public Transform GetConditionEffectTran() {
        return conditionEffectTran;
    }

    /// <summary>
    /// 現在のコンディションの状態の残り時間を更新
    /// </summary>
    public void UpdateConditionsDuration() {
        for (int i = 0; i< conditionsList.Count; i++) {
            conditionsList[i].CalcDuration();
        }
    }

    /// <summary>
    /// コンディションを追加
    /// </summary>
    /// <param name="playerCondition"></param>
    public void AddConditionsList(PlayerConditionBase playerCondition) {
        conditionsList.Add(playerCondition);
    }

    /// <summary>
    /// コンディションを削除
    /// </summary>
    public void RemoveConditionsList(PlayerConditionBase playerCondition) {
        conditionsList.Remove(playerCondition);
        Destroy(playerCondition);
    }

    /// <summary>
    /// コンディションの List を取得
    /// </summary>
    /// <returns></returns>
    public List<PlayerConditionBase> GetConditionsList() {
        return conditionsList;
    }


//　ここまで


}

Stage スクリプトを修正する

　OnEnable メソッド内の TODO １つと、CheckTurn メソッド内の TODO ２つを実装します。
この部分にはメソッドの呼び出し命令を実装するため、新しく３つのメソッドを追加しています。

　このクラスにおいて、実際に MapMoveController クラスに対してバトルで付与されたデバフの効果を適用しています。

Stage.cs

<= クリックすると開きます

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class Stage : MonoBehaviour {

    [SerializeField]
    private UIManager uiManager;

    [SerializeField]
    private StageGenerator stageGenerator;

    [SerializeField]
    private SymbolManager symbolManager;

    [SerializeField]
    private MapMoveController mapMoveController;

    public enum TurnState {
        None,
        Player,
        Enemy,
        Boss
    }

    private TurnState currentTurnState = TurnState.None;

    public TurnState CurrentTurnState  // プロパティ
    {
        set => currentTurnState = value;
        get => currentTurnState;
    }

    // Stage ゲームオブジェクトが Active 状態になる度に実行されるメソッド
    // ゲーム開始時にも Start メソッドよりも前に実行される(Awake メソッドの後)
    private void OnEnable() {
	
        // HP の更新
        uiManager.DisplayHpGauge();


        // TODO バトル後にレベルアップした時のカウントの初期化
		

        // TODO レベルアップするか確認


        // TODO レベルアップしていたらレベルアップのボーナス


////*　ここから TODO を実装　*////


        // バトルで付与されたデバフの確認と付与
        CheckDebuffConditions();


////*　ここまで　*////


        // ターンの確認とプレイヤーのターンに切り替え。コンディションの更新
        CheckTurn();

        // TODO 特殊シンボルを獲得している場合は獲得処理を実行


        // ボスの出現確認
        if (CurrentTurnState == TurnState.Boss) {

            // ボスの出現
            Debug.Log("Boss 出現");


            // TODO 演出


            // TODO シーン遷移

        }
    }

    void Start() {
		
　　　　// TODO ステージ選択機能を実装した時の処理
		
		
        // ステージのランダム作成
        stageGenerator.GenerateStageFromRandomTiles();


        symbolManager.AllClearSymbolsList();


        // 通常のシンボルのランダム作成して List に追加
        symbolManager.SymbolsList = stageGenerator.GenerateSymbols(-1);


        // TODO 特殊シンボルのランダム作成して List に追加
        
		
        // 全シンボルの設定
        symbolManager.SetUpAllSymbols();

        // プレイヤーの設定
        mapMoveController.SetUpMapMoveController(this);

        // 現在のターンをプレイヤーのターンに設定
        CurrentTurnState = TurnState.Player;

        // TODO エネミーのシンボルに侵入できるようにする(特殊シンボル使う場合)

    }

    /// <summary>
    /// エネミーのターン経過監視処理
    /// </summary>
    /// <returns></returns>
    public IEnumerator ObserveEnemyTurnState() {

        Debug.Log("敵の移動　開始");
		
        // エネミーの移動を１体ずつ行う。すべて移動が終わるまで、下の処理にはいかない
        yield return StartCoroutine(symbolManager.EnemisMove());

        Debug.Log("すべての敵の移動 完了");

        // シンボルのイベントを発生させる
        bool isEnemyTriggerEvent = mapMoveController.CallBackEnemySymbolTriggerEvent();

        Debug.Log(isEnemyTriggerEvent);

        // ターンの状態を確認
        if (!isEnemyTriggerEvent) CheckTurn();

        if (CurrentTurnState == TurnState.Boss) {

            // ボスの出現
            Debug.Log("Boss 出現");


            // TODO 演出


            // TODO シーン遷移

        }
    }

    /// <summary>
    /// ターンの確認。プレイヤーのターンに切り替え。コンディションの更新
    /// </summary>
    private void CheckTurn() {
	
	// 移動できるか確認
        if (GameData.instance.MaxMoveCount <= 0) {
		
            // 移動できないなら、ボスのターンにする
            CurrentTurnState = TurnState.Boss;
        } else {
		　　
            // まだ移動できるなら、プレイヤーのターンにする
            CurrentTurnState = TurnState.Player;


////*  ここから TODO を２つ実装  *////


            // コンディションの残り時間の更新
            mapMoveController.UpdateConditionsDuration();　　　　　//　<=　☆①
            

            // TODO 移動ボタンと足踏みボタンを押せる状態にする


            // コンディションの効果を適用
            ApplyEffectConditions();　　　　　　　　　　　　　　　 //　<=　☆②


////*  ここまで  *////


            // 移動の入力を受け付けるようにする
            mapMoveController.IsMoving = false;
        }
        Debug.Log(CurrentTurnState);
    }

    /// <summary>
    /// SymbolManager の情報を取得
    /// </summary>
    /// <returns></returns>
    public SymbolManager GetSymbolManager() {
        return symbolManager;
    }


////*　ここからメソッドを３つ追加　*////


    /// <summary>
    /// バトルで付与されたデバフの確認
    /// </summary>
    private void CheckDebuffConditions() {

        // バトル内で付与されているデバフがないか判定
        if (GameData.instance.debuffConditionsList.Count == 0) {

　　　　　　// デバフが登録されていなければ、処理を終了する
            return;
        }

        // 登録されているデバフを順番に
        for (int i =0; i < GameData.instance.debuffConditionsList.Count; i++) {

            // デバフの付与
            AddDebuff(GameData.instance.debuffConditionsList[i]);
        }

        // デバフのリストをクリア。次のバトルに備える
        GameData.instance.debuffConditionsList.Clear();
    }

    /// <summary>
    /// デバフの付与
    /// </summary>
    private void AddDebuff(ConditionType conditionType) {

        // TODO ConditionDataSO スクリプタブル・オブジェクトを作成してから適用
        ConditionData conditionData = DataBaseManager.instance.conditionDataSO.conditionDatasList.Find(x => x.conditionType == conditionType);

        // すでに同じコンディションが付与されているか確認
        if (mapMoveController.GetConditionsList().Exists(x => x.GetConditionType() == conditionType)) {
            // すでに付与されている場合は、持続時間を更新し、効果は上書きして処理を終了する
            mapMoveController.GetConditionsList().Find(x => x.GetConditionType() == conditionType).ExtentionCondition(conditionData.duration, conditionData.conditionValue);
            return;
        }

        // 付与するコンディションが睡眠かつ、すでに混乱のコンディションが付与されているときには、睡眠のコンディションは無視する(操作不能になるため)
        if (conditionType == ConditionType.Sleep && mapMoveController.GetConditionsList().Exists(x => x.GetConditionType() == ConditionType.Confusion)) {
            return;
        }

        // 付与されていないコンディションの場合は、付与する準備する
        PlayerConditionBase playerCondition;

        // Player にコンディションを付与
        playerCondition = conditionType switch {

            // TODO コンディションの種類が増えたら、ここに追加する


            ConditionType.Fatigue => mapMoveController.gameObject.AddComponent<PlayerCondition_Fatigue>(),
            _ => null
        };

        // 初期設定を実行
        playerCondition.AddCondition(conditionType, conditionData.duration, conditionData.conditionValue, mapMoveController, symbolManager);

        // コンディション用の List に追加
        mapMoveController.AddConditionsList(playerCondition);
    }

    /// <summary>
    /// 付与されているコンディションの効果をすべて適用
    /// </summary>
    private void ApplyEffectConditions() {

　　　　// 付与されているコンディションの効果を順番にすべて適用
        foreach (PlayerConditionBase condition in mapMoveController.GetConditionsList()) {

　　　　　　// コンディションの効果を適用
            condition.ApplyEffect();
        }
    }


////*　ここまで　*////


}

ゲームを実行して動作を確認する

　設計部分の処理の流れ通りにゲームが動くかを確認します。

　現在の設計では、同じ種類のデバフを適用する場合、効果時間が延長されます。
そのままでも問題はありませんが、必要に応じて、実際にエネミーからの攻撃や、適用する確率なども調整しながら、１回のバトルで同じデバフは重複しないようにするなどの修正を適宜行ってください。

このページを編集するこのページを元に新規ページを作成

印刷する

コメント（0）

コンディション機能の実装３ - i-school 先頭へ

コメントをかく

名前	ユーザIDを使用しないで書き込む	ユーザーIDを使う	ログインする
画像コード	画像に記載されている文字を下のフォームに入力してください。
備考	「http://」を含む投稿は禁止されています。
本文
利用規約をご確認のうえご記入下さい

i-school