戦略が深まるSRPGステータス設計｜数値バランスが劇的に良くなる方法

SRPGのステータス設計は、ゲームの戦略性と遊びごたえを左右します。

順番を間違えると、数値調整が難しくなり、バランスが崩れやすくなります。

この記事では、SRPGのステータス設計をスムーズに進めるための考え方と、実践しやすい設計手順を解説します。

✨ 上手なSRPGステータス設計をする順番

基本ステータスの種類と意味を決める
成長率を設計して強さの伸びを固める
職業差で役割と個性を作る
難易度に応じて数値を調整する
表計算ソフトでバランスを試算する

ゲーム開発講師

ステータス設計は、表計算ソフトで試算してから実装すると失敗しにくくなります。数値を変えながら、戦略性への影響を確認しましょう。

ゲームを「遊ぶ側」から「作る側」へ

あなたのオリジナルゲーム、今年こそ完成させませんか？

RPG・アクション・ホラー…Unityで本格ゲームを作りたい人のための学習サイトです。

Unity入門の森｜永久会員チケット

全講座ラインナップを見てみる

実際に完成するゲームを題材に、
ソースコード・素材・プロジェクト一式をすべて公開。
仕事や学校の合間の1〜2時間でも、
「写経→改造」で自分のゲームまで作りきれる環境です。

基本ステータスの種類と意味
成長率の設計方法
職業差のバランス調整
難易度に応じた調整方法
表計算ソフトを使った試算方法
1. Excelでの試算例
2. バランス確認のポイント
実装例：完全なステータスシステム
よくある質問（FAQ）
まとめ

基本ステータスの種類と意味

SRPGでは、ユニットの強さや役割を数値で表現します。
この数値が「ステータス」です。

最初にステータスの種類と意味を正しく理解しておくことで、後の成長率や職業差の設計がスムーズになります。

SRPGで使われる基本ステータス

SRPGでよく使われる基本ステータスは、次の6つです。

これらは多くのSRPGで共通しており、設計の基準として使いやすい構成です。

ステータス	意味	ゲーム内での役割
HP	体力・耐久力	0になると戦闘不能になる。高いほど前線で戦いやすい
攻撃力	与えるダメージ量	敵に与えるダメージの基本値になる
防御力	受けるダメージを軽減	敵の攻撃をどれだけ耐えられるかに影響する
移動力	1ターンで移動できる距離	戦術の幅やポジション取りに直結する
命中率	攻撃が当たる確率	命中判定の基準値になる
回避率	攻撃を避ける確率	命中率と組み合わせて最終的な命中判定を行う

ステータス設計で意識したいポイント

ステータスは多ければ良いわけではありません。

初心者の場合は、まず「役割がはっきり分かる数値」だけに絞るのがおすすめです。

たとえば、

HPと防御力は「耐久力」
攻撃力は「火力」
移動力は「戦術の自由度」

というように、それぞれの数値が何を表現しているのかを意識して設計しましょう。

ステータスの実装例（Unity / C#）

以下は、基本ステータスを管理するためのシンプルな実装例です。

Unityでは、このようにクラスでまとめて管理すると扱いやすくなります。

[System.Serializable]
public class UnitStats
{
    [Header("基本ステータス")]
    public int maxHP = 100;
    public int currentHP = 100;
    public int attack = 20;
    public int defense = 10;
    public int moveRange = 3;
    public int hitRate = 90;      // 命中率（%）
    public int evasion = 10;      // 回避率（%）
    
    [Header("成長率")]
    public float hpGrowth = 0.1f;      // HP成長率
    public float attackGrowth = 0.08f;  // 攻撃成長率
    public float defenseGrowth = 0.06f; // 防御成長率
}

[System.Serializable]

public class UnitStats

{

[Header("基本ステータス")]

public int maxHP = 100;

public int currentHP = 100;

public int attack = 20;

public int defense = 10;

public int moveRange = 3;

public int hitRate = 90; // 命中率（%）

public int evasion = 10; // 回避率（%）

[Header("成長率")]

public float hpGrowth = 0.1f; // HP成長率

public float attackGrowth = 0.08f; // 攻撃成長率

public float defenseGrowth = 0.06f; // 防御成長率

}

このようにステータスをまとめておくことで、HP管理やダメージ計算をシンプルに実装できます。

また、成長率も同じクラスで管理しておくと、レベルアップ処理やバランス調整がしやすくなります。

成長率の設計方法

成長率は、ユニットがレベルアップしたときに「どれくらい強くなるか」を決める重要な要素です。

この設計次第で、ゲームの難易度や終盤のバランスが大きく変わります。

まずは、成長率の考え方を理解し、扱いやすい方式を選びましょう。

