レベルアップ機能と経験値計算方法の実装例

　経験値を加算し、一定値を超えた場合にレベルアップを行う機能の実装例です。

設計

　獲得した経験値の量によっては複数回のレベルアップが発生する可能性もあるため、
そういったケースにも対応したアプローチ方法になります。

データテーブルの作成

　Json データやスプレッドシートなどで経験値とレベルのデータテーブルを作成します。
レベルに応じて変化する固定ステータスがある場合には合わせて用意しておくと便利です。

　下記のテーブル例は、レベル、経験値、累計経験値、レベルによる Hp です。

CharaLevelManager クラスの作成

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

using Cysharp.Threading.Tasks;
using System.Linq;
using UnityEngine;

public static class CharaLevelManager
{
    /// <summary>
    /// 現在のレベルから次のレベルまでの経験値の量を取得
    /// </summary>
    /// <param name="charaLevel"></param>
    /// <returns></returns>
    public static int GetNextExp(int charaLevel)
    {
        return TitleDataManager.instance.PcharLevelMasterData.Find(data => data.level == charaLevel + 1).exp;
    }

    /// <summary>
    /// 累積経験値の取得
    /// </summary>
    /// <param name="charaLevel"></param>
    /// <returns></returns>
    public static int GetTotalExp(int charaLevel)
    {
        return TitleDataManager.instance.PcharLevelMasterData.Find(data => data.level == charaLevel).acc_exp;
    }

    /// <summary>
    /// 現在のレベルの取得
    /// </summary>
    /// <param name="totalExp"></param>
    /// <returns></returns>
    public static int GetCharaLevel(int totalExp)
    {
        return TitleDataManager.instance.PcharLevelMasterData.LastOrDefault(data => data.acc_exp <= totalExp).level;
    }

    /// <summary>
    /// 現在のレベルからプレイヤーのHpの取得
    /// </summary>
    /// <param name="charaLevel"></param>
    /// <returns></returns>
    public static int GetCurrentLevelHp(int charaLevel)
    {
        return TitleDataManager.instance.PcharLevelMasterData.Find(data => data.level == charaLevel).hp;
    }

    /// <summary>
    /// レベルアップした際のステータス振分ポイントの取得
    /// </summary>
    /// <returns></returns>
    public static int GetLevelupStatusPoint()
    {
        return TitleDataManager.instance.ContentControllerMasterData.levelup_status_point;
    }

    /// <summary>
    /// 経験値の加算
    /// </summary>
    /// <param name="exp"></param>
    public static void AddExp(int exp)
    {
        // レベルがMaxの場合はリターンを返す
        if (UserDataManager.Instance.CharaStatus.current_level >= MarriageManager.GetCharaMaxLevel(UserDataManager.Instance.CharaStatus.marriage_count))
            return;

        // キャラの現在の経験値加算
        UserDataManager.Instance.CharaStatus.current_exp += exp;

        //// キャラの累計経験値の加算
        UserDataManager.Instance.CharaStatus.acc_exp += exp;

        UserDataManager.Instance.UpdateReactiveUserData();

        // 加算した経験値が目標経験値に達しているか(次の目標経験値に達しない場合早期リターン)
        if (UserDataManager.Instance.CharaStatus.current_exp < GetNextExp(UserDataManager.Instance.CharaStatus.current_level))
            return;

        // レベルアップ
        Levelup();
    }

