大局観で戦うシミュレーションゲーム制作｜初心者でも戦略ゲームを組める方法

戦略シミュレーションゲームは、複雑に見えます。

しかし、要素を分解すれば、実装できます。

この記事では、設計から実装まで詳しく解説します。

✨ この記事でわかること

資源管理システムの設計方法
ユニット生産システムの実装
テックツリーの構築方法
マップ制圧システムの実装
実装例とコード

ゲーム開発講師

戦略シミュレーションゲームは、システム設計が重要です。まずは基本要素から実装しましょう。

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

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

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

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

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

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

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

資源管理システムの設計
ユニット生産システムの実装
テックツリーの構築方法
マップ制圧システムの実装
実装例：完全な戦略シミュレーションシステム
よくある質問（FAQ）
まとめ

資源管理システムの設計

資源管理は、戦略シミュレーションゲームにおいて最も重要な基盤システムです。

なぜなら、ユニット生産・技術研究・領地拡張といった、あらゆる行動が「資源をどう使うか」という判断に集約されるからです。

逆に言えば、資源管理の設計が甘いと、どれだけ戦闘や演出を作り込んでも、戦略性のない作業ゲームになってしまいます。

ここでは初心者でも理解しやすいように、「何を考えて設計すればいいのか」から順に解説します。

なぜ資源管理が「核心」なのか

戦略ゲームにおけるプレイヤーの判断は、常に次の問いに集約されます。

「限られた資源を、今どこに使うか？」

例えば、同じ100ゴールドでも、

今すぐユニットを増やして攻めるのか
研究に回して後半を有利にするのか
防衛用に温存するのか

この選択が、ゲーム全体の流れ＝大局を左右します。

そのため、資源管理は単なる数値処理ではなく、戦略を生み出す装置として設計する必要があります。

資源管理システム設計の基本方針

初心者が最初に意識すべきポイントは、以下の3点です。

設計で押さえるポイント

資源の種類は少なくする（最初は3〜4種類で十分）
消費と獲得の窓口を一元管理する
上限値を設けて無限増加を防ぐ

これらを満たすために、「ResourceManager」という専用クラスを用意し、すべての資源処理をここに集約します。

基本資源システムの実装例

以下は、戦略シミュレーションゲーム向けのシンプルな資源管理クラスです。

初心者でも読みやすいよう、コメントを多めに入れています。

using UnityEngine;

/// <summary>
/// ゲーム内の資源を一括で管理するクラス
/// ユニット生産・研究・建設などは必ずこのクラスを経由する
/// </summary>
[System.Serializable]
public class ResourceManager
{
    // ===== 現在の資源量 =====
    [Header("基本資源")]
    public int gold = 1000;
    public int wood = 100;
    public int stone = 50;
    public int food = 200;

    // ===== 各資源の最大値 =====
    // 上限を設けることで、資源のため込みを防ぐ
    [Header("資源の上限")]
    public int maxGold = 10000;
    public int maxWood = 1000;
    public int maxStone = 500;
    public int maxFood = 2000;

    /// <summary>
    /// 指定したコストを支払えるかどうかを判定
    /// </summary>
    public bool CanAfford(ResourceCost cost)
    {
        return gold >= cost.gold &&
               wood >= cost.wood &&
               stone >= cost.stone &&
               food >= cost.food;
    }

    /// <summary>
    /// 資源を消費する処理
    /// </summary>
    public void SpendResources(ResourceCost cost)
    {
        // 支払えない場合は処理しない
        if (!CanAfford(cost))
        {
            Debug.LogError("資源が足りません");
            return;
        }

        // Clampで0〜最大値の範囲に制限
        gold  = Mathf.Clamp(gold  - cost.gold,  0, maxGold);
        wood  = Mathf.Clamp(wood  - cost.wood,  0, maxWood);
        stone = Mathf.Clamp(stone - cost.stone, 0, maxStone);
        food  = Mathf.Clamp(food  - cost.food,  0, maxFood);
    }

    /// <summary>
    /// 資源を加算する処理
    /// </summary>
    public void AddResources(ResourceCost gain)
    {
        gold  = Mathf.Clamp(gold  + gain.gold,  0, maxGold);
        wood  = Mathf.Clamp(wood  + gain.wood,  0, maxWood);
        stone = Mathf.Clamp(stone + gain.stone, 0, maxStone);
        food  = Mathf.Clamp(food  + gain.food,  0, maxFood);
    }
}