成長率設計の基本的な考え方

成長率を決めるときは、次の点を意識します。

レベルが上がるたびに、確実に強くなっているか
終盤でも戦闘が成立する数値になっているか
職業差や難易度調整の邪魔をしないか

初心者の場合は、予測しやすい設計を選ぶことが重要です。

固定成長とは何か

固定成長は、レベルアップのたびに「一定の割合」でステータスが上昇する方式です。

毎回ほぼ同じ結果になるため、数値の管理がしやすいのが特徴です。

固定成長の実装例

以下は、成長率を使ってステータスを上昇させるシンプルな実装例です。

public class Unit : MonoBehaviour
{
    public UnitStats stats;
    public int level = 1;
    
    public void LevelUp()
    {
        level++;
        
        // 固定成長
        stats.maxHP += Mathf.RoundToInt(stats.maxHP * stats.hpGrowth);
        stats.attack += Mathf.RoundToInt(stats.attack * stats.attackGrowth);
        stats.defense += Mathf.RoundToInt(stats.defense * stats.defenseGrowth);
        
        // HPを回復
        stats.currentHP = stats.maxHP;
    }
}

public class Unit : MonoBehaviour

{

public UnitStats stats;

public int level = 1;

public void LevelUp()

{

level++;

// 固定成長

stats.maxHP += Mathf.RoundToInt(stats.maxHP * stats.hpGrowth);

stats.attack += Mathf.RoundToInt(stats.attack * stats.attackGrowth);

stats.defense += Mathf.RoundToInt(stats.defense * stats.defenseGrowth);

// HPを回復

stats.currentHP = stats.maxHP;

}

この方式では、レベルアップ後の数値を事前に予測できます。

バランス調整がしやすく、初心者に最もおすすめの成長方式です。

ランダム成長とは何か

ランダム成長は、成長率にランダム要素を加える方式です。

同じユニットでも、育成結果に差が出るのが特徴です。

ランダム成長の実装例

以下は、成長率にランダム幅を持たせた実装例です。

public void LevelUpRandom()
{
    level++;
    
    // ランダム成長（成長率の±50%）
    int hpGrowth = Mathf.RoundToInt(stats.maxHP * stats.hpGrowth * Random.Range(0.5f, 1.5f));
    int attackGrowth = Mathf.RoundToInt(stats.attack * stats.attackGrowth * Random.Range(0.5f, 1.5f));
    int defenseGrowth = Mathf.RoundToInt(stats.defense * stats.defenseGrowth * Random.Range(0.5f, 1.5f));
    
    stats.maxHP += hpGrowth;
    stats.attack += attackGrowth;
    stats.defense += defenseGrowth;
    
    stats.currentHP = stats.maxHP;
}

public void LevelUpRandom()

{

level++;

// ランダム成長（成長率の±50%）

int hpGrowth = Mathf.RoundToInt(stats.maxHP * stats.hpGrowth * Random.Range(0.5f, 1.5f));

int attackGrowth = Mathf.RoundToInt(stats.attack * stats.attackGrowth * Random.Range(0.5f, 1.5f));

int defenseGrowth = Mathf.RoundToInt(stats.defense * stats.defenseGrowth * Random.Range(0.5f, 1.5f));

stats.maxHP += hpGrowth;

stats.attack += attackGrowth;

stats.defense += defenseGrowth;

stats.currentHP = stats.maxHP;

}

ランダム成長は、育成の楽しさややり込み要素が増える一方で、数値がブレやすく、バランス調整が難しくなります。

固定成長とランダム成長の使い分け

どちらの成長方式にもメリット・デメリットがあります。

固定成長：予測しやすく、バランス調整が簡単。初心者向け
ランダム成長：育成の幅が広がるが、調整が難しい

まずは固定成長で全体のバランスを整え、慣れてきたらランダム要素を加える、という進め方がおすすめです。

【ゲームの作り方講座プレゼント中！】

職業差のバランス調整

SRPGでは、職業ごとのステータス差が「戦略性」を生み出します。

どの職業をどこに配置するか、誰で敵を倒すかといった判断は、職業差があるからこそ成立します。

ここでは、初心者でも破綻しにくい職業差の作り方を解説します。

職業差を作るときの考え方

職業差を設計する際は、数値そのものよりも「役割」を意識することが重要です。

前線で敵を受け止める役割
後方から火力を出す役割
素早く動いて戦況を動かす役割

まずは役割を決め、その役割に合うステータスを高く設定します。

職業別ステータスの例

以下は、代表的な職業ごとのステータス傾向をまとめた例です。

数値ではなく「高・中・低」で整理すると、全体のバランスを把握しやすくなります。

職業	HP	攻撃	防御	移動	役割
戦士	高	高	中	中	前線で戦う主力
魔法使い	低	高	低	低	後方から高火力を出す
盗賊	低	中	低	高	機動力で戦況を動かす
騎士	中	中	高	中	防御役として味方を守る

この段階では、細かい数値にこだわる必要はありません。

まずは「どの職業が何を得意とするか」を明確にすることが大切です。

職業データの管理方法

Unityでは、ScriptableObjectを使って職業データを管理すると便利です。

コードを触らずに数値を調整できるため、バランス調整の作業が楽になります。

職業データの実装例

以下は、職業ごとのステータスや成長率をまとめた実装例です。

[CreateAssetMenu(fileName = "NewJob", menuName = "Game/Job Data")]
public class JobData : ScriptableObject
{
    public string jobName;
    