    /// <summary>
    /// レベルアップ
    /// </summary>
    public static async void Levelup()
    {
        // 現在の経験値
        int currentExp = UserDataManager.Instance.CharaStatus.current_exp;
        // レベルアップした回数
        int levelupCount = 0;

        // 現在レベル以上のリストを取得
        var MasterData = TitleDataManager.instance.PcharLevelMasterData.FindAll(data => data.level >= UserDataManager.Instance.CharaStatus.current_level);

        // 現在の最大レベル
        int maxLevel = MarriageManager.GetCharaMaxLevel(UserDataManager.Instance.CharaStatus.marriage_count);

        // 一度の経験値取得で２レベル以上上がるかを調べる
        foreach (var data in MasterData)
        {
            //Maxレベルを超えているか
            if (data.level >= maxLevel)
            {
                // レベル最大の更新用ユーザーデータのセット
                UserDataManager.Instance.CharaStatus.UpdateLevelUpStatus(maxLevel, GetTotalExp(maxLevel),0, GetTotalStatusPoint());
                break;
            }

            // キャラ経験値と比較  
            if (currentExp >= GetNextExp(data.level))
            {
                // 次の経験値分マイナス
                currentExp -= GetNextExp(data.level);
                
                levelupCount++;
                continue;
            }

            // 最新の累計経験値
            int totalExp = GetTotalExp(data.level) + currentExp;

            // 更新用ユーザーデータのセット
            UserDataManager.Instance.CharaStatus.UpdateLevelUpStatus(data.level, totalExp, currentExp, GetTotalStatusPoint());

            // レベルアップ演出
            {
                // オブジェクトプールからレベルアップ用のエフェクトを取り出し
                (EffectPlayerBase levelUpEffect, float duraion) = EffectManager.instance.GetEffect(ConstData.LEVEL_UP_EFFECT_INDEX);

                // エフェクトを表示する位置を調整
                Vector3 effectPos = new(0, ConstData.LEVEL_UP_EFFECT_START_POS_Y, 0);

                var token = PlayerManager.instance.GetCancellationTokenOnDestroy();

                // プレイヤーの顔の上で再生
                levelUpEffect.PlayEffect(duraion, PlayerManager.instance.transform.position + effectPos, token).Forget();
            }

            break;


            /// <summary>
            /// ローカルメソッド
            /// 取得できるステータスポイントの最終値
            /// <summary>
            int GetTotalStatusPoint() => levelupCount * GetLevelupStatusPoint();
        }

        // サーバーに保存
        bool result = await UserDataManager.Instance.UpdateUserDataForAllAsync("CharaStatus", UserDataManager.Instance.CharaStatus);

        if(result == false)
        {
            // 本番は失敗した場合タイトルに戻る
            // TODO デバッグ用
            Debug.Log("更新失敗");
            return;
        }

        // TODO デバッグ用
        Debug.Log("更新成功");

        // ReactiveProperty 更新
        UserDataManager.Instance.UpdateReactiveUserData();

        // HPの更新とレベルアップした際の全回復
        PlayerManager.instance.InitHp();
    }
}

PetLevelManager

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

using Cysharp.Threading.Tasks;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using System;

public static class PetLevelManager
{
    /// <summary>
    /// 現在のレベルから次のレベルまでの経験値の量を取得
    /// </summary>
    /// <param name="petLevel"></param>
    /// <returns></returns>
    public static long GetNextExp(int petLevel, float expScale) {
        return (long)(TitleDataManager.instance.PetLevelMasterData.Find(data => data.level == petLevel + 1).exp * expScale);
    }

    /// <summary>
    /// 累積経験値の取得
    /// </summary>
    /// <param name="petLevel"></param>
    /// <returns></returns>
    public static long GetAccExp(int petLevel, float expScale) {
        return (long)(TitleDataManager.instance.PetLevelMasterData.Find(data => data.level == petLevel).acc_exp * expScale);
    }

    /// <summary>
    /// レベルからペットの上昇後の各ステータスの取得
    /// </summary>
    /// <param name="petLevel"></param>
    /// <returns></returns>
    public static PetStatus GetPetStatus(int petLevel, int petIndex) {
        PetMasterData petMasterData = TitleDataManager.instance.PetMasterData.FirstOrDefault(data => data.pet_id == petIndex);

        PetStatus petStatus = new();

        // 基礎値 &#8314; ((予測レベル -1) * レベルアップ時のステータス値) 
        petStatus.hp = petMasterData.hp + ((petLevel - 1) * petMasterData.level_hp);
        petStatus.atk = petMasterData.atk + ((petLevel - 1) * petMasterData.level_atk);
        petStatus.inte = petMasterData.inte + ((petLevel - 1) * petMasterData.level_inte);
        petStatus.def = petMasterData.def + ((petLevel - 1) * petMasterData.level_def);
        petStatus.mdef = petMasterData.mdef + ((petLevel - 1) * petMasterData.level_mdef);
        petStatus.spd = petMasterData.spd + ((petLevel - 1) * petMasterData.level_spd);
        petStatus.luk = petMasterData.luk + ((petLevel - 1) * petMasterData.level_luk);

        return petStatus;
    }

