ラングリッサー風SRPG制作法｜傭兵システムと分岐ルートの再現テクニック

ラングリッサー風SRPGは、本体＋傭兵ユニットが特徴です。

部隊単位の戦闘とルート分岐が、戦略性を高めます。

この記事では、実装方法を詳しく解説します。

✨ この記事でわかること

傭兵システムの実装
部隊単位の戦闘処理
ルート分岐システムの実装
マルチエンディングの実装
実装例とコード

ゲーム開発講師

傭兵システムは、本体ユニットと傭兵ユニットをグループ化することが大切です。部隊として管理しましょう。

＼ゲーム制作をゼロから学びたいあなたへ／
Unity入門の森を見る初心者歓迎！動画×プロジェクト一式で本格ゲーム制作を学べる

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

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

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

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

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

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

傭兵システムの実装
1. 部隊システムの実装
2. 傭兵の雇用システム
部隊単位の戦闘処理
1. 部隊戦闘の実装
ルート分岐システムの実装
1. 分岐ポイントの実装
マルチエンディングの実装
1. エンディング判定の実装
実装例：完全なラングリッサー風システム
よくある質問（FAQ）
まとめ

傭兵システムの実装

傭兵システムは、本体ユニットに傭兵を配属します。

実装方法を紹介します。

部隊システムの実装

using UnityEngine;
using System.Collections.Generic;

[System.Serializable]
public class UnitSquad
{
    public Unit leader; // 本体ユニット
    public List<Unit> mercenaries = new List<Unit>(); // 傭兵ユニット
    public int maxMercenaries = 4; // 最大傭兵数
    
    public void AddMercenary(Unit mercenary)
    {
        if (mercenaries.Count >= maxMercenaries)
        {
            Debug.Log("傭兵の上限に達しています");
            return;
        }
        
        mercenaries.Add(mercenary);
        mercenary.squad = this;
    }
    
    public void RemoveMercenary(Unit mercenary)
    {
        mercenaries.Remove(mercenary);
        mercenary.squad = null;
    }
    
    public List<Unit> GetAllUnits()
    {
        List<Unit> allUnits = new List<Unit>();
        allUnits.Add(leader);
        allUnits.AddRange(mercenaries);
        return allUnits;
    }
    
    public bool IsLeaderAlive()
    {
        return leader != null && leader.stats.currentHP > 0;
    }
}

public class MercenarySystem : MonoBehaviour
{
    public List<UnitSquad> allSquads = new List<UnitSquad>();
    
    public void CreateSquad(Unit leader)
    {
        UnitSquad squad = new UnitSquad();
        squad.leader = leader;
        leader.squad = squad;
        allSquads.Add(squad);
    }
    
    public void AssignMercenary(UnitSquad squad, Unit mercenary)
    {
        squad.AddMercenary(mercenary);
    }
}

using UnityEngine;

using System.Collections.Generic;

[System.Serializable]

public class UnitSquad

{

public Unit leader; // 本体ユニット

public List<Unit> mercenaries = new List<Unit>(); // 傭兵ユニット

public int maxMercenaries = 4; // 最大傭兵数

public void AddMercenary(Unit mercenary)

{

if (mercenaries.Count >= maxMercenaries)

{

Debug.Log("傭兵の上限に達しています");

return;

}

mercenaries.Add(mercenary);

mercenary.squad = this;

}

public void RemoveMercenary(Unit mercenary)

{

mercenaries.Remove(mercenary);

mercenary.squad = null;

}

public List<Unit> GetAllUnits()

{

List<Unit> allUnits = new List<Unit>();

allUnits.Add(leader);

allUnits.AddRange(mercenaries);

return allUnits;

}

public bool IsLeaderAlive()

{

return leader != null && leader.stats.currentHP > 0;

}

public class MercenarySystem : MonoBehaviour

{

public List<UnitSquad> allSquads = new List<UnitSquad>();

public void CreateSquad(Unit leader)

{

UnitSquad squad = new UnitSquad();

squad.leader = leader;

leader.squad = squad;

allSquads.Add(squad);

}

public void AssignMercenary(UnitSquad squad, Unit mercenary)

{

squad.AddMercenary(mercenary);

}

このコードで、傭兵システムが実装できます。

本体ユニットと傭兵ユニットを部隊として管理します。

傭兵の雇用システム

public class MercenaryRecruitment : MonoBehaviour
{
    public ResourceManager resourceManager;
    public List<MercenaryData> availableMercenaries = new List<MercenaryData>();
    