/// <summary>
/// 資源コストをまとめて扱うためのクラス
/// </summary>
[System.Serializable]
public class ResourceCost
{
    public int gold = 0;
    public int wood = 0;
    public int stone = 0;
    public int food = 0;
}

using UnityEngine;

/// <summary>

/// ゲーム内の資源を一括で管理するクラス

/// ユニット生産・研究・建設などは必ずこのクラスを経由する

/// </summary>

[System.Serializable]

public class ResourceManager

{

// ===== 現在の資源量 =====

[Header("基本資源")]

public int gold = 1000;

public int wood = 100;

public int stone = 50;

public int food = 200;

// ===== 各資源の最大値 =====

// 上限を設けることで、資源のため込みを防ぐ

[Header("資源の上限")]

public int maxGold = 10000;

public int maxWood = 1000;

public int maxStone = 500;

public int maxFood = 2000;

/// <summary>

/// 指定したコストを支払えるかどうかを判定

/// </summary>

public bool CanAfford(ResourceCost cost)

{

return gold >= cost.gold &&

wood >= cost.wood &&

stone >= cost.stone &&

food >= cost.food;

}

/// <summary>

/// 資源を消費する処理

/// </summary>

public void SpendResources(ResourceCost cost)

{

// 支払えない場合は処理しない

if (!CanAfford(cost))

{

Debug.LogError("資源が足りません");

return;

}

// Clampで0〜最大値の範囲に制限

gold = Mathf.Clamp(gold - cost.gold, 0, maxGold);

wood = Mathf.Clamp(wood - cost.wood, 0, maxWood);

stone = Mathf.Clamp(stone - cost.stone, 0, maxStone);

food = Mathf.Clamp(food - cost.food, 0, maxFood);

}

/// <summary>

/// 資源を加算する処理

/// </summary>

public void AddResources(ResourceCost gain)

{

gold = Mathf.Clamp(gold + gain.gold, 0, maxGold);

wood = Mathf.Clamp(wood + gain.wood, 0, maxWood);

stone = Mathf.Clamp(stone + gain.stone, 0, maxStone);

food = Mathf.Clamp(food + gain.food, 0, maxFood);

}

/// <summary>

/// 資源コストをまとめて扱うためのクラス

/// </summary>

[System.Serializable]

public class ResourceCost

{

public int gold = 0;

public int wood = 0;

public int stone = 0;

public int food = 0;

}

この構成にすることで、「資源が足りるか？」→「支払う」→「増える」という流れを、どのシステムからも共通で扱えるようになります。

資源はどこから生まれるのか

次に重要なのが、「資源をどう獲得させるか」です。

獲得手段は多すぎると管理が難しくなるため、最初は役割が明確な方法に絞りましょう。

代表的な資源獲得方法

建物からの生産：農場（食料）、鉱山（石）、製材所（木材）など
領地からの収入：占領したエリアから毎ターン自動で獲得
交易：他勢力と資源を交換する仕組み
戦利品：戦闘に勝利した際のボーナス

重要なのは、どの行動が、どの資源につながるのかを明確にすることです。

これにより、プレイヤーは自然と「次に取るべき戦略」を考えるようになります。

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

ユニット生産システムの実装

ユニット生産は、戦略シミュレーションゲームにおいて行動力そのものを生み出す仕組みです。

どれだけ資源や技術があっても、ユニットを生産できなければ、マップを制圧することはできません。

また、ユニット生産は「何を作るか」だけでなく、「いつ作るか」「どれだけ待つか」という判断も含めて、戦略性を生み出します。

ここでは初心者がつまずきやすいポイントを避けつつ、戦略ゲームらしさを保てるユニット生産システムを解説します。

なぜユニットは即時生成しないのか

初心者が最初に作りがちなのが、「ボタンを押したら即ユニットが出てくる」仕組みです。

しかし、それでは戦略ゲームらしい駆け引きが生まれません。

生産に時間をかけることで、

どのユニットを優先するか
今は生産を止めて資源を温存するか
攻撃に出るタイミングを待つか

といった中長期的な判断が必要になります。

そのため、今回は「生産キュー」と「生産時間」を持つ方式を採用します。

ユニット生産システムの設計方針

シンプルかつ拡張しやすい設計にするため、以下の点を意識します。

設計のポイント

生産に必要な情報を1つのデータにまとめる
生産はキューで管理する
資源管理はResourceManagerに任せる

これにより、「生産のロジック」と「資源の管理」を分離でき、後からユニットの種類が増えても対応しやすくなります。

生産システムの実装例

以下は、ターン制・リアルタイムどちらにも応用できる基本的なユニット生産システムです。

処理の流れが追いやすいよう、コメントを付けています。

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

/// <summary>
/// ユニットの生産を管理するクラス
/// 生産キューを使って、順番にユニットを生成する
/// </summary>
public class UnitProduction : MonoBehaviour
{
    // 資源管理クラスへの参照
    public ResourceManager resourceManager;