    /// <summary>
    /// 経験値による予測レベルの計算
    /// </summary>
    /// <param name="invenPet"></param>
    /// <param name="exp"></param>
    /// <returns></returns>
    public static (int predictLevel, long currentExp) CalcPredictLevel(InvenPet invenPet, long exp) {
        // 加算後の経験値
        long currentExp = invenPet.pet_current_exp + exp;
        
        // レベルアップした回数
        int levelupCount = 0;

        // ペットのデータ取得
        PetMasterData petMasterData = TitleDataManager.instance.GetPetMasterData(invenPet.pet_index);

        // 現在レベル以上のリストを取得
        List<PetLevelMasterData> MasterData = TitleDataManager.instance.PetLevelMasterData.FindAll(data => data.level >= invenPet.pet_level);

        // 現在の最大レベル
        int maxLevel = TitleDataManager.instance.ContentControllerMasterData.pet_level_max;

        // 一度の経験値取得で２レベル以上上がるかを調べる
        foreach (var data in MasterData) {
            //Maxレベルを超えているか
            if (data.level >= maxLevel) {
                // レベル最大のデータのセット
                break;
            }

            // 経験値と比較  
            if (currentExp >= GetNextExp(data.level, petMasterData.exp_scale)) {
                // 次の経験値分マイナス
                currentExp -= GetNextExp(data.level, petMasterData.exp_scale);

                levelupCount++;
                continue;
            }            
        }
#if DEBUG
        Debug.Log($"levelupCount : {levelupCount}");
        Debug.Log($"invenPet.pet_current_exp + exp: {invenPet.pet_current_exp + exp}");
#endif
        // レベルアップ後の予測値を返す
        return (invenPet.pet_level + levelupCount, currentExp);
    }

    /// <summary>
    /// 次のレベルから到達最大レベルまでの経験値リストを取得
    /// </summary>
    /// <param name="currentLevel"></param>
    /// <param name="maxReachedLevel"></param>
    /// <param name="expScale"></param>
    /// <returns></returns>
    public static List<long> GetNextExpList(int currentLevel, int maxReachedLevel, float expScale) {
        // ペットの最大レベルの設定
        int reachedLevel = Mathf.Min(maxReachedLevel + 1, TitleDataManager.instance.ContentControllerMasterData.pet_level_max);

        // 次のレベルから到達最大レベルの次のレベルまでのレコードを抽出
        var nextLevelRecords = TitleDataManager.instance.PetLevelMasterData
            .Where(record => record.level > currentLevel && record.level <= reachedLevel).ToList();

        nextLevelRecords.ForEach(data => Debug.Log(data));
        Debug.Log(nextLevelRecords.Count);

        // 抽出されたレコードから経験値の部分を取り出し、リスト化
        List<long> nextExpList = nextLevelRecords.Select(record => (long)(record.exp * expScale)).ToList();

        // 累積和を求める。リストの最初の要素の場合はそのまま追加し、2番目以降の要素は直前の累積値に現在の値を加算
        List<long> cumulativeList = new ();
        long sum = 0;
        foreach (long value in nextExpList) {
            sum += value;
            cumulativeList.Add(sum);
        }
        cumulativeList.ForEach(data => Debug.Log(data));
        return cumulativeList;
    }

    /// <summary>
    /// 次のレベルから到達最大レベルまでの累積経験値リストを取得
    /// </summary>
    /// <param name="currentLevel"></param>
    /// <param name="maxReachedLevel"></param>
    /// <param name="expScale"></param>
    /// <returns></returns>
    public static List<long> GetNextAccExpList(int currentLevel, int maxReachedLevel, float expScale) {
        // ペットの最大レベルの設定
        int reachedLevel = Mathf.Min(maxReachedLevel + 1, TitleDataManager.instance.ContentControllerMasterData.pet_level_max);

        // 次のレベルから到達最大レベルの次のレベルまでのレコードを抽出
        var nextLevelRecords = TitleDataManager.instance.PetLevelMasterData
            .Where(record => record.level > currentLevel && record.level <= reachedLevel).ToList();

        nextLevelRecords.ForEach(data => Debug.Log(data));
        Debug.Log(nextLevelRecords.Count);

        // 抽出されたレコードから累積経験値の部分を取り出し、リスト化
        List<long> nextExpList = nextLevelRecords.Select(record => (long)(record.acc_exp * expScale)).ToList();
        nextExpList.ForEach(data => Debug.Log(data));
        return nextExpList;
    }

    /// <summary>
    /// セーブ
    /// </summary>
    /// <param name="invenPet"></param>
    /// <returns></returns>
    public static async UniTask SaveInvenPet(InvenPet invenPet) {
        // サーバーに保存
        bool result = await UserDataManager.Instance
                          .UpdateUserDataForAllAsync(ConstData.INVENTORY_PET_LIST_KEY, UserDataManager.Instance.inventoryPetList);

        if (result == false) {
            // 本番は失敗した場合タイトルに戻る
            // TODO デバッグ用
            Debug.Log("更新失敗");
            return;
        }

        // TODO デバッグ用
        Debug.Log("更新成功");
    }