    [Header("基本ステータス")]
    public int baseHP = 100;
    public int baseAttack = 20;
    public int baseDefense = 10;
    public int baseMoveRange = 3;
    
    [Header("成長率")]
    public float hpGrowth = 0.1f;
    public float attackGrowth = 0.08f;
    public float defenseGrowth = 0.06f;
    
    [Header("ステータス補正")]
    public float hpMultiplier = 1.0f;
    public float attackMultiplier = 1.0f;
    public float defenseMultiplier = 1.0f;
}

public class Unit : MonoBehaviour
{
    public JobData job;
    public UnitStats stats;
    
    public void InitializeWithJob(JobData jobData)
    {
        job = jobData;
        
        stats.maxHP = Mathf.RoundToInt(jobData.baseHP * jobData.hpMultiplier);
        stats.attack = Mathf.RoundToInt(jobData.baseAttack * jobData.attackMultiplier);
        stats.defense = Mathf.RoundToInt(jobData.baseDefense * jobData.defenseMultiplier);
        stats.moveRange = jobData.baseMoveRange;
        
        stats.currentHP = stats.maxHP;
    }
}

[CreateAssetMenu(fileName = "NewJob", menuName = "Game/Job Data")]

public class JobData : ScriptableObject

{

public string jobName;

[Header("基本ステータス")]

public int baseHP = 100;

public int baseAttack = 20;

public int baseDefense = 10;

public int baseMoveRange = 3;

[Header("成長率")]

public float hpGrowth = 0.1f;

public float attackGrowth = 0.08f;

public float defenseGrowth = 0.06f;

[Header("ステータス補正")]

public float hpMultiplier = 1.0f;

public float attackMultiplier = 1.0f;

public float defenseMultiplier = 1.0f;

}

public class Unit : MonoBehaviour

{

public JobData job;

public UnitStats stats;

public void InitializeWithJob(JobData jobData)

{

job = jobData;

stats.maxHP = Mathf.RoundToInt(jobData.baseHP * jobData.hpMultiplier);

stats.attack = Mathf.RoundToInt(jobData.baseAttack * jobData.attackMultiplier);

stats.defense = Mathf.RoundToInt(jobData.baseDefense * jobData.defenseMultiplier);

stats.moveRange = jobData.baseMoveRange;

stats.currentHP = stats.maxHP;

}

このように職業データを分離して管理すると、職業差の調整やテストプレイ時の微調整がしやすくなります。

また、数値変更だけでバランスを調整できるため、デザイナーとプログラマーの分業もしやすくなります。

難易度に応じた調整方法

SRPGでは、難易度設定によって遊びやすさが大きく変わります。

同じマップ・同じ敵配置でも、ステータス調整次第で体験は別物になります。

ここでは、実装しやすく破綻しにくい難易度調整の考え方を紹介します。

難易度調整の基本方針

難易度を変える際は、プレイヤー側ではなく「敵側」を調整するのが基本です。

プレイヤーの成長感を損なわない
ルールや操作感を変えずに難易度を調整できる
実装と調整がシンプル

そのため、多くのSRPGでは敵ステータスに倍率補正をかける方法が使われます。

難易度別ステータス調整の実装例

以下は、難易度に応じて敵ユニットのステータスを補正するシンプルな例です。

public enum Difficulty
{
    Easy,    // 簡単
    Normal,  // 普通
    Hard     // 難しい
}

public class DifficultyManager : MonoBehaviour
{
    public Difficulty currentDifficulty = Difficulty.Normal;
    
    public UnitStats AdjustStatsForDifficulty(UnitStats baseStats, bool isEnemy)
    {
        if (!isEnemy) return baseStats; // プレイヤー側は調整しない
        
        UnitStats adjustedStats = baseStats;
        float multiplier = GetDifficultyMultiplier();
        
        adjustedStats.maxHP = Mathf.RoundToInt(baseStats.maxHP * multiplier);
        adjustedStats.attack = Mathf.RoundToInt(baseStats.attack * multiplier);
        adjustedStats.defense = Mathf.RoundToInt(baseStats.defense * multiplier);
        
        return adjustedStats;
    }
    