    public bool HireMercenary(UnitSquad squad, MercenaryData mercenaryData)
    {
        // コストチェック
        if (!resourceManager.CanAfford(mercenaryData.hireCost))
        {
            Debug.Log("雇用コストが足りません");
            return false;
        }
        
        // 傭兵数の上限チェック
        if (squad.mercenaries.Count >= squad.maxMercenaries)
        {
            Debug.Log("傭兵の上限に達しています");
            return false;
        }
        
        // 傭兵を生成
        Unit mercenary = CreateMercenary(mercenaryData);
        
        // 部隊に配属
        squad.AddMercenary(mercenary);
        
        // コストを支払う
        resourceManager.SpendResources(mercenaryData.hireCost);
        
        return true;
    }
    
    Unit CreateMercenary(MercenaryData data)
    {
        GameObject mercenaryObj = Instantiate(data.unitPrefab);
        Unit mercenary = mercenaryObj.GetComponent<Unit>();
        
        // ステータスを設定
        mercenary.stats = data.baseStats;
        mercenary.unitName = data.mercenaryName;
        
        return mercenary;
    }
}

[System.Serializable]
public class MercenaryData
{
    public string mercenaryName;
    public GameObject unitPrefab;
    public UnitStats baseStats;
    public ResourceCost hireCost;
}

public class MercenaryRecruitment : MonoBehaviour

{

public ResourceManager resourceManager;

public List<MercenaryData> availableMercenaries = new List<MercenaryData>();

public bool HireMercenary(UnitSquad squad, MercenaryData mercenaryData)

{

// コストチェック

if (!resourceManager.CanAfford(mercenaryData.hireCost))

{

Debug.Log("雇用コストが足りません");

return false;

}

// 傭兵数の上限チェック

if (squad.mercenaries.Count >= squad.maxMercenaries)

{

Debug.Log("傭兵の上限に達しています");

return false;

}

// 傭兵を生成

Unit mercenary = CreateMercenary(mercenaryData);

// 部隊に配属

squad.AddMercenary(mercenary);

// コストを支払う

resourceManager.SpendResources(mercenaryData.hireCost);

return true;

}

Unit CreateMercenary(MercenaryData data)

{

GameObject mercenaryObj = Instantiate(data.unitPrefab);

Unit mercenary = mercenaryObj.GetComponent<Unit>();

// ステータスを設定

mercenary.stats = data.baseStats;

mercenary.unitName = data.mercenaryName;

return mercenary;

}

[System.Serializable]

public class MercenaryData

{

public string mercenaryName;

public GameObject unitPrefab;

public UnitStats baseStats;

public ResourceCost hireCost;

}

傭兵の雇用システムを実装します。

コストを支払って、傭兵を雇用できます。

＼ゲーム制作をゼロから学びたいあなたへ／
Unity入門の森を見る初心者歓迎！動画×プロジェクト一式で本格ゲーム制作を学べる

部隊単位の戦闘処理

部隊単位の戦闘は、本体と傭兵が一緒に行動します。

実装方法を紹介します。

部隊戦闘の実装

public class SquadCombat : MonoBehaviour
{
    public void ExecuteSquadAttack(UnitSquad attackerSquad, UnitSquad defenderSquad)
    {
        // 本体同士の戦闘
        ExecuteLeaderCombat(attackerSquad.leader, defenderSquad.leader);
        
        // 傭兵同士の戦闘
        ExecuteMercenaryCombat(attackerSquad.mercenaries, defenderSquad.mercenaries);
    }
    