    /// <summary>
    /// 最大レベル時の最大経験値の取得
    /// </summary>
    /// <param name="petIndex"></param>
    /// <returns></returns>
    public static long GetMaxExpfromMaxLevel(int petIndex) {
        PetMasterData petMasterData = TitleDataManager.instance.PetMasterData.FirstOrDefault(data => data.pet_id == petIndex);
        int maxLevel = TitleDataManager.instance.ContentControllerMasterData.pet_level_max;
        long maxAccExp = (long)(TitleDataManager.instance.PetLevelMasterData.FirstOrDefault(data => data.level == maxLevel).acc_exp * petMasterData.exp_scale);
        long prevAccExp = (long)(TitleDataManager.instance.PetLevelMasterData.FirstOrDefault(data => data.level == maxLevel - 1).acc_exp * petMasterData.exp_scale);
        long diffExp = maxAccExp - prevAccExp;
#if DEBUG
        Debug.Log($"最大レベル時の最大経験値 {diffExp}");
#endif
        return diffExp;
    }

    /// <summary>
    /// 最大レベル時の最大累積経験値の取得
    /// </summary>
    /// <param name="petIndex"></param>
    /// <returns></returns>
    public static long GetMaxAccExpfromMaxLevel(int petIndex) {
        PetMasterData petMasterData = TitleDataManager.instance.PetMasterData.FirstOrDefault(data => data.pet_id == petIndex);
        int maxLevel = TitleDataManager.instance.ContentControllerMasterData.pet_level_max;
        long maxAccExp = (long)(TitleDataManager.instance.PetLevelMasterData.FirstOrDefault(data => data.level == maxLevel).acc_exp * petMasterData.exp_scale);
#if DEBUG
        Debug.Log($"最大レベル時の最大累積経験値 {maxAccExp}");
#endif
        return maxAccExp;
    }


//*****  ペット AI 強化用  *****//


    /// <summary>
    /// 強化レベルからペットの強化ステータスを取得
    /// </summary>
    /// <param name="enhanceLevel"></param>
    /// <param name="petIndex"></param>
    /// <returns></returns>
    public static PetStatus GetPetEnhanceStatus(int enhanceLevel, int petIndex) {
        PetMasterData petMasterData = TitleDataManager.instance.PetMasterData.FirstOrDefault(data => data.pet_id == petIndex);

        PetStatus petStatus = new();

        // 強化レベル * レベルアップ時のステータス値
        petStatus.hp = enhanceLevel * petMasterData.enhance_hp;
        petStatus.atk = enhanceLevel * petMasterData.enhance_atk;
        petStatus.inte = enhanceLevel * petMasterData.enhance_inte;
        petStatus.def = enhanceLevel * petMasterData.enhance_def;
        petStatus.mdef = enhanceLevel * petMasterData.enhance_mdef;
        petStatus.spd = enhanceLevel * petMasterData.enhance_spd;
        petStatus.luk = enhanceLevel * petMasterData.enhance_luk;

        return petStatus;
    }


//*****  ペット AI 制作時用  *****//


    /// <summary>
    /// 現在のレベルの取得
    /// </summary>
    /// <param name="totalExp"></param>
    /// <returns></returns>
    public static int GetPetLevel(int totalExp) {
        return TitleDataManager.instance.PetLevelMasterData.LastOrDefault(data => data.acc_exp <= totalExp).level;
    }

    /// <summary>
    /// ペットの最大Hp取得
    /// </summary>
    /// <param name="enhanceLevel"></param>
    /// <param name="petLevel"></param>
    /// <param name="petIndex"></param>
    /// <returns></returns>
    public static int GetPetMaxHp(int enhanceLevel, int petLevel, int petIndex) {
        PetMasterData petMasterData = TitleDataManager.instance.PetMasterData.FirstOrDefault(data => data.pet_id == petIndex);
        int baseHp = petMasterData.hp + ((petLevel - 1) * petMasterData.level_hp);
        int enhanceHp = enhanceLevel * petMasterData.enhance_hp;
        return baseHp + enhanceHp;
    }