    // ユニットが出現する位置
    public Transform spawnPoint;

    /// <summary>
    /// 生産可能なユニットの定義
    /// </summary>
    [System.Serializable]
    public class UnitRecipe
    {
        public string unitName;          // ユニット名
        public GameObject unitPrefab;    // 生成するプレハブ
        public ResourceCost cost;        // 必要な資源
        public int productionTime;       // 生産にかかるターン数
    }

    // 生産可能なユニット一覧
    public List<UnitRecipe> availableUnits = new List<UnitRecipe>();

    // 生産待ちユニットを管理するキュー
    private Queue<UnitRecipe> productionQueue = new Queue<UnitRecipe>();

    // 現在の残り生産時間
    private int currentProductionTime = 0;

    /// <summary>
    /// ユニット生産を開始する
    /// </summary>
    public void StartProduction(UnitRecipe recipe)
    {
        // 資源が足りるかチェック
        if (!resourceManager.CanAfford(recipe.cost))
        {
            Debug.Log("資源が足りません");
            return;
        }

        // 資源を消費
        resourceManager.SpendResources(recipe.cost);

        // 生産キューに追加
        productionQueue.Enqueue(recipe);

        // キューが空だった場合のみ、生産処理を開始
        if (productionQueue.Count == 1)
        {
            StartCoroutine(ProduceUnit());
        }
    }