    void ExecuteLeaderCombat(Unit attacker, Unit defender)
    {
        int damage = BattleCalculator.CalculateDamage(attacker, defender);
        defender.TakeDamage(damage);
        
        // 反撃
        if (defender.stats.currentHP > 0 && defender.CanCounterAttack())
        {
            int counterDamage = BattleCalculator.CalculateDamage(defender, attacker);
            attacker.TakeDamage(counterDamage);
        }
    }
    
    void ExecuteMercenaryCombat(List<Unit> attackers, List<Unit> defenders)
    {
        // 傭兵同士の戦闘
        int attackerCount = attackers.Count;
        int defenderCount = defenders.Count;
        
        for (int i = 0; i < Mathf.Min(attackerCount, defenderCount); i++)
        {
            if (attackers[i].stats.currentHP > 0 && defenders[i].stats.currentHP > 0)
            {
                ExecuteUnitCombat(attackers[i], defenders[i]);
            }
        }
    }
    
    void ExecuteUnitCombat(Unit attacker, Unit defender)
    {
        int damage = BattleCalculator.CalculateDamage(attacker, defender);
        defender.TakeDamage(damage);
    }
    
    public bool IsSquadDefeated(UnitSquad squad)
    {
        // 本体が倒れたら部隊全滅
        if (!squad.IsLeaderAlive())
        {
            return true;
        }
        
        return false;
    }
}

public class SquadCombat : MonoBehaviour

{

public void ExecuteSquadAttack(UnitSquad attackerSquad, UnitSquad defenderSquad)

{

// 本体同士の戦闘

ExecuteLeaderCombat(attackerSquad.leader, defenderSquad.leader);

// 傭兵同士の戦闘

ExecuteMercenaryCombat(attackerSquad.mercenaries, defenderSquad.mercenaries);

}

void ExecuteLeaderCombat(Unit attacker, Unit defender)

{

int damage = BattleCalculator.CalculateDamage(attacker, defender);

defender.TakeDamage(damage);

// 反撃

if (defender.stats.currentHP > 0 && defender.CanCounterAttack())

{

int counterDamage = BattleCalculator.CalculateDamage(defender, attacker);

attacker.TakeDamage(counterDamage);

}

void ExecuteMercenaryCombat(List<Unit> attackers, List<Unit> defenders)

{

// 傭兵同士の戦闘

int attackerCount = attackers.Count;

int defenderCount = defenders.Count;

for (int i = 0; i < Mathf.Min(attackerCount, defenderCount); i++)

{

if (attackers[i].stats.currentHP > 0 && defenders[i].stats.currentHP > 0)

{

ExecuteUnitCombat(attackers[i], defenders[i]);

}

void ExecuteUnitCombat(Unit attacker, Unit defender)

{

int damage = BattleCalculator.CalculateDamage(attacker, defender);

defender.TakeDamage(damage);

}

public bool IsSquadDefeated(UnitSquad squad)

{

// 本体が倒れたら部隊全滅

if (!squad.IsLeaderAlive())

{

return true;

}

return false;

}

このコードで、部隊単位の戦闘が実装できます。

本体同士と傭兵同士が戦闘し、本体が倒れると部隊全滅です。

ゲーム開発講師

部隊戦闘は、本体の生存が重要です。本体が倒れると、傭兵も全滅します。本体を守ることが戦略の核心です。

＼ゲーム制作をゼロから学びたいあなたへ／
Unity入門の森を見る初心者歓迎！動画×プロジェクト一式で本格ゲーム制作を学べる

ルート分岐システムの実装

ルート分岐は、選択によって物語が分かれます。

実装方法を紹介します。

分岐ポイントの実装

using UnityEngine;
using System.Collections.Generic;

[System.Serializable]
public class RouteBranch
{
    public string branchID;
    public string branchName;
    public string description;
    public List<RouteCondition> conditions = new List<RouteCondition>();
    public string nextScenarioID;
}

[System.Serializable]
public class RouteCondition
{
    public string flagName;
    public int requiredValue;
    public ComparisonType comparison;
}

public enum ComparisonType
{
    Equal,
    GreaterThan,
    LessThan
}

public class RouteBranchSystem : MonoBehaviour
{
    public Dictionary<string, int> routeFlags = new Dictionary<string, int>();
    public List<RouteBranch> availableBranches = new List<RouteBranch>();
    
    public List<RouteBranch> GetAvailableBranches()
    {
        List<RouteBranch> available = new List<RouteBranch>();
        
        foreach (var branch in availableBranches)
        {
            if (CheckBranchConditions(branch))
            {
                available.Add(branch);
            }
        }
        
        return available;
    }
    
    bool CheckBranchConditions(RouteBranch branch)
    {
        foreach (var condition in branch.conditions)
        {
            if (!routeFlags.ContainsKey(condition.flagName))
            {
                return false;
            }
            
            int flagValue = routeFlags[condition.flagName];
            
            switch (condition.comparison)
            {
                case ComparisonType.Equal:
                    if (flagValue != condition.requiredValue) return false;
                    break;
                    
                case ComparisonType.GreaterThan:
                    if (flagValue <= condition.requiredValue) return false;
                    break;
                    
                case ComparisonType.LessThan:
                    if (flagValue >= condition.requiredValue) return false;
                    break;
            }
        }
        
        return true;
    }
    
    public void SelectBranch(RouteBranch branch)
    {
        // フラグを更新
        UpdateRouteFlags(branch);
        
        // 次のシナリオへ
        LoadScenario(branch.nextScenarioID);
    }
    
    void UpdateRouteFlags(RouteBranch branch)
    {
        // 分岐に応じてフラグを更新
        // 実装は省略
    }
    
    void LoadScenario(string scenarioID)
    {
        // シナリオを読み込む
        // 実装は省略
    }
}

100

using UnityEngine;

using System.Collections.Generic;

[System.Serializable]

public class RouteBranch

{

public string branchID;

public string branchName;

public string description;

public List<RouteCondition> conditions = new List<RouteCondition>();

public string nextScenarioID;

}

[System.Serializable]

public class RouteCondition

{

public string flagName;

public int requiredValue;

public ComparisonType comparison;

}

public enum ComparisonType

{

Equal,

GreaterThan,

LessThan

}

public class RouteBranchSystem : MonoBehaviour

{

public Dictionary<string, int> routeFlags = new Dictionary<string, int>();

public List<RouteBranch> availableBranches = new List<RouteBranch>();

public List<RouteBranch> GetAvailableBranches()

{

List<RouteBranch> available = new List<RouteBranch>();

foreach (var branch in availableBranches)

{

if (CheckBranchConditions(branch))

{

available.Add(branch);

}

return available;

}

bool CheckBranchConditions(RouteBranch branch)

{

foreach (var condition in branch.conditions)

{

if (!routeFlags.ContainsKey(condition.flagName))

{

return false;

}

int flagValue = routeFlags[condition.flagName];

switch (condition.comparison)

{

case ComparisonType.Equal:

if (flagValue != condition.requiredValue) return false;

break;

case ComparisonType.GreaterThan:

if (flagValue <= condition.requiredValue) return false;

break;

case ComparisonType.LessThan:

if (flagValue >= condition.requiredValue) return false;

break;

}

return true;

}

public void SelectBranch(RouteBranch branch)

{

// フラグを更新

UpdateRouteFlags(branch);

// 次のシナリオへ

LoadScenario(branch.nextScenarioID);

}

void UpdateRouteFlags(RouteBranch branch)

{

// 分岐に応じてフラグを更新

// 実装は省略

}

void LoadScenario(string scenarioID)

{

// シナリオを読み込む

// 実装は省略

}

このコードで、ルート分岐システムが実装できます。

条件を満たす分岐が表示され、選択によって物語が分かれます。

＼ゲーム制作をゼロから学びたいあなたへ／
Unity入門の森を見る初心者歓迎！動画×プロジェクト一式で本格ゲーム制作を学べる

マルチエンディングの実装

マルチエンディングは、ルート分岐の結果によって決まります。

実装方法を紹介します。

エンディング判定の実装

using UnityEngine;
using System.Collections.Generic;

public enum EndingType
{
    Good,       // 良いエンディング
    Normal,     // 普通のエンディング
    Bad,        // 悪いエンディング
    True        // 真エンディング
}

[System.Serializable]
public class EndingCondition
{
    public EndingType endingType;
    public List<RouteCondition> conditions = new List<RouteCondition>();
    public string endingSceneID;
}

public class EndingSystem : MonoBehaviour
{
    public RouteBranchSystem routeSystem;
    public List<EndingCondition> endingConditions = new List<EndingCondition>();
    
    public EndingType DetermineEnding()
    {
        foreach (var ending in endingConditions)
        {
            if (CheckEndingConditions(ending))
            {
                return ending.endingType;
            }
        }
        
        return EndingType.Normal;
    }
    
    bool CheckEndingConditions(EndingCondition ending)
    {
        foreach (var condition in ending.conditions)
        {
            if (!routeSystem.routeFlags.ContainsKey(condition.flagName))
            {
                return false;
            }
            
            int flagValue = routeSystem.routeFlags[condition.flagName];
            
            switch (condition.comparison)
            {
                case ComparisonType.Equal:
                    if (flagValue != condition.requiredValue) return false;
                    break;
                    
                case ComparisonType.GreaterThan:
                    if (flagValue <= condition.requiredValue) return false;
                    break;
                    
                case ComparisonType.LessThan:
                    if (flagValue >= condition.requiredValue) return false;
                    break;
            }
        }
        
        return true;
    }
    
    public void ShowEnding(EndingType endingType)
    {
        EndingCondition ending = endingConditions.Find(e => e.endingType == endingType);
        
        if (ending != null)
        {
            LoadEndingScene(ending.endingSceneID);
        }
    }
    
    void LoadEndingScene(string sceneID)
    {
        // エンディングシーンを読み込む
        // 実装は省略
    }
}

using UnityEngine;

using System.Collections.Generic;

public enum EndingType

{

Good, // 良いエンディング

Normal, // 普通のエンディング

Bad, // 悪いエンディング

True // 真エンディング

}

[System.Serializable]

public class EndingCondition

{

public EndingType endingType;

public List<RouteCondition> conditions = new List<RouteCondition>();

public string endingSceneID;

}

public class EndingSystem : MonoBehaviour

{

public RouteBranchSystem routeSystem;

public List<EndingCondition> endingConditions = new List<EndingCondition>();

public EndingType DetermineEnding()

{

foreach (var ending in endingConditions)

{

if (CheckEndingConditions(ending))

{

return ending.endingType;

}

return EndingType.Normal;

}

bool CheckEndingConditions(EndingCondition ending)

{

foreach (var condition in ending.conditions)

{

if (!routeSystem.routeFlags.ContainsKey(condition.flagName))

{

return false;

}

int flagValue = routeSystem.routeFlags[condition.flagName];

switch (condition.comparison)

{

case ComparisonType.Equal:

if (flagValue != condition.requiredValue) return false;

break;

case ComparisonType.GreaterThan:

if (flagValue <= condition.requiredValue) return false;

break;

case ComparisonType.LessThan:

if (flagValue >= condition.requiredValue) return false;

break;

}

return true;

}

public void ShowEnding(EndingType endingType)

{

EndingCondition ending = endingConditions.Find(e => e.endingType == endingType);

if (ending != null)

{

LoadEndingScene(ending.endingSceneID);

}

void LoadEndingScene(string sceneID)

{

// エンディングシーンを読み込む

// 実装は省略

}

このコードで、マルチエンディングが実装できます。

ルート分岐の結果に応じて、エンディングが決まります。

＼ゲーム制作をゼロから学びたいあなたへ／
Unity入門の森を見る初心者歓迎！動画×プロジェクト一式で本格ゲーム制作を学べる

実装例：完全なラングリッサー風システム

実際に使える、完全なラングリッサー風システムの実装例を紹介します。

using UnityEngine;

public class CompleteLangrisserStyleSystem : MonoBehaviour
{
    [Header("システム")]
    public MercenarySystem mercenarySystem;
    public SquadCombat squadCombat;
    public RouteBranchSystem routeSystem;
    public EndingSystem endingSystem;
    
    public void ProcessBattle(UnitSquad playerSquad, UnitSquad enemySquad)
    {
        // 部隊戦闘を実行
        squadCombat.ExecuteSquadAttack(playerSquad, enemySquad);
        
        // 部隊全滅チェック
        if (squadCombat.IsSquadDefeated(enemySquad))
        {
            OnBattleVictory();
        }
    }
    
    void OnBattleVictory()
    {
        // 勝利時の処理
        // ルート分岐のフラグを更新
        routeSystem.routeFlags["battlesWon"]++;
        
        // エンディング判定
        EndingType ending = endingSystem.DetermineEnding();
        endingSystem.ShowEnding(ending);
    }
}

using UnityEngine;

public class CompleteLangrisserStyleSystem : MonoBehaviour

{

[Header("システム")]

public MercenarySystem mercenarySystem;

public SquadCombat squadCombat;

public RouteBranchSystem routeSystem;

public EndingSystem endingSystem;

public void ProcessBattle(UnitSquad playerSquad, UnitSquad enemySquad)

{

// 部隊戦闘を実行

squadCombat.ExecuteSquadAttack(playerSquad, enemySquad);

// 部隊全滅チェック

if (squadCombat.IsSquadDefeated(enemySquad))

{

OnBattleVictory();

}

void OnBattleVictory()

{

// 勝利時の処理

// ルート分岐のフラグを更新

routeSystem.routeFlags["battlesWon"]++;

// エンディング判定

EndingType ending = endingSystem.DetermineEnding();

endingSystem.ShowEnding(ending);

}

このコードで、完全なラングリッサー風システムが実装できます。

傭兵システム、部隊戦闘、ルート分岐、マルチエンディングを統合しています。

＼ゲーム制作をゼロから学びたいあなたへ／
Unity入門の森を見る初心者歓迎！動画×プロジェクト一式で本格ゲーム制作を学べる

よくある質問（FAQ）

Q: 傭兵の最大数はどう設定すればいいですか？
A: 4〜6人が標準です。多すぎると管理が複雑になり、少なすぎると戦略性が失われます。

Q: 部隊戦闘のバランスはどう調整すればいいですか？
A: 本体の生存が重要です。本体が倒れると部隊全滅になるため、本体の防御力を高めるか、本体を後方に配置する戦略を取らせます。

Q: ルート分岐の数はいくつ用意すればいいですか？
A: 最初は3〜5つの分岐がおすすめです。多すぎると、管理が複雑になります。重要な選択肢だけを分岐させましょう。

Q: マルチエンディングの種類はいくつ用意すればいいですか？
A: 3〜5種類が標準です。良いエンディング、普通のエンディング、悪いエンディング、真エンディングなど、バリエーションを持たせましょう。

Q: 傭兵の雇用コストはどう設定すればいいですか？
A: 傭兵の強さに応じて設定しましょう。弱い傭兵は低コスト、強い傭兵は高コストにします。バランス調整で変更することも可能です。

＼ゲーム制作をゼロから学びたいあなたへ／
Unity入門の森を見る初心者歓迎！動画×プロジェクト一式で本格ゲーム制作を学べる

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

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

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

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

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

まとめ

ラングリッサー風SRPGは、傭兵システムとルート分岐が核心です。

これらの要素を実装すれば、戦略性の高いバトルが実現できます。

✅ 今日から始める3ステップ

ステップ1：傭兵システムを実装する（所要3時間）
ステップ2：部隊戦闘システムを実装する（所要3時間）
ステップ3：ルート分岐システムを実装する（所要2時間）

本格的にUnityを学びたい方は、Unity入門の森で実践的なスキルを身につけましょう。

あなたのペースで、少しずつ進めていけば大丈夫です。

＼ゲーム制作をゼロから学びたいあなたへ／
Unity入門の森を見る初心者歓迎！動画×プロジェクト一式で本格ゲーム制作を学べる