    float GetDifficultyMultiplier()
    {
        switch (currentDifficulty)
        {
            case Difficulty.Easy:
                return 0.8f;  // 20%弱く
            case Difficulty.Normal:
                return 1.0f;  // 標準
            case Difficulty.Hard:
                return 1.2f;  // 20%強く
            default:
                return 1.0f;
        }
    }
}

public enum Difficulty

{

Easy, // 簡単

Normal, // 普通

Hard // 難しい

}

public class DifficultyManager : MonoBehaviour

{

public Difficulty currentDifficulty = Difficulty.Normal;

public UnitStats AdjustStatsForDifficulty(UnitStats baseStats, bool isEnemy)

{

if (!isEnemy) return baseStats; // プレイヤー側は調整しない

UnitStats adjustedStats = baseStats;

float multiplier = GetDifficultyMultiplier();

adjustedStats.maxHP = Mathf.RoundToInt(baseStats.maxHP * multiplier);

adjustedStats.attack = Mathf.RoundToInt(baseStats.attack * multiplier);

adjustedStats.defense = Mathf.RoundToInt(baseStats.defense * multiplier);

return adjustedStats;

}

float GetDifficultyMultiplier()

{

switch (currentDifficulty)

{

case Difficulty.Easy:

return 0.8f; // 20%弱く

case Difficulty.Normal:

return 1.0f; // 標準

case Difficulty.Hard:

return 1.2f; // 20%強く

default:

return 1.0f;

}

このように倍率で管理すれば、難易度ごとの差を一元管理できます。

テストプレイ時の微調整も、数値変更だけで対応できます。

難易度調整の目安

最初は、以下のようなシンプルな倍率設定から始めると安全です。

✅ 難易度調整の目安

簡単：敵のステータス × 0.8（余裕を持って進める）
普通：敵のステータス × 1.0（想定バランス）
難しい：敵のステータス × 1.2（戦略性重視）

慣れてきたら、攻撃力だけを強化する、HPのみを増やすなど、難易度ごとに個性を持たせる調整も検討できます。

表計算ソフトを使った試算方法

表計算ソフトで試算してから、実装すると効率的です。

試算方法を紹介します。

Excelでの試算例

✅ Excelの列構成

A列：レベル（1, 2, 3…）
B列：HP（計算式：前のレベル × 1.1）
C列：攻撃（計算式：前のレベル × 1.08）
D列：防御（計算式：前のレベル × 1.06）
E列：ダメージ（攻撃 – 防御）

表計算で確認してから、実装すると失敗を防げます。

数値を変えて、結果を確認しましょう。

バランス確認のポイント

ダメージ計算：攻撃力 – 防御力が適切か（3〜5回で倒せるか）
HPの成長：レベルが上がっても、ダメージが有効か
職業差：各職業に役割があるか

これらのポイントを確認してから、実装しましょう。

ゲーム開発講師

表計算での試算は、時間を大幅に節約できます。数値を変えて、結果を確認してから実装しましょう。

実装例：完全なステータスシステム

実際に使える、完全なステータスシステムの実装例を紹介します。

using UnityEngine;

public class CompleteStatsSystem : MonoBehaviour
{
    public Unit unit;
    public JobData job;
    public DifficultyManager difficultyManager;
    
    public void InitializeUnit(JobData jobData, bool isEnemy)
    {
        // 1. 職業データで初期化
        unit.InitializeWithJob(jobData);
        
        // 2. 難易度調整（敵のみ）
        if (isEnemy)
        {
            unit.stats = difficultyManager.AdjustStatsForDifficulty(unit.stats, true);
        }
        
        // 3. レベル補正
        ApplyLevelBonus(unit.level);
    }
    
    public void LevelUp()
    {
        unit.level++;
        
        // 成長率に基づいてステータス上昇
        int hpGrowth = Mathf.RoundToInt(unit.stats.maxHP * job.hpGrowth);
        int attackGrowth = Mathf.RoundToInt(unit.stats.attack * job.attackGrowth);
        int defenseGrowth = Mathf.RoundToInt(unit.stats.defense * job.defenseGrowth);
        
        unit.stats.maxHP += hpGrowth;
        unit.stats.attack += attackGrowth;
        unit.stats.defense += defenseGrowth;
        
        // HPを回復
        unit.stats.currentHP = unit.stats.maxHP;
    }
    
    void ApplyLevelBonus(int level)
    {
        // レベルに応じた補正（省略）
    }
}