    /// <summary>
    /// 生産キューを順番に処理するコルーチン
    /// </summary>
    IEnumerator ProduceUnit()
    {
        while (productionQueue.Count > 0)
        {
            // 現在生産中のユニット
            UnitRecipe recipe = productionQueue.Peek();
            currentProductionTime = recipe.productionTime;

            // 生産時間が経過するまで待つ
            while (currentProductionTime > 0)
            {
                yield return new WaitForSeconds(1f);
                currentProductionTime--;
            }

            // 生産完了：ユニットを生成
            Instantiate(recipe.unitPrefab, spawnPoint.position, Quaternion.identity);

            // キューから取り除く
            productionQueue.Dequeue();
        }
    }
}

using UnityEngine;

using System.Collections;

using System.Collections.Generic;

/// <summary>

/// ユニットの生産を管理するクラス

/// 生産キューを使って、順番にユニットを生成する

/// </summary>

public class UnitProduction : MonoBehaviour

{

// 資源管理クラスへの参照

public ResourceManager resourceManager;

// ユニットが出現する位置

public Transform spawnPoint;

/// <summary>

/// 生産可能なユニットの定義

/// </summary>

[System.Serializable]

public class UnitRecipe

{

public string unitName; // ユニット名

public GameObject unitPrefab; // 生成するプレハブ

public ResourceCost cost; // 必要な資源

public int productionTime; // 生産にかかるターン数

}

// 生産可能なユニット一覧

public List<UnitRecipe> availableUnits = new List<UnitRecipe>();

// 生産待ちユニットを管理するキュー

private Queue<UnitRecipe> productionQueue = new Queue<UnitRecipe>();

// 現在の残り生産時間

private int currentProductionTime = 0;

/// <summary>

/// ユニット生産を開始する

/// </summary>

public void StartProduction(UnitRecipe recipe)

{

// 資源が足りるかチェック

if (!resourceManager.CanAfford(recipe.cost))

{

Debug.Log("資源が足りません");

return;

}

// 資源を消費

resourceManager.SpendResources(recipe.cost);

// 生産キューに追加

productionQueue.Enqueue(recipe);

// キューが空だった場合のみ、生産処理を開始

if (productionQueue.Count == 1)

{

StartCoroutine(ProduceUnit());

}

/// <summary>

/// 生産キューを順番に処理するコルーチン

/// </summary>

IEnumerator ProduceUnit()

{

while (productionQueue.Count > 0)

{

// 現在生産中のユニット

UnitRecipe recipe = productionQueue.Peek();

currentProductionTime = recipe.productionTime;

// 生産時間が経過するまで待つ

while (currentProductionTime > 0)

{

yield return new WaitForSeconds(1f);

currentProductionTime--;

}

// 生産完了：ユニットを生成

Instantiate(recipe.unitPrefab, spawnPoint.position, Quaternion.identity);

// キューから取り除く

productionQueue.Dequeue();

}

この仕組みによって、「資源を払う → 待つ → 戦力が増える」という戦略ゲームらしい流れを自然に作れます。

生産可能なユニット設計の考え方

ユニットの種類は、単に性能差をつけるだけでなく、どのタイミングで強いかを意識して設計すると、戦略性が高まります。

ユニット設計の一例

歩兵：コストが低く、序盤の主力になりやすい
弓兵：中コストで、支援や防衛向き
騎兵：機動力が高く、中盤以降に活躍
攻城兵器：高コスト・長時間生産だが、拠点攻略に必須

このように、生産コストと生産時間を調整することで、プレイヤーは自然と「今はどのユニットを作るべきか」を考えるようになります。

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

テックツリーの構築方法

テックツリーは、戦略シミュレーションゲームにおける中長期戦略を形にする仕組みです。

どの技術を、どの順番で研究するかによって、ゲーム後半の展開は大きく変わります。

ユニット生産が「今どう動くか」を決める仕組みだとすれば、テックツリーは将来どんな戦い方をするかを決める仕組みだと言えます。

ここでは初心者が混乱しやすい「設計の考え方」と「最小構成の実装」を中心に解説します。

なぜテックツリーが戦略性を生むのか

テックツリーの本質は、「すべての技術を同時に取れない」点にあります。

例えば、

軍事技術を優先して早期決戦を狙う
経済技術を伸ばして後半有利を目指す
防衛技術を固めて持久戦に入る

といったように、研究の選択そのものがプレイヤーの戦略になります。

この取り返しのつかない選択が、大局観を生み出します。

テックツリー設計の基本方針

初心者が最初から複雑なツリーを作る必要はありません。

まずは、以下のポイントを押さえたシンプルな設計がおすすめです。

設計のポイント

技術は「ノード」として独立させる
前提条件は文字列やIDで管理する
研究中は1つだけに制限する

この構成にすることで、後から分岐を増やしたり、研究効果を追加したりするのが簡単になります。

テックノードの基本構造

まずは、1つ1つの技術を表す「テックノード」を定義します。

このクラスは、技術の情報をまとめたデータ入れ物として使います。

using UnityEngine;
using System.Collections.Generic;

/// <summary>
/// 1つの技術を表すクラス
/// </summary>
[System.Serializable]
public class TechNode
{
    // 技術名（前提判定にも使用）
    public string techName;

    // 技術の説明文
    public string description;

    // 研究に必要な資源
    public ResourceCost researchCost;

    // 研究にかかるターン数
    public int researchTime;

    // 研究済みかどうか
    public bool isResearched = false;

    // 前提となる技術名の一覧
    public List<string> prerequisites = new List<string>();

    [Header("研究完了時の効果")]
    public List<UnitUnlock> unitUnlocks = new List<UnitUnlock>();
    public List<BuildingUnlock> buildingUnlocks = new List<BuildingUnlock>();
    public StatBonus statBonus;
}

/// ユニット解放用データ
[System.Serializable]
public class UnitUnlock
{
    public string unitName;
    public GameObject unitPrefab;
}

/// 建物解放用データ
[System.Serializable]
public class BuildingUnlock
{
    public string buildingName;
    public GameObject buildingPrefab;
}

/// ステータス補正用データ
[System.Serializable]
public class StatBonus
{
    public float attackBonus = 0f;
    public float defenseBonus = 0f;
    public float productionBonus = 0f;
}

using UnityEngine;

using System.Collections.Generic;

/// <summary>

/// 1つの技術を表すクラス

/// </summary>

[System.Serializable]

public class TechNode

{

// 技術名（前提判定にも使用）

public string techName;

// 技術の説明文

public string description;

// 研究に必要な資源

public ResourceCost researchCost;

// 研究にかかるターン数

public int researchTime;

// 研究済みかどうか

public bool isResearched = false;

// 前提となる技術名の一覧

public List<string> prerequisites = new List<string>();

[Header("研究完了時の効果")]

public List<UnitUnlock> unitUnlocks = new List<UnitUnlock>();

public List<BuildingUnlock> buildingUnlocks = new List<BuildingUnlock>();

public StatBonus statBonus;

}

/// ユニット解放用データ

[System.Serializable]

public class UnitUnlock

{

public string unitName;

public GameObject unitPrefab;

}

/// 建物解放用データ

[System.Serializable]

public class BuildingUnlock

{

public string buildingName;

public GameObject buildingPrefab;

}

/// ステータス補正用データ

[System.Serializable]

public class StatBonus

{

public float attackBonus = 0f;

public float defenseBonus = 0f;

public float productionBonus = 0f;

}

ここでは、「技術が何を解放・強化するのか」をデータとして持たせています。
実際の処理は、別クラスでまとめて行います。

テックツリー全体を管理するクラス

次に、テックノードをまとめて管理し、研究の進行を制御するクラスを作ります。

public class TechTree : MonoBehaviour
{
    // 資源管理への参照
    public ResourceManager resourceManager;

    // 登録されているすべての技術
    public List<TechNode> techNodes = new List<TechNode>();

    // 現在研究中の技術
    private TechNode currentResearch = null;

    // 残り研究ターン
    private int remainingTurns = 0;

    /// <summary>
    /// 指定した技術が研究可能かを判定
    /// </summary>
    public bool CanResearch(TechNode tech)
    {
        // 前提技術を満たしているか確認
        foreach (var prereq in tech.prerequisites)
        {
            TechNode prereqTech = techNodes.Find(t => t.techName == prereq);
            if (prereqTech == null || !prereqTech.isResearched)
            {
                return false;
            }
        }

        // 資源が足りているか
        if (!resourceManager.CanAfford(tech.researchCost))
        {
            return false;
        }

        // すでに研究済みでないか
        if (tech.isResearched)
        {
            return false;
        }

        return true;
    }

    /// <summary>
    /// 研究を開始する
    /// </summary>
    public void StartResearch(TechNode tech)
    {
        if (!CanResearch(tech))
        {
            Debug.Log("研究できません");
            return;
        }

        // 資源を消費
        resourceManager.SpendResources(tech.researchCost);

        currentResearch = tech;
        remainingTurns = tech.researchTime;
    }

    /// <summary>
    /// ターン終了時に呼び出す
    /// </summary>
    public void ProcessTurn()
    {
        if (currentResearch == null) return;

        remainingTurns--;

        if (remainingTurns <= 0)
        {
            CompleteResearch(currentResearch);
            currentResearch = null;
        }
    }

    /// <summary>
    /// 研究完了時の処理
    /// </summary>
    void CompleteResearch(TechNode tech)
    {
        tech.isResearched = true;
        ApplyTechEffects(tech);
        Debug.Log(tech.techName + " の研究が完了しました");
    }

    /// <summary>
    /// 技術効果を適用する（詳細実装は省略）
    /// </summary>
    void ApplyTechEffects(TechNode tech)
    {
        // ユニットの解放
        // 建物の解放
        // ステータス補正の反映
    }
}

public class TechTree : MonoBehaviour

{

// 資源管理への参照

public ResourceManager resourceManager;

// 登録されているすべての技術

public List<TechNode> techNodes = new List<TechNode>();

// 現在研究中の技術

private TechNode currentResearch = null;

// 残り研究ターン

private int remainingTurns = 0;

/// <summary>

/// 指定した技術が研究可能かを判定

/// </summary>

public bool CanResearch(TechNode tech)

{

// 前提技術を満たしているか確認

foreach (var prereq in tech.prerequisites)

{

TechNode prereqTech = techNodes.Find(t => t.techName == prereq);

if (prereqTech == null || !prereqTech.isResearched)

{

return false;

}

// 資源が足りているか

if (!resourceManager.CanAfford(tech.researchCost))

{

return false;

}

// すでに研究済みでないか

if (tech.isResearched)

{

return false;

}

return true;

}

/// <summary>

/// 研究を開始する

/// </summary>

public void StartResearch(TechNode tech)

{

if (!CanResearch(tech))

{

Debug.Log("研究できません");

return;

}

// 資源を消費

resourceManager.SpendResources(tech.researchCost);

currentResearch = tech;

remainingTurns = tech.researchTime;

}

/// <summary>

/// ターン終了時に呼び出す

/// </summary>

public void ProcessTurn()

{

if (currentResearch == null) return;

remainingTurns--;

if (remainingTurns <= 0)

{

CompleteResearch(currentResearch);

currentResearch = null;

}

/// <summary>

/// 研究完了時の処理

/// </summary>

void CompleteResearch(TechNode tech)

{

tech.isResearched = true;

ApplyTechEffects(tech);

Debug.Log(tech.techName + " の研究が完了しました");

}

/// <summary>

/// 技術効果を適用する（詳細実装は省略）

/// </summary>

void ApplyTechEffects(TechNode tech)

{

// ユニットの解放

// 建物の解放

// ステータス補正の反映

}

この構成により、「研究できるか判定 → 資源消費 → ターン経過 → 効果発動」という一連の流れをシンプルに管理できます。

ゲーム開発講師

テックツリーは、最初は一本道で問題ありません。
慣れてきたら分岐や特殊条件を追加すると、戦略性が一気に高まります。

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

マップ制圧システムの実装

マップ制圧は、戦略シミュレーションゲームにおける最終的な目標です。

これまでに解説した「資源管理」「ユニット生産」「テックツリー」は、すべてこの目的に収束します。

つまり、マップ制圧は単なるシステムの1つではなく、プレイヤーの行動すべてを意味づけるゴールです。

ここでは、領地を管理し、制圧状況をゲーム進行に反映させるための基本的な実装方法を紹介します。

なぜ「領地制圧」が勝利条件になるのか

戦略ゲームでは、「敵を倒す」こと自体が目的ではありません。

重要なのは、どれだけの影響力をマップ上に持っているかです。

領地を制圧することで、

資源収入が増える
防衛ラインが広がる
次の侵攻拠点を確保できる

といった、戦略的な優位が連鎖的に発生します。

この「有利の積み重ね」を数値として管理するのが、領地システムです。

領地システム設計の考え方

領地システムを設計する際は、以下の役割を明確に分離します。

設計のポイント

領地は「誰のものか」を常に保持する
領地ごとに効果（収入・防御）を持たせる
管理処理はマネージャークラスに集約する

この分離を行うことで、後から「特殊領地」や「中立地帯」などを追加しやすくなります。

領地クラスの実装

まずは、マップ上の1マス（または1エリア）を表す領地クラスを作成します。

このクラスは、領地そのものの状態だけを管理します。

using UnityEngine;

public class Territory : MonoBehaviour
{
    // 所有者ID（-1は中立）
    public int ownerID = -1;

    // 領地識別用ID
    public int territoryID;

    // マップ上の位置
    public Vector2Int gridPosition;

    [Header("領地の効果")]
    // 毎ターン得られる資源
    public ResourceCost incomePerTurn;

    // 防衛時の補正値
    public int defenseBonus = 0;

    /// <summary>
    /// 領地を占領する
    /// </summary>
    public void Capture(int newOwnerID)
    {
        ownerID = newOwnerID;
        Debug.Log($"領地{territoryID}が勢力{newOwnerID}に占領されました");
    }

    /// <summary>
    /// 指定プレイヤーの領地かどうか
    /// </summary>
    public bool IsOwnedBy(int playerID)
    {
        return ownerID == playerID;
    }
}

using UnityEngine;

public class Territory : MonoBehaviour

{

// 所有者ID（-1は中立）

public int ownerID = -1;

// 領地識別用ID

public int territoryID;

// マップ上の位置

public Vector2Int gridPosition;

[Header("領地の効果")]

// 毎ターン得られる資源

public ResourceCost incomePerTurn;

// 防衛時の補正値

public int defenseBonus = 0;

/// <summary>

/// 領地を占領する

/// </summary>

public void Capture(int newOwnerID)

{

ownerID = newOwnerID;

Debug.Log($"領地{territoryID}が勢力{newOwnerID}に占領されました");

}

/// <summary>

/// 指定プレイヤーの領地かどうか

/// </summary>

public bool IsOwnedBy(int playerID)

{

return ownerID == playerID;

}

このクラスでは、戦闘処理や勝敗判定は行いません。

あくまで「領地の状態」を保持することに専念しています。

領地全体を管理するマネージャー

次に、すべての領地をまとめて管理するクラスを作成します。

ターン処理や収入計算は、ここで一括して行います。

using UnityEngine;
using System.Collections.Generic;

public class TerritoryManager : MonoBehaviour
{
    // マップ上の全領地
    public List<Territory> allTerritories = new List<Territory>();

    // 資源管理への参照
    public ResourceManager resourceManager;

    /// <summary>
    /// ターン開始時の処理
    /// </summary>
    public void ProcessTurn(int playerID)
    {
        // 所有領地からの収入を加算
        foreach (var territory in allTerritories)
        {
            if (territory.IsOwnedBy(playerID))
            {
                resourceManager.AddResources(territory.incomePerTurn);
            }
        }
    }

    /// <summary>
    /// 領地を占領する
    /// </summary>
    public void CaptureTerritory(Territory territory, int playerID)
    {
        territory.Capture(playerID);
    }

    /// <summary>
    /// 所有している領地数を取得
    /// </summary>
    public int GetOwnedTerritoryCount(int playerID)
    {
        int count = 0;

        foreach (var territory in allTerritories)
        {
            if (territory.IsOwnedBy(playerID))
            {
                count++;
            }
        }

        return count;
    }
}

using UnityEngine;

using System.Collections.Generic;

public class TerritoryManager : MonoBehaviour

{

// マップ上の全領地

public List<Territory> allTerritories = new List<Territory>();

// 資源管理への参照

public ResourceManager resourceManager;

/// <summary>

/// ターン開始時の処理

/// </summary>

public void ProcessTurn(int playerID)

{

// 所有領地からの収入を加算

foreach (var territory in allTerritories)

{

if (territory.IsOwnedBy(playerID))

{

resourceManager.AddResources(territory.incomePerTurn);

}

/// <summary>

/// 領地を占領する

/// </summary>

public void CaptureTerritory(Territory territory, int playerID)

{

territory.Capture(playerID);

}

/// <summary>

/// 所有している領地数を取得

/// </summary>

public int GetOwnedTerritoryCount(int playerID)

{

int count = 0;

foreach (var territory in allTerritories)

{

if (territory.IsOwnedBy(playerID))

{

count++;

}

return count;

}

この構成により、「領地の状態」と「ゲーム進行処理」を明確に分離できます。

勝利条件の実装

最後に、ゲームが終了する条件を定義します。

勝利条件は、プレイヤーの行動指針を明確にする重要な要素です。

public class VictoryCondition : MonoBehaviour
{
    public TerritoryManager territoryManager;

    // 勝利に必要な領地数
    public int targetTerritoryCount = 10;

    // 勝利に必要な資源量
    public int targetResourceAmount = 5000;

    /// <summary>
    /// 勝利判定
    /// </summary>
    public bool CheckVictory(int playerID)
    {
        // 条件1：領地数による勝利
        int ownedTerritories = territoryManager.GetOwnedTerritoryCount(playerID);
        if (ownedTerritories >= targetTerritoryCount)
        {
            return true;
        }

        // 条件2：資源量による勝利
        // （ResourceManagerと連携して判定する）
        // 実装は省略

        return false;
    }
}

public class VictoryCondition : MonoBehaviour

{

public TerritoryManager territoryManager;

// 勝利に必要な領地数

public int targetTerritoryCount = 10;

// 勝利に必要な資源量

public int targetResourceAmount = 5000;

/// <summary>

/// 勝利判定

/// </summary>

public bool CheckVictory(int playerID)

{

// 条件1：領地数による勝利

int ownedTerritories = territoryManager.GetOwnedTerritoryCount(playerID);

if (ownedTerritories >= targetTerritoryCount)

{

return true;

}

// 条件2：資源量による勝利

// （ResourceManagerと連携して判定する）

// 実装は省略

return false;

}

領地数・資源量・特定拠点の占領など、勝利条件を組み合わせることで、多様なゲーム展開を作れます。

ゲーム開発講師

勝利条件を先に決めると、逆算してシステム設計ができるようになります。

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

実装例：完全な戦略シミュレーションシステム

実際に使える、完全な戦略シミュレーションシステムの実装例を紹介します。

using UnityEngine;
using System.Collections.Generic;

public class CompleteStrategySystem : MonoBehaviour
{
    [Header("管理システム")]
    public ResourceManager resourceManager;
    public UnitProduction unitProduction;
    public TechTree techTree;
    public TerritoryManager territoryManager;
    public VictoryCondition victoryCondition;
    
    [Header("プレイヤー情報")]
    public int currentPlayerID = 0;
    
    void Start()
    {
        InitializeGame();
    }
    
    void InitializeGame()
    {
        // 初期資源を設定
        resourceManager.gold = 1000;
        resourceManager.wood = 100;
        resourceManager.stone = 50;
    }
    
    public void ProcessTurn()
    {
        // 1. 領地からの収入
        territoryManager.ProcessTurn(currentPlayerID);
        
        // 2. 研究の進行
        techTree.ProcessTurn();
        
        // 3. ユニット生産の進行
        // unitProduction.ProcessTurn();
        
        // 4. 勝利条件チェック
        if (victoryCondition.CheckVictory(currentPlayerID))
        {
            OnVictory();
        }
    }
    
    void OnVictory()
    {
        Debug.Log("勝利！");
    }
}

using UnityEngine;

using System.Collections.Generic;

public class CompleteStrategySystem : MonoBehaviour

{

[Header("管理システム")]

public ResourceManager resourceManager;

public UnitProduction unitProduction;

public TechTree techTree;

public TerritoryManager territoryManager;

public VictoryCondition victoryCondition;

[Header("プレイヤー情報")]

public int currentPlayerID = 0;

void Start()

{

InitializeGame();

}

void InitializeGame()

{

// 初期資源を設定

resourceManager.gold = 1000;

resourceManager.wood = 100;

resourceManager.stone = 50;

}

public void ProcessTurn()

{

// 1. 領地からの収入

territoryManager.ProcessTurn(currentPlayerID);

// 2. 研究の進行

techTree.ProcessTurn();

// 3. ユニット生産の進行

// unitProduction.ProcessTurn();

// 4. 勝利条件チェック

if (victoryCondition.CheckVictory(currentPlayerID))

{

OnVictory();

}

void OnVictory()

{

Debug.Log("勝利！");

}

このコードで、完全な戦略シミュレーションシステムが実装できます。

資源・生産・研究・領地を統合しています。

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

よくある質問（FAQ）

Q: 資源の種類はいくつ用意すればいいですか？
A: 最初は3〜4種類がおすすめです。金・木材・石・食料など。種類が多すぎると、管理が複雑になります。

Q: テックツリーの規模はどう決めればいいですか？
A: 最初は10〜15ノードから始めましょう。前提条件を2〜3段階に分けると、戦略性が生まれます。

Q: ユニット生産のバランスはどう調整すればいいですか？
A: テストプレイで調整しましょう。コストと生産時間のバランスが重要です。表計算ソフトで試算してから実装すると効率的です。

Q: 領地システムが複雑になりました。どう簡素化すればいいですか？
A: 領地の効果を統一しましょう。すべての領地が同じ収入を生むようにすれば、管理が簡単になります。

Q: 勝利条件を複数設定したいです。どう実装すればいいですか？
A: 勝利条件を配列で管理しましょう。いずれかの条件を満たせば勝利とします。また、条件の組み合わせ（AND/OR）も設定できます。

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

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

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

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

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

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

まとめ

戦略シミュレーションゲームは、システム設計が重要です。

まずは基本要素から実装して、徐々に機能を追加しましょう。

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

ステップ1：資源管理システムを実装する（所要2時間）
ステップ2：ユニット生産システムを実装する（所要3時間）
ステップ3：テックツリーを実装する（所要3時間）

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

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

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