    /// <summary>
    /// ペットの経験値加算
    /// </summary>
    /// <param name="exp"></param>
    /// <param name="petIndex"></param>
    public static async UniTask<bool> AddPetExp(int exp, int petIndex) {
        InvenPet invenPet = UserDataManager.Instance.inventoryPetList.FirstOrDefault(pet => pet.pet_index == petIndex);

        bool isLevelUp = false;

        // レベルがMaxの場合はリターンを返す
        if (invenPet.pet_level >= TitleDataManager.instance.ContentControllerMasterData.pet_level_max)
            return isLevelUp;

        // 経験値加算後のレベルと繰り越し経験値を算出
        (int predictLevel, long remainderExp) = CalcPredictLevel(invenPet, exp);

        // 経験値と累積経験値を、それぞれの最大値の範囲内に収まるようにして更新
        // ペットの現在の経験値算出
        long maxExp = GetMaxExpfromMaxLevel(invenPet.pet_index);
        invenPet.pet_current_exp = Math.Min(remainderExp, maxExp);

        // ペットの累計経験値の加算
        long maxAccExp = GetMaxAccExpfromMaxLevel(invenPet.pet_index);
        invenPet.pet_acc_exp = Math.Min(invenPet.pet_acc_exp += exp, maxAccExp);

        // 現在のレベルよりも、経験値加算後のレベルの方が高い場合
        if (invenPet.pet_level < predictLevel) {
            // レベルアップ
            invenPet.pet_level = predictLevel;
            isLevelUp = true;
        }

        // サーバーに保存
        await SaveInvenPet(invenPet);
        return isLevelUp;
    }
}

実装例

　経験値の加算用のメソッドの呼び出し処理の実装を行います。

　プレイヤー側に実装する方法と、敵側に実装する方法の２つのアプローチ方法が考えられます。

　

    /// <summary>
    /// EnemyBase の敵の Hp が 0 になったときに実行される
    /// </summary>
    /// <param name="exp"></param>
    public async void AddExpToActivePets(int exp) {

        // 経験値に対する係数を算出し、ペットの経験値を求める(現在はプレイヤーの獲得値の 30％)
        int percentage = TitleDataManager.instance.ContentControllerMasterData.pet_exp_rate;
        double petExp = exp * (percentage / 100.0);

        Debug.Log($"ペットの獲得経験値 : {(int)petExp}");

        for (int i = 0; i < summonPets.Length; i++) {

            // 召喚中のペットの場合
            if (summonPets[i] != null) {

                // 経験値加算し、レベルアップ有無をもらう
                bool isLevelUp = await PetLevelManager.AddPetExp((int)petExp, summonPets[i].currentPetMasterData.pet_id);

                // レベルアップした場合
                if (isLevelUp) {

                    // レベルアップ後処理(Hp 全回復、エフェクト)
                    ProcessAfterLevelUp(i, summonPets[i]);
                }
            }
        }
    }

    /// <summary>
    /// レベルアップ後処理(Hp 全回復、エフェクト)
    /// </summary>
    /// <param name="buttonIndex"></param>
    /// <param name="pet"></param>
    public void ProcessAfterLevelUp(int buttonIndex, Pet pet) {
        // Hp 全回復
        pet.HealLife(pet.MaxHp);

        // エフェクト再生の準備
        PrepareLevelUpPetEffect(buttonIndex, pet);
    }

    /// <summary>
    /// エフェクト再生の準備
    /// </summary>
    /// <param name="buttonIndex"></param>
    /// <param name="pet"></param>
    public void PrepareLevelUpPetEffect(int buttonIndex, Pet pet) {
        // オブジェクトプールからレベルアップ用のエフェクトを取り出し
        (EffectPlayerBase levelUpEffect, float duraion) = EffectManager.instance.GetEffect(ConstData.PET_LEVEL_UP_EFFECT_INDEX);

        // エフェクトを表示する位置を調整
        Vector3 effectPos = new(0, ConstData.LEVEL_UP_EFFECT_START_POS_Y, 0);

        // ペットの上で再生
        levelUpEffect.PlayEffect(duraion, pet.transform.position + effectPos, token).Forget();

        // PetButtonManager 側にて購読している OnLevelUpPet へ buttonIndex を通知し、ペットのボタンの上にもエフェクトを出す
        OnLevelUpPet.OnNext(buttonIndex);
    }

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

印刷する

コメント（0）

レベルアップ機能と経験値計算方法の実装例 - i-school 先頭へ

コメントをかく

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

i-school

レベルアップ機能と経験値計算方法の実装例

設計

データテーブルの作成

CharaLevelManager クラスの作成

PetLevelManager

実装例

コメントをかく

Menu

アクセス解析中