/// <summary>
 /// 値のセット
 /// </summary>
 /// <returns>The volume.</returns>
 /// <param name="idx">Index.</param>
 private float GetVolume(int idx)
 {
     if (statusListCount - 1 < idx)
     {
         return(0);
     }
     Struct.NodeStatus v = statusJobList[idx];                        // ステータス値の取得
     return(v.jobValMax > statusValMax ? statusValMax : v.jobValMax); // 最大値より大きい値は返さない
 }
 /// <summary>
 /// 値のセット
 /// </summary>
 /// <returns>The volume.</returns>
 /// <param name="idx">Index.</param>
 private float GetVolume(int idx)
 {
     if (statusListCount - 1 < idx)
     {
         return(0);
     }
     Struct.NodeStatus v = statusList[idx];               // ステータス値の取得
     v.val = v.val > MIN_VAL ? v.val : MIN_VAL;           // MIN_VAL未満ならMIN_VALとする
     v.val = v.val > statusValMax ? statusValMax : v.val; // 最大値より大きい値は返さない
     return(v.val);
 }
    /// <summary>
    /// レベルアップイベント
    /// </summary>
    /// <param name="unitInfo"></param>
    /// <param name="addLevel"></param>
    /// <param name="callBackEvent"></param>
    public void LevelUpEvent(UnitInfo unitInfo, int addLevel, Action callBackEvent)
    {
        this.unitInfo    = unitInfo;
        this.maxUnitInfo = UnitInfo.GetUnitClassData(unitInfo.classType);
        spawn            = 0;

        // UIに各パラメータをセット
        faceImage.sprite = Resources.Load <Sprite>("Sprite/UnitFace/Chara" + unitInfo.id);
        unitName.text    = unitInfo.unitName;
        unitClass.text   = unitInfo.className;
        level.text       = unitInfo.level.ToString();
        statusList[0]    = new Struct.NodeStatus("VIT", unitInfo.vitality, maxUnitInfo.vitality);
        statusList[1]    = new Struct.NodeStatus("STR", unitInfo.strengtht, maxUnitInfo.attack);
        statusList[2]    = new Struct.NodeStatus("TEC", unitInfo.technical, maxUnitInfo.technical);
        statusList[3]    = new Struct.NodeStatus("SPPD", unitInfo.speed, maxUnitInfo.speed);
        statusList[4]    = new Struct.NodeStatus("DEF", unitInfo.defense, maxUnitInfo.defense);
        statusList[5]    = new Struct.NodeStatus("RES", unitInfo.resist, maxUnitInfo.defense);
        statusList[6]    = new Struct.NodeStatus("LUK", unitInfo.luck, maxUnitInfo.luck);

        rCSValMax.color           = max;
        rCSValMax.radius          = RADIUS;
        rCSValMax.statusListCount = statusList.Length;
        rCSValMax.statusValMax    = VALUE_MAX;
        rCSValMax.SetVerticesDirty();

        rCSValJob.color           = job;
        rCSValJob.radius          = RADIUS;
        rCSValJob.statusJobList   = statusList;
        rCSValJob.statusListCount = statusList.Length;
        rCSValJob.statusValMax    = VALUE_MAX;
        rCSValJob.SetVerticesDirty();

        rCSVal.color           = status;
        rCSVal.radius          = RADIUS;
        rCSVal.statusList      = statusList;
        rCSVal.statusListCount = statusList.Length;
        rCSVal.statusValMax    = VALUE_MAX;
        rCSVal.SetVerticesDirty();

        rCSLine.color           = line;
        rCSLine.radius          = RADIUS;
        rCSLine.statusListCount = statusList.Length;
        rCSLine.statusValMax    = VALUE_MAX;
        rCSLine.LineWidth       = LINE_WIDTH;
        rCSLine.SetVerticesDirty();

        rCSLabel.radius          = RADIUS;
        rCSLabel.statusList      = statusList;
        rCSLabel.statusListCount = statusList.Length;
        rCSLabel.statusValMax    = VALUE_MAX;
        rCSLabel.ReDraw();

        rCSLabelVal.radius          = RADIUS;
        rCSLabelVal.statusList      = statusList;
        rCSLabelVal.statusListCount = statusList.Length;
        rCSLabelVal.statusValMax    = VALUE_MAX;
        rCSLabelVal.ReDraw();

        rCSLevelUpLabel.radius          = RADIUS;
        rCSLevelUpLabel.statusList      = statusList;
        rCSLevelUpLabel.statusListCount = statusList.Length;
        rCSLevelUpLabel.statusValMax    = VALUE_MAX;

        gameObject.SetActive(true);

        // 1秒後にイベントを開始
        StartCoroutine(DelayMethod(1f, () =>
        {
            // イベントの登録
            int addVal = 1;
            for (int i = 0; i < addLevel; i++)
            {
                // レベル加算
                eventList.Add(() =>
                {
                    unitInfo.level += addVal;
                });

                if (unitInfo.vitality < maxUnitInfo.vitality)
                {
                    if (Main.GameManager.GetCommonCalc().ProbabilityDecision(maxUnitInfo.vitality + 30))
                    {
                        eventList.Add(() =>
                        {
                            unitInfo.vitality += addVal;
                            rCSLevelUpLabel.CreateText(0, addVal);
                        });
                    }
                }

                if (unitInfo.strengtht < maxUnitInfo.attack)
                {
                    if (Main.GameManager.GetCommonCalc().ProbabilityDecision(maxUnitInfo.attack + 30))
                    {
                        eventList.Add(() =>
                        {
                            unitInfo.strengtht += addVal;
                            rCSLevelUpLabel.CreateText(1, addVal);
                        });
                    }
                }

                if (unitInfo.technical < maxUnitInfo.technical)
                {
                    if (Main.GameManager.GetCommonCalc().ProbabilityDecision(maxUnitInfo.technical + 30))
                    {
                        eventList.Add(() =>
                        {
                            unitInfo.technical += addVal;
                            rCSLevelUpLabel.CreateText(2, addVal);
                        });
                    }
                }

                if (unitInfo.speed < maxUnitInfo.speed)
                {
                    if (Main.GameManager.GetCommonCalc().ProbabilityDecision(maxUnitInfo.speed + 30))
                    {
                        eventList.Add(() =>
                        {
                            unitInfo.speed += addVal;
                            rCSLevelUpLabel.CreateText(3, addVal);
                        });
                    }
                }

                if (unitInfo.defense < maxUnitInfo.defense)
                {
                    if (Main.GameManager.GetCommonCalc().ProbabilityDecision(maxUnitInfo.defense + 30))
                    {
                        eventList.Add(() =>
                        {
                            unitInfo.defense += addVal;
                            rCSLevelUpLabel.CreateText(4, addVal);
                        });
                    }
                }

                if (unitInfo.resist < maxUnitInfo.defense)
                {
                    if (Main.GameManager.GetCommonCalc().ProbabilityDecision(maxUnitInfo.defense + 30))
                    {
                        eventList.Add(() =>
                        {
                            unitInfo.resist += addVal;
                            rCSLevelUpLabel.CreateText(5, addVal);
                        });
                    }
                }

                if (unitInfo.luck < maxUnitInfo.luck)
                {
                    if (Main.GameManager.GetCommonCalc().ProbabilityDecision(maxUnitInfo.luck + 30))
                    {
                        eventList.Add(() =>
                        {
                            unitInfo.luck += addVal;
                            rCSLevelUpLabel.CreateText(6, addVal);
                        });
                    }
                }

                eventList.Add(() => { rCSLevelUpLabel.Reset(); });
            }

            eventList.Add(() =>
            {
                // ステータスの再計算
                unitInfo.hpMax = unitInfo.vitality * 2;

                gameObject.SetActive(false); // UI非表示
                callBackEvent();             // コールバックイベントの実行
            });
        }));